gauss-ai 4.0.0

package/dist/agent-builder-8W3mBR-N.d.ts

@@ -0,0 +1,1075 @@
+import { T as Tool, L as LanguageModel } from './types-CVsP7gFI.js';
+import { M as Message, F as FilesystemPort, A as AgentEventType, e as AgentEventHandler, f as McpToolsetSelection, P as PolicyContext, T as TokenCounterPort, g as PolicyEnginePort, h as SubagentConfig, i as ApprovalConfig, C as CheckpointConfig, j as AgentConfig } from './token-counter.port-CRgxZZGe.js';
+import { z } from 'zod';
+
+declare const TodoStatusSchema: z.ZodEnum<["pending", "in_progress", "done", "blocked"]>;
+type TodoStatus = z.infer<typeof TodoStatusSchema>;
+declare const TodoSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "done", "blocked"]>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+    updatedAt: z.ZodDefault<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "done" | "pending" | "in_progress" | "blocked";
+    id: string;
+    title: string;
+    dependencies: string[];
+    priority: "low" | "medium" | "high" | "critical";
+    createdAt: number;
+    updatedAt: number;
+    description?: string | undefined;
+    completedAt?: number | undefined;
+}, {
+    id: string;
+    title: string;
+    status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+    description?: string | undefined;
+    dependencies?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    completedAt?: number | undefined;
+}>;
+type Todo = z.infer<typeof TodoSchema>;
+declare const TodoListSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "done", "blocked"]>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+    updatedAt: z.ZodDefault<z.ZodNumber>;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "done" | "pending" | "in_progress" | "blocked";
+    id: string;
+    title: string;
+    dependencies: string[];
+    priority: "low" | "medium" | "high" | "critical";
+    createdAt: number;
+    updatedAt: number;
+    description?: string | undefined;
+    completedAt?: number | undefined;
+}, {
+    id: string;
+    title: string;
+    status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+    description?: string | undefined;
+    dependencies?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    completedAt?: number | undefined;
+}>, "many">;
+type TodoList = z.infer<typeof TodoListSchema>;
+declare const WriteTodosInputSchema: z.ZodObject<{
+    todos: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "done", "blocked"]>>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        createdAt: z.ZodDefault<z.ZodNumber>;
+        updatedAt: z.ZodDefault<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "done" | "pending" | "in_progress" | "blocked";
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: "low" | "medium" | "high" | "critical";
+        createdAt: number;
+        updatedAt: number;
+        description?: string | undefined;
+        completedAt?: number | undefined;
+    }, {
+        id: string;
+        title: string;
+        status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+        description?: string | undefined;
+        dependencies?: string[] | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+        createdAt?: number | undefined;
+        updatedAt?: number | undefined;
+        completedAt?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    todos: {
+        status: "done" | "pending" | "in_progress" | "blocked";
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: "low" | "medium" | "high" | "critical";
+        createdAt: number;
+        updatedAt: number;
+        description?: string | undefined;
+        completedAt?: number | undefined;
+    }[];
+}, {
+    todos: {
+        id: string;
+        title: string;
+        status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+        description?: string | undefined;
+        dependencies?: string[] | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+        createdAt?: number | undefined;
+        updatedAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[];
+}>;
+type WriteTodosInput = z.infer<typeof WriteTodosInputSchema>;
+declare const UpdateTodoInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "done", "blocked"]>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+    description?: string | undefined;
+    title?: string | undefined;
+}, {
+    id: string;
+    status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+    description?: string | undefined;
+    title?: string | undefined;
+}>;
+type UpdateTodoInput = z.infer<typeof UpdateTodoInputSchema>;
+
+declare const CheckpointSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    stepIndex: z.ZodNumber;
+    conversation: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant", "system"]>;
+        content: z.ZodString;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        role: "system" | "user" | "assistant";
+        content: string;
+        timestamp?: number | undefined;
+    }, {
+        role: "system" | "user" | "assistant";
+        content: string;
+        timestamp?: number | undefined;
+    }>, "many">;
+    todos: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "in_progress", "done", "blocked"]>>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        createdAt: z.ZodDefault<z.ZodNumber>;
+        updatedAt: z.ZodDefault<z.ZodNumber>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "done" | "pending" | "in_progress" | "blocked";
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: "low" | "medium" | "high" | "critical";
+        createdAt: number;
+        updatedAt: number;
+        description?: string | undefined;
+        completedAt?: number | undefined;
+    }, {
+        id: string;
+        title: string;
+        status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+        description?: string | undefined;
+        dependencies?: string[] | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+        createdAt?: number | undefined;
+        updatedAt?: number | undefined;
+        completedAt?: number | undefined;
+    }>, "many">>;
+    filesSnapshot: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    toolResults: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    generatedTokens: z.ZodDefault<z.ZodNumber>;
+    lastToolCallId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: number;
+    todos: {
+        status: "done" | "pending" | "in_progress" | "blocked";
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: "low" | "medium" | "high" | "critical";
+        createdAt: number;
+        updatedAt: number;
+        description?: string | undefined;
+        completedAt?: number | undefined;
+    }[];
+    sessionId: string;
+    stepIndex: number;
+    conversation: {
+        role: "system" | "user" | "assistant";
+        content: string;
+        timestamp?: number | undefined;
+    }[];
+    filesSnapshot: Record<string, string>;
+    toolResults: Record<string, unknown>;
+    generatedTokens: number;
+    lastToolCallId: string | null;
+    metadata: Record<string, unknown>;
+}, {
+    id: string;
+    sessionId: string;
+    stepIndex: number;
+    conversation: {
+        role: "system" | "user" | "assistant";
+        content: string;
+        timestamp?: number | undefined;
+    }[];
+    createdAt?: number | undefined;
+    todos?: {
+        id: string;
+        title: string;
+        status?: "done" | "pending" | "in_progress" | "blocked" | undefined;
+        description?: string | undefined;
+        dependencies?: string[] | undefined;
+        priority?: "low" | "medium" | "high" | "critical" | undefined;
+        createdAt?: number | undefined;
+        updatedAt?: number | undefined;
+        completedAt?: number | undefined;
+    }[] | undefined;
+    filesSnapshot?: Record<string, string> | undefined;
+    toolResults?: Record<string, unknown> | undefined;
+    generatedTokens?: number | undefined;
+    lastToolCallId?: string | null | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type Checkpoint = z.infer<typeof CheckpointSchema>;
+
+interface MemoryPort {
+    saveTodos(sessionId: string, todos: Todo[]): Promise<void>;
+    loadTodos(sessionId: string): Promise<Todo[]>;
+    saveCheckpoint(sessionId: string, checkpoint: Checkpoint): Promise<void>;
+    loadLatestCheckpoint(sessionId: string): Promise<Checkpoint | null>;
+    listCheckpoints(sessionId: string): Promise<Checkpoint[]>;
+    deleteOldCheckpoints(sessionId: string, keepCount: number): Promise<void>;
+    saveConversation(sessionId: string, messages: Message[]): Promise<void>;
+    loadConversation(sessionId: string): Promise<Message[]>;
+    saveMetadata(sessionId: string, key: string, value: unknown): Promise<void>;
+    loadMetadata<T = unknown>(sessionId: string, key: string): Promise<T | null>;
+    deleteMetadata(sessionId: string, key: string): Promise<void>;
+}
+
+declare const UserProfileSchema: z.ZodObject<{
+    userId: z.ZodString;
+    preferences: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    language: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodEnum<["concise", "detailed", "technical", "casual"]>>;
+    context: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodDefault<z.ZodNumber>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    createdAt: number;
+    updatedAt: number;
+    userId: string;
+    preferences: Record<string, unknown>;
+    language?: string | undefined;
+    style?: "concise" | "detailed" | "technical" | "casual" | undefined;
+    context?: string | undefined;
+}, {
+    userId: string;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    preferences?: Record<string, unknown> | undefined;
+    language?: string | undefined;
+    style?: "concise" | "detailed" | "technical" | "casual" | undefined;
+    context?: string | undefined;
+}>;
+type UserProfile = z.infer<typeof UserProfileSchema>;
+declare const UserMemorySchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    source: z.ZodDefault<z.ZodEnum<["explicit", "inferred"]>>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: number;
+    content: string;
+    tags: string[];
+    confidence: number;
+    source: "explicit" | "inferred";
+}, {
+    id: string;
+    content: string;
+    createdAt?: number | undefined;
+    tags?: string[] | undefined;
+    confidence?: number | undefined;
+    source?: "explicit" | "inferred" | undefined;
+}>;
+type UserMemory = z.infer<typeof UserMemorySchema>;
+type UserMemoryInput = z.input<typeof UserMemorySchema>;
+declare const SharedKnowledgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    usageCount: z.ZodDefault<z.ZodNumber>;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: number;
+    content: string;
+    tags: string[];
+    usageCount: number;
+    category?: string | undefined;
+}, {
+    id: string;
+    content: string;
+    createdAt?: number | undefined;
+    tags?: string[] | undefined;
+    category?: string | undefined;
+    usageCount?: number | undefined;
+}>;
+type SharedKnowledge = z.infer<typeof SharedKnowledgeSchema>;
+type SharedKnowledgeInput = z.input<typeof SharedKnowledgeSchema>;
+
+interface LearningPort {
+    getProfile(userId: string): Promise<UserProfile | null>;
+    updateProfile(userId: string, updates: Partial<Omit<UserProfile, "userId" | "createdAt">>): Promise<UserProfile>;
+    deleteProfile(userId: string): Promise<void>;
+    addMemory(userId: string, memory: Omit<UserMemoryInput, "id" | "createdAt">): Promise<UserMemory>;
+    getMemories(userId: string, options?: {
+        tags?: string[];
+        limit?: number;
+        since?: number;
+    }): Promise<UserMemory[]>;
+    deleteMemory(userId: string, memoryId: string): Promise<void>;
+    clearMemories(userId: string): Promise<void>;
+    addKnowledge(knowledge: Omit<SharedKnowledgeInput, "id" | "createdAt" | "usageCount">): Promise<SharedKnowledge>;
+    queryKnowledge(query: string, options?: {
+        category?: string;
+        limit?: number;
+    }): Promise<SharedKnowledge[]>;
+    incrementKnowledgeUsage(knowledgeId: string): Promise<void>;
+    deleteKnowledge(knowledgeId: string): Promise<void>;
+}
+
+interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    domain?: string;
+}
+interface McpToolResult {
+    content: McpToolResultContent[];
+    isError?: boolean;
+}
+interface McpToolResultContent {
+    type: "text" | "image" | "resource";
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+interface McpServerInfo {
+    id: string;
+    name: string;
+    status: "connected" | "disconnected" | "error";
+    toolCount: number;
+    transport: "stdio" | "http" | "sse" | "streamable-http";
+}
+interface McpServerConfig {
+    id: string;
+    name: string;
+    transport: "stdio" | "http" | "sse" | "streamable-http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+}
+interface McpPort {
+    /** Discover all available tools from connected MCP servers */
+    discoverTools(): Promise<Record<string, McpToolDefinition>>;
+    /** Execute a tool by name with given arguments */
+    executeTool(name: string, args: unknown): Promise<McpToolResult>;
+    /** List connected MCP servers */
+    listServers(): Promise<McpServerInfo[]>;
+    /** Connect to a new MCP server */
+    connect(config: McpServerConfig): Promise<void>;
+    /** Disconnect from an MCP server */
+    disconnect(serverId: string): Promise<void>;
+    /** Close all connections */
+    closeAll(): Promise<void>;
+}
+
+interface TelemetrySpan {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setStatus(code: "OK" | "ERROR", message?: string): void;
+    end(): void;
+}
+interface TelemetryPort {
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): TelemetrySpan;
+    recordMetric(name: string, value: number, attributes?: Record<string, string>): void;
+    flush(): Promise<void>;
+}
+
+interface CostTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    model: string;
+    provider: string;
+    timestamp: number;
+}
+interface CostEstimate {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    currency: "USD";
+    breakdown: Array<{
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+    }>;
+}
+interface CostTrackerPort {
+    recordUsage(usage: CostTokenUsage): void;
+    getEstimate(): CostEstimate;
+    getSessionBudget(): number | null;
+    isOverBudget(): boolean;
+    reset(): void;
+    exportUsage(): string;
+}
+
+interface PluginRunMetadata {
+    readonly [key: string]: unknown;
+}
+/** Context passed to plugin hooks — read-only snapshot of the current run */
+interface PluginContext {
+    readonly sessionId: string;
+    readonly agentName?: string;
+    readonly config: Readonly<{
+        instructions: string;
+        maxSteps: number;
+    }>;
+    readonly filesystem: FilesystemPort;
+    readonly memory: MemoryPort;
+    readonly learning?: LearningPort;
+    readonly toolNames: readonly string[];
+    readonly runMetadata?: PluginRunMetadata;
+}
+/** Context passed once during plugin setup */
+interface PluginSetupContext extends Omit<PluginContext, "runMetadata"> {
+    /** Subscribe to agent lifecycle events; returned function unsubscribes */
+    on(eventType: AgentEventType | "*", handler: AgentEventHandler): () => void;
+}
+interface BeforeRunParams {
+    prompt: string;
+}
+interface BeforeRunResult {
+    prompt?: string;
+}
+interface AfterRunParams {
+    result: {
+        text: string;
+        steps: unknown[];
+        sessionId: string;
+    };
+}
+interface BeforeToolParams {
+    toolName: string;
+    args: unknown;
+}
+interface BeforeToolResult {
+    args?: unknown;
+    skip?: boolean;
+    result?: unknown;
+}
+interface AfterToolParams {
+    toolName: string;
+    args: unknown;
+    result: unknown;
+}
+interface BeforeStepParams {
+    stepIndex: number;
+    step: unknown;
+}
+interface BeforeStepResult {
+    step?: unknown;
+    skip?: boolean;
+}
+interface AfterStepParams {
+    stepIndex: number;
+    step: unknown;
+}
+interface OnErrorParams {
+    error: unknown;
+    phase: "run" | "stream" | "tool" | "step" | "setup";
+}
+interface OnErrorResult {
+    suppress?: boolean;
+}
+interface PluginHooks {
+    beforeRun?(ctx: PluginContext, params: BeforeRunParams): Promise<BeforeRunResult | void> | BeforeRunResult | void;
+    afterRun?(ctx: PluginContext, params: AfterRunParams): Promise<void> | void;
+    beforeTool?(ctx: PluginContext, params: BeforeToolParams): Promise<BeforeToolResult | void> | BeforeToolResult | void;
+    afterTool?(ctx: PluginContext, params: AfterToolParams): Promise<void> | void;
+    beforeStep?(ctx: PluginContext, params: BeforeStepParams): Promise<BeforeStepResult | void> | BeforeStepResult | void;
+    afterStep?(ctx: PluginContext, params: AfterStepParams): Promise<void> | void;
+    onError?(ctx: PluginContext, params: OnErrorParams): Promise<OnErrorResult | void> | OnErrorResult | void;
+}
+interface Plugin {
+    readonly name: string;
+    readonly version?: string;
+    readonly hooks?: PluginHooks;
+    readonly tools?: Record<string, Tool<any, any>>;
+    setup?(ctx: PluginSetupContext): Promise<void> | void;
+    dispose?(): Promise<void> | void;
+}
+
+interface RuntimePort {
+    /** Human-readable runtime identifier */
+    readonly name: 'node' | 'deno' | 'bun' | 'edge' | 'unknown';
+    /** Generate a unique identifier */
+    randomUUID(): string;
+    /** HTTP fetch (standard Fetch API) */
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    /** Read an environment variable */
+    getEnv(key: string): string | undefined;
+    /** Schedule a delayed callback. Returns a disposable handle. */
+    setTimeout(callback: () => void, ms: number): {
+        clear(): void;
+    };
+}
+
+interface LifecycleHooks {
+    onStartup?: () => Promise<void>;
+    onShutdown?: () => Promise<void>;
+    onHealthCheck?: () => Promise<HealthStatus>;
+}
+interface HealthStatus {
+    healthy: boolean;
+    details?: Record<string, {
+        status: 'up' | 'down';
+        message?: string;
+    }>;
+}
+declare class LifecycleManager {
+    private _isReady;
+    private _isShuttingDown;
+    private readonly hooks;
+    private readonly runningOperations;
+    constructor(hooks: LifecycleHooks);
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    get isReady(): boolean;
+    get isShuttingDown(): boolean;
+    /**
+     * Track a running operation for graceful shutdown.
+     * Returns a cleanup function to remove the operation from tracking.
+     */
+    trackOperation<T>(operation: Promise<T>): Promise<T>;
+}
+
+type TemplateValue = string | number | boolean | null | undefined | any[] | Record<string, any>;
+interface PromptTemplateConfig {
+    template: string;
+    variables?: Record<string, TemplateValue>;
+    partials?: Record<string, PromptTemplate>;
+}
+declare class PromptTemplate {
+    private readonly config;
+    constructor(config: PromptTemplateConfig);
+    compile(overrides?: Record<string, TemplateValue>): string;
+    private processLoops;
+    private processConditionals;
+    private processFilters;
+    extend(overrides: Partial<PromptTemplateConfig>): PromptTemplate;
+    get requiredVariables(): string[];
+    static from(template: string): PromptTemplate;
+}
+
+declare abstract class AbstractBuilder<T> {
+    protected abstract validate(): void;
+    protected abstract construct(): T;
+    build(): T;
+}
+
+/**
+ * Circuit Breaker implementation following the classic pattern
+ * States: closed → open → half-open
+ */
+interface CircuitBreakerConfig {
+    readonly failureThreshold: number;
+    readonly resetTimeoutMs: number;
+    readonly monitorWindowMs: number;
+}
+declare enum CircuitBreakerState {
+    CLOSED = "closed",
+    OPEN = "open",
+    HALF_OPEN = "half-open"
+}
+declare class CircuitBreaker {
+    private readonly config;
+    private state;
+    private failures;
+    private lastFailureTime;
+    private halfOpenTestInProgress;
+    constructor(config?: CircuitBreakerConfig);
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+    getState(): CircuitBreakerState;
+    getFailureCount(): number;
+    reset(): void;
+    private shouldReject;
+    private onSuccess;
+    private onFailure;
+    private updateState;
+    private cleanupOldFailures;
+}
+
+/**
+ * Rate Limiter using token bucket algorithm
+ */
+interface RateLimiterConfig {
+    readonly maxTokens: number;
+    readonly refillRateMs: number;
+}
+declare class RateLimiter {
+    private readonly config;
+    private tokens;
+    private lastRefillTime;
+    private waitQueue;
+    private processingScheduled;
+    constructor(config?: RateLimiterConfig);
+    /**
+     * Acquire a token, waiting if necessary
+     */
+    acquire(): Promise<void>;
+    /**
+     * Try to acquire a token immediately
+     * @returns true if token acquired, false otherwise
+     */
+    tryAcquire(): boolean;
+    /**
+     * Get number of available tokens
+     */
+    get availableTokens(): number;
+    /**
+     * Reset the rate limiter to initial state
+     */
+    reset(): void;
+    private refillTokens;
+    private processQueue;
+}
+
+/**
+ * LRU Cache with TTL support for tool execution results
+ */
+interface ToolCacheConfig {
+    readonly defaultTtlMs: number;
+    readonly maxSize: number;
+    readonly cleanupIntervalMs?: number;
+}
+declare class ToolCache<T = any> {
+    private readonly config;
+    private cache;
+    private lastCleanup;
+    private readonly cleanupIntervalMs;
+    constructor(config?: ToolCacheConfig);
+    /**
+     * Check if a non-expired entry exists for the key
+     */
+    has(key: string): boolean;
+    /**
+     * Get a cached value
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set a cached value
+     */
+    set(key: string, value: T, ttlMs?: number): void;
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(key: string): boolean;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Get current cache size
+     */
+    get size(): number;
+    /**
+     * Get cache hit/miss statistics
+     */
+    getStats(): {
+        hits: number;
+        misses: number;
+        size: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    private hitCount;
+    private missCount;
+    private evictLRU;
+    private cleanupExpired;
+}
+
+declare enum MiddlewarePriority {
+    /** Executes first — security, auth, rate limiting */
+    FIRST = 0,
+    /** Executes early — validation, input transformation */
+    EARLY = 250,
+    /** Default priority */
+    NORMAL = 500,
+    /** Executes late — logging, metrics */
+    LATE = 750,
+    /** Executes last — cleanup, final telemetry */
+    LAST = 1000
+}
+interface MiddlewareContext {
+    readonly sessionId: string;
+    readonly agentName?: string;
+    readonly timestamp: number;
+    /** Mutable metadata bag — each middleware can read/write entries */
+    readonly metadata: Record<string, unknown>;
+}
+interface BeforeAgentParams {
+    prompt: string;
+    instructions: string;
+    tools: Record<string, Tool<any, any>>;
+}
+interface BeforeAgentResult {
+    /** Modified prompt (optional — original used if omitted) */
+    prompt?: string;
+    /** Modified instructions (optional) */
+    instructions?: string;
+    /** Additional tools to inject (merged with existing) */
+    tools?: Record<string, Tool<any, any>>;
+    /** If true, skip agent execution entirely and use `earlyResult` */
+    abort?: boolean;
+    /** Result to return when `abort` is true */
+    earlyResult?: string;
+}
+interface AfterAgentParams {
+    prompt: string;
+    result: {
+        text: string;
+        steps: unknown[];
+        sessionId: string;
+    };
+}
+interface AfterAgentResult {
+    /** Modified result text (optional) */
+    text?: string;
+}
+interface BeforeToolCallParams {
+    toolName: string;
+    args: unknown;
+    stepIndex: number;
+}
+interface BeforeToolCallResult {
+    /** Modified args (optional) */
+    args?: unknown;
+    /** If true, skip this tool call and use `mockResult` */
+    skip?: boolean;
+    /** Result to return when `skip` is true */
+    mockResult?: unknown;
+}
+interface AfterToolCallParams {
+    toolName: string;
+    args: unknown;
+    result: unknown;
+    stepIndex: number;
+    durationMs: number;
+}
+interface AfterToolCallResult {
+    /** Modified result (optional) */
+    result?: unknown;
+}
+interface OnMiddlewareErrorParams {
+    error: unknown;
+    phase: "beforeAgent" | "afterAgent" | "beforeTool" | "afterTool";
+    middlewareName: string;
+}
+interface OnMiddlewareErrorResult {
+    /** If true, suppress the error and continue the chain */
+    suppress?: boolean;
+    /** Fallback result to use when suppressing */
+    fallbackResult?: unknown;
+}
+interface MiddlewarePort {
+    /** Unique name for this middleware */
+    readonly name: string;
+    /** Execution priority — lower values execute first */
+    readonly priority: MiddlewarePriority;
+    /** Called before agent execution starts */
+    beforeAgent?(ctx: MiddlewareContext, params: BeforeAgentParams): Promise<BeforeAgentResult | void> | BeforeAgentResult | void;
+    /** Called after agent execution completes */
+    afterAgent?(ctx: MiddlewareContext, params: AfterAgentParams): Promise<AfterAgentResult | void> | AfterAgentResult | void;
+    /** Called before each tool invocation */
+    beforeTool?(ctx: MiddlewareContext, params: BeforeToolCallParams): Promise<BeforeToolCallResult | void> | BeforeToolCallResult | void;
+    /** Called after each tool invocation */
+    afterTool?(ctx: MiddlewareContext, params: AfterToolCallParams): Promise<AfterToolCallResult | void> | AfterToolCallResult | void;
+    /** Called when an error occurs in this or another middleware */
+    onError?(ctx: MiddlewareContext, params: OnMiddlewareErrorParams): Promise<OnMiddlewareErrorResult | void> | OnMiddlewareErrorResult | void;
+    /** Called once during agent initialization */
+    setup?(ctx: MiddlewareContext): Promise<void> | void;
+    /** Called once during agent shutdown */
+    teardown?(ctx: MiddlewareContext): Promise<void> | void;
+}
+interface BeforeAgentChainResult extends BeforeAgentParams {
+    /** If true, agent execution should be skipped and `earlyResult` returned */
+    aborted?: boolean;
+    /** Text to return when aborted */
+    earlyResult?: string;
+}
+interface MiddlewareChainPort {
+    /** Add a middleware to the chain */
+    use(middleware: MiddlewarePort): void;
+    /** Remove a middleware by name */
+    remove(name: string): boolean;
+    /** Get all registered middleware (sorted by priority) */
+    list(): readonly MiddlewarePort[];
+    /** Execute beforeAgent hooks in priority order */
+    runBeforeAgent(ctx: MiddlewareContext, params: BeforeAgentParams): Promise<BeforeAgentChainResult>;
+    /** Execute afterAgent hooks in reverse priority order */
+    runAfterAgent(ctx: MiddlewareContext, params: AfterAgentParams): Promise<AfterAgentParams>;
+    /** Execute beforeTool hooks in priority order */
+    runBeforeTool(ctx: MiddlewareContext, params: BeforeToolCallParams): Promise<BeforeToolCallResult>;
+    /** Execute afterTool hooks in reverse priority order */
+    runAfterTool(ctx: MiddlewareContext, params: AfterToolCallParams): Promise<AfterToolCallParams>;
+    /** Initialize all middleware */
+    setup(ctx: MiddlewareContext): Promise<void>;
+    /** Teardown all middleware */
+    teardown(ctx: MiddlewareContext): Promise<void>;
+}
+
+type EventKey = AgentEventType | "*";
+/**
+ * Portable event bus for agent lifecycle events.
+ * Supports typed subscriptions, wildcard listeners, auto-filled metadata,
+ * hierarchical parent/child relationships, bubbling, capturing, and anti-storm protection.
+ */
+interface EventBusOptions {
+    /** Maximum listeners allowed per event type (default: 100). */
+    maxListenersPerEvent?: number;
+    /** Maximum bubbled events per second from a single child (default: 100). */
+    maxBubblesPerSecond?: number;
+}
+declare class EventBus {
+    private readonly sessionId;
+    private readonly listeners;
+    private readonly maxListenersPerEvent;
+    private readonly maxBubblesPerSecond;
+    private parent;
+    private readonly children;
+    private namespace;
+    private readonly namespacedListeners;
+    private readonly bubbleCounts;
+    constructor(sessionId: string, options?: EventBusOptions);
+    /** Subscribe to a specific event type or '*' for all events. Returns unsubscribe fn. */
+    on(eventType: EventKey, handler: AgentEventHandler): () => void;
+    /** Unsubscribe a handler from a specific event type. */
+    off(eventType: EventKey, handler: AgentEventHandler): void;
+    /** Emit an event, auto-filling timestamp and sessionId. Also bubbles to parent. */
+    emit(type: AgentEventType, data?: unknown): void;
+    /** Remove all listeners for a given event type, or all listeners if no type specified. */
+    removeAllListeners(eventType?: EventKey): void;
+    /** Return the number of listeners for a given event type. */
+    listenerCount(eventType: EventKey): number;
+    /** Create a child bus with a given namespace. */
+    createChild(childNamespace: string): EventBus;
+    /** Broadcast an event from this bus to ALL children recursively (capturing phase). */
+    broadcast(type: AgentEventType, data?: unknown): void;
+    /** Subscribe to events bubbled from a specific child namespace. */
+    onNamespaced(childNamespace: string, handler: AgentEventHandler): () => void;
+    /** Get all child buses. */
+    getChildren(): Map<string, EventBus>;
+    /** Get the parent bus, or null for root. */
+    getParent(): EventBus | null;
+    /** Dispatch an event to local listeners (specific + wildcard). */
+    private dispatchLocal;
+    /** Bubble an event to the parent bus with _source and _bubbled metadata. */
+    private bubbleToParent;
+    /** Check if a child is within the allowed bubble rate. Returns true if allowed. */
+    private checkBubbleRate;
+}
+
+interface AgentResult<TOutput = unknown> {
+    text: string;
+    steps: unknown[];
+    sessionId: string;
+    /** Parsed structured output when `output` is configured via builder or run options. */
+    output?: TOutput;
+    /** Tool calls extracted from all steps. */
+    toolCalls: Array<{
+        name: string;
+        args?: unknown;
+        stepIndex: number;
+    }>;
+}
+interface AgentRunOptions {
+    pluginMetadata?: PluginRunMetadata;
+    mcpToolset?: McpToolsetSelection;
+    policyContext?: PolicyContext;
+}
+
+interface AgentInternalConfig {
+    model: LanguageModel;
+    instructions: string;
+    id?: string;
+    name?: string;
+    maxSteps: number;
+    fs: FilesystemPort;
+    memory: MemoryPort;
+    tokenCounter: TokenCounterPort;
+    mcp?: McpPort;
+    policyEngine?: PolicyEnginePort;
+    runtime?: RuntimePort;
+    learning?: LearningPort;
+    userId?: string;
+    planning: boolean;
+    subagents: boolean;
+    subagentConfig?: Partial<SubagentConfig>;
+    approvalConfig?: Required<ApprovalConfig>;
+    checkpointConfig?: Required<CheckpointConfig>;
+    extraTools?: Record<string, Tool<any, any>>;
+    plugins?: Plugin[];
+    costTracker?: CostTrackerPort;
+    circuitBreaker?: CircuitBreaker;
+    rateLimiter?: RateLimiter;
+    toolCache?: ToolCache;
+    lifecycleHooks?: LifecycleHooks;
+    telemetry?: TelemetryPort;
+    /** AI SDK Output specification for structured output (passthrough to ToolLoopAgent). */
+    output?: any;
+    /** Middleware stack — composable, priority-ordered hooks */
+    middleware?: MiddlewarePort[];
+}
+declare class Agent {
+    readonly sessionId: string;
+    readonly eventBus: EventBus;
+    private readonly config;
+    private _runtime;
+    private _runtimePromise;
+    private readonly tokenTracker;
+    private readonly pluginManager;
+    private readonly middlewareChain;
+    private _toolManager?;
+    private _executionEngine?;
+    private readonly lifecycleManager;
+    private readonly circuitBreaker?;
+    private readonly rateLimiter?;
+    private readonly toolCache?;
+    private readonly telemetry?;
+    constructor(config: AgentInternalConfig);
+    private get toolManager();
+    private get executionEngine();
+    /** Lazy-initialized runtime adapter. Resolves on first use. */
+    private ensureRuntime;
+    static create(config: AgentConfig): AgentBuilder;
+    static minimal(config: AgentConfig): Agent;
+    static full(config: AgentConfig & {
+        memory?: MemoryPort;
+        mcp?: McpPort;
+        tokenCounter?: TokenCounterPort;
+    }): Agent;
+    /**
+     * Auto-configuring factory that works in any runtime.
+     * Uses universal adapters (VirtualFilesystem, InMemoryAdapter, ApproximateTokenCounter)
+     * that require zero platform-specific APIs.
+     *
+     * For runtime-specific adapters (LocalFilesystem, DenoFilesystem, OpfsFilesystem, etc.),
+     * use `Agent.create()` and compose manually.
+     */
+    static auto(config: AgentConfig): Agent;
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    get isReady(): boolean;
+    get isShuttingDown(): boolean;
+    run(prompt: string, options?: AgentRunOptions): Promise<AgentResult>;
+    stream(params: {
+        messages: Array<{
+            role: string;
+            content: unknown;
+        }>;
+    }, options?: AgentRunOptions): Promise<any>;
+    dispose(): Promise<void>;
+}
+
+declare class AgentBuilder extends AbstractBuilder<Agent> {
+    private readonly agentConfig;
+    private maxStepsOverride?;
+    private fs?;
+    private memory?;
+    private learning?;
+    private userId?;
+    private tokenCounter?;
+    private mcp?;
+    private policyEngine?;
+    private runtime?;
+    private costTracker?;
+    private planning;
+    private subagents;
+    private subagentConfig?;
+    private approvalConfig?;
+    private circuitBreaker?;
+    private rateLimiter?;
+    private toolCache?;
+    private telemetryAdapter?;
+    private extraTools;
+    private readonly plugins;
+    private lifecycleHooks?;
+    private readonly eventHandlers;
+    /** AI SDK Output specification (e.g. Output.object({schema})) */
+    private outputSpec?;
+    constructor(config: AgentConfig);
+    withFilesystem(fs: FilesystemPort): this;
+    withMemory(memory: MemoryPort): this;
+    withLearning(learning: LearningPort, userId?: string): this;
+    withTokenCounter(counter: TokenCounterPort): this;
+    withMcp(mcp: McpPort): this;
+    withPolicyEngine(policyEngine: PolicyEnginePort): this;
+    withRuntime(runtime: RuntimePort): this;
+    withCostTracker(tracker: CostTrackerPort): this;
+    withPlanning(): this;
+    withSubagents(config?: Partial<SubagentConfig>): this;
+    withApproval(config?: Partial<ApprovalConfig>): this;
+    withMaxSteps(steps: number): this;
+    withCircuitBreaker(config?: Partial<CircuitBreakerConfig>): this;
+    withRateLimiter(config?: Partial<RateLimiterConfig>): this;
+    withToolCache(config?: Partial<ToolCacheConfig>): this;
+    withTools(tools: Record<string, Tool<any, any>>): this;
+    withTool(name: string, tool: Tool): this;
+    withPlugin(plugin: Plugin): this;
+    on(type: AgentEventType | "*", handler: AgentEventHandler): this;
+    withLifecycle(hooks: LifecycleHooks): this;
+    withTelemetry(adapter: TelemetryPort): this;
+    /**
+     * Set structured output specification (AI SDK passthrough).
+     * Usage: `.withOutput(Output.object({ schema: z.object({...}) }))`
+     */
+    withOutput(output: any): this;
+    withInstructions(instructions: string): this;
+    withInstructions(template: PromptTemplate, variables?: Record<string, string>): this;
+    protected validate(): void;
+    protected construct(): Agent;
+    build(): Agent;
+}
+
+export { type BeforeStepParams as $, AbstractBuilder as A, type BeforeAgentParams as B, CircuitBreaker as C, type McpToolResult as D, EventBus as E, type McpToolDefinition as F, type McpServerInfo as G, type McpServerConfig as H, type TelemetrySpan as I, type CostTokenUsage as J, type CostEstimate as K, type LearningPort as L, type MemoryPort as M, Agent as N, type AfterToolCallResult as O, type PluginRunMetadata as P, type OnMiddlewareErrorParams as Q, RateLimiter as R, type SharedKnowledgeInput as S, type TelemetryPort as T, type UserProfile as U, type OnMiddlewareErrorResult as V, type AfterRunParams as W, type AfterStepParams as X, type AfterToolParams as Y, type BeforeRunParams as Z, type BeforeRunResult as _, AgentBuilder as a, type BeforeStepResult as a0, type BeforeToolParams as a1, type BeforeToolResult as a2, CheckpointSchema as a3, type HealthStatus as a4, type LifecycleHooks as a5, LifecycleManager as a6, type McpToolResultContent as a7, type OnErrorParams as a8, type OnErrorResult as a9, type PluginSetupContext as aa, PromptTemplate as ab, type PromptTemplateConfig as ac, SharedKnowledgeSchema as ad, type TodoList as ae, TodoListSchema as af, TodoSchema as ag, type TodoStatus as ah, TodoStatusSchema as ai, type UpdateTodoInput as aj, UpdateTodoInputSchema as ak, UserMemorySchema as al, UserProfileSchema as am, type WriteTodosInput as an, WriteTodosInputSchema as ao, type McpPort as b, ToolCache as c, type RuntimePort as d, type PluginContext as e, type MiddlewareChainPort as f, type MiddlewarePort as g, type MiddlewareContext as h, type BeforeAgentChainResult as i, type AfterAgentParams as j, type BeforeToolCallParams as k, type BeforeToolCallResult as l, type AfterToolCallParams as m, type CostTrackerPort as n, type AgentRunOptions as o, type AgentResult as p, type Plugin as q, type PluginHooks as r, MiddlewarePriority as s, type BeforeAgentResult as t, type AfterAgentResult as u, type Todo as v, type Checkpoint as w, type UserMemoryInput as x, type UserMemory as y, type SharedKnowledge as z };