@standardagents/builder 0.11.12 → 0.12.1

package/dist/index-DkbUJ4MM.d.ts

@@ -0,0 +1,1043 @@
+import { DurableObjectStorage } from '@cloudflare/workers-types';
+import { ZodObject, ZodRawShape } from 'zod';
+import { N as NamespacedRegistry } from './types-pLkJx8vg.js';
+import { ToolResult as ToolResult$1, HookName, HookSignatures, ThreadState, HookMessage, HookToolCall, HookToolResult, AgentDefinition, ControllerContext, Controller, ThreadEndpointHandler } from '@standardagents/spec';
+
+/**
+ * Callback function to execute before stream closes
+ */
+type BeforeClose = () => Promise<void> | void;
+/**
+ * Manages HTTP streaming of content chunks.
+ * WebSocket telemetry is handled separately by DurableThread.
+ * Inspired by bod.coach MultiplexedStream pattern.
+ */
+declare class StreamManager {
+    /**
+     * HTTP ReadableStream controller for content
+     */
+    private httpController?;
+    /**
+     * HTTP ReadableStream for content chunks
+     */
+    httpStream: ReadableStream<Uint8Array>;
+    /**
+     * Active channels
+     */
+    activeChannels: number;
+    /**
+     * Before close hooks
+     */
+    private beforeCloseHooks;
+    /**
+     * Prevent automatic close
+     */
+    preventClose: boolean;
+    /**
+     * Text encoder for streams
+     */
+    private encoder;
+    /**
+     * Promise that resolves when stream is completely finished
+     */
+    then: Promise<void>;
+    /**
+     * Resolver for the then promise
+     */
+    private resolver;
+    /**
+     * Whether the stream has been closed
+     */
+    private closed;
+    constructor(beforeClose?: BeforeClose | BeforeClose[]);
+    /**
+     * Send content chunk to HTTP stream
+     */
+    sendContent(chunk: string): void;
+    /**
+     * Add a before close hook
+     */
+    addBeforeClose(hook: BeforeClose | BeforeClose[]): void;
+    /**
+     * Wait for a callback to complete before allowing stream to close
+     */
+    waitFor(callback: () => Promise<void> | void): Promise<void>;
+    /**
+     * Close a channel (decrement active channel count)
+     */
+    closeChannel(): void;
+    /**
+     * Close all streams and connections
+     */
+    close(): Promise<void>;
+    /**
+     * Force close the stream immediately
+     */
+    forceClose(): void;
+}
+
+/**
+ * Agent configuration from D1 agents table
+ */
+interface Agent {
+    id: string;
+    title: string;
+    type: "dual_ai" | "ai_human";
+    created_at: number;
+    max_session_turns: number | null;
+    side_a_label: string | null;
+    side_a_agent_prompt: string | null;
+    side_a_stop_on_response: boolean;
+    side_a_stop_tool: string | null;
+    side_a_stop_tool_response_property: string | null;
+    side_a_max_steps: number | null;
+    side_a_end_session_tool: string | null;
+    side_b_label: string | null;
+    side_b_agent_prompt: string | null;
+    side_b_stop_on_response: boolean;
+    side_b_stop_tool: string | null;
+    side_b_stop_tool_response_property: string | null;
+    side_b_max_steps: number | null;
+    side_b_end_session_tool: string | null;
+    hooks?: string[];
+}
+/**
+ * Message in OpenAI chat completion format
+ */
+interface Message {
+    id: string;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null;
+    name?: string | null;
+    tool_calls?: string | null;
+    tool_call_id?: string | null;
+    log_id?: string | null;
+    created_at: number;
+    request_sent_at?: number | null;
+    response_completed_at?: number | null;
+    status?: "pending" | "completed" | "failed" | null;
+    silent?: boolean;
+    tool_status?: "success" | "error" | null;
+    reasoning_content?: string | null;
+    reasoning_details?: string | null;
+    parent_id?: string | null;
+    depth?: number;
+    attachments?: string | null;
+}
+/**
+ * Tool call from OpenAI format
+ */
+interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+    forceAllow?: boolean;
+    queued_at?: number;
+}
+/**
+ * Thread metadata from DurableAgentBuilder
+ * Note: agent_id is now the agent name (not UUID) since agents are in TypeScript
+ */
+interface ThreadMetadata {
+    id: string;
+    agent_id: string;
+    user_id: string | null;
+    tenvs: Record<string, unknown> | null;
+    properties: Record<string, unknown> | null;
+    created_at: number;
+}
+/**
+ * A loaded hook definition with its metadata.
+ * Generic K preserves the hook type for type-safe execution.
+ *
+ * @template K - Hook type from HookSignatures (e.g., 'filter_messages')
+ */
+interface LoadedHook<K extends HookName = HookName> {
+    /** The hook type name */
+    hook: K;
+    /** The unique hook ID */
+    id: string;
+    /** The typed execute function */
+    execute: HookSignatures<ThreadState, HookMessage, HookToolCall, HookToolResult>[K];
+}
+/**
+ * Union type for any loaded hook (used when hook type isn't known statically).
+ * This creates a discriminated union on the `hook` property.
+ */
+type AnyLoadedHook = {
+    [K in HookName]: LoadedHook<K>;
+}[HookName];
+/**
+ * Hook registry type - maps hook IDs to async loaders returning typed hooks.
+ * The new format uses hook IDs as keys (not hook type names).
+ */
+type HookRegistry = Record<string, () => Promise<AnyLoadedHook | null>>;
+/**
+ * Native tool module type - represents a loaded tool definition.
+ * Tools can have args (with validation schema) or no args.
+ * Uses local Zod types for compatibility with z.toJSONSchema().
+ */
+interface NativeToolModule {
+    /** Description of what the tool does (shown to the LLM). */
+    description: string;
+    /** Zod schema for validating tool arguments, or null for no args. */
+    args: ZodObject<ZodRawShape> | null;
+    /** The tool implementation function. */
+    execute: ((state: any, args: Record<string, unknown>) => Promise<ToolResult$1>) | ((state: any) => Promise<ToolResult$1>);
+    /** Zod schema for thread environment variables, or null if none. */
+    tenvs?: ZodObject<ZodRawShape> | null;
+    /**
+     * Where this tool is executed:
+     * - 'local': Execute locally by the execution engine (default)
+     * - 'provider': Executed by the LLM provider, results come in response
+     */
+    executionMode?: 'local' | 'provider';
+    /**
+     * Which provider executes this tool (when executionMode='provider').
+     */
+    executionProvider?: string;
+}
+/**
+ * Thread instance (forward reference to avoid circular dependency)
+ */
+interface ThreadInstance {
+    ctx: DurableObjectState;
+    env: ThreadEnv;
+    getMessages(limit?: number, offset?: number, order?: "asc" | "desc", includeSilent?: boolean, maxDepth?: number): Promise<{
+        messages: Message[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    getLogs(limit?: number, offset?: number, order?: "asc" | "desc"): Promise<LogData[]>;
+    getThreadMeta(threadId: string): Promise<ThreadMetadata | null>;
+    deleteMessage(messageId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    shouldStop(): Promise<boolean>;
+    tools(): Record<string, () => Promise<NativeToolModule>>;
+    hooks(): HookRegistry;
+    loadModel(name: string): Promise<any>;
+    loadPrompt(name: string): Promise<any>;
+    loadAgent(name: string): Promise<any>;
+    loadTool(name: string): Promise<any>;
+    getPromptNames(): string[];
+    getAgentNames(): string[];
+    writeFile(path: string, data: string, mimeType: string, options?: Record<string, unknown>): Promise<any>;
+    writeTextFile(path: string, content: string, mimeType: string, options?: Record<string, unknown>): Promise<any>;
+    readFile(path: string): Promise<{
+        success: boolean;
+        data?: string;
+        error?: string;
+    }>;
+    statFile(path: string): Promise<any>;
+    readdirFile(path: string): Promise<any[]>;
+    unlinkFile(path: string): Promise<void>;
+    mkdirFile(path: string): Promise<any>;
+    rmdirFile(path: string): Promise<void>;
+    getFileStats(): Promise<any>;
+    grepFiles(pattern: string): Promise<any[]>;
+    findFiles(pattern: string): Promise<any>;
+    getFileThumbnail(path: string): Promise<ArrayBuffer | null>;
+    readFileChunk(path: string, chunkIndex: number): Promise<{
+        success: boolean;
+        data?: string;
+        error?: string;
+    }>;
+    runAgent(threadId: string, agentName: string): Promise<void>;
+    scheduleEffect(threadId: string, effectName: string, effectArgs: Record<string, unknown>, delayMs?: number): Promise<string>;
+    getScheduledEffects(name?: string): Promise<Array<{
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+        scheduledAt: number;
+        createdAt: number;
+    }>>;
+    removeScheduledEffect(id: string): Promise<boolean>;
+    insertOrphanedToolCall(params: {
+        content?: string;
+        toolCallId: string;
+        toolName: string;
+        toolArgs: string;
+    }): Promise<Response>;
+}
+/**
+ * Tool call for internal flow management
+ */
+type FlowToolCall = {
+    tool: string;
+    args: Record<string, unknown>;
+};
+/**
+ * Prompt call for internal flow management
+ */
+type FlowPromptCall = {
+    prompt: string;
+    args: Record<string, unknown>;
+};
+/**
+ * Flow call (tool or prompt)
+ */
+type FlowCall = FlowToolCall | FlowPromptCall;
+/**
+ * Flow call with retry tracking
+ */
+type FlowCallWithRetries = FlowCall & {
+    retries: number;
+    reasons: string[];
+};
+/**
+ * Sub-prompt configuration - defines options for when a sub-prompt is called as a tool
+ */
+interface SubpromptConfig {
+    name: string;
+    initUserMessageProperty?: string;
+    initAttachmentsProperty?: string;
+    includeTextResponse?: boolean;
+    includeToolCalls?: boolean;
+    includeErrors?: boolean;
+}
+/**
+ * Prompt configuration - now loaded from TypeScript virtual modules
+ */
+interface PromptData {
+    id: string;
+    name: string;
+    prompt: string | any[];
+    system_prompt?: string;
+    model: string;
+    model_id?: string;
+    tool_description: string;
+    required_schema: string;
+    include_chat: boolean;
+    include_past_tools: boolean;
+    prompts: string;
+    created_at: number;
+    /** @deprecated All prompts are now automatically exposed as tools */
+    expose_as_tool?: boolean;
+    parallel_tool_calls: boolean;
+    tool_choice: "auto" | "none" | "required" | "function";
+    reasoning_effort: "low" | "medium" | "high" | null;
+    reasoning_max_tokens: number | null;
+    reasoning_exclude: boolean;
+    include_reasoning: boolean;
+    recentImageThreshold: number | null;
+    _tools?: (string | SubpromptConfig)[];
+    _requiredSchema?: unknown;
+    _hooks?: string[];
+}
+/**
+ * Central state object that flows through execution
+ */
+interface FlowState {
+    threadId: string;
+    flowId: string;
+    thread: {
+        instance: ThreadInstance;
+        metadata: ThreadMetadata;
+    };
+    agentConfig: Agent;
+    currentSide: "a" | "b";
+    prompts: {
+        sideA: PromptData;
+        sideB: PromptData | null;
+    };
+    prompt: PromptData;
+    stepCount: number;
+    sideAStepCount: number;
+    sideBStepCount: number;
+    stopped: boolean;
+    stoppedBy?: "a" | "b";
+    forcedNextSide?: "side_a" | "side_b";
+    pendingForceTurn?: "side_a" | "side_b";
+    abortController?: AbortController;
+    messageHistory: Message[];
+    /**
+     * Appends these messages
+     */
+    extraMessages: Message[];
+    sequence: {
+        queue: ToolCall[];
+        queuedTools: ToolCall[];
+        isHandling: boolean;
+    };
+    active: FlowCallWithRetries;
+    queue: FlowCall[];
+    pendingHandoff?: {
+        agentId: string;
+        args?: Record<string, unknown>;
+        toolConfig?: {
+            initUserMessageProperty?: string;
+            initAttachmentsProperty?: string;
+        };
+    };
+    stream: StreamManager;
+    context: Record<string, unknown>;
+    retryCount: number;
+    retryReason?: string;
+    storage: DurableObjectStorage;
+    env: ThreadEnv;
+    emitLog?: (log: unknown) => void;
+    emitMessage?: (message: unknown) => void;
+    emitMessageChunk?: (messageId: string, chunk: string, depth?: number) => void;
+    emitTelemetry?: (event: TelemetryEvent) => void;
+    emitEvent?: (type: string, data: unknown) => void;
+    rootState: FlowState;
+    rootMessageId?: string | null;
+    parentLogId?: string | null;
+    currentLogId?: string | null;
+    parentMessageId?: string;
+    depth: number;
+    /** Path from root prompt to current prompt (e.g., ['basic_prompt', 'generate_image']) */
+    promptPath: string[];
+    pendingMessageId?: string;
+    allowedTools?: ToolDefinition[];
+    pendingMetadataPromises?: Promise<void>[];
+    /**
+     * Current namespace context for execution.
+     * Determines what tools, prompts, and agents are visible.
+     * - { type: 'global' } for unpacked agents
+     * - { type: 'packed', packageId: '...' } for packed agents
+     */
+    namespaceContext: {
+        type: 'global';
+    } | {
+        type: 'packed';
+        packageId: string;
+    };
+    /**
+     * The `uses` list from the currently executing tool.
+     * Used by queueTool/invokeTool to validate allowed calls.
+     * Undefined means no restriction (global context or tool without uses).
+     */
+    currentToolUses?: string[];
+}
+/**
+ * Text content part for multimodal messages
+ */
+interface TextContentPart {
+    type: "text";
+    text: string;
+}
+/**
+ * Image URL content part for multimodal messages (OpenAI/OpenRouter format)
+ */
+interface ImageContentPart {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+}
+/**
+ * Multimodal content - array of text and image parts
+ */
+type MultimodalContent = Array<TextContentPart | ImageContentPart>;
+/**
+ * Message content - can be string (text only) or array (multimodal)
+ */
+type MessageContent = string | MultimodalContent;
+/**
+ * Request context for LLM calls
+ */
+interface RequestContext {
+    messages: Array<{
+        role: "system" | "user" | "assistant" | "tool";
+        content?: MessageContent;
+        tool_calls?: ToolCall[];
+        tool_call_id?: string;
+        name?: string;
+        reasoning_content?: string;
+        reasoning_details?: any[];
+        attachments?: any[];
+        toolName?: string;
+    }>;
+    model: string;
+    tools?: ToolDefinition[];
+    stream?: boolean;
+    promptName?: string;
+    systemPrompt?: string;
+    parentLogId?: string | null;
+    parallel_tool_calls?: boolean;
+    tool_choice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    reasoning?: {
+        effort?: "low" | "medium" | "high";
+        max_tokens?: number;
+        exclude?: boolean;
+    };
+    imagePathMap?: Map<string, string>;
+}
+/**
+ * Tool definition for LLM requests
+ */
+interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, any>;
+    };
+    /**
+     * Where this tool is executed:
+     * - 'local': Execute locally by the execution engine (default)
+     * - 'provider': Executed by the LLM provider, results come in response
+     */
+    executionMode?: 'local' | 'provider';
+    /**
+     * Which provider executes this tool (when executionMode='provider')
+     * e.g., 'openai', 'anthropic'
+     */
+    executionProvider?: string;
+}
+/**
+ * Image returned by an LLM response (e.g., from image generation models)
+ * Format follows OpenAI/OpenRouter chat completions API
+ */
+interface LLMResponseImage {
+    type: "image_url";
+    /** Unique ID for this generated image (used to link to tool call) */
+    id?: string;
+    /** Name of the tool that generated this image (e.g., 'image_generation') */
+    toolName?: string;
+    /** The revised/actual prompt used to generate the image (from OpenAI's image_generation) */
+    revisedPrompt?: string;
+    image_url: {
+        url: string;
+    };
+}
+/**
+ * LLM response
+ */
+interface LLMResponse {
+    id: string;
+    model: string;
+    content: string | null;
+    reasoning_content?: string | null;
+    reasoning_details?: any[];
+    tool_calls?: ToolCall[];
+    images?: LLMResponseImage[];
+    finish_reason: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+        completion_tokens_details?: {
+            reasoning_tokens?: number;
+        };
+        cost?: number;
+        provider?: string;
+    };
+    /** @internal Provider instance reference for async metadata fetching */
+    _provider?: unknown;
+    /** @internal Provider response ID for async metadata fetching */
+    _providerResponseId?: string;
+    /** @internal Aggregate response for logging */
+    _aggregate_response?: unknown;
+}
+/**
+ * Attachment returned by a tool (e.g., generated images)
+ * Stored in thread filesystem and linked to the tool message
+ */
+interface ToolAttachment {
+    name: string;
+    mimeType: string;
+    data: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Tool result
+ */
+interface ToolResult {
+    status: "success" | "error";
+    /**
+     * Flattened text representation of the tool output.
+     *
+     * For tools that return structured MCP-style content (an array of
+     * content parts), this will be derived by concatenating all text
+     * parts. For legacy tools that returned a plain string `result`,
+     * that value is used directly.
+     */
+    result?: string;
+    error?: string;
+    stack?: string;
+    /**
+     * File attachments returned by the tool.
+     *
+     * Can contain either:
+     * - ToolAttachment: New files with base64 data to be stored
+     * - AttachmentRef: References to existing files in the thread filesystem
+     *
+     * New attachments are stored under /attachments/ directory.
+     */
+    attachments?: Array<ToolAttachment | AttachmentRef>;
+}
+/**
+ * Flow execution result
+ */
+interface FlowResult {
+    messages: Message[];
+    stopped: boolean;
+    stoppedBy?: "a" | "b";
+    stepCount: number;
+    stream: ReadableStream<Uint8Array>;
+}
+/**
+ * Telemetry event types
+ */
+type TelemetryEvent = {
+    type: "step_started";
+    step: number;
+    side: "a" | "b";
+    timestamp: number;
+} | {
+    type: "step_completed";
+    step: number;
+    stopped: boolean;
+    timestamp: number;
+} | {
+    type: "llm_request";
+    model: string;
+    attempt: number;
+    timestamp: number;
+} | {
+    type: "llm_response";
+    tokens: number;
+    latency: number;
+    timestamp: number;
+} | {
+    type: "validation_failed";
+    error: string;
+    timestamp: number;
+} | {
+    type: "fallback_triggered";
+    from: string;
+    to: string;
+    timestamp: number;
+} | {
+    type: "tool_started";
+    tool: string;
+    timestamp: number;
+} | {
+    type: "tool_completed";
+    tool: string;
+    status: string;
+    timestamp: number;
+} | {
+    type: "stopped";
+    reason: string;
+    side: "a" | "b";
+    timestamp: number;
+} | {
+    type: "stopped_by_user";
+    timestamp: number;
+};
+/**
+ * Log data for telemetry table
+ */
+interface LogData {
+    id: string;
+    message_id: string;
+    provider: string;
+    model: string;
+    model_name?: string;
+    endpoint?: string;
+    request_body?: string;
+    request_headers?: string;
+    response_body?: string;
+    response_headers?: string;
+    status_code?: number;
+    reasoning_content?: string | null;
+    input_tokens?: number;
+    cached_tokens?: number;
+    output_tokens?: number;
+    reasoning_tokens?: number;
+    total_tokens?: number;
+    latency_ms?: number;
+    time_to_first_token_ms?: number;
+    finish_reason?: string;
+    error?: string;
+    error_type?: string;
+    cost_input?: number;
+    cost_output?: number;
+    cost_total?: number;
+    message_history_length?: number;
+    tools_available?: number;
+    prompt_name?: string;
+    tools_called?: string;
+    queued_tools?: string;
+    actual_provider?: string | null;
+    parent_log_id?: string | null;
+    tools_schema?: string | null;
+    message_history?: string | null;
+    system_prompt?: string | null;
+    is_complete?: boolean;
+    errors?: string | null;
+    retry_of_log_id?: string | null;
+    created_at: number;
+}
+/**
+ * Base environment interface for StandardAgents.
+ * Extends ThreadEnv with optional provider API keys.
+ *
+ * User's Env interface should extend this or include these bindings.
+ */
+interface Env extends ThreadEnv {
+    OPENAI_API_KEY?: string;
+    ANTHROPIC_API_KEY?: string;
+    OPENROUTER_API_KEY?: string;
+    GOOGLE_API_KEY?: string;
+    UI_DEV_SERVER?: string;
+    ASSETS?: {
+        fetch(request: Request | string): Promise<Response>;
+    };
+    GITHUB_TOKEN?: string;
+    GITHUB_REPO?: string;
+    GITHUB_BRANCH?: string;
+    SUPER_ADMIN_PASSWORD?: string;
+    ENCRYPTION_KEY?: string;
+    [key: string]: unknown;
+}
+/**
+ * Storage backend types for files
+ */
+type StorageBackend = "local" | "url" | "s3" | "r2";
+/**
+ * File record stored in the files table
+ */
+interface FileRecord {
+    path: string;
+    name: string;
+    mimeType: string;
+    storage: StorageBackend;
+    location?: string | null;
+    size: number;
+    metadata?: Record<string, unknown> | null;
+    isDirectory: boolean;
+    createdAt: number;
+    width?: number | null;
+    height?: number | null;
+    isChunked?: boolean;
+    chunkCount?: number;
+}
+/**
+ * Image-specific metadata stored in FileRecord.metadata
+ */
+interface ImageMetadata {
+    width: number;
+    height: number;
+}
+/**
+ * Attachment reference stored in messages.attachments (JSON array)
+ */
+interface AttachmentRef {
+    id: string;
+    type: "file";
+    path: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    width?: number;
+    height?: number;
+    description?: string;
+}
+/**
+ * Grep search result
+ */
+interface GrepResult {
+    path: string;
+    name: string;
+    matches: string[];
+    lineNumbers?: number[];
+}
+/**
+ * File stats for storage tracking
+ */
+interface FileStats {
+    totalSize: number;
+    fileCount: number;
+}
+
+/**
+ * Router and endpoint definition module for AgentBuilder.
+ *
+ * This module re-exports endpoint types from @standardagents/spec and provides
+ * the runtime router implementation for handling HTTP requests.
+ *
+ * @module
+ */
+
+/**
+ * Durable Object namespace interface.
+ * This is Cloudflare-specific and used by the builder runtime.
+ */
+interface DurableObjectNamespace<T = unknown> {
+    idFromName(name: string): DurableObjectId;
+    idFromString(id: string): DurableObjectId;
+    newUniqueId(): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub<T>;
+}
+/**
+ * Durable Object ID interface.
+ */
+interface DurableObjectId {
+    toString(): string;
+    equals(other: DurableObjectId): boolean;
+}
+/**
+ * Durable Object stub interface.
+ * The generic type T represents the RPC methods available on the stub.
+ */
+type DurableObjectStub<T = unknown> = {
+    id: DurableObjectId;
+    name?: string;
+    fetch(request: Request | string, requestInitr?: RequestInit): Promise<Response>;
+} & T;
+/**
+ * Log entry from DurableThread.getLogs()
+ */
+interface LogEntry {
+    id: string;
+    message_id: string;
+    provider: string;
+    model: string;
+    model_name: string | null;
+    prompt_name: string | null;
+    tools_called: string | null;
+    parent_log_id: string | null;
+    retry_of_log_id: string | null;
+    error: string | null;
+    cost_total: number | null;
+    is_complete: number;
+    created_at: number;
+    request_body: string | null;
+}
+/**
+ * Response from getThreadMeta()
+ */
+interface ThreadMetaResponse {
+    thread: ThreadRegistryEntry;
+    agent: AgentDefinition | null;
+    stats: {
+        messageCount: number;
+        logCount: number;
+        lastActivity: number | null;
+    };
+}
+/**
+ * Log details returned by getLogDetails
+ */
+interface LogDetails {
+    id: string;
+    message_id: string;
+    provider: string;
+    actual_provider: string | null;
+    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;
+    provider_tools: string | null;
+    parent_log_id: string | null;
+    tools_schema: string | null;
+    system_prompt: string | null;
+    errors: string | null;
+    retry_of_log_id: string | null;
+    tool_results: string | null;
+    is_complete: number;
+    created_at: number;
+}
+/**
+ * RPC methods exposed by DurableThread for external callers.
+ */
+interface DurableThreadRpc {
+    stop(): Promise<Response>;
+    getMessages(limit?: number, offset?: number, order?: "ASC" | "DESC", includeSilent?: boolean, maxDepth?: number): Promise<{
+        messages: unknown[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    deleteMessage(messageId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    updateMessageContent(messageId: string, content: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getLogs(limit?: number, offset?: number, order?: "ASC" | "DESC"): Promise<{
+        logs: LogEntry[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    getLogDetails(logId: string): Promise<LogDetails | null>;
+    getThreadMeta(threadId: string): Promise<ThreadMetaResponse | null>;
+    deleteThread(): Promise<void>;
+    readFile(path: string): Promise<{
+        success: boolean;
+        data?: string;
+        error?: string;
+    }>;
+}
+/**
+ * Thread registry entry from DurableAgentBuilder.
+ */
+interface ThreadRegistryEntry {
+    id: string;
+    agent_name: string;
+    user_id: string | null;
+    tags: string[] | null;
+    created_at: number;
+}
+/**
+ * RPC methods exposed by DurableAgentBuilder for external callers.
+ */
+interface DurableAgentBuilderRpc {
+    createThread(params: {
+        agent_name: string;
+        user_id?: string;
+        tags?: string[];
+        tenvs?: Record<string, unknown>;
+        properties?: Record<string, unknown>;
+    }): Promise<ThreadRegistryEntry>;
+    getThread(threadId: string): Promise<ThreadRegistryEntry | null>;
+    listThreads(params?: {
+        agent_name?: string;
+        user_id?: string;
+        search?: string;
+        startDate?: number;
+        endDate?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        threads: ThreadRegistryEntry[];
+        total: number;
+    }>;
+    deleteThread(threadId: string): Promise<void>;
+    getUserByUsername(username: string): Promise<unknown>;
+    createSession(session: {
+        user_id: string;
+        token_hash: string;
+        expires_at: number;
+    }): Promise<void>;
+    loadAgent(name: string): Promise<AgentDefinition>;
+}
+/**
+ * Minimum required environment bindings for thread endpoints.
+ * User's Env interface should extend this.
+ *
+ * This is Cloudflare-specific and used by the builder runtime.
+ */
+interface ThreadEnv {
+    AGENT_BUILDER_THREAD: DurableObjectNamespace<DurableThreadRpc>;
+    AGENT_BUILDER: DurableObjectNamespace<DurableAgentBuilderRpc>;
+    [key: string]: unknown;
+}
+/**
+ * Builder-specific controller context with typed env.
+ *
+ * This extends the spec's ControllerContext with proper typing for
+ * Cloudflare environment bindings.
+ */
+interface BuilderControllerContext<Env extends ThreadEnv = ThreadEnv> extends Omit<ControllerContext, 'env'> {
+    env: Env;
+    /** Namespaced registry for packed agent support */
+    registry?: NamespacedRegistry;
+}
+/**
+ * Builder-specific controller type with typed env.
+ */
+type BuilderController<Env extends ThreadEnv = ThreadEnv> = (context: BuilderControllerContext<Env>) => ReturnType<Controller>;
+/**
+ * Thread endpoint context with access to thread instance and metadata.
+ * @deprecated Use ThreadState instead
+ */
+interface ThreadEndpointContext {
+    req: Request;
+    thread: {
+        instance: ThreadInstance;
+        metadata: ThreadMetadata;
+    };
+}
+/**
+ * Handler function for builder thread endpoints.
+ *
+ * Receives the request and a ThreadState object per the Standard Agents spec.
+ * The ThreadState provides access to thread identity, messages, logs,
+ * resource loading, tool invocation, and more.
+ *
+ * Note: `state.execution` is always null in endpoints since the thread
+ * is not actively executing.
+ */
+type BuilderThreadEndpointHandler = ThreadEndpointHandler;
+
+/**
+ * Define a controller with typed Cloudflare environment bindings.
+ *
+ * This is the builder's version of defineController that provides
+ * proper typing for AGENT_BUILDER_THREAD and other CF bindings.
+ *
+ * @example
+ * ```typescript
+ * import { defineController } from '../router/index.js';
+ *
+ * export default defineController(async ({ req, env }) => {
+ *   const stub = env.AGENT_BUILDER.get(env.AGENT_BUILDER.idFromName('singleton'));
+ *   // ...
+ * });
+ * ```
+ */
+declare function defineController<Env extends ThreadEnv = ThreadEnv>(controller: BuilderController<Env>): BuilderController<Env>;
+/**
+ * Runtime implementation for defineThreadEndpoint.
+ *
+ * This wraps the spec's defineThreadEndpoint to provide the actual
+ * thread lookup and ThreadState creation at runtime.
+ *
+ * @param handler - Function that receives the request and ThreadState
+ * @returns A Controller that can be used with the router
+ *
+ * @example
+ * // agentbuilder/api/threads/[id]/status.get.ts
+ * import { defineThreadEndpoint } from '@standardagents/spec';
+ *
+ * export default defineThreadEndpoint(async (req, state) => {
+ *   const { messages } = await state.getMessages({ limit: 1 });
+ *   return Response.json({ status: "ok", messageCount: messages.length });
+ * });
+ */
+declare function createThreadEndpointHandler<Env extends ThreadEnv = ThreadEnv>(handler: ThreadEndpointHandler): BuilderController<Env>;
+
+export { type AttachmentRef as A, type BuilderController as B, type Env as E, type FileRecord as F, type GrepResult as G, type ImageMetadata as I, type LLMResponse as L, type Message as M, type RequestContext as R, type StorageBackend as S, type ThreadEnv as T, type ThreadMetadata as a, type FlowState as b, type FileStats as c, type MessageContent as d, defineController as e, createThreadEndpointHandler as f, type BuilderControllerContext as g, type ThreadEndpointContext as h, type BuilderThreadEndpointHandler as i, type Agent as j, type ThreadInstance as k, type ToolCall as l, type ToolResult as m, type FlowResult as n, type TelemetryEvent as o, type TextContentPart as p, type ImageContentPart as q, type MultimodalContent as r };