@jrkropp/codex-js 0.1.4 → 0.3.0

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

@@ -0,0 +1,28 @@
+import { type RequestPermissionProfile, type RequestPermissionsResponse } from "../request_permissions.js";
+export declare const ToolApprovalRequirement: {
+    readonly Skip: "skip";
+    readonly NeedsApproval: "needs_approval";
+    readonly Forbidden: "forbidden";
+};
+export type ToolApprovalRequirement = {
+    type: typeof ToolApprovalRequirement.Skip;
+} | {
+    type: typeof ToolApprovalRequirement.NeedsApproval;
+    reason?: string | null;
+} | {
+    type: typeof ToolApprovalRequirement.Forbidden;
+    reason: string;
+};
+export declare class PermissionGrantStore {
+    private readonly grants;
+    private strict_auto_review;
+    record(response: RequestPermissionsResponse): void;
+    all(): RequestPermissionProfile[];
+    hasGrants(): boolean;
+    strictAutoReviewEnabled(): boolean;
+    clear(): void;
+}
+export declare class ToolOrchestrator {
+    static defaultApprovalRequirement(): ToolApprovalRequirement;
+}
+export declare function normalizeRequestPermissionsResponseForCwd(response: RequestPermissionsResponse, cwd: string): RequestPermissionsResponse;

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

@@ -0,0 +1,33 @@
+import type { ResponseInputItem } from "../protocol.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { AnyToolResult, FunctionCallError, type ToolPayload, type ToolOutput, type ToolCallSource } from "./context.js";
+import { type ToolCall, type ToolRouter } from "./router.js";
+import { ToolDispatchTrace } from "./tool_dispatch_trace.js";
+export type ToolCallRuntimeParams = {
+    router: ToolRouter;
+    session: Session;
+    turn: TurnContext;
+};
+export declare class AbortedToolOutput implements ToolOutput {
+    readonly message: string;
+    constructor(message: string);
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+}
+export declare class ToolCallRuntime {
+    private readonly params;
+    private readonly parallelExecution;
+    constructor(params: ToolCallRuntimeParams);
+    find_spec(toolName: Parameters<ToolRouter["find_spec"]>[0]): import("./tool_spec.js").ToolSpec | null;
+    create_diff_consumer(toolName: Parameters<ToolRouter["createDiffConsumer"]>[0]): import("./context.js").ToolArgumentDiffConsumer | null;
+    handle_tool_call(call: ToolCall, signal?: AbortSignal): Promise<ResponseInputItem>;
+    handle_tool_call_with_source(call: ToolCall, source?: ToolCallSource, signal?: AbortSignal, trace?: ToolDispatchTrace): Promise<AnyToolResult>;
+    static failureResponse(call: ToolCall, error: FunctionCallError): ResponseInputItem;
+    static abortedResponse(call: ToolCall, secs: number): AnyToolResult;
+    private raceAbort;
+    private static abortMessage;
+}

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

@@ -0,0 +1,27 @@
+export { FunctionCallError, FunctionCallErrorKind, matchesToolKind, ToolKind, ToolRegistry, type ConfiguredToolSpec, type PostToolUsePayload, type PreToolUsePayload, type ToolArgumentDiffConsumer, type ToolHandler, type ToolSpec, } from "./context.js";
+import { ToolRegistry, type ConfiguredToolSpec, type ToolHandler, type ToolSpec } from "./context.js";
+export * from "./responses_api.js";
+export * from "./spec.js";
+export * from "./tool_spec.js";
+export * from "./tool_search_entry.js";
+export * from "./handlers/apply_patch.js";
+export * from "./handlers/apply_patch_spec.js";
+export * from "./handlers/shell_spec.js";
+export * from "./handlers/unified_exec.js";
+export * from "./events.js";
+export * from "./sandboxing.js";
+export { ToolName, type ToolNameInput } from "./tool_name.js";
+export { build_tool_registry_plan } from "./spec_plan.js";
+export { create_image_generation_tool, create_web_search_tool, type WebSearchToolOptions, } from "./hosted_spec.js";
+export { ToolHandlerKind, defaultToolsConfig, type DefaultToolsConfigInput, type ToolHandlerSpec, type ToolRegistryPlan, type ToolRegistryPlanParams, type ToolsConfig, type WebSearchConfig, type WebSearchMode, type WebSearchToolType, } from "./spec_plan_types.js";
+export declare class ToolRegistryBuilder {
+    private readonly handlers;
+    private readonly specs;
+    pushSpec(spec: ToolSpec): void;
+    pushSpecWithParallelSupport(spec: ToolSpec, supportsParallelToolCalls: boolean): void;
+    registerHandler(handler: ToolHandler): void;
+    build(): {
+        specs: ConfiguredToolSpec[];
+        registry: ToolRegistry;
+    };
+}

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

@@ -0,0 +1,34 @@
+import type { DynamicToolSpec } from "../protocol/dynamic_tools.js";
+import type { JsonSchema } from "./tool_spec.js";
+export type FreeformTool = {
+    name: string;
+    description: string;
+    format: {
+        type: string;
+        syntax: string;
+        definition: string;
+    };
+};
+export type ResponsesApiTool = {
+    name: string;
+    description: string;
+    strict: boolean;
+    defer_loading?: boolean;
+    parameters: JsonSchema;
+};
+export type ResponsesApiFunctionTool = ResponsesApiTool & {
+    type: "function";
+};
+export type LoadableToolSpec = ResponsesApiFunctionTool | (ResponsesApiNamespace & {
+    type: "namespace";
+});
+export type ResponsesApiNamespace = {
+    name: string;
+    description: string;
+    tools: ResponsesApiNamespaceTool[];
+};
+export type ResponsesApiNamespaceTool = ResponsesApiFunctionTool;
+export declare function default_namespace_description(namespaceName: string): string;
+export declare function dynamic_tool_to_responses_api_tool(tool: DynamicToolSpec): ResponsesApiTool;
+export declare function dynamic_tool_to_loadable_tool_spec(tool: DynamicToolSpec): LoadableToolSpec;
+export declare function coalesce_loadable_tool_specs(specs: Iterable<LoadableToolSpec>): LoadableToolSpec[];

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

@@ -0,0 +1,50 @@
+import type { McpToolInfo } from "../mcp.js";
+import type { ProviderCapabilities } from "../model-provider.js";
+import type { DynamicToolSpec, ResponseItem } from "../protocol.js";
+import { type ConfiguredToolSpec, ToolRegistry, type ToolArgumentDiffConsumer, type ToolPayload, type ToolSpec } from "./context.js";
+import { type ToolsConfig } from "./spec_plan_types.js";
+import { ToolName, type ToolNameInput } from "./tool_name.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import type { ToolCallSource } from "./context.js";
+import type { DiscoverableTool } from "./tool_search_entry.js";
+export type ToolRouterParams = {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+    deferred_mcp_tools?: readonly McpToolInfo[];
+    unavailable_called_tools?: readonly ToolName[];
+    parallel_mcp_server_names?: ReadonlySet<string>;
+    discoverable_tools?: readonly DiscoverableTool[];
+    provider_capabilities?: Partial<ProviderCapabilities>;
+    tools_config?: Partial<ToolsConfig>;
+};
+export type ToolCall = {
+    call_id: string;
+    tool_name: ToolName;
+    payload: ToolPayload;
+};
+export declare class ToolRouter {
+    private readonly tool_registry;
+    private readonly configured_specs;
+    private readonly visible_specs;
+    private readonly parallel_tool_names;
+    private readonly parallel_mcp_server_names;
+    private constructor();
+    static from_config(params: ToolRouterParams): ToolRouter;
+    specs(): ToolSpec[];
+    configured_tools(): ConfiguredToolSpec[];
+    model_visible_specs(): ToolSpec[];
+    registry_for_test(): ToolRegistry;
+    registry(): ToolRegistry;
+    find_spec(toolName: ToolNameInput): ToolSpec | null;
+    createDiffConsumer(toolName: ToolNameInput): ToolArgumentDiffConsumer | null;
+    tool_supports_parallel(call: ToolCall): boolean;
+    static build_tool_call(session: Session, item: ResponseItem): Promise<ToolCall | null>;
+    dispatch_tool_call_with_code_mode_result(params: {
+        session: Session;
+        turn: TurnContext;
+        call: ToolCall;
+        source?: ToolCallSource;
+        signal?: AbortSignal;
+    }): Promise<import("./context.js").AnyToolResult>;
+}

package/dist/internal/codex/core/src/tools/runtimes/apply_patch.d.ts

@@ -0,0 +1,2 @@
+import { FunctionToolOutput } from "../context.js";
+export declare function run_apply_patch_runtime(): Promise<FunctionToolOutput>;

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

@@ -0,0 +1,4 @@
+export * from "./apply_patch.js";
+export * from "./shell.js";
+export * from "./unified_exec.js";
+export declare const TOOL_RUNTIME_UNAVAILABLE = "tool execution is unavailable in this Codex assistant runtime; a desktop/local executor is required.";

package/dist/internal/codex/core/src/tools/runtimes/shell.d.ts

@@ -0,0 +1,2 @@
+import { FunctionToolOutput } from "../context.js";
+export declare function run_shell_runtime(): Promise<FunctionToolOutput>;

package/dist/internal/codex/core/src/tools/runtimes/unified_exec.d.ts

@@ -0,0 +1,2 @@
+import { FunctionToolOutput } from "../context.js";
+export declare function run_unified_exec_runtime(): Promise<FunctionToolOutput>;

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

@@ -0,0 +1,36 @@
+import type { PermissionProfile } from "../protocol.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+export declare const ToolErrorKind: {
+    readonly Rejected: "rejected";
+    readonly Unavailable: "unavailable";
+    readonly Failed: "failed";
+};
+export type ToolErrorKind = (typeof ToolErrorKind)[keyof typeof ToolErrorKind];
+export declare class ToolError extends Error {
+    readonly kind: ToolErrorKind;
+    constructor(kind: ToolErrorKind, message: string);
+    static rejected(message: string): ToolError;
+    static unavailable(message: string): ToolError;
+    static failed(message: string): ToolError;
+}
+export type SandboxAttempt = {
+    sandbox: "none" | "read-only" | "workspace-write";
+    permissions?: PermissionProfile | null;
+};
+export type ToolCtx = {
+    session: Session;
+    turn: TurnContext;
+    call_id: string;
+    signal?: AbortSignal;
+};
+export interface Sandboxable {
+    sandbox_preference(): "auto" | "none";
+    escalate_on_failure?(): boolean;
+}
+export interface Approvable<TRequest> {
+    approval_keys(request: TRequest): unknown[];
+}
+export interface ToolRuntime<TRequest, TOutput> {
+    run(request: TRequest, attempt: SandboxAttempt, ctx: ToolCtx): Promise<TOutput>;
+}

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

@@ -0,0 +1,10 @@
+import { type McpToolInfo } from "../mcp.js";
+import type { DynamicToolSpec } from "../protocol.js";
+import { ToolRegistryBuilder } from "./registry.js";
+import { type ToolRegistryPlanParams, type ToolsConfig } from "./spec_plan_types.js";
+export type BuildSpecsWithDiscoverableToolsParams = ToolRegistryPlanParams & {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+};
+export declare function build_specs_with_discoverable_tools(config: ToolsConfig, params: BuildSpecsWithDiscoverableToolsParams): ToolRegistryBuilder;
+export { ToolRegistryBuilder };

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

@@ -0,0 +1,2 @@
+import type { ToolsConfig, ToolRegistryPlan, ToolRegistryPlanParams } from "./spec_plan_types.js";
+export declare function build_tool_registry_plan(config: ToolsConfig, params: ToolRegistryPlanParams): ToolRegistryPlan;

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

@@ -0,0 +1,93 @@
+import type { ModeKind } from "../config-types.js";
+import type { McpToolInfo } from "../mcp.js";
+import type { DynamicToolSpec } from "../protocol/dynamic_tools.js";
+import type { ConfiguredToolSpec } from "./context.js";
+import type { ToolName } from "./tool_name.js";
+import type { DiscoverableTool } from "./tool_search_entry.js";
+export declare const ToolHandlerKind: {
+    readonly DynamicTool: "DynamicTool";
+    readonly RequestPermissions: "RequestPermissions";
+    readonly RequestUserInput: "RequestUserInput";
+    readonly ToolSearch: "ToolSearch";
+    readonly UnavailableTool: "UnavailableTool";
+    readonly Mcp: "Mcp";
+    readonly ListMcpResources: "ListMcpResources";
+    readonly ListMcpResourceTemplates: "ListMcpResourceTemplates";
+    readonly ReadMcpResource: "ReadMcpResource";
+    readonly ExecCommand: "ExecCommand";
+    readonly WriteStdin: "WriteStdin";
+    readonly ApplyPatch: "ApplyPatch";
+    readonly Plan: "Plan";
+    readonly GetGoal: "GetGoal";
+    readonly CreateGoal: "CreateGoal";
+    readonly UpdateGoal: "UpdateGoal";
+    readonly SpawnAgent: "SpawnAgent";
+    readonly SendInput: "SendInput";
+    readonly WaitAgent: "WaitAgent";
+    readonly CloseAgent: "CloseAgent";
+    readonly ResumeAgent: "ResumeAgent";
+    readonly ListAgents: "ListAgents";
+    readonly SendMessage: "SendMessage";
+    readonly FollowupTask: "FollowupTask";
+};
+export type ToolHandlerKind = (typeof ToolHandlerKind)[keyof typeof ToolHandlerKind];
+export type ToolHandlerSpec = {
+    name: ToolName;
+    kind: ToolHandlerKind;
+};
+export type ToolRegistryPlan = {
+    specs: ConfiguredToolSpec[];
+    handlers: ToolHandlerSpec[];
+};
+export type ToolRegistryPlanParams = {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+    deferred_mcp_tools?: readonly McpToolInfo[];
+    discoverable_tools?: readonly DiscoverableTool[];
+    tool_namespaces?: readonly string[];
+    unavailable_called_tools?: readonly ToolName[];
+    parallel_mcp_tool_names?: readonly ToolName[];
+};
+export type WebSearchMode = "disabled" | "cached" | "live";
+export type WebSearchToolType = "text" | "text_and_image";
+export type WebSearchConfig = {
+    filters?: unknown;
+    user_location?: unknown;
+    search_context_size?: unknown;
+};
+export type ToolsConfig = {
+    namespace_tools: boolean;
+    request_permissions_tool_enabled: boolean;
+    request_user_input_available_modes: readonly ModeKind[];
+    search_tool: boolean;
+    web_search_mode: WebSearchMode | null;
+    web_search_tool_type: WebSearchToolType;
+    web_search_config?: WebSearchConfig | null;
+    image_gen_tool: boolean;
+    exec_command_tool_enabled: boolean;
+    write_stdin_tool_enabled: boolean;
+    apply_patch_tool_enabled: boolean;
+    thread_goal_tools_enabled: boolean;
+    mcp_tools_enabled: boolean;
+    multi_agent_tools_enabled: boolean;
+};
+export type DefaultToolsConfigInput = {
+    namespace_tools?: boolean;
+    image_generation?: boolean;
+    web_search?: boolean;
+    request_permissions_tool_enabled?: boolean;
+    request_user_input_available_modes?: readonly ModeKind[];
+    search_tool?: boolean;
+    web_search_mode?: WebSearchMode | null;
+    web_search_tool_type?: WebSearchToolType;
+    web_search_config?: WebSearchConfig | null;
+    image_gen_tool?: boolean;
+    exec_command_tool_enabled?: boolean;
+    write_stdin_tool_enabled?: boolean;
+    apply_patch_tool_enabled?: boolean;
+    thread_goal_tools_enabled?: boolean;
+    mcp_tools_enabled?: boolean;
+    multi_agent_tools_enabled?: boolean;
+};
+export declare function createToolRegistryPlan(): ToolRegistryPlan;
+export declare function defaultToolsConfig(input?: DefaultToolsConfigInput): ToolsConfig;

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

@@ -0,0 +1,12 @@
+import type { ToolCall } from "./router.js";
+export declare class ToolDispatchTrace {
+    readonly events: Array<{
+        type: "started" | "completed" | "failed";
+        call_id: string;
+        tool_name: string;
+        message?: string;
+    }>;
+    start(call: ToolCall): void;
+    record_completed(call: ToolCall): void;
+    record_failed(call: ToolCall, error: Error): void;
+}

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

@@ -0,0 +1,17 @@
+export type ToolNameInput = ToolName | string | {
+    namespace?: string | null;
+    name: string;
+};
+export declare class ToolName {
+    readonly namespace: string | null;
+    readonly name: string;
+    private constructor();
+    static plain(name: string): ToolName;
+    static namespaced(namespace: string, name: string): ToolName;
+    static new(namespace: string | null | undefined, name: string): ToolName;
+    static from(input: ToolNameInput): ToolName;
+    display(): string;
+    key(): string;
+    equals(other: ToolNameInput): boolean;
+    toJSON(): string;
+}

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

@@ -0,0 +1,35 @@
+import type { DynamicToolSpec } from "../protocol.js";
+import { type McpToolInfo } from "../mcp.js";
+import type { ToolsConfig } from "./spec_plan_types.js";
+import { type LoadableToolSpec } from "./responses_api.js";
+export declare const TOOL_SEARCH_TOOL_NAME = "tool_search";
+export declare const TOOL_SEARCH_DEFAULT_LIMIT = 8;
+export type ToolSearchSourceInfo = {
+    name: string;
+    description?: string | null;
+};
+export type DiscoverableTool = {
+    name: string;
+    title?: string | null;
+    description: string;
+    source: string;
+    input_schema?: unknown;
+    server_name?: string | null;
+    tool_name?: string | null;
+    mcp_app_resource_uri?: string | null;
+};
+export type ToolSearchEntry = {
+    limit_bucket?: string | null;
+    output: LoadableToolSpec;
+    search_text: string;
+};
+export declare function build_tool_search_entries(input: {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+}): ToolSearchEntry[];
+export declare function build_tool_search_entries_for_config(config: ToolsConfig, mcp_tools: readonly McpToolInfo[] | null | undefined, dynamic_tools: readonly DynamicToolSpec[]): ToolSearchEntry[];
+export declare function dynamic_tool_to_tool_search_entry(tool: DynamicToolSpec): ToolSearchEntry;
+export declare function mcp_tool_to_tool_search_entry(tool: McpToolInfo): ToolSearchEntry;
+export declare function tool_search_source_info_for_dynamic_tools(tools: readonly DynamicToolSpec[]): ToolSearchSourceInfo[];
+export declare function tool_search_source_info_for_mcp_tools(tools: readonly McpToolInfo[]): ToolSearchSourceInfo[];
+export declare function tool_search_outputs(entries: readonly ToolSearchEntry[]): LoadableToolSpec[];

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

@@ -0,0 +1,29 @@
+import type { FreeformTool, LoadableToolSpec } from "./responses_api.js";
+export type JsonSchema = unknown;
+export type ToolSpec = LoadableToolSpec | {
+    type: "tool_search";
+    execution: string;
+    description: string;
+    parameters: JsonSchema;
+} | {
+    type: "local_shell";
+} | {
+    type: "image_generation";
+    output_format: string;
+} | {
+    type: "web_search";
+    external_web_access?: boolean;
+    filters?: unknown;
+    user_location?: unknown;
+    search_context_size?: unknown;
+    search_content_types?: string[];
+} | (FreeformTool & {
+    type: "custom";
+});
+export type ConfiguredToolSpec = {
+    spec: ToolSpec;
+    supports_parallel_tool_calls: boolean;
+};
+export declare function toolSpecName(spec: ToolSpec): string;
+export declare function create_tools_json_for_responses_api(tools: readonly ToolSpec[]): ToolSpec[];
+export declare function assertValidResponsesToolSpecs(specs: readonly ToolSpec[]): asserts specs is ToolSpec[];

package/dist/{mod-DYVLSWO4.d.ts → internal/codex/thread-store/src/in_memory.d.ts}

@@ -1,8 +1,8 @@
-import { l as ThreadId, j as RolloutItem } from './protocol-mpBcYHrm.js';
-import { C as CreateThreadParams, e as StoredThread, d as ResumeThreadParams, A as AppendThreadItemsParams, b as LoadThreadHistoryParams, f as StoredThreadHistory, c as ReadThreadParams, R as ReadThreadByRolloutPathParams, L as ListThreadsParams, h as ThreadPage, U as UpdateThreadMetadataParams, a as ArchiveThreadParams } from './types-BTeabLYr.js';
-import { T as ThreadStore } from './store-AGRxhgQ3.js';
-
-type InMemoryThreadStoreCalls = {
+import type { ThreadId } from "../../core/src/ids.js";
+import type { RolloutItem } from "../../core/src/protocol.js";
+import type { AppendThreadItemsParams, ArchiveThreadParams, CreateThreadParams, ListThreadsParams, LoadThreadHistoryParams, ReadThreadByRolloutPathParams, ReadThreadParams, ResumeThreadParams, StoredThread, StoredThreadHistory, ThreadPage, UpdateThreadMetadataParams } from "../../core/src/thread-store/types.js";
+import type { ThreadStore } from "../../core/src/thread-store/store.js";
+export type InMemoryThreadStoreCalls = {
     archiveThread: number;
     appendItems: number;
     createThread: number;
@@ -25,13 +25,13 @@ type InMemoryThreadStoreState = {
     rolloutPaths: Map<string, ThreadId>;
     threads: Map<ThreadId, StoredThread>;
 };
-type InMemoryThreadStoreSnapshot = {
+export type InMemoryThreadStoreSnapshot = {
     createdThreads: Array<[ThreadId, CreateThreadParams]>;
     histories: Array<[ThreadId, RolloutItem[]]>;
     rolloutPaths: Array<[string, ThreadId]>;
     threads: Array<[ThreadId, StoredThread]>;
 };
-declare class InMemoryThreadStore implements ThreadStore {
+export declare class InMemoryThreadStore implements ThreadStore {
     protected readonly state: InMemoryThreadStoreState;
     static forId(id: string): InMemoryThreadStore;
     static removeId(id: string): InMemoryThreadStore | null;
@@ -57,35 +57,4 @@ declare class InMemoryThreadStore implements ThreadStore {
     private touch;
     private updateThreadTokenUsage;
 }
-
-type LocalThreadStoreConfig = {
-    codex_home: string;
-    default_model_provider_id: string;
-};
-declare class LocalThreadStore extends InMemoryThreadStore {
-    readonly config: LocalThreadStoreConfig;
-    constructor(config: LocalThreadStoreConfig);
-    stateDb(): null;
-    createThread(params: CreateThreadParams): Promise<void>;
-    resumeThread(params: ResumeThreadParams): Promise<void>;
-    appendItems(params: AppendThreadItemsParams): Promise<void>;
-    persistThread(threadId: ThreadId): Promise<void>;
-    flushThread(threadId: ThreadId): Promise<void>;
-    shutdownThread(threadId: ThreadId): Promise<void>;
-    discardThread(threadId: ThreadId): Promise<void>;
-    loadHistory(params: LoadThreadHistoryParams): Promise<StoredThreadHistory>;
-    readThread(params: ReadThreadParams): Promise<StoredThread>;
-    readThreadByRolloutPath(params: ReadThreadByRolloutPathParams): Promise<StoredThread>;
-    listThreads(params: ListThreadsParams): Promise<ThreadPage>;
-    updateThreadMetadata(params: UpdateThreadMetadataParams): Promise<StoredThread>;
-    archiveThread(params: ArchiveThreadParams): Promise<void>;
-    unarchiveThread(params: ArchiveThreadParams): Promise<StoredThread>;
-    liveRolloutPath(threadId: ThreadId): string;
-    private attachRolloutPath;
-    private load;
-    private save;
-    private rolloutPath;
-    private storePath;
-}
-
-export { InMemoryThreadStore as I, LocalThreadStore as L, type InMemoryThreadStoreCalls as a, type LocalThreadStoreConfig as b, type InMemoryThreadStoreSnapshot as c };
+export {};

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

@@ -0,0 +1,6 @@
+export * from "../../core/src/thread-store/index.js";
+export * from "../../core/src/thread-store/types.js";
+export * from "../../core/src/thread-store/store.js";
+export * from "../../core/src/thread-store/live-thread.js";
+export * from "./in_memory.js";
+export * from "./local/mod.js";

package/dist/internal/codex/thread-store/src/local/mod.d.ts

@@ -0,0 +1,32 @@
+import type { ThreadId } from "../../../core/src/ids.js";
+import type { AppendThreadItemsParams, ArchiveThreadParams, CreateThreadParams, ListThreadsParams, LoadThreadHistoryParams, ReadThreadByRolloutPathParams, ReadThreadParams, ResumeThreadParams, StoredThread, ThreadPage, UpdateThreadMetadataParams } from "../../../core/src/thread-store/types.js";
+import { InMemoryThreadStore } from "../in_memory.js";
+export type LocalThreadStoreConfig = {
+    codex_home: string;
+    default_model_provider_id: string;
+};
+export declare class LocalThreadStore extends InMemoryThreadStore {
+    readonly config: LocalThreadStoreConfig;
+    constructor(config: LocalThreadStoreConfig);
+    stateDb(): null;
+    createThread(params: CreateThreadParams): Promise<void>;
+    resumeThread(params: ResumeThreadParams): Promise<void>;
+    appendItems(params: AppendThreadItemsParams): Promise<void>;
+    persistThread(threadId: ThreadId): Promise<void>;
+    flushThread(threadId: ThreadId): Promise<void>;
+    shutdownThread(threadId: ThreadId): Promise<void>;
+    discardThread(threadId: ThreadId): Promise<void>;
+    loadHistory(params: LoadThreadHistoryParams): Promise<import("../index.js").StoredThreadHistory>;
+    readThread(params: ReadThreadParams): Promise<StoredThread>;
+    readThreadByRolloutPath(params: ReadThreadByRolloutPathParams): Promise<StoredThread>;
+    listThreads(params: ListThreadsParams): Promise<ThreadPage>;
+    updateThreadMetadata(params: UpdateThreadMetadataParams): Promise<StoredThread>;
+    archiveThread(params: ArchiveThreadParams): Promise<void>;
+    unarchiveThread(params: ArchiveThreadParams): Promise<StoredThread>;
+    liveRolloutPath(threadId: ThreadId): string;
+    private attachRolloutPath;
+    private load;
+    private save;
+    private rolloutPath;
+    private storePath;
+}

package/dist/internal/codex/utils/output-truncation/src/lib.d.ts

@@ -0,0 +1,19 @@
+import type { FunctionCallOutputContentItem, FunctionCallOutputPayload, TruncationPolicy } from "../../../core/src/protocol.js";
+import { approx_bytes_for_tokens, approx_token_count, approx_tokens_from_byte_count } from "../../string/src/lib.js";
+export { approx_bytes_for_tokens, approx_token_count, approx_tokens_from_byte_count, };
+export type ResolvedTruncationPolicy = {
+    mode: "bytes";
+    limit: number;
+} | {
+    mode: "tokens";
+    limit: number;
+};
+export declare const DEFAULT_TRUNCATION_POLICY: ResolvedTruncationPolicy;
+export declare function resolve_truncation_policy(policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): ResolvedTruncationPolicy;
+export declare function scale_truncation_policy(policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined, scale: number): ResolvedTruncationPolicy;
+export declare function formatted_truncate_text(content: string, policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): string;
+export declare function truncate_text(content: string, policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): string;
+export declare function formatted_truncate_text_content_items_with_policy(items: readonly FunctionCallOutputContentItem[], policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): [FunctionCallOutputContentItem[], number | null];
+export declare function truncate_function_output_items_with_policy(items: readonly FunctionCallOutputContentItem[], policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): FunctionCallOutputContentItem[];
+export declare function truncate_function_output_payload(output: FunctionCallOutputPayload, policy: TruncationPolicy | ResolvedTruncationPolicy | null | undefined): FunctionCallOutputPayload;
+export declare function approx_tokens_from_byte_count_i64(bytes: number): number;

package/dist/internal/codex/utils/string/src/lib.d.ts

@@ -0,0 +1 @@
+export * from "./truncate.js";

package/dist/internal/codex/utils/string/src/truncate.d.ts

@@ -0,0 +1,5 @@
+export declare function truncate_middle_chars(value: string, maxBytes: number): string;
+export declare function truncate_middle_with_token_budget(value: string, maxTokens: number): [string, number | null];
+export declare function approx_token_count(text: string): number;
+export declare function approx_bytes_for_tokens(tokens: number): number;
+export declare function approx_tokens_from_byte_count(bytes: number): number;

package/dist/runtime/index.d.ts

@@ -0,0 +1,47 @@
+export type { EventMsg, UserInput as CoreUserInput, Op, RealtimeEvent, RolloutItem, SandboxPolicy, Submission, } from "../internal/codex/core/src/protocol.js";
+export type { DynamicToolCallRequest, DynamicToolSpec, DynamicToolSpecWire, } from "../internal/codex/core/src/protocol/dynamic_tools.js";
+export { BaseInstructions } from "../internal/codex/core/src/protocol.js";
+export type { AuthDotJson, ChatgptOAuthTokenExchangeResponse, CodexAuth, ProviderAccountState, } from "../internal/codex/core/src/auth.js";
+export { AuthMode, CODEX_CHATGPT_OAUTH_CALLBACK_PATH, CODEX_CHATGPT_OAUTH_CLIENT_ID, CODEX_CHATGPT_OAUTH_FALLBACK_PORT, CODEX_CHATGPT_OAUTH_ISSUER, CODEX_CHATGPT_OAUTH_ORIGINATOR, CODEX_CHATGPT_OAUTH_PRIMARY_PORT, CODEX_CHATGPT_OAUTH_SCOPE, } from "../internal/codex/core/src/auth.js";
+export { allowsRequestUserInput, applyCollaborationModeMask, collaborationModeForModel, collaborationModeWithUpdates, ModeKind, TUI_VISIBLE_COLLABORATION_MODES, type CollaborationMode, type CollaborationModeMask, } from "../internal/codex/core/src/config-types.js";
+export { builtinCollaborationModePresets, builtinCollaborationModePresets as codexBuiltinCollaborationModePresets, collaborationModePresetForMode, defaultModeInstructions, normalizeCollaborationMode, } from "../internal/codex/core/src/collaboration-mode-presets.js";
+export { CODEX_PLAN_MODE_INSTRUCTIONS } from "../internal/codex/core/src/plan-mode.js";
+export type { ClientRequest, CollaborationMode as AppServerCollaborationMode, InitializeParams, InitializeResponse, ModeKind as AppServerModeKind, RequestId, ServerNotification, ServerRequest, WebSearchMode, WebSearchToolConfig, } from "../internal/codex/app-server-protocol/schema/typescript/index.js";
+export type { CommandExecutionRequestApprovalResponse, CollaborationModeListParams, CollaborationModeListResponse, CollaborationModeMask as AppServerCollaborationModeMask, DynamicToolCallParams, DynamicToolCallResponse, DynamicToolSpec as AppServerDynamicToolSpec, FileChangeRequestApprovalResponse, ListMcpServerStatusParams, ListMcpServerStatusResponse, McpResourceReadParams, McpResourceReadResponse, McpServerElicitationRequestResponse, McpServerOauthLoginParams, McpServerOauthLoginResponse, McpServerRefreshResponse, McpServerStatus as AppServerMcpServerStatus, McpServerToolCallParams, McpServerToolCallResponse, PermissionsRequestApprovalResponse, Thread, ThreadArchiveParams, ThreadArchiveResponse, ThreadCompactStartParams, ThreadCompactStartResponse, ThreadItem, ThreadListParams, ThreadListResponse, ThreadMetadataUpdateParams, ThreadMetadataUpdateResponse, ThreadReadParams, ThreadReadResponse, ThreadResumeParams, ThreadResumeResponse, ThreadSetNameParams, ThreadSetNameResponse, ThreadStartParams, ThreadStartResponse, ThreadTokenUsage, ThreadUnarchiveParams, ThreadUnarchiveResponse, ToolRequestUserInputQuestion, ToolRequestUserInputResponse, Turn, TurnInterruptParams, TurnInterruptResponse, TurnStartParams, TurnStartResponse, TurnSteerParams, TurnSteerResponse, UserInput, } from "../internal/codex/app-server-protocol/schema/typescript/v2/index.js";
+export type { AppServerEvent, AppServerRequestHandle, JSONRPCErrorError, Result, TypedRequestError, } from "../internal/codex/app-server-client/src/lib.js";
+export { clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, type ClientRequestSerializationScope, } from "../internal/codex/app-server-protocol/src/protocol/index.js";
+export { requestMethodName, requestTyped, serverNotificationRequiresDelivery, } from "../internal/codex/app-server-client/src/lib.js";
+export { CodexAppServerClientTransportError, createCodexAppServerClient, parseCodexAppServerEvent, type CodexAppServerClientConnectionStatus, type CodexAppServerClientOptions, } from "../internal/codex/app-server-client/src/remote.js";
+export { jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, parseClientTransportPayload, parseJsonRpcMessage, parseJsonRpcTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage, type ConnectionOrigin, type JSONRPCError, type JSONRPCMessage, type JSONRPCNotification, type JSONRPCRequest, type JSONRPCResponse, type ParsedClientTransportMessage, type ParsedServerTransportMessage, type ParsedTransportPayload, type TransportEvent, } from "../internal/codex/app-server-transport/src/transport/mod.js";
+export { OutgoingMessageSender, ThreadScopedOutgoingMessageSender, outgoingMessageToAppServerEvent, type ConnectionId, type ConnectionRequestId, type OutgoingError, type OutgoingMessage, type OutgoingResponse, type QueuedOutgoingMessage, type RequestContext, } from "../internal/codex/app-server/src/outgoing_message.js";
+export { CodexAppServerRequestError } from "../internal/codex/app-server/src/request_processors/request_errors.js";
+export { codexAppServerDeferredResponse, CodexAppServerConnectionSessionState, CodexAppServerMessageProcessor, type CodexAppServerMethodHandlers, type CodexAppServerRequestContext, type CodexAppServerDeferredResponse, type CodexAppServerConnectionSnapshot, type CodexAppServerConnectionRequestOutcome, type CodexAppServerMessageProcessorOptions, type InitializedConnectionSessionSnapshot, type InitializedConnectionSessionState, } from "../internal/codex/app-server/src/message_processor.js";
+export { ConnectionRpcGate, ConnectionRpcGateClosedError, } from "../internal/codex/app-server/src/connection_rpc_gate.js";
+export { RequestSerializationQueues, requestSerializationQueueKeyFromScope, type RequestSerializationQueueKey, } from "../internal/codex/app-server/src/request_serialization.js";
+export { McpRequestProcessor, ThreadRequestProcessor, TurnRequestProcessor, type RuntimeSession, } from "../internal/codex/app-server/src/request_processors.js";
+export { createCodexAppServerRuntime, type CodexAppServerEventSink, type CodexAppServerOutgoingSink, type CodexAppServerRuntime, type CodexAppServerRuntimeContext, type CodexAppServerRuntimeOptions, } from "../internal/codex/app-server/src/runtime.js";
+export { AppServerSession, type CodexAppServer, } from "../internal/codex/app-server-client/src/session.js";
+export { serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted, ThreadEventStore, type ServerNotificationThreadTarget, type ThreadBufferedEvent, type ThreadEventSnapshot, type ThreadTokenUsageSnapshot, } from "../internal/codex/app-server-client/src/thread_event_store.js";
+export { PendingAppServerRequests, type AppServerRequestResolution, type ResolvedAppServerRequest, type UnsupportedAppServerRequest, } from "../internal/codex/app-server-client/src/pending_requests.js";
+export { deniedRequestPermissionsResponse } from "../internal/codex/core/src/request_permissions.js";
+export type { RequestPermissionsEvent } from "../internal/codex/core/src/request_permissions.js";
+export type { Event } from "../internal/codex/core/src/session/session.js";
+export { applyEventMsgToRenderedThread, createRenderedThreadState, renderThreadFromHistory, setRenderedThreadConnectionStatus, } from "../internal/codex/core/src/rendered-thread.js";
+export type { RenderedThreadConnectionStatus, RenderedThreadState, } from "../internal/codex/core/src/rendered-thread.js";
+export { LiveThread } from "../internal/codex/core/src/thread-store/live-thread.js";
+export type { ThreadStore } from "../internal/codex/core/src/thread-store/store.js";
+export { InMemoryThreadStore, type InMemoryThreadStoreCalls, LocalThreadStore, type LocalThreadStoreConfig, } from "../internal/codex/thread-store/src/index.js";
+export type { AppendThreadItemsParams, ArchiveThreadParams, CreateThreadParams, ListThreadsParams, LoadThreadHistoryParams, ReadThreadByRolloutPathParams, ReadThreadParams, ResumeThreadParams, StoredThread, StoredThreadHistory, ThreadMetadataPatch, ThreadPage, ThreadPersistenceMetadata, UpdateThreadMetadataParams, } from "../internal/codex/core/src/thread-store/types.js";
+export { ThreadHistoryBuilder } from "../internal/codex/core/src/thread-history-builder.js";
+export type { Turn as ThreadHistoryTurn, TurnStatus as ThreadHistoryTurnStatus, } from "../internal/codex/core/src/thread-history-builder.js";
+export type { TextElement as CoreTextElement, UserInput as CoreUserInputItem, } from "../internal/codex/core/src/protocol/user_input.js";
+export type { TurnItem as CoreTurnItem, UserMessageTurnItem as CoreUserMessageTurnItem, } from "../internal/codex/core/src/items.js";
+export type { Model, ModelPreset, } from "../internal/codex/core/src/model-provider.js";
+export { createModelClient, defaultModelsManager, ModelClientSession, ResponsesClient, ResponsesWebsocketClient, ResponsesWebsocketConnection, resolveReasoningEffortForModel, } from "../internal/codex/core/src/index.js";
+export type { CreateModelClientInput, ModelClient, ModelClientSessionHandle, Prompt, ResponseEvent, ResponseStream, ResponsesApiRequest, ResponsesClientInput, ResponseCreateWsRequest, ResponseProcessedWsRequest, ResponsesWsRequest, } from "../internal/codex/core/src/index.js";
+export { ThreadMemoryMode } from "../internal/codex/core/src/memory.js";
+export { CodexMcpConnectionManagerAdapter, EmptyMcpConnectionManager, StaticMcpConnectionManager, type McpConnectionManager, type McpResourceInfo, type McpResourceTemplateInfo, type McpRuntimeEnvironment, type McpServerRefreshConfig, type McpServerStatus, type McpServerStatusListOptions, type McpToolInfo, } from "../internal/codex/core/src/mcp.js";
+export { SortDirection, ThreadEventPersistenceMode, ThreadSortKey, } from "../internal/codex/core/src/thread-store/types.js";
+export { thread_token_usage_updated_notification_from_rollout_items } from "../internal/codex/app-server/src/request_processors/token_usage_replay.js";
+export { asThreadId } from "../internal/codex/core/src/ids.js";
+export type { ThreadId } from "../internal/codex/core/src/ids.js";