@hanzo/playground 0.1.41-rc.101

package/dist/index.d.ts

@@ -0,0 +1,949 @@
+import express from 'express';
+import http from 'node:http';
+import { z } from 'zod';
+
+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 reconnectPending;
+    private reconnectTimer?;
+    private readonly headers;
+    constructor(baseUrl: string, headers?: Record<string, string | number | boolean | undefined>);
+    start(): void;
+    onEvent(handler: MemoryEventHandler): void;
+    stop(): void;
+    private cleanup;
+    private connect;
+    private scheduleReconnect;
+    private buildForwardHeaders;
+}
+
+type ZodSchema<T> = z.Schema<T, z.ZodTypeDef, any>;
+interface AIRequestOptions {
+    system?: string;
+    schema?: ZodSchema<any>;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    provider?: AIConfig['provider'];
+    /**
+     * Mode for structured output generation.
+     * - 'auto': Let the provider choose (default in ai-sdk, uses tool calling)
+     * - 'json': Use JSON mode (more compatible across providers/models)
+     * - 'tool': Force tool calling mode
+     */
+    mode?: 'auto' | 'json' | 'tool';
+}
+type AIStream = AsyncIterable<string>;
+interface AIEmbeddingOptions {
+    model?: string;
+    provider?: AIConfig['provider'];
+}
+declare class AIClient {
+    private readonly config;
+    private rateLimiter?;
+    constructor(config?: AIConfig);
+    generate<T>(prompt: string, options: AIRequestOptions & {
+        schema: ZodSchema<T>;
+    }): Promise<T>;
+    generate(prompt: string, options?: AIRequestOptions): Promise<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 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 PlaygroundClient {
+    private readonly http;
+    private readonly config;
+    private readonly defaultHeaders;
+    constructor(config: BotConfig);
+    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;
+        botId: 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;
+    private buildExecutionHeaders;
+    sendNote(message: string, tags: string[], agentNodeId: string, metadata: {
+        runId?: string;
+        executionId?: string;
+        sessionId?: string;
+        actorId?: string;
+        workflowId?: string;
+        parentExecutionId?: string;
+        callerDid?: string;
+        targetDid?: string;
+        agentNodeDid?: string;
+    }, uiApiBaseUrl: string, devMode?: boolean): void;
+}
+
+interface WorkflowMetadata {
+    executionId: string;
+    runId?: string;
+    workflowId?: string;
+    agentNodeId?: string;
+    botId?: string;
+}
+interface WorkflowProgressOptions {
+    status?: string;
+    result?: Record<string, any>;
+    error?: string;
+    durationMs?: number;
+}
+declare class WorkflowReporter {
+    private readonly client;
+    private readonly metadata;
+    constructor(client: PlaygroundClient, 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: Bot;
+    constructor(params: {
+        input: any;
+        metadata: ExecutionMetadata;
+        req: express.Request;
+        res: express.Response;
+        agent: Bot;
+    });
+    static run<T>(ctx: ExecutionContext, fn: () => T): T;
+    static getCurrent(): ExecutionContext | undefined;
+}
+
+interface DIDIdentity {
+    did: string;
+    privateKeyJwk: string;
+    publicKeyJwk: string;
+    derivationPath: string;
+    componentType: string;
+    functionName?: string;
+}
+interface DIDIdentityPackage {
+    agentDid: DIDIdentity;
+    botDids: Record<string, DIDIdentity>;
+    skillDids: Record<string, DIDIdentity>;
+    playgroundServerId: string;
+}
+interface DIDRegistrationRequest {
+    agentNodeId: string;
+    bots: Array<{
+        id: string;
+        [key: string]: any;
+    }>;
+    skills: Array<{
+        id: string;
+        [key: string]: any;
+    }>;
+}
+interface DIDRegistrationResponse {
+    success: boolean;
+    identityPackage?: DIDIdentityPackage;
+    message?: string;
+    error?: string;
+}
+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>);
+    /**
+     * Register an agent with the DID system and obtain an identity package.
+     * This must be called before generating VCs to get the caller/target DIDs.
+     */
+    registerAgent(request: DIDRegistrationRequest): Promise<DIDRegistrationResponse>;
+    private parseIdentityPackage;
+    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 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: Bot;
+    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: Bot;
+        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;
+}
+
+declare class BotContext<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: Bot;
+    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: Bot;
+        aiClient: AIClient;
+        memory: MemoryInterface;
+        workflow: WorkflowReporter;
+        did: DidInterface;
+    });
+    ai<T>(prompt: string, options: AIRequestOptions & {
+        schema: ZodSchema<T>;
+    }): Promise<T>;
+    ai(prompt: string, options?: AIRequestOptions): Promise<string>;
+    aiStream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
+    call(target: string, input: any): Promise<any>;
+    discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+    note(message: string, tags?: string[]): void;
+}
+declare function getCurrentContext<TInput = any>(): BotContext<TInput> | undefined;
+
+interface BotDefinition<TInput = any, TOutput = any> {
+    name: string;
+    handler: BotHandler<TInput, TOutput>;
+    options?: BotOptions;
+}
+type BotHandler<TInput = any, TOutput = any> = (ctx: BotContext<TInput>) => Promise<TOutput> | TOutput;
+interface BotOptions {
+    tags?: string[];
+    description?: string;
+    inputSchema?: any;
+    outputSchema?: any;
+    trackWorkflow?: boolean;
+    memoryConfig?: any;
+}
+type DeploymentType = 'long_running' | 'serverless';
+interface BotConfig {
+    nodeId: string;
+    version?: string;
+    teamId?: string;
+    playgroundUrl?: string;
+    port?: number;
+    host?: string;
+    publicUrl?: string;
+    aiConfig?: AIConfig;
+    memoryConfig?: MemoryConfig;
+    didEnabled?: boolean;
+    devMode?: boolean;
+    heartbeatIntervalMs?: number;
+    defaultHeaders?: Record<string, string | number | boolean | undefined>;
+    apiKey?: string;
+    mcp?: MCPConfig;
+    deploymentType?: DeploymentType;
+}
+interface AIConfig {
+    provider?: 'openai' | 'anthropic' | 'google' | 'mistral' | 'groq' | 'xai' | 'deepseek' | 'cohere' | '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 NodeCapability {
+    agentId: string;
+    baseUrl: string;
+    version: string;
+    healthStatus: string;
+    deploymentType?: string;
+    lastHeartbeat?: string;
+    bots: BotCapability[];
+    skills: SkillCapability[];
+}
+interface BotCapability {
+    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;
+    totalBots: number;
+    totalSkills: number;
+    pagination: DiscoveryPagination;
+    capabilities: NodeCapability[];
+}
+interface DiscoveryPagination {
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+interface CompactCapability {
+    id: string;
+    agentId: string;
+    target: string;
+    tags: string[];
+}
+interface CompactDiscoveryResponse {
+    discoveredAt: string;
+    bots: 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[];
+    bot?: 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 BotState {
+    bots: Map<string, BotDefinition>;
+    skills: Map<string, SkillDefinition>;
+    memoryWatchers: Array<{
+        pattern: string;
+        handler: MemoryWatchHandler;
+        scope?: string;
+        scopeId?: string;
+    }>;
+}
+interface HealthStatus {
+    status: 'ok' | 'running';
+    node_id: 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;
+    bot?: string;
+    skill?: string;
+    type?: 'bot' | 'skill';
+    body?: any;
+    input?: any;
+    executionContext?: Partial<ExecutionMetadata>;
+    execution_context?: Partial<ExecutionMetadata>;
+}
+interface ServerlessResponse {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body: any;
+}
+type ServerlessAdapter = (event: any, context?: any) => ServerlessEvent;
+/** Top-level serverless/HTTP entry-point handler. */
+type ServerHandler = (event: ServerlessEvent | http.IncomingMessage, res?: http.ServerResponse) => Promise<ServerlessResponse | void> | ServerlessResponse | void;
+type Awaitable<T> = T | Promise<T>;
+
+interface BotRouterOptions {
+    prefix?: string;
+    tags?: string[];
+}
+declare class BotRouter {
+    readonly prefix?: string;
+    readonly tags?: string[];
+    readonly bots: BotDefinition[];
+    readonly skills: SkillDefinition[];
+    constructor(options?: BotRouterOptions);
+    bot<TInput = any, TOutput = any>(name: string, handler: BotHandler<TInput, TOutput>, options?: BotOptions): this;
+    skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;
+}
+
+declare class BotRegistry {
+    private readonly bots;
+    register<TInput = any, TOutput = any>(name: string, handler: BotHandler<TInput, TOutput>, options?: BotOptions): void;
+    includeRouter(router: BotRouter): void;
+    get(name: string): BotDefinition<any, any> | undefined;
+    all(): BotDefinition<any, any>[];
+}
+
+declare class SkillRegistry {
+    private readonly skills;
+    register<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): void;
+    includeRouter(router: BotRouter): 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 Bot {
+    readonly config: BotConfig;
+    readonly app: express.Express;
+    readonly bots: BotRegistry;
+    readonly skills: SkillRegistry;
+    private server?;
+    private heartbeatTimer?;
+    private readonly aiClient;
+    private readonly playgroundClient;
+    private readonly memoryClient;
+    private readonly memoryEventClient;
+    private readonly didClient;
+    private readonly didManager;
+    private readonly memoryWatchers;
+    private readonly mcpClientRegistry?;
+    private readonly mcpToolRegistrar?;
+    constructor(config: BotConfig);
+    bot<TInput = any, TOutput = any>(name: string, handler: BotHandler<TInput, TOutput>, options?: BotOptions): this;
+    skill<TInput = any, TOutput = any>(name: string, handler: SkillHandler<TInput, TOutput>, options?: SkillOptions): this;
+    includeRouter(router: BotRouter): void;
+    handler(adapter?: (event: any, context?: any) => ServerlessEvent): ServerHandler;
+    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, targetName?: string): DidInterface;
+    note(message: string, tags?: string[], metadata?: ExecutionMetadata): void;
+    serve(): Promise<void>;
+    shutdown(): Promise<void>;
+    call(target: string, input: any): Promise<any>;
+    private registerDefaultRoutes;
+    private executeBot;
+    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 botDefinitions;
+    private skillDefinitions;
+    private discoveryPayload;
+    private executeInvocation;
+    private runBot;
+    private runSkill;
+    private registerWithControlPlane;
+    private startHeartbeat;
+    private health;
+    private mcpStatus;
+    private dispatchMemoryEvent;
+    private parseTarget;
+}
+
+/**
+ * Manages DID registration and identity package storage for an agent.
+ *
+ * This class handles:
+ * - Registering the agent with the DID system
+ * - Storing the identity package (agent DID, bot DIDs, skill DIDs)
+ * - Resolving DIDs for specific functions (bots/skills)
+ */
+declare class DidManager {
+    private readonly client;
+    private readonly agentNodeId;
+    private identityPackage?;
+    private _enabled;
+    constructor(client: DidClient, agentNodeId: string);
+    /**
+     * Register agent with the DID system and obtain identity package.
+     *
+     * @param bots - List of bot definitions
+     * @param skills - List of skill definitions
+     * @returns true if registration succeeded
+     */
+    registerAgent(bots: Array<{
+        id: string;
+        [key: string]: any;
+    }>, skills: Array<{
+        id: string;
+        [key: string]: any;
+    }>): Promise<boolean>;
+    /**
+     * Check if DID system is enabled and identity package is available.
+     */
+    get enabled(): boolean;
+    /**
+     * Get the agent node DID.
+     */
+    getAgentDid(): string | undefined;
+    /**
+     * Get DID for a specific function (bot or skill).
+     * Falls back to agent DID if function not found.
+     *
+     * @param functionName - Name of the bot or skill
+     * @returns DID string or undefined if not registered
+     */
+    getFunctionDid(functionName: string): string | undefined;
+    /**
+     * Get the full identity package (for debugging/inspection).
+     */
+    getIdentityPackage(): DIDIdentityPackage | undefined;
+    /**
+     * Get a summary of the identity for debugging/monitoring.
+     */
+    getIdentitySummary(): Record<string, any>;
+}
+
+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[];
+    clear(): void;
+    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: Bot, 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, Bot as Agent, BotRouter as AgentRouter, type BotRouterOptions as AgentRouterOptions, type AuditTrailExport, type AuditTrailFilters, type Awaitable, Bot, type BotCapability, type BotConfig, BotContext, type BotDefinition, type BotHandler, type BotOptions, BotRouter, type BotRouterOptions, type BotState, type CompactCapability, type CompactDiscoveryResponse, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, 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, type NodeCapability, RateLimitError, type RateLimiterOptions, type ServerHandler, type ServerlessAdapter, 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, type ZodSchema, getCurrentContext, getCurrentSkillContext };