@agentxjs/types 0.0.9 → 0.2.0

package/dist/runtime-internal.d.ts

@@ -0,0 +1,943 @@
+import { b as SystemBusProducer, c as SystemBusConsumer } from './Container-DR-1g44i.js';
+export { B as BusEventHandler, C as Container, d as SubscribeOptions, S as SystemBus, U as Unsubscribe } from './Container-DR-1g44i.js';
+import { M as Message } from './Message-DWQUt647.js';
+import { M as MessageRole, C as ContentPart } from './ContentPart-CqOh-rI1.js';
+import { S as StopReason } from './StopReason-D4DthB1h.js';
+import { E as EventSource } from './SystemEvent-CPvvxdMQ.js';
+import { C as ContainerRepository, I as ImageRepository, S as SessionRepository } from './Persistence-BQkdKomV.js';
+export { c as ContainerConfig, a as ContainerRecord, P as Persistence, b as SessionRecord } from './Persistence-BQkdKomV.js';
+export { a as ImageMetadata, I as ImageRecord } from './ImageRecord-Cn0VcJWk.js';
+import './CommandEvent-CbXzPolX.js';
+import './ToolResultMessage-CDG2L7Zv.js';
+import './ErrorMessage-BoIh3MIO.js';
+
+/**
+ * Repository - Unified persistence interface for AgentX
+ *
+ * Combines all domain-specific repositories into a single interface.
+ * Implementations can be local (SQLite) or remote (HTTP API).
+ *
+ * @example
+ * ```typescript
+ * // Local implementation (node-runtime)
+ * const repository = new SQLiteRepository(dbPath);
+ *
+ * // Remote implementation (browser)
+ * const repository = new RemoteRepository({ serverUrl: "http://..." });
+ *
+ * // Use with runtime
+ * const runtime = createRuntime({ repository });
+ * ```
+ */
+
+/**
+ * Repository - Unified persistence interface
+ *
+ * Combines all domain repositories for convenient single-point configuration.
+ */
+interface Repository extends ContainerRepository, ImageRepository, SessionRepository {
+}
+
+/**
+ * MessageRecord - Storage schema for Message persistence
+ *
+ * Pure data type representing a message in storage.
+ * Content is stored as JSON to accommodate different message types.
+ */
+
+/**
+ * Message storage record
+ */
+interface MessageRecord {
+    /**
+     * Unique message identifier
+     */
+    messageId: string;
+    /**
+     * Associated session identifier
+     */
+    sessionId: string;
+    /**
+     * Message role: user, assistant, tool-call, tool-result
+     */
+    role: MessageRole;
+    /**
+     * Serialized message content (JSON)
+     * Structure varies by role type
+     */
+    content: Record<string, unknown>;
+    /**
+     * Creation timestamp (Unix milliseconds)
+     */
+    createdAt: number;
+}
+
+/**
+ * EnvironmentRecord - Storage for Environment implementation private state
+ *
+ * Used by Environment implementations (Receptor + Effector) to store
+ * their private state that maps to our Session. The business layer
+ * doesn't care about the internal structure of `state`.
+ *
+ * Examples:
+ * - ClaudeEnvironment: { sdkSessionId: "claude_xxx" }
+ * - OpenAIEnvironment: { threadId: "thread_xxx" }
+ * - CustomEnvironment: any implementation-specific data
+ *
+ * Relationship:
+ * ```
+ * SessionRecord (business layer)
+ *     │
+ *     │ sessionId
+ *     ▼
+ * EnvironmentRecord (implementation layer)
+ *     │
+ *     │ state (opaque to business layer)
+ *     ▼
+ * External SDK/API state
+ * ```
+ */
+/**
+ * EnvironmentRecord - Environment implementation private state storage
+ */
+interface EnvironmentRecord {
+    /**
+     * Associated session ID (foreign key to SessionRecord)
+     */
+    sessionId: string;
+    /**
+     * Environment type identifier
+     * Examples: "claude", "openai", "custom"
+     */
+    environmentType: string;
+    /**
+     * Environment private state (opaque to business layer)
+     * Structure is defined by each Environment implementation
+     */
+    state: Record<string, unknown>;
+    /**
+     * Creation timestamp (Unix milliseconds)
+     */
+    createdAt: number;
+    /**
+     * Last update timestamp (Unix milliseconds)
+     */
+    updatedAt: number;
+}
+
+/**
+ * Workdir - Working Directory
+ *
+ * Represents an isolated working directory for an Agent.
+ * The actual path is determined by Runtime, not defined here.
+ *
+ * Workdir is a location declaration, not an operation interface.
+ * Claude SDK has its own tools (Bash, file operations), we just
+ * tell it where to work (cwd).
+ */
+interface Workdir {
+    /**
+     * Unique workdir identifier
+     */
+    readonly id: string;
+    /**
+     * Human-readable workdir name
+     */
+    readonly name: string;
+    /**
+     * Absolute path to working directory
+     *
+     * Examples:
+     * - NodeRuntime: ~/.agentx/workdirs/{id}/
+     * - CloudRuntime: /workdir/ (in container)
+     */
+    readonly path: string;
+}
+
+/**
+ * Sandbox
+ *
+ * Pure resource isolation layer for an Agent.
+ * Isolates external tool resources: Workdir and MCP.
+ *
+ * Architecture:
+ * ```
+ * ┌─────────────────────────────────────────────────────────┐
+ * │                  Container                              │
+ * │  ┌───────────────────────────────────────────────────┐  │
+ * │  │  Agent ──→ Sandbox (Workdir + MCP)               │  │
+ * │  │        ──→ LLM (separate from Sandbox)            │  │
+ * │  └───────────────────────────────────────────────────┘  │
+ * └─────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * Note: LLM is at the same level as Sandbox, not inside it.
+ * Sandbox focuses on external tool isolation (workdir, MCP tools).
+ */
+
+/**
+ * Sandbox - External tool resource isolation
+ *
+ * Isolates external tool resources for an Agent:
+ * - Workdir: Isolated working directory
+ * - MCP: Model Context Protocol tools (future)
+ *
+ * Note: LLM is NOT part of Sandbox - it's at container level.
+ */
+interface Sandbox {
+    /** Sandbox identifier */
+    readonly name: string;
+    /** Isolated working directory for file operations */
+    readonly workdir: Workdir;
+}
+
+declare const SUPPORTED_PROTOCOL_VERSIONS: readonly ["2025-06-18", "2025-03-26", "2024-11-05"];
+type McpProtocolVersion = (typeof SUPPORTED_PROTOCOL_VERSIONS)[number];
+
+/**
+ * MCP Tool Types
+ *
+ * Tool definitions and execution results for Model Context Protocol.
+ */
+/**
+ * JSON Schema Definition
+ *
+ * Simplified JSON Schema for tool input parameters.
+ * Based on JSON Schema Draft 7.
+ */
+interface JsonSchema {
+    /** Schema type (always "object" for MCP tools) */
+    type: "object";
+    /** Property definitions */
+    properties?: Record<string, JsonSchemaProperty>;
+    /** Required property names */
+    required?: string[];
+    /** Additional properties allowed */
+    additionalProperties?: boolean;
+    /** Schema description */
+    description?: string;
+}
+interface JsonSchemaProperty {
+    type: "string" | "number" | "boolean" | "object" | "array" | "null";
+    description?: string;
+    enum?: unknown[];
+    items?: JsonSchemaProperty;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    default?: unknown;
+}
+/**
+ * Tool Definition
+ *
+ * Defines a tool that can be invoked by the LLM.
+ */
+interface McpTool {
+    /** Tool name (unique identifier) */
+    name: string;
+    /** Human-readable description of what the tool does */
+    description?: string;
+    /** JSON Schema for input parameters */
+    inputSchema: JsonSchema;
+    /** Optional annotations (e.g., UI hints) */
+    annotations?: {
+        /** Display title */
+        title?: string;
+        /** Additional metadata */
+        [key: string]: unknown;
+    };
+}
+
+/**
+ * MCP Resource Types
+ *
+ * Resource definitions for Model Context Protocol.
+ * Resources are static data sources (files, documents, etc.) that can be read by the LLM.
+ */
+/**
+ * Resource Definition
+ *
+ * Defines a resource that can be accessed by the LLM.
+ */
+interface McpResource {
+    /** Unique resource identifier (URI) */
+    uri: string;
+    /** Resource name */
+    name: string;
+    /** Optional human-readable title */
+    title?: string;
+    /** Optional description */
+    description?: string;
+    /** MIME type of the resource */
+    mimeType?: string;
+    /** Optional resource size in bytes */
+    size?: number;
+    /** Optional metadata */
+    annotations?: Record<string, unknown>;
+}
+
+/**
+ * MCP Prompt Types
+ *
+ * Prompt templates for Model Context Protocol.
+ * Prompts are reusable message templates that can be parameterized.
+ */
+/**
+ * Prompt Argument
+ *
+ * Defines a parameter for a prompt template.
+ */
+interface McpPromptArgument {
+    /** Argument name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Whether this argument is required */
+    required?: boolean;
+}
+/**
+ * Prompt Definition
+ *
+ * Defines a reusable prompt template.
+ */
+interface McpPrompt {
+    /** Prompt name (unique identifier) */
+    name: string;
+    /** Optional display title */
+    title?: string;
+    /** Optional description */
+    description?: string;
+    /** Prompt arguments/parameters */
+    arguments?: McpPromptArgument[];
+}
+
+/**
+ * Server Information
+ *
+ * Metadata about the MCP server.
+ */
+interface McpServerInfo {
+    /** Server name */
+    name: string;
+    /** Server version */
+    version: string;
+}
+
+/**
+ * MCP Transport Types
+ *
+ * Transport layer configuration for Model Context Protocol.
+ * Defines how to connect to MCP servers via different protocols.
+ */
+/**
+ * Stdio Transport Configuration
+ *
+ * Connect to MCP server via standard input/output (spawned process).
+ * Common for local MCP servers.
+ */
+interface McpStdioTransport {
+    /** Transport type discriminator */
+    type: "stdio";
+    /** Command to execute */
+    command: string;
+    /** Command arguments */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory */
+    cwd?: string;
+}
+/**
+ * SSE Transport Configuration
+ *
+ * Connect to MCP server via Server-Sent Events.
+ * Common for remote MCP servers with streaming support.
+ */
+interface McpSseTransport {
+    /** Transport type discriminator */
+    type: "sse";
+    /** Server URL */
+    url: string;
+    /** HTTP headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * HTTP Transport Configuration
+ *
+ * Connect to MCP server via HTTP requests.
+ * Common for stateless remote MCP servers.
+ */
+interface McpHttpTransport {
+    /** Transport type discriminator */
+    type: "http";
+    /** Server URL */
+    url: string;
+    /** HTTP headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * SDK Transport Configuration
+ *
+ * Use an in-process MCP server instance.
+ * Common for embedded MCP servers in the same application.
+ */
+interface McpSdkTransport {
+    /** Transport type discriminator */
+    type: "sdk";
+    /** Server name */
+    name: string;
+    /** Server instance (implementation-specific) */
+    instance: unknown;
+}
+/**
+ * MCP Transport Config
+ *
+ * Union of all transport configuration types.
+ */
+type McpTransportConfig = McpStdioTransport | McpSseTransport | McpHttpTransport | McpSdkTransport;
+
+/**
+ * MCP Request Types
+ *
+ * Request/response types for JSON-RPC based MCP communication.
+ */
+/**
+ * Base Request Parameters
+ *
+ * Common parameters for all MCP requests.
+ */
+interface McpBaseParams {
+    /** Optional metadata */
+    _meta?: Record<string, unknown>;
+}
+/**
+ * MCP Request
+ *
+ * Generic request structure.
+ */
+interface McpRequest {
+    /** RPC method name */
+    method: string;
+    /** Request parameters */
+    params?: McpBaseParams;
+}
+
+/**
+ * LLM - Large Language Model definition
+ *
+ * Defines the capabilities and metadata of a language model.
+ * Provider-agnostic design allows supporting multiple LLM vendors.
+ */
+interface LLM {
+    /**
+     * Provider name (e.g., "anthropic", "openai", "custom")
+     */
+    provider: string;
+    /**
+     * Provider-specific model identifier
+     * Examples: "claude-3-5-sonnet-20241022", "gpt-4-turbo"
+     */
+    modelId: string;
+    /**
+     * Whether the model supports streaming output
+     */
+    supportsStreaming: boolean;
+    /**
+     * Whether the model supports tool calling
+     */
+    supportsTools: boolean;
+    /**
+     * Whether the model supports vision/image inputs
+     */
+    supportsVision: boolean;
+    /**
+     * Whether the model supports prompt caching
+     */
+    supportsCaching: boolean;
+    /**
+     * Whether the model supports extended thinking
+     */
+    supportsThinking?: boolean;
+}
+
+/**
+ * LLM inference configuration
+ *
+ * Parameters that control how the language model generates responses.
+ * These are the standard parameters supported by most LLM providers.
+ */
+interface LLMConfig {
+    /**
+     * Model identifier to use for inference
+     * Examples: "claude-3-5-sonnet-20241022", "gpt-4-turbo"
+     */
+    model: string;
+    /**
+     * Sampling temperature (0-2)
+     * Higher values make output more random, lower values more deterministic
+     * @default 1.0
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Top-p sampling (nucleus sampling)
+     * Range: 0-1
+     */
+    topP?: number;
+    /**
+     * Top-k sampling
+     * Only consider the top k tokens
+     */
+    topK?: number;
+    /**
+     * Presence penalty (-2.0 to 2.0)
+     * Penalize tokens that have already appeared
+     */
+    presencePenalty?: number;
+    /**
+     * Frequency penalty (-2.0 to 2.0)
+     * Penalize tokens based on their frequency
+     */
+    frequencyPenalty?: number;
+    /**
+     * Stop sequences
+     * Generation stops when any of these sequences is encountered
+     */
+    stopSequences?: string[];
+    /**
+     * Maximum number of thinking tokens (for models with extended thinking)
+     */
+    maxThinkingTokens?: number;
+}
+
+/**
+ * Complete LLM inference request (stateless)
+ *
+ * Contains everything needed for a single LLM inference call.
+ * The LLM is stateless - all context must be provided in messages.
+ *
+ * IMPORTANT: This does NOT include tool definitions.
+ * Tools are external capabilities provided by the runtime environment.
+ */
+interface LLMRequest {
+    /**
+     * Context messages
+     * All conversation history that the LLM should consider
+     */
+    messages: Message[];
+    /**
+     * Inference configuration
+     * Controls how the model generates responses
+     */
+    config: LLMConfig;
+    /**
+     * System prompt (optional)
+     * High-level instructions that guide the model's behavior
+     */
+    systemPrompt?: string;
+}
+
+/**
+ * Token Usage
+ *
+ * Tracks token consumption for AI messages.
+ */
+interface TokenUsage {
+    /** Input tokens used */
+    input: number;
+    /** Output tokens generated */
+    output: number;
+    /** Tokens read from cache (optional) */
+    cacheRead?: number;
+    /** Tokens written to cache (optional) */
+    cacheWrite?: number;
+}
+
+/**
+ * Complete LLM inference response (stateless)
+ *
+ * Contains everything returned from a single LLM inference call.
+ * Given the same LLMRequest (with temperature=0), the response should be reproducible.
+ */
+interface LLMResponse {
+    /**
+     * Generated content
+     * Can be text, thinking, tool calls, etc.
+     */
+    content: string | ContentPart[];
+    /**
+     * Why the model stopped generating
+     */
+    stopReason: StopReason;
+    /**
+     * Token usage statistics
+     */
+    usage: TokenUsage;
+    /**
+     * When the generation finished
+     */
+    finishTime: Date;
+    /**
+     * Model that generated this response
+     */
+    model?: string;
+}
+
+/**
+ * Streaming output chunk types
+ *
+ * When LLM generates responses in streaming mode, it emits chunks of different types.
+ * This allows real-time display of the generation process.
+ */
+/**
+ * Text content chunk
+ */
+interface TextChunk {
+    type: "text";
+    /**
+     * Text delta (incremental content)
+     */
+    delta: string;
+    /**
+     * Cumulative index of this chunk
+     */
+    index: number;
+}
+/**
+ * Thinking process chunk (for models with extended thinking)
+ */
+interface ThinkingChunk {
+    type: "thinking";
+    /**
+     * Thinking delta (incremental reasoning)
+     */
+    delta: string;
+    /**
+     * Cumulative index of this chunk
+     */
+    index: number;
+}
+/**
+ * Tool use chunk (when model requests tool usage)
+ */
+interface ToolUseChunk {
+    type: "tool-use";
+    /**
+     * Tool name
+     */
+    name: string;
+    /**
+     * Tool call ID
+     */
+    id: string;
+    /**
+     * Partial input (may be incomplete JSON)
+     */
+    inputDelta?: string;
+}
+/**
+ * Union type of all streaming chunks
+ */
+type StreamChunk = TextChunk | ThinkingChunk | ToolUseChunk;
+
+/**
+ * LLMProvider - Large Language Model Supply Service
+ *
+ * Provides LLM invocation capabilities to Drivers.
+ * This is a resource component managed by Runtime.
+ *
+ * ## Architecture Decision Record (ADR)
+ *
+ * ### Context
+ *
+ * AgentX separates "business components" from "resource components":
+ *
+ * - **Business Components**: Agent-specific logic (Driver, Presenter, Middleware)
+ * - **Resource Components**: Infrastructure capabilities (LLM, FileSystem, Process)
+ *
+ * LLM access (apiKey, baseUrl, model) is a resource that:
+ * 1. Should not be exposed to Agent business code
+ * 2. Can be shared across multiple Agents
+ * 3. May have different supply strategies (static, pooled, proxy)
+ * 4. Needs unified management (quota, billing, load balancing)
+ *
+ * ### Decision
+ *
+ * Create `LLMProvider` as a minimal generic interface:
+ *
+ * ```typescript
+ * interface LLMProvider<TSupply = unknown> {
+ *   readonly name: string;
+ *   provide(): TSupply;
+ * }
+ * ```
+ *
+ * - `name`: Provider identifier (for logging, debugging)
+ * - `provide()`: Returns whatever the Driver needs
+ * - `TSupply`: User-defined, can be anything (config, client, token, etc.)
+ *
+ * ### Usage
+ *
+ * ```typescript
+ * // User defines their own supply type
+ * interface MyLLMSupply {
+ *   apiKey: string;
+ *   baseUrl?: string;
+ * }
+ *
+ * // Create provider
+ * const provider: LLMProvider<MyLLMSupply> = {
+ *   name: "claude",
+ *   provide: () => ({
+ *     apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   }),
+ * };
+ *
+ * // Driver uses it
+ * const supply = runtime.llm.provide();
+ * ```
+ *
+ * ### Status
+ *
+ * **Accepted** - 2024-11-30
+ */
+/**
+ * LLMProvider - Large Language Model supply service
+ *
+ * @typeParam TSupply - User-defined supply type (config, client, token, etc.)
+ */
+interface LLMProvider<TSupply = unknown> {
+    /**
+     * Provider identifier
+     */
+    readonly name: string;
+    /**
+     * Provide LLM access
+     */
+    provide(): TSupply;
+}
+
+/**
+ * Receptor - Perceives the external world and emits to SystemBus
+ *
+ * From systems theory:
+ * - A receptor is a sensory component that detects stimuli from outside
+ * - It transforms external signals into events the system can process
+ *
+ * In our architecture:
+ * - Receptor perceives external world (LLM API, Network, etc.)
+ * - Emits events to SystemBus
+ *
+ * ```
+ *   External World
+ *        │
+ *        │ perceive
+ *        ▼
+ *    Receptor
+ *        │
+ *        │ emit
+ *        ▼
+ *    SystemBus
+ * ```
+ *
+ * @see issues/030-ecosystem-architecture.md
+ */
+
+/**
+ * Receptor - Perceives external world and emits events to SystemBus
+ */
+interface Receptor {
+    /**
+     * Connect to SystemBus producer to emit events
+     *
+     * Receptor only needs Producer (write-only) because it only emits events.
+     */
+    connect(producer: SystemBusProducer): void;
+}
+
+/**
+ * Effector - Listens to SystemBus and acts upon external world
+ *
+ * From systems theory:
+ * - An effector is a component that produces an effect on the environment
+ * - It transforms internal signals into external actions
+ *
+ * In our architecture:
+ * - Effector subscribes to SystemBus
+ * - Sends commands/events to external world (LLM API, Network, other systems)
+ *
+ * ```
+ *    SystemBus
+ *        │
+ *        │ subscribe
+ *        ▼
+ *    Effector
+ *        │
+ *        │ send
+ *        ▼
+ *   External World
+ * ```
+ *
+ * @see issues/030-ecosystem-architecture.md
+ */
+
+/**
+ * Effector - Subscribes to SystemBus and acts upon external world
+ */
+interface Effector {
+    /**
+     * Connect to SystemBus consumer to subscribe to events
+     *
+     * Effector only needs Consumer (read-only) because it only subscribes to events.
+     */
+    connect(consumer: SystemBusConsumer): void;
+}
+
+/**
+ * Environment - External world interface (Receptor + Effector)
+ *
+ * From systems theory:
+ * - Environment is everything outside the system boundary
+ * - Receptor perceives the environment (input)
+ * - Effector acts upon the environment (output)
+ *
+ * Environment combines both:
+ * - Perceives external world (Claude API, Network) → emits to SystemBus
+ * - Receives from SystemBus → sends to external world
+ *
+ * ```
+ *                    SystemBus
+ *                    ▲       │
+ *           emit     │       │ subscribe
+ *                    │       ▼
+ *              ┌─────┴───────────┐
+ *              │   Environment   │
+ *              │                 │
+ *              │  ┌───────────┐  │
+ *              │  │ Receptor  │──┼──► emit to bus
+ *              │  └───────────┘  │
+ *              │                 │
+ *              │  External World │
+ *              │  (Claude SDK)   │
+ *              │                 │
+ *              │  ┌───────────┐  │
+ *              │  │ Effector  │◄─┼── subscribe from bus
+ *              │  └───────────┘  │
+ *              └─────────────────┘
+ * ```
+ *
+ * Implementations:
+ * - ClaudeEnvironment: Claude SDK (Node.js)
+ * - RemoteEnvironment: Network SSE/WebSocket (Browser)
+ *
+ * @see issues/030-ecosystem-architecture.md
+ */
+
+/**
+ * Environment - External world interface
+ */
+interface Environment {
+    /**
+     * Environment name
+     */
+    readonly name: string;
+    /**
+     * Receptor - perceives external world, emits to SystemBus
+     */
+    readonly receptor: Receptor;
+    /**
+     * Effector - subscribes to SystemBus, acts on external world
+     */
+    readonly effector: Effector;
+}
+
+/**
+ * Session - Message collector and storage
+ *
+ * Session is responsible for:
+ * - Listening to messages from Agent/Bus
+ * - Persisting messages to storage
+ *
+ * Session is created per Image and stores the conversation history.
+ * In the Image-First model, Session persists across Agent restarts.
+ */
+
+/**
+ * Session - Collects and stores messages
+ */
+interface Session {
+    /**
+     * Unique session identifier
+     */
+    readonly sessionId: string;
+    /**
+     * Associated image ID (persistent conversation entity)
+     */
+    readonly imageId: string;
+    /**
+     * Associated container ID
+     */
+    readonly containerId: string;
+    /**
+     * Session creation timestamp (Unix ms)
+     */
+    readonly createdAt: number;
+    /**
+     * Add a message to the session
+     */
+    addMessage(message: Message): Promise<void>;
+    /**
+     * Get all messages
+     */
+    getMessages(): Promise<Message[]>;
+    /**
+     * Clear all messages
+     */
+    clear(): Promise<void>;
+}
+
+/**
+ * EventHandler - Event handler related types
+ *
+ * Types for the event handler system.
+ */
+
+/**
+ * Error context for error handling
+ *
+ * Provides context information when handling errors in event handlers.
+ */
+interface ErrorContext {
+    /**
+     * Event source that triggered the error
+     */
+    source?: EventSource;
+    /**
+     * Request ID (if error is related to a request)
+     */
+    requestId?: string;
+    /**
+     * Error severity
+     */
+    severity?: "info" | "warn" | "error" | "fatal";
+    /**
+     * Operation name (for logging and debugging)
+     */
+    operation?: string;
+    /**
+     * Additional error details
+     */
+    details?: Record<string, unknown>;
+    /**
+     * Optional callback to handle error (e.g., emit error response)
+     */
+    onError?: (err: unknown) => void;
+}
+
+export { ContainerRepository, type Effector, type Environment, type EnvironmentRecord, type ErrorContext, ImageRepository, type LLM, type LLMConfig, type LLMProvider, type LLMRequest, type LLMResponse, type McpPrompt, type McpProtocolVersion, type McpRequest, type McpResource, type McpServerInfo, type McpTool, type McpTransportConfig, type MessageRecord, type Receptor, type Repository, type Sandbox, type Session, SessionRepository, StopReason, type StreamChunk, SystemBusConsumer, SystemBusProducer, type TokenUsage, type Workdir };