@jrkropp/codex-js 0.1.4 → 0.3.0

package/dist/internal/codex/core/src/stream-parser.d.ts

@@ -0,0 +1,36 @@
+export type StreamTextChunk<TExtracted> = {
+    visible_text: string;
+    extracted: TExtracted[];
+};
+export type ProposedPlanSegment = {
+    type: "Normal";
+    text: string;
+} | {
+    type: "ProposedPlanStart";
+} | {
+    type: "ProposedPlanDelta";
+    text: string;
+} | {
+    type: "ProposedPlanEnd";
+};
+export type AssistantTextChunk = {
+    visible_text: string;
+    citations: string[];
+    plan_segments: ProposedPlanSegment[];
+};
+export declare class ProposedPlanParser {
+    private readonly parser;
+    push_str(chunk: string): StreamTextChunk<ProposedPlanSegment>;
+    finish(): StreamTextChunk<ProposedPlanSegment>;
+}
+export declare function stripProposedPlanBlocks(text: string): string;
+export declare function extractProposedPlanText(text: string): string | null;
+export declare class AssistantTextStreamParser {
+    private readonly planMode;
+    private readonly citations;
+    private readonly plan;
+    constructor(planMode: boolean);
+    push_str(chunk: string): AssistantTextChunk;
+    finish(): AssistantTextChunk;
+    private parseVisibleText;
+}

package/dist/internal/codex/core/src/stream_events_utils.d.ts

@@ -0,0 +1,43 @@
+import type { ResponseItem } from "./models.js";
+import type { Session } from "./session/session.js";
+import type { TurnContext } from "./session/turn-context.js";
+import type { ToolCallRuntime } from "./tools/parallel.js";
+export declare function record_completed_response_item(session: Session, turnContext: TurnContext, item: ResponseItem): Promise<void>;
+export type InFlightFuture = Promise<ResponseItem>;
+export type OutputItemResult = {
+    last_agent_message: string | null;
+    needs_follow_up: boolean;
+    tool_future: InFlightFuture | null;
+    streamed_item_id?: string | null;
+};
+export type HandleOutputCtx = {
+    session: Session;
+    turn_context: TurnContext;
+    tool_runtime: ToolCallRuntime;
+    plan_mode_stream: PlanModeStreamState | null;
+    streamed_item_id: string | null;
+    signal?: AbortSignal;
+};
+export declare function handle_output_item_done(ctx: HandleOutputCtx, item: ResponseItem): Promise<OutputItemResult>;
+export declare function handle_non_tool_response_item(ctx: HandleOutputCtx, item: ResponseItem): Promise<OutputItemResult>;
+export declare function last_assistant_message_from_item(item: ResponseItem, planMode: boolean): string | null;
+export declare class PlanModeStreamState {
+    private readonly params;
+    private readonly itemId;
+    private readonly parser;
+    private emittedPlanText;
+    private planItemStarted;
+    constructor(params: {
+        session: Session;
+        turn: TurnContext;
+    });
+    pushDelta(delta: string): Promise<string>;
+    completeFromFinalText(text: string): Promise<{
+        assistantText: string | null;
+        planText: string | null;
+    }>;
+    private emitPlanSegments;
+    private emitRemainingPlanDelta;
+    private emitPlanDelta;
+    private startPlanItem;
+}

package/dist/internal/codex/core/src/tasks/compact.d.ts

@@ -0,0 +1,26 @@
+import type { RolloutItem, Submission } from "../protocol.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { TaskKind, type SessionTask, type SessionTaskResult, type SessionTaskRunInput } from "./mod.js";
+export type CompactTaskRunner = (input: {
+    session: Session;
+    turn: TurnContext;
+    history: RolloutItem[];
+    submission: Submission;
+    signal?: AbortSignal;
+}) => Promise<SessionTaskResult>;
+export type CompactTaskParams = {
+    history: RolloutItem[];
+    submission: Submission;
+    run_compact_task: CompactTaskRunner;
+};
+export declare class CompactTask implements SessionTask {
+    private readonly history;
+    private readonly submission;
+    private readonly run_compact_task;
+    constructor(params: CompactTaskParams);
+    kind(): TaskKind;
+    span_name(): string;
+    records_turn_token_usage_on_span(): boolean;
+    run(input: SessionTaskRunInput): Promise<SessionTaskResult>;
+}

package/dist/internal/codex/core/src/tasks/mod.d.ts

@@ -0,0 +1,43 @@
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import type { UserInput } from "../protocol.js";
+export declare const TaskKind: {
+    readonly Regular: "Regular";
+    readonly Compact: "Compact";
+    readonly Review: "Review";
+};
+export type TaskKind = (typeof TaskKind)[keyof typeof TaskKind];
+export type SessionTaskResult = {
+    last_agent_message: string | null;
+    steps?: number;
+    message?: string;
+};
+export declare class SessionTaskContext {
+    private readonly session;
+    constructor(session: Session);
+    clone_session(): Session;
+}
+export type SessionTaskRunInput = {
+    session: SessionTaskContext;
+    ctx: TurnContext;
+    input: UserInput[];
+    signal?: AbortSignal;
+};
+export interface SessionTask {
+    kind(): TaskKind;
+    span_name(): string;
+    records_turn_token_usage_on_span(): boolean;
+    run(input: SessionTaskRunInput): Promise<SessionTaskResult>;
+    abort?(input: {
+        session: SessionTaskContext;
+        ctx: TurnContext;
+    }): Promise<void>;
+}
+export type RunningTask = {
+    sub_id: string;
+    kind: TaskKind;
+    turn_context: TurnContext;
+    task?: SessionTask;
+    abort_controller?: AbortController;
+    records_turn_token_usage_on_span?: boolean;
+};

package/dist/internal/codex/core/src/tasks/regular.d.ts

@@ -0,0 +1,27 @@
+import type { RolloutItem, Submission } from "../protocol.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { TaskKind, type SessionTask, type SessionTaskResult, type SessionTaskRunInput } from "./mod.js";
+export type RegularTaskRunner = (input: {
+    session: Session;
+    turn: TurnContext;
+    history: RolloutItem[];
+    submission: Submission;
+    signal?: AbortSignal;
+}) => Promise<SessionTaskResult>;
+export type RegularTaskParams = {
+    history: RolloutItem[];
+    submission: Submission;
+    run_turn: RegularTaskRunner;
+};
+export declare class RegularTask implements SessionTask {
+    private readonly history;
+    private readonly submission;
+    private readonly run_turn;
+    constructor(params: RegularTaskParams);
+    static new(params: RegularTaskParams): RegularTask;
+    kind(): TaskKind;
+    span_name(): string;
+    records_turn_token_usage_on_span(): boolean;
+    run(input: SessionTaskRunInput): Promise<SessionTaskResult>;
+}

package/dist/internal/codex/core/src/templates.d.ts

@@ -0,0 +1,12 @@
+export declare const CORE_TEMPLATES: {
+    readonly "compact/prompt.md": "Your task is to create a concise summary of the conversation so far.\n\nPreserve user intent, important decisions, constraints, current task state, and any unresolved requests.\nDo not add new recommendations or solve the task.";
+    readonly "compact/summary_prefix.md": "Conversation summary:";
+    readonly "goals/budget_limit.md": "The active thread goal has reached its token budget.\n\n<untrusted_objective>\n{{objective}}\n</untrusted_objective>\n\nGoal status is now budgetLimited. Do not start substantive new work on the goal. Wrap up soon with concise progress, remaining work, and the next useful step. Do not call update_goal unless the objective is actually complete.\n\nTime spent: {{time_used_seconds}}s\nTokens used: {{tokens_used}}\nToken budget: {{token_budget}}\nRemaining budget: {{remaining_token_budget}}";
+    readonly "goals/continuation.md": "The active thread goal is still in progress. Continue working toward the objective while respecting the remaining budget.";
+    readonly "model_instructions/default_instructions_template.md": "";
+    readonly "personalities/default.md": "";
+    readonly "search_tool/tool_search.md": "Search available deferred tools and return the best matching tool definitions.";
+};
+export type CoreTemplatePath = keyof typeof CORE_TEMPLATES;
+export declare function loadCoreTemplate(path: CoreTemplatePath): string;
+export declare function renderCoreTemplate(path: CoreTemplatePath, variables: Record<string, string | number | null | undefined>): string;

package/dist/{thread-history-builder-zW0zeqcS.d.ts → internal/codex/core/src/thread-history-builder.d.ts}

@@ -1,13 +1,13 @@
-import { t as TurnItem, j as RolloutItem, E as EventMsg, A as ResponseItem } from './protocol-mpBcYHrm.js';
-
-type TurnStatus = "completed" | "interrupted" | "failed" | "in_progress";
-type TurnItemsView = "not_loaded" | "summary" | "full";
-type TurnError = {
+import type { TurnItem } from "./items.js";
+import type { EventMsg, ResponseItem, RolloutItem } from "./protocol.js";
+export type TurnStatus = "completed" | "interrupted" | "failed" | "in_progress";
+export type TurnItemsView = "not_loaded" | "summary" | "full";
+export type TurnError = {
     message: string;
     codex_error_info?: unknown | null;
     additional_details?: string | null;
 };
-type Turn = {
+export type Turn = {
     id: string;
     items: TurnItem[];
     items_view: TurnItemsView;
@@ -17,10 +17,10 @@ type Turn = {
     completed_at: number | null;
     duration_ms: number | null;
 };
-type PendingTurn = Turn & {
+export type PendingTurn = Turn & {
     opened_explicitly: boolean;
 };
-declare class ThreadHistoryBuilder {
+export declare class ThreadHistoryBuilder {
     private turns;
     private next_item_index;
     static fromTurns(turns: readonly Turn[]): ThreadHistoryBuilder;
@@ -48,11 +48,9 @@ declare class ThreadHistoryBuilder {
     private turn_by_id;
     private find_item;
 }
-declare function buildTurnsFromRolloutItems(items: readonly RolloutItem[]): Turn[];
-declare function applyEventToThreadHistoryBuilder(builder: ThreadHistoryBuilder, event: EventMsg, eventId?: string): ThreadHistoryBuilder;
-declare function flattenTurnsToTurnItems(turns: readonly Turn[]): TurnItem[];
-declare function applyEventToTurns(turns: readonly Turn[], event: EventMsg, eventId?: string): Turn[];
-declare function applyResponseItemToTurns(turns: readonly Turn[], item: ResponseItem, id: string): Turn[];
-declare function appendCompactionTurnToTurns(turns: readonly Turn[], id: string): Turn[];
-
-export { type PendingTurn as P, ThreadHistoryBuilder as T, type Turn as a, type TurnError as b, type TurnItemsView as c, type TurnStatus as d, appendCompactionTurnToTurns as e, applyEventToThreadHistoryBuilder as f, applyEventToTurns as g, applyResponseItemToTurns as h, buildTurnsFromRolloutItems as i, flattenTurnsToTurnItems as j };
+export declare function buildTurnsFromRolloutItems(items: readonly RolloutItem[]): Turn[];
+export declare function applyEventToThreadHistoryBuilder(builder: ThreadHistoryBuilder, event: EventMsg, eventId?: string): ThreadHistoryBuilder;
+export declare function flattenTurnsToTurnItems(turns: readonly Turn[]): TurnItem[];
+export declare function applyEventToTurns(turns: readonly Turn[], event: EventMsg, eventId?: string): Turn[];
+export declare function applyResponseItemToTurns(turns: readonly Turn[], item: ResponseItem, id: string): Turn[];
+export declare function appendCompactionTurnToTurns(turns: readonly Turn[], id: string): Turn[];

package/dist/internal/codex/core/src/thread-store/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./live-thread.js";
+export * from "./store.js";
+export * from "./types.js";

package/dist/{live-thread-BMvlflzM.d.ts → internal/codex/core/src/thread-store/live-thread.d.ts}

@@ -1,8 +1,9 @@
-import { l as ThreadId, j as RolloutItem, m as ThreadMemoryMode } from './protocol-mpBcYHrm.js';
-import { C as CreateThreadParams, d as ResumeThreadParams, f as StoredThreadHistory, e as StoredThread, g as ThreadMetadataPatch } from './types-BTeabLYr.js';
-import { T as ThreadStore } from './store-AGRxhgQ3.js';
-
-declare class LiveThread {
+import type { ThreadId } from "../ids.js";
+import type { ThreadMemoryMode } from "../memory.js";
+import type { RolloutItem } from "../protocol.js";
+import type { CreateThreadParams, ResumeThreadParams, StoredThread, StoredThreadHistory, ThreadMetadataPatch } from "./types.js";
+import type { ThreadStore } from "./store.js";
+export declare class LiveThread {
     readonly threadId: ThreadId;
     private readonly threadStore;
     private constructor();
@@ -19,12 +20,10 @@ declare class LiveThread {
     updateMetadata(patch: ThreadMetadataPatch, includeArchived: boolean): Promise<StoredThread>;
     localRolloutPath(): Promise<string | null>;
 }
-declare class LiveThreadInitGuard {
+export declare class LiveThreadInitGuard {
     private liveThread;
     constructor(liveThread?: LiveThread | null);
     asRef(): LiveThread | null;
     commit(): void;
     discard(): Promise<void>;
 }
-
-export { LiveThread as L, LiveThreadInitGuard as a };

package/dist/{store-AGRxhgQ3.d.ts → internal/codex/core/src/thread-store/store.d.ts}

@@ -1,7 +1,6 @@
-import { l as ThreadId } from './protocol-mpBcYHrm.js';
-import { C as CreateThreadParams, d as ResumeThreadParams, A as AppendThreadItemsParams, b as LoadThreadHistoryParams, f as StoredThreadHistory, c as ReadThreadParams, e as StoredThread, R as ReadThreadByRolloutPathParams, L as ListThreadsParams, h as ThreadPage, U as UpdateThreadMetadataParams, a as ArchiveThreadParams } from './types-BTeabLYr.js';
-
-interface ThreadStore {
+import type { ThreadId } from "../ids.js";
+import type { AppendThreadItemsParams, ArchiveThreadParams, CreateThreadParams, ListThreadsParams, LoadThreadHistoryParams, ReadThreadByRolloutPathParams, ReadThreadParams, ResumeThreadParams, StoredThread, StoredThreadHistory, ThreadPage, UpdateThreadMetadataParams } from "./types.js";
+export interface ThreadStore {
     createThread(params: CreateThreadParams): Promise<void>;
     resumeThread(params: ResumeThreadParams): Promise<void>;
     appendItems(params: AppendThreadItemsParams): Promise<void>;
@@ -17,5 +16,3 @@ interface ThreadStore {
     archiveThread(params: ArchiveThreadParams): Promise<void>;
     unarchiveThread(params: ArchiveThreadParams): Promise<StoredThread>;
 }
-
-export type { ThreadStore as T };

package/dist/{types-BTeabLYr.d.ts → internal/codex/core/src/thread-store/types.d.ts}

@@ -1,27 +1,28 @@
-import { l as ThreadId, j as RolloutItem, B as BaseInstructions, D as DynamicToolSpec, m as ThreadMemoryMode } from './protocol-mpBcYHrm.js';
-
-declare const ThreadEventPersistenceMode: {
+import type { BaseInstructions, DynamicToolSpec, RolloutItem } from "../protocol.js";
+import type { ThreadId } from "../ids.js";
+import type { ThreadMemoryMode } from "../memory.js";
+export declare const ThreadEventPersistenceMode: {
     readonly Limited: "Limited";
     readonly Extended: "Extended";
 };
-type ThreadEventPersistenceMode = (typeof ThreadEventPersistenceMode)[keyof typeof ThreadEventPersistenceMode];
-declare const ThreadSortKey: {
+export type ThreadEventPersistenceMode = (typeof ThreadEventPersistenceMode)[keyof typeof ThreadEventPersistenceMode];
+export declare const ThreadSortKey: {
     readonly CreatedAt: "CreatedAt";
     readonly UpdatedAt: "UpdatedAt";
 };
-type ThreadSortKey = (typeof ThreadSortKey)[keyof typeof ThreadSortKey];
-declare const SortDirection: {
+export type ThreadSortKey = (typeof ThreadSortKey)[keyof typeof ThreadSortKey];
+export declare const SortDirection: {
     readonly Asc: "Asc";
     readonly Desc: "Desc";
 };
-type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
-type ThreadPersistenceMetadata = {
+export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+export type ThreadPersistenceMetadata = {
     cwd?: string | null;
     model_provider: string;
     memory_mode: ThreadMemoryMode;
     [key: string]: unknown;
 };
-type CreateThreadParams = {
+export type CreateThreadParams = {
     thread_id: ThreadId;
     forked_from_id?: ThreadId | null;
     source: string;
@@ -31,7 +32,7 @@ type CreateThreadParams = {
     metadata: ThreadPersistenceMetadata;
     event_persistence_mode: ThreadEventPersistenceMode;
 };
-type ResumeThreadParams = {
+export type ResumeThreadParams = {
     thread_id: ThreadId;
     rollout_path?: string | null;
     history?: RolloutItem[] | null;
@@ -39,29 +40,29 @@ type ResumeThreadParams = {
     metadata: ThreadPersistenceMetadata;
     event_persistence_mode: ThreadEventPersistenceMode;
 };
-type AppendThreadItemsParams = {
+export type AppendThreadItemsParams = {
     thread_id: ThreadId;
     items: RolloutItem[];
 };
-type LoadThreadHistoryParams = {
+export type LoadThreadHistoryParams = {
     thread_id: ThreadId;
     include_archived: boolean;
 };
-type StoredThreadHistory = {
+export type StoredThreadHistory = {
     thread_id: ThreadId;
     items: RolloutItem[];
 };
-type ReadThreadParams = {
+export type ReadThreadParams = {
     thread_id: ThreadId;
     include_archived: boolean;
     include_history: boolean;
 };
-type ReadThreadByRolloutPathParams = {
+export type ReadThreadByRolloutPathParams = {
     rollout_path: string;
     include_archived: boolean;
     include_history: boolean;
 };
-type ListThreadsParams = {
+export type ListThreadsParams = {
     page_size: number;
     cursor?: string | null;
     sort_key: ThreadSortKey;
@@ -73,11 +74,11 @@ type ListThreadsParams = {
     search_term?: string | null;
     use_state_db_only: boolean;
 };
-type ThreadPage = {
+export type ThreadPage = {
     items: StoredThread[];
     next_cursor?: string | null;
 };
-type StoredThread = {
+export type StoredThread = {
     thread_id: ThreadId;
     rollout_path?: string | null;
     forked_from_id?: ThreadId | null;
@@ -103,24 +104,22 @@ type StoredThread = {
     first_user_message?: string | null;
     history?: StoredThreadHistory | null;
 };
-type OptionalStringPatch = string | null | undefined;
-type GitInfoPatch = {
+export type OptionalStringPatch = string | null | undefined;
+export type GitInfoPatch = {
     sha?: OptionalStringPatch;
     branch?: OptionalStringPatch;
     origin_url?: OptionalStringPatch;
 };
-type ThreadMetadataPatch = {
+export type ThreadMetadataPatch = {
     name?: string;
     memory_mode?: ThreadMemoryMode;
     git_info?: GitInfoPatch;
 };
-type UpdateThreadMetadataParams = {
+export type UpdateThreadMetadataParams = {
     thread_id: ThreadId;
     patch: ThreadMetadataPatch;
     include_archived: boolean;
 };
-type ArchiveThreadParams = {
+export type ArchiveThreadParams = {
     thread_id: ThreadId;
 };
-
-export { type AppendThreadItemsParams as A, type CreateThreadParams as C, type GitInfoPatch as G, type ListThreadsParams as L, type OptionalStringPatch as O, type ReadThreadByRolloutPathParams as R, SortDirection as S, ThreadEventPersistenceMode as T, type UpdateThreadMetadataParams as U, type ArchiveThreadParams as a, type LoadThreadHistoryParams as b, type ReadThreadParams as c, type ResumeThreadParams as d, type StoredThread as e, type StoredThreadHistory as f, type ThreadMetadataPatch as g, type ThreadPage as h, type ThreadPersistenceMetadata as i, ThreadSortKey as j };

package/dist/internal/codex/core/src/tools/code_mode/execute_handler.d.ts

@@ -0,0 +1,7 @@
+import { FunctionToolOutput, ToolKind, type ToolHandler } from "../context.js";
+import { ToolName } from "../tool_name.js";
+export declare class CodeModeExecuteHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(): Promise<FunctionToolOutput>;
+}

package/dist/internal/codex/core/src/tools/code_mode/execute_spec.d.ts

@@ -0,0 +1,13 @@
+export declare const CODE_MODE_EXECUTE_TOOL_NAME = "code_mode_execute";
+export declare function create_code_mode_execute_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};

package/dist/internal/codex/core/src/tools/code_mode/mod.d.ts

@@ -0,0 +1,5 @@
+export * from "./execute_handler.js";
+export * from "./execute_spec.js";
+export * from "./response_adapter.js";
+export * from "./wait_handler.js";
+export * from "./wait_spec.js";

package/dist/internal/codex/core/src/tools/code_mode/response_adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ResponseInputItem } from "../../protocol.js";
+export declare function code_mode_response_item(item: ResponseInputItem): ResponseInputItem;

package/dist/internal/codex/core/src/tools/code_mode/wait_handler.d.ts

@@ -0,0 +1,7 @@
+import { FunctionToolOutput, ToolKind, type ToolHandler } from "../context.js";
+import { ToolName } from "../tool_name.js";
+export declare class CodeModeWaitHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(): Promise<FunctionToolOutput>;
+}

package/dist/internal/codex/core/src/tools/code_mode/wait_spec.d.ts

@@ -0,0 +1,13 @@
+export declare const CODE_MODE_WAIT_TOOL_NAME = "code_mode_wait";
+export declare function create_code_mode_wait_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};

package/dist/internal/codex/core/src/tools/context.d.ts

@@ -0,0 +1,155 @@
+import type { FunctionCallOutputContentItem, ResponseInputItem, TruncationPolicy } from "../protocol.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { type ToolNameInput } from "./tool_name.js";
+export type { ConfiguredToolSpec, ToolSpec } from "./tool_spec.js";
+export declare const ToolKind: {
+    readonly Function: "Function";
+    readonly Mcp: "Mcp";
+};
+export type ToolKind = (typeof ToolKind)[keyof typeof ToolKind];
+export type SearchToolCallParams = {
+    query?: string;
+    limit?: number;
+    [key: string]: unknown;
+};
+export type ShellToolCallParams = {
+    command?: string[];
+    workdir?: string | null;
+    timeout_ms?: number | null;
+    sandbox_permissions?: unknown;
+    prefix_rule?: string[] | null;
+    justification?: string | null;
+    [key: string]: unknown;
+};
+export type ToolPayload = {
+    type: "function";
+    arguments: string;
+} | {
+    type: "tool_search";
+    arguments: SearchToolCallParams;
+} | {
+    type: "custom";
+    input: string;
+} | {
+    type: "local_shell";
+    params: ShellToolCallParams;
+} | {
+    type: "mcp";
+    server: string;
+    tool: string;
+    raw_arguments: string;
+};
+export declare function logPayload(payload: ToolPayload): string;
+export type ToolCallSource = {
+    type: "direct";
+} | {
+    type: "code_mode";
+    cell_id: string;
+    runtime_tool_call_id: string;
+};
+export type ToolInvocation = {
+    session: Session;
+    turn: TurnContext;
+    cancellation_token: CancellationToken;
+    call_id: string;
+    tool_name: ToolNameInput;
+    source: ToolCallSource;
+    payload: ToolPayload;
+};
+export declare class CancellationToken {
+    readonly signal?: AbortSignal | undefined;
+    constructor(signal?: AbortSignal | undefined);
+    is_cancelled(): boolean;
+    cancelled(): Promise<void>;
+}
+export type PreToolUsePayload = {
+    tool_name: string;
+    tool_input: unknown;
+};
+export type PostToolUsePayload = {
+    tool_name: string;
+    tool_use_id: string;
+    tool_input: unknown;
+    tool_response: unknown;
+};
+export interface ToolArgumentDiffConsumer {
+    consumeDiff(turn: TurnContext, callId: string, diff: string): unknown | null;
+    finish?(): unknown | null;
+}
+export interface ToolOutput {
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(callId: string, payload: ToolPayload): unknown | null;
+    codeModeResult(payload: ToolPayload): unknown;
+}
+export declare class FunctionToolOutput implements ToolOutput {
+    readonly body: FunctionCallOutputContentItem[];
+    readonly success?: boolean | null | undefined;
+    readonly post_tool_use_response: unknown | null;
+    constructor(body: FunctionCallOutputContentItem[], success?: boolean | null | undefined, post_tool_use_response?: unknown | null);
+    static fromText(text: string, success?: boolean | null): FunctionToolOutput;
+    static fromContent(content: FunctionCallOutputContentItem[], success?: boolean | null): FunctionToolOutput;
+    intoText(): string;
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+}
+export declare class McpToolOutput implements ToolOutput {
+    readonly result: unknown;
+    readonly tool_input: unknown;
+    readonly wall_time_ms: number;
+    readonly original_image_detail_supported: boolean;
+    readonly truncation_policy?: (TruncationPolicy | null) | undefined;
+    constructor(result: unknown, tool_input: unknown, wall_time_ms: number, original_image_detail_supported: boolean, truncation_policy?: (TruncationPolicy | null) | undefined);
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+    private response_payload;
+}
+export interface ToolHandler<TOutput extends ToolOutput = ToolOutput> {
+    toolName(): ToolNameInput;
+    kind(): ToolKind;
+    matchesKind?(payload: ToolPayload): boolean;
+    isMutating?(invocation: ToolInvocation): Promise<boolean>;
+    preToolUsePayload?(invocation: ToolInvocation): PreToolUsePayload | null;
+    postToolUsePayload?(invocation: ToolInvocation, result: TOutput): PostToolUsePayload | null;
+    createDiffConsumer?(): ToolArgumentDiffConsumer | null;
+    handle(invocation: ToolInvocation): Promise<TOutput>;
+}
+export declare function matchesToolKind(kind: ToolKind, payload: ToolPayload): boolean;
+export declare class AnyToolResult {
+    readonly call_id: string;
+    readonly payload: ToolPayload;
+    readonly result: ToolOutput;
+    readonly post_tool_use_payload: PostToolUsePayload | null;
+    constructor(call_id: string, payload: ToolPayload, result: ToolOutput, post_tool_use_payload: PostToolUsePayload | null);
+    intoResponse(): ResponseInputItem;
+    codeModeResult(): unknown;
+}
+export declare const FunctionCallErrorKind: {
+    readonly RespondToModel: "respond_to_model";
+    readonly Fatal: "fatal";
+};
+export type FunctionCallErrorKind = (typeof FunctionCallErrorKind)[keyof typeof FunctionCallErrorKind];
+export declare class FunctionCallError extends Error {
+    readonly kind: FunctionCallErrorKind;
+    private constructor();
+    static respondToModel(message: string): FunctionCallError;
+    static fatal(message: string): FunctionCallError;
+}
+export declare class ToolRegistry {
+    private readonly handlers;
+    private constructor();
+    static emptyForTest(): ToolRegistry;
+    static withHandlerForTest(handler: ToolHandler): ToolRegistry;
+    static fromHandlersForBuilder(handlers: Map<string, ToolHandler>): ToolRegistry;
+    hasHandler(name: ToolNameInput): boolean;
+    createDiffConsumer(name: ToolNameInput): ToolArgumentDiffConsumer | null;
+    dispatchAny(invocation: ToolInvocation): Promise<AnyToolResult>;
+}