@octavus/core 2.18.0 → 2.20.0

package/dist/index.d.cts

@@ -0,0 +1,2239 @@
+import { z } from 'zod';
+
+declare class AppError extends Error {
+    code: string;
+    statusCode: number;
+    constructor(message: string, code: string, statusCode?: number);
+}
+declare class NotFoundError extends AppError {
+    constructor(resource: string, id: string);
+}
+declare class ValidationError extends AppError {
+    issues?: unknown[] | undefined;
+    constructor(message: string, issues?: unknown[] | undefined);
+}
+declare class ConflictError extends AppError {
+    constructor(resource: string, identifier: string);
+}
+declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+
+/**
+ * Error types for Octavus streaming errors.
+ * These types categorize errors to enable appropriate UI handling.
+ */
+type ErrorType = 'authentication_error' | 'permission_error' | 'validation_error' | 'not_found_error' | 'rate_limit_error' | 'quota_exceeded_error' | 'provider_error' | 'provider_overloaded' | 'provider_timeout' | 'unsupported_error' | 'execution_error' | 'tool_error' | 'protocol_error' | 'internal_error' | 'unknown_error';
+/**
+ * Error source - where the error originated.
+ */
+type ErrorSource = 'platform' | 'provider' | 'tool' | 'client';
+/**
+ * Provider information for provider errors.
+ */
+interface ProviderErrorInfo {
+    /** Provider name (e.g., 'openai', 'anthropic', 'google') */
+    name: string;
+    /** Model that caused the error */
+    model?: string;
+    /** HTTP status code from provider */
+    statusCode?: number;
+    /** Provider's error type string */
+    errorType?: string;
+    /** Provider's request ID for support */
+    requestId?: string;
+}
+/**
+ * Tool information for tool errors.
+ */
+interface ToolErrorInfo {
+    /** Tool name */
+    name: string;
+    /** Tool call ID */
+    callId?: string;
+}
+/**
+ * Options for creating an OctavusError.
+ */
+interface OctavusErrorOptions {
+    errorType: ErrorType;
+    message: string;
+    source: ErrorSource;
+    retryable?: boolean;
+    retryAfter?: number;
+    code?: string;
+    provider?: ProviderErrorInfo;
+    tool?: ToolErrorInfo;
+    cause?: unknown;
+}
+
+/**
+ * Base error class for Octavus streaming errors.
+ *
+ * Provides structured error information including:
+ * - Error type classification for UI handling
+ * - Source information (platform, provider, tool)
+ * - Retryability flag and retry delay
+ * - Provider/tool details when applicable
+ *
+ * @example
+ * ```typescript
+ * const error = new OctavusError({
+ *   errorType: 'rate_limit_error',
+ *   message: 'Rate limit exceeded. Please try again later.',
+ *   source: 'provider',
+ *   retryable: true,
+ *   retryAfter: 60,
+ *   provider: {
+ *     name: 'anthropic',
+ *     statusCode: 429,
+ *     requestId: 'req_xxx',
+ *   },
+ * });
+ * ```
+ */
+declare class OctavusError extends Error {
+    /** @internal Marker for cross-version instanceof checks */
+    readonly __octavusErrorMarker = "octavus.error";
+    /** Error type classification */
+    readonly errorType: ErrorType;
+    /** Where the error originated */
+    readonly source: ErrorSource;
+    /** Whether automatic retry is possible */
+    readonly retryable: boolean;
+    /** Suggested retry delay in seconds (from provider headers) */
+    readonly retryAfter?: number;
+    /** Machine-readable error code */
+    readonly code?: string;
+    /** Provider details (when source === 'provider') */
+    readonly provider?: ProviderErrorInfo;
+    /** Tool details (when source === 'tool') */
+    readonly tool?: ToolErrorInfo;
+    constructor(options: OctavusErrorOptions);
+    /**
+     * Check if an unknown value is an OctavusError.
+     * Works reliably across package versions using marker property.
+     */
+    static isInstance(error: unknown): error is OctavusError;
+    /**
+     * Convert error to plain object for serialization.
+     * Used for streaming error events.
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Check if an error is a rate limit error.
+ */
+declare function isRateLimitError(error: unknown): error is OctavusError;
+/**
+ * Check if an error is an authentication error.
+ */
+declare function isAuthenticationError(error: unknown): error is OctavusError;
+/**
+ * Check if an error is a provider error.
+ */
+declare function isProviderError(error: unknown): error is OctavusError;
+/**
+ * Check if an error is a tool error.
+ */
+declare function isToolError(error: unknown): error is OctavusError;
+/**
+ * Check if an error is retryable.
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Check if an error is a validation error (non-retryable request issue).
+ */
+declare function isValidationError(error: unknown): error is OctavusError;
+
+/**
+ * Stream event types for Octavus agent communication.
+ *
+ * Events are organized into two categories:
+ * - Standard Events (====): Common streaming patterns for AI agents
+ * - Octavus Events (----): Octavus-specific protocol events
+ */
+/**
+ * Display mode - controls execution indicator visibility (NOT final message visibility).
+ * - hidden: Block runs silently
+ * - name: Shows block/tool name
+ * - description: Shows description
+ * - stream: Shows live streaming content
+ */
+
+type DisplayMode = 'hidden' | 'name' | 'description' | 'stream';
+type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
+type ToolHandlers = Record<string, ToolHandler>;
+/** Schema for a tool provided via additionalToolSchemas (device MCP tools, etc.) */
+interface ToolSchema {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/**
+ * Interface for providing namespaced tools to a session.
+ * Implementors include `@octavus/computer` (browser, filesystem, shell)
+ * and custom consumer-defined tool providers.
+ */
+interface ToolProvider {
+    toolHandlers(): Record<string, ToolHandler>;
+    toolSchemas(): ToolSchema[];
+}
+/**
+ * Reference to an uploaded file.
+ * Used in trigger input, user messages, and tool results for file attachments.
+ * Compatible with UIFilePart structure for rendering.
+ */
+interface FileReference {
+    /** Unique file ID (platform-generated) */
+    id: string;
+    /** IANA media type (e.g., 'image/png', 'application/pdf') */
+    mediaType: string;
+    /** Presigned download URL (S3) */
+    url: string;
+    /** Original filename */
+    filename?: string;
+    /** File size in bytes */
+    size?: number;
+}
+type ResourceUpdateHandler = (name: string, value: unknown) => Promise<void> | void;
+type MessageRole = 'user' | 'assistant' | 'system';
+type ToolCallStatus = 'pending' | 'streaming' | 'available' | 'error';
+interface ToolCallInfo {
+    id: string;
+    name: string;
+    description?: string;
+    arguments: Record<string, unknown>;
+    status: ToolCallStatus;
+    result?: unknown;
+    error?: string;
+    /** Google Gemini 3 thought signature - required for tool call continuation */
+    thoughtSignature?: string;
+    /** Display mode from tool definition - controls what data flows to UIMessage */
+    display?: DisplayMode;
+}
+/** Signals the start of a response message */
+interface StartEvent {
+    type: 'start';
+    messageId?: string;
+    /** Execution ID for tool continuation. Used by client to resume after client-side tool handling. */
+    executionId?: string;
+    /** ID of the last ChatMessage in session state before this execution. Used by client SDK for retry rollback. */
+    lastMessageId?: string;
+}
+/** Signals completion of streaming */
+interface FinishEvent {
+    type: 'finish';
+    finishReason: FinishReason;
+    /** Execution ID for cleanup confirmation. Present when execution completes or pauses for client tools. */
+    executionId?: string;
+}
+
+/**
+ * Error during streaming.
+ *
+ * Enhanced with structured error information including:
+ * - Error type classification for UI handling
+ * - Source information (platform, provider, tool)
+ * - Retryability flag and retry delay
+ * - Provider/tool details when applicable
+ *
+ * @example Rate limit error from provider
+ * ```typescript
+ * {
+ *   type: 'error',
+ *   errorType: 'rate_limit_error',
+ *   message: 'Rate limit exceeded',
+ *   source: 'provider',
+ *   retryable: true,
+ *   retryAfter: 60,
+ *   provider: { name: 'anthropic', statusCode: 429 }
+ * }
+ * ```
+ */
+interface ErrorEvent {
+    type: 'error';
+    /** Error type classification for UI handling */
+    errorType: ErrorType;
+    /** Human-readable error message */
+    message: string;
+    /** Whether automatic retry is possible */
+    retryable: boolean;
+    /** Where the error originated */
+    source: ErrorSource;
+    /** Suggested retry delay in seconds (from provider headers) */
+    retryAfter?: number;
+    /** Machine-readable error code */
+    code?: string;
+    /** Provider details (when source === 'provider') */
+    provider?: ProviderErrorInfo;
+    /** Tool details (when source === 'tool') */
+    tool?: ToolErrorInfo;
+}
+type FinishReason = 'stop' | 'tool-calls' | 'client-tool-calls' | 'length' | 'content-filter' | 'error' | 'other';
+/**
+ * Start of text generation for a specific text part.
+ *
+ * If `responseType` is set, the text content is JSON matching a custom type.
+ * The client SDK should parse the text as a structured object instead of
+ * displaying it as plain text.
+ */
+interface TextStartEvent {
+    type: 'text-start';
+    id: string;
+    /**
+     * If specified, the text content is JSON matching this type name.
+     * Client SDK should parse as object, not display as text.
+     */
+    responseType?: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Incremental text content */
+interface TextDeltaEvent {
+    type: 'text-delta';
+    id: string;
+    delta: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** End of text generation for a specific text part */
+interface TextEndEvent {
+    type: 'text-end';
+    id: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Start of reasoning/thinking generation */
+interface ReasoningStartEvent {
+    type: 'reasoning-start';
+    id: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Incremental reasoning content */
+interface ReasoningDeltaEvent {
+    type: 'reasoning-delta';
+    id: string;
+    delta: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** End of reasoning generation */
+interface ReasoningEndEvent {
+    type: 'reasoning-end';
+    id: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Tool call initiated - input streaming will follow */
+interface ToolInputStartEvent {
+    type: 'tool-input-start';
+    toolCallId: string;
+    toolName: string;
+    /** Human-readable title/description for the tool call */
+    title?: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Incremental tool input/arguments */
+interface ToolInputDeltaEvent {
+    type: 'tool-input-delta';
+    toolCallId: string;
+    inputTextDelta: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Tool input streaming has ended */
+interface ToolInputEndEvent {
+    type: 'tool-input-end';
+    toolCallId: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Tool input is complete and available */
+interface ToolInputAvailableEvent {
+    type: 'tool-input-available';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Tool output/result is available */
+interface ToolOutputAvailableEvent {
+    type: 'tool-output-available';
+    toolCallId: string;
+    output: unknown;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Tool execution resulted in error */
+interface ToolOutputErrorEvent {
+    type: 'tool-output-error';
+    toolCallId: string;
+    error: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Base source event fields */
+interface BaseSourceEvent {
+    type: 'source';
+    /** Unique source ID */
+    id: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** URL source from web search or similar tools */
+interface SourceUrlEvent extends BaseSourceEvent {
+    sourceType: 'url';
+    /** URL of the source */
+    url: string;
+    /** Title of the source */
+    title?: string;
+}
+/** Document source from file processing */
+interface SourceDocumentEvent extends BaseSourceEvent {
+    sourceType: 'document';
+    /** IANA media type (e.g., 'application/pdf') */
+    mediaType: string;
+    /** Title of the document */
+    title: string;
+    /** Filename of the document */
+    filename?: string;
+}
+/** Source event - union of all source types */
+type SourceEvent = SourceUrlEvent | SourceDocumentEvent;
+/** Protocol block execution started */
+interface BlockStartEvent {
+    type: 'block-start';
+    blockId: string;
+    blockName: string;
+    blockType: string;
+    display: DisplayMode;
+    description?: string;
+    /** Whether output goes to main chat (false for independent blocks) */
+    outputToChat?: boolean;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Protocol block execution completed */
+interface BlockEndEvent {
+    type: 'block-end';
+    blockId: string;
+    summary?: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/** Resource value updated */
+interface ResourceUpdateEvent {
+    type: 'resource-update';
+    name: string;
+    value: unknown;
+}
+/** Pending tool call that needs external execution (continuation pattern) */
+interface PendingToolCall {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    /** 'llm' for LLM-initiated, 'block' for protocol block */
+    source?: 'llm' | 'block';
+    /** For block-based tools: variable name to store result in */
+    outputVariable?: string;
+    /** For block-based tools: block index to resume from after execution */
+    blockIndex?: number;
+    /** Thread name where this tool call originated (for workers with threads) */
+    thread?: string;
+    /** Worker ID if this tool call originated from a worker execution */
+    workerId?: string;
+    /** Google Gemini 3 thought signature - required for tool call continuation */
+    thoughtSignature?: string;
+}
+/**
+ * When this event is received, the stream will close.
+ * Consumer should execute the tools and POST a new trigger request with toolResults.
+ */
+interface ToolRequestEvent {
+    type: 'tool-request';
+    toolCalls: PendingToolCall[];
+    /** Worker ID if this tool request originated from a worker execution */
+    workerId?: string;
+}
+/**
+ * Request for client-side tool execution.
+ * Emitted by server-SDK when a tool has no server handler registered.
+ * Client should execute the tools and submit results via `continueWithToolResults(executionId, results)`.
+ */
+interface ClientToolRequestEvent {
+    type: 'client-tool-request';
+    /**
+     * Unique execution ID for this trigger execution.
+     * Include this when sending tool results back to continue the execution.
+     */
+    executionId: string;
+    toolCalls: PendingToolCall[];
+    /**
+     * Server tool results already executed in this round.
+     * When mixed server+client tools are requested, the server executes its tools
+     * first and includes results here. Client must include these when continuing.
+     */
+    serverToolResults?: ToolResult[];
+}
+/** Result from tool execution (consumer's response to tool-request) */
+interface ToolResult {
+    toolCallId: string;
+    toolName?: string;
+    result?: unknown;
+    error?: string;
+    /** Files produced by the tool (e.g., screenshots, generated images). */
+    files?: FileReference[];
+    outputVariable?: string;
+    blockIndex?: number;
+    /** Thread name where this tool call originated (for workers with threads) */
+    thread?: string;
+    /** Worker ID if this tool result is for a worker execution */
+    workerId?: string;
+}
+/**
+ * A file generated during execution.
+ * Used for skill outputs, image generation, code execution artifacts, etc.
+ */
+interface GeneratedFile {
+    /** Unique file ID */
+    id: string;
+    /** MIME type (e.g., 'image/png', 'application/pdf') */
+    mediaType: string;
+    /** URL for download/display */
+    url: string;
+    /** Original filename (for display/download) */
+    filename?: string;
+    /** Size in bytes */
+    size?: number;
+}
+/**
+ * File generated and available for download/display.
+ * Emitted when a tool or skill produces a file output.
+ */
+interface FileAvailableEvent {
+    type: 'file-available';
+    /** Unique file ID */
+    id: string;
+    /** MIME type (e.g., 'image/png', 'application/pdf') */
+    mediaType: string;
+    /** URL for download/display */
+    url: string;
+    /** Original filename */
+    filename?: string;
+    /** Size in bytes */
+    size?: number;
+    /** Tool call that generated this file */
+    toolCallId?: string;
+    /** Worker ID if this event originated from a worker execution */
+    workerId?: string;
+}
+/**
+ * Worker execution has started.
+ * Emitted when a worker begins execution (standalone or delegated from another agent).
+ */
+interface WorkerStartEvent {
+    type: 'worker-start';
+    /** Unique ID for this worker invocation (correlates with worker-result, also used as session ID) */
+    workerId: string;
+    /** The worker's slug (agent identifier) */
+    workerSlug: string;
+    /** Display description for the worker execution */
+    description?: string;
+}
+/**
+ * Worker execution completed with output value.
+ * Emitted by worker agents before the finish event when output is defined.
+ */
+interface WorkerResultEvent {
+    type: 'worker-result';
+    /** Unique ID for this worker invocation (correlates with worker-start) */
+    workerId: string;
+    /** The worker's output value (undefined if no output variable defined) */
+    output?: unknown;
+    /** Error message if the worker failed */
+    error?: string;
+}
+type StreamEvent = StartEvent | FinishEvent | ErrorEvent | TextStartEvent | TextDeltaEvent | TextEndEvent | ReasoningStartEvent | ReasoningDeltaEvent | ReasoningEndEvent | ToolInputStartEvent | ToolInputDeltaEvent | ToolInputEndEvent | ToolInputAvailableEvent | ToolOutputAvailableEvent | ToolOutputErrorEvent | SourceEvent | BlockStartEvent | BlockEndEvent | ResourceUpdateEvent | ToolRequestEvent | ClientToolRequestEvent | FileAvailableEvent | WorkerStartEvent | WorkerResultEvent;
+/**
+ * Type of content in a message part (internal)
+ */
+type MessagePartType = 'text' | 'reasoning' | 'tool-call' | 'operation' | 'source' | 'file' | 'object' | 'worker';
+/**
+ * Source info for URL sources (from web search, etc.)
+ */
+interface SourceUrlInfo {
+    sourceType: 'url';
+    id: string;
+    url: string;
+    title?: string;
+}
+/**
+ * Source info for document sources (from file processing)
+ */
+interface SourceDocumentInfo {
+    sourceType: 'document';
+    id: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+}
+/**
+ * Source info - union of all source types (internal)
+ */
+type SourceInfo = SourceUrlInfo | SourceDocumentInfo;
+/**
+ * File info for generated files (from skill execution, code execution, etc.)
+ */
+interface FileInfo {
+    id: string;
+    mediaType: string;
+    url: string;
+    filename?: string;
+    size?: number;
+    toolCallId?: string;
+}
+/**
+ * Object info for structured output (internal storage)
+ */
+interface ObjectInfo {
+    id: string;
+    /** Type name from the protocol */
+    typeName: string;
+    /** The structured object value */
+    value: unknown;
+}
+/**
+ * Operation info for block operations (internal storage).
+ * Used for operations like set-resource, serialize-thread, etc.
+ */
+interface OperationInfo {
+    /** Operation ID (same as block ID) */
+    id: string;
+    /** Human-readable name (from block name/description) */
+    name: string;
+    /** Type of operation (e.g., 'set-resource', 'serialize-thread') */
+    operationType: string;
+}
+/**
+ * Worker part info for worker execution (internal storage).
+ * Stores nested parts generated by a worker, enabling parallel workers
+ * and persistence across page refresh.
+ */
+interface WorkerPartInfo {
+    /** Unique ID for this worker invocation (also used as session ID for debug) */
+    workerId: string;
+    /** The worker's slug (agent identifier) */
+    workerSlug: string;
+    /** Display description for the worker */
+    description?: string;
+    /** Nested parts generated by the worker (text, reasoning, tool calls, etc.) */
+    nestedParts: MessagePart[];
+    /** Worker output value (when completed) */
+    output?: unknown;
+    /** Error message if worker failed */
+    error?: string;
+}
+/**
+ * A single part of a message, stored in order for proper display (internal)
+ */
+interface MessagePart {
+    type: MessagePartType;
+    /** Whether shown in chat UI (false = LLM sees it, user doesn't) */
+    visible: boolean;
+    /** Content for text/reasoning parts */
+    content?: string;
+    /** Tool call info for tool-call parts */
+    toolCall?: ToolCallInfo;
+    /** Operation info for operation parts (block operations) */
+    operation?: OperationInfo;
+    /** Source info for source parts (from web search, etc.) */
+    source?: SourceInfo;
+    /** File info for file parts (from skill execution, etc.) */
+    file?: FileInfo;
+    /** Object info for object parts (structured output) */
+    object?: ObjectInfo;
+    /** Worker info for worker parts (worker execution container) */
+    worker?: WorkerPartInfo;
+    /** Thread name for non-main-thread content (e.g., "summary") */
+    thread?: string;
+}
+/**
+ * Tool result entry for tool continuation messages.
+ * Used internally when injecting tool results back into conversation history.
+ */
+interface ToolResultEntry {
+    toolCallId: string;
+    toolName?: string;
+    result: unknown;
+    /** Files produced by the tool, included as visual content for the LLM. */
+    files?: FileReference[];
+}
+/**
+ * Internal chat message - stored in session state, used by LLM
+ */
+interface ChatMessage {
+    id: string;
+    role: MessageRole;
+    /** Ordered parts for display - preserves reasoning/tool/text order */
+    parts: MessagePart[];
+    createdAt: string;
+    /**
+     * Whether shown in chat UI (false = LLM sees it, user doesn't).
+     * Use for internal directives. Different from `display` which controls execution indicator.
+     * @default true
+     */
+    visible?: boolean;
+    content: string;
+    toolCalls?: ToolCallInfo[];
+    reasoning?: string;
+    /** Required by Anthropic to verify reasoning blocks */
+    reasoningSignature?: string;
+    /**
+     * Tool results for continuation messages.
+     * When present, this message represents tool results being injected back
+     * into the conversation (converted to role: 'tool' for the AI SDK).
+     */
+    toolResults?: ToolResultEntry[];
+}
+/**
+ * Status of a UI message
+ */
+type UIMessageStatus = 'streaming' | 'done';
+/**
+ * Status of a UI message part
+ */
+type UIPartStatus = 'streaming' | 'done';
+/**
+ * Text content in a UI message
+ */
+interface UITextPart {
+    type: 'text';
+    text: string;
+    status: UIPartStatus;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+}
+/**
+ * Reasoning/thinking content in a UI message
+ */
+interface UIReasoningPart {
+    type: 'reasoning';
+    text: string;
+    status: UIPartStatus;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+    /**
+     * Provider-specific metadata for this reasoning block.
+     * Used to preserve cryptographic signatures across session restore.
+     * e.g. `{ anthropic: { signature: "..." } }`
+     */
+    providerMetadata?: Record<string, unknown>;
+}
+/**
+ * Tool call status for UI
+ */
+type UIToolCallStatus = 'pending' | 'running' | 'done' | 'error' | 'cancelled';
+/**
+ * Tool call in a UI message
+ */
+interface UIToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    /** Human-readable display name (from protocol description) */
+    displayName?: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    status: UIToolCallStatus;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+    /**
+     * Provider-specific metadata for this tool call.
+     * Used to preserve cryptographic signatures across session restore.
+     * e.g. `{ google: { thoughtSignature: "..." } }`
+     */
+    providerMetadata?: Record<string, unknown>;
+}
+/**
+ * Operation status for UI
+ */
+type UIOperationStatus = 'running' | 'done' | 'cancelled';
+/**
+ * Internal operation in a UI message (e.g., set-resource, serialize-thread)
+ * These are Octavus-specific operations, not LLM tool calls
+ */
+interface UIOperationPart {
+    type: 'operation';
+    operationId: string;
+    /** Human-readable name (from block name/description) */
+    name: string;
+    /** Type of operation (e.g., 'set-resource', 'serialize-thread') */
+    operationType: string;
+    status: UIOperationStatus;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+}
+/** Base UI source part fields */
+interface BaseUISourcePart {
+    type: 'source';
+    /** The ID of the source */
+    id: string;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+}
+/**
+ * URL source part (from web search results)
+ */
+interface UISourceUrlPart extends BaseUISourcePart {
+    sourceType: 'url';
+    url: string;
+    title?: string;
+}
+/**
+ * Document source part (from file processing)
+ */
+interface UISourceDocumentPart extends BaseUISourcePart {
+    sourceType: 'document';
+    mediaType: string;
+    title: string;
+    filename?: string;
+}
+/**
+ * Source part - union of all source types
+ */
+type UISourcePart = UISourceUrlPart | UISourceDocumentPart;
+/**
+ * File attachment part.
+ * Generated by skill execution, image generation, code execution, etc.
+ */
+interface UIFilePart {
+    type: 'file';
+    /** Unique file ID */
+    id: string;
+    /** MIME type (e.g., 'image/png', 'application/pdf') */
+    mediaType: string;
+    /** URL for download/display */
+    url: string;
+    /** Original filename (for display/download) */
+    filename?: string;
+    /** Size in bytes */
+    size?: number;
+    /** Tool call that generated this file */
+    toolCallId?: string;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+}
+/**
+ * Status of a UI object part
+ */
+type UIObjectStatus = 'streaming' | 'done' | 'error';
+/**
+ * Structured object part in a UI message.
+ * Used when the agent response is a typed object (structured output).
+ * Client applications can render custom UI based on the typeName.
+ */
+interface UIObjectPart {
+    type: 'object';
+    /** Unique part ID */
+    id: string;
+    /** The type name from the protocol (e.g., "ChatResponse") */
+    typeName: string;
+    /** Partial object while streaming (may have missing/incomplete fields) */
+    partial?: unknown;
+    /** Final validated object when done */
+    object?: unknown;
+    /** Current status */
+    status: UIObjectStatus;
+    /** Error message if status is 'error' */
+    error?: string;
+    /** Thread name (undefined or 'main' for main thread) */
+    thread?: string;
+}
+/**
+ * Status of a UI worker part
+ */
+type UIWorkerStatus = 'running' | 'done' | 'error';
+/**
+ * Worker execution in a UI message.
+ * Represents a nested worker agent execution with its own parts.
+ * Used to display worker content in a dedicated container.
+ */
+interface UIWorkerPart {
+    type: 'worker';
+    /** Unique ID for this worker invocation (correlates events, also used as session ID for debug) */
+    workerId: string;
+    /** The worker's slug (agent identifier) */
+    workerSlug: string;
+    /** Display description for the worker */
+    description?: string;
+    /** Nested parts generated by the worker */
+    parts: UIMessagePart[];
+    /** Worker output value (when done) */
+    output?: unknown;
+    /** Error message if worker failed */
+    error?: string;
+    /** Current status */
+    status: UIWorkerStatus;
+}
+/**
+ * Union of all UI message part types
+ */
+type UIMessagePart = UITextPart | UIReasoningPart | UIToolCallPart | UIOperationPart | UISourcePart | UIFilePart | UIObjectPart | UIWorkerPart;
+/**
+ * UI Message - the client-facing message format
+ * All complexity is handled by the SDK, this is what consumers render
+ */
+interface UIMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    parts: UIMessagePart[];
+    status: UIMessageStatus;
+    createdAt: Date;
+}
+
+/**
+ * Options for creating an error event.
+ */
+interface CreateErrorEventOptions {
+    errorType: ErrorType;
+    message: string;
+    source: ErrorSource;
+    retryable?: boolean;
+    retryAfter?: number;
+    code?: string;
+    provider?: ProviderErrorInfo;
+    tool?: ToolErrorInfo;
+}
+/**
+ * Create an ErrorEvent from options.
+ * Use this for constructing error events in streaming responses.
+ */
+declare function createErrorEvent(options: CreateErrorEventOptions): ErrorEvent;
+/**
+ * Create an ErrorEvent from an OctavusError.
+ */
+declare function errorToStreamEvent(error: OctavusError): ErrorEvent;
+/**
+ * Create an internal error event.
+ * Convenience function for platform-level errors.
+ */
+declare function createInternalErrorEvent(message: string): ErrorEvent;
+/**
+ * Create an error event from an API response.
+ * Maps HTTP status codes to appropriate error types.
+ *
+ * Use this when handling errors from API responses (before streaming starts).
+ *
+ * @param statusCode - HTTP status code from the response
+ * @param message - Error message to display
+ */
+declare function createApiErrorEvent(statusCode: number, message: string): ErrorEvent;
+
+/**
+ * Generate a unique ID for messages, tool calls, etc.
+ * Format: timestamp-random (e.g., "1702345678901-abc123def")
+ */
+declare function generateId(): string;
+/**
+ * Check if an error is an abort error.
+ *
+ * This handles the various ways abort errors can manifest across different
+ * environments (browsers, Node.js, Next.js, etc.).
+ *
+ * @param error - The error to check
+ * @returns True if the error is an abort error
+ */
+declare function isAbortError(error: unknown): error is Error;
+
+/**
+ * Default thread name when none is specified.
+ */
+declare const MAIN_THREAD: "main";
+/**
+ * Resolve a thread name, defaulting to main thread.
+ */
+declare function resolveThread(thread: string | undefined): string;
+/**
+ * Check if a thread is the main thread.
+ */
+declare function isMainThread(thread: string | undefined): boolean;
+/**
+ * Normalize thread for storage in message parts.
+ * Main thread is stored as undefined to save space.
+ */
+declare function threadForPart(thread: string | undefined): string | undefined;
+/**
+ * Check if a message part belongs to a non-main thread.
+ * Non-main thread content (e.g., "summary") is typically displayed differently.
+ */
+declare function isOtherThread(part: {
+    thread?: string;
+}): boolean;
+
+/**
+ * Zod schemas for stream events.
+ *
+ * Schemas are organized into two categories:
+ * - Standard Events (====): Common streaming patterns for AI agents
+ * - Octavus Events (----): Octavus-specific protocol events
+ */
+
+/**
+ * Schema for file references used in trigger input, user messages, and tool results.
+ */
+declare const fileReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    mediaType: z.ZodString;
+    url: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const toolResultSchema: z.ZodObject<{
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        url: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    outputVariable: z.ZodOptional<z.ZodString>;
+    blockIndex: z.ZodOptional<z.ZodNumber>;
+    thread: z.ZodOptional<z.ZodString>;
+    workerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const chatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+        system: "system";
+    }>;
+    parts: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            object: "object";
+            source: "source";
+            text: "text";
+            reasoning: "reasoning";
+            "tool-call": "tool-call";
+            operation: "operation";
+            file: "file";
+            worker: "worker";
+        }>;
+        visible: z.ZodBoolean;
+        content: z.ZodOptional<z.ZodString>;
+        toolCall: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                streaming: "streaming";
+                available: "available";
+                error: "error";
+            }>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+            thoughtSignature: z.ZodOptional<z.ZodString>;
+            display: z.ZodOptional<z.ZodEnum<{
+                name: "name";
+                hidden: "hidden";
+                description: "description";
+                stream: "stream";
+            }>>;
+        }, z.core.$strip>>;
+        operation: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            operationType: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            sourceType: z.ZodLiteral<"url">;
+            id: z.ZodString;
+            url: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            sourceType: z.ZodLiteral<"document">;
+            id: z.ZodString;
+            mediaType: z.ZodString;
+            title: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "sourceType">>;
+        file: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            mediaType: z.ZodString;
+            url: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            toolCallId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        object: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            typeName: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>;
+        worker: z.ZodOptional<z.ZodObject<{
+            workerId: z.ZodString;
+            workerSlug: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            nestedParts: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    object: "object";
+                    source: "source";
+                    text: "text";
+                    reasoning: "reasoning";
+                    "tool-call": "tool-call";
+                    operation: "operation";
+                    file: "file";
+                }>;
+                visible: z.ZodBoolean;
+                content: z.ZodOptional<z.ZodString>;
+                toolCall: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        streaming: "streaming";
+                        available: "available";
+                        error: "error";
+                    }>;
+                    result: z.ZodOptional<z.ZodUnknown>;
+                    error: z.ZodOptional<z.ZodString>;
+                    thoughtSignature: z.ZodOptional<z.ZodString>;
+                    display: z.ZodOptional<z.ZodEnum<{
+                        name: "name";
+                        hidden: "hidden";
+                        description: "description";
+                        stream: "stream";
+                    }>>;
+                }, z.core.$strip>>;
+                operation: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    operationType: z.ZodString;
+                }, z.core.$strip>>;
+                source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    sourceType: z.ZodLiteral<"url">;
+                    id: z.ZodString;
+                    url: z.ZodString;
+                    title: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    sourceType: z.ZodLiteral<"document">;
+                    id: z.ZodString;
+                    mediaType: z.ZodString;
+                    title: z.ZodString;
+                    filename: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>], "sourceType">>;
+                file: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    mediaType: z.ZodString;
+                    url: z.ZodString;
+                    filename: z.ZodOptional<z.ZodString>;
+                    size: z.ZodOptional<z.ZodNumber>;
+                    toolCallId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                object: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    typeName: z.ZodString;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>;
+                thread: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodString;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    content: z.ZodString;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            streaming: "streaming";
+            available: "available";
+            error: "error";
+        }>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        thoughtSignature: z.ZodOptional<z.ZodString>;
+        display: z.ZodOptional<z.ZodEnum<{
+            name: "name";
+            hidden: "hidden";
+            description: "description";
+            stream: "stream";
+        }>>;
+    }, z.core.$strip>>>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    reasoningSignature: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const uiWorkerStatusSchema: z.ZodEnum<{
+    error: "error";
+    done: "done";
+    running: "running";
+}>;
+declare const uiWorkerPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"worker">;
+    workerId: z.ZodString;
+    workerSlug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-call">;
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            error: "error";
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"operation">;
+        operationId: z.ZodString;
+        name: z.ZodString;
+        operationType: z.ZodString;
+        status: z.ZodEnum<{
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"url">;
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"document">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "sourceType">, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        url: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        id: z.ZodString;
+        typeName: z.ZodString;
+        partial: z.ZodOptional<z.ZodUnknown>;
+        object: z.ZodOptional<z.ZodUnknown>;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            error: "error";
+            done: "done";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        done: "done";
+        running: "running";
+    }>;
+}, z.core.$strip>;
+declare const uiMessagePartSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+    status: z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reasoning">;
+    text: z.ZodString;
+    status: z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>;
+    thread: z.ZodOptional<z.ZodString>;
+    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-call">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        error: "error";
+        done: "done";
+        running: "running";
+    }>;
+    thread: z.ZodOptional<z.ZodString>;
+    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"operation">;
+    operationId: z.ZodString;
+    name: z.ZodString;
+    operationType: z.ZodString;
+    status: z.ZodEnum<{
+        done: "done";
+        running: "running";
+    }>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"source">;
+    sourceType: z.ZodLiteral<"url">;
+    id: z.ZodString;
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"source">;
+    sourceType: z.ZodLiteral<"document">;
+    id: z.ZodString;
+    mediaType: z.ZodString;
+    title: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "sourceType">, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    id: z.ZodString;
+    mediaType: z.ZodString;
+    url: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    id: z.ZodString;
+    typeName: z.ZodString;
+    partial: z.ZodOptional<z.ZodUnknown>;
+    object: z.ZodOptional<z.ZodUnknown>;
+    status: z.ZodEnum<{
+        streaming: "streaming";
+        error: "error";
+        done: "done";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"worker">;
+    workerId: z.ZodString;
+    workerSlug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-call">;
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            error: "error";
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"operation">;
+        operationId: z.ZodString;
+        name: z.ZodString;
+        operationType: z.ZodString;
+        status: z.ZodEnum<{
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"url">;
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"document">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "sourceType">, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        url: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        id: z.ZodString;
+        typeName: z.ZodString;
+        partial: z.ZodOptional<z.ZodUnknown>;
+        object: z.ZodOptional<z.ZodUnknown>;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            error: "error";
+            done: "done";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        done: "done";
+        running: "running";
+    }>;
+}, z.core.$strip>]>;
+declare const uiMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+    }>;
+    parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"reasoning">;
+        text: z.ZodString;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            done: "done";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool-call">;
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            error: "error";
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"operation">;
+        operationId: z.ZodString;
+        name: z.ZodString;
+        operationType: z.ZodString;
+        status: z.ZodEnum<{
+            done: "done";
+            running: "running";
+        }>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"url">;
+        id: z.ZodString;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"source">;
+        sourceType: z.ZodLiteral<"document">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "sourceType">, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        id: z.ZodString;
+        mediaType: z.ZodString;
+        url: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodNumber>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        id: z.ZodString;
+        typeName: z.ZodString;
+        partial: z.ZodOptional<z.ZodUnknown>;
+        object: z.ZodOptional<z.ZodUnknown>;
+        status: z.ZodEnum<{
+            streaming: "streaming";
+            error: "error";
+            done: "done";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        thread: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"worker">;
+        workerId: z.ZodString;
+        workerSlug: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+            status: z.ZodEnum<{
+                streaming: "streaming";
+                done: "done";
+            }>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            status: z.ZodEnum<{
+                streaming: "streaming";
+                done: "done";
+            }>;
+            thread: z.ZodOptional<z.ZodString>;
+            providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                error: "error";
+                done: "done";
+                running: "running";
+            }>;
+            thread: z.ZodOptional<z.ZodString>;
+            providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"operation">;
+            operationId: z.ZodString;
+            name: z.ZodString;
+            operationType: z.ZodString;
+            status: z.ZodEnum<{
+                done: "done";
+                running: "running";
+            }>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceType: z.ZodLiteral<"url">;
+            id: z.ZodString;
+            url: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceType: z.ZodLiteral<"document">;
+            id: z.ZodString;
+            mediaType: z.ZodString;
+            title: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "sourceType">, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            id: z.ZodString;
+            mediaType: z.ZodString;
+            url: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            toolCallId: z.ZodOptional<z.ZodString>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            id: z.ZodString;
+            typeName: z.ZodString;
+            partial: z.ZodOptional<z.ZodUnknown>;
+            object: z.ZodOptional<z.ZodUnknown>;
+            status: z.ZodEnum<{
+                streaming: "streaming";
+                error: "error";
+                done: "done";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+            thread: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            error: "error";
+            done: "done";
+            running: "running";
+        }>;
+    }, z.core.$strip>]>>;
+    status: z.ZodEnum<{
+        streaming: "streaming";
+        done: "done";
+    }>;
+    createdAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+declare function safeParseStreamEvent(data: unknown): z.ZodSafeParseResult<{
+    type: "source";
+    sourceType: "url";
+    id: string;
+    url: string;
+    title?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "source";
+    sourceType: "document";
+    id: string;
+    mediaType: string;
+    title: string;
+    filename?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "start";
+    messageId?: string | undefined;
+    executionId?: string | undefined;
+    lastMessageId?: string | undefined;
+} | {
+    type: "finish";
+    finishReason: "error" | "stop" | "tool-calls" | "client-tool-calls" | "length" | "content-filter" | "other";
+    executionId?: string | undefined;
+} | {
+    type: "error";
+    errorType: "authentication_error" | "permission_error" | "validation_error" | "not_found_error" | "rate_limit_error" | "quota_exceeded_error" | "provider_error" | "provider_overloaded" | "provider_timeout" | "execution_error" | "tool_error" | "protocol_error" | "internal_error" | "unknown_error";
+    message: string;
+    retryable: boolean;
+    source: "platform" | "provider" | "tool" | "client";
+    retryAfter?: number | undefined;
+    code?: string | undefined;
+    provider?: {
+        name: string;
+        model?: string | undefined;
+        statusCode?: number | undefined;
+        errorType?: string | undefined;
+        requestId?: string | undefined;
+    } | undefined;
+    tool?: {
+        name: string;
+        callId?: string | undefined;
+    } | undefined;
+} | {
+    type: "text-start";
+    id: string;
+    responseType?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "text-delta";
+    id: string;
+    delta: string;
+    workerId?: string | undefined;
+} | {
+    type: "text-end";
+    id: string;
+    workerId?: string | undefined;
+} | {
+    type: "reasoning-start";
+    id: string;
+    workerId?: string | undefined;
+} | {
+    type: "reasoning-delta";
+    id: string;
+    delta: string;
+    workerId?: string | undefined;
+} | {
+    type: "reasoning-end";
+    id: string;
+    workerId?: string | undefined;
+} | {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+    title?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "tool-input-delta";
+    toolCallId: string;
+    inputTextDelta: string;
+    workerId?: string | undefined;
+} | {
+    type: "tool-input-end";
+    toolCallId: string;
+    workerId?: string | undefined;
+} | {
+    type: "tool-input-available";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    workerId?: string | undefined;
+} | {
+    type: "tool-output-available";
+    toolCallId: string;
+    output: unknown;
+    workerId?: string | undefined;
+} | {
+    type: "tool-output-error";
+    toolCallId: string;
+    error: string;
+    workerId?: string | undefined;
+} | {
+    type: "block-start";
+    blockId: string;
+    blockName: string;
+    blockType: string;
+    display: "name" | "hidden" | "description" | "stream";
+    description?: string | undefined;
+    outputToChat?: boolean | undefined;
+    thread?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "block-end";
+    blockId: string;
+    summary?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "resource-update";
+    name: string;
+    value: unknown;
+} | {
+    type: "tool-request";
+    toolCalls: {
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+        source?: "llm" | "block" | undefined;
+        outputVariable?: string | undefined;
+        blockIndex?: number | undefined;
+        thread?: string | undefined;
+        workerId?: string | undefined;
+    }[];
+    workerId?: string | undefined;
+} | {
+    type: "client-tool-request";
+    executionId: string;
+    toolCalls: {
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+        source?: "llm" | "block" | undefined;
+        outputVariable?: string | undefined;
+        blockIndex?: number | undefined;
+        thread?: string | undefined;
+        workerId?: string | undefined;
+    }[];
+    serverToolResults?: {
+        toolCallId: string;
+        toolName?: string | undefined;
+        result?: unknown;
+        error?: string | undefined;
+        files?: {
+            id: string;
+            mediaType: string;
+            url: string;
+            filename?: string | undefined;
+            size?: number | undefined;
+        }[] | undefined;
+        outputVariable?: string | undefined;
+        blockIndex?: number | undefined;
+        thread?: string | undefined;
+        workerId?: string | undefined;
+    }[] | undefined;
+} | {
+    type: "file-available";
+    id: string;
+    mediaType: string;
+    url: string;
+    filename?: string | undefined;
+    size?: number | undefined;
+    toolCallId?: string | undefined;
+    workerId?: string | undefined;
+} | {
+    type: "worker-start";
+    workerId: string;
+    workerSlug: string;
+    description?: string | undefined;
+} | {
+    type: "worker-result";
+    workerId: string;
+    output?: unknown;
+    error?: string | undefined;
+}>;
+declare function safeParseUIMessage(data: unknown): z.ZodSafeParseResult<{
+    id: string;
+    role: "user" | "assistant";
+    parts: ({
+        type: "source";
+        sourceType: "url";
+        id: string;
+        url: string;
+        title?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "source";
+        sourceType: "document";
+        id: string;
+        mediaType: string;
+        title: string;
+        filename?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "text";
+        text: string;
+        status: "streaming" | "done";
+        thread?: string | undefined;
+    } | {
+        type: "reasoning";
+        text: string;
+        status: "streaming" | "done";
+        thread?: string | undefined;
+        providerMetadata?: Record<string, unknown> | undefined;
+    } | {
+        type: "tool-call";
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+        status: "pending" | "error" | "done" | "running";
+        displayName?: string | undefined;
+        result?: unknown;
+        error?: string | undefined;
+        thread?: string | undefined;
+        providerMetadata?: Record<string, unknown> | undefined;
+    } | {
+        type: "operation";
+        operationId: string;
+        name: string;
+        operationType: string;
+        status: "done" | "running";
+        thread?: string | undefined;
+    } | {
+        type: "file";
+        id: string;
+        mediaType: string;
+        url: string;
+        filename?: string | undefined;
+        size?: number | undefined;
+        toolCallId?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "object";
+        id: string;
+        typeName: string;
+        status: "streaming" | "error" | "done";
+        partial?: unknown;
+        object?: unknown;
+        error?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "worker";
+        workerId: string;
+        workerSlug: string;
+        parts: ({
+            type: "source";
+            sourceType: "url";
+            id: string;
+            url: string;
+            title?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "source";
+            sourceType: "document";
+            id: string;
+            mediaType: string;
+            title: string;
+            filename?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "text";
+            text: string;
+            status: "streaming" | "done";
+            thread?: string | undefined;
+        } | {
+            type: "reasoning";
+            text: string;
+            status: "streaming" | "done";
+            thread?: string | undefined;
+            providerMetadata?: Record<string, unknown> | undefined;
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            status: "pending" | "error" | "done" | "running";
+            displayName?: string | undefined;
+            result?: unknown;
+            error?: string | undefined;
+            thread?: string | undefined;
+            providerMetadata?: Record<string, unknown> | undefined;
+        } | {
+            type: "operation";
+            operationId: string;
+            name: string;
+            operationType: string;
+            status: "done" | "running";
+            thread?: string | undefined;
+        } | {
+            type: "file";
+            id: string;
+            mediaType: string;
+            url: string;
+            filename?: string | undefined;
+            size?: number | undefined;
+            toolCallId?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "object";
+            id: string;
+            typeName: string;
+            status: "streaming" | "error" | "done";
+            partial?: unknown;
+            object?: unknown;
+            error?: string | undefined;
+            thread?: string | undefined;
+        })[];
+        status: "error" | "done" | "running";
+        description?: string | undefined;
+        output?: unknown;
+        error?: string | undefined;
+    })[];
+    status: "streaming" | "done";
+    createdAt: Date;
+}>;
+declare function safeParseUIMessages(data: unknown): z.ZodSafeParseResult<{
+    id: string;
+    role: "user" | "assistant";
+    parts: ({
+        type: "source";
+        sourceType: "url";
+        id: string;
+        url: string;
+        title?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "source";
+        sourceType: "document";
+        id: string;
+        mediaType: string;
+        title: string;
+        filename?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "text";
+        text: string;
+        status: "streaming" | "done";
+        thread?: string | undefined;
+    } | {
+        type: "reasoning";
+        text: string;
+        status: "streaming" | "done";
+        thread?: string | undefined;
+        providerMetadata?: Record<string, unknown> | undefined;
+    } | {
+        type: "tool-call";
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+        status: "pending" | "error" | "done" | "running";
+        displayName?: string | undefined;
+        result?: unknown;
+        error?: string | undefined;
+        thread?: string | undefined;
+        providerMetadata?: Record<string, unknown> | undefined;
+    } | {
+        type: "operation";
+        operationId: string;
+        name: string;
+        operationType: string;
+        status: "done" | "running";
+        thread?: string | undefined;
+    } | {
+        type: "file";
+        id: string;
+        mediaType: string;
+        url: string;
+        filename?: string | undefined;
+        size?: number | undefined;
+        toolCallId?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "object";
+        id: string;
+        typeName: string;
+        status: "streaming" | "error" | "done";
+        partial?: unknown;
+        object?: unknown;
+        error?: string | undefined;
+        thread?: string | undefined;
+    } | {
+        type: "worker";
+        workerId: string;
+        workerSlug: string;
+        parts: ({
+            type: "source";
+            sourceType: "url";
+            id: string;
+            url: string;
+            title?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "source";
+            sourceType: "document";
+            id: string;
+            mediaType: string;
+            title: string;
+            filename?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "text";
+            text: string;
+            status: "streaming" | "done";
+            thread?: string | undefined;
+        } | {
+            type: "reasoning";
+            text: string;
+            status: "streaming" | "done";
+            thread?: string | undefined;
+            providerMetadata?: Record<string, unknown> | undefined;
+        } | {
+            type: "tool-call";
+            toolCallId: string;
+            toolName: string;
+            args: Record<string, unknown>;
+            status: "pending" | "error" | "done" | "running";
+            displayName?: string | undefined;
+            result?: unknown;
+            error?: string | undefined;
+            thread?: string | undefined;
+            providerMetadata?: Record<string, unknown> | undefined;
+        } | {
+            type: "operation";
+            operationId: string;
+            name: string;
+            operationType: string;
+            status: "done" | "running";
+            thread?: string | undefined;
+        } | {
+            type: "file";
+            id: string;
+            mediaType: string;
+            url: string;
+            filename?: string | undefined;
+            size?: number | undefined;
+            toolCallId?: string | undefined;
+            thread?: string | undefined;
+        } | {
+            type: "object";
+            id: string;
+            typeName: string;
+            status: "streaming" | "error" | "done";
+            partial?: unknown;
+            object?: unknown;
+            error?: string | undefined;
+            thread?: string | undefined;
+        })[];
+        status: "error" | "done" | "running";
+        description?: string | undefined;
+        output?: unknown;
+        error?: string | undefined;
+    })[];
+    status: "streaming" | "done";
+    createdAt: Date;
+}[]>;
+/**
+ * Type guard to check if a value is a FileReference object.
+ */
+declare function isFileReference(value: unknown): value is z.infer<typeof fileReferenceSchema>;
+/**
+ * Type guard to check if a value is an array of FileReference objects.
+ */
+declare function isFileReferenceArray(value: unknown): value is z.infer<typeof fileReferenceSchema>[];
+
+/**
+ * Internal Octavus tool definitions.
+ *
+ * These tools are reserved by Octavus and executed server-side.
+ * User-defined tools and workers cannot use the "octavus_" prefix.
+ */
+/**
+ * Prefix reserved for internal Octavus tools.
+ * User-defined tools/workers cannot use this prefix.
+ */
+declare const OCTAVUS_INTERNAL_PREFIX = "octavus_";
+/**
+ * All internal Octavus tool names.
+ *
+ * These are tools that are executed server-side by the Octavus runtime.
+ * They should never be sent to client handlers.
+ */
+declare const OCTAVUS_INTERNAL_TOOLS: {
+    /** Read skill documentation (SKILL.md) */
+    readonly SKILL_READ: "octavus_skill_read";
+    /** List available scripts in a skill */
+    readonly SKILL_LIST: "octavus_skill_list";
+    /** Execute a pre-built skill script */
+    readonly SKILL_RUN: "octavus_skill_run";
+    /** Execute Python/Bash code in sandbox */
+    readonly CODE_RUN: "octavus_code_run";
+    /** Create/write files in sandbox */
+    readonly FILE_WRITE: "octavus_file_write";
+    /** Read files from sandbox */
+    readonly FILE_READ: "octavus_file_read";
+    /** List all available references with descriptions */
+    readonly REFERENCE_LIST: "octavus_reference_list";
+    /** Read the full content of a specific reference */
+    readonly REFERENCE_READ: "octavus_reference_read";
+    /** Generate images using AI models */
+    readonly GENERATE_IMAGE: "octavus_generate_image";
+    /** Search the web for current information */
+    readonly WEB_SEARCH: "octavus_web_search";
+};
+type OctavusInternalToolName = (typeof OCTAVUS_INTERNAL_TOOLS)[keyof typeof OCTAVUS_INTERNAL_TOOLS];
+/**
+ * Check if a tool name is an internal Octavus tool.
+ *
+ * Internal tools are reserved by Octavus and executed server-side.
+ * User-defined tools cannot start with "octavus_".
+ *
+ * @example
+ * ```typescript
+ * if (isOctavusInternalTool(toolName)) {
+ *   // This is an internal Octavus tool, skip client handling
+ * }
+ * ```
+ */
+declare function isOctavusInternalTool(toolName: string): boolean;
+/**
+ * Skill tool names (subset of internal tools).
+ *
+ * Use this for skill-specific filtering. For checking if any tool is internal,
+ * use `isOctavusInternalTool()` instead.
+ */
+declare const OCTAVUS_SKILL_TOOLS: {
+    readonly SKILL_READ: "octavus_skill_read";
+    readonly SKILL_LIST: "octavus_skill_list";
+    readonly SKILL_RUN: "octavus_skill_run";
+    readonly CODE_RUN: "octavus_code_run";
+    readonly FILE_WRITE: "octavus_file_write";
+    readonly FILE_READ: "octavus_file_read";
+};
+type OctavusSkillToolName = (typeof OCTAVUS_SKILL_TOOLS)[keyof typeof OCTAVUS_SKILL_TOOLS];
+/**
+ * Check if a tool name is an Octavus skill tool.
+ *
+ * Skill tools are a subset of internal tools that execute in E2B sandboxes.
+ *
+ * @example
+ * ```typescript
+ * if (isOctavusSkillTool(event.toolName)) {
+ *   // This is a skill tool, executed in E2B sandbox
+ *   const skillSlug = event.input?.skill;
+ * }
+ * ```
+ */
+declare function isOctavusSkillTool(toolName: string): toolName is OctavusSkillToolName;
+/**
+ * Reference tool names (subset of internal tools).
+ *
+ * Reference tools let agents dynamically fetch agent-local documents
+ * without loading everything into the system prompt upfront.
+ */
+declare const OCTAVUS_REFERENCE_TOOLS: {
+    readonly REFERENCE_LIST: "octavus_reference_list";
+    readonly REFERENCE_READ: "octavus_reference_read";
+};
+type OctavusReferenceToolName = (typeof OCTAVUS_REFERENCE_TOOLS)[keyof typeof OCTAVUS_REFERENCE_TOOLS];
+/**
+ * Check if a tool name is an Octavus reference tool.
+ */
+declare function isOctavusReferenceTool(toolName: string): toolName is OctavusReferenceToolName;
+
+/**
+ * Skill-specific utilities.
+ *
+ * For internal tool definitions and checking, see internal-tools.ts
+ */
+
+/**
+ * Extract skill slug from skill tool arguments.
+ *
+ * Most skill tools include a `skill` parameter with the skill slug.
+ * Returns undefined if the tool is not a skill tool or if the skill slug is not present.
+ *
+ * @example
+ * ```typescript
+ * const slug = getSkillSlugFromToolCall(event.toolName, event.input);
+ * if (slug) {
+ *   console.log(`Using skill: ${slug}`);
+ * }
+ * ```
+ */
+declare function getSkillSlugFromToolCall(toolName: string, args: Record<string, unknown> | undefined): string | undefined;
+
+export { AppError, type BlockEndEvent, type BlockStartEvent, type ChatMessage, type ClientToolRequestEvent, ConflictError, type CreateErrorEventOptions, type DisplayMode, type ErrorEvent, type ErrorSource, type ErrorType, type FileAvailableEvent, type FileInfo, type FileReference, type FinishEvent, type FinishReason, ForbiddenError, type GeneratedFile, MAIN_THREAD, type MessagePart, type MessagePartType, type MessageRole, NotFoundError, OCTAVUS_INTERNAL_PREFIX, OCTAVUS_INTERNAL_TOOLS, OCTAVUS_REFERENCE_TOOLS, OCTAVUS_SKILL_TOOLS, type ObjectInfo, OctavusError, type OctavusErrorOptions, type OctavusInternalToolName, type OctavusReferenceToolName, type OctavusSkillToolName, type OperationInfo, type PendingToolCall, type ProviderErrorInfo, type ReasoningDeltaEvent, type ReasoningEndEvent, type ReasoningStartEvent, type ResourceUpdateEvent, type ResourceUpdateHandler, type SourceDocumentEvent, type SourceDocumentInfo, type SourceEvent, type SourceInfo, type SourceUrlEvent, type SourceUrlInfo, type StartEvent, type StreamEvent, type TextDeltaEvent, type TextEndEvent, type TextStartEvent, type ToolCallInfo, type ToolCallStatus, type ToolErrorInfo, type ToolHandler, type ToolHandlers, type ToolInputAvailableEvent, type ToolInputDeltaEvent, type ToolInputEndEvent, type ToolInputStartEvent, type ToolOutputAvailableEvent, type ToolOutputErrorEvent, type ToolProvider, type ToolRequestEvent, type ToolResult, type ToolResultEntry, type ToolSchema, type UIFilePart, type UIMessage, type UIMessagePart, type UIMessageStatus, type UIObjectPart, type UIObjectStatus, type UIOperationPart, type UIOperationStatus, type UIPartStatus, type UIReasoningPart, type UISourceDocumentPart, type UISourcePart, type UISourceUrlPart, type UITextPart, type UIToolCallPart, type UIToolCallStatus, type UIWorkerPart, type UIWorkerStatus, ValidationError, type WorkerPartInfo, type WorkerResultEvent, type WorkerStartEvent, chatMessageSchema, createApiErrorEvent, createErrorEvent, createInternalErrorEvent, errorToStreamEvent, fileReferenceSchema, generateId, getSkillSlugFromToolCall, isAbortError, isAuthenticationError, isFileReference, isFileReferenceArray, isMainThread, isOctavusInternalTool, isOctavusReferenceTool, isOctavusSkillTool, isOtherThread, isProviderError, isRateLimitError, isRetryableError, isToolError, isValidationError, resolveThread, safeParseStreamEvent, safeParseUIMessage, safeParseUIMessages, threadForPart, toolResultSchema, uiMessagePartSchema, uiMessageSchema, uiWorkerPartSchema, uiWorkerStatusSchema };