@agentxjs/core 1.9.5-dev → 1.9.7-dev

package/dist/bus-uF1DM2ox.d.ts

@@ -0,0 +1,906 @@
+import { S as SystemEvent, B as BusEvent } from './base-m40r3Qgu.js';
+
+/**
+ * Command Events - API operations (request/response)
+ *
+ * Command events for the EventBus system.
+ */
+
+/**
+ * Text content part for user messages
+ */
+interface TextPart {
+    type: "text";
+    text: string;
+}
+/**
+ * Image content part for user messages
+ */
+interface ImagePart {
+    type: "image";
+    data: string;
+    mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+}
+/**
+ * File content part for user messages
+ */
+interface FilePart {
+    type: "file";
+    data: string;
+    filename: string;
+    mediaType: string;
+}
+/**
+ * User content part - content that users can send in messages
+ */
+type UserContentPart = TextPart | ImagePart | FilePart;
+/**
+ * AgentXResponse - Base interface for all command response data
+ *
+ * All command response data types should extend this interface
+ * to ensure consistent structure and enable automatic client-side handling.
+ */
+interface AgentXResponse {
+    /**
+     * Request ID for correlation and tracking
+     */
+    requestId: string;
+    /**
+     * Error message if the request failed
+     */
+    error?: string;
+    /**
+     * Session IDs that the client should subscribe to
+     */
+    __subscriptions?: string[];
+}
+/**
+ * MCP Server Configuration
+ */
+interface McpServerConfig {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+}
+/**
+ * Image metadata for storing provider-specific data
+ */
+interface ImageMetadata {
+    claudeSdkSessionId?: string;
+}
+/**
+ * Image storage record
+ */
+interface ImageRecord {
+    imageId: string;
+    containerId: string;
+    sessionId: string;
+    name: string;
+    description?: string;
+    systemPrompt?: string;
+    parentImageId?: string;
+    mcpServers?: Record<string, McpServerConfig>;
+    metadata?: ImageMetadata;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Image list item with online status
+ */
+interface ImageListItem extends ImageRecord {
+    /** Whether an agent is currently running for this image */
+    online: boolean;
+    /** Current agent ID if online */
+    agentId?: string;
+}
+/**
+ * Base interface for Command request events
+ */
+interface BaseCommandRequest<T extends string, D = unknown> extends SystemEvent<T, D, "command", "request", "request"> {
+}
+/**
+ * Base interface for Command response events
+ *
+ * All response data types must extend AgentXResponse to ensure:
+ * - Consistent structure (requestId, error)
+ * - Automatic client-side handling (__subscriptions, etc.)
+ */
+interface BaseCommandResponse<T extends string, D extends AgentXResponse = AgentXResponse> extends SystemEvent<T, D, "command", "response", "result"> {
+}
+/**
+ * Request to create a container
+ */
+interface ContainerCreateRequest extends BaseCommandRequest<"container_create_request", {
+    requestId: string;
+    containerId: string;
+}> {
+}
+/**
+ * Response to container creation
+ */
+interface ContainerCreateResponse extends BaseCommandResponse<"container_create_response", AgentXResponse & {
+    containerId: string;
+}> {
+}
+/**
+ * Request to get a container
+ */
+interface ContainerGetRequest extends BaseCommandRequest<"container_get_request", {
+    requestId: string;
+    containerId: string;
+}> {
+}
+/**
+ * Response to container get
+ */
+interface ContainerGetResponse extends BaseCommandResponse<"container_get_response", AgentXResponse & {
+    containerId?: string;
+    exists: boolean;
+}> {
+}
+/**
+ * Request to list containers
+ */
+interface ContainerListRequest extends BaseCommandRequest<"container_list_request", {
+    requestId: string;
+}> {
+}
+/**
+ * Response to container list
+ */
+interface ContainerListResponse extends BaseCommandResponse<"container_list_response", AgentXResponse & {
+    containerIds: string[];
+}> {
+}
+/**
+ * Request to get an agent
+ */
+interface AgentGetRequest extends BaseCommandRequest<"agent_get_request", {
+    requestId: string;
+    agentId: string;
+}> {
+}
+/**
+ * Response to agent get
+ */
+interface AgentGetResponse extends BaseCommandResponse<"agent_get_response", AgentXResponse & {
+    agentId?: string;
+    containerId?: string;
+    exists: boolean;
+}> {
+}
+/**
+ * Request to list agents
+ */
+interface AgentListRequest extends BaseCommandRequest<"agent_list_request", {
+    requestId: string;
+    containerId: string;
+}> {
+}
+/**
+ * Response to agent list
+ */
+interface AgentListResponse extends BaseCommandResponse<"agent_list_response", AgentXResponse & {
+    agents: Array<{
+        agentId: string;
+        containerId: string;
+        imageId: string;
+    }>;
+}> {
+}
+/**
+ * Request to destroy an agent
+ */
+interface AgentDestroyRequest extends BaseCommandRequest<"agent_destroy_request", {
+    requestId: string;
+    agentId: string;
+}> {
+}
+/**
+ * Response to agent destroy
+ */
+interface AgentDestroyResponse extends BaseCommandResponse<"agent_destroy_response", AgentXResponse & {
+    agentId: string;
+    success: boolean;
+}> {
+}
+/**
+ * Request to destroy all agents in a container
+ */
+interface AgentDestroyAllRequest extends BaseCommandRequest<"agent_destroy_all_request", {
+    requestId: string;
+    containerId: string;
+}> {
+}
+/**
+ * Response to destroy all agents
+ */
+interface AgentDestroyAllResponse extends BaseCommandResponse<"agent_destroy_all_response", AgentXResponse & {
+    containerId: string;
+}> {
+}
+/**
+ * Request to send a message
+ * Can use either imageId (preferred) or agentId
+ * If using imageId and agent is not running, it will be auto-activated
+ */
+interface MessageSendRequest extends BaseCommandRequest<"message_send_request", {
+    requestId: string;
+    /** Image ID (preferred) - will auto-activate if offline */
+    imageId?: string;
+    /** Agent ID (legacy) - must be already running */
+    agentId?: string;
+    /** Message content (text-only or multimodal) */
+    content: string | UserContentPart[];
+}> {
+}
+/**
+ * Response to message send (acknowledges message received, not completion)
+ */
+interface MessageSendResponse extends BaseCommandResponse<"message_send_response", AgentXResponse & {
+    imageId?: string;
+    agentId: string;
+}> {
+}
+/**
+ * Request to interrupt an agent
+ * Can use either imageId or agentId
+ */
+interface AgentInterruptRequest extends BaseCommandRequest<"agent_interrupt_request", {
+    requestId: string;
+    /** Image ID (preferred) */
+    imageId?: string;
+    /** Agent ID (legacy) */
+    agentId?: string;
+}> {
+}
+/**
+ * Response to agent interrupt
+ */
+interface AgentInterruptResponse extends BaseCommandResponse<"agent_interrupt_response", AgentXResponse & {
+    imageId?: string;
+    agentId?: string;
+}> {
+}
+/**
+ * Request to create a new image (conversation)
+ */
+interface ImageCreateRequest extends BaseCommandRequest<"image_create_request", {
+    requestId: string;
+    containerId: string;
+    config: {
+        name?: string;
+        description?: string;
+        systemPrompt?: string;
+    };
+}> {
+}
+/**
+ * Response to image creation
+ *
+ * Includes __subscriptions with the new image's sessionId for auto-subscription.
+ * Note: record is optional because it may be undefined on error.
+ */
+interface ImageCreateResponse extends BaseCommandResponse<"image_create_response", AgentXResponse & {
+    record?: ImageRecord;
+}> {
+}
+/**
+ * Request to run an image (create or reuse agent)
+ */
+interface ImageRunRequest extends BaseCommandRequest<"image_run_request", {
+    requestId: string;
+    imageId: string;
+}> {
+}
+/**
+ * Response to image run
+ */
+interface ImageRunResponse extends BaseCommandResponse<"image_run_response", AgentXResponse & {
+    imageId: string;
+    agentId: string;
+    /** true if reusing existing agent, false if newly created */
+    reused: boolean;
+}> {
+}
+/**
+ * Request to stop an image (destroy agent, keep image)
+ */
+interface ImageStopRequest extends BaseCommandRequest<"image_stop_request", {
+    requestId: string;
+    imageId: string;
+}> {
+}
+/**
+ * Response to image stop
+ */
+interface ImageStopResponse extends BaseCommandResponse<"image_stop_response", AgentXResponse & {
+    imageId: string;
+}> {
+}
+/**
+ * Request to update an image (name, description, etc.)
+ */
+interface ImageUpdateRequest extends BaseCommandRequest<"image_update_request", {
+    requestId: string;
+    imageId: string;
+    updates: {
+        name?: string;
+        description?: string;
+    };
+}> {
+}
+/**
+ * Response to image update
+ *
+ * Note: record is optional because it may be undefined on error.
+ */
+interface ImageUpdateResponse extends BaseCommandResponse<"image_update_response", AgentXResponse & {
+    record?: ImageRecord;
+}> {
+}
+/**
+ * Request to list all images
+ */
+interface ImageListRequest extends BaseCommandRequest<"image_list_request", {
+    requestId: string;
+    containerId?: string;
+}> {
+}
+/**
+ * Response to image list
+ *
+ * Includes __subscriptions with all images' sessionIds for auto-subscription.
+ */
+interface ImageListResponse extends BaseCommandResponse<"image_list_response", AgentXResponse & {
+    records: ImageListItem[];
+}> {
+}
+/**
+ * Request to get an image by ID
+ */
+interface ImageGetRequest extends BaseCommandRequest<"image_get_request", {
+    requestId: string;
+    imageId: string;
+}> {
+}
+/**
+ * Response to image get
+ *
+ * Includes __subscriptions with the image's sessionId for auto-subscription.
+ */
+interface ImageGetResponse extends BaseCommandResponse<"image_get_response", AgentXResponse & {
+    record?: ImageListItem | null;
+}> {
+}
+/**
+ * Request to delete an image
+ */
+interface ImageDeleteRequest extends BaseCommandRequest<"image_delete_request", {
+    requestId: string;
+    imageId: string;
+}> {
+}
+/**
+ * Response to image delete
+ */
+interface ImageDeleteResponse extends BaseCommandResponse<"image_delete_response", AgentXResponse & {
+    imageId: string;
+}> {
+}
+/**
+ * Request to get messages for an image
+ */
+interface ImageMessagesRequest extends BaseCommandRequest<"image_messages_request", {
+    requestId: string;
+    imageId: string;
+}> {
+}
+/**
+ * Response to image messages request
+ */
+interface ImageMessagesResponse extends BaseCommandResponse<"image_messages_response", AgentXResponse & {
+    imageId: string;
+    messages: Array<{
+        id: string;
+        role: "user" | "assistant" | "tool_call" | "tool_result";
+        content: unknown;
+        timestamp: number;
+    }>;
+}> {
+}
+/**
+ * All Command request events
+ */
+type CommandRequest = ContainerCreateRequest | ContainerGetRequest | ContainerListRequest | AgentGetRequest | AgentListRequest | AgentDestroyRequest | AgentDestroyAllRequest | MessageSendRequest | AgentInterruptRequest | ImageCreateRequest | ImageRunRequest | ImageStopRequest | ImageUpdateRequest | ImageListRequest | ImageGetRequest | ImageDeleteRequest | ImageMessagesRequest;
+/**
+ * All Command response events
+ */
+type CommandResponse = ContainerCreateResponse | ContainerGetResponse | ContainerListResponse | AgentGetResponse | AgentListResponse | AgentDestroyResponse | AgentDestroyAllResponse | MessageSendResponse | AgentInterruptResponse | ImageCreateResponse | ImageRunResponse | ImageStopResponse | ImageUpdateResponse | ImageListResponse | ImageGetResponse | ImageDeleteResponse | ImageMessagesResponse;
+/**
+ * All Command events (requests + responses)
+ */
+type CommandEvent = CommandRequest | CommandResponse;
+/**
+ * Command event type strings
+ */
+type CommandEventType = CommandEvent["type"];
+/**
+ * Type guard: is this a CommandEvent?
+ */
+declare function isCommandEvent(event: {
+    source?: string;
+}): event is CommandEvent;
+/**
+ * Type guard: is this a Command request event?
+ */
+declare function isCommandRequest(event: {
+    source?: string;
+    category?: string;
+}): event is CommandRequest;
+/**
+ * Type guard: is this a Command response event?
+ */
+declare function isCommandResponse(event: {
+    source?: string;
+    category?: string;
+}): event is CommandResponse;
+/**
+ * CommandEventMap - Maps event type string to event interface
+ *
+ * Enables type-safe event handling:
+ * ```typescript
+ * bus.onCommand("container_create_request", (event) => {
+ *   event.data.requestId;    // string
+ *   event.data.containerId;  // string
+ * });
+ * ```
+ */
+interface CommandEventMap {
+    container_create_request: ContainerCreateRequest;
+    container_create_response: ContainerCreateResponse;
+    container_get_request: ContainerGetRequest;
+    container_get_response: ContainerGetResponse;
+    container_list_request: ContainerListRequest;
+    container_list_response: ContainerListResponse;
+    agent_get_request: AgentGetRequest;
+    agent_get_response: AgentGetResponse;
+    agent_list_request: AgentListRequest;
+    agent_list_response: AgentListResponse;
+    agent_destroy_request: AgentDestroyRequest;
+    agent_destroy_response: AgentDestroyResponse;
+    agent_destroy_all_request: AgentDestroyAllRequest;
+    agent_destroy_all_response: AgentDestroyAllResponse;
+    message_send_request: MessageSendRequest;
+    message_send_response: MessageSendResponse;
+    agent_interrupt_request: AgentInterruptRequest;
+    agent_interrupt_response: AgentInterruptResponse;
+    image_create_request: ImageCreateRequest;
+    image_create_response: ImageCreateResponse;
+    image_run_request: ImageRunRequest;
+    image_run_response: ImageRunResponse;
+    image_stop_request: ImageStopRequest;
+    image_stop_response: ImageStopResponse;
+    image_update_request: ImageUpdateRequest;
+    image_update_response: ImageUpdateResponse;
+    image_list_request: ImageListRequest;
+    image_list_response: ImageListResponse;
+    image_get_request: ImageGetRequest;
+    image_get_response: ImageGetResponse;
+    image_delete_request: ImageDeleteRequest;
+    image_delete_response: ImageDeleteResponse;
+    image_messages_request: ImageMessagesRequest;
+    image_messages_response: ImageMessagesResponse;
+}
+/**
+ * Maps request event type to its corresponding response event type
+ */
+interface CommandRequestResponseMap {
+    container_create_request: "container_create_response";
+    container_get_request: "container_get_response";
+    container_list_request: "container_list_response";
+    agent_get_request: "agent_get_response";
+    agent_list_request: "agent_list_response";
+    agent_destroy_request: "agent_destroy_response";
+    agent_destroy_all_request: "agent_destroy_all_response";
+    message_send_request: "message_send_response";
+    agent_interrupt_request: "agent_interrupt_response";
+    image_create_request: "image_create_response";
+    image_run_request: "image_run_response";
+    image_stop_request: "image_stop_response";
+    image_update_request: "image_update_response";
+    image_list_request: "image_list_response";
+    image_get_request: "image_get_response";
+    image_delete_request: "image_delete_response";
+    image_messages_request: "image_messages_response";
+}
+/**
+ * All command request types
+ */
+type CommandRequestType = keyof CommandRequestResponseMap;
+/**
+ * Get response type for a request type
+ */
+type ResponseTypeFor<T extends CommandRequestType> = CommandRequestResponseMap[T];
+/**
+ * Get response event for a request type
+ */
+type ResponseEventFor<T extends CommandRequestType> = CommandEventMap[ResponseTypeFor<T>];
+/**
+ * Get request data type (without requestId, as it's auto-generated)
+ */
+type RequestDataFor<T extends CommandRequestType> = Omit<CommandEventMap[T]["data"], "requestId">;
+
+/**
+ * EventBus Interfaces - EventBus, EventProducer, EventConsumer
+ *
+ * Central event bus interfaces for ecosystem communication.
+ */
+
+/**
+ * Unsubscribe function type
+ */
+type Unsubscribe = () => void;
+/**
+ * Event handler function type
+ */
+type BusEventHandler<E extends BusEvent = BusEvent> = (event: E) => void;
+/**
+ * Subscription options for advanced event handling
+ */
+interface SubscribeOptions<E extends BusEvent = BusEvent> {
+    /**
+     * Event filter - only events returning true will trigger the handler
+     * Useful for filtering by agentId, sessionId, etc.
+     */
+    filter?: (event: E) => boolean;
+    /**
+     * Priority - higher numbers execute first (default: 0)
+     * Useful for ensuring certain handlers run before others
+     */
+    priority?: number;
+    /**
+     * Whether to trigger only once then auto-unsubscribe
+     */
+    once?: boolean;
+}
+/**
+ * EventProducer interface - Write-only view
+ *
+ * Used by components that produce events:
+ * - Effector (emits DriveableEvents from Claude API)
+ * - Receptor (emits stream events)
+ * - Agent (emits state/message events)
+ *
+ * Producer can only emit events, cannot subscribe.
+ * This prevents accidental event loops and clarifies data flow.
+ *
+ * @example
+ * ```typescript
+ * class Effector {
+ *   constructor(private producer: EventProducer) {}
+ *
+ *   async sendMessage(message: UserMessage) {
+ *     // Can only emit, cannot subscribe
+ *     this.producer.emit({
+ *       type: "message_start",
+ *       timestamp: Date.now(),
+ *       data: { messageId: "msg-1", model: "claude" },
+ *     });
+ *   }
+ * }
+ * ```
+ */
+interface EventProducer {
+    /**
+     * Emit a single event to the bus
+     *
+     * @param event - The event to emit
+     */
+    emit(event: BusEvent): void;
+    /**
+     * Emit multiple events (batch operation)
+     *
+     * @param events - Array of events to emit
+     */
+    emitBatch(events: BusEvent[]): void;
+    /**
+     * Emit a typed command event
+     *
+     * @param type - The command event type
+     * @param data - Event data (type-checked)
+     */
+    emitCommand<T extends keyof CommandEventMap>(type: T, data: CommandEventMap[T]["data"]): void;
+}
+/**
+ * EventConsumer interface - Read-only view
+ *
+ * Used by components that consume events:
+ * - BusDriver (subscribes to DriveableEvents)
+ * - UI components (subscribes to display events)
+ * - Presenters (subscribes to forward events)
+ *
+ * Consumer can only subscribe to events, cannot emit.
+ * This prevents accidental event emission and clarifies data flow.
+ *
+ * @example
+ * ```typescript
+ * class BusDriver {
+ *   constructor(private consumer: EventConsumer) {}
+ *
+ *   async *receive(message: UserMessage) {
+ *     // Can only subscribe, cannot emit
+ *     this.consumer.on('message_start', (event) => {
+ *       console.log('Received:', event.type);
+ *     });
+ *   }
+ * }
+ * ```
+ */
+interface EventConsumer {
+    /**
+     * Subscribe to a specific event type
+     *
+     * @param type - The event type to listen for
+     * @param handler - Callback invoked when event is received
+     * @param options - Subscription options (filter, priority, once)
+     * @returns Unsubscribe function
+     */
+    on<T extends string>(type: T, handler: BusEventHandler<BusEvent & {
+        type: T;
+    }>, options?: SubscribeOptions<BusEvent & {
+        type: T;
+    }>): Unsubscribe;
+    /**
+     * Subscribe to multiple event types
+     *
+     * @param types - Array of event types to listen for
+     * @param handler - Callback invoked when any matching event is received
+     * @param options - Subscription options
+     * @returns Unsubscribe function
+     */
+    on(types: string[], handler: BusEventHandler, options?: SubscribeOptions): Unsubscribe;
+    /**
+     * Subscribe to all events
+     *
+     * @param handler - Callback invoked for every event
+     * @param options - Subscription options
+     * @returns Unsubscribe function
+     */
+    onAny(handler: BusEventHandler, options?: SubscribeOptions): Unsubscribe;
+    /**
+     * Subscribe to an event type once (auto-unsubscribes after first trigger)
+     *
+     * @param type - Event type to subscribe to
+     * @param handler - Callback function
+     * @returns Unsubscribe function
+     */
+    once<T extends string>(type: T, handler: BusEventHandler<BusEvent & {
+        type: T;
+    }>): Unsubscribe;
+    /**
+     * Subscribe to a CommandEvent with full type safety
+     *
+     * @example
+     * ```typescript
+     * consumer.onCommand("container_create_request", (event) => {
+     *   event.data.requestId;    // string
+     *   event.data.containerId;  // string
+     * });
+     * ```
+     *
+     * @param type - The command event type
+     * @param handler - Callback with fully typed event
+     * @returns Unsubscribe function
+     */
+    onCommand<T extends keyof CommandEventMap>(type: T, handler: (event: CommandEventMap[T]) => void): Unsubscribe;
+    /**
+     * Send a command request and wait for response
+     *
+     * Automatically generates requestId, emits request, waits for matching response.
+     *
+     * @example
+     * ```typescript
+     * const response = await consumer.request("container_create_request", {
+     *   containerId: "my-container"
+     * });
+     * // response is ContainerCreateResponse
+     * console.log(response.data.containerId);
+     * ```
+     *
+     * @param type - The request event type
+     * @param data - Request data (without requestId)
+     * @param timeout - Timeout in milliseconds (default: 30000)
+     * @returns Promise of response event
+     */
+    request<T extends CommandRequestType>(type: T, data: RequestDataFor<T>, timeout?: number): Promise<ResponseEventFor<T>>;
+}
+/**
+ * EventBus interface - Central event bus for ecosystem communication.
+ *
+ * Extends both Producer and Consumer interfaces for internal use.
+ * External components should use restricted views via asProducer/asConsumer.
+ *
+ * @example
+ * ```typescript
+ * const bus = new EventBus();
+ *
+ * // Subscribe to specific event type
+ * bus.on('text_chunk', (e) => {
+ *   console.log('Received text:', e.data.text);
+ * });
+ *
+ * // Subscribe with options
+ * bus.on('text_delta', handler, {
+ *   filter: (e) => e.agentId === 'agent-1',
+ *   priority: 10,
+ *   once: true
+ * });
+ *
+ * // Subscribe to all events
+ * bus.onAny((e) => {
+ *   console.log('Event:', e.type);
+ * });
+ *
+ * // Emit event
+ * bus.emit({ type: 'text_chunk', data: { text: 'Hello' } });
+ * ```
+ */
+interface EventBus {
+    /**
+     * Emit an event to the bus.
+     *
+     * All subscribed handlers will receive this event.
+     *
+     * @param event - The event to emit
+     */
+    emit(event: BusEvent): void;
+    /**
+     * Emit multiple events (batch operation).
+     *
+     * @param events - Array of events to emit
+     */
+    emitBatch(events: BusEvent[]): void;
+    /**
+     * Subscribe to a specific event type.
+     *
+     * @param type - The event type to listen for
+     * @param handler - Callback invoked when event is received
+     * @param options - Subscription options (filter, priority, once)
+     * @returns Unsubscribe function
+     */
+    on<T extends string>(type: T, handler: BusEventHandler<BusEvent & {
+        type: T;
+    }>, options?: SubscribeOptions<BusEvent & {
+        type: T;
+    }>): Unsubscribe;
+    /**
+     * Subscribe to multiple event types.
+     *
+     * @param types - Array of event types to listen for
+     * @param handler - Callback invoked when any matching event is received
+     * @param options - Subscription options
+     * @returns Unsubscribe function
+     */
+    on(types: string[], handler: BusEventHandler, options?: SubscribeOptions): Unsubscribe;
+    /**
+     * Subscribe to all events.
+     *
+     * @param handler - Callback invoked for every event
+     * @param options - Subscription options
+     * @returns Unsubscribe function
+     */
+    onAny(handler: BusEventHandler, options?: SubscribeOptions): Unsubscribe;
+    /**
+     * Subscribe to an event type once (auto-unsubscribes after first trigger).
+     *
+     * @param type - Event type to subscribe to
+     * @param handler - Callback function
+     * @returns Unsubscribe function
+     */
+    once<T extends string>(type: T, handler: BusEventHandler<BusEvent & {
+        type: T;
+    }>): Unsubscribe;
+    /**
+     * Subscribe to a CommandEvent with full type safety.
+     *
+     * @example
+     * ```typescript
+     * bus.onCommand("container_create_request", (event) => {
+     *   event.data.requestId;    // string
+     *   event.data.containerId;  // string
+     * });
+     * ```
+     *
+     * @param type - The command event type
+     * @param handler - Callback with fully typed event
+     * @returns Unsubscribe function
+     */
+    onCommand<T extends keyof CommandEventMap>(type: T, handler: (event: CommandEventMap[T]) => void): Unsubscribe;
+    /**
+     * Emit a CommandEvent with full type safety.
+     *
+     * @example
+     * ```typescript
+     * bus.emitCommand("container_create_request", {
+     *   requestId: "req_123",
+     *   containerId: "my-container"
+     * });
+     * ```
+     *
+     * @param type - The command event type
+     * @param data - Event data (type-checked)
+     */
+    emitCommand<T extends keyof CommandEventMap>(type: T, data: CommandEventMap[T]["data"]): void;
+    /**
+     * Send a command request and wait for response.
+     *
+     * Automatically generates requestId, emits request, waits for matching response.
+     *
+     * @example
+     * ```typescript
+     * const response = await bus.request("container_create_request", {
+     *   containerId: "my-container"
+     * });
+     * // response is ContainerCreateResponse
+     * console.log(response.data.containerId);
+     * ```
+     *
+     * @param type - The request event type
+     * @param data - Request data (without requestId)
+     * @param timeout - Timeout in milliseconds (default: 30000)
+     * @returns Promise of response event
+     */
+    request<T extends CommandRequestType>(type: T, data: RequestDataFor<T>, timeout?: number): Promise<ResponseEventFor<T>>;
+    /**
+     * Get a read-only consumer view of the bus.
+     *
+     * Use this to safely expose event subscription to external code
+     * without allowing them to emit events.
+     *
+     * @example
+     * ```typescript
+     * class BusDriver {
+     *   constructor(consumer: EventConsumer) {
+     *     // Can only subscribe, cannot emit
+     *     consumer.on('text_delta', ...);
+     *   }
+     * }
+     * ```
+     *
+     * @returns EventConsumer - Read-only view
+     */
+    asConsumer(): EventConsumer;
+    /**
+     * Get a write-only producer view of the bus.
+     *
+     * Use this to give components the ability to emit events
+     * without exposing subscription capabilities.
+     *
+     * @example
+     * ```typescript
+     * class ClaudeReceptor {
+     *   constructor(producer: EventProducer) {
+     *     // Can only emit, cannot subscribe
+     *     producer.emit({ type: 'text_delta', ... });
+     *   }
+     * }
+     * ```
+     *
+     * @returns EventProducer - Write-only view
+     */
+    asProducer(): EventProducer;
+    /**
+     * Destroy the bus and clean up resources.
+     *
+     * All subscriptions will be terminated.
+     * After calling destroy():
+     * - All subscriptions are removed
+     * - New emissions are ignored
+     * - New subscriptions are no-ops
+     */
+    destroy(): void;
+}
+
+export { type CommandRequest as $, type AgentXResponse as A, type BusEventHandler as B, type CommandEventMap as C, type ImageCreateRequest as D, type EventBus as E, type FilePart as F, type ImageCreateResponse as G, type ImageRunRequest as H, type ImagePart as I, type ImageRunResponse as J, type ImageStopRequest as K, type ImageStopResponse as L, type McpServerConfig as M, type ImageUpdateRequest as N, type ImageUpdateResponse as O, type ImageListRequest as P, type ImageListResponse as Q, type RequestDataFor as R, type SubscribeOptions as S, type TextPart as T, type Unsubscribe as U, type ImageGetRequest as V, type ImageGetResponse as W, type ImageDeleteRequest as X, type ImageDeleteResponse as Y, type ImageMessagesRequest as Z, type ImageMessagesResponse as _, type CommandRequestType as a, type CommandResponse as a0, type CommandEvent as a1, type CommandEventType as a2, isCommandEvent as a3, isCommandRequest as a4, isCommandResponse as a5, type CommandRequestResponseMap as a6, type ResponseTypeFor as a7, type ResponseEventFor as b, type EventConsumer as c, type EventProducer as d, type UserContentPart as e, type ImageMetadata as f, type ImageRecord as g, type ImageListItem as h, type ContainerCreateRequest as i, type ContainerCreateResponse as j, type ContainerGetRequest as k, type ContainerGetResponse as l, type ContainerListRequest as m, type ContainerListResponse as n, type AgentGetRequest as o, type AgentGetResponse as p, type AgentListRequest as q, type AgentListResponse as r, type AgentDestroyRequest as s, type AgentDestroyResponse as t, type AgentDestroyAllRequest as u, type AgentDestroyAllResponse as v, type MessageSendRequest as w, type MessageSendResponse as x, type AgentInterruptRequest as y, type AgentInterruptResponse as z };