@agentfield/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,823 @@
+import express from 'express';
+import http from 'node:http';
+import { ZodSchema } from 'zod';
+
+interface AIRequestOptions {
+    system?: string;
+    schema?: ZodSchema<any>;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    provider?: AIConfig['provider'];
+}
+type AIStream = AsyncIterable<string>;
+interface AIEmbeddingOptions {
+    model?: string;
+    provider?: AIConfig['provider'];
+}
+declare class AIClient {
+    private readonly config;
+    private rateLimiter?;
+    constructor(config?: AIConfig);
+    generate<T = any>(prompt: string, options?: AIRequestOptions): Promise<T | string>;
+    stream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
+    embed(value: string, options?: AIEmbeddingOptions): Promise<number[]>;
+    embedMany(values: string[], options?: AIEmbeddingOptions): Promise<number[][]>;
+    private buildModel;
+    private buildEmbeddingModel;
+    private getRateLimiter;
+    private withRateLimitRetry;
+}
+
+interface MemoryRequestMetadata {
+    workflowId?: string;
+    sessionId?: string;
+    actorId?: string;
+    runId?: string;
+    executionId?: string;
+    parentExecutionId?: string;
+    callerDid?: string;
+    targetDid?: string;
+    agentNodeDid?: string;
+    agentNodeId?: string;
+}
+interface MemoryRequestOptions {
+    scope?: MemoryScope;
+    scopeId?: string;
+    metadata?: MemoryRequestMetadata;
+    headers?: Record<string, string | number | boolean | undefined>;
+}
+interface VectorSearchOptions extends MemoryRequestOptions {
+    topK?: number;
+    filters?: Record<string, any>;
+}
+interface VectorSearchResult {
+    key: string;
+    scope: string;
+    scopeId: string;
+    score: number;
+    metadata?: Record<string, any>;
+}
+declare class MemoryClient {
+    private readonly http;
+    private readonly defaultHeaders;
+    constructor(baseUrl: string, defaultHeaders?: Record<string, string | number | boolean | undefined>);
+    set(key: string, data: any, options?: MemoryRequestOptions): Promise<void>;
+    get<T = any>(key: string, options?: MemoryRequestOptions): Promise<T | undefined>;
+    delete(key: string, options?: MemoryRequestOptions): Promise<void>;
+    listKeys(scope: MemoryScope, options?: MemoryRequestOptions): Promise<string[]>;
+    exists(key: string, options?: MemoryRequestOptions): Promise<boolean>;
+    setVector(key: string, embedding: number[], metadata?: any, options?: MemoryRequestOptions): Promise<void>;
+    deleteVector(key: string, options?: MemoryRequestOptions): Promise<void>;
+    searchVector(queryEmbedding: number[], options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    private buildHeaders;
+    private scopeToHeader;
+    private resolveScopeId;
+    private sanitizeHeaders;
+}
+
+type MemoryEventHandler = (event: MemoryChangeEvent) => Promise<void> | void;
+declare class MemoryEventClient {
+    private readonly url;
+    private ws?;
+    private handlers;
+    private reconnectDelay;
+    private closed;
+    private readonly headers;
+    constructor(baseUrl: string, headers?: Record<string, string | number | boolean | undefined>);
+    start(): void;
+    onEvent(handler: MemoryEventHandler): void;
+    stop(): void;
+    private connect;
+    private scheduleReconnect;
+    private buildForwardHeaders;
+}
+
+interface MemoryChangeEvent {
+    key: string;
+    data: any;
+    scope: MemoryScope;
+    scopeId: string;
+    timestamp: string | Date;
+    agentId: string;
+}
+type MemoryWatchHandler = (event: MemoryChangeEvent) => Promise<void> | void;
+declare class MemoryInterface {
+    private readonly client;
+    private readonly eventClient?;
+    private readonly aiClient?;
+    private readonly defaultScope;
+    private readonly defaultScopeId?;
+    private readonly metadata?;
+    constructor(params: {
+        client: MemoryClient;
+        eventClient?: MemoryEventClient;
+        aiClient?: AIClient;
+        defaultScope?: MemoryScope;
+        defaultScopeId?: string;
+        metadata?: MemoryRequestMetadata;
+    });
+    set(key: string, data: any, scope?: MemoryScope, scopeId?: string | undefined): Promise<void>;
+    get<T = any>(key: string, scope?: MemoryScope, scopeId?: string | undefined): Promise<T | undefined>;
+    getWithFallback<T = any>(key: string): Promise<(Awaited<T> & ({} | null)) | undefined>;
+    setVector(key: string, embedding: number[], metadata?: any, scope?: MemoryScope, scopeId?: string | undefined): Promise<void>;
+    deleteVector(key: string, scope?: MemoryScope, scopeId?: string | undefined): Promise<void>;
+    searchVector(queryEmbedding: number[], options?: Omit<VectorSearchOptions, 'metadata'>): Promise<VectorSearchResult[]>;
+    delete(key: string, scope?: MemoryScope, scopeId?: string | undefined): Promise<void>;
+    exists(key: string, scope?: MemoryScope, scopeId?: string | undefined): Promise<boolean>;
+    listKeys(scope?: MemoryScope, scopeId?: string | undefined): Promise<string[]>;
+    embedText(text: string, options?: AIEmbeddingOptions): Promise<number[]>;
+    embedTexts(texts: string[], options?: AIEmbeddingOptions): Promise<number[][]>;
+    embedAndSet(key: string, text: string, metadata?: any, scope?: MemoryScope, scopeId?: string | undefined, embeddingOptions?: AIEmbeddingOptions): Promise<number[]>;
+    deleteVectors(keys: string[], scope?: MemoryScope, scopeId?: string | undefined): Promise<void>;
+    workflow(scopeId: string): MemoryInterface;
+    session(scopeId: string): MemoryInterface;
+    actor(scopeId: string): MemoryInterface;
+    get globalScope(): MemoryInterface;
+    onEvent(handler: MemoryWatchHandler): void;
+    private cloneWithScope;
+    private getScopeOrder;
+    private resolveScopeId;
+}
+
+interface ExecutionStatusUpdate {
+    status?: string;
+    result?: Record<string, any>;
+    error?: string;
+    durationMs?: number;
+    progress?: number;
+}
+declare class AgentFieldClient {
+    private readonly http;
+    private readonly config;
+    private readonly defaultHeaders;
+    constructor(config: AgentConfig);
+    register(payload: any): Promise<void>;
+    heartbeat(status?: 'starting' | 'ready' | 'degraded' | 'offline'): Promise<HealthStatus>;
+    execute<T = any>(target: string, input: any, metadata?: {
+        runId?: string;
+        workflowId?: string;
+        parentExecutionId?: string;
+        sessionId?: string;
+        actorId?: string;
+        callerDid?: string;
+        targetDid?: string;
+        agentNodeDid?: string;
+        agentNodeId?: string;
+    }): Promise<T>;
+    publishWorkflowEvent(event: {
+        executionId: string;
+        runId: string;
+        workflowId?: string;
+        reasonerId: string;
+        agentNodeId: string;
+        status: 'running' | 'succeeded' | 'failed';
+        parentExecutionId?: string;
+        parentWorkflowId?: string;
+        inputData?: Record<string, any>;
+        result?: any;
+        error?: string;
+        durationMs?: number;
+    }): Promise<void>;
+    updateExecutionStatus(executionId: string, update: ExecutionStatusUpdate): Promise<void>;
+    discoverCapabilities(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+    private mapDiscoveryResponse;
+    private mapCompactDiscovery;
+    private sanitizeHeaders;
+    private mergeHeaders;
+}
+
+interface WorkflowMetadata {
+    executionId: string;
+    runId?: string;
+    workflowId?: string;
+    agentNodeId?: string;
+    reasonerId?: string;
+}
+interface WorkflowProgressOptions {
+    status?: string;
+    result?: Record<string, any>;
+    error?: string;
+    durationMs?: number;
+}
+declare class WorkflowReporter {
+    private readonly client;
+    private readonly metadata;
+    constructor(client: AgentFieldClient, metadata: WorkflowMetadata);
+    progress(progress: number, options?: WorkflowProgressOptions): Promise<void>;
+}
+
+interface ExecutionMetadata {
+    executionId: string;
+    runId?: string;
+    sessionId?: string;
+    actorId?: string;
+    workflowId?: string;
+    parentExecutionId?: string;
+    callerDid?: string;
+    targetDid?: string;
+    agentNodeDid?: string;
+}
+declare class ExecutionContext {
+    readonly input: any;
+    readonly metadata: ExecutionMetadata;
+    readonly req: express.Request;
+    readonly res: express.Response;
+    readonly agent: Agent;
+    constructor(params: {
+        input: any;
+        metadata: ExecutionMetadata;
+        req: express.Request;
+        res: express.Response;
+        agent: Agent;
+    });
+    static run<T>(ctx: ExecutionContext, fn: () => T): T;
+    static getCurrent(): ExecutionContext | undefined;
+}
+
+interface ExecutionCredential {
+    vcId: string;
+    executionId: string;
+    workflowId: string;
+    sessionId?: string;
+    issuerDid?: string;
+    targetDid?: string;
+    callerDid?: string;
+    vcDocument: any;
+    signature?: string;
+    inputHash?: string;
+    outputHash?: string;
+    status: string;
+    createdAt: string;
+}
+interface WorkflowCredential {
+    workflowId: string;
+    sessionId?: string;
+    componentVcs: string[];
+    workflowVcId: string;
+    status: string;
+    startTime: string;
+    endTime?: string;
+    totalSteps: number;
+    completedSteps: number;
+}
+interface AuditTrailFilters {
+    workflowId?: string;
+    sessionId?: string;
+    issuerDid?: string;
+    status?: string;
+    limit?: number;
+}
+interface AuditTrailExport {
+    agentDids: string[];
+    executionVcs: Array<{
+        vcId: string;
+        executionId: string;
+        workflowId: string;
+        sessionId?: string;
+        issuerDid?: string;
+        targetDid?: string;
+        callerDid?: string;
+        status: string;
+        createdAt: string;
+    }>;
+    workflowVcs: WorkflowCredential[];
+    totalCount: number;
+    filtersApplied?: Record<string, any>;
+}
+interface GenerateCredentialParams {
+    executionContext: {
+        executionId: string;
+        workflowId?: string;
+        sessionId?: string;
+        callerDid?: string;
+        targetDid?: string;
+        agentNodeDid?: string;
+        timestamp?: string | Date;
+    };
+    inputData?: any;
+    outputData?: any;
+    status?: string;
+    errorMessage?: string;
+    durationMs?: number;
+    headers?: Record<string, string>;
+}
+declare class DidClient {
+    private readonly http;
+    private readonly defaultHeaders;
+    constructor(baseUrl: string, defaultHeaders?: Record<string, string | number | boolean | undefined>);
+    generateCredential(params: GenerateCredentialParams): Promise<ExecutionCredential>;
+    exportAuditTrail(filters?: AuditTrailFilters): Promise<AuditTrailExport>;
+    private serializeDataForJson;
+    private mapExecutionCredential;
+    private cleanFilters;
+    private mergeHeaders;
+    private sanitizeHeaders;
+}
+
+interface GenerateCredentialOptions {
+    inputData?: any;
+    outputData?: any;
+    status?: string;
+    errorMessage?: string;
+    durationMs?: number;
+    timestamp?: string | Date;
+    callerDid?: string;
+    targetDid?: string;
+    agentNodeDid?: string;
+    workflowId?: string;
+    sessionId?: string;
+    executionId?: string;
+    headers?: Record<string, string>;
+}
+declare class DidInterface {
+    private readonly client;
+    private readonly metadata;
+    private readonly enabled;
+    private readonly defaultInput;
+    constructor(params: {
+        client: DidClient;
+        metadata: ExecutionMetadata;
+        enabled: boolean;
+        defaultInput?: any;
+    });
+    generateCredential(options?: GenerateCredentialOptions): Promise<ExecutionCredential>;
+    exportAuditTrail(filters?: AuditTrailFilters): Promise<AuditTrailExport>;
+}
+
+declare class ReasonerContext<TInput = any> {
+    readonly input: TInput;
+    readonly executionId: string;
+    readonly runId?: string;
+    readonly sessionId?: string;
+    readonly actorId?: string;
+    readonly workflowId?: string;
+    readonly parentExecutionId?: string;
+    readonly callerDid?: string;
+    readonly targetDid?: string;
+    readonly agentNodeDid?: string;
+    readonly req: express.Request;
+    readonly res: express.Response;
+    readonly agent: Agent;
+    readonly aiClient: AIClient;
+    readonly memory: MemoryInterface;
+    readonly workflow: WorkflowReporter;
+    readonly did: DidInterface;
+    constructor(params: {
+        input: TInput;
+        executionId: string;
+        runId?: string;
+        sessionId?: string;
+        actorId?: string;
+        workflowId?: string;
+        parentExecutionId?: string;
+        callerDid?: string;
+        targetDid?: string;
+        agentNodeDid?: string;
+        req: express.Request;
+        res: express.Response;
+        agent: Agent;
+        aiClient: AIClient;
+        memory: MemoryInterface;
+        workflow: WorkflowReporter;
+        did: DidInterface;
+    });
+    ai(prompt: string, options?: AIRequestOptions): Promise<any>;
+    aiStream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
+    call(target: string, input: any): Promise<any>;
+    discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+}
+declare function getCurrentContext<TInput = any>(): ReasonerContext<TInput> | undefined;
+
+interface ReasonerDefinition<TInput = any, TOutput = any> {
+    name: string;
+    handler: ReasonerHandler<TInput, TOutput>;
+    options?: ReasonerOptions;
+}
+type ReasonerHandler<TInput = any, TOutput = any> = (ctx: ReasonerContext<TInput>) => Promise<TOutput> | TOutput;
+interface ReasonerOptions {
+    tags?: string[];
+    description?: string;
+    inputSchema?: any;
+    outputSchema?: any;
+    trackWorkflow?: boolean;
+    memoryConfig?: any;
+}
+
+declare class SkillContext<TInput = any> {
+    readonly input: TInput;
+    readonly executionId: string;
+    readonly sessionId?: string;
+    readonly workflowId?: string;
+    readonly callerDid?: string;
+    readonly agentNodeDid?: string;
+    readonly req: express.Request;
+    readonly res: express.Response;
+    readonly agent: Agent;
+    readonly memory: MemoryInterface;
+    readonly workflow: WorkflowReporter;
+    readonly did: DidInterface;
+    constructor(params: {
+        input: TInput;
+        executionId: string;
+        sessionId?: string;
+        workflowId?: string;
+        callerDid?: string;
+        agentNodeDid?: string;
+        req: express.Request;
+        res: express.Response;
+        agent: Agent;
+        memory: MemoryInterface;
+        workflow: WorkflowReporter;
+        did: DidInterface;
+    });
+    discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+}
+declare function getCurrentSkillContext<TInput = any>(): SkillContext<TInput> | undefined;
+
+interface SkillDefinition<TInput = any, TOutput = any> {
+    name: string;
+    handler: SkillHandler<TInput, TOutput>;
+    options?: SkillOptions;
+}
+type SkillHandler<TInput = any, TOutput = any> = (ctx: SkillContext<TInput>) => Awaitable<TOutput>;
+interface SkillOptions {
+    tags?: string[];
+    description?: string;
+    inputSchema?: any;
+    outputSchema?: any;
+}
+
+type DeploymentType = 'long_running' | 'serverless';
+interface AgentConfig {
+    nodeId: string;
+    version?: string;
+    teamId?: string;
+    agentFieldUrl?: string;
+    port?: number;
+    host?: string;
+    publicUrl?: string;
+    aiConfig?: AIConfig;
+    memoryConfig?: MemoryConfig;
+    didEnabled?: boolean;
+    devMode?: boolean;
+    heartbeatIntervalMs?: number;
+    defaultHeaders?: Record<string, string | number | boolean | undefined>;
+    mcp?: MCPConfig;
+    deploymentType?: DeploymentType;
+}
+interface AIConfig {
+    provider?: 'openai' | 'anthropic' | 'openrouter' | 'ollama';
+    model?: string;
+    embeddingModel?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    temperature?: number;
+    maxTokens?: number;
+    enableRateLimitRetry?: boolean;
+    rateLimitMaxRetries?: number;
+    rateLimitBaseDelay?: number;
+    rateLimitMaxDelay?: number;
+    rateLimitJitterFactor?: number;
+    rateLimitCircuitBreakerThreshold?: number;
+    rateLimitCircuitBreakerTimeout?: number;
+}
+interface MemoryConfig {
+    defaultScope?: MemoryScope;
+    ttl?: number;
+}
+type MemoryScope = 'workflow' | 'session' | 'actor' | 'global';
+interface MCPServerConfig {
+    alias: string;
+    url?: string;
+    port?: number;
+    transport?: 'http' | 'bridge';
+    headers?: Record<string, string>;
+}
+interface MCPConfig {
+    servers?: MCPServerConfig[];
+    autoRegisterTools?: boolean;
+    namespace?: string;
+    tags?: string[];
+}
+interface AgentCapability {
+    agentId: string;
+    baseUrl: string;
+    version: string;
+    healthStatus: string;
+    deploymentType?: string;
+    lastHeartbeat?: string;
+    reasoners: ReasonerCapability[];
+    skills: SkillCapability[];
+}
+interface ReasonerCapability {
+    id: string;
+    description?: string;
+    tags: string[];
+    inputSchema?: any;
+    outputSchema?: any;
+    examples?: any[];
+    invocationTarget: string;
+}
+interface SkillCapability {
+    id: string;
+    description?: string;
+    tags: string[];
+    inputSchema?: any;
+    invocationTarget: string;
+}
+interface DiscoveryResponse {
+    discoveredAt: string;
+    totalAgents: number;
+    totalReasoners: number;
+    totalSkills: number;
+    pagination: DiscoveryPagination;
+    capabilities: AgentCapability[];
+}
+interface DiscoveryPagination {
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+interface CompactCapability {
+    id: string;
+    agentId: string;
+    target: string;
+    tags: string[];
+}
+interface CompactDiscoveryResponse {
+    discoveredAt: string;
+    reasoners: CompactCapability[];
+    skills: CompactCapability[];
+}
+type DiscoveryFormat = 'json' | 'compact' | 'xml';
+interface DiscoveryResult {
+    format: DiscoveryFormat;
+    raw: string;
+    json?: DiscoveryResponse;
+    compact?: CompactDiscoveryResponse;
+    xml?: string;
+}
+interface DiscoveryOptions {
+    agent?: string;
+    nodeId?: string;
+    agentIds?: string[];
+    nodeIds?: string[];
+    reasoner?: string;
+    skill?: string;
+    tags?: string[];
+    includeInputSchema?: boolean;
+    includeOutputSchema?: boolean;
+    includeDescriptions?: boolean;
+    includeExamples?: boolean;
+    format?: DiscoveryFormat;
+    healthStatus?: string;
+    limit?: number;
+    offset?: number;
+    headers?: Record<string, string>;
+}
+interface AgentState {
+    reasoners: Map<string, ReasonerDefinition>;
+    skills: Map<string, SkillDefinition>;
+    memoryWatchers: Array<{
+        pattern: string;
+        handler: MemoryWatchHandler;
+        scope?: string;
+        scopeId?: string;
+    }>;
+}
+interface HealthStatus {
+    status: 'ok' | 'running';
+    nodeId: string;
+    version?: string;
+}
+interface ServerlessEvent {
+    path?: string;
+    rawPath?: string;
+    httpMethod?: string;
+    method?: string;
+    action?: string;
+    headers?: Record<string, string | undefined>;
+    queryStringParameters?: Record<string, string | undefined>;
+    target?: string;
+    reasoner?: string;
+    skill?: string;
+    type?: 'reasoner' | 'skill';
+    body?: any;
+    input?: any;
+    executionContext?: Partial<ExecutionMetadata>;
+    execution_context?: Partial<ExecutionMetadata>;
+}
+interface ServerlessResponse {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body: any;
+}
+type AgentHandler = (event: ServerlessEvent | http.IncomingMessage, res?: http.ServerResponse) => Promise<ServerlessResponse | void> | ServerlessResponse | void;
+type Awaitable<T> = T | Promise<T>;
+
+interface AgentRouterOptions {
+    prefix?: string;
+    tags?: string[];
+}
+declare class AgentRouter {
+    readonly prefix?: string;
+    readonly tags?: string[];
+    readonly reasoners: ReasonerDefinition[];
+    readonly skills: SkillDefinition[];
+    constructor(options?: AgentRouterOptions);
+    reasoner<TInput = any, TOutput = any>(name: string, handler: ReasonerHandler<TInput, TOutput>, options?: ReasonerOptions): this;
+    skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;
+}
+
+declare class ReasonerRegistry {
+    private readonly reasoners;
+    register<TInput = any, TOutput = any>(name: string, handler: ReasonerHandler<TInput, TOutput>, options?: ReasonerOptions): void;
+    includeRouter(router: AgentRouter): void;
+    get(name: string): ReasonerDefinition<any, any> | undefined;
+    all(): ReasonerDefinition<any, any>[];
+}
+
+declare class SkillRegistry {
+    private readonly skills;
+    register<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): void;
+    includeRouter(router: AgentRouter): void;
+    get(name: string): SkillDefinition<any, any> | undefined;
+    all(): SkillDefinition<any, any>[];
+}
+
+interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+    input_schema?: any;
+}
+interface MCPToolRegistration {
+    server: string;
+    skillName: string;
+    tool: MCPTool;
+}
+interface MCPHealthSummary {
+    status: 'ok' | 'degraded' | 'disabled';
+    totalServers: number;
+    healthyServers: number;
+    servers: Array<{
+        alias: string;
+        baseUrl: string;
+        transport: 'http' | 'bridge';
+        healthy: boolean;
+    }>;
+}
+
+declare class Agent {
+    readonly config: AgentConfig;
+    readonly app: express.Express;
+    readonly reasoners: ReasonerRegistry;
+    readonly skills: SkillRegistry;
+    private server?;
+    private heartbeatTimer?;
+    private readonly aiClient;
+    private readonly agentFieldClient;
+    private readonly memoryClient;
+    private readonly memoryEventClient;
+    private readonly didClient;
+    private readonly memoryWatchers;
+    private readonly mcpClientRegistry?;
+    private readonly mcpToolRegistrar?;
+    constructor(config: AgentConfig);
+    reasoner<TInput = any, TOutput = any>(name: string, handler: ReasonerHandler<TInput, TOutput>, options?: ReasonerOptions): this;
+    skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;
+    includeRouter(router: AgentRouter): void;
+    handler(): AgentHandler;
+    watchMemory(pattern: string | string[], handler: MemoryWatchHandler, options?: {
+        scope?: string;
+        scopeId?: string;
+    }): void;
+    discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+    registerMcpTools(): Promise<{
+        registered: MCPToolRegistration[];
+    }>;
+    getAIClient(): AIClient;
+    getMemoryInterface(metadata?: ExecutionMetadata): MemoryInterface;
+    getWorkflowReporter(metadata: ExecutionMetadata): WorkflowReporter;
+    getDidInterface(metadata: ExecutionMetadata, defaultInput?: any): DidInterface;
+    serve(): Promise<void>;
+    shutdown(): Promise<void>;
+    call(target: string, input: any): Promise<any>;
+    private registerDefaultRoutes;
+    private executeReasoner;
+    private executeSkill;
+    private buildMetadata;
+    private executeServerlessHttp;
+    private buildMetadataFromHeaders;
+    private handleHttpRequest;
+    private handleServerlessEvent;
+    private normalizeEventBody;
+    private mergeExecutionContext;
+    private extractInvocationDetails;
+    private parsePathTarget;
+    private parseBody;
+    private normalizeInputPayload;
+    private firstDefined;
+    private reasonerDefinitions;
+    private skillDefinitions;
+    private discoveryPayload;
+    private executeInvocation;
+    private runReasoner;
+    private runSkill;
+    private registerWithControlPlane;
+    private startHeartbeat;
+    private health;
+    private mcpStatus;
+    private dispatchMemoryEvent;
+    private parseTarget;
+}
+
+declare class MCPClient {
+    readonly alias: string;
+    readonly baseUrl: string;
+    readonly transport: 'http' | 'bridge';
+    private readonly http;
+    private readonly devMode;
+    private lastHealthy;
+    constructor(config: MCPServerConfig, devMode?: boolean);
+    healthCheck(): Promise<boolean>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, arguments_?: Record<string, any>): Promise<any>;
+    get lastHealthStatus(): boolean;
+    private normalizeTools;
+}
+
+declare class MCPClientRegistry {
+    private readonly clients;
+    private readonly devMode;
+    constructor(devMode?: boolean);
+    register(config: MCPServerConfig): MCPClient;
+    get(alias: string): MCPClient | undefined;
+    list(): MCPClient[];
+    healthSummary(): Promise<MCPHealthSummary>;
+}
+
+interface MCPToolRegistrarOptions {
+    namespace?: string;
+    tags?: string[];
+    devMode?: boolean;
+}
+declare class MCPToolRegistrar {
+    private readonly agent;
+    private readonly registry;
+    private readonly options;
+    private readonly registered;
+    private readonly devMode;
+    constructor(agent: Agent, registry: MCPClientRegistry, options?: MCPToolRegistrarOptions);
+    registerServers(servers: MCPServerConfig[]): void;
+    registerAll(): Promise<{
+        registered: MCPToolRegistration[];
+    }>;
+    private buildTags;
+    private buildSkillName;
+    private sanitize;
+}
+
+declare class RateLimitError extends Error {
+    retryAfter?: number;
+    constructor(message: string, retryAfter?: number);
+}
+interface RateLimiterOptions {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    jitterFactor?: number;
+    circuitBreakerThreshold?: number;
+    circuitBreakerTimeout?: number;
+}
+/**
+ * Stateless rate limiter with adaptive exponential backoff.
+ *
+ * Designed to work across many containers without coordination.
+ * Uses container-specific jitter to naturally distribute load.
+ */
+declare class StatelessRateLimiter {
+    readonly maxRetries: number;
+    readonly baseDelay: number;
+    readonly maxDelay: number;
+    readonly jitterFactor: number;
+    readonly circuitBreakerThreshold: number;
+    readonly circuitBreakerTimeout: number;
+    protected _containerSeed: number;
+    protected _consecutiveFailures: number;
+    protected _circuitOpenTime?: number;
+    constructor(options?: RateLimiterOptions);
+    protected _getContainerSeed(): number;
+    protected _isRateLimitError(error: unknown): boolean;
+    protected _extractRetryAfter(error: unknown): number | undefined;
+    protected _createJitterRng(seed: number): () => number;
+    protected _calculateBackoffDelay(attempt: number, retryAfter?: number): number;
+    protected _checkCircuitBreaker(): boolean;
+    protected _updateCircuitBreaker(success: boolean): void;
+    protected _sleep(delaySeconds: number): Promise<void>;
+    protected _now(): number;
+    executeWithRetry<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+export { AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, type AuditTrailExport, type AuditTrailFilters, type Awaitable, type CompactCapability, type CompactDiscoveryResponse, type DeploymentType, DidClient, DidInterface, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionMetadata, type GenerateCredentialOptions, type GenerateCredentialParams, type HealthStatus, MCPClient, MCPClientRegistry, type MCPConfig, type MCPHealthSummary, type MCPServerConfig, type MCPTool, MCPToolRegistrar, type MCPToolRegistrarOptions, type MCPToolRegistration, type MemoryChangeEvent, MemoryClient, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, RateLimitError, type RateLimiterOptions, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type ServerlessEvent, type ServerlessResponse, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, type VectorSearchOptions, type VectorSearchResult, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, getCurrentContext, getCurrentSkillContext };