@standardagents/builder 0.15.3 → 0.17.0-next.a4b7340

package/dist/runtime.d.ts

@@ -0,0 +1,3124 @@
+import { e as ThreadEnv, h as ThreadMetadata, M as Message, l as FileRecord, F as FlowState, n as FileStats, G as GrepResult, m as AttachmentRef, r as MessageContent, E as Env, g as ThreadInstance } from './index-EaxysUHv.js';
+export { A as Agent, f as BuilderThreadEndpointHandler, B as Controller, a as ControllerContext, j as FlowResult, p as ImageContentPart, I as ImageMetadata, L as LLMResponse, q as MultimodalContent, R as RequestContext, S as StorageBackend, k as TelemetryEvent, o as TextContentPart, b as ThreadEndpointContext, T as ToolCall, i as ToolResult, c as createThreadEndpointHandler, d as defineController } from './index-EaxysUHv.js';
+import { CodeExecutionOptions, CodeExecutionResult, SubagentRegistryEntry, InjectMessageInput, QueueMessageInput, ModelDefinition as ModelDefinition$1, ToolArgs, PromptTextPart, PromptEnvPart, VariableDefinition, SubpromptConfig as SubpromptConfig$1, PromptToolConfig as PromptToolConfig$1, SubagentToolConfig as SubagentToolConfig$1, ReasoningConfig, SideConfig as SideConfig$1, LLMProviderInterface, ContentPart, TextPart, ImagePart, FilePart, NamespaceContext, DefinitionLoader } from '@standardagents/spec';
+export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ModelCapabilities as ProviderModelCapabilities, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel } from '@standardagents/spec';
+import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
+import { N as NamespacedRegistry } from './types-Bpe7IANZ.js';
+import '@cloudflare/workers-types';
+import 'zod';
+
+/**
+ * Global namespace for AgentBuilder types.
+ *
+ * This namespace provides type-safe references for models, prompts, agents, and tools.
+ * Types are automatically populated when you run `pnpm dev` or `pnpm build`,
+ * which scans your `agentbuilder/` directories and generates types.
+ *
+ * The generated types are placed in `.agents/types.d.ts` and augment the
+ * StandardAgentSpec namespace from @standardagents/spec.
+ *
+ * Note: This namespace is provided for backward compatibility. New code should
+ * use StandardAgentSpec types directly, which are defined in @standardagents/spec.
+ *
+ * @deprecated Use StandardAgentSpec namespace from @standardagents/spec instead
+ */
+declare global {
+    namespace AgentBuilder {
+        /**
+         * Interface for model type registration.
+         * @deprecated Use StandardAgentSpec.ModelRegistry instead
+         */
+        interface ModelRegistry extends StandardAgentSpec.ModelRegistry {
+        }
+        /**
+         * Interface for prompt type registration.
+         * @deprecated Use StandardAgentSpec.PromptRegistry instead
+         */
+        interface PromptRegistry extends StandardAgentSpec.PromptRegistry {
+        }
+        /**
+         * Interface for agent type registration.
+         * @deprecated Use StandardAgentSpec.AgentRegistry instead
+         */
+        interface AgentRegistry extends StandardAgentSpec.AgentRegistry {
+        }
+        /**
+         * Interface for tool type registration.
+         * @deprecated Use StandardAgentSpec.ToolRegistry instead
+         */
+        interface ToolRegistry extends StandardAgentSpec.ToolRegistry {
+        }
+        /**
+         * Interface for callable type registration (prompts, agents, tools).
+         * @deprecated Use StandardAgentSpec.CallableRegistry instead
+         */
+        interface CallableRegistry extends StandardAgentSpec.CallableRegistry {
+        }
+        /**
+         * Union type of all model names defined in agentbuilder/models/.
+         * @deprecated Use StandardAgentSpec.Models instead
+         */
+        type Models = StandardAgentSpec.Models;
+        /**
+         * Union type of all prompt names defined in agentbuilder/prompts/.
+         * @deprecated Use StandardAgentSpec.Prompts instead
+         */
+        type Prompts = StandardAgentSpec.Prompts;
+        /**
+         * Union type of all agent names defined in agentbuilder/agents/.
+         * @deprecated Use StandardAgentSpec.Agents instead
+         */
+        type Agents = StandardAgentSpec.Agents;
+        /**
+         * Union type of all tool names defined in agentbuilder/tools/.
+         * @deprecated Use StandardAgentSpec.Tools instead
+         */
+        type Tools = StandardAgentSpec.Tools;
+        /**
+         * Union type of all callable items (prompts, agents, tools) that can be used as tools.
+         * @deprecated Use StandardAgentSpec.Callables instead
+         */
+        type Callables = StandardAgentSpec.Callables;
+        /**
+         * Interface for hook ID registration.
+         * @deprecated Use StandardAgentSpec.HookIdRegistry instead
+         */
+        interface HookIdRegistry extends StandardAgentSpec.HookIdRegistry {
+        }
+        /**
+         * Union type of all hook IDs defined in agents/hooks/.
+         * @deprecated Use StandardAgentSpec.HookIds instead
+         */
+        type Hooks = StandardAgentSpec.HookIds;
+    }
+}
+
+/**
+ * Authentication middleware for protecting API routes
+ *
+ * Supports multiple authentication types:
+ * - Super admin token (signed with ENCRYPTION_KEY)
+ * - User session token (validated against DurableAgentBuilder)
+ * - API key (validated against DurableAgentBuilder)
+ */
+interface AuthUser {
+    id: string;
+    username: string;
+    role: string;
+}
+interface AuthContext {
+    user: AuthUser;
+    authType: 'super_admin' | 'session' | 'api_key';
+}
+/**
+ * Authenticate a request using various token types
+ */
+declare function authenticate(request: Request, env: any): Promise<AuthContext | null>;
+/**
+ * Middleware to require authentication
+ * Returns 401 if not authenticated
+ */
+declare function requireAuth(request: Request, env: any): Promise<AuthContext | Response>;
+/**
+ * Middleware to require admin role
+ * Returns 401 if not authenticated, 403 if not admin
+ */
+declare function requireAdmin(request: Request, env: any): Promise<AuthContext | Response>;
+
+type AlarmQueueStatus = "pending" | "processing" | "completed" | "failed" | "agent_canceled" | "user_canceled";
+type EffectCancelSource = "agent" | "user";
+interface EffectRunRecord {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    scheduledAt: number;
+    createdAt: number;
+    status: AlarmQueueStatus;
+    attempts: number;
+    error: string | null;
+    completedAt: number | null;
+    manualRun: boolean;
+    manualRunAt: number | null;
+    replayedFrom: string | null;
+}
+interface EffectRunListOptions {
+    limit?: number;
+    offset?: number;
+}
+interface EffectRunListResult {
+    effects: EffectRunRecord[];
+    total: number;
+    upcomingCount: number;
+    limit: number;
+    offset: number;
+}
+interface EffectRunActionResult {
+    action: "ran" | "replayed";
+    id: string;
+    replayedId?: string;
+}
+
+interface CodeExecutionBridgeRegistration {
+    call(functionId: string, encodedArgs: unknown[]): Promise<unknown>;
+}
+
+type ThreadEndpointCodeOptions = Pick<CodeExecutionOptions, "language" | "filename" | "execute" | "modules" | "memoryLimitBytes">;
+declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableObject<Env> {
+    private migratedToVersion;
+    private logSockets;
+    private messageSockets;
+    private alarmQueue;
+    private alarmQueueRearmed;
+    private currentAbortController;
+    private isExecuting;
+    private codeExecutionBridges;
+    constructor(ctx: DurableObjectState, env: Env);
+    /**
+     * Returns the tools registry for this thread.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of tool name to tool loader function
+     *
+     * @example
+     * ```typescript
+     * import { DurableThread } from 'virtual:@standardagents/builder'
+     *
+     * export class Thread extends DurableThread {}
+     * ```
+     */
+    tools(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the hooks registry for this thread.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of hook name to hook loader function
+     *
+     * @example
+     * ```typescript
+     * import { DurableThread } from 'virtual:@standardagents/builder'
+     *
+     * export class Thread extends DurableThread {}
+     * ```
+     */
+    hooks(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the models registry for lazy-loading model definitions.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of model name to model loader function
+     */
+    models(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the prompts registry for lazy-loading prompt definitions.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of prompt name to prompt loader function
+     */
+    prompts(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the agents registry for lazy-loading agent definitions.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of agent name to agent loader function
+     */
+    agents(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the effects registry for lazy-loading effect definitions.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * Effects are scheduled operations that run outside the tool execution context,
+     * ideal for delayed notifications, webhooks, and cleanup tasks.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns Record of effect name to effect loader function
+     */
+    effects(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the namespaced registry for packed agent support.
+     * This method is implemented when you import DurableThread from 'virtual:@standardagents/builder'.
+     *
+     * @throws Error if not implemented in a subclass
+     * @returns The namespaced registry with global and packages namespaces
+     */
+    registry(): any;
+    /**
+     * Load a model definition by name.
+     * Supports both global models and packed models (e.g., "packageId/modelName").
+     * For scoped packages, use "@scope/pkg/modelName".
+     * For packed context, tries package first then falls back to global.
+     */
+    loadModel(name: string): Promise<any>;
+    /**
+     * List available model names.
+     */
+    getModelNames(): string[];
+    /**
+     * Load a prompt definition by name.
+     * Supports both global prompts (e.g., "my-prompt") and packed prompts (e.g., "packageId/promptName").
+     */
+    loadPrompt(name: string): Promise<any>;
+    /**
+     * List available prompt names.
+     */
+    getPromptNames(): string[];
+    /**
+     * Load an agent definition by name.
+     * Supports both global agents (e.g., "my-agent") and packed agents (e.g., "packageId/agentName").
+     * For scoped packages, use "@scope/pkg/agentName".
+     */
+    loadAgent(name: string): Promise<any>;
+    /**
+     * List available agent names.
+     */
+    getAgentNames(): string[];
+    /**
+     * Load an effect definition by name.
+     */
+    loadEffect(name: string): Promise<any>;
+    /**
+     * List available effect names.
+     */
+    getEffectNames(): string[];
+    /**
+     * Load a tool definition by name.
+     * Supports both global tools (e.g., "my_tool") and packed tools (e.g., "packageId/toolName").
+     */
+    loadTool(name: string): Promise<any>;
+    /**
+     * Get thread metadata from DurableAgentBuilder.
+     * Used for creating ThreadState outside of flow execution.
+     */
+    getThreadMetadata(threadId: string): Promise<ThreadMetadata>;
+    /**
+     * Execute sandboxed code for a thread endpoint from inside the thread DO.
+     *
+     * Thread endpoint handlers often start in the top-level Worker with only a
+     * Durable Object stub. Code execution must originate here so the dynamic
+     * worker can use this DO's env, ctx exports, and bridge registration map.
+     */
+    executeThreadEndpointCode(threadId: string, source: string, options: ThreadEndpointCodeOptions): Promise<CodeExecutionResult>;
+    /**
+     * Execute ThreadState.runCode for endpoint handlers that only have a
+     * Durable Object stub. The actual Dynamic Worker must be started inside this
+     * DurableThread so it has access to env, ctx exports, and bridge callbacks.
+     */
+    executeThreadStateRunCode(threadId: string, source: string, options?: CodeExecutionOptions, wantsReport?: boolean): Promise<CodeExecutionResult>;
+    /**
+     * Read a JSON value from this thread's durable key-value store.
+     */
+    getValue<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Write a JSON value to this thread's durable key-value store.
+     *
+     * Per the Standard Agents spec, null and undefined delete the key.
+     */
+    setValue(key: string, value: unknown): Promise<void>;
+    listValues(options?: {
+        search?: string | null;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        values: Array<{
+            key: string;
+            value: unknown;
+            serialized: string;
+            size: number;
+            updatedAt: number;
+            parseError?: string;
+        }>;
+        total: number;
+        limit: number;
+        offset: number;
+        search: string | null;
+    }>;
+    private assertValidThreadValueKey;
+    private escapeThreadValueLike;
+    private serializeThreadValue;
+    private assertJsonSerializableThreadValue;
+    /**
+     * Trigger an agent to run on this thread.
+     *
+     * Queues an agent execution via the alarm queue. The execution
+     * runs asynchronously in the background.
+     *
+     * @param threadId - Thread ID for the execution
+     * @param agentName - Name of the agent to run
+     */
+    runAgent(threadId: string, agentName: string): Promise<void>;
+    /**
+     * Get the persisted resumable-subagent registry for this thread.
+     */
+    getChildrenRegistry(_threadId: string): Promise<SubagentRegistryEntry[]>;
+    private setChildrenRegistry;
+    upsertChildRegistry(_threadId: string, entry: SubagentRegistryEntry): Promise<void>;
+    updateChildRegistryStatus(_threadId: string, reference: string, status: string): Promise<void>;
+    removeChildRegistry(_threadId: string, reference: string): Promise<void>;
+    private asOptionalString;
+    private asOptionalBoolean;
+    private getThreadNameFromTags;
+    private toSubagentProjection;
+    private resolveSubagentMessageProjections;
+    /**
+     * Inject a top-level message without starting a new execution.
+     *
+     * This path is used by effects and thread endpoints, which run without a
+     * FlowState but still need to write visible messages to the thread.
+     */
+    injectMessage(threadId: string, message: InjectMessageInput): Promise<Message>;
+    /**
+     * Queue a message for deferred delivery.
+     */
+    queueMessage(threadId: string, message: QueueMessageInput): Promise<void>;
+    private hasPendingTurnAlarm;
+    private ensureQueuedMessageExecution;
+    private ensureRootMessageId;
+    /**
+     * Soft-terminate this thread.
+     */
+    terminateThread(threadId: string): Promise<{
+        success: boolean;
+        terminated: number;
+    }>;
+    /**
+     * Schedule an effect for future execution.
+     *
+     * @param threadId - Thread ID for the effect execution context
+     * @param effectName - Name of the effect to schedule
+     * @param effectArgs - Arguments to pass to the effect handler
+     * @param delayMs - Delay in milliseconds before execution (default: 0)
+     * @returns UUID of the scheduled effect
+     */
+    scheduleEffect(threadId: string, effectName: string, effectArgs: Record<string, unknown>, delayMs?: number, options?: {
+        sourceLogId?: string | null;
+    }): Promise<string>;
+    /**
+     * Check whether an effect loader exists in either global or packed registries.
+     */
+    private effectExists;
+    /**
+     * Get scheduled effects for this thread.
+     *
+     * @param name - Optional effect name to filter by
+     * @returns Array of scheduled effect records
+     */
+    getScheduledEffects(name?: string): Promise<Array<{
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+        scheduledAt: number;
+        createdAt: number;
+    }>>;
+    /**
+     * List pending and historical effect runs for the AgentBuilder UI.
+     */
+    listEffectRuns(options?: EffectRunListOptions): Promise<EffectRunListResult>;
+    /**
+     * Run a pending effect now, or replay a historical effect immediately.
+     */
+    runEffectNow(effectRunId: string): Promise<EffectRunActionResult>;
+    /**
+     * Cancel a scheduled effect and keep it in history.
+     *
+     * @param id - The effect ID returned by scheduleEffect
+     * @returns true if the effect was found and canceled, false otherwise
+     */
+    removeScheduledEffect(id: string, canceledBy?: EffectCancelSource): Promise<boolean>;
+    /**
+     * Ensures the database schema is up to date.
+     * This method is called on the first request to the Durable Object.
+     * It checks the schema version and runs any pending migrations.
+     *
+     * Performance:
+     * - Already migrated to latest: ~0.1ms (single SELECT + integer comparison)
+     * - Needs migration: Runs once per Durable Object lifetime per schema version
+     * - Detects new migrations after code deployment
+     */
+    private ensureMigrated;
+    /**
+     * Gets the current schema version from the database.
+     * Returns 0 if the metadata table doesn't exist (brand new database).
+     */
+    private getCurrentVersion;
+    /**
+     * Runs all pending migrations sequentially.
+     * Each migration is run in order, starting from the current version + 1.
+     */
+    private runMigrations;
+    /**
+     * Legacy fetch handler for WebSocket upgrades only
+     */
+    fetch(request: Request): Promise<Response>;
+    registerCodeExecutionBridge(runId: string, bridge: CodeExecutionBridgeRegistration): void;
+    unregisterCodeExecutionBridge(runId: string): void;
+    callCodeExecutionBridge(runId: string, functionId: string, encodedArgs: unknown[]): Promise<unknown>;
+    /**
+     * Execute thread with initial messages (RPC method)
+     * Enqueues the execution to be processed by the alarm handler
+     */
+    execute(threadId: string, agentId: string, initial_messages?: any[], data?: any): Promise<Response>;
+    /**
+     * Execute a flow synchronously and return the final top-level message content.
+     * Used by blocking subagent tool calls.
+     */
+    executeBlocking(threadId: string, agentId: string, initial_messages?: any[], data?: any): Promise<{
+        status: "success" | "error";
+        result?: string;
+        error?: string;
+        attachments?: unknown[];
+        terminal?: boolean;
+    }>;
+    /**
+     * Send a new message to the thread (RPC method)
+     * Enqueues the message processing to be handled by the alarm handler
+     */
+    sendMessage(threadId: string, content: string, role?: string, attachments?: string): Promise<Response>;
+    /**
+     * Check if execution should be stopped (called by FlowEngine)
+     * Reads from SQLite for persistence across hibernation
+     */
+    shouldStop(): Promise<boolean>;
+    /**
+     * Returns the termination timestamp (microseconds) or null when active.
+     */
+    getTerminated(_threadId: string): Promise<number | null>;
+    private assertNotTerminated;
+    private getLatestTopLevelMessage;
+    private getTerminalSessionToolNames;
+    private parseAttachmentRefsJson;
+    private deleteAttachmentRefsFromJson;
+    private cancelQueuedMessage;
+    private parseMessageMetadata;
+    private extractSubagentIdFromMetadata;
+    private getLatestTerminalSessionMessageAfter;
+    private inferMimeTypeFromPath;
+    private extensionForMimeType;
+    private sanitizeFilename;
+    private splitFilename;
+    private resolveAttachmentMimeType;
+    private buildAttachmentTargetPath;
+    private copyAttachmentRefsToThread;
+    private readAttachmentDataFromSource;
+    private arrayBufferToBase64;
+    private formatSubagentAttachmentPathSummary;
+    private persistParentHandoffStatusMessage;
+    private buildMissingTerminalSessionFailure;
+    private deliverCompletionToParentIfNeeded;
+    private getParentCommunicationModeForChild;
+    /**
+     * Stop the currently executing thread (RPC method)
+     * Simple "off" switch - stops turns, only cleared by user messages
+     */
+    stop(): Promise<Response>;
+    /**
+     * Continue execution from where it stopped (RPC method)
+     * Useful for debugging - continues the FlowEngine with additional steps
+     * without adding a new message.
+     *
+     * @param threadId The thread ID
+     * @param side Which side to start from ('a' or 'b'), defaults to 'a'
+     */
+    continueExecution(threadId: string, side?: 'a' | 'b'): Promise<Response>;
+    /**
+     * Get message history (RPC method)
+     *
+     * By default, returns the newest messages (when truncating), but in chronological
+     * order (oldest first in the array). This is ideal for chat UIs where messages
+     * should be appended and scrolled to the bottom.
+     *
+     * The offset parameter allows "scrolling up" to view older messages.
+     *
+     * Example:
+     * - getMessages(10, 0) -> newest 10 messages, oldest first in array
+     * - getMessages(10, 10) -> next 10 older messages, oldest first in array
+     *
+     * @param limit Number of messages to return (default: 100)
+     * @param offset Number of newest messages to skip (default: 0)
+     * @param order Internal query order - "DESC" (default) fetches newest first then reverses
+     * @param includeSilent Include silent messages (UI-only messages)
+     * @param maxDepth Maximum depth to include (default: 0 for top-level only)
+     */
+    getMessages(limit?: number, offset?: number, order?: "ASC" | "DESC", includeSilent?: boolean, maxDepth?: number): Promise<{
+        messages: {
+            id: string;
+            role: string;
+            content: string | null;
+            name: string | null;
+            tool_calls: string | null;
+            tool_call_id: string | null;
+            tool_status: "success" | "error" | null;
+            log_id: string | null;
+            created_at: number;
+            silent: boolean;
+            parent_id: string | null;
+            depth: number;
+            status: "pending" | "completed" | "failed" | null;
+            reasoning_content: string | null;
+            reasoning_details: string | null;
+            attachments: any;
+            metadata: Record<string, unknown> | undefined;
+            subagent_id: string | null;
+        }[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get specific messages, optionally expanding any requested tool-call message
+     * to the full contiguous workblock it belongs to.
+     */
+    getMessagesByIds(ids: string[], includeSilent?: boolean, maxDepth?: number, includeWorkblocks?: boolean): Promise<{
+        messages: {
+            id: string;
+            role: string;
+            content: string | null;
+            name: string | null;
+            tool_calls: string | null;
+            tool_call_id: string | null;
+            tool_status: "success" | "error" | null;
+            log_id: string | null;
+            created_at: number;
+            silent: boolean;
+            parent_id: string | null;
+            depth: number;
+            status: "pending" | "completed" | "failed" | null;
+            reasoning_content: string | null;
+            reasoning_details: string | null;
+            attachments: any;
+            metadata: Record<string, unknown> | undefined;
+            subagent_id: string | null;
+        }[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Delete a message (RPC method)
+     * Also cleans up any attachment files stored on the thread filesystem
+     */
+    deleteMessage(messageId: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    /**
+     * Update a message's content (RPC method)
+     */
+    updateMessageContent(messageId: string, content: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    /**
+     * Seed messages directly into the database (RPC method - for testing)
+     * This bypasses the normal message processing flow
+     */
+    seedMessages(args: {
+        messages: Array<{
+            id: string;
+            role: string;
+            content: string;
+            created_at: number;
+            log_id?: string | null;
+        }>;
+    }): Promise<{
+        success: boolean;
+        count: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        count?: undefined;
+    }>;
+    /**
+     * Seed a log directly into the database (RPC method - for testing)
+     * This bypasses the normal log creation flow
+     */
+    seedLog(args: {
+        id: string;
+        message_id: string;
+        provider: string;
+        model: string;
+        created_at: number;
+        is_complete?: boolean;
+        prompt_name?: string;
+    }): Promise<{
+        success: boolean;
+        id: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        id?: undefined;
+    }>;
+    /**
+     * Get logs (RPC method)
+     */
+    getLogs(limit?: number, offset?: number, order?: "ASC" | "DESC"): Promise<{
+        logs: {
+            id: string;
+            message_id: string;
+            provider: string;
+            actual_provider: string | null;
+            standard_agents_router_used: boolean;
+            model: string;
+            model_name: string | null;
+            prompt_name: string | null;
+            tools_called: string | null;
+            queued_tools: string | null;
+            provider_tools: string | null;
+            parent_log_id: string | null;
+            retry_of_log_id: string | null;
+            error: string | null;
+            cost_total: number | null;
+            is_complete: boolean;
+            created_at: number;
+            request_body: string | null;
+        }[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get specific logs, optionally including all descendant logs.
+     */
+    getLogsByIds(ids: string[], includeDescendants?: boolean, order?: "ASC" | "DESC"): Promise<{
+        logs: {
+            id: string;
+            message_id: string;
+            provider: string;
+            actual_provider: string | null;
+            model: string;
+            model_name: string | null;
+            prompt_name: string | null;
+            tools_called: string | null;
+            queued_tools: string | null;
+            provider_tools: string | null;
+            parent_log_id: string | null;
+            retry_of_log_id: string | null;
+            error: string | null;
+            cost_total: number | null;
+            is_complete: boolean;
+            created_at: number;
+            request_body: string | null;
+        }[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get logs for specific messages, optionally expanding requested messages to
+     * the full contiguous workblock they belong to and including descendant logs.
+     */
+    getLogsByMessageIds(messageIds: string[], includeWorkblocks?: boolean, includeDescendants?: boolean, order?: "ASC" | "DESC"): Promise<{
+        logs: {
+            id: string;
+            message_id: string;
+            provider: string;
+            actual_provider: string | null;
+            model: string;
+            model_name: string | null;
+            prompt_name: string | null;
+            tools_called: string | null;
+            queued_tools: string | null;
+            provider_tools: string | null;
+            parent_log_id: string | null;
+            retry_of_log_id: string | null;
+            error: string | null;
+            cost_total: number | null;
+            is_complete: boolean;
+            created_at: number;
+            request_body: string | null;
+        }[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get detailed information for a single log (RPC method)
+     * This includes all fields including large ones like request/response bodies
+     */
+    getLogDetails(logId: string): Promise<{
+        id: string;
+        message_id: string;
+        provider: string;
+        actual_provider: string | null;
+        standard_agents_router_used: boolean;
+        model: string;
+        model_name: string | null;
+        endpoint: string | null;
+        request_body: string | null;
+        request_headers: string | null;
+        response_body: string | null;
+        response_headers: string | null;
+        status_code: number | null;
+        reasoning_content: string | null;
+        input_tokens: number | null;
+        cached_tokens: number | null;
+        output_tokens: number | null;
+        reasoning_tokens: number | null;
+        total_tokens: number | null;
+        latency_ms: number | null;
+        time_to_first_token_ms: number | null;
+        finish_reason: string | null;
+        error: string | null;
+        error_type: string | null;
+        cost_input: number | null;
+        cost_output: number | null;
+        cost_total: number | null;
+        message_history_length: number | null;
+        tools_available: number | null;
+        prompt_name: string | null;
+        tools_called: string | null;
+        queued_tools: string | null;
+        provider_tools: string | null;
+        parent_log_id: string | null;
+        tools_schema: string | null;
+        message_history: string | null;
+        system_prompt: string | null;
+        errors: string | null;
+        retry_of_log_id: string | null;
+        tool_results: string | null;
+        is_complete: boolean;
+        created_at: number;
+        source_message_role: string | null;
+        source_message_content: string | null;
+        source_message_created_at: number | null;
+        source_message_metadata: string | null;
+        scheduled_effects: string;
+    } | null>;
+    /**
+     * Get thread metadata (RPC method)
+     */
+    getThreadMeta(threadId: string): Promise<Response | {
+        thread: {
+            id: any;
+            agent_id: any;
+            user_id: any;
+            tags: any;
+            parent: any;
+            terminated: any;
+            created_at: any;
+        };
+        agent: {
+            id: any;
+            title: any;
+            type: any;
+            description: any;
+            icon: any;
+            side_a_label: any;
+            side_b_label: any;
+            side_a_agent_prompt: string | null;
+            side_b_agent_prompt: string | null;
+        } | null;
+        stats: {
+            message_count: number;
+            log_count: number;
+        };
+    }>;
+    /**
+     * Update thread metadata (RPC method)
+     * Calls the DurableAgentBuilder to update the thread registry
+     */
+    updateThreadMeta(threadId: string, params: {
+        agent_name?: string;
+        user_id?: string | null;
+        tags?: string[] | null;
+        env?: Record<string, string> | null;
+        tenvs?: Record<string, unknown> | null;
+    }): Promise<{
+        success: boolean;
+        thread: {
+            id: any;
+            agent_id: any;
+            user_id: any;
+            tags: any;
+            created_at: any;
+        };
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        thread?: undefined;
+    }>;
+    /**
+     * Delete thread data completely (RPC method)
+     * This will permanently delete the Durable Object instance
+     */
+    deleteThread(): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Handle WebSocket upgrade for real-time log streaming
+     * Uses Hibernation API to reduce costs during inactivity
+     */
+    private handleLogsWebSocketUpgrade;
+    /**
+     * Handle WebSocket upgrade for real-time message streaming
+     * Uses Hibernation API to reduce costs during inactivity
+     */
+    private handleMessagesWebSocketUpgrade;
+    /**
+     * Broadcast a log record to all connected WebSocket clients
+     */
+    private broadcastLog;
+    /**
+     * Broadcast a message record to all connected message WebSocket clients
+     * Filters silent messages based on each socket's includeSilent preference
+     */
+    private broadcastMessage;
+    private broadcastMessageWithSubagentProjection;
+    /**
+     * Broadcast a content chunk for real-time streaming
+     * Does NOT update database - only broadcasts to connected clients
+     */
+    private broadcastMessageChunk;
+    /**
+     * Broadcast a telemetry event to all connected message WebSocket clients
+     * Used for execution status updates (step_started, tool_started, etc.)
+     */
+    private broadcastTelemetry;
+    /**
+     * Broadcast a custom event to all connected message WebSocket clients
+     * Used by tools via emitThreadEvent() to send user-defined events
+     */
+    private broadcastEvent;
+    /**
+     * WebSocket Hibernation API handler for incoming messages
+     * Called when a message is received on a hibernated WebSocket
+     */
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    /**
+     * WebSocket Hibernation API handler for connection close
+     * Called when a WebSocket connection is closed
+     * Note: Do NOT call ws.close() here - the connection is already closed
+     */
+    webSocketClose(ws: WebSocket, _code: number, _reason: string, _wasClean: boolean): Promise<void>;
+    /**
+     * WebSocket Hibernation API handler for errors
+     * Called when a WebSocket encounters an error
+     */
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+    /**
+     * Alarm handler - called by Cloudflare when a scheduled alarm fires
+     * Processes the next item in the alarm queue
+     *
+     * Important: This method must NEVER throw an exception, as that would break
+     * the alarm chain. All errors are caught and logged.
+     */
+    alarm(): Promise<void>;
+    /**
+     * Internal method: Execute a flow (called by alarm queue)
+     * This is the actual execution logic, separate from the public execute() RPC method
+     */
+    private executeFlow;
+    /**
+     * Internal method: Execute an effect (called by alarm queue)
+     * Effects run outside the tool execution context.
+     */
+    private executeEffect;
+    /**
+     * Internal method: Process a message (called by alarm queue)
+     * This is the actual message processing logic, separate from the public sendMessage() RPC method
+     */
+    private processMessage;
+    /**
+     * Internal method: Continue execution without adding a message (called by alarm queue)
+     * This allows resuming FlowEngine execution from where it stopped.
+     */
+    private doContinueExecution;
+    private getLatestQueuedMessageSide;
+    /**
+     * TEST METHOD: Queue a test operation
+     * Used for testing alarm queue ordering and timing
+     */
+    queueTestOperation(id: string, label: string, expectedOrder: number, delayMs: number): Promise<Response>;
+    /**
+     * TEST METHOD: Get queue state
+     */
+    getQueueState(): Promise<Response>;
+    /**
+     * TEST METHOD: Get test execution logs
+     */
+    getTestLogs(): Promise<Response>;
+    /**
+     * TEST METHOD: Clear test logs
+     */
+    clearTestLogs(): Promise<Response>;
+    /**
+     * TEST METHOD: Insert a malformed message with orphaned tool calls
+     * This allows testing the tool call filtering logic
+     */
+    insertOrphanedToolCall(params: {
+        content?: string;
+        toolCallId: string;
+        toolName: string;
+        toolArgs: string;
+    }): Promise<Response>;
+    /**
+     * TEST METHOD: Execute a test operation
+     * Internal method called by alarm queue
+     */
+    private testOperation;
+    /**
+     * Get file storage helper instance
+     */
+    private getFileStorage;
+    /**
+     * Write a file to storage (RPC method)
+     */
+    writeFile(path: string, data: string, // base64 encoded
+    mimeType: string, options?: {
+        metadata?: Record<string, unknown>;
+        thumbnail?: string;
+    }): Promise<{
+        success: boolean;
+        file: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        file?: undefined;
+    }>;
+    /**
+     * Write a text file to storage (RPC method)
+     */
+    writeTextFile(path: string, content: string, mimeType?: string, options?: {
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        file: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        file?: undefined;
+    }>;
+    /**
+     * Process an image using sip (WASM-based image processing)
+     * This runs inside the DO where WASM is properly initialized.
+     *
+     * @param data - base64 encoded image data
+     * @param mimeType - MIME type of the input image
+     * @returns Processed image data, dimensions, and mimeType
+     */
+    processImage(data: string, mimeType: string): Promise<{
+        success: boolean;
+        data?: string;
+        mimeType?: string;
+        width?: number;
+        height?: number;
+        error?: string;
+    }>;
+    /**
+     * Link to an external file (RPC method)
+     */
+    linkFile(path: string, location: string, options?: {
+        mimeType?: string;
+        size?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        file: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        file?: undefined;
+    }>;
+    /**
+     * Read a file from storage (RPC method)
+     * Returns base64-encoded data
+     */
+    readFile(path: string): Promise<{
+        success: boolean;
+        data: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        data?: undefined;
+    }>;
+    /**
+     * Read a text file from storage (RPC method)
+     */
+    readTextFile(path: string): Promise<{
+        success: boolean;
+        content: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        content?: undefined;
+    }>;
+    /**
+     * Get file metadata (RPC method)
+     */
+    statFile(path: string): Promise<{
+        success: boolean;
+        file: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        file?: undefined;
+    }>;
+    /**
+     * Check if file exists (RPC method)
+     */
+    fileExists(path: string): Promise<{
+        success: boolean;
+        exists: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        exists?: undefined;
+    }>;
+    /**
+     * Delete a file (RPC method)
+     */
+    unlinkFile(path: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    /**
+     * Create a directory (RPC method)
+     */
+    mkdirFile(path: string): Promise<{
+        success: boolean;
+        directory: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        directory?: undefined;
+    }>;
+    /**
+     * List directory contents (RPC method)
+     */
+    readdirFile(path: string): Promise<{
+        success: boolean;
+        files: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        files?: undefined;
+    }>;
+    /**
+     * Remove empty directory (RPC method)
+     */
+    rmdirFile(path: string): Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    }>;
+    /**
+     * Get file storage statistics (RPC method)
+     */
+    getFileStats(): Promise<{
+        success: boolean;
+        stats: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        stats?: undefined;
+    }>;
+    /**
+     * Get thumbnail for an image (RPC method)
+     * Returns base64-encoded data
+     */
+    getFileThumbnail(path: string): Promise<{
+        success: boolean;
+        data: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        data?: undefined;
+    }>;
+    /**
+     * Search file contents using FTS5 (RPC method)
+     */
+    grepFiles(pattern: string, options?: {
+        path?: string;
+        limit?: number;
+    }): Promise<{
+        success: boolean;
+        results: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        results?: undefined;
+    }>;
+    /**
+     * Find files by path pattern (RPC method)
+     */
+    findFiles(pattern: string, options?: {
+        type?: "file" | "directory" | "all";
+        limit?: number;
+    }): Promise<{
+        success: boolean;
+        files: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        files?: undefined;
+    }>;
+    /**
+     * Start a chunked file upload.
+     * Creates file record with is_chunked=1 and chunk_count=null.
+     * Caller should then use writeFileChunk() to write chunks.
+     */
+    startChunkedUpload(path: string, totalSize: number, mimeType: string, options?: {
+        metadata?: Record<string, unknown>;
+        width?: number;
+        height?: number;
+    }): Promise<{
+        success: boolean;
+        chunkSize?: number;
+        expectedChunks?: number;
+        error?: string;
+    }>;
+    /**
+     * Write a single chunk of a chunked file upload.
+     * @param path - File path
+     * @param chunkIndex - 0-based chunk index
+     * @param data - Base64 encoded chunk data
+     */
+    writeFileChunk(path: string, chunkIndex: number, data: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Complete a chunked file upload.
+     * Validates all chunks are present and sets chunk_count.
+     */
+    completeChunkedUpload(path: string, expectedChunks: number, options?: {
+        thumbnail?: string;
+    }): Promise<{
+        success: boolean;
+        file?: FileRecord;
+        error?: string;
+    }>;
+    /**
+     * Read a single chunk of a file.
+     * Use for streaming large files to client.
+     */
+    readFileChunk(path: string, chunkIndex: number): Promise<{
+        success: boolean;
+        data?: string;
+        error?: string;
+    }>;
+    /**
+     * Get file info including chunking metadata.
+     */
+    getFileInfo(path: string): Promise<{
+        success: boolean;
+        file?: FileRecord;
+        error?: string;
+    }>;
+}
+
+type EnvValueType = 'text' | 'secret';
+/**
+ * Environment type for DurableAgentBuilder.
+ * Users extend this with their own bindings.
+ */
+interface AgentBuilderEnv {
+    AGENT_BUILDER: DurableObjectNamespace<DurableAgentBuilder>;
+    AGENT_BUILDER_THREAD: DurableObjectNamespace;
+    ENCRYPTION_KEY?: string;
+}
+/**
+ * Thread metadata stored in the registry.
+ */
+interface ThreadRegistryEntry {
+    id: string;
+    agent_name: string;
+    user_id: string | null;
+    tags: string[] | null;
+    env: Record<string, string> | null;
+    env_types: Record<string, EnvValueType> | null;
+    /** @deprecated Use env */
+    tenvs: Record<string, unknown> | null;
+    properties: Record<string, unknown> | null;
+    parent: string | null;
+    terminated: number | null;
+    created_at: number;
+}
+interface PendingSubagentAttachmentRef {
+    path: string;
+    name?: string;
+    mimeType?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+}
+interface PendingSubagentEnvRequestPayload {
+    blocking: boolean;
+    resumable: boolean;
+    receives_messages: 'side_a' | 'side_b';
+    parent_communication: 'implicit' | 'explicit';
+    initial_message_content: string;
+    initial_message_attachments: PendingSubagentAttachmentRef[];
+    initial_agent_name?: string | null;
+    agent_title?: string | null;
+    agent_description?: string | null;
+    spawn_group_id?: string | null;
+}
+interface PendingSubagentEnvRequest {
+    request_id: string;
+    parent_thread_id: string;
+    agent_name: string;
+    registry_agent_name: string;
+    required: string[];
+    missing: string[];
+    payload: PendingSubagentEnvRequestPayload;
+    created_at: number;
+}
+/**
+ * Parameters for updating a thread.
+ */
+interface UpdateThreadParams {
+    agent_name?: string;
+    user_id?: string | null;
+    tags?: string[] | null;
+    env?: Record<string, string> | null;
+    env_types?: Record<string, EnvValueType> | null;
+    /** @deprecated Use env */
+    tenvs?: Record<string, unknown> | null;
+    properties?: Record<string, unknown> | null;
+    parent?: string | null;
+    terminated?: number | null;
+}
+/**
+ * User record.
+ */
+interface User {
+    id: string;
+    username: string;
+    password_hash: string;
+    role: 'admin';
+    created_at: number;
+    updated_at: number;
+}
+interface ScopedEnvEntry {
+    name: string;
+    value: string;
+    type: EnvValueType;
+    created_at: number;
+    updated_at: number;
+}
+/**
+ * Provider credentials.
+ */
+interface Provider$1 {
+    name: string;
+    sdk: string;
+    api_key: string;
+}
+declare class DurableAgentBuilder<Env extends AgentBuilderEnv = AgentBuilderEnv> extends DurableObject<Env> {
+    private migratedToVersion;
+    private eventSockets;
+    constructor(ctx: DurableObjectState, env: Env);
+    private normalizeEnvRecord;
+    private normalizeEnvTypeRecord;
+    private extractEnvTypeRecord;
+    private withEnvTypeRecord;
+    private serializeEnvTypes;
+    private resolveRegistryKey;
+    private extractScopedVariables;
+    private filterScopedInheritedEnv;
+    private filterScopedInheritedEnvTypes;
+    private collectScopedVariablesForAgent;
+    private getScopedVariableNamesForAgent;
+    private getRequiredScopedVariableNamesForAgent;
+    private normalizeScopedVariableList;
+    private normalizePendingAttachments;
+    private sanitizeFilename;
+    private inferMimeTypeFromPath;
+    private extensionForMimeType;
+    private buildAttachmentTargetPath;
+    private formatSubagentAttachmentPathSummary;
+    private formatSubagentTerminalMessage;
+    private copyPendingAttachmentsBetweenThreads;
+    private buildThreadNameTag;
+    private encryptEnvRecord;
+    private decryptEnvRecord;
+    private listActiveDescendantThreadIds;
+    private propagateThreadEnvToDescendants;
+    /**
+     * Returns the tools registry for lazy-loading tool definitions.
+     * Must be overridden in a subclass.
+     */
+    tools(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the hooks registry for lazy-loading hook definitions.
+     * Must be overridden in a subclass.
+     */
+    hooks(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the models registry for lazy-loading model definitions.
+     * Must be overridden in a subclass.
+     */
+    models(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the prompts registry for lazy-loading prompt definitions.
+     * Must be overridden in a subclass.
+     */
+    prompts(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the agents registry for lazy-loading agent definitions.
+     * Must be overridden in a subclass.
+     */
+    agents(): Record<string, () => Promise<any>>;
+    /**
+     * Returns the namespaced registry for packed agent support.
+     * Must be overridden in a subclass.
+     */
+    registry(): any;
+    private ensureMigrated;
+    private getCurrentVersion;
+    private runMigrations;
+    /**
+     * Create a new thread and add it to the registry.
+     */
+    createThread(params: {
+        agent_name: string;
+        user_id?: string;
+        tags?: string[];
+        env?: Record<string, string>;
+        env_types?: Record<string, EnvValueType>;
+        /** @deprecated Use env */
+        tenvs?: Record<string, unknown>;
+        properties?: Record<string, unknown>;
+        parent?: string;
+    }): Promise<ThreadRegistryEntry>;
+    private runAfterThreadCreatedHook;
+    /**
+     * Get a thread by ID.
+     */
+    getThread(id: string): Promise<ThreadRegistryEntry | null>;
+    /**
+     * List threads with optional filtering.
+     * Note: tenvs are not decrypted in list operations for performance.
+     * Use getThread() to retrieve a thread with decrypted tenvs.
+     */
+    listThreads(params?: {
+        agent_name?: string;
+        user_id?: string;
+        search?: string;
+        startDate?: number;
+        endDate?: number;
+        limit?: number;
+        offset?: number;
+        include_children?: boolean;
+    }): Promise<{
+        threads: ThreadRegistryEntry[];
+        total: number;
+    }>;
+    /**
+     * Delete a thread from the registry.
+     */
+    deleteThread(id: string): Promise<boolean>;
+    /**
+     * Get a thread tree (root + all descendants) in child-first order.
+     *
+     * Child-first ordering allows callers to perform destructive operations
+     * (like deletes) without leaving child rows referencing a deleted parent.
+     */
+    getThreadTreeIds(rootThreadId: string): Promise<string[]>;
+    /**
+     * Update a thread's agent_name (used during agent handoff).
+     */
+    updateThreadAgent(id: string, agent_name: string): Promise<boolean>;
+    /**
+     * Update a thread's metadata.
+     */
+    updateThread(id: string, params: UpdateThreadParams): Promise<ThreadRegistryEntry | null>;
+    private getEncryptionKey;
+    private encryptEnvValue;
+    private decryptEnvValue;
+    private listScopedEnv;
+    private listScopedEnvEntries;
+    private getScopedEnvTypeRecord;
+    private replaceScopedEnv;
+    private patchScopedEnv;
+    getInstanceEnv(): Promise<Record<string, string>>;
+    getInstanceEnvTypes(): Promise<Record<string, EnvValueType>>;
+    getInstanceEnvEntries(): Promise<ScopedEnvEntry[]>;
+    setInstanceEnv(env: Record<string, string>, envTypes?: Record<string, EnvValueType> | null): Promise<void>;
+    patchInstanceEnv(params: {
+        env_patch?: Record<string, unknown> | null;
+        env_type_patch?: Record<string, unknown> | null;
+        env_delete?: string[] | null;
+    }): Promise<void>;
+    getUserEnv(userId: string): Promise<Record<string, string>>;
+    getUserEnvTypes(userId: string): Promise<Record<string, EnvValueType>>;
+    getUserEnvEntries(userId: string): Promise<ScopedEnvEntry[]>;
+    setUserEnv(userId: string, env: Record<string, string>, envTypes?: Record<string, EnvValueType> | null): Promise<void>;
+    patchUserEnv(userId: string, params: {
+        env_patch?: Record<string, unknown> | null;
+        env_type_patch?: Record<string, unknown> | null;
+        env_delete?: string[] | null;
+    }): Promise<void>;
+    getMissingRequiredScopedSubagentEnv(params: {
+        parent_thread_id: string;
+        agent_name: string;
+        provided_env?: Record<string, string> | null;
+    }): Promise<string[]>;
+    createPendingSubagentEnvRequest(params: {
+        parent_thread_id: string;
+        agent_name: string;
+        registry_agent_name: string;
+        required_variables: string[];
+        missing_variables: string[];
+        payload: PendingSubagentEnvRequestPayload;
+    }): Promise<PendingSubagentEnvRequest>;
+    getPendingSubagentEnvRequest(parentThreadId: string, requestId: string): Promise<PendingSubagentEnvRequest | null>;
+    private clearPendingSubagentEnvRequest;
+    completePendingSubagentEnvRequest(params: {
+        parent_thread_id: string;
+        request_id: string;
+        env: Record<string, string>;
+    }): Promise<{
+        request_id: string;
+        child_thread_id: string;
+        status: 'success';
+    }>;
+    resolveThreadEnv(params: {
+        threadId: string;
+        property: string;
+        promptName?: string;
+    }): Promise<string | null>;
+    resolveThreadEnvType(params: {
+        threadId: string;
+        property: string;
+        promptName?: string;
+    }): Promise<EnvValueType>;
+    private toThreadEventPayload;
+    /**
+     * Load a model definition by name.
+     */
+    loadModel(name: string): Promise<any>;
+    /**
+     * List available model names.
+     */
+    getModelNames(): string[];
+    /**
+     * Load a prompt definition by name.
+     */
+    loadPrompt(name: string): Promise<any>;
+    /**
+     * List available prompt names.
+     */
+    getPromptNames(): string[];
+    /**
+     * Load an agent definition by name.
+     * Supports both global agents (e.g., "my-agent") and packed agents (e.g., "packageId/agentName").
+     * For scoped packages, use "@scope/pkg/agentName".
+     */
+    loadAgent(name: string): Promise<any>;
+    /**
+     * List available agent names.
+     */
+    getAgentNames(): string[];
+    /**
+     * Get a provider's credentials.
+     */
+    getProvider(name: string): Promise<Provider$1 | null>;
+    /**
+     * Set a provider's credentials.
+     */
+    setProvider(provider: Provider$1): Promise<void>;
+    /**
+     * List all providers.
+     */
+    listProviders(): Promise<Provider$1[]>;
+    /**
+     * Delete a provider.
+     */
+    deleteProvider(name: string): Promise<boolean>;
+    /**
+     * Get a user by username.
+     */
+    getUserByUsername(username: string): Promise<User | null>;
+    /**
+     * Get a user by ID.
+     */
+    getUserById(id: string): Promise<User | null>;
+    /**
+     * Create a new user.
+     */
+    createUser(params: {
+        username: string;
+        password_hash: string;
+        role?: 'admin';
+    }): Promise<User>;
+    /**
+     * Check if any users exist (for first-time setup).
+     */
+    hasUsers(): Promise<boolean>;
+    /**
+     * List all users (excludes password hash).
+     */
+    listUsers(): Promise<Array<{
+        id: string;
+        username: string;
+        role: 'admin';
+        created_at: number;
+        updated_at: number;
+    }>>;
+    /**
+     * Update a user.
+     */
+    updateUser(id: string, params: {
+        username?: string;
+        password_hash?: string;
+        role?: 'admin';
+    }): Promise<User | null>;
+    /**
+     * Delete a user.
+     */
+    deleteUser(id: string): Promise<boolean>;
+    /**
+     * Create a new session.
+     */
+    createSession(params: {
+        user_id: string;
+        token_hash: string;
+        expires_at: number;
+    }): Promise<string>;
+    /**
+     * Validate a session token.
+     */
+    validateSession(tokenHash: string): Promise<{
+        user_id: string;
+        expires_at: number;
+    } | null>;
+    /**
+     * Delete expired sessions.
+     */
+    cleanupSessions(): Promise<number>;
+    /**
+     * Delete a session.
+     */
+    deleteSession(tokenHash: string): Promise<void>;
+    /**
+     * Create an API key.
+     */
+    createApiKey(params: {
+        name: string;
+        key_hash: string;
+        key_prefix: string;
+        last_five: string;
+        user_id: string;
+    }): Promise<string>;
+    /**
+     * Validate an API key.
+     */
+    validateApiKey(keyHash: string): Promise<{
+        user_id: string;
+        id: string;
+    } | null>;
+    /**
+     * List API keys for a user.
+     */
+    listApiKeys(userId: string): Promise<Array<{
+        id: string;
+        name: string;
+        key_prefix: string;
+        last_five: string;
+        created_at: number;
+        last_used_at: number | null;
+    }>>;
+    /**
+     * Delete an API key.
+     */
+    deleteApiKey(id: string, userId: string): Promise<boolean>;
+    /**
+     * Link an OAuth account to a user.
+     */
+    linkOAuthAccount(params: {
+        user_id: string;
+        provider: 'github' | 'google';
+        provider_user_id: string;
+        provider_username?: string;
+    }): Promise<void>;
+    /**
+     * Find user by OAuth account.
+     */
+    findUserByOAuth(provider: 'github' | 'google', providerUserId: string): Promise<User | null>;
+    /**
+     * Acquire edit lock for coordinated edits.
+     */
+    acquireEditLock(params: {
+        locked_by: string;
+        lock_reason: string;
+    }): Promise<boolean>;
+    /**
+     * Release edit lock.
+     */
+    releaseEditLock(lockedBy: string): Promise<boolean>;
+    /**
+     * Get current lock state.
+     */
+    getEditLockState(): Promise<{
+        locked: boolean;
+        locked_by: string | null;
+        locked_at: number | null;
+        lock_reason: string | null;
+        pending_changes: string | null;
+    }>;
+    /**
+     * Store pending changes for commit.
+     */
+    setPendingChanges(changes: string): Promise<void>;
+    /**
+     * Get the Durable Object stub for a thread.
+     */
+    getThreadStub(threadId: string): DurableObjectStub;
+    /**
+     * Handle fetch requests - used for WebSocket upgrades
+     */
+    fetch(request: Request): Promise<Response>;
+    /**
+     * Handle WebSocket upgrade for events channel
+     * Uses Hibernation API to reduce costs during inactivity
+     */
+    private handleEventsWebSocketUpgrade;
+    /**
+     * Broadcast an event to all connected WebSocket clients
+     */
+    private broadcastEvent;
+    /**
+     * WebSocket Hibernation API handler for incoming messages
+     * Called when a message is received on a hibernated WebSocket
+     */
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    /**
+     * WebSocket Hibernation API handler for connection close
+     * Called when a WebSocket connection is closed
+     */
+    webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+    /**
+     * WebSocket Hibernation API handler for errors
+     * Called when a WebSocket encounters an error
+     */
+    webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+}
+
+interface CodeExecutionBridgeProps {
+    threadId?: string;
+    runId?: string;
+}
+declare class CodeExecutionBridge extends WorkerEntrypoint<ThreadEnv, CodeExecutionBridgeProps> {
+    call(threadId: string, runId: string, functionId: string, encodedArgs: unknown[]): Promise<unknown>;
+}
+
+/**
+ * Model definition module for AgentBuilder.
+ *
+ * This module re-exports model types from @standardagents/spec and provides
+ * a builder-specific version of ModelDefinition that supports the generated
+ * AgentBuilder.Models type for fallback references.
+ *
+ * @module
+ */
+
+/**
+ * Model definition configuration with AgentBuilder-specific fallback typing.
+ *
+ * Extends the base ModelDefinition from @standardagents/spec to support
+ * the generated AgentBuilder.Models type for type-safe fallback references.
+ *
+ * @template N - The model name as a string literal type for type inference
+ */
+interface ModelDefinition<N extends string = string> extends Omit<ModelDefinition$1<N>, 'fallbacks'> {
+    /**
+     * Fallback models to try if this model fails.
+     * Referenced by model name (must be defined in agents/models/).
+     * Tried in order after primary model exhausts retries.
+     *
+     * @example ['gpt-4', 'gpt-3.5-turbo']
+     */
+    fallbacks?: AgentBuilder.Models[];
+}
+
+/**
+ * Prompt definition module for AgentBuilder.
+ *
+ * This module re-exports prompt types from @standardagents/spec and provides
+ * builder-specific versions that use the generated AgentBuilder namespace types.
+ *
+ * @module
+ */
+
+/**
+ * A prompt inclusion part with type-safe autocomplete.
+ * Uses AgentBuilder.Prompts for type-safe prompt name references.
+ */
+interface PromptIncludePart {
+    type: 'include';
+    /** The name of the prompt to include (type-safe with autocomplete) */
+    prompt: AgentBuilder.Prompts;
+}
+/**
+ * A single part of a structured prompt.
+ */
+type PromptPart = PromptTextPart | PromptIncludePart | PromptEnvPart;
+/**
+ * Prompt content can be a string or structured array with type-safe includes.
+ */
+type PromptContent = string | PromptPart[];
+/**
+ * Sub-prompt configuration with type-safe name references.
+ */
+interface SubpromptConfig<T extends string = AgentBuilder.Callables> extends Omit<SubpromptConfig$1<T>, 'name'> {
+    /** Name of the sub-prompt (type-safe with autocomplete) */
+    name: T;
+}
+/**
+ * Prompt tool configuration with static tenvs/options.
+ */
+interface PromptToolConfig<T extends string = AgentBuilder.Callables> extends Omit<PromptToolConfig$1, 'name'> {
+    /** Name of the callable tool/agent (type-safe with autocomplete). */
+    name: T;
+    /** Environment values scoped to this tool invocation. */
+    env?: Record<string, string>;
+    /** @deprecated Use env */
+    tenvs?: Record<string, unknown>;
+}
+/**
+ * Subagent tool configuration with type-safe name references.
+ */
+interface SubagentToolConfig<T extends string = AgentBuilder.Callables> extends Omit<SubagentToolConfig$1<T>, 'name'> {
+    /** Name of the callable dual_ai agent (type-safe with autocomplete). */
+    name: T;
+}
+/**
+ * @deprecated Use SubpromptConfig instead
+ */
+type ToolConfig<T extends string = AgentBuilder.Callables> = SubpromptConfig<T>;
+
+/**
+ * Prompt definition configuration with AgentBuilder-specific typing.
+ *
+ * Provides type-safe references to models, tools, and agents via the
+ * generated AgentBuilder namespace.
+ *
+ * @template N - The prompt name as a string literal type
+ * @template S - The Zod schema type for requiredSchema (inferred automatically)
+ */
+interface PromptDefinition<N extends string = string, S extends ToolArgs = ToolArgs> {
+    /** Unique name for this prompt. */
+    name: N;
+    /** Description shown when this prompt is exposed as a tool. */
+    toolDescription: string;
+    /** The system prompt content with type-safe includes. */
+    prompt: PromptContent;
+    /** Model to use (type-safe with autocomplete). */
+    model: AgentBuilder.Models;
+    /**
+     * @deprecated All prompts are now automatically exposed as tools.
+     */
+    exposeAsTool?: boolean;
+    /** Include full chat history in the LLM context. @default false */
+    includeChat?: boolean;
+    /** Include results from past tool calls. @default false */
+    includePastTools?: boolean;
+    /** Allow parallel execution of multiple tool calls. @default false */
+    parallelToolCalls?: boolean;
+    /** Tool calling strategy. @default 'auto' */
+    toolChoice?: 'auto' | 'none' | 'required';
+    /** Zod schema for validating inputs when called as a tool. */
+    requiredSchema?: S;
+    /** Variable declarations for this prompt. */
+    variables?: VariableDefinition[];
+    /** Tools available to this prompt (type-safe with autocomplete). To enable handoffs, include ai_human agent names. */
+    tools?: (AgentBuilder.Callables | SubpromptConfig | PromptToolConfig | SubagentToolConfig)[];
+    /** Prompt-level environment values. */
+    env?: Record<string, string>;
+    /** @deprecated Use env */
+    tenvs?: Record<string, unknown>;
+    /** Reasoning configuration for extended thinking models. */
+    reasoning?: ReasoningConfig;
+    /** Number of recent messages to keep actual images for. @default 10 */
+    recentImageThreshold?: number;
+    /** Hook IDs to run when this prompt is active. Falls back to agent-level hooks if not set. */
+    hooks?: AgentBuilder.Hooks[];
+}
+
+/**
+ * Agent definition module for AgentBuilder.
+ *
+ * This module re-exports agent types from @standardagents/spec and provides
+ * builder-specific versions that use the generated AgentBuilder namespace types.
+ *
+ * @module
+ */
+
+/**
+ * Side configuration with type-safe autocomplete.
+ * Uses AgentBuilder.Prompts and AgentBuilder.Callables for type-safe references.
+ */
+interface SessionToolConfig {
+    /**
+     * Tool name for this lifecycle binding.
+     */
+    name: AgentBuilder.Callables;
+    /**
+     * Optional tool-argument property used as message text.
+     */
+    messageProperty?: string;
+    /**
+     * Optional tool-argument property containing attachment path(s).
+     */
+    attachmentsProperty?: string;
+}
+/**
+ * Session lifecycle binding (string shorthand or explicit object form).
+ */
+type SessionToolBinding = AgentBuilder.Callables | SessionToolConfig;
+interface SideConfig extends Omit<SideConfig$1, 'prompt' | 'stopTool' | 'sessionStop' | 'sessionFail' | 'sessionStatus'> {
+    /**
+     * The prompt to use for this side (type-safe with autocomplete).
+     * Must reference a prompt defined in agents/prompts/.
+     */
+    prompt: AgentBuilder.Prompts;
+    /**
+     * Stop this side's turn when a specific tool is called (type-safe with autocomplete).
+     * Overrides stopOnResponse when the named tool is invoked.
+     * Requires stopToolResponseProperty to extract the result.
+     */
+    stopTool?: AgentBuilder.Callables;
+    /**
+     * Tool that ends the entire session when called.
+     * Supports shorthand string or explicit message/attachment mapping object.
+     */
+    sessionStop?: SessionToolBinding;
+    /**
+     * Tool that fails the entire session when called.
+     * Supports shorthand string or explicit message/attachment mapping object.
+     */
+    sessionFail?: SessionToolBinding;
+    /**
+     * Tool that publishes status updates to the parent thread when used as a subagent.
+     * Supports shorthand string or explicit message/attachment mapping object.
+     */
+    sessionStatus?: SessionToolBinding;
+    /**
+     * Enable manual stop condition handling via hooks.
+     * Builder-specific feature for custom stop logic.
+     * @default false
+     */
+    manualStopCondition?: boolean;
+}
+/**
+ * Agent definition configuration with AgentBuilder-specific typing.
+ *
+ * Provides type-safe references to prompts and tools via the
+ * generated AgentBuilder namespace.
+ *
+ * @template N - The agent name as a string literal type
+ *
+ * @example
+ * ```typescript
+ * import { defineAgent } from '@standardagents/builder';
+ *
+ * export default defineAgent({
+ *   name: 'support_agent',
+ *   title: 'Customer Support Agent',
+ *   type: 'ai_human',
+ *   sideA: {
+ *     label: 'Support',
+ *     prompt: 'customer_support',
+ *     stopOnResponse: true,
+ *   },
+ * });
+ * ```
+ */
+interface AgentDefinition<N extends string = string> {
+    /** Unique name for this agent. */
+    name: N;
+    /**
+     * Human-readable title for the agent.
+     * @deprecated Use name instead. Title will be removed in a future version.
+     */
+    title?: string;
+    /**
+     * Agent conversation type.
+     * - `ai_human`: AI conversing with a human user (default)
+     * - `dual_ai`: Two AI participants conversing
+     * @default 'ai_human'
+     */
+    type?: 'ai_human' | 'dual_ai';
+    /**
+     * Maximum total turns across both sides.
+     * Only applies to `dual_ai` agents.
+     */
+    maxSessionTurns?: number;
+    /** Configuration for Side A (type-safe with autocomplete). */
+    sideA: SideConfig;
+    /** Configuration for Side B (type-safe with autocomplete). */
+    sideB?: SideConfig;
+    /**
+     * Expose this agent as a tool for other prompts.
+     * @default false
+     */
+    exposeAsTool?: boolean;
+    /** Description shown when agent is used as a tool. */
+    toolDescription?: string;
+    /**
+     * Environment values provided by this agent.
+     */
+    env?: Record<string, string>;
+    /**
+     * @deprecated Use env
+     */
+    tenvs?: Record<string, unknown>;
+    /** Brief description of what this agent does. */
+    description?: string;
+    /** Icon URL or absolute path for the agent. */
+    icon?: string;
+    /**
+     * npm package name for this agent when packed.
+     * Preserved through unpack → edit → pack cycles.
+     */
+    packageName?: string;
+    /**
+     * Package version (semver format).
+     * Preserved through unpack → edit → pack cycles.
+     */
+    version?: string;
+    /**
+     * Package author/copyright holder.
+     * Preserved through unpack → edit → pack cycles.
+     */
+    author?: string;
+    /**
+     * License identifier (SPDX format).
+     * Preserved through unpack → edit → pack cycles.
+     */
+    license?: string;
+}
+
+/**
+ * Options for injecting a message
+ */
+interface InjectMessageOptions$1 {
+    /** The message content */
+    content: string;
+    /** The message role */
+    role: "system" | "user" | "assistant" | "tool";
+    /** Optional message ID. If not provided, a UUID will be generated */
+    id?: string;
+    /** Optional message to insert before. If not provided, message is appended to the end */
+    beforeMessageId?: string;
+    /** Optional tool call ID (for role="tool" only) */
+    toolCallId?: string;
+    /** Optional name field */
+    name?: string;
+    /** Whether this message is silent (hidden from LLM, visible in UI only). Default: false */
+    silent?: boolean;
+    /** Optional structured metadata */
+    metadata?: Record<string, unknown>;
+    /** Force message to be top-level (depth 0) even when called from sub-prompts. Default: false */
+    forceTopLevel?: boolean;
+    /** Force a specific side to play the next turn after injecting the message */
+    forceTurn?: "side_a" | "side_b";
+}
+/**
+ * Queue a new tool call to be executed in the current flow
+ *
+ * This adds a tool call to the execution queue without immediately executing it.
+ * The tool will be executed as part of the normal flow processing.
+ *
+ * If the current tool has a `uses` list defined, the toolName must be in that list.
+ * This enforces namespace isolation for packed agents.
+ *
+ * @param flow - The current FlowState
+ * @param toolName - The name of the tool to call
+ * @param args - The arguments to pass to the tool
+ * @throws Error if toolName is not in the current tool's uses list (when defined)
+ *
+ * @example
+ * ```typescript
+ * import { queueTool } from '@standardagents/builder';
+ *
+ * queueTool(flow, "search_user", { email: "user@example.com" });
+ * ```
+ */
+declare function queueTool(flow: FlowState, toolName: string, args?: Record<string, unknown>): void;
+/**
+ * Inject a message into the thread without triggering execution
+ *
+ * This allows you to add messages to the conversation history programmatically.
+ * The message is persisted to storage but does not cause the agent to execute.
+ *
+ * By default, messages are appended to the end of the conversation.
+ * You can optionally insert a message before another message by providing beforeMessageId.
+ *
+ * @param flow - The current FlowState
+ * @param options - Message options
+ *
+ * @example
+ * ```typescript
+ * import { injectMessage } from '@standardagents/builder';
+ *
+ * // Append a system message
+ * await injectMessage(flow, {
+ *   role: "system",
+ *   content: "Context has been updated"
+ * });
+ *
+ * // Insert a user message before a specific message
+ * await injectMessage(flow, {
+ *   role: "user",
+ *   content: "Additional context",
+ *   beforeMessageId: "msg-123"
+ * });
+ *
+ * // Inject a message and force a specific side to play next
+ * await injectMessage(flow, {
+ *   role: "system",
+ *   content: "New instructions for the AI",
+ *   forceTurn: "side_a" // Force side_a to respond to this message
+ * });
+ * ```
+ */
+declare function injectMessage(flow: FlowState, options: InjectMessageOptions$1): Promise<Message>;
+/**
+ * Get messages from the thread history
+ *
+ * Retrieves message history from the thread's SQLite storage.
+ * Messages are ordered by creation time (oldest first by default).
+ *
+ * @param flow - The current FlowState
+ * @param limit - Maximum number of messages to retrieve (default: 100)
+ * @param offset - Number of messages to skip (default: 0)
+ * @param order - Sort order: "asc" (oldest first) or "desc" (newest first) (default: "asc")
+ * @returns Array of messages
+ *
+ * @example
+ * ```typescript
+ * import { getMessages } from '@standardagents/builder';
+ *
+ * // Get last 10 messages
+ * const messages = await getMessages(flow, 10);
+ *
+ * // Get 10 messages, skipping the first 20
+ * const messages = await getMessages(flow, 10, 20);
+ *
+ * // Get newest 10 messages
+ * const messages = await getMessages(flow, 10, 0, "desc");
+ * ```
+ */
+declare function getMessages(flow: FlowState, limit?: number, offset?: number, order?: "asc" | "desc"): Promise<Message[]>;
+/**
+ * Reload message history from storage
+ *
+ * Re-loads the complete message history from the thread's SQLite storage,
+ * applying any filter_messages hooks. This is useful when you need to refresh
+ * the message history after making changes (e.g., injecting silent messages).
+ *
+ * @param flow - The current FlowState
+ * @returns Array of messages (reloaded from storage)
+ *
+ * @example
+ * ```typescript
+ * import { injectMessage, reloadHistory } from '@standardagents/builder';
+ *
+ * // Reload history after injecting a silent message
+ * await injectMessage(flow, { role: "system", content: "...", silent: true });
+ * flow.messageHistory = await reloadHistory(flow);
+ * ```
+ */
+declare function reloadHistory(state: FlowState): Promise<Message[]>;
+/**
+ * Emit a custom event to WebSocket clients via the stream
+ *
+ * Sends a custom event to all connected WebSocket clients on the stream channel.
+ * This allows backend code to push arbitrary data to the frontend
+ * outside of the standard message events.
+ *
+ * @param flow - The current FlowState
+ * @param type - The event type name (e.g., "progress", "notification")
+ * @param data - The event payload (any serializable data)
+ *
+ * @example
+ * ```typescript
+ * import { emitThreadEvent } from '@standardagents/builder';
+ *
+ * // Emit a progress update
+ * emitThreadEvent(flow, "progress", { step: 3, total: 10, message: "Processing data..." });
+ *
+ * // Emit a custom notification
+ * emitThreadEvent(flow, "notification", { level: "info", message: "User authenticated" });
+ *
+ * // Emit metadata
+ * emitThreadEvent(flow, "metadata", { userId: "123", sessionId: "abc" });
+ * ```
+ */
+declare function emitThreadEvent(flow: FlowState, type: string, data: unknown): void;
+/**
+ * Force a specific side to play the next turn
+ *
+ * This queues the specified side to play next without interrupting the current turn.
+ * The forced turn only takes effect at the END of the current turn execution.
+ *
+ * If the tool queue is currently being processed (sequence.isHandling is true),
+ * the forced turn is deferred until all queued tools complete. This allows patterns like:
+ *
+ * ```typescript
+ * import { queueTool, forceTurn } from '@standardagents/builder';
+ *
+ * queueTool(flow, 'myTool', {});
+ * forceTurn(flow, 'side_a');
+ * // myTool executes first, THEN the turn switches to side_a
+ * ```
+ *
+ * @param flow - The current FlowState
+ * @param side - Which side should play next ('side_a' or 'side_b')
+ *
+ * @example
+ * ```typescript
+ * import { forceTurn } from '@standardagents/builder';
+ *
+ * // Force current side to continue (override stop condition)
+ * // If side_a is playing and would stop, this forces it to play at least 1 more turn
+ * forceTurn(flow, 'side_a');
+ *
+ * // Force switch to other side
+ * // If side_a is playing, this forces side_b to play next turn
+ * forceTurn(flow, 'side_b');
+ *
+ * // Force human turn in ai_human agent (execution stops and waits for user input)
+ * if (flow.agentConfig.type === 'ai_human') {
+ *   forceTurn(flow, 'side_b'); // Stops execution, awaits user input
+ * }
+ * ```
+ */
+declare function forceTurn(flow: FlowState, side: 'side_a' | 'side_b'): void;
+/**
+ * Thread context from defineThreadEndpoint
+ */
+interface ThreadContext {
+    instance: {
+        updateThreadMeta: (threadId: string, params: {
+            agent_name?: string;
+            user_id?: string | null;
+            tags?: string[] | null;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+            thread?: {
+                id: string;
+                agent_id: string;
+                user_id: string | null;
+                tags: string[];
+                created_at: number;
+            };
+        }>;
+    };
+    metadata: {
+        id: string;
+        agent_name: string;
+        user_id: string | null;
+        tags: string[] | null;
+        created_at: number;
+    };
+}
+/**
+ * Update a thread's metadata in the DurableAgentBuilder registry
+ *
+ * This allows updating the agent_name, user_id, and tags for an existing thread.
+ * Uses the thread instance from defineThreadEndpoint context.
+ *
+ * @param thread - The thread context from defineThreadEndpoint ({ instance, metadata })
+ * @param params - The fields to update (agent_name, user_id, tags)
+ * @returns The updated thread info, or null if update failed
+ *
+ * @example
+ * ```typescript
+ * import { defineThreadEndpoint, updateThread } from '@standardagents/builder';
+ *
+ * export default defineThreadEndpoint(async (req, thread) => {
+ *   // Update thread's user_id
+ *   await updateThread(thread, { user_id: 'user-123' });
+ *
+ *   // Update thread's tags
+ *   await updateThread(thread, { tags: ['support', 'urgent'] });
+ *
+ *   // Update multiple fields
+ *   const result = await updateThread(thread, {
+ *     agent_name: 'new-agent',
+ *     user_id: 'user-456',
+ *     tags: ['sales']
+ *   });
+ *
+ *   return Response.json(result);
+ * });
+ * ```
+ */
+declare function updateThread(thread: ThreadContext, params: {
+    agent_name?: string;
+    user_id?: string | null;
+    tags?: string[] | null;
+}): Promise<{
+    id: string;
+    agent_id: string;
+    user_id: string | null;
+    tags: string[];
+    created_at: number;
+} | null>;
+/**
+ * Write a file to thread storage
+ *
+ * @param flow - The current FlowState
+ * @param path - File path (e.g., "/images/photo.jpg")
+ * @param data - File data as ArrayBuffer or string
+ * @param mimeType - MIME type of the file
+ * @param options - Optional metadata and thumbnail
+ * @returns The created file record
+ *
+ * @example
+ * ```typescript
+ * import { writeFile } from '@standardagents/builder';
+ *
+ * // Write binary file
+ * const imageData = new Uint8Array([...]);
+ * await writeFile(flow, "/images/photo.jpg", imageData.buffer, "image/jpeg");
+ *
+ * // Write text file
+ * await writeFile(flow, "/docs/readme.md", "# Hello", "text/markdown");
+ * ```
+ */
+declare function writeFile(flow: FlowState, path: string, data: ArrayBuffer | string, mimeType: string, options?: {
+    metadata?: Record<string, unknown>;
+    thumbnail?: ArrayBuffer;
+}): Promise<FileRecord>;
+/**
+ * Write an image file with optional thumbnail
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @param data - Image data as ArrayBuffer
+ * @param mimeType - Image MIME type
+ * @param options - Image metadata (width, height) and optional thumbnail
+ * @returns The created file record
+ *
+ * @example
+ * ```typescript
+ * import { writeImage } from '@standardagents/builder';
+ *
+ * await writeImage(flow, "/images/photo.jpg", imageBuffer, "image/jpeg", {
+ *   metadata: { width: 1024, height: 768 },
+ *   thumbnail: thumbnailBuffer
+ * });
+ * ```
+ */
+declare function writeImage(flow: FlowState, path: string, data: ArrayBuffer, mimeType: string, options?: {
+    metadata?: {
+        width: number;
+        height: number;
+        [key: string]: unknown;
+    };
+    thumbnail?: ArrayBuffer;
+}): Promise<FileRecord>;
+/**
+ * Link to an external file (URL, S3, R2)
+ *
+ * Creates a file entry pointing to an external location without storing the data locally.
+ *
+ * @param flow - The current FlowState
+ * @param path - File path in thread storage
+ * @param location - External location (https://, s3://, r2://)
+ * @param options - Optional MIME type, size, and metadata
+ * @returns The created file record
+ *
+ * @example
+ * ```typescript
+ * import { linkFile } from '@standardagents/builder';
+ *
+ * // Link to a URL
+ * await linkFile(flow, "/images/hero.jpg", "https://cdn.example.com/hero.jpg");
+ *
+ * // Link to S3
+ * await linkFile(flow, "/data/large.csv", "s3://mybucket/data/large.csv", {
+ *   mimeType: "text/csv",
+ *   size: 10 * 1024 * 1024 * 1024 // 10GB
+ * });
+ * ```
+ */
+declare function linkFile(flow: FlowState, path: string, location: string, options?: {
+    mimeType?: string;
+    size?: number;
+    metadata?: Record<string, unknown>;
+}): Promise<FileRecord>;
+/**
+ * Read a file from thread storage
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @returns File data as ArrayBuffer, or null if not found/external
+ *
+ * @example
+ * ```typescript
+ * import { readFile } from '@standardagents/builder';
+ *
+ * const data = await readFile(flow, "/images/photo.jpg");
+ * if (data) {
+ *   // Process binary data
+ * }
+ * ```
+ */
+declare function readFile(flow: FlowState, path: string): Promise<ArrayBuffer | null>;
+/**
+ * Get file metadata
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @returns File record or null if not found
+ *
+ * @example
+ * ```typescript
+ * import { stat } from '@standardagents/builder';
+ *
+ * const file = await stat(flow, "/images/photo.jpg");
+ * if (file) {
+ *   console.log(`Size: ${file.size}, Type: ${file.mimeType}`);
+ * }
+ * ```
+ */
+declare function stat(flow: FlowState, path: string): Promise<FileRecord | null>;
+/**
+ * Check if file or directory exists
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @returns true if exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { exists } from '@standardagents/builder';
+ *
+ * if (await exists(flow, "/config.json")) {
+ *   // File exists
+ * }
+ * ```
+ */
+declare function exists(flow: FlowState, path: string): Promise<boolean>;
+/**
+ * Delete a file
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ *
+ * @example
+ * ```typescript
+ * import { unlink } from '@standardagents/builder';
+ *
+ * await unlink(flow, "/temp/draft.txt");
+ * ```
+ */
+declare function unlink(flow: FlowState, path: string): Promise<void>;
+/**
+ * Create a directory
+ *
+ * @param flow - The current FlowState
+ * @param path - Directory path
+ * @returns The created directory record
+ *
+ * @example
+ * ```typescript
+ * import { mkdir } from '@standardagents/builder';
+ *
+ * await mkdir(flow, "/uploads/2024");
+ * ```
+ */
+declare function mkdir(flow: FlowState, path: string): Promise<FileRecord>;
+/**
+ * List directory contents
+ *
+ * @param flow - The current FlowState
+ * @param path - Directory path
+ * @returns Array of file records in the directory
+ *
+ * @example
+ * ```typescript
+ * import { readdir } from '@standardagents/builder';
+ *
+ * const files = await readdir(flow, "/images");
+ * for (const file of files) {
+ *   console.log(file.name, file.size);
+ * }
+ * ```
+ */
+declare function readdir(flow: FlowState, path: string): Promise<FileRecord[]>;
+/**
+ * Remove an empty directory
+ *
+ * @param flow - The current FlowState
+ * @param path - Directory path
+ *
+ * @example
+ * ```typescript
+ * import { rmdir } from '@standardagents/builder';
+ *
+ * await rmdir(flow, "/temp");
+ * ```
+ */
+declare function rmdir(flow: FlowState, path: string): Promise<void>;
+/**
+ * Get file storage statistics
+ *
+ * @param flow - The current FlowState
+ * @returns Storage statistics (total size and file count)
+ *
+ * @example
+ * ```typescript
+ * import { getFileStats } from '@standardagents/builder';
+ *
+ * const stats = await getFileStats(flow);
+ * console.log(`Total: ${stats.totalSize} bytes, Files: ${stats.fileCount}`);
+ * ```
+ */
+declare function getFileStats(flow: FlowState): Promise<FileStats>;
+/**
+ * Get thumbnail for an image file
+ *
+ * @param flow - The current FlowState
+ * @param path - Image file path
+ * @returns Thumbnail data as ArrayBuffer, or null if not found
+ *
+ * @example
+ * ```typescript
+ * import { getThumbnail } from '@standardagents/builder';
+ *
+ * const thumb = await getThumbnail(flow, "/images/photo.jpg");
+ * ```
+ */
+declare function getThumbnail(flow: FlowState, path: string): Promise<ArrayBuffer | null>;
+/**
+ * Read a text file as string
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @returns File content as string, or null if not found
+ *
+ * @example
+ * ```typescript
+ * import { cat } from '@standardagents/builder';
+ *
+ * const content = await cat(flow, "/docs/readme.md");
+ * ```
+ */
+declare function cat(flow: FlowState, path: string): Promise<string | null>;
+/**
+ * Read first N lines of a text file
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @param lines - Number of lines to read (default: 10)
+ * @returns First N lines as string, or null if not found
+ *
+ * @example
+ * ```typescript
+ * import { head } from '@standardagents/builder';
+ *
+ * const firstLines = await head(flow, "/logs/app.log", 20);
+ * ```
+ */
+declare function head(flow: FlowState, path: string, lines?: number): Promise<string | null>;
+/**
+ * Read last N lines of a text file
+ *
+ * @param flow - The current FlowState
+ * @param path - File path
+ * @param lines - Number of lines to read (default: 10)
+ * @returns Last N lines as string, or null if not found
+ *
+ * @example
+ * ```typescript
+ * import { tail } from '@standardagents/builder';
+ *
+ * const lastLines = await tail(flow, "/logs/app.log", 50);
+ * ```
+ */
+declare function tail(flow: FlowState, path: string, lines?: number): Promise<string | null>;
+/**
+ * Search text file contents using FTS5 full-text search
+ *
+ * @param flow - The current FlowState
+ * @param pattern - Search pattern (FTS5 syntax)
+ * @param options - Search options
+ * @returns Array of matching results with snippets
+ *
+ * @example
+ * ```typescript
+ * import { grep } from '@standardagents/builder';
+ *
+ * // Search all files
+ * const results = await grep(flow, "error");
+ *
+ * // Search in specific directory
+ * const results = await grep(flow, "TODO", { path: "/src" });
+ * ```
+ */
+declare function grep(flow: FlowState, pattern: string, options?: {
+    path?: string;
+    limit?: number;
+}): Promise<GrepResult[]>;
+/**
+ * Find files by path pattern
+ *
+ * @param flow - The current FlowState
+ * @param pattern - Glob-like pattern (e.g., "*.md", "/docs/subdir/*.txt")
+ * @param options - Find options
+ * @returns Array of matching file records
+ *
+ * @example
+ * ```typescript
+ * import { find } from '@standardagents/builder';
+ *
+ * // Find all markdown files
+ * const mdFiles = await find(flow, "*.md");
+ *
+ * // Find all files in docs
+ * const docFiles = await find(flow, "/docs/*", { type: "file" });
+ * ```
+ */
+declare function find(flow: FlowState, pattern: string, options?: {
+    type?: "file" | "directory" | "all";
+    limit?: number;
+}): Promise<FileRecord[]>;
+
+/**
+ * Options for injecting a message
+ */
+interface InjectMessageOptions {
+    /** The message content */
+    content: string;
+    /** The message role */
+    role: "system" | "user" | "assistant" | "tool";
+    /** Optional message ID. If not provided, a UUID will be generated */
+    id?: string;
+    /** Optional message to insert before. If not provided, message is appended to the end */
+    beforeMessageId?: string;
+    /** Optional tool call ID (for role="tool" only) */
+    toolCallId?: string;
+    /** Optional name field */
+    name?: string;
+    /** Whether this message is silent (hidden from LLM, visible in UI only). Default: false */
+    silent?: boolean;
+    /** Force message to be top-level (depth 0) even when called from sub-prompts. Default: false */
+    forceTopLevel?: boolean;
+    /** Force a specific side to play the next turn after injecting the message */
+    forceTurn?: "side_a" | "side_b";
+}
+/**
+ * Options for broadcasting custom data
+ */
+interface BroadcastOptions {
+    /** The type of the broadcast message */
+    type: string;
+    /** The value/payload of the broadcast message */
+    value: unknown;
+}
+/**
+ * FlowState SDK - Utility methods for working with FlowState
+ *
+ * These methods extend the FlowState object with helpful utilities for:
+ * - Queuing tool calls
+ * - Injecting messages
+ * - Retrieving message history
+ * - Broadcasting custom data via WebSocket
+ */
+declare class FlowStateSdk {
+    /**
+     * Queue a new tool call to be executed in the current flow
+     *
+     * This adds a tool call to the execution queue without immediately executing it.
+     * The tool will be executed as part of the normal flow processing.
+     *
+     * @param flow - The current FlowState
+     * @param toolName - The name of the tool to call (autocompletes from available tools)
+     * @param args - The arguments to pass to the tool
+     *
+     * @example
+     * ```typescript
+     * FlowStateSdk.queueTool(flow, "search_user", { email: "user@example.com" });
+     * ```
+     */
+    static queueTool(flow: FlowState, toolName: StandardAgentSpec.Callables, args?: Record<string, unknown>): void;
+    /**
+     * Inject a message into the thread without triggering execution
+     *
+     * This allows you to add messages to the conversation history programmatically.
+     * The message is persisted to storage but does not cause the agent to execute.
+     *
+     * By default, messages are appended to the end of the conversation.
+     * You can optionally insert a message before another message by providing beforeMessageId.
+     *
+     * @param flow - The current FlowState
+     * @param options - Message options
+     *
+     * @example
+     * ```typescript
+     * // Append a system message
+     * await FlowStateSdk.injectMessage(flow, {
+     *   role: "system",
+     *   content: "Context has been updated"
+     * });
+     *
+     * // Insert a user message before a specific message
+     * await FlowStateSdk.injectMessage(flow, {
+     *   role: "user",
+     *   content: "Additional context",
+     *   beforeMessageId: "msg-123"
+     * });
+     *
+     * // Inject a message and force a specific side to play next
+     * await FlowStateSdk.injectMessage(flow, {
+     *   role: "system",
+     *   content: "New instructions for the AI",
+     *   forceTurn: "side_a" // Force side_a to respond to this message
+     * });
+     * ```
+     */
+    static injectMessage(flow: FlowState, options: InjectMessageOptions): Promise<Message>;
+    /**
+     * Get messages from the thread history
+     *
+     * Retrieves message history from the thread's SQLite storage.
+     * Messages are ordered by creation time (oldest first by default).
+     *
+     * @param flow - The current FlowState
+     * @param limit - Maximum number of messages to retrieve (default: 100)
+     * @param offset - Number of messages to skip (default: 0)
+     * @param order - Sort order: "asc" (oldest first) or "desc" (newest first) (default: "asc")
+     * @returns Array of messages
+     *
+     * @example
+     * ```typescript
+     * // Get last 10 messages
+     * const messages = await FlowStateSdk.getMessages(flow, 10);
+     *
+     * // Get 10 messages, skipping the first 20
+     * const messages = await FlowStateSdk.getMessages(flow, 10, 20);
+     *
+     * // Get newest 10 messages
+     * const messages = await FlowStateSdk.getMessages(flow, 10, 0, "desc");
+     * ```
+     */
+    static getMessages(flow: FlowState, limit?: number, offset?: number, order?: "asc" | "desc"): Promise<Message[]>;
+    /**
+     * Reload message history from storage
+     *
+     * Re-loads the complete message history from the thread's SQLite storage,
+     * applying any filter_messages hooks. This is useful when you need to refresh
+     * the message history after making changes (e.g., injecting silent messages).
+     *
+     * @param flow - The current FlowState
+     * @returns Array of messages (reloaded from storage)
+     *
+     * @example
+     * ```typescript
+     * // Reload history after injecting a silent message
+     * await FlowStateSdk.injectMessage(flow, { role: "system", content: "...", silent: true });
+     * flow.messageHistory = await FlowStateSdk.reloadHistory(flow);
+     * ```
+     */
+    static reloadHistory(state: FlowState): Promise<Message[]>;
+    /**
+     * Broadcast custom data to WebSocket clients
+     *
+     * Sends a custom message to all connected WebSocket clients.
+     * This allows backend code to push arbitrary data to the frontend
+     * outside of the standard telemetry events.
+     *
+     * The message is sent with the structure: { type: string, value: unknown }
+     *
+     * @param flow - The current FlowState
+     * @param options - Broadcast options
+     *
+     * @example
+     * ```typescript
+     * // Broadcast a progress update
+     * FlowStateSdk.broadcast(flow, {
+     *   type: "progress",
+     *   value: { step: 3, total: 10, message: "Processing data..." }
+     * });
+     *
+     * // Broadcast a custom notification
+     * FlowStateSdk.broadcast(flow, {
+     *   type: "notification",
+     *   value: { level: "info", message: "User authenticated successfully" }
+     * });
+     *
+     * // Broadcast metadata
+     * FlowStateSdk.broadcast(flow, {
+     *   type: "metadata",
+     *   value: { userId: "123", sessionId: "abc", timestamp: Date.now() }
+     * });
+     * ```
+     */
+    static broadcast(flow: FlowState, options: BroadcastOptions): void;
+    /**
+     * Force a specific side to play the next turn
+     *
+     * This queues the specified side to play next without interrupting the current turn.
+     * The forced turn only takes effect at the END of the current turn execution.
+     *
+     * If the tool queue is currently being processed (sequence.isHandling is true),
+     * the forced turn is deferred until all queued tools complete. This allows patterns like:
+     *
+     * ```typescript
+     * FlowStateSdk.queueTool(flow, 'myTool', {});
+     * FlowStateSdk.forceTurn(flow, 'side_a');
+     * // myTool executes first, THEN the turn switches to side_a
+     * ```
+     *
+     * @param flow - The current FlowState
+     * @param side - Which side should play next ('side_a' or 'side_b')
+     *
+     * @example
+     * ```typescript
+     * // Force current side to continue (override stop condition)
+     * // If side_a is playing and would stop, this forces it to play at least 1 more turn
+     * FlowStateSdk.forceTurn(flow, 'side_a');
+     *
+     * // Force switch to other side
+     * // If side_a is playing, this forces side_b to play next turn
+     * FlowStateSdk.forceTurn(flow, 'side_b');
+     *
+     * // Force human turn in ai_human agent (execution stops and waits for user input)
+     * if (flow.agentConfig.type === 'ai_human') {
+     *   FlowStateSdk.forceTurn(flow, 'side_b'); // Stops execution, awaits user input
+     * }
+     * ```
+     */
+    static forceTurn(flow: FlowState, side: 'side_a' | 'side_b'): void;
+}
+/**
+ * Convenience methods added to FlowState (optional - can be used via static methods above)
+ *
+ * These are helper methods that can be added to FlowState instances for convenience.
+ * They delegate to the static methods above.
+ */
+interface FlowStateWithSdk extends FlowState {
+    queueTool: (toolName: StandardAgentSpec.Callables, args?: Record<string, unknown>) => void;
+    injectMessage: (options: InjectMessageOptions) => Promise<Message>;
+    getMessages: (limit?: number, offset?: number, order?: "asc" | "desc") => Promise<Message[]>;
+    reloadHistory: () => Promise<Message[]>;
+    broadcast: (options: BroadcastOptions) => void;
+    forceTurn: (side: 'side_a' | 'side_b') => void;
+}
+/**
+ * Enhance a FlowState object with SDK methods
+ *
+ * This adds convenience methods to a FlowState instance that delegate to
+ * the static FlowStateSdk methods.
+ *
+ * @param flow - The FlowState to enhance
+ * @returns The enhanced FlowState with SDK methods
+ *
+ * @example
+ * ```typescript
+ * const enhancedFlow = enhanceFlowState(flow);
+ *
+ * // Now you can use methods directly on the flow object
+ * enhancedFlow.queueTool("search_user", { email: "user@example.com" });
+ * await enhancedFlow.injectMessage({ role: "system", content: "Context updated" });
+ * const messages = await enhancedFlow.getMessages(10);
+ * flow.messageHistory = await enhancedFlow.reloadHistory();
+ * enhancedFlow.broadcast({ type: "progress", value: { step: 1 } });
+ * enhancedFlow.forceTurn('side_b'); // Force side_b to play next turn
+ * ```
+ */
+declare function enhanceFlowState(flow: FlowState): FlowStateWithSdk;
+
+/**
+ * Context Management for Image Attachments
+ *
+ * Handles auto-summarization of old images to reduce context window usage
+ * while preserving the semantic meaning of image content.
+ */
+
+/**
+ * Configuration for image context management
+ */
+interface ImageContextConfig {
+    /** Number of recent messages to keep images for (default: 10) */
+    recentMessageThreshold: number;
+    /** System prompt for generating image descriptions */
+    descriptionPrompt: string;
+}
+/**
+ * Check if a message has image attachments that could be summarized
+ */
+declare function hasImageAttachments(message: Message): boolean;
+/**
+ * Get image attachments from a message that don't have descriptions yet
+ */
+declare function getUnsummarizedImageAttachments(message: Message): AttachmentRef[];
+/**
+ * Determine which messages should have their images replaced with descriptions.
+ * Returns indices of messages that are old enough to be summarized.
+ */
+declare function getMessagesToSummarize(messages: Message[], config?: ImageContextConfig): number[];
+/**
+ * Build text representation for an image attachment (used when image is too old)
+ */
+declare function buildImageDescription(attachment: AttachmentRef): string;
+/**
+ * Transform message content to replace old images with text descriptions.
+ * This modifies the content array for LLM context building.
+ */
+declare function replaceImagesWithDescriptions(content: MessageContent, attachments: AttachmentRef[]): MessageContent;
+/**
+ * Process message history to optimize context window usage.
+ * Old images are replaced with their text descriptions.
+ *
+ * @param messages - Full message history
+ * @param config - Context management configuration
+ * @returns Processed messages with old images replaced by descriptions
+ */
+declare function optimizeImageContext(messages: Message[], config?: ImageContextConfig): Message[];
+/**
+ * Generate a description for an image using a vision model.
+ * This should be called when storing new messages with images.
+ *
+ * Note: This function is a placeholder for the actual LLM call.
+ * The actual implementation would need to make an API call to a vision model.
+ *
+ * @param imageBase64 - Base64-encoded image data
+ * @param mimeType - MIME type of the image
+ * @param state - Flow state for LLM access
+ * @returns Generated description
+ */
+declare function generateImageDescription(_imageBase64: string, _mimeType: string, _state: FlowState): Promise<string | null>;
+
+/** @public Alias for LLMProviderInterface */
+type Provider = LLMProviderInterface;
+/** @public Alias for ContentPart */
+type ProviderContentPart = ContentPart;
+/** @public Alias for TextPart */
+type ProviderTextPart = TextPart;
+/** @public Alias for ImagePart */
+type ProviderImagePart = ImagePart;
+/** @public Alias for FilePart */
+type ProviderFilePart = FilePart;
+
+/**
+ * Function that can intercept provider creation.
+ * Returns a provider to override the default, or null to fall through.
+ */
+type ProviderOverrideFn = (modelName: string, modelDef: ModelDefinition$1<string>, env: Env) => LLMProviderInterface | null;
+/**
+ * Provider registry implementation
+ *
+ * Models must use ProviderFactory functions imported from provider packages
+ * (e.g., @standardagents/openai, @standardagents/openrouter).
+ *
+ * Loads model configs from TypeScript virtual modules and
+ * provider API keys from environment variables.
+ */
+declare class ProviderRegistryImpl {
+    private providerCache;
+    private providerOverrideFn;
+    private providerOverrideRevision;
+    setProviderOverride(fn: ProviderOverrideFn | null): void;
+    /**
+     * Get provider for a model.
+     *
+     * Models must use ProviderFactory functions (imported from provider packages).
+     *
+     * @param modelName - The model name (from TypeScript config)
+     * @param env - Environment bindings
+     * @param thread - Thread instance for loading model from virtual modules
+     * @returns Provider and model definition
+     */
+    getProvider(modelName: string, env: Env, thread?: ThreadInstance): Promise<{
+        provider: LLMProviderInterface;
+        modelName: string;
+        modelDef: ModelDefinition$1<string>;
+    }>;
+    private buildResult;
+    private cacheAndReturn;
+    private getProviderFingerprint;
+    /**
+     * Get API key for a provider from environment variables.
+     */
+    private getApiKeyForProvider;
+    /**
+     * Clear the provider cache
+     * Useful for testing or when configurations change
+     */
+    clearCache(): void;
+}
+/**
+ * Singleton instance
+ */
+declare const ProviderRegistry: ProviderRegistryImpl;
+
+/**
+ * Namespace-scoped resolution for the packing system.
+ *
+ * This module provides functions to resolve items (tools, prompts, models, agents)
+ * within the correct namespace context, enforcing isolation between packed and
+ * unpacked code.
+ *
+ * @module
+ */
+
+/**
+ * Error thrown when an item cannot be resolved in the current namespace.
+ */
+declare class NamespaceResolutionError extends Error {
+    readonly itemType: 'tool' | 'prompt' | 'model' | 'agent' | 'hook';
+    readonly itemName: string;
+    readonly namespace: NamespaceContext;
+    constructor(itemType: 'tool' | 'prompt' | 'model' | 'agent' | 'hook', itemName: string, namespace: NamespaceContext, message: string);
+}
+/**
+ * Parse a potentially qualified name into package ID and short name.
+ *
+ * For scoped npm packages (starting with @), the format is @scope/pkg-name/item-name
+ * where @scope/pkg-name is the package and item-name is the short name.
+ *
+ * For non-scoped packages, the format is pkg-name/item-name.
+ *
+ * @param name - The name to parse (e.g., 'tool', 'pkg/tool', or '@scope/pkg/tool')
+ * @returns Tuple of [packageId, shortName] where packageId is null for unqualified names
+ */
+declare function parseQualifiedName(name: string): [string | null, string];
+/**
+ * Create a qualified name from package ID and short name.
+ */
+declare function qualifyName(packageId: string, shortName: string): string;
+/**
+ * Get the short name (strip any package qualification).
+ */
+declare function getShortName(name: string): string;
+/**
+ * Resolve a tool by name within a namespace context.
+ *
+ * Resolution rules:
+ * - Qualified names (pkg:tool) → resolve cross-package entry point
+ * - Unqualified names in packed context → resolve from own package
+ * - Unqualified names in global context → resolve from global namespace
+ *
+ * @param registry - The namespaced registry
+ * @param name - Tool name (can be qualified with packageId:toolName)
+ * @param namespace - Current namespace context
+ * @returns Loader function for the tool definition
+ * @throws NamespaceResolutionError if tool cannot be found or accessed
+ */
+declare function resolveTool(registry: NamespacedRegistry, name: string, namespace: NamespaceContext): DefinitionLoader<unknown>;
+/**
+ * Resolve a prompt by name within a namespace context.
+ *
+ * @param registry - The namespaced registry
+ * @param name - Prompt name (can be qualified)
+ * @param namespace - Current namespace context
+ * @returns Loader function for the prompt definition
+ */
+declare function resolvePrompt(registry: NamespacedRegistry, name: string, namespace: NamespaceContext): DefinitionLoader<unknown>;
+/**
+ * Resolve a model by name within a namespace context.
+ *
+ * Models are special: packed agents include their model definitions,
+ * but the host must provide API keys.
+ *
+ * @param registry - The namespaced registry
+ * @param name - Model name
+ * @param namespace - Current namespace context
+ * @returns Loader function for the model definition
+ */
+declare function resolveModel(registry: NamespacedRegistry, name: string, namespace: NamespaceContext): DefinitionLoader<unknown>;
+/**
+ * Resolve an agent by name within a namespace context.
+ *
+ * Resolution rules:
+ * - Qualified names (pkg:agent) → resolve cross-package entry point
+ * - Unqualified in packed → resolve from own package
+ * - Unqualified in global → resolve from global + entry points
+ *
+ * @param registry - The namespaced registry
+ * @param name - Agent name (can be qualified)
+ * @param namespace - Current namespace context
+ * @returns Loader function for the agent definition
+ */
+declare function resolveAgent(registry: NamespacedRegistry, name: string, namespace: NamespaceContext): DefinitionLoader<unknown>;
+/**
+ * Resolve a hook by name within a namespace context.
+ *
+ * Hooks follow similar rules to tools but are keyed by hook type.
+ *
+ * @param registry - The namespaced registry
+ * @param name - Hook name (file name, e.g., 'filter_messages')
+ * @param namespace - Current namespace context
+ * @returns Loader function for the hook implementation
+ */
+declare function resolveHook(registry: NamespacedRegistry, name: string, namespace: NamespaceContext): DefinitionLoader<unknown> | null;
+/**
+ * Get all tool names visible in a namespace context.
+ *
+ * @param registry - The namespaced registry
+ * @param namespace - Current namespace context
+ * @returns Array of visible tool names (short names)
+ */
+declare function getVisibleToolNames(registry: NamespacedRegistry, namespace: NamespaceContext): string[];
+/**
+ * Get all agent names visible in a namespace context.
+ *
+ * @param registry - The namespaced registry
+ * @param namespace - Current namespace context
+ * @returns Array of visible agent names (may include qualified names for cross-package)
+ */
+declare function getVisibleAgentNames(registry: NamespacedRegistry, namespace: NamespaceContext): string[];
+/**
+ * Get all prompt names visible in a namespace context.
+ */
+declare function getVisiblePromptNames(registry: NamespacedRegistry, namespace: NamespaceContext): string[];
+/**
+ * Get all model names visible in a namespace context.
+ */
+declare function getVisibleModelNames(registry: NamespacedRegistry, namespace: NamespaceContext): string[];
+/**
+ * Create a namespace context for an agent definition.
+ *
+ * @param agentDef - Agent definition (may have __package field)
+ * @returns Appropriate namespace context
+ */
+declare function createNamespaceContext(agentDef: {
+    __package?: {
+        packageId: string;
+    };
+} | undefined): NamespaceContext;
+/**
+ * Check if a name is qualified (contains package prefix).
+ *
+ * For scoped packages (@scope/name), there must be at least two slashes
+ * to be considered qualified (e.g., @scope/pkg/item).
+ * For non-scoped packages, a single slash qualifies it (e.g., pkg/item).
+ */
+declare function isQualifiedName(name: string): boolean;
+
+export { type AgentBuilderEnv, type AgentDefinition, AttachmentRef, type AuthContext, type AuthUser, type BroadcastOptions, CodeExecutionBridge, DurableAgentBuilder, DurableThread, Env, FileRecord, FileStats, FlowState, FlowStateSdk, type FlowStateWithSdk, GrepResult, type ImageContextConfig, type InjectMessageOptions$1 as InjectMessageOptions, type Provider as LLMProviderInterface, Message, MessageContent, type ModelDefinition, NamespaceResolutionError, NamespacedRegistry, type PromptContent, type PromptDefinition, type PromptIncludePart, type PromptPart, type PromptToolConfig, type Provider$1 as Provider, type ProviderContentPart, type ProviderFilePart, type ProviderImagePart, ProviderRegistry, type ProviderTextPart, type SessionToolBinding, type SessionToolConfig, type SideConfig, type SubagentToolConfig, type SubpromptConfig, ThreadEnv, ThreadInstance, ThreadMetadata, type ThreadRegistryEntry, type ToolConfig, type UpdateThreadParams, type User, authenticate, buildImageDescription, cat, createNamespaceContext, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isQualifiedName, linkFile, mkdir, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage };