@agentxjs/core 1.9.5-dev → 1.9.6-dev

package/dist/event/types/index.d.ts

@@ -0,0 +1,1149 @@
+import { S as SystemEvent, c as EventContext } from '../../base-m40r3Qgu.js';
+export { B as BusEvent, b as EventCategory, a as EventIntent, E as EventSource, h as hasIntent, i as isFromSource, f as isNotification, d as isRequest, e as isResult } from '../../base-m40r3Qgu.js';
+export { u as AgentDestroyAllRequest, v as AgentDestroyAllResponse, s as AgentDestroyRequest, t as AgentDestroyResponse, o as AgentGetRequest, p as AgentGetResponse, y as AgentInterruptRequest, z as AgentInterruptResponse, q as AgentListRequest, r as AgentListResponse, A as AgentXResponse, B as BusEventHandler, a1 as CommandEvent, C as CommandEventMap, a2 as CommandEventType, $ as CommandRequest, a6 as CommandRequestResponseMap, a as CommandRequestType, a0 as CommandResponse, i as ContainerCreateRequest, j as ContainerCreateResponse, k as ContainerGetRequest, l as ContainerGetResponse, m as ContainerListRequest, n as ContainerListResponse, E as EventBus, c as EventConsumer, d as EventProducer, F as FilePart, D as ImageCreateRequest, G as ImageCreateResponse, X as ImageDeleteRequest, Y as ImageDeleteResponse, V as ImageGetRequest, W as ImageGetResponse, h as ImageListItem, P as ImageListRequest, Q as ImageListResponse, Z as ImageMessagesRequest, _ as ImageMessagesResponse, f as ImageMetadata, I as ImagePart, g as ImageRecord, H as ImageRunRequest, J as ImageRunResponse, K as ImageStopRequest, L as ImageStopResponse, N as ImageUpdateRequest, O as ImageUpdateResponse, M as McpServerConfig, w as MessageSendRequest, x as MessageSendResponse, R as RequestDataFor, b as ResponseEventFor, a7 as ResponseTypeFor, S as SubscribeOptions, T as TextPart, U as Unsubscribe, e as UserContentPart, a3 as isCommandEvent, a4 as isCommandRequest, a5 as isCommandResponse } from '../../bus-uF1DM2ox.js';
+import { U as UserMessage, A as AssistantMessage, T as ToolCallMessage, a as ToolResultMessage, E as ErrorMessage } from '../../message-BMrMm1pq.js';
+
+/**
+ * Environment Events - External world events (LLM API, Network)
+ *
+ * DriveableEvent, ConnectionEvent, StopReason, ErrorEvent
+ */
+
+/**
+ * Reason why the LLM stopped generating
+ *
+ * Based on common stop reasons across multiple LLM providers:
+ * - Anthropic Claude: end_turn, max_tokens, tool_use, stop_sequence
+ * - OpenAI: stop, length, tool_calls, content_filter
+ * - Vercel AI SDK: stop, length, tool-calls, content-filter, error, other
+ */
+type StopReason = 
+/**
+ * Natural completion - model decided to stop
+ */
+"end_turn"
+/**
+ * Reached maximum token limit
+ */
+ | "max_tokens"
+/**
+ * Model requested tool usage
+ */
+ | "tool_use"
+/**
+ * Encountered a custom stop sequence
+ */
+ | "stop_sequence"
+/**
+ * Content filter triggered
+ */
+ | "content_filter"
+/**
+ * Error occurred during generation
+ */
+ | "error"
+/**
+ * Other/unknown reason
+ */
+ | "other";
+/**
+ * Type guard to check if a string is a valid StopReason
+ */
+declare function isStopReason(value: string): value is StopReason;
+/**
+ * Base interface for all LLM stream events (DriveableEvent)
+ *
+ * All DriveableEvents have:
+ * - source: "driver" (from LLM Driver)
+ * - category: "stream" (streaming output)
+ * - intent: "notification" (informational, no action needed)
+ * - requestId: correlation with the original request
+ * - context: agent/image/session scope (inherited from SystemEvent)
+ */
+interface BaseStreamEvent<T extends string, D = unknown> extends SystemEvent<T, D, "driver", "stream", "notification"> {
+    /**
+     * Content block index (for multi-block responses)
+     */
+    index?: number;
+    /**
+     * Request ID for correlating events with the original message_send_request
+     */
+    requestId?: string;
+}
+/**
+ * MessageStartEvent - Emitted when streaming message begins
+ */
+interface MessageStartEvent extends BaseStreamEvent<"message_start", {
+    message: {
+        id: string;
+        model: string;
+    };
+}> {
+}
+/**
+ * MessageDeltaEvent - Emitted with message-level updates
+ */
+interface MessageDeltaEvent extends BaseStreamEvent<"message_delta", {
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}> {
+}
+/**
+ * MessageStopEvent - Emitted when streaming message completes
+ */
+interface MessageStopEvent extends BaseStreamEvent<"message_stop", {
+    stopReason?: StopReason;
+    stopSequence?: string;
+}> {
+}
+/**
+ * TextContentBlockStartEvent - Text block started
+ */
+interface TextContentBlockStartEvent extends BaseStreamEvent<"text_content_block_start", Record<string, never>> {
+    index: number;
+}
+/**
+ * TextDeltaEvent - Incremental text output
+ */
+interface TextDeltaEvent extends BaseStreamEvent<"text_delta", {
+    text: string;
+}> {
+}
+/**
+ * TextContentBlockStopEvent - Text block completed
+ */
+interface TextContentBlockStopEvent extends BaseStreamEvent<"text_content_block_stop", Record<string, never>> {
+    index: number;
+}
+/**
+ * ToolUseContentBlockStartEvent - Tool use block started
+ */
+interface ToolUseContentBlockStartEvent extends BaseStreamEvent<"tool_use_content_block_start", {
+    id: string;
+    name: string;
+}> {
+    index: number;
+}
+/**
+ * InputJsonDeltaEvent - Incremental tool input JSON
+ */
+interface InputJsonDeltaEvent extends BaseStreamEvent<"input_json_delta", {
+    partialJson: string;
+}> {
+    index: number;
+}
+/**
+ * ToolUseContentBlockStopEvent - Tool use block completed
+ */
+interface ToolUseContentBlockStopEvent extends BaseStreamEvent<"tool_use_content_block_stop", Record<string, never>> {
+    index: number;
+}
+/**
+ * ToolCallEvent - Tool call ready for execution
+ */
+interface ToolCallEvent extends BaseStreamEvent<"tool_call", {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}> {
+}
+/**
+ * ToolResultEvent - Tool execution result
+ */
+interface ToolResultEvent extends BaseStreamEvent<"tool_result", {
+    toolUseId: string;
+    result: unknown;
+    isError?: boolean;
+}> {
+}
+/**
+ * InterruptedEvent - Stream interrupted
+ */
+interface InterruptedEvent extends BaseStreamEvent<"interrupted", {
+    reason: "user_interrupt" | "timeout" | "error" | "system";
+}> {
+}
+/**
+ * ErrorReceivedEvent - Error received from environment (e.g., Claude API error)
+ *
+ * This event drives the MealyMachine to produce:
+ * - error_occurred (StateEvent) -> state transitions to "error"
+ * - error_message (MessageEvent) -> displayed in chat
+ */
+interface ErrorReceivedEvent extends BaseStreamEvent<"error_received", {
+    /** Error message (human-readable) */
+    message: string;
+    /** Error code (e.g., "rate_limit_error", "api_error", "overloaded_error") */
+    errorCode?: string;
+}> {
+}
+/**
+ * DriveableEvent - All events that can drive Agent
+ */
+type DriveableEvent = MessageStartEvent | MessageDeltaEvent | MessageStopEvent | TextContentBlockStartEvent | TextDeltaEvent | TextContentBlockStopEvent | ToolUseContentBlockStartEvent | InputJsonDeltaEvent | ToolUseContentBlockStopEvent | ToolCallEvent | ToolResultEvent | InterruptedEvent | ErrorReceivedEvent;
+/**
+ * DriveableEventType - String literal union of all driveable event types
+ */
+type DriveableEventType = DriveableEvent["type"];
+/**
+ * Type guard: is this a DriveableEvent?
+ */
+declare function isDriveableEvent(event: {
+    source?: string;
+    category?: string;
+}): event is DriveableEvent;
+/**
+ * Base interface for all connection events
+ */
+interface BaseConnectionEvent<T extends string, D = unknown> extends SystemEvent<T, D, "driver", "connection", "notification"> {
+}
+/**
+ * ConnectedEvent - Connection established
+ */
+interface ConnectedEvent extends BaseConnectionEvent<"connected", {
+    url?: string;
+    reconnectAttempt?: number;
+}> {
+}
+/**
+ * DisconnectedEvent - Connection lost
+ */
+interface DisconnectedEvent extends BaseConnectionEvent<"disconnected", {
+    reason?: string;
+    code?: number;
+    willReconnect?: boolean;
+}> {
+}
+/**
+ * ReconnectingEvent - Attempting to reconnect
+ */
+interface ReconnectingEvent extends BaseConnectionEvent<"reconnecting", {
+    attempt: number;
+    maxAttempts?: number;
+    delayMs: number;
+}> {
+}
+/**
+ * ConnectionEvent - All network status events
+ */
+type ConnectionEvent = ConnectedEvent | DisconnectedEvent | ReconnectingEvent;
+/**
+ * ConnectionEventType - String literal union
+ */
+type ConnectionEventType = ConnectionEvent["type"];
+/**
+ * Type guard: is this a ConnectionEvent?
+ */
+declare function isConnectionEvent(event: {
+    source?: string;
+    category?: string;
+}): event is ConnectionEvent;
+/**
+ * EnvironmentEvent - Union of all environment events
+ */
+type EnvironmentEvent = DriveableEvent | ConnectionEvent;
+/**
+ * SystemError - Generic error event
+ *
+ * Used for all errors until we create specific error types.
+ * Can originate from any source (runtime, agent, container, etc.)
+ *
+ * @example
+ * ```typescript
+ * const error: SystemError = {
+ *   type: "system_error",
+ *   timestamp: Date.now(),
+ *   source: "container",
+ *   category: "error",
+ *   intent: "notification",
+ *   data: {
+ *     message: "Container not found: default",
+ *     requestId: "req_123",
+ *     severity: "error",
+ *   },
+ *   context: { containerId: "default" }
+ * };
+ * ```
+ */
+interface SystemError extends SystemEvent<"system_error", {
+    /**
+     * Error message (human-readable)
+     */
+    message: string;
+    /**
+     * Associated request ID (if error is related to a request)
+     */
+    requestId?: string;
+    /**
+     * Error severity
+     * - info: Informational, no action needed
+     * - warn: Warning, operation succeeded but with issues
+     * - error: Error, operation failed
+     * - fatal: Fatal error, system unstable
+     */
+    severity?: "info" | "warn" | "error" | "fatal";
+    /**
+     * Additional error details (stack trace, error code, etc.)
+     */
+    details?: unknown;
+}, "agent" | "container" | "driver" | "session" | "sandbox" | "command", "error", "notification"> {
+}
+/**
+ * Error event map - will grow as we add specific error types
+ */
+interface ErrorEventMap {
+    system_error: SystemError;
+}
+/**
+ * Error event types
+ */
+type ErrorEventType = keyof ErrorEventMap;
+/**
+ * Union of all error events
+ */
+type ErrorEvent = ErrorEventMap[ErrorEventType];
+
+/**
+ * Agent Events - Events from Agent domain (stream/state/message/turn)
+ *
+ * Agent events for the EventBus system.
+ */
+
+/**
+ * Agent event categories
+ */
+type AgentEventCategory = "stream" | "state" | "message" | "turn";
+/**
+ * BaseAgentEvent - Base interface for all Agent events
+ *
+ * Extends SystemEvent with fixed source and intent.
+ */
+interface BaseAgentEvent<T extends string, D, C extends AgentEventCategory> extends SystemEvent<T, D, "agent", C, "notification"> {
+    /**
+     * Runtime context (optional, added by Presenter)
+     */
+    readonly context?: EventContext;
+}
+/**
+ * Base type for agent stream events
+ */
+interface AgentStreamEventBase<T extends string, D> extends BaseAgentEvent<T, D, "stream"> {
+}
+type AgentStopReason = StopReason;
+/**
+ * AgentMessageStartEvent - Streaming message begins
+ */
+interface AgentMessageStartEvent extends AgentStreamEventBase<"message_start", {
+    messageId: string;
+    model: string;
+}> {
+}
+/**
+ * AgentMessageDeltaEvent - Message-level updates (usage info)
+ */
+interface AgentMessageDeltaEvent extends AgentStreamEventBase<"message_delta", {
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}> {
+}
+/**
+ * AgentMessageStopEvent - Streaming message completes
+ */
+interface AgentMessageStopEvent extends AgentStreamEventBase<"message_stop", {
+    stopReason?: StopReason;
+}> {
+}
+/**
+ * AgentTextDeltaEvent - Incremental text output
+ */
+interface AgentTextDeltaEvent extends AgentStreamEventBase<"text_delta", {
+    text: string;
+}> {
+}
+/**
+ * AgentToolUseStartEvent - Tool use block started
+ */
+interface AgentToolUseStartEvent extends AgentStreamEventBase<"tool_use_start", {
+    toolCallId: string;
+    toolName: string;
+}> {
+}
+/**
+ * AgentInputJsonDeltaEvent - Incremental tool input JSON
+ */
+interface AgentInputJsonDeltaEvent extends AgentStreamEventBase<"input_json_delta", {
+    partialJson: string;
+}> {
+}
+/**
+ * AgentToolUseStopEvent - Tool use block completed
+ */
+interface AgentToolUseStopEvent extends AgentStreamEventBase<"tool_use_stop", {
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+}> {
+}
+/**
+ * AgentToolResultEvent - Tool execution result
+ */
+interface AgentToolResultEvent extends AgentStreamEventBase<"tool_result", {
+    toolCallId: string;
+    result: unknown;
+    isError?: boolean;
+}> {
+}
+/**
+ * AgentErrorReceivedEvent - Error received from environment
+ *
+ * Processed by MealyMachine to produce:
+ * - error_occurred (StateEvent)
+ * - error_message (MessageEvent)
+ */
+interface AgentErrorReceivedEvent extends AgentStreamEventBase<"error_received", {
+    /** Error message (human-readable) */
+    message: string;
+    /** Error code (e.g., "rate_limit_error", "api_error") */
+    errorCode?: string;
+}> {
+}
+/**
+ * AgentStreamEvent - All stream events
+ */
+type AgentStreamEvent = AgentMessageStartEvent | AgentMessageDeltaEvent | AgentMessageStopEvent | AgentTextDeltaEvent | AgentToolUseStartEvent | AgentInputJsonDeltaEvent | AgentToolUseStopEvent | AgentToolResultEvent | AgentErrorReceivedEvent;
+/**
+ * AgentStreamEventType - String literal union
+ */
+type AgentStreamEventType = AgentStreamEvent["type"];
+/**
+ * Type guard: is this a stream event?
+ */
+declare function isAgentStreamEvent(event: {
+    source?: string;
+    category?: string;
+}): event is AgentStreamEvent;
+/**
+ * Base type for state events
+ */
+interface AgentStateEventBase<T extends string, D> extends BaseAgentEvent<T, D, "state"> {
+}
+/**
+ * ConversationQueuedEvent - Message queued for processing
+ */
+interface ConversationQueuedEvent extends AgentStateEventBase<"conversation_queued", {
+    messageId: string;
+}> {
+}
+/**
+ * ConversationStartEvent - Conversation started
+ */
+interface ConversationStartEvent extends AgentStateEventBase<"conversation_start", {
+    messageId: string;
+}> {
+}
+/**
+ * ConversationThinkingEvent - Agent is thinking
+ */
+interface ConversationThinkingEvent extends AgentStateEventBase<"conversation_thinking", Record<string, never>> {
+}
+/**
+ * ConversationRespondingEvent - Agent is responding
+ */
+interface ConversationRespondingEvent extends AgentStateEventBase<"conversation_responding", Record<string, never>> {
+}
+/**
+ * ConversationEndEvent - Conversation ended
+ */
+interface ConversationEndEvent extends AgentStateEventBase<"conversation_end", {
+    reason: "completed" | "interrupted" | "error";
+}> {
+}
+/**
+ * ConversationInterruptedEvent - Conversation interrupted
+ */
+interface ConversationInterruptedEvent extends AgentStateEventBase<"conversation_interrupted", {
+    reason: string;
+}> {
+}
+/**
+ * ToolPlannedEvent - Tool use planned
+ */
+interface ToolPlannedEvent extends AgentStateEventBase<"tool_planned", {
+    toolId: string;
+    toolName: string;
+}> {
+}
+/**
+ * ToolExecutingEvent - Tool is executing
+ */
+interface ToolExecutingEvent extends AgentStateEventBase<"tool_executing", {
+    toolId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+}> {
+}
+/**
+ * ToolCompletedEvent - Tool execution completed
+ */
+interface ToolCompletedEvent extends AgentStateEventBase<"tool_completed", {
+    toolId: string;
+    toolName: string;
+    result: unknown;
+}> {
+}
+/**
+ * ToolFailedEvent - Tool execution failed
+ */
+interface ToolFailedEvent extends AgentStateEventBase<"tool_failed", {
+    toolId: string;
+    toolName: string;
+    error: string;
+}> {
+}
+/**
+ * ErrorOccurredEvent - Error occurred during processing
+ */
+interface ErrorOccurredEvent extends AgentStateEventBase<"error_occurred", {
+    code: string;
+    message: string;
+    recoverable: boolean;
+    category?: string;
+}> {
+}
+/**
+ * AgentStateEvent - All state events
+ */
+type AgentStateEvent = ConversationQueuedEvent | ConversationStartEvent | ConversationThinkingEvent | ConversationRespondingEvent | ConversationEndEvent | ConversationInterruptedEvent | ToolPlannedEvent | ToolExecutingEvent | ToolCompletedEvent | ToolFailedEvent | ErrorOccurredEvent;
+/**
+ * AgentStateEventType - String literal union
+ */
+type AgentStateEventType = AgentStateEvent["type"];
+/**
+ * Type guard: is this a state event?
+ */
+declare function isAgentStateEvent(event: {
+    source?: string;
+    category?: string;
+}): event is AgentStateEvent;
+/**
+ * Base type for message events
+ */
+interface AgentMessageEventBase<T extends string, D> extends BaseAgentEvent<T, D, "message"> {
+}
+/**
+ * UserMessageEvent - User sent a message
+ * Data: Complete UserMessage object
+ */
+interface UserMessageEvent extends AgentMessageEventBase<"user_message", UserMessage> {
+}
+/**
+ * AssistantMessageEvent - Assistant response message
+ * Data: Complete AssistantMessage object
+ */
+interface AssistantMessageEvent extends AgentMessageEventBase<"assistant_message", AssistantMessage> {
+}
+/**
+ * ToolCallMessageEvent - Tool call message (part of assistant turn)
+ * Data: Complete ToolCallMessage object
+ */
+interface ToolCallMessageEvent extends AgentMessageEventBase<"tool_call_message", ToolCallMessage> {
+}
+/**
+ * ToolResultMessageEvent - Tool result message
+ * Data: Complete ToolResultMessage object
+ */
+interface ToolResultMessageEvent extends AgentMessageEventBase<"tool_result_message", ToolResultMessage> {
+}
+/**
+ * ErrorMessageEvent - Error message displayed in chat
+ * Data: Complete ErrorMessage object
+ *
+ * Generated when error_received StreamEvent is processed by MealyMachine.
+ * Displayed in the chat history so users can see what went wrong.
+ */
+interface ErrorMessageEvent extends AgentMessageEventBase<"error_message", ErrorMessage> {
+}
+/**
+ * AgentMessageEvent - All message events
+ */
+type AgentMessageEvent = UserMessageEvent | AssistantMessageEvent | ToolCallMessageEvent | ToolResultMessageEvent | ErrorMessageEvent;
+/**
+ * AgentMessageEventType - String literal union
+ */
+type AgentMessageEventType = AgentMessageEvent["type"];
+/**
+ * Type guard: is this a message event?
+ */
+declare function isAgentMessageEvent(event: {
+    source?: string;
+    category?: string;
+}): event is AgentMessageEvent;
+/**
+ * Base type for turn events
+ */
+interface AgentTurnEventBase<T extends string, D> extends BaseAgentEvent<T, D, "turn"> {
+}
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens?: number;
+}
+/**
+ * TurnRequestEvent - Turn started (user message received)
+ */
+interface TurnRequestEvent extends AgentTurnEventBase<"turn_request", {
+    turnId: string;
+    messageId: string;
+    content: string;
+    timestamp: number;
+}> {
+}
+/**
+ * TurnResponseEvent - Turn completed (assistant response finished)
+ */
+interface TurnResponseEvent extends AgentTurnEventBase<"turn_response", {
+    turnId: string;
+    messageId: string;
+    duration: number;
+    usage?: TokenUsage;
+    model?: string;
+    stopReason?: string;
+    timestamp: number;
+}> {
+}
+/**
+ * AgentTurnEvent - All turn events
+ */
+type AgentTurnEvent = TurnRequestEvent | TurnResponseEvent;
+/**
+ * AgentTurnEventType - String literal union
+ */
+type AgentTurnEventType = AgentTurnEvent["type"];
+/**
+ * Type guard: is this a turn event?
+ */
+declare function isAgentTurnEvent(event: {
+    source?: string;
+    category?: string;
+}): event is AgentTurnEvent;
+/**
+ * AgentEvent - All events from Agent domain
+ */
+type AgentEvent = AgentStreamEvent | AgentStateEvent | AgentMessageEvent | AgentTurnEvent;
+/**
+ * Type guard: is this an agent event?
+ */
+declare function isAgentEvent(event: {
+    source?: string;
+}): event is AgentEvent;
+
+/**
+ * Session Events - Session lifecycle, persist, and action events
+ *
+ * Events for session operations in the event system.
+ */
+
+/**
+ * Base SessionLifecycleEvent
+ */
+interface BaseSessionLifecycleEvent<T extends string, D = unknown> extends SystemEvent<T, D, "session", "lifecycle", "notification"> {
+}
+/**
+ * SessionCreatedEvent - Session was created
+ */
+interface SessionCreatedEvent extends BaseSessionLifecycleEvent<"session_created", {
+    sessionId: string;
+    imageId: string;
+    containerId: string;
+    title?: string;
+    createdAt: number;
+}> {
+}
+/**
+ * SessionDestroyedEvent - Session was destroyed
+ */
+interface SessionDestroyedEvent extends BaseSessionLifecycleEvent<"session_destroyed", {
+    sessionId: string;
+    reason?: string;
+}> {
+}
+/**
+ * SessionLifecycleEvent - All session lifecycle events
+ */
+type SessionLifecycleEvent = SessionCreatedEvent | SessionDestroyedEvent;
+/**
+ * Type guard: is this a SessionLifecycleEvent?
+ */
+declare function isSessionLifecycleEvent(event: {
+    source?: string;
+    category?: string;
+}): event is SessionLifecycleEvent;
+/**
+ * Base SessionPersistRequest
+ */
+interface BaseSessionPersistRequest<T extends string, D = unknown> extends SystemEvent<T, D, "session", "persist", "request"> {
+}
+/**
+ * Base SessionPersistResult
+ */
+interface BaseSessionPersistResult<T extends string, D = unknown> extends SystemEvent<T, D, "session", "persist", "result"> {
+}
+/**
+ * SessionSaveRequest - Request to save session
+ */
+interface SessionSaveRequest extends BaseSessionPersistRequest<"session_save_request", {
+    sessionId: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+}> {
+}
+/**
+ * SessionSavedEvent - Session was saved
+ */
+interface SessionSavedEvent extends BaseSessionPersistResult<"session_saved", {
+    sessionId: string;
+    savedAt: number;
+}> {
+}
+/**
+ * MessagePersistRequest - Request to persist a message
+ */
+interface MessagePersistRequest extends BaseSessionPersistRequest<"message_persist_request", {
+    sessionId: string;
+    messageId: string;
+    role: "user" | "assistant" | "tool_call" | "tool_result";
+    content: unknown;
+}> {
+}
+/**
+ * MessagePersistedEvent - Message was persisted
+ */
+interface MessagePersistedEvent extends BaseSessionPersistResult<"message_persisted", {
+    sessionId: string;
+    messageId: string;
+    savedAt: number;
+}> {
+}
+/**
+ * SessionPersistEvent - All session persist events
+ */
+type SessionPersistEvent = SessionSaveRequest | SessionSavedEvent | MessagePersistRequest | MessagePersistedEvent;
+/**
+ * Session persist request events
+ */
+type SessionPersistRequestEvent = SessionSaveRequest | MessagePersistRequest;
+/**
+ * Session persist result events
+ */
+type SessionPersistResultEvent = SessionSavedEvent | MessagePersistedEvent;
+/**
+ * Type guard: is this a SessionPersistEvent?
+ */
+declare function isSessionPersistEvent(event: {
+    source?: string;
+    category?: string;
+}): event is SessionPersistEvent;
+/**
+ * Base SessionActionRequest
+ */
+interface BaseSessionActionRequest<T extends string, D = unknown> extends SystemEvent<T, D, "session", "action", "request"> {
+}
+/**
+ * Base SessionActionResult
+ */
+interface BaseSessionActionResult<T extends string, D = unknown> extends SystemEvent<T, D, "session", "action", "result"> {
+}
+/**
+ * SessionResumeRequest - Request to resume a session
+ */
+interface SessionResumeRequest extends BaseSessionActionRequest<"session_resume_request", {
+    sessionId: string;
+    containerId?: string;
+}> {
+}
+/**
+ * SessionResumedEvent - Session was resumed
+ */
+interface SessionResumedEvent extends BaseSessionActionResult<"session_resumed", {
+    sessionId: string;
+    agentId: string;
+    resumedAt: number;
+}> {
+}
+/**
+ * SessionForkRequest - Request to fork a session
+ */
+interface SessionForkRequest extends BaseSessionActionRequest<"session_fork_request", {
+    sessionId: string;
+    newTitle?: string;
+}> {
+}
+/**
+ * SessionForkedEvent - Session was forked
+ */
+interface SessionForkedEvent extends BaseSessionActionResult<"session_forked", {
+    originalSessionId: string;
+    newSessionId: string;
+    newImageId: string;
+    forkedAt: number;
+}> {
+}
+/**
+ * SessionTitleUpdateRequest - Request to update session title
+ */
+interface SessionTitleUpdateRequest extends BaseSessionActionRequest<"session_title_update_request", {
+    sessionId: string;
+    title: string;
+}> {
+}
+/**
+ * SessionTitleUpdatedEvent - Session title was updated
+ */
+interface SessionTitleUpdatedEvent extends BaseSessionActionResult<"session_title_updated", {
+    sessionId: string;
+    title: string;
+    updatedAt: number;
+}> {
+}
+/**
+ * SessionActionEvent - All session action events
+ */
+type SessionActionEvent = SessionResumeRequest | SessionResumedEvent | SessionForkRequest | SessionForkedEvent | SessionTitleUpdateRequest | SessionTitleUpdatedEvent;
+/**
+ * Session action request events
+ */
+type SessionActionRequestEvent = SessionResumeRequest | SessionForkRequest | SessionTitleUpdateRequest;
+/**
+ * Session action result events
+ */
+type SessionActionResultEvent = SessionResumedEvent | SessionForkedEvent | SessionTitleUpdatedEvent;
+/**
+ * Type guard: is this a SessionActionEvent?
+ */
+declare function isSessionActionEvent(event: {
+    source?: string;
+    category?: string;
+}): event is SessionActionEvent;
+/**
+ * SessionEvent - All session events
+ */
+type SessionEvent = SessionLifecycleEvent | SessionPersistEvent | SessionActionEvent;
+/**
+ * Type guard: is this a session event?
+ */
+declare function isSessionEvent(event: {
+    source?: string;
+}): event is SessionEvent;
+
+/**
+ * Container Events - Container lifecycle and sandbox events
+ *
+ * Events for container operations in the event system.
+ */
+
+/**
+ * Base ContainerLifecycleEvent
+ */
+interface BaseContainerLifecycleEvent<T extends string, D = unknown> extends SystemEvent<T, D, "container", "lifecycle", "notification"> {
+}
+/**
+ * ContainerCreatedEvent - Container was created
+ */
+interface ContainerCreatedEvent extends BaseContainerLifecycleEvent<"container_created", {
+    containerId: string;
+    name?: string;
+    createdAt: number;
+}> {
+}
+/**
+ * ContainerDestroyedEvent - Container was destroyed
+ */
+interface ContainerDestroyedEvent extends BaseContainerLifecycleEvent<"container_destroyed", {
+    containerId: string;
+    reason?: string;
+    agentCount: number;
+}> {
+}
+/**
+ * AgentRegisteredEvent - Agent was registered to container
+ */
+interface AgentRegisteredEvent extends BaseContainerLifecycleEvent<"agent_registered", {
+    containerId: string;
+    agentId: string;
+    definitionName: string;
+    registeredAt: number;
+}> {
+}
+/**
+ * AgentUnregisteredEvent - Agent was unregistered from container
+ */
+interface AgentUnregisteredEvent extends BaseContainerLifecycleEvent<"agent_unregistered", {
+    containerId: string;
+    agentId: string;
+    reason?: string;
+}> {
+}
+/**
+ * ContainerLifecycleEvent - All container lifecycle events
+ */
+type ContainerLifecycleEvent = ContainerCreatedEvent | ContainerDestroyedEvent | AgentRegisteredEvent | AgentUnregisteredEvent;
+/**
+ * Type guard: is this a ContainerLifecycleEvent?
+ */
+declare function isContainerLifecycleEvent(event: {
+    source?: string;
+    category?: string;
+}): event is ContainerLifecycleEvent;
+/**
+ * Base WorkdirRequest
+ */
+interface BaseWorkdirRequest<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "workdir", "request"> {
+}
+/**
+ * Base WorkdirResult
+ */
+interface BaseWorkdirResult<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "workdir", "result"> {
+}
+/**
+ * Base WorkdirNotification
+ */
+interface BaseWorkdirNotification<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "workdir", "notification"> {
+}
+/**
+ * FileReadRequest - Request to read a file
+ */
+interface FileReadRequest extends BaseWorkdirRequest<"file_read_request", {
+    path: string;
+    encoding?: string;
+}> {
+}
+/**
+ * FileReadResult - File read result
+ */
+interface FileReadResult extends BaseWorkdirResult<"file_read_result", {
+    path: string;
+    content: string;
+    size: number;
+    encoding: string;
+}> {
+}
+/**
+ * FileWriteRequest - Request to write a file
+ */
+interface FileWriteRequest extends BaseWorkdirRequest<"file_write_request", {
+    path: string;
+    content: string;
+    encoding?: string;
+    createDirectories?: boolean;
+}> {
+}
+/**
+ * FileWrittenEvent - File was written
+ */
+interface FileWrittenEvent extends BaseWorkdirResult<"file_written", {
+    path: string;
+    size: number;
+    timestamp: number;
+}> {
+}
+/**
+ * FileDeleteRequest - Request to delete a file
+ */
+interface FileDeleteRequest extends BaseWorkdirRequest<"file_delete_request", {
+    path: string;
+    recursive?: boolean;
+}> {
+}
+/**
+ * FileDeletedEvent - File was deleted
+ */
+interface FileDeletedEvent extends BaseWorkdirResult<"file_deleted", {
+    path: string;
+    timestamp: number;
+}> {
+}
+/**
+ * DirectoryListRequest - Request to list directory
+ */
+interface DirectoryListRequest extends BaseWorkdirRequest<"directory_list_request", {
+    path: string;
+    recursive?: boolean;
+    pattern?: string;
+}> {
+}
+/**
+ * DirectoryListResult - Directory listing result
+ */
+interface DirectoryListResult extends BaseWorkdirResult<"directory_list_result", {
+    path: string;
+    entries: Array<{
+        name: string;
+        type: "file" | "directory";
+        size?: number;
+        modifiedAt?: number;
+    }>;
+}> {
+}
+/**
+ * WorkdirErrorEvent - Workdir operation error
+ */
+interface WorkdirErrorEvent extends BaseWorkdirNotification<"workdir_error", {
+    operation: string;
+    path: string;
+    code: string;
+    message: string;
+}> {
+}
+/**
+ * WorkdirEvent - All workdir events
+ */
+type WorkdirEvent = FileReadRequest | FileReadResult | FileWriteRequest | FileWrittenEvent | FileDeleteRequest | FileDeletedEvent | DirectoryListRequest | DirectoryListResult | WorkdirErrorEvent;
+/**
+ * Workdir request events
+ */
+type WorkdirRequestEvent = FileReadRequest | FileWriteRequest | FileDeleteRequest | DirectoryListRequest;
+/**
+ * Workdir result events
+ */
+type WorkdirResultEvent = FileReadResult | FileWrittenEvent | FileDeletedEvent | DirectoryListResult;
+/**
+ * Type guard: is this a WorkdirEvent?
+ */
+declare function isWorkdirEvent(event: {
+    source?: string;
+    category?: string;
+}): event is WorkdirEvent;
+/**
+ * Base MCPRequest
+ */
+interface BaseMCPRequest<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "mcp", "request"> {
+}
+/**
+ * Base MCPResult
+ */
+interface BaseMCPResult<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "mcp", "result"> {
+}
+/**
+ * Base MCPNotification
+ */
+interface BaseMCPNotification<T extends string, D = unknown> extends SystemEvent<T, D, "sandbox", "mcp", "notification"> {
+}
+/**
+ * ToolExecuteRequest - Request to execute a tool
+ */
+interface ToolExecuteRequest extends BaseMCPRequest<"tool_execute_request", {
+    toolId: string;
+    toolName: string;
+    serverName: string;
+    input: Record<string, unknown>;
+    timestamp: number;
+}> {
+}
+/**
+ * ToolExecutedEvent - Tool execution completed
+ */
+interface ToolExecutedEvent extends BaseMCPResult<"tool_executed", {
+    toolId: string;
+    toolName: string;
+    result: unknown;
+    duration: number;
+    timestamp: number;
+}> {
+}
+/**
+ * ToolExecutionErrorEvent - Tool execution failed
+ */
+interface ToolExecutionErrorEvent extends BaseMCPNotification<"tool_execution_error", {
+    toolId: string;
+    toolName: string;
+    code: string;
+    message: string;
+    timestamp: number;
+}> {
+}
+/**
+ * MCPServerConnectedEvent - MCP server connected
+ */
+interface MCPServerConnectedEvent extends BaseMCPNotification<"mcp_server_connected", {
+    serverName: string;
+    version?: string;
+    toolCount: number;
+    resourceCount: number;
+    timestamp: number;
+}> {
+}
+/**
+ * MCPServerDisconnectedEvent - MCP server disconnected
+ */
+interface MCPServerDisconnectedEvent extends BaseMCPNotification<"mcp_server_disconnected", {
+    serverName: string;
+    reason?: string;
+    timestamp: number;
+}> {
+}
+/**
+ * ResourceReadRequest - Request to read an MCP resource
+ */
+interface ResourceReadRequest extends BaseMCPRequest<"resource_read_request", {
+    serverName: string;
+    uri: string;
+}> {
+}
+/**
+ * ResourceReadResult - Resource read result
+ */
+interface ResourceReadResult extends BaseMCPResult<"resource_read_result", {
+    serverName: string;
+    uri: string;
+    content: unknown;
+    mimeType?: string;
+}> {
+}
+/**
+ * MCPEvent - All MCP events
+ */
+type MCPEvent = ToolExecuteRequest | ToolExecutedEvent | ToolExecutionErrorEvent | MCPServerConnectedEvent | MCPServerDisconnectedEvent | ResourceReadRequest | ResourceReadResult;
+/**
+ * MCP request events
+ */
+type MCPRequestEvent = ToolExecuteRequest | ResourceReadRequest;
+/**
+ * MCP result events
+ */
+type MCPResultEvent = ToolExecutedEvent | ResourceReadResult;
+/**
+ * Type guard: is this a MCPEvent?
+ */
+declare function isMCPEvent(event: {
+    source?: string;
+    category?: string;
+}): event is MCPEvent;
+/**
+ * SandboxEvent - All sandbox events
+ */
+type SandboxEvent = WorkdirEvent | MCPEvent;
+/**
+ * Type guard: is this a sandbox event?
+ */
+declare function isSandboxEvent(event: {
+    source?: string;
+}): event is SandboxEvent;
+/**
+ * ContainerEvent - All container events
+ */
+type ContainerEvent = ContainerLifecycleEvent | SandboxEvent;
+/**
+ * Type guard: is this a container event?
+ */
+declare function isContainerEvent(event: {
+    source?: string;
+}): event is ContainerEvent;
+
+export { type AgentErrorReceivedEvent, type AgentEvent, type AgentEventCategory, type AgentInputJsonDeltaEvent, type AgentMessageDeltaEvent, type AgentMessageEvent, type AgentMessageEventBase, type AgentMessageEventType, type AgentMessageStartEvent, type AgentMessageStopEvent, type AgentRegisteredEvent, type AgentStateEvent, type AgentStateEventBase, type AgentStateEventType, type AgentStopReason, type AgentStreamEvent, type AgentStreamEventBase, type AgentStreamEventType, type AgentTextDeltaEvent, type AgentToolResultEvent, type AgentToolUseStartEvent, type AgentToolUseStopEvent, type AgentTurnEvent, type AgentTurnEventBase, type AgentTurnEventType, type AgentUnregisteredEvent, type AssistantMessageEvent, type BaseAgentEvent, type ConnectedEvent, type ConnectionEvent, type ConnectionEventType, type ContainerCreatedEvent, type ContainerDestroyedEvent, type ContainerEvent, type ContainerLifecycleEvent, type ConversationEndEvent, type ConversationInterruptedEvent, type ConversationQueuedEvent, type ConversationRespondingEvent, type ConversationStartEvent, type ConversationThinkingEvent, type DirectoryListRequest, type DirectoryListResult, type DisconnectedEvent, type DriveableEvent, type DriveableEventType, type EnvironmentEvent, type ErrorEvent, type ErrorEventMap, type ErrorEventType, type ErrorMessageEvent, type ErrorOccurredEvent, type ErrorReceivedEvent, EventContext, type FileDeleteRequest, type FileDeletedEvent, type FileReadRequest, type FileReadResult, type FileWriteRequest, type FileWrittenEvent, type InputJsonDeltaEvent, type InterruptedEvent, type MCPEvent, type MCPRequestEvent, type MCPResultEvent, type MCPServerConnectedEvent, type MCPServerDisconnectedEvent, type MessageDeltaEvent, type MessagePersistRequest, type MessagePersistedEvent, type MessageStartEvent, type MessageStopEvent, type ReconnectingEvent, type ResourceReadRequest, type ResourceReadResult, type SandboxEvent, type SessionActionEvent, type SessionActionRequestEvent, type SessionActionResultEvent, type SessionCreatedEvent, type SessionDestroyedEvent, type SessionEvent, type SessionForkRequest, type SessionForkedEvent, type SessionLifecycleEvent, type SessionPersistEvent, type SessionPersistRequestEvent, type SessionPersistResultEvent, type SessionResumeRequest, type SessionResumedEvent, type SessionSaveRequest, type SessionSavedEvent, type SessionTitleUpdateRequest, type SessionTitleUpdatedEvent, type StopReason, type SystemError, SystemEvent, type TextContentBlockStartEvent, type TextContentBlockStopEvent, type TextDeltaEvent, type TokenUsage, type ToolCallEvent, type ToolCallMessageEvent, type ToolCompletedEvent, type ToolExecuteRequest, type ToolExecutedEvent, type ToolExecutingEvent, type ToolExecutionErrorEvent, type ToolFailedEvent, type ToolPlannedEvent, type ToolResultEvent, type ToolResultMessageEvent, type ToolUseContentBlockStartEvent, type ToolUseContentBlockStopEvent, type TurnRequestEvent, type TurnResponseEvent, type UserMessageEvent, type WorkdirErrorEvent, type WorkdirEvent, type WorkdirRequestEvent, type WorkdirResultEvent, isAgentEvent, isAgentMessageEvent, isAgentStateEvent, isAgentStreamEvent, isAgentTurnEvent, isConnectionEvent, isContainerEvent, isContainerLifecycleEvent, isDriveableEvent, isMCPEvent, isSandboxEvent, isSessionActionEvent, isSessionEvent, isSessionLifecycleEvent, isSessionPersistEvent, isStopReason, isWorkdirEvent };