npm config set @100monkeys-ai:registry https://npm.pkg.github.com
npm install @100monkeys-ai/aegis-sdk

import { AegisClient } from '@100monkeys-ai/aegis-sdk';

const client = new AegisClient(
  'https://your-aegis-node',
  process.env.AEGIS_API_KEY,   // Optional; Keycloak Bearer JWT
);

new AegisClient(baseUrl: string, apiKey?: string)

const { execution_id } = await client.startExecution(
  'agent-uuid',
  'Write a primality check in TypeScript',
);
console.log(execution_id); // "exec-uuid"

interface StartExecutionResponse {
  execution_id: string;
}

const stream = await client.streamExecution(execution_id);

const { pending_requests, count } = await client.listPendingApprovals();
console.log(`${count} pending approvals`);

await client.approveRequest('approval-uuid', {
  feedback: 'Looks good',
  approved_by: 'jeshua',
});

await client.rejectRequest('approval-uuid', {
  reason: 'Scope too broad',
  rejected_by: 'jeshua',
});

interface SealAttestationResponse {
  security_token: string;
}

interface SealToolsResponse {
  protocol: string;
  attestation_endpoint: string;
  invoke_endpoint: string;
  security_context?: string;
  tools: any[];
}

import { SEALClient, Ed25519Key, createSealEnvelope, verifySealEnvelope } from '@100monkeys-ai/aegis-sdk';

import { SEALClient } from '@100monkeys-ai/aegis-sdk';

const seal = new SEALClient(
  'https://your-aegis-node',
  'my-workload',
  'default',
);

try {
  const result = await seal.attest();
  console.log(result.security_token);

  const output = await seal.callTool('read_file', { path: '/workspace/main.ts' });
  console.log(output);
} finally {
  seal.dispose();  // zeroes the in-memory private key
}

new SEALClient(gatewayUrl: string, workloadId: string, securityScope: string)

type AttestationResult = {
  security_token: string;
  expires_at: string;
  session_id?: string;
}

import { Ed25519Key } from '@100monkeys-ai/aegis-sdk';

const key = Ed25519Key.generate();
const signatureB64 = key.signBase64(new TextEncoder().encode('my message'));
const pubKeyB64 = key.getPublicKeyBase64();
key.erase();  // zeroes the private key when done

import { createSealEnvelope, Ed25519Key } from '@100monkeys-ai/aegis-sdk';

const key = Ed25519Key.generate();
const envelope = createSealEnvelope(
  '<security-token>',
  { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'read_file', arguments: {} } },
  key,
);
// Pass envelope to AegisClient.invokeSeal() or the raw SEAL endpoint

import { verifySealEnvelope } from '@100monkeys-ai/aegis-sdk';

const payload = verifySealEnvelope(
  envelopeObject,
  registeredPublicKeyBytes,
  30,   // max age in seconds (default: 30)
);

import { createCanonicalMessage } from '@100monkeys-ai/aegis-sdk';

const msgBytes = createCanonicalMessage('<token>', mcpPayload, Math.floor(Date.now() / 1000));

interface McpPayload {
  jsonrpc: string;
  id: string | number;
  method: string;
  params?: Record<string, unknown>;
}

interface SealEnvelope {
  protocol: string;
  security_token: string;
  signature: string;
  payload: McpPayload;
  timestamp: string;
}

class SEALError extends Error {}

interface WorkflowExecutionLogs {
  execution_id: string;
  events: any[];
  count: number;
  limit: number;
  offset: number;
}

interface Tenant {
  slug: string;
  display_name: string;
  status: string;
  tier: string;
  keycloak_realm: string;
  openbao_namespace: string;
  quotas: TenantQuotas;
  created_at: string;
  updated_at: string;
  deleted_at?: string;
}

interface TenantQuotas {
  max_concurrent_executions: number;
  max_agents: number;
  max_storage_gb: number;
}

interface RateLimitOverride {
  id: string;
  resource_type: string;
  bucket: string;
  limit_value: number;
  tenant_id?: string;
  user_id?: string;
  burst_value?: number;
  created_at: string;
  updated_at: string;
}

interface UsageRecord {
  scope_type: string;
  scope_id: string;
  resource_type: string;
  bucket: string;
  window_start: string;
  counter: number;
}

import { AegisClient } from '@100monkeys-ai/aegis-sdk';

const client = new AegisClient('https://your-aegis-node', process.env.AEGIS_API_KEY);

const { execution_id } = await client.startExecution('agent-uuid', 'Analyze this codebase');
const stream = await client.streamExecution(execution_id);

const decoder = new TextDecoder();
const reader = stream.getReader();

while (true) {
  const { value, done } = await reader.read();
  if (done) break;

  const text = decoder.decode(value);
  for (const line of text.split('\n')) {
    if (!line.startsWith('data:')) continue;
    const event = JSON.parse(line.slice(5).trim());

    if (event.iteration_started) {
      console.log(`Iteration ${event.iteration_started.iteration_number}`);
    } else if (event.execution_completed) {
      console.log('Output:', event.execution_completed.final_output);
    } else if (event.execution_failed) {
      console.error('Failed:', event.execution_failed.reason);
    }
  }
}

import { AgentManifestBuilder, ImagePullPolicy } from '@100monkeys-ai/aegis-sdk';

import { AgentManifestBuilder, ImagePullPolicy } from '@100monkeys-ai/aegis-sdk';

const manifest = new AgentManifestBuilder('my-agent', 'typescript')
  .withDescription('Analyses TypeScript repos for security issues')
  .withInstruction('You are a security auditor. Analyse the code and report CVEs.')
  .withExecutionMode('iterative', 15)
  .withImagePullPolicy(ImagePullPolicy.IfNotPresent)
  .withNetworkAllow(['api.github.com', 'registry.npmjs.org'])
  .withTool('read_file')
  .withTool('run_command')
  .withEnv('LOG_LEVEL', 'debug')
  .build();

new AgentManifestBuilder(name: string, language?: string, version?: string)

enum ImagePullPolicy {
  Always = 'Always',
  IfNotPresent = 'IfNotPresent',
  Never = 'Never',
}

import axios from 'axios';
import { AegisClient } from '@100monkeys-ai/aegis-sdk';

const client = new AegisClient('https://your-aegis-node', process.env.AEGIS_API_KEY);

try {
  const { execution_id } = await client.startExecution('agent-uuid', 'Do something');
} catch (err) {
  if (axios.isAxiosError(err)) {
    console.error(err.response?.status, err.response?.data);
  } else {
    throw err;
  }
}