@agentxjs/types 0.0.9 → 0.2.0

package/dist/event.d.cts

@@ -0,0 +1,769 @@
+import { S as SystemEvent } from './SystemEvent-CPvvxdMQ.cjs';
+export { b as EventCategory, c as EventContext, a as EventIntent, E as EventSource, h as hasIntent, i as isFromSource, f as isNotification, d as isRequest, e as isResult } from './SystemEvent-CPvvxdMQ.cjs';
+import { D as DriveableEvent } from './DriveableEvent-CCMC1h_C.cjs';
+export { a as DriveableEventType, E as ErrorReceivedEvent, I as InputJsonDeltaEvent, j as InterruptedEvent, b as MessageDeltaEvent, M as MessageStartEvent, c as MessageStopEvent, T as TextContentBlockStartEvent, e as TextContentBlockStopEvent, d as TextDeltaEvent, h as ToolCallEvent, i as ToolResultEvent, f as ToolUseContentBlockStartEvent, g as ToolUseContentBlockStopEvent, k as isDriveableEvent } from './DriveableEvent-CCMC1h_C.cjs';
+export { n as AgentDestroyAllRequest, o as AgentDestroyAllResponse, l as AgentDestroyRequest, m as AgentDestroyResponse, A as AgentGetRequest, i as AgentGetResponse, q as AgentInterruptRequest, r as AgentInterruptResponse, j as AgentListRequest, k as AgentListResponse, L as CommandEvent, b as CommandEventMap, N as CommandEventType, J as CommandRequest, O as CommandRequestResponseMap, C as CommandRequestType, K as CommandResponse, c as ContainerCreateRequest, d as ContainerCreateResponse, e as ContainerGetRequest, f as ContainerGetResponse, g as ContainerListRequest, h as ContainerListResponse, I as ImageCreateRequest, s as ImageCreateResponse, G as ImageDeleteRequest, H as ImageDeleteResponse, E as ImageGetRequest, F as ImageGetResponse, D as ImageListItem, z as ImageListRequest, B as ImageListResponse, t as ImageRunRequest, u as ImageRunResponse, v as ImageStopRequest, w as ImageStopResponse, x as ImageUpdateRequest, y as ImageUpdateResponse, M as MessageSendRequest, p as MessageSendResponse, R as RequestDataFor, a as ResponseEventFor, P as ResponseTypeFor, Q as isCommandEvent, S as isCommandRequest, T as isCommandResponse } from './CommandEvent-DCdk7lzX.cjs';
+import { A as AgentStreamEvent, i as AgentStateEvent, r as AgentMessageEvent } from './index-CjFNcCxR.cjs';
+export { x as AgentErrorReceivedEvent, f as AgentInputJsonDeltaEvent, b as AgentMessageDeltaEvent, G as AgentMessageEventBase, H as AgentMessageEventType, a as AgentMessageStartEvent, c as AgentMessageStopEvent, B as AgentStateEventBase, D as AgentStateEventType, w as AgentStreamEventBase, y as AgentStreamEventType, d as AgentTextDeltaEvent, h as AgentToolResultEvent, e as AgentToolUseStartEvent, g as AgentToolUseStopEvent, s as AssistantMessageEvent, m as ConversationEndEvent, n as ConversationInterruptedEvent, C as ConversationQueuedEvent, l as ConversationRespondingEvent, j as ConversationStartEvent, k as ConversationThinkingEvent, v as ErrorMessageEvent, E as ErrorOccurredEvent, S as StopReason, t as ToolCallMessageEvent, p as ToolCompletedEvent, o as ToolExecutingEvent, q as ToolFailedEvent, T as ToolPlannedEvent, u as ToolResultMessageEvent, U as UserMessageEvent, I as isAgentMessageEvent, F as isAgentStateEvent, z as isAgentStreamEvent } from './index-CjFNcCxR.cjs';
+import { h as AgentTurnEvent } from './ToolResultMessage-CRKMSf5d.cjs';
+export { k as AgentEventCategory, l as AgentTurnEventBase, m as AgentTurnEventType, B as BaseAgentEvent, g as TokenUsage, i as TurnRequestEvent, j as TurnResponseEvent, n as isAgentTurnEvent } from './ToolResultMessage-CRKMSf5d.cjs';
+import './StopReason-D4DthB1h.cjs';
+import './ImageRecord-Cn0VcJWk.cjs';
+import './ErrorMessage-BoIh3MIO.cjs';
+
+/**
+ * ConnectionEvent - Network connection status events
+ *
+ * These events notify about network connection status.
+ * They do NOT drive the Agent (not processed by AgentEngine).
+ *
+ * All ConnectionEvents have:
+ * - source: "environment"
+ * - category: "connection"
+ * - intent: "notification"
+ */
+
+/**
+ * Base interface for all connection events
+ */
+interface BaseConnectionEvent<T extends string, D = unknown> extends SystemEvent<T, D, "environment", "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: SystemEvent): event is ConnectionEvent;
+
+type EnvironmentEvent = DriveableEvent | ConnectionEvent;
+
+/**
+ * Container Lifecycle Events
+ *
+ * Events for container creation, destruction, and agent management.
+ *
+ * All ContainerLifecycleEvents have:
+ * - source: "container"
+ * - category: "lifecycle"
+ * - intent: "notification"
+ */
+
+/**
+ * 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: SystemEvent): event is ContainerLifecycleEvent;
+
+/**
+ * Sandbox Workdir Events
+ *
+ * Events for file system operations in the agent's working directory.
+ *
+ * All WorkdirEvents have:
+ * - source: "sandbox"
+ * - category: "workdir"
+ * - intent: "request" | "result" | "notification"
+ */
+
+/**
+ * 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: SystemEvent): event is WorkdirEvent;
+
+/**
+ * Sandbox MCP Events
+ *
+ * Events for MCP (Model Context Protocol) tool operations.
+ *
+ * All MCPEvents have:
+ * - source: "sandbox"
+ * - category: "mcp"
+ * - intent: "request" | "result" | "notification"
+ */
+
+/**
+ * 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: SystemEvent): event is MCPEvent;
+
+/**
+ * Sandbox Events
+ *
+ * All events related to Sandbox resource operations:
+ * - Workdir: File system operations
+ * - MCP: Model Context Protocol tools
+ *
+ * Note: LLM events are NOT part of Sandbox.
+ * Agent system doesn't need to observe LLM-level events.
+ */
+
+/**
+ * SandboxEvent - All sandbox events
+ */
+type SandboxEvent = WorkdirEvent | MCPEvent;
+/**
+ * Type guard: is this a sandbox event?
+ */
+declare function isSandboxEvent(event: {
+    source?: string;
+}): event is SandboxEvent;
+
+/**
+ * Container Events
+ *
+ * All events related to Container operations:
+ * - Lifecycle: creation, destruction, agent registration
+ * - Sandbox: workspace and MCP tool operations
+ */
+
+/**
+ * ContainerEvent - All container events
+ */
+type ContainerEvent = ContainerLifecycleEvent | SandboxEvent;
+/**
+ * Type guard: is this a container event?
+ */
+declare function isContainerEvent(event: {
+    source?: string;
+}): event is ContainerEvent;
+
+/**
+ * Session Lifecycle Events
+ *
+ * Events for session creation and destruction.
+ *
+ * All SessionLifecycleEvents have:
+ * - source: "session"
+ * - category: "lifecycle"
+ * - intent: "notification"
+ */
+
+/**
+ * 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: SystemEvent): event is SessionLifecycleEvent;
+
+/**
+ * Session Persist Events
+ *
+ * Events for session persistence operations.
+ *
+ * Isomorphic Design:
+ * - Request events may be forwarded (RemoteEcosystem) or executed (NodeEcosystem)
+ * - Result events confirm completion
+ *
+ * All SessionPersistEvents have:
+ * - source: "session"
+ * - category: "persist"
+ * - intent: "request" | "result"
+ */
+
+/**
+ * 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: SystemEvent): event is SessionPersistEvent;
+
+/**
+ * Session Action Events
+ *
+ * Events for user-initiated session actions (resume, fork, etc.)
+ *
+ * All SessionActionEvents have:
+ * - source: "session"
+ * - category: "action"
+ * - intent: "request" | "result"
+ */
+
+/**
+ * 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: SystemEvent): event is SessionActionEvent;
+
+/**
+ * Session Events
+ *
+ * All events related to Session operations:
+ * - Lifecycle: creation, destruction
+ * - Persist: save, message persistence
+ * - Action: resume, fork, title update
+ */
+
+/**
+ * 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;
+
+/**
+ * Agent Events - SystemEvent for Agent domain
+ *
+ * Complete event definitions for Agent, extending SystemEvent with:
+ * - source: "agent"
+ * - category: "stream" | "state" | "message" | "turn"
+ * - intent: "notification"
+ *
+ * ## Event Categories
+ *
+ * ```
+ * AgentEvent (source: "agent")
+ * │
+ * ├── category: "stream"   ← Real-time streaming from LLM
+ * │   └── TextDeltaEvent, MessageStartEvent, ToolUseStartEvent...
+ * │
+ * ├── category: "state"    ← State transitions
+ * │   └── ConversationStartEvent, ConversationEndEvent, ToolExecutingEvent...
+ * │
+ * ├── category: "message"  ← Assembled complete messages
+ * │   └── UserMessageEvent, AssistantMessageEvent, ToolCallMessageEvent...
+ * │
+ * └── category: "turn"     ← Turn analytics
+ *     └── TurnStartEvent, TurnEndEvent
+ * ```
+ *
+ * ## Relationship with Engine Events
+ *
+ * Engine uses lightweight events (type, timestamp, data only).
+ * Use `ToEngineEvent<T>` to convert AgentEvent to EngineEvent.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * 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;
+
+/**
+ * ErrorEvent - System-wide error events
+ *
+ * Generic error events for reporting failures and exceptions.
+ * These are independent notification events that can be:
+ * - Associated with a request (via requestId)
+ * - Asynchronous (not tied to any request)
+ * - Used for UI notifications
+ *
+ * Design:
+ * - Start with generic SystemError
+ * - Gradually refine to specific error types (ContainerNotFoundError, etc.)
+ */
+
+/**
+ * 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" | "environment" | "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];
+
+export { type AgentEvent, AgentMessageEvent, type AgentRegisteredEvent, AgentStateEvent, AgentStreamEvent, AgentTurnEvent, type AgentUnregisteredEvent, type ConnectedEvent, type ConnectionEvent, type ConnectionEventType, type ContainerCreatedEvent, type ContainerDestroyedEvent, type ContainerEvent, type ContainerLifecycleEvent, type DirectoryListRequest, type DirectoryListResult, type DisconnectedEvent, DriveableEvent, type EnvironmentEvent, type ErrorEvent, type ErrorEventMap, type ErrorEventType, type FileDeleteRequest, type FileDeletedEvent, type FileReadRequest, type FileReadResult, type FileWriteRequest, type FileWrittenEvent, type MCPEvent, type MCPRequestEvent, type MCPResultEvent, type MCPServerConnectedEvent, type MCPServerDisconnectedEvent, type MessagePersistRequest, type MessagePersistedEvent, 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 SystemError, SystemEvent, type ToolExecuteRequest, type ToolExecutedEvent, type ToolExecutionErrorEvent, type WorkdirErrorEvent, type WorkdirEvent, type WorkdirRequestEvent, type WorkdirResultEvent, isAgentEvent, isConnectionEvent, isContainerEvent, isContainerLifecycleEvent, isMCPEvent, isSandboxEvent, isSessionActionEvent, isSessionEvent, isSessionLifecycleEvent, isSessionPersistEvent, isWorkdirEvent };