@jrkropp/codex-js 0.1.0

package/dist/server/index.d.ts

@@ -0,0 +1,1999 @@
+import { J as JsonValue, M as McpServerRefreshConfig, B as McpRuntimeEnvironment, F as McpServerStatusListOptions, G as McpServerStatus, H as McpResourceListParams, I as McpResourceListResponse, K as McpResourceTemplateListResponse, O as McpResourceReadParams, P as McpResourceReadResponse, Q as McpServerToolCallParams, V as McpServerToolCallResponse, W as McpToolInfo, X as McpRequestId, Y as McpServerElicitationResponse, Z as McpResourceInfo, _ as McpResourceTemplateInfo, T as ThreadId, C as CreateThreadParams, R as ResumeThreadParams, $ as RolloutItem, b as StoredThreadHistory, d as StoredThread, a0 as ThreadMemoryMode, a1 as ThreadMetadataPatch, l as RequestId, a as ServerRequest, S as ServerNotification, a2 as ServiceTier, a3 as ReasoningEffortConfig, a4 as ReasoningSummaryConfig, a5 as Personality, a6 as AskForApproval, a7 as ApprovalsReviewer, a8 as SandboxPolicy, a9 as PermissionProfile, aa as ActivePermissionProfile, ab as WindowsSandboxLevel, ac as BaseInstructions, w as CollaborationMode, ad as SessionSource, ae as TurnEnvironmentSelection, af as DynamicToolSpec$1, ag as TruncationPolicy, ah as ThreadGoal, ai as ThreadGoalStatus, aj as HookEventName, ak as HookSource, al as HookRunStatus, am as HookOutputEntry, an as HookRunSummary, ao as HookCompletedEvent, r as UserInput, ap as TokenUsage, aq as RequestUserInputResponse, ar as DynamicToolResponse, as as RequestPermissionsResponse, at as RequestPermissionProfile, au as EventMsg, av as Op, aw as Submission, ax as NormalizedRequestUserInputArgs, ay as RequestPermissionsArgs, az as McpServerElicitationRequest, aA as CompactedItem, aB as ResponseItem, aC as RateLimitSnapshot, aD as TokenUsageInfo, aE as TurnContextItem, aF as ModeKind, aG as W3cTraceContext } from '../thread_event_store-BIS0qzhi.js';
+export { aH as ThreadEventPersistenceMode, m as ThreadEventSnapshot, n as ThreadEventStore, aI as ThreadHistoryBuilder, aJ as asThreadId, aK as deniedRequestPermissionsResponse } from '../thread_event_store-BIS0qzhi.js';
+import { c as ClientRequest, h as CollaborationModeListParams, i as CollaborationModeListResponse, I as InitializeParams, d as InitializeResponse, M as McpServerRefreshResponse, j as McpResourceReadParams$1, k as McpResourceReadResponse$1, l as McpServerOauthLoginParams, m as McpServerOauthLoginResponse, L as ListMcpServerStatusParams, n as ListMcpServerStatusResponse, o as McpServerToolCallParams$1, p as McpServerToolCallResponse$1, q as ThreadArchiveParams, t as ThreadArchiveResponse, u as ThreadCompactStartParams, v as ThreadCompactStartResponse, w as ThreadListParams, x as ThreadListResponse, y as ThreadMetadataUpdateParams, z as ThreadMetadataUpdateResponse, B as ThreadSetNameParams, D as ThreadSetNameResponse, E as ThreadReadParams, F as ThreadReadResponse, G as ThreadResumeParams, H as ThreadResumeResponse, f as ThreadStartParams, K as ThreadStartResponse, N as ThreadUnarchiveParams, O as ThreadUnarchiveResponse, P as TurnInterruptParams, Q as TurnInterruptResponse, g as TurnStartParams, S as TurnStartResponse, U as TurnSteerParams, V as TurnSteerResponse, A as AppServerEvent$1, J as JSONRPCErrorError$1, R as Result$1 } from '../session-BO6EZNK7.js';
+export { b as AppServerSession, C as CodexAppServer } from '../session-BO6EZNK7.js';
+export { D as DynamicToolCallResponse } from '../DynamicToolCallResponse-D2OVpa4p.js';
+import { T as ThreadStore } from '../store-H2cQxdpe.js';
+export { InMemoryThreadStore, InMemoryThreadStoreCalls, LocalThreadStore, LocalThreadStoreConfig } from '../testing/index.js';
+
+type ClientNotification = {
+    "method": "initialized";
+};
+
+type WebSearchContextSize = "low" | "medium" | "high";
+
+type WebSearchLocation = {
+    country: string | null;
+    region: string | null;
+    city: string | null;
+    timezone: string | null;
+};
+
+type WebSearchMode$1 = "disabled" | "cached" | "live";
+
+type WebSearchToolConfig = {
+    context_size: WebSearchContextSize | null;
+    allowed_domains: Array<string> | null;
+    location: WebSearchLocation | null;
+};
+
+type DynamicToolSpec = {
+    namespace?: string;
+    name: string;
+    description: string;
+    inputSchema: JsonValue;
+    deferLoading?: boolean;
+};
+
+type FreeformTool = {
+    name: string;
+    description: string;
+    format: {
+        type: string;
+        syntax: string;
+        definition: string;
+    };
+};
+type ResponsesApiTool = {
+    name: string;
+    description: string;
+    strict: boolean;
+    defer_loading?: boolean;
+    parameters: JsonSchema;
+};
+type ResponsesApiFunctionTool = ResponsesApiTool & {
+    type: "function";
+};
+type LoadableToolSpec = ResponsesApiFunctionTool | (ResponsesApiNamespace & {
+    type: "namespace";
+});
+type ResponsesApiNamespace = {
+    name: string;
+    description: string;
+    tools: ResponsesApiNamespaceTool[];
+};
+type ResponsesApiNamespaceTool = ResponsesApiFunctionTool;
+
+type JsonSchema = unknown;
+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";
+});
+
+interface McpConnectionManager {
+    refresh_mcp_servers_now(config: McpServerRefreshConfig, environment: McpRuntimeEnvironment): Promise<void>;
+    list_server_statuses(options?: McpServerStatusListOptions): Promise<McpServerStatus[]>;
+    list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
+    list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
+    read_resource(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    call_tool(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    resolve_tool_info(serverName: string, toolName: string): Promise<McpToolInfo | null>;
+    list_tools(): Promise<McpToolInfo[]>;
+    resolve_elicitation(serverName: string, id: McpRequestId, response: McpServerElicitationResponse): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare class EmptyMcpConnectionManager implements McpConnectionManager {
+    static readonly instance: EmptyMcpConnectionManager;
+    refresh_mcp_servers_now(): Promise<void>;
+    list_server_statuses(): Promise<McpServerStatus[]>;
+    list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
+    list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
+    read_resource(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    call_tool(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    resolve_tool_info(): Promise<McpToolInfo | null>;
+    list_tools(): Promise<McpToolInfo[]>;
+    resolve_elicitation(serverName: string): Promise<void>;
+    shutdown(): Promise<void>;
+}
+type StaticMcpConnectionManagerOptions = {
+    resources?: Record<string, ReadonlyArray<McpResourceInfo>>;
+    resource_templates?: Record<string, ReadonlyArray<McpResourceTemplateInfo>>;
+    read_resources?: Record<string, McpResourceReadResponse>;
+};
+declare class StaticMcpConnectionManager implements McpConnectionManager {
+    private readonly tools;
+    private readonly resources;
+    private readonly resource_templates;
+    private readonly read_resources;
+    constructor(tools?: readonly McpToolInfo[], options?: StaticMcpConnectionManagerOptions);
+    refresh_mcp_servers_now(): Promise<void>;
+    list_server_statuses(options?: McpServerStatusListOptions): Promise<McpServerStatus[]>;
+    list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
+    list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
+    read_resource(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    call_tool(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    resolve_tool_info(serverName: string, toolName: string): Promise<McpToolInfo | null>;
+    list_tools(): Promise<McpToolInfo[]>;
+    resolve_elicitation(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+declare class LiveThread {
+    readonly threadId: ThreadId;
+    private readonly threadStore;
+    private constructor();
+    static create(threadStore: ThreadStore, params: CreateThreadParams): Promise<LiveThread>;
+    static resume(threadStore: ThreadStore, params: ResumeThreadParams): Promise<LiveThread>;
+    appendItems(items: RolloutItem[]): Promise<void>;
+    persist(): Promise<void>;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    discard(): Promise<void>;
+    loadHistory(includeArchived: boolean): Promise<StoredThreadHistory>;
+    readThread(includeArchived: boolean, includeHistory: boolean): Promise<StoredThread>;
+    updateMemoryMode(mode: ThreadMemoryMode, includeArchived: boolean): Promise<void>;
+    updateMetadata(patch: ThreadMetadataPatch, includeArchived: boolean): Promise<StoredThread>;
+    localRolloutPath(): Promise<string | null>;
+}
+
+declare const AuthMode: {
+    readonly ApiKey: "apiKey";
+    readonly Chatgpt: "chatgpt";
+};
+type AuthMode = (typeof AuthMode)[keyof typeof AuthMode];
+type PlanType = "free" | "plus" | "pro" | "team" | "enterprise" | "edu" | "unknown";
+type TokenData = {
+    access_token: string;
+    refresh_token: string;
+    id_token: string;
+    account_id?: string | null;
+    expires_at?: number | null;
+};
+type AuthDotJson = {
+    auth_mode?: AuthMode | null;
+    openai_api_key?: string | null;
+    tokens?: TokenData | null;
+    last_refresh?: string | null;
+};
+type CodexAuth = {
+    type: typeof AuthMode.ApiKey;
+    api_key: string;
+} | {
+    type: typeof AuthMode.Chatgpt;
+    auth: AuthDotJson;
+    account_id?: string | null;
+    email?: string | null;
+    plan_type?: PlanType | null;
+};
+type ProviderAccount = {
+    type: typeof AuthMode.ApiKey;
+} | {
+    type: typeof AuthMode.Chatgpt;
+    email: string;
+    plan_type: PlanType;
+};
+type ProviderAccountState = {
+    account: ProviderAccount | null;
+    requires_openai_auth: boolean;
+};
+
+type ClientRequestSerializationScope = {
+    key: string;
+    type: "global";
+} | {
+    threadId: string;
+    type: "thread";
+} | {
+    path: string;
+    type: "threadPath";
+} | {
+    processId: string;
+    type: "commandExecProcess";
+} | {
+    processHandle: string;
+    type: "process";
+} | {
+    sessionId: string;
+    type: "fuzzyFileSearchSession";
+} | {
+    watchId: string;
+    type: "fsWatch";
+} | {
+    serverName: string;
+    type: "mcpOauth";
+};
+declare function clientRequestId(request: ClientRequest): RequestId;
+declare function clientRequestMethod(request: ClientRequest): string;
+declare function clientRequestExperimentalReason(request: ClientRequest | {
+    method: string;
+    params?: unknown;
+}): string | null;
+declare function clientRequestSerializationScope(request: ClientRequest | {
+    method: string;
+    params?: unknown;
+}): ClientRequestSerializationScope | null;
+
+type JSONRPCErrorError = {
+    code: number;
+    data?: unknown;
+    message: string;
+};
+type Result = unknown;
+type ConnectionId = number;
+type OutgoingResponse = {
+    id: RequestId;
+    result: Result;
+};
+type OutgoingError = {
+    error: JSONRPCErrorError;
+    id: RequestId;
+};
+type OutgoingMessage = ServerRequest | ServerNotification | OutgoingResponse | OutgoingError;
+type QueuedOutgoingMessage = {
+    message: OutgoingMessage;
+    writeComplete?: () => void;
+};
+
+type ConnectionOrigin = "stdio" | "inProcess" | "webSocket" | "remoteControl";
+type JSONRPCRequest = {
+    id: RequestId;
+    method: string;
+    params?: unknown;
+};
+type JSONRPCNotification = {
+    method: string;
+    params?: unknown;
+};
+type JSONRPCResponse = {
+    id: RequestId;
+    result: Result;
+};
+type JSONRPCError = {
+    error: JSONRPCErrorError;
+    id: RequestId | null;
+};
+type JSONRPCMessage = JSONRPCRequest | JSONRPCNotification | JSONRPCResponse | JSONRPCError;
+type ParsedServerTransportMessage = {
+    request: ClientRequest;
+    type: "client_request";
+} | {
+    notification: ClientNotification;
+    type: "client_notification";
+} | {
+    response: JSONRPCResponse;
+    type: "response";
+} | {
+    error: JSONRPCError;
+    type: "error";
+};
+type ParsedClientTransportMessage = {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    response: JSONRPCResponse;
+    type: "response";
+} | {
+    error: JSONRPCError;
+    type: "error";
+};
+type ParsedTransportPayload<T> = {
+    message: T;
+    type: "ok";
+} | {
+    error: JSONRPCErrorError;
+    id: RequestId | null;
+    type: "invalid";
+};
+declare function parseServerTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<ParsedServerTransportMessage>;
+declare function parseClientTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<ParsedClientTransportMessage>;
+declare function serializeOutgoingMessage(message: OutgoingMessage): string;
+declare function serializeJsonRpcResponse(id: RequestId, result: Result): string;
+declare function serializeJsonRpcError(id: RequestId | null, error: JSONRPCErrorError): string;
+declare function queuedOutgoingMessage(message: OutgoingMessage, writeComplete?: () => void): QueuedOutgoingMessage;
+declare function jsonRpcParseError(message: string): JSONRPCErrorError;
+declare function jsonRpcInvalidRequestError(message: string): JSONRPCErrorError;
+declare function jsonRpcInternalError(message: string): JSONRPCErrorError;
+
+type AppServerEvent = {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    skipped: number;
+    type: "lagged";
+} | {
+    message: string;
+    type: "disconnected";
+};
+type ConnectionRequestId = {
+    connectionId: ConnectionId;
+    requestId: RequestId;
+};
+type RequestContext = {
+    connectionId: ConnectionId;
+    requestId: RequestId;
+};
+type OutgoingServerRequestHandle = {
+    request: ServerRequest;
+    result: Promise<Result>;
+};
+type OutgoingMessageSenderOptions = {
+    send: (message: OutgoingMessage, context: {
+        connectionIds?: ConnectionId[];
+        context?: unknown;
+        threadId?: ThreadId;
+    }) => Promise<void> | void;
+};
+declare class OutgoingMessageSender {
+    private nextServerRequestId;
+    private readonly requestIdToCallback;
+    private readonly requestContexts;
+    private readonly sendMessage;
+    constructor(options: OutgoingMessageSenderOptions);
+    threadScoped(threadId: ThreadId): ThreadScopedOutgoingMessageSender;
+    threadScopedForConnections(threadId: ThreadId, connectionIds: ConnectionId[]): ThreadScopedOutgoingMessageSender;
+    sendServerNotification(notification: ServerNotification, context?: unknown, threadId?: ThreadId, connectionIds?: ConnectionId[]): Promise<void>;
+    sendRequest(request: ServerRequest, threadId?: ThreadId | null, context?: unknown, connectionIds?: ConnectionId[]): Promise<Result>;
+    sendRequestWithHandle(request: ServerRequest, threadId?: ThreadId | null, context?: unknown, connectionIds?: ConnectionId[]): OutgoingServerRequestHandle;
+    registerRequestContext(requestContext: RequestContext): void;
+    requestContext(requestId: ConnectionRequestId): RequestContext | null;
+    sendResponse(requestId: ConnectionRequestId, result: Result, context?: unknown): Promise<void>;
+    sendError(requestId: ConnectionRequestId, error: JSONRPCErrorError, context?: unknown): Promise<void>;
+    notifyClientResponse(id: RequestId, result: Result): Promise<void>;
+    notifyClientError(id: RequestId, error: JSONRPCErrorError): Promise<void>;
+    cancelRequest(id: RequestId): boolean;
+    connectionClosed(connectionId: ConnectionId): void;
+    cancelRequestsForThread(threadId: ThreadId, error?: JSONRPCErrorError): void;
+    pendingRequestsForThread(threadId: ThreadId): ServerRequest[];
+    private nextRequestId;
+    private takeRequestCallback;
+}
+declare class ThreadScopedOutgoingMessageSender {
+    private readonly outgoing;
+    private readonly threadId;
+    private readonly connectionIds;
+    constructor(outgoing: OutgoingMessageSender, threadId: ThreadId, connectionIds?: ConnectionId[]);
+    sendRequest(request: ServerRequest, context?: unknown): Promise<Result>;
+    sendServerNotification(notification: ServerNotification, context?: unknown): Promise<void>;
+    sendResponse(requestId: ConnectionRequestId, result: Result, context?: unknown): Promise<void>;
+    sendError(requestId: ConnectionRequestId, error: JSONRPCErrorError, context?: unknown): Promise<void>;
+    abortPendingServerRequests(error?: JSONRPCErrorError): void;
+    pendingRequests(): ServerRequest[];
+}
+
+declare class CodexAppServerRequestError extends Error {
+    readonly error: JSONRPCErrorError;
+    readonly status: number;
+    constructor(error: JSONRPCErrorError, status?: number);
+}
+
+declare class ConnectionRpcGateClosedError extends Error {
+    constructor();
+}
+declare class ConnectionRpcGate {
+    private accepting;
+    private inFlight;
+    private readonly shutdownWaiters;
+    isAccepting(): boolean;
+    run<T>(work: () => Promise<T> | T): Promise<T>;
+    shutdown(): Promise<void>;
+}
+
+type RequestSerializationQueueKey = string;
+declare class RequestSerializationQueues {
+    private readonly tails;
+    enqueue<T>(key: RequestSerializationQueueKey, work: () => Promise<T> | T): Promise<T>;
+}
+
+type CodexAppServerRequestContext = {
+    connectionId: ConnectionId;
+    outgoing: OutgoingMessageSender;
+    requestId: ConnectionRequestId;
+    session: CodexAppServerConnectionSessionState;
+};
+type CodexAppServerMethodHandlers<Context = unknown> = {
+    collaborationModeList?(params: CollaborationModeListParams, context?: Context): Promise<CollaborationModeListResponse>;
+    initialize?(params: InitializeParams, context?: Context, session?: CodexAppServerConnectionSessionState): Promise<InitializeResponse>;
+    configMcpServerReload?(params: undefined, context?: Context): Promise<McpServerRefreshResponse>;
+    mcpResourceRead?(params: McpResourceReadParams$1, context?: Context, request?: CodexAppServerRequestContext): Promise<McpResourceReadResponse$1 | CodexAppServerDeferredResponse>;
+    mcpServerOauthLogin?(params: McpServerOauthLoginParams, context?: Context): Promise<McpServerOauthLoginResponse>;
+    mcpServerStatusList?(params: ListMcpServerStatusParams, context?: Context, request?: CodexAppServerRequestContext): Promise<ListMcpServerStatusResponse | CodexAppServerDeferredResponse>;
+    mcpServerToolCall?(params: McpServerToolCallParams$1, context?: Context, request?: CodexAppServerRequestContext): Promise<McpServerToolCallResponse$1 | CodexAppServerDeferredResponse>;
+    threadArchive?(params: ThreadArchiveParams, context?: Context): Promise<ThreadArchiveResponse>;
+    threadCompactStart(params: ThreadCompactStartParams, context?: Context): Promise<ThreadCompactStartResponse>;
+    threadList?(params: ThreadListParams, context?: Context): Promise<ThreadListResponse>;
+    threadMetadataUpdate?(params: ThreadMetadataUpdateParams, context?: Context): Promise<ThreadMetadataUpdateResponse>;
+    threadNameSet?(params: ThreadSetNameParams, context?: Context): Promise<ThreadSetNameResponse>;
+    threadRead?(params: ThreadReadParams, context?: Context): Promise<ThreadReadResponse>;
+    threadResume(params: ThreadResumeParams, context?: Context): Promise<ThreadResumeResponse>;
+    threadStart(params: ThreadStartParams, context?: Context): Promise<ThreadStartResponse>;
+    threadUnarchive?(params: ThreadUnarchiveParams, context?: Context): Promise<ThreadUnarchiveResponse>;
+    turnInterrupt(params: TurnInterruptParams, context?: Context): Promise<TurnInterruptResponse>;
+    turnStart(params: TurnStartParams, context?: Context): Promise<TurnStartResponse>;
+    turnSteer(params: TurnSteerParams, context?: Context): Promise<TurnSteerResponse>;
+};
+type InitializedConnectionSessionState = {
+    appServerClientName: string;
+    clientVersion: string;
+    experimentalApiEnabled: boolean;
+    optedOutNotificationMethods: ReadonlySet<string>;
+};
+declare class CodexAppServerConnectionSessionState {
+    readonly rpcGate: ConnectionRpcGate;
+    private initializedState;
+    constructor(initializedState?: InitializedConnectionSessionState | null);
+    initialized(): boolean;
+    initialize(state: InitializedConnectionSessionState): void;
+    experimentalApiEnabled(): boolean;
+    optedOutNotificationMethods(): ReadonlySet<string>;
+    appServerClientName(): string | null;
+    clientVersion(): string | null;
+}
+type CodexAppServerMessageProcessorOptions<Context = unknown> = {
+    connectionId?: ConnectionId;
+    handlers: CodexAppServerMethodHandlers<Context>;
+    initializeResponse?: InitializeResponse | (() => InitializeResponse);
+    outgoing?: OutgoingMessageSender;
+    requestSerializationQueues?: RequestSerializationQueues;
+    session?: CodexAppServerConnectionSessionState;
+};
+type CodexAppServerConnectionRequestOutcome = {
+    result: unknown;
+    type: "response";
+} | {
+    type: "deferred";
+} | {
+    error: JSONRPCErrorError;
+    type: "error";
+};
+type CodexAppServerDeferredResponse = {
+    readonly __codexAppServerDeferredResponse: true;
+};
+declare class CodexAppServerMessageProcessor<Context = unknown> {
+    readonly connectionId: ConnectionId;
+    readonly requestSerializationQueues: RequestSerializationQueues;
+    readonly session: CodexAppServerConnectionSessionState;
+    private readonly handlers;
+    private readonly initializeResponse;
+    private readonly outgoing;
+    constructor(options: CodexAppServerMessageProcessorOptions<Context>);
+    processClientRequest(request: ClientRequest, context?: Context): Promise<unknown>;
+    processConnectionRequest(request: ClientRequest, context?: Context): Promise<CodexAppServerConnectionRequestOutcome>;
+    shutdown(): Promise<void>;
+    connectionClosed(): Promise<void>;
+    private initialize;
+    private handleInitializedClientRequest;
+    private defaultInitializeResponse;
+    private connectionRequestId;
+    private requestContext;
+}
+
+declare class AgentPath {
+    private readonly value;
+    static readonly ROOT = "/root";
+    private constructor();
+    static root(): AgentPath;
+    static parse(value: string): AgentPath;
+    isRoot(): boolean;
+    toString(): string;
+}
+
+type AgentMetadata = {
+    agent_id?: ThreadId | null;
+    agent_path?: AgentPath | null;
+    agent_nickname?: string | null;
+    agent_role?: string | null;
+    last_task_message?: string | null;
+};
+type LiveAgent = {
+    thread_id: ThreadId;
+    metadata: AgentMetadata;
+    status: AgentStatus;
+};
+type ListedAgent = {
+    agent_name: string;
+    agent_status: AgentStatus;
+    last_task_message?: string | null;
+};
+declare const AgentStatus: {
+    readonly Running: "running";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+    readonly Closed: "closed";
+    readonly Cancelled: "cancelled";
+};
+type AgentStatus = (typeof AgentStatus)[keyof typeof AgentStatus];
+declare class AgentRegistry {
+    private readonly agent_tree;
+    private readonly used_agent_nicknames;
+    private total_count;
+    private nickname_reset_count;
+    reserve_spawn_slot(max_threads?: number | null): SpawnReservation;
+    release_spawned_thread(thread_id: ThreadId): void;
+    release_spawn_slot(): void;
+    register_root_thread(thread_id: ThreadId): void;
+    agent_id_for_path(agent_path: AgentPath): ThreadId | null;
+    agent_metadata_for_thread(thread_id: ThreadId): AgentMetadata | null;
+    live_agents(): AgentMetadata[];
+    update_last_task_message(thread_id: ThreadId, last_task_message: string): void;
+    register_spawned_thread(agent_metadata: AgentMetadata): void;
+    reserve_agent_nickname(names: readonly string[], preferred?: string | null): string | null;
+    reserve_agent_path(agent_path: AgentPath): void;
+    private reset_and_select_nickname;
+}
+declare class SpawnReservation {
+    private readonly registry;
+    private active;
+    constructor(registry: AgentRegistry);
+    commit(metadata: AgentMetadata): void;
+    release(): void;
+}
+
+type InterAgentCommunication = {
+    author: AgentPath;
+    recipient: AgentPath;
+    items: unknown[];
+    content: string;
+    trigger_turn: boolean;
+    seq?: number;
+};
+declare class Mailbox {
+    private readonly pending;
+    private next_seq;
+    static new(): {
+        mailbox: Mailbox;
+        receiver: MailboxReceiver;
+    };
+    send(communication: Omit<InterAgentCommunication, "seq">): number;
+    drain(): InterAgentCommunication[];
+    has_pending(): boolean;
+    has_pending_trigger_turn(): boolean;
+}
+declare class MailboxReceiver {
+    private readonly mailbox;
+    constructor(mailbox: Mailbox);
+    has_pending(): boolean;
+    has_pending_trigger_turn(): boolean;
+    drain(): InterAgentCommunication[];
+}
+
+declare const SpawnAgentForkMode: {
+    readonly FullHistory: "full_history";
+    readonly LastNTurns: "last_n_turns";
+};
+type SpawnAgentForkMode = {
+    type: typeof SpawnAgentForkMode.FullHistory;
+} | {
+    type: typeof SpawnAgentForkMode.LastNTurns;
+    turns: number;
+};
+type SpawnAgentOptions = {
+    fork_parent_spawn_call_id?: string | null;
+    fork_mode?: SpawnAgentForkMode | null;
+    environments?: unknown[] | null;
+};
+type AgentControlExecutor = {
+    spawn_agent?(input: {
+        initial_operation: unknown;
+        session_source?: unknown;
+        options?: SpawnAgentOptions;
+    }): Promise<LiveAgent>;
+    send_input?(input: {
+        target: ThreadId;
+        message?: string | null;
+        items?: unknown[] | null;
+        interrupt?: boolean;
+    }): Promise<unknown>;
+    wait_agent?(input: {
+        targets: ThreadId[];
+        timeout_ms?: number | null;
+    }): Promise<unknown>;
+    close_agent?(input: {
+        target: ThreadId;
+    }): Promise<unknown>;
+    resume_agent?(input: {
+        id: ThreadId;
+    }): Promise<unknown>;
+};
+declare class AgentControl {
+    private readonly executor;
+    readonly registry: AgentRegistry;
+    readonly mailbox: Mailbox;
+    constructor(executor?: AgentControlExecutor | null);
+    static empty(): AgentControl;
+    spawn_agent_with_metadata(input: {
+        initial_operation: unknown;
+        session_source?: unknown;
+        options?: SpawnAgentOptions;
+    }): Promise<LiveAgent>;
+    send_input(input: {
+        target: ThreadId;
+        message?: string | null;
+        items?: unknown[] | null;
+        interrupt?: boolean;
+    }): Promise<unknown>;
+    wait_agent(input: {
+        targets: ThreadId[];
+        timeout_ms?: number | null;
+    }): Promise<unknown>;
+    close_agent(input: {
+        target: ThreadId;
+    }): Promise<unknown>;
+    resume_agent(input: {
+        id: ThreadId;
+    }): Promise<unknown>;
+    list_agents(): ListedAgent[];
+    send_mail(communication: Omit<InterAgentCommunication, "seq">): number;
+}
+
+type WireApi = "responses";
+type ModelProviderAuthInfo = {
+    command: string;
+    args?: string[] | null;
+    env?: Record<string, string> | null;
+};
+type ModelProviderAwsAuthInfo = {
+    profile?: string | null;
+    region?: string | null;
+};
+type ModelProviderInfo = {
+    name: string;
+    base_url?: string | null;
+    env_key?: string | null;
+    env_key_instructions?: string | null;
+    experimental_bearer_token?: string | null;
+    auth?: ModelProviderAuthInfo | null;
+    aws?: ModelProviderAwsAuthInfo | null;
+    wire_api?: WireApi;
+    query_params?: Record<string, string> | null;
+    http_headers?: Record<string, string> | null;
+    env_http_headers?: Record<string, string> | null;
+    request_max_retries?: number | null;
+    stream_max_retries?: number | null;
+    stream_idle_timeout_ms?: number | null;
+    websocket_connect_timeout_ms?: number | null;
+    requires_openai_auth?: boolean;
+    supports_websockets?: boolean;
+};
+type ProviderCapabilities = {
+    namespace_tools: boolean;
+    image_generation: boolean;
+    web_search: boolean;
+};
+type ProviderRuntimeConfig = {
+    name: string;
+    base_url: string;
+    responses_url: string;
+    query_params: Record<string, string> | null;
+    headers: Record<string, string>;
+    request_max_retries: number;
+    stream_max_retries: number;
+    stream_idle_timeout_ms: number;
+    websocket_connect_timeout_ms: number;
+    supports_websockets: boolean;
+};
+type ModelServiceTier = {
+    id: string;
+    name: string;
+    description: string;
+};
+type ReasoningEffortOption = {
+    reasoning_effort: string;
+    description: string;
+};
+type ModelInfo = {
+    slug: string;
+    display_name: string;
+    description: string | null;
+    default_reasoning_level: string | null;
+    supported_reasoning_levels: ReasoningEffortOption[];
+    visibility: "list" | "hide" | "none";
+    supported_in_api: boolean;
+    priority: number;
+    upgrade: string | null;
+    upgrade_info: null;
+    availability_nux: null;
+    input_modalities: string[];
+    supports_personality: boolean;
+    additional_speed_tiers: string[];
+    service_tiers: ModelServiceTier[];
+    base_instructions: string;
+    model_messages?: ModelMessages | null;
+    context_window?: number | null;
+    max_context_window?: number | null;
+    auto_compact_token_limit?: number | null;
+    effective_context_window_percent?: number | null;
+};
+type ModelMessages = {
+    instructions_template?: string | null;
+    instructions_variables?: ModelInstructionsVariables | null;
+};
+type ModelInstructionsVariables = {
+    personality?: Record<string, string> | null;
+};
+type ModelPreset = {
+    id: string;
+    model: string;
+    upgrade: string | null;
+    upgrade_info: null;
+    availability_nux: null;
+    display_name: string;
+    description: string;
+    hidden: boolean;
+    supported_reasoning_efforts: ReasoningEffortOption[];
+    default_reasoning_effort: string;
+    input_modalities: string[];
+    supports_personality: boolean;
+    additional_speed_tiers: string[];
+    service_tiers: ModelServiceTier[];
+    is_default: boolean;
+    supported_in_api: boolean;
+};
+type ModelListParams = {
+    cursor?: string | null;
+    limit?: number | null;
+    include_hidden?: boolean | null;
+};
+type ModelListResponse = {
+    data: ModelPreset[];
+    next_cursor: string | null;
+};
+type RefreshStrategy = "online" | "offline" | "online_if_uncached";
+type ModelsManager = {
+    list_models(params?: ModelListParams): ModelListResponse;
+    raw_model_catalog(refresh_strategy?: RefreshStrategy): {
+        models: ModelInfo[];
+    };
+    get_model_info(model: string): ModelInfo;
+    get_default_model(model?: string | null): string;
+    default_reasoning_effort(model?: string | null): string;
+};
+type ModelProvider = {
+    info(): ModelProviderInfo;
+    account_state(): ProviderAccountState;
+    capabilities(): ProviderCapabilities;
+    runtime_config(auth?: CodexAuth | null): ProviderRuntimeConfig;
+    models_manager(): ModelsManager;
+};
+
+type ConfigToml = {
+    model?: string;
+    review_model?: string;
+    model_provider?: string;
+    service_tier?: ServiceTier | null;
+    model_reasoning_effort?: ReasoningEffortConfig | null;
+    plan_mode_reasoning_effort?: ReasoningEffortConfig | null;
+    model_reasoning_summary?: ReasoningSummaryConfig;
+    personality?: Personality | null;
+    approval_policy?: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy?: SandboxPolicy | null;
+    sandbox_mode?: SandboxPolicy["mode"] | null;
+    default_permissions?: string | null;
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    cwd?: string;
+    instructions?: string | null;
+    model_instructions_file?: string | null;
+    model_instructions_file_contents?: string | null;
+    base_instructions?: BaseInstructions | string | null;
+    developer_instructions?: string | null;
+    user_instructions?: string | null;
+    collaboration_mode?: CollaborationMode | null;
+    session_source?: SessionSource;
+    environments?: TurnEnvironmentSelection[];
+    dynamic_tools?: DynamicToolSpec$1[];
+    final_output_json_schema?: unknown;
+    truncation_policy?: TruncationPolicy | null;
+    web_search?: WebSearchMode$1 | null;
+    tools?: ToolsToml | null;
+    features?: FeaturesToml | null;
+    profiles?: Record<string, ConfigProfile>;
+    profile?: string | null;
+    compact_prompt?: string | null;
+    include_permissions_instructions?: boolean;
+    include_environment_context?: boolean;
+    include_apps_instructions?: boolean;
+    include_skill_instructions?: boolean;
+};
+type ConfigProfile = Omit<ConfigToml, "profiles" | "profile">;
+type ToolsToml = Omit<DefaultToolsConfigInput, "web_search"> & {
+    web_search?: Partial<WebSearchToolConfig> | boolean | null;
+};
+type FeaturesToml = Record<string, unknown>;
+type ResolvedConfig = Required<Pick<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source">> & Omit<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source"> & {
+    base_instructions: BaseInstructions;
+    base_instructions_source: "config" | "model_instructions_file" | "default";
+    service_tier: ServiceTier | null;
+    reasoning_effort: ReasoningEffortConfig | null;
+    reasoning_summary: ReasoningSummaryConfig;
+    developer_instructions: string | null;
+    user_instructions: string | null;
+    personality: Personality | null;
+    sandbox_policy: SandboxPolicy;
+    permission_profile: PermissionProfile;
+    active_permission_profile: ActivePermissionProfile | null;
+    windows_sandbox_level: WindowsSandboxLevel | null;
+    collaboration_mode: CollaborationMode;
+    environments: TurnEnvironmentSelection[];
+    dynamic_tools: DynamicToolSpec$1[];
+    final_output_json_schema?: unknown;
+    truncation_policy: TruncationPolicy | null;
+    web_search_mode: WebSearchMode$1;
+    tools: ToolsConfig;
+    startup_warnings: string[];
+};
+
+type ThreadGoalUpdate = {
+    status?: ThreadGoalStatus;
+    token_budget?: number | null;
+    expected_goal_id?: string | null;
+};
+declare const ThreadGoalAccountingMode: {
+    readonly ActiveStatusOnly: "active_status_only";
+    readonly ActiveOnly: "active_only";
+    readonly ActiveOrComplete: "active_or_complete";
+    readonly ActiveOrStopped: "active_or_stopped";
+};
+type ThreadGoalAccountingMode = (typeof ThreadGoalAccountingMode)[keyof typeof ThreadGoalAccountingMode];
+type ThreadGoalAccountingOutcome = {
+    type: "updated";
+    goal: ThreadGoal;
+} | {
+    type: "unchanged";
+    goal: ThreadGoal | null;
+};
+type ThreadGoalStore = {
+    getThreadGoal(threadId: ThreadId): Promise<ThreadGoal | null>;
+    replaceThreadGoal(params: {
+        thread_id: ThreadId;
+        objective: string;
+        status: ThreadGoalStatus;
+        token_budget?: number | null;
+    }): Promise<ThreadGoal>;
+    insertThreadGoal(params: {
+        thread_id: ThreadId;
+        objective: string;
+        status: ThreadGoalStatus;
+        token_budget?: number | null;
+    }): Promise<ThreadGoal>;
+    updateThreadGoal(params: {
+        thread_id: ThreadId;
+        update: ThreadGoalUpdate;
+    }): Promise<ThreadGoal>;
+    pauseActiveThreadGoal(threadId: ThreadId): Promise<ThreadGoal | null>;
+    deleteThreadGoal(threadId: ThreadId): Promise<void>;
+    accountThreadGoalUsage(params: {
+        thread_id: ThreadId;
+        tokens_used_delta?: number;
+        time_used_seconds_delta?: number;
+        mode?: ThreadGoalAccountingMode;
+    }): Promise<ThreadGoalAccountingOutcome>;
+};
+type CreateGoalRequest = {
+    objective: string;
+    token_budget?: number | null;
+};
+
+type ConfiguredHookHandler = {
+    event_name: HookEventName;
+    matcher?: string | null;
+    name?: string | null;
+    status_message?: string | null;
+    source_path?: string | null;
+    source?: HookSource;
+    display_order?: number;
+    run?: (request: unknown) => Promise<HookHandlerResult> | HookHandlerResult;
+};
+type HookHandlerResult = {
+    status?: HookRunStatus;
+    entries?: HookOutputEntry[];
+    additional_contexts?: string[];
+    block_reason?: string | null;
+    stop_reason?: string | null;
+    feedback_message?: string | null;
+    permission_decision?: PermissionRequestDecision | null;
+};
+declare const PermissionRequestDecision: {
+    readonly Allow: "allow";
+    readonly Deny: "deny";
+};
+type PermissionRequestDecision = {
+    type: typeof PermissionRequestDecision.Allow;
+} | {
+    type: typeof PermissionRequestDecision.Deny;
+    message?: string | null;
+};
+
+type SessionStartRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    source: string;
+};
+type UserPromptSubmitRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    prompt: string;
+};
+type PreToolUseRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    tool_name: string;
+    matcher_aliases: string[];
+    tool_use_id: string;
+    tool_input: unknown;
+};
+type PostToolUseRequest = PreToolUseRequest & {
+    tool_response: unknown;
+};
+type PermissionRequestRequest = PreToolUseRequest & {
+    run_id_suffix: string;
+};
+type CompactHookRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    trigger: "manual" | "auto";
+};
+type PreToolUseOutcome = {
+    hook_events: HookCompletedEvent[];
+    should_block: boolean;
+    block_reason?: string | null;
+    additional_contexts: string[];
+};
+type PostToolUseOutcome = {
+    hook_events: HookCompletedEvent[];
+    should_stop: boolean;
+    stop_reason?: string | null;
+    feedback_message?: string | null;
+    additional_contexts: string[];
+};
+type PermissionRequestOutcome = {
+    hook_events: HookCompletedEvent[];
+    decision?: PermissionRequestDecision | null;
+};
+declare class Hooks {
+    private readonly handlers;
+    constructor(handlers?: readonly ConfiguredHookHandler[]);
+    static empty(): Hooks;
+    static withHandlersForTest(handlers: readonly ConfiguredHookHandler[]): Hooks;
+    is_empty(): boolean;
+    preview_session_start(request: SessionStartRequest): HookRunSummary[];
+    run_session_start(request: SessionStartRequest): Promise<PostToolUseOutcome>;
+    preview_user_prompt_submit(): HookRunSummary[];
+    run_user_prompt_submit(request: UserPromptSubmitRequest): Promise<PostToolUseOutcome>;
+    preview_pre_tool_use(request: PreToolUseRequest): HookRunSummary[];
+    run_pre_tool_use(request: PreToolUseRequest): Promise<PreToolUseOutcome>;
+    preview_post_tool_use(request: PostToolUseRequest): HookRunSummary[];
+    run_post_tool_use(request: PostToolUseRequest): Promise<PostToolUseOutcome>;
+    preview_permission_request(request: PermissionRequestRequest): HookRunSummary[];
+    run_permission_request(request: PermissionRequestRequest): Promise<PermissionRequestOutcome>;
+    preview_pre_compact(request: CompactHookRequest): HookRunSummary[];
+    run_pre_compact(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    preview_post_compact(request: CompactHookRequest): HookRunSummary[];
+    run_post_compact(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    preview_stop(): HookRunSummary[];
+    run_stop(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    private preview;
+    private runContextInjecting;
+    private runMatching;
+}
+
+declare const TaskKind: {
+    readonly Regular: "Regular";
+    readonly Compact: "Compact";
+    readonly Review: "Review";
+};
+type TaskKind = (typeof TaskKind)[keyof typeof TaskKind];
+type SessionTaskResult = {
+    last_agent_message: string | null;
+    steps?: number;
+    message?: string;
+};
+declare class SessionTaskContext {
+    private readonly session;
+    constructor(session: Session);
+    clone_session(): Session;
+}
+type SessionTaskRunInput = {
+    session: SessionTaskContext;
+    ctx: TurnContext;
+    input: UserInput[];
+    signal?: AbortSignal;
+};
+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>;
+}
+type RunningTask = {
+    sub_id: string;
+    kind: TaskKind;
+    turn_context: TurnContext;
+    task?: SessionTask;
+    abort_controller?: AbortController;
+    records_turn_token_usage_on_span?: boolean;
+};
+
+declare const MailboxDeliveryPhase: {
+    readonly CurrentTurn: "CurrentTurn";
+    readonly NextTurn: "NextTurn";
+};
+type MailboxDeliveryPhase = (typeof MailboxDeliveryPhase)[keyof typeof MailboxDeliveryPhase];
+type PendingUserInput = {
+    resolve(response: RequestUserInputResponse | null): void;
+};
+type PendingDynamicTool = {
+    resolve(response: DynamicToolResponse | null): void;
+};
+type PendingRequestPermissions = {
+    resolve(response: RequestPermissionsResponse | null): void;
+};
+type PendingMcpElicitation = {
+    resolve(response: McpServerElicitationResponse | null): void;
+};
+type RemovedTask = {
+    active_turn_is_empty: boolean;
+    task: RunningTask;
+};
+declare class TurnState$1 {
+    private readonly pending_user_input;
+    private readonly pending_dynamic_tools;
+    private readonly pending_request_permissions;
+    private readonly pending_mcp_elicitations;
+    private pending_input;
+    private readonly mailbox;
+    private mailbox_delivery_phase;
+    private readonly permission_grants;
+    tool_calls: number;
+    has_memory_citation: boolean;
+    token_usage_at_turn_start: TokenUsage;
+    insertPendingUserInput(key: string, pending: PendingUserInput): PendingUserInput | undefined;
+    removePendingUserInput(key: string): PendingUserInput | undefined;
+    insertPendingDynamicTool(key: string, pending: PendingDynamicTool): PendingDynamicTool | undefined;
+    removePendingDynamicTool(key: string): PendingDynamicTool | undefined;
+    insertPendingRequestPermissions(key: string, pending: PendingRequestPermissions): PendingRequestPermissions | undefined;
+    removePendingRequestPermissions(key: string): PendingRequestPermissions | undefined;
+    insertPendingMcpElicitation(serverName: string, id: McpRequestId, pending: PendingMcpElicitation): PendingMcpElicitation | undefined;
+    removePendingMcpElicitation(serverName: string, id: McpRequestId): PendingMcpElicitation | undefined;
+    recordPermissionGrant(response: RequestPermissionsResponse): void;
+    grantedPermissions(): RequestPermissionProfile[];
+    strictAutoReviewEnabled(): boolean;
+    pushPendingInput(input: UserInput): void;
+    prependPendingInput(input: UserInput[]): void;
+    takePendingInput(): UserInput[];
+    hasPendingInput(): boolean;
+    clearPending(): void;
+    cancelPending(): void;
+    sendMailboxMessage(communication: Omit<InterAgentCommunication, "seq">): number;
+    drainMailbox(): InterAgentCommunication[];
+    hasMailboxPending(): boolean;
+    hasMailboxPendingTriggerTurn(): boolean;
+    acceptMailboxDeliveryForCurrentTurn(): void;
+    acceptsMailboxDeliveryForCurrentTurn(): boolean;
+    setMailboxDeliveryPhase(phase: MailboxDeliveryPhase): void;
+}
+declare class ActiveTurn {
+    private readonly tasks;
+    readonly turn_state: TurnState$1;
+    addTask(task: RunningTask): void;
+    removeTask(sub_id: string): RemovedTask | undefined;
+    drainTasks(): RunningTask[];
+    firstTask(): RunningTask | null;
+    hasTask(sub_id: string): boolean;
+    clearPending(): void;
+    cancelPending(): void;
+    get size(): number;
+}
+
+type SessionSettingsUpdate = {
+    cwd?: string;
+    approval_policy?: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy?: SandboxPolicy;
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    model?: string;
+    effort?: ReasoningEffortConfig | null;
+    summary?: ReasoningSummaryConfig;
+    service_tier?: ServiceTier | null;
+    collaboration_mode?: CollaborationMode;
+    personality?: Personality | null;
+    environments?: TurnEnvironmentSelection[];
+    persist_environments?: boolean;
+    final_output_json_schema?: unknown;
+};
+
+type Event = {
+    id: string;
+    msg: EventMsg;
+};
+type SessionConfiguration = {
+    provider: string;
+    model: string;
+    model_info?: ModelInfo | null;
+    collaboration_mode: CollaborationMode;
+    reasoning_effort?: ReasoningEffortConfig | null;
+    reasoning_summary: ReasoningSummaryConfig;
+    service_tier?: ServiceTier | null;
+    base_instructions: BaseInstructions;
+    developer_instructions?: string | null;
+    user_instructions?: string | null;
+    personality?: Personality | null;
+    cwd: string;
+    approval_policy: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy: SandboxPolicy;
+    permission_profile: PermissionProfile;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    environments: TurnEnvironmentSelection[];
+    session_source: SessionSource;
+    dynamic_tools: DynamicToolSpec$1[];
+    tools: ToolsConfig;
+    final_output_json_schema?: unknown;
+    truncation_policy?: TruncationPolicy | null;
+};
+type SessionParams = {
+    threadId: ThreadId;
+    configuration: SessionConfiguration;
+    liveThread?: LiveThread | null;
+    idGenerator?: () => string;
+    eventSink?: (event: Event) => void;
+    now?: () => number;
+    initialHistory?: RolloutItem[] | null;
+    rolloutPath?: string | null;
+    forkedFromId?: ThreadId | null;
+    threadName?: string | null;
+    threadSource?: string | null;
+    hooks?: Hooks;
+    threadGoalStore?: ThreadGoalStore | null;
+    mcpConnectionManager?: McpConnectionManager | null;
+    agentControl?: AgentControl | null;
+};
+declare class Session {
+    readonly threadId: ThreadId;
+    readonly emittedEvents: Event[];
+    private readonly liveThread;
+    private readonly idGenerator;
+    private readonly eventSink?;
+    private readonly now;
+    private configuration;
+    private readonly rolloutPath;
+    private readonly forkedFromId;
+    private readonly threadName;
+    private readonly threadSource;
+    private readonly initialMessages;
+    private readonly hook_runtime;
+    private readonly agent_control;
+    private readonly goal_runtime;
+    private readonly mcp_connection_manager;
+    private readonly state;
+    private sessionConfiguredSent;
+    private sessionStartHooksRan;
+    private readonly idle_pending_input;
+    private readonly session_permission_grants;
+    activeTurn: ActiveTurn | null;
+    constructor(params: SessionParams);
+    private get token_info();
+    private set token_info(value);
+    private get latest_rate_limits();
+    private set latest_rate_limits(value);
+    private get reference_context_item();
+    private set reference_context_item(value);
+    private get previous_turn_settings();
+    private set previous_turn_settings(value);
+    submit(op: Op): Promise<string>;
+    submit_with_id(submission: Submission): Promise<void>;
+    insertPendingUserInput(key: string, pending: PendingUserInput): void;
+    insertPendingDynamicTool(key: string, pending: PendingDynamicTool): void;
+    insertPendingRequestPermissions(key: string, pending: PendingRequestPermissions): void;
+    steer_input(input: UserInput[], expected_turn_id?: string | null): Promise<string>;
+    inject_response_items(input: UserInput[]): Promise<boolean>;
+    prepend_pending_input(input: UserInput[]): Promise<boolean>;
+    get_pending_input(): Promise<UserInput[]>;
+    has_pending_input(): Promise<boolean>;
+    queue_response_items_for_next_turn(items: UserInput[]): Promise<void>;
+    take_queued_response_items_for_next_turn(): Promise<UserInput[]>;
+    collaboration_mode(): CollaborationMode;
+    granted_session_permissions(): RequestPermissionProfile[];
+    hooks(): Hooks;
+    agentControl(): AgentControl;
+    configure_session(initialMessages?: EventMsg[] | null): Promise<void>;
+    strict_auto_review_enabled_for_turn(): boolean;
+    request_user_input(turnContext: TurnContext, callId: string, args: NormalizedRequestUserInputArgs): Promise<RequestUserInputResponse | null>;
+    request_permissions(turnContext: TurnContext, callId: string, args: RequestPermissionsArgs): Promise<RequestPermissionsResponse | null>;
+    refresh_mcp_servers_now(turnContext: TurnContext, config: McpServerRefreshConfig, environment?: McpRuntimeEnvironment): Promise<void>;
+    refresh_mcp_servers_if_requested(turnContext: TurnContext, config?: McpServerRefreshConfig | null): Promise<void>;
+    list_mcp_server_statuses(): Promise<McpServerStatus[]>;
+    list_mcp_tools(): Promise<McpToolInfo[]>;
+    list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
+    list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
+    read_resource(_paramsTurnContext: TurnContext | null, params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    call_tool(turnContext: TurnContext, params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    resolve_mcp_tool_info(toolName: string): Promise<McpToolInfo | null>;
+    request_mcp_server_elicitation(turnContext: TurnContext, serverName: string, id: McpRequestId, request: McpServerElicitationRequest): Promise<McpServerElicitationResponse | null>;
+    request_dynamic_tool(turnContext: TurnContext, callId: string, toolName: string, argumentsValue: unknown): Promise<DynamicToolResponse | null>;
+    startTurn(submission: Submission): Promise<TurnContext>;
+    startCompactTurn(submission: Submission): Promise<TurnContext>;
+    start_task(input: {
+        turnContext: TurnContext;
+        task?: SessionTask;
+        kind?: TaskKind;
+        abortController?: AbortController;
+    }): Promise<RunningTask>;
+    spawn_task(input: {
+        turnContext: TurnContext;
+        task: SessionTask;
+        input: UserInput[];
+        abortController?: AbortController;
+    }): Promise<SessionTaskResult>;
+    recordCompactedItem(item: CompactedItem): Promise<void>;
+    record_into_history(turnContext: TurnContext, items: readonly ResponseItem[]): void;
+    record_conversation_items(turnContext: TurnContext, items: readonly ResponseItem[]): Promise<void>;
+    completeTurn(turnContext: TurnContext, lastAgentMessage?: string | null): Promise<void>;
+    on_task_finished(turnContext: TurnContext, result: SessionTaskResult): Promise<void>;
+    failTurn(turnContext: TurnContext, error: unknown): Promise<void>;
+    abortActiveTurn(reason?: "interrupted"): Promise<void>;
+    abort_all_tasks(reason?: "interrupted"): Promise<void>;
+    markFirstToken(turnContext: TurnContext): void;
+    update_token_usage_info(turnContext: TurnContext, tokenUsage?: TokenUsage | null): Promise<void>;
+    update_rate_limits(turnContext: TurnContext, newRateLimits: RateLimitSnapshot): Promise<void>;
+    token_usage_info(): TokenUsageInfo | null;
+    clone_history(): ContextManager;
+    replace_history(items: ResponseItem[], referenceContextItem?: TurnContextItem | null): void;
+    replace_compacted_history(turnContext: TurnContext, items: ResponseItem[], referenceContextItem?: TurnContextItem | null): Promise<void>;
+    get_total_token_usage_breakdown(): TotalTokenUsageBreakdown;
+    get_total_token_usage(): number;
+    get_thread_goal(): Promise<ThreadGoal | null>;
+    create_thread_goal(turnContext: TurnContext, request: CreateGoalRequest): Promise<ThreadGoal>;
+    update_thread_goal_complete(turnContext: TurnContext): Promise<ThreadGoal>;
+    note_tool_completed(turnContext: TurnContext, toolName: string): Promise<void>;
+    thread_goal_steering_items(): Promise<ResponseItem[]>;
+    latest_rate_limit_snapshot(): RateLimitSnapshot | null;
+    private send_token_count_event;
+    private send_thread_goal_update_if_needed;
+    private send_thread_goal_updated;
+    private userInputOrTurn;
+    private createTurnContext;
+    new_turn_with_sub_id(submissionId: string, updates: SessionSettingsUpdate, trace?: Submission["trace"]): Promise<TurnContext>;
+    new_default_turn_with_sub_id(submissionId: string, trace?: Submission["trace"]): Promise<TurnContext>;
+    turn_context_from_config(config: ResolvedConfig, submissionId: string, trace?: Submission["trace"]): TurnContext;
+    private turnContextFromConfiguration;
+    private overrideTurnContext;
+    private sessionSettingsUpdateFromOp;
+    private notifyUserInputResponse;
+    notify_request_permissions_response(callId: string, response: RequestPermissionsResponse): void;
+    resolve_elicitation(serverName: string, id: McpRequestId, response: McpServerElicitationResponse): Promise<void>;
+    private record_granted_request_permissions;
+    notify_dynamic_tool_response(callId: string, response: DynamicToolResponse): void;
+    private setThreadMemoryMode;
+    private shutdown;
+    private interrupt;
+    private threadRollback;
+    private compactWithoutModel;
+    send_event(turnContext: TurnContext, msg: EventMsg): Promise<void>;
+    recordResponseItem(turnContext: TurnContext, item: ResponseItem): Promise<void>;
+    record_context_updates_and_set_reference_context_item(turnContext: TurnContext): Promise<void>;
+    send_event_raw(event: Event): Promise<void>;
+    private deliver_event_raw;
+    private persist_rollout_items;
+}
+
+type WebSearchMode = "disabled" | "cached" | "live";
+type WebSearchToolType = "text" | "text_and_image";
+type WebSearchConfig = {
+    filters?: unknown;
+    user_location?: unknown;
+    search_context_size?: unknown;
+};
+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;
+};
+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;
+};
+
+type TurnTimingSnapshot = {
+    completed_at: number;
+    duration_ms: number;
+    time_to_first_token_ms: number | null;
+};
+declare class TurnTimingState {
+    private started_at_ms;
+    private first_token_at_ms;
+    markTurnStarted(now: number): number;
+    markFirstToken(now: number): void;
+    completedAtAndDuration(now: number): TurnTimingSnapshot;
+}
+
+type TurnContextParams = {
+    sub_id: string;
+    trace?: W3cTraceContext;
+    cwd: string;
+    current_date?: string;
+    timezone?: string;
+    approval_policy: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy: SandboxPolicy;
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    model: string;
+    model_info?: ModelInfo | null;
+    personality?: Personality | null;
+    collaboration_mode?: CollaborationMode | null;
+    effort?: ReasoningEffortConfig | null;
+    summary: ReasoningSummaryConfig;
+    service_tier?: ServiceTier | null;
+    session_source: SessionSource;
+    environments: TurnEnvironmentSelection[];
+    base_instructions?: string | null;
+    user_instructions?: string | null;
+    developer_instructions?: string | null;
+    final_output_json_schema?: unknown;
+    truncation_policy?: TruncationPolicy | null;
+    dynamic_tools: DynamicToolSpec$1[];
+    tools: ToolsConfig;
+};
+declare class TurnContext {
+    readonly sub_id: string;
+    readonly trace_id?: string;
+    readonly cwd: string;
+    readonly current_date?: string;
+    readonly timezone?: string;
+    readonly approval_policy: AskForApproval;
+    readonly approvals_reviewer?: ApprovalsReviewer | null;
+    readonly sandbox_policy: SandboxPolicy;
+    readonly permission_profile?: PermissionProfile | null;
+    readonly active_permission_profile?: ActivePermissionProfile | null;
+    readonly windows_sandbox_level?: WindowsSandboxLevel | null;
+    readonly model: string;
+    readonly model_info: ModelInfo;
+    readonly personality?: Personality | null;
+    readonly collaboration_mode?: CollaborationMode | null;
+    readonly effort?: ReasoningEffortConfig | null;
+    readonly summary: ReasoningSummaryConfig;
+    readonly service_tier?: ServiceTier | null;
+    readonly session_source: SessionSource;
+    readonly environments: TurnEnvironmentSelection[];
+    readonly base_instructions?: string | null;
+    readonly user_instructions?: string | null;
+    readonly developer_instructions?: string | null;
+    readonly final_output_json_schema?: unknown;
+    readonly truncation_policy?: TruncationPolicy | null;
+    readonly dynamic_tools: DynamicToolSpec$1[];
+    readonly tools: ToolsConfig;
+    readonly turn_timing_state: TurnTimingState;
+    constructor(params: TurnContextParams);
+    toTurnContextItem(): TurnContextItem;
+    effectivePermissionProfile(): PermissionProfile;
+    effectiveSandboxPolicy(): SandboxPolicy;
+    model_context_window(): number | null;
+    auto_compact_token_limit(): number | null;
+    effectiveReasoningEffort(): ReasoningEffortConfig | null;
+}
+
+type Prompt = {
+    input: ResponseItem[];
+    tools: ToolSpec[];
+    parallel_tool_calls: boolean;
+    base_instructions: BaseInstructions;
+};
+type ResponseEvent = {
+    type: "created";
+} | {
+    type: "output_text_delta";
+    item_id?: string;
+    delta: string;
+} | {
+    type: "tool_call_input_delta";
+    item_id: string;
+    call_id?: string | null;
+    delta: string;
+} | {
+    type: "reasoning_summary_delta";
+    delta: string;
+    summary_index: number;
+} | {
+    type: "reasoning_content_delta";
+    delta: string;
+    content_index: number;
+} | {
+    type: "reasoning_summary_part_added";
+    summary_index: number;
+} | {
+    type: "output_item_added";
+    item: ResponseItem;
+} | {
+    type: "output_item_done";
+    item: ResponseItem;
+} | {
+    type: "server_model";
+    model: string;
+} | {
+    type: "model_verifications";
+    model_verifications: unknown[];
+} | {
+    type: "server_reasoning_included";
+    reasoning_included: boolean;
+} | {
+    type: "completed";
+    response_id: string;
+    token_usage?: TokenUsage | null;
+    end_turn?: boolean | null;
+} | {
+    type: "rate_limits";
+    rate_limits: RateLimitSnapshot;
+} | {
+    type: "models_etag";
+    etag: string;
+};
+type ResponseStream = AsyncIterable<ResponseEvent> & {
+    upstream_request_id?: string | null;
+};
+type TurnState = {
+    get(): string | null;
+    set(value: string): void;
+};
+type ResponsesApiRequest = {
+    model: string;
+    instructions: string;
+    input: ResponseItem[];
+    tools: unknown[];
+    tool_choice: string;
+    parallel_tool_calls: boolean;
+    reasoning: unknown | null;
+    store: boolean;
+    stream: true;
+    include: string[];
+    service_tier?: string;
+    prompt_cache_key?: string;
+    text?: unknown;
+    client_metadata?: Record<string, string>;
+};
+type ResponseCreateWsRequest = Omit<ResponsesApiRequest, "stream"> & {
+    stream: true;
+    previous_response_id?: string;
+    generate?: boolean;
+};
+type ResponseProcessedWsRequest = {
+    response_id: string;
+};
+type ResponsesWsRequest = ({
+    type: "response.create";
+} & ResponseCreateWsRequest) | ({
+    type: "response.processed";
+} & ResponseProcessedWsRequest);
+
+type Compression = "none" | "zstd";
+type ResponsesOptions = {
+    signal?: AbortSignal;
+    thread_id?: string | null;
+    session_id?: string | null;
+    session_source?: SessionSource | string | null;
+    extra_headers?: HeadersInit;
+    compression?: Compression;
+    turn_state?: TurnState | null;
+};
+type ResponsesClientInput = {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+};
+declare class ResponsesClient {
+    private readonly input;
+    private readonly fetcher;
+    constructor(input: ResponsesClientInput);
+    stream_request(request: ResponsesApiRequest, options?: ResponsesOptions): Promise<ResponseStream>;
+    streamRequest(request: ResponsesApiRequest, options?: ResponsesOptions): Promise<ResponseStream>;
+}
+
+type FetchLike$1 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type WorkerWebSocket = WebSocket & {
+    accept?: (options?: unknown) => void;
+    binaryType?: BinaryType;
+};
+type ResponsesWebsocketClientInput = {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    fetch?: FetchLike$1;
+};
+declare class WsStream {
+    private readonly socket;
+    private readonly queued;
+    private readonly waiters;
+    private closed;
+    constructor(socket: WorkerWebSocket);
+    is_closed(): boolean;
+    send(message: string): void;
+    close(): void;
+    next(timeoutMs?: number | null): Promise<MessageEvent | CloseEvent | ErrorEvent>;
+    private push;
+}
+declare class ResponsesWebsocketConnection {
+    private readonly input;
+    private lock;
+    private streamClosed;
+    constructor(input: {
+        stream: WsStream;
+        idle_timeout_ms?: number | null;
+        server_reasoning_included?: boolean;
+        models_etag?: string | null;
+        server_model?: string | null;
+    });
+    is_closed(): Promise<boolean>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream_request(request: ResponsesWsRequest, connection_reused: boolean): Promise<ResponseStream>;
+    close(): void;
+    private initialEvents;
+    private runWebsocketResponseStream;
+    private withExclusiveStream;
+}
+declare class ResponsesWebsocketClient {
+    private readonly input;
+    private readonly fetcher;
+    constructor(input: ResponsesWebsocketClientInput);
+    connect(extra_headers?: HeadersInit, default_headers?: HeadersInit, turn_state?: TurnState | null): Promise<ResponsesWebsocketConnection>;
+}
+
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type CreateModelClientInput = {
+    apiKey: string;
+    baseUrl?: string;
+    chatgptAccountId?: string | null;
+    fedramp?: boolean;
+    fetch?: FetchLike;
+    provider?: ModelProvider;
+    sessionId: string;
+    threadId: ThreadId | string;
+    installationId: string;
+    includeTimingMetrics?: boolean;
+    betaFeaturesHeader?: string | null;
+};
+type ModelClientSessionHandle = {
+    prewarm_websocket(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<void>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<ResponseStream>;
+    release(): void;
+};
+type ModelClient = {
+    new_session(turn?: TurnContext): ModelClientSessionHandle;
+    responses_websocket_enabled(): boolean;
+    force_http_fallback(): boolean;
+};
+declare function createModelClient(input: CreateModelClientInput): ModelClient;
+type LastResponse = {
+    response_id: string;
+    items_added: ResponseItem[];
+};
+type WebsocketSession = {
+    connection: ResponsesWebsocketConnection | null;
+    last_request: ResponsesApiRequest | null;
+    last_response: LastResponse | null;
+    connection_reused: boolean;
+};
+declare class CodexModelClient implements ModelClient {
+    private readonly provider;
+    private readonly runtime;
+    private readonly apiKey;
+    private readonly chatgptAccountId;
+    private readonly fedramp;
+    private readonly fetcher?;
+    private readonly sessionId;
+    private readonly threadId;
+    private readonly installationId;
+    private readonly includeTimingMetrics;
+    private readonly betaFeaturesHeader;
+    private disableWebsockets;
+    private windowGeneration;
+    private cachedWebsocketSession;
+    constructor(input: CreateModelClientInput);
+    new_session(turn?: TurnContext): ModelClientSession;
+    responses_websocket_enabled(): boolean;
+    force_http_fallback(): boolean;
+    set_window_generation(windowGeneration: number): void;
+    advance_window_generation(): void;
+    current_window_id(): string;
+    stream_max_retries(): number;
+    websocket_connect_timeout_ms(): number;
+    take_cached_websocket_session(): WebsocketSession;
+    store_cached_websocket_session(websocketSession: WebsocketSession): void;
+    build_responses_request(prompt: Prompt, turn: TurnContext): ResponsesApiRequest;
+    build_responses_options(turn: TurnContext, turnState: TurnState, turnMetadataHeader?: string | null): ResponsesOptions;
+    build_websocket_headers(turn: TurnContext, turnState: TurnState, turnMetadataHeader?: string | null): Headers;
+    build_ws_client_metadata(turn: TurnContext, turnMetadataHeader?: string | null): Record<string, string>;
+    new_responses_client(): ResponsesClient;
+    new_responses_websocket_client(): ResponsesWebsocketClient;
+    private build_responses_headers;
+}
+declare class ModelClientSession {
+    private readonly client;
+    private readonly turn?;
+    private websocketSession;
+    private readonly turnState;
+    private released;
+    constructor(client: CodexModelClient, turn?: TurnContext | undefined, websocketSession?: WebsocketSession);
+    prewarm_websocket(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<void>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<ResponseStream>;
+    release(): void;
+    private stream_responses_api;
+    private stream_responses_websocket;
+    private websocket_connection;
+    private codex_client;
+    private prepare_websocket_request;
+    private get_incremental_items;
+    private reset_websocket_session;
+    private try_switch_fallback_transport;
+}
+
+type TotalTokenUsageBreakdown = {
+    last_api_response_total_tokens: number;
+    all_history_items_model_visible_bytes: number;
+    estimated_tokens_of_items_added_since_last_successful_api_response: number;
+    estimated_bytes_of_items_added_since_last_successful_api_response: number;
+};
+declare class ContextManager {
+    private items;
+    private history_version;
+    private token_info_value;
+    private reference_context_item_value;
+    static new(): ContextManager;
+    clone(): ContextManager;
+    token_info(): TokenUsageInfo | null;
+    tokenInfo(): TokenUsageInfo | null;
+    set_token_info(info: TokenUsageInfo | null): void;
+    setTokenInfo(info: TokenUsageInfo | null): void;
+    set_token_usage_full(contextWindow: number): void;
+    setTokenUsageFull(contextWindow: number): void;
+    recordItems(items: Iterable<ResponseItem>, policy?: TruncationPolicy | null): void;
+    record_items(items: Iterable<ResponseItem>, policy?: TruncationPolicy | null): void;
+    replace(items: ResponseItem[]): void;
+    rawItems(): ResponseItem[];
+    raw_items(): ResponseItem[];
+    forPrompt(inputModalities?: readonly string[] | null): ResponseItem[];
+    for_prompt(inputModalities?: readonly string[] | null): ResponseItem[];
+    historyVersion(): number;
+    history_version_value(): number;
+    estimate_token_count_with_base_instructions(baseInstructions: BaseInstructions): number;
+    setReferenceContextItem(item: TurnContextItem | null): void;
+    set_reference_context_item(item: TurnContextItem | null): void;
+    referenceContextItem(): TurnContextItem | null;
+    reference_context_item(): TurnContextItem | null;
+    dropLastNUserTurns(numTurns: number): void;
+    drop_last_n_user_turns(numTurns: number): void;
+    removeFirstItem(): void;
+    remove_first_item(): void;
+    removeLastItem(): boolean;
+    remove_last_item(): boolean;
+    replaceLastTurnImages(placeholder: string): boolean;
+    replace_last_turn_images(placeholder: string): boolean;
+    updateTokenInfo(usage: TokenUsage, modelContextWindow?: number | null): void;
+    update_token_info(usage: TokenUsage, modelContextWindow?: number | null): void;
+    getTotalTokenUsage(serverReasoningIncluded?: boolean): number;
+    get_total_token_usage(serverReasoningIncluded?: boolean): number;
+    getTotalTokenUsageBreakdown(): TotalTokenUsageBreakdown;
+    get_total_token_usage_breakdown(): TotalTokenUsageBreakdown;
+    private getNonLastReasoningItemsTokens;
+    private itemsAfterLastModelGeneratedItem;
+    private trim_pre_turn_context_updates;
+}
+
+type RuntimeSession = {
+    abortController: AbortController | null;
+    runPromise: Promise<unknown> | null;
+    session: Session;
+};
+type ProcessorEmit<Context> = (threadId: ThreadId, event: AppServerEvent, context?: Context) => Promise<void>;
+type ProcessorCreateSession<Context> = (threadId: ThreadId, params: ThreadStartParams | ThreadResumeParams | TurnStartParams | ThreadCompactStartParams, context?: Context, submission?: Submission) => Promise<Session>;
+
+type McpRequestProcessorOptions<Context> = {
+    mcpConnectionManager?: McpConnectionManager | null;
+    mcpServerOauthLogin?: (input: {
+        context?: Context;
+        params: McpServerOauthLoginParams;
+    }) => McpServerOauthLoginResponse | Promise<McpServerOauthLoginResponse>;
+    reloadMcpServers?: (input: {
+        context?: Context;
+    }) => void | Promise<void>;
+    runInBackground?: (promise: Promise<unknown>, context: {
+        context?: Context;
+    }) => void;
+    store: ThreadStore;
+};
+declare class McpRequestProcessor<Context> {
+    private readonly options;
+    constructor(options: McpRequestProcessorOptions<Context>);
+    mcpServerRefresh(_params: undefined, context?: Context): Promise<McpServerRefreshResponse>;
+    mcpServerStatusList(params: ListMcpServerStatusParams, context?: Context, request?: CodexAppServerRequestContext): Promise<ListMcpServerStatusResponse | CodexAppServerDeferredResponse>;
+    private mcpServerStatusListResponse;
+    mcpResourceRead(params: McpResourceReadParams$1, context?: Context, request?: CodexAppServerRequestContext): Promise<McpResourceReadResponse$1 | CodexAppServerDeferredResponse>;
+    private mcpResourceReadResponse;
+    mcpServerToolCall(params: McpServerToolCallParams$1, context?: Context, request?: CodexAppServerRequestContext): Promise<McpServerToolCallResponse$1 | CodexAppServerDeferredResponse>;
+    private mcpServerToolCallResponse;
+    mcpServerOauthLogin(params: McpServerOauthLoginParams, context?: Context): Promise<McpServerOauthLoginResponse>;
+    private manager;
+    private runDeferred;
+    private loadThread;
+}
+
+type CodexSessionTaskRunnerCreateModelClientInput<Context> = {
+    context?: Context;
+    session: Session;
+    threadId: ThreadId;
+};
+type CodexSessionTaskRunnerOptions<Context> = {
+    createModelClient: (input: CodexSessionTaskRunnerCreateModelClientInput<Context>) => ModelClient | Promise<ModelClient>;
+    modelClientCacheKey?: (input: CodexSessionTaskRunnerCreateModelClientInput<Context>) => string | null | undefined;
+    onRuntimeError?: (error: unknown, context: {
+        context?: Context;
+        threadId?: ThreadId;
+    }) => void;
+    runInBackground?: (promise: Promise<unknown>, context: {
+        context?: Context;
+        threadId: ThreadId;
+    }) => void;
+    store: ThreadStore;
+};
+declare class CodexSessionTaskRunner<Context> {
+    private readonly options;
+    private readonly modelClients;
+    constructor(options: CodexSessionTaskRunnerOptions<Context>);
+    startRegularTask(input: {
+        context?: Context;
+        items: UserInput[];
+        params: TurnStartParams;
+        runtimeSession: RuntimeSession;
+        submission: Submission;
+        threadId: ThreadId;
+    }): Promise<TurnContext>;
+    startCompactTask(input: {
+        context?: Context;
+        params: ThreadCompactStartParams;
+        runtimeSession: RuntimeSession;
+        submission: Submission;
+        threadId: ThreadId;
+    }): Promise<TurnContext>;
+    private spawnTask;
+    private modelClient;
+}
+
+type ThreadRequestProcessorOptions<Context> = {
+    buildCreateThreadParams?: (input: {
+        context?: Context;
+        params: ThreadStartParams;
+        threadId: ThreadId;
+    }) => CreateThreadParams | Promise<CreateThreadParams>;
+    createSession: ProcessorCreateSession<Context>;
+    emit: ProcessorEmit<Context>;
+    resolveDynamicTools?: (input: {
+        context?: Context;
+        params: ThreadStartParams;
+        threadId: ThreadId;
+    }) => DynamicToolSpec$1[] | Promise<DynamicToolSpec$1[]>;
+    sessions: Map<ThreadId, RuntimeSession>;
+    store: ThreadStore;
+    taskRunner: CodexSessionTaskRunner<Context>;
+};
+declare class ThreadRequestProcessor<Context> {
+    private readonly options;
+    constructor(options: ThreadRequestProcessorOptions<Context>);
+    threadStart(params: ThreadStartParams, context?: Context): Promise<ThreadStartResponse>;
+    threadResume(params: ThreadResumeParams, context?: Context): Promise<ThreadResumeResponse>;
+    threadCompactStart(params: ThreadCompactStartParams, context?: Context): Promise<ThreadCompactStartResponse>;
+    threadList(params: ThreadListParams): Promise<ThreadListResponse>;
+    threadRead(params: ThreadReadParams): Promise<ThreadReadResponse>;
+    threadNameSet(params: ThreadSetNameParams, context?: Context): Promise<ThreadSetNameResponse>;
+    threadArchive(params: ThreadArchiveParams, context?: Context): Promise<ThreadArchiveResponse>;
+    threadUnarchive(params: ThreadUnarchiveParams, context?: Context): Promise<ThreadUnarchiveResponse>;
+    threadMetadataUpdate(params: ThreadMetadataUpdateParams): Promise<ThreadMetadataUpdateResponse>;
+    private readThreadResponse;
+    private readThreadResponseWithHistory;
+    private createThreadParams;
+    private ensureLiveThread;
+}
+
+type TurnRequestProcessorOptions<Context> = {
+    createSession: ProcessorCreateSession<Context>;
+    onRuntimeError?: (error: unknown, context: {
+        context?: Context;
+        threadId?: ThreadId;
+    }) => void;
+    sessions: Map<ThreadId, RuntimeSession>;
+    taskRunner: CodexSessionTaskRunner<Context>;
+};
+declare class TurnRequestProcessor<Context> {
+    private readonly options;
+    constructor(options: TurnRequestProcessorOptions<Context>);
+    turnStart(params: TurnStartParams, context?: Context): Promise<TurnStartResponse>;
+    turnSteer(params: TurnSteerParams, context?: Context): Promise<TurnSteerResponse>;
+    turnInterrupt(params: TurnInterruptParams): Promise<TurnInterruptResponse>;
+    private sessionForTurn;
+}
+
+type CodexAppServerRuntimeContext = unknown;
+type CodexAppServerEventSink<Context = CodexAppServerRuntimeContext> = (event: AppServerEvent$1, context: {
+    context?: Context;
+    threadId: ThreadId;
+}) => Promise<void> | void;
+type CodexAppServerOutgoingSink<Context = CodexAppServerRuntimeContext> = (message: OutgoingMessage, context: {
+    connectionIds?: ConnectionId[];
+    context?: Context;
+    threadId?: ThreadId;
+}) => Promise<void> | void;
+type CodexAppServerRuntimeOptions<Context = CodexAppServerRuntimeContext> = {
+    buildCreateThreadParams?: (input: {
+        context?: Context;
+        params: ThreadStartParams;
+        threadId: ThreadId;
+    }) => CreateThreadParams | Promise<CreateThreadParams>;
+    buildSessionConfiguration?: (input: {
+        context?: Context;
+        params: ThreadStartParams | ThreadResumeParams | TurnStartParams | ThreadCompactStartParams;
+        thread: Awaited<ReturnType<ThreadStore["readThread"]>>;
+    }) => Partial<SessionConfiguration> | Promise<Partial<SessionConfiguration>>;
+    createModelClient: (input: {
+        context?: Context;
+        session: Session;
+        threadId: ThreadId;
+    }) => ModelClient | Promise<ModelClient>;
+    modelClientCacheKey?: (input: {
+        context?: Context;
+        session: Session;
+        threadId: ThreadId;
+    }) => string | null | undefined;
+    mcpConnectionManager?: McpConnectionManager | null;
+    mcpServerOauthLogin?: (input: {
+        context?: Context;
+        params: McpServerOauthLoginParams;
+    }) => McpServerOauthLoginResponse | Promise<McpServerOauthLoginResponse>;
+    reloadMcpServers?: (input: {
+        context?: Context;
+    }) => void | Promise<void>;
+    createSession?: (input: {
+        context?: Context;
+        eventSink: (event: Event) => void;
+        params: ThreadStartParams | ThreadResumeParams | TurnStartParams | ThreadCompactStartParams;
+        submission?: Submission;
+        threadId: ThreadId;
+    }) => Session | Promise<Session>;
+    eventSink?: CodexAppServerEventSink<Context>;
+    onRuntimeError?: (error: unknown, context: {
+        context?: Context;
+        threadId?: ThreadId;
+    }) => void;
+    runInBackground?: (promise: Promise<unknown>, context: {
+        context?: Context;
+        threadId: ThreadId;
+    }) => void;
+    runConnectionBackground?: (promise: Promise<unknown>, context: {
+        context?: Context;
+    }) => void;
+    sendOutgoingMessage?: CodexAppServerEventSink<Context>;
+    sendOutgoingTransportMessage?: CodexAppServerOutgoingSink<Context>;
+    resolveDynamicTools?: (input: {
+        context?: Context;
+        params: ThreadStartParams;
+        threadId: ThreadId;
+    }) => DynamicToolSpec$1[] | Promise<DynamicToolSpec$1[]>;
+    store: ThreadStore;
+};
+type CodexAppServerRuntime<Context = CodexAppServerRuntimeContext> = {
+    connectionClosed(connectionId: number): Promise<void>;
+    connectionInitialized(connectionId: number): void;
+    createMessageProcessor(input: {
+        connectionId: ConnectionId;
+        initialize?: (params: InitializeParams, context?: Context, session?: CodexAppServerConnectionSessionState) => Promise<InitializeResponse>;
+        initializeResponse?: InitializeResponse | (() => InitializeResponse);
+        session?: CodexAppServerConnectionSessionState;
+    }): CodexAppServerMessageProcessor<Context>;
+    methodHandlers: CodexAppServerMethodHandlers<Context>;
+    rejectServerRequest(params: {
+        error: JSONRPCErrorError$1;
+        requestId: string | number;
+        threadId: ThreadId | string;
+    }, context?: Context): Promise<void>;
+    resolveServerRequest(params: {
+        requestId: string | number;
+        result: Result$1;
+        threadId: ThreadId | string;
+    }, context?: Context): Promise<void>;
+};
+declare function createCodexAppServerRuntime<Context = CodexAppServerRuntimeContext>(options: CodexAppServerRuntimeOptions<Context>): CodexAppServerRuntime<Context>;
+
+export { type DynamicToolSpec as AppServerDynamicToolSpec, AppServerEvent$1 as AppServerEvent, ClientRequest, CodexAppServerConnectionSessionState, type CodexAppServerEventSink, CodexAppServerMessageProcessor, type CodexAppServerMessageProcessorOptions, type CodexAppServerMethodHandlers, type CodexAppServerOutgoingSink, type CodexAppServerRequestContext, CodexAppServerRequestError, type CodexAppServerRuntime, type CodexAppServerRuntimeContext, type CodexAppServerRuntimeOptions, type ConnectionId, type ConnectionOrigin, ConnectionRpcGate, ConnectionRpcGateClosedError, type CreateModelClientInput, DynamicToolSpec$1 as DynamicToolSpec, EmptyMcpConnectionManager, type Event, EventMsg, type JSONRPCError, JSONRPCErrorError$1 as JSONRPCErrorError, type JSONRPCMessage, LiveThread, McpRequestProcessor, type ModelClient, ModelClientSession, type ModelClientSessionHandle, OutgoingMessageSender, type RequestContext, RequestId, RequestSerializationQueues, type ResponseEvent, type ResponseStream, ResponsesClient, ResponsesWebsocketClient, ResponsesWebsocketConnection, Result$1 as Result, type RuntimeSession, ServerNotification, ServerRequest, StaticMcpConnectionManager, ThreadId, ThreadMemoryMode, ThreadRequestProcessor, ThreadScopedOutgoingMessageSender, ThreadStore, TurnRequestProcessor, TurnStartParams, TurnStartResponse, clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, createCodexAppServerRuntime, createModelClient, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, parseClientTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage };