@jrkropp/codex-js 0.1.1 → 0.1.3

package/dist/runtime-Cm6ml53h.d.ts

@@ -0,0 +1,528 @@
+import { C as ClientNotification } from './ClientNotification-B6-FhXQf.js';
+import { C as ClientRequest, a as CollaborationModeListParams, I as InitializeParams, M as McpResourceReadParams, b as McpServerOauthLoginParams, L as ListMcpServerStatusParams, c as McpServerToolCallParams, T as ThreadArchiveParams, d as ThreadCompactStartParams, e as ThreadListParams, f as ThreadMetadataUpdateParams, j as ThreadSetNameParams, g as ThreadReadParams, h as ThreadResumeParams, i as ThreadResumeResponse, k as ThreadStartParams, l as ThreadUnarchiveParams, m as TurnInterruptParams, n as TurnStartParams, o as TurnSteerParams } from './ThreadResumeResponse-DvmE1juU.js';
+import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
+import { a as ServerRequest, S as ServerNotification, U as UserInput } from './ServerRequest-B5cKVJjr.js';
+import { b as CollaborationModeListResponse, I as InitializeResponse, e as McpServerRefreshResponse, c as McpResourceReadResponse, d as McpServerOauthLoginResponse, L as ListMcpServerStatusResponse, f as McpServerToolCallResponse, T as ThreadArchiveResponse, g as ThreadCompactStartResponse, h as ThreadListResponse, i as ThreadMetadataUpdateResponse, k as ThreadSetNameResponse, j as ThreadReadResponse, l as ThreadStartResponse, m as ThreadUnarchiveResponse, n as TurnInterruptResponse, o as TurnStartResponse, p as TurnSteerResponse } from './TurnSteerResponse-0kBCfplh.js';
+import { h as Session, i as SteerInputErrorKind, M as McpConnectionManager, c as ModelClient, T as TurnContext, g as SessionConfiguration, b as Event } from './history-CfM-4V7b.js';
+import { T as ThreadStore } from './store-AGRxhgQ3.js';
+import { l as ThreadId, k as Submission, C as CollaborationMode, U as UserInput$1, D as DynamicToolSpec } from './protocol-mpBcYHrm.js';
+import { C as CreateThreadParams } from './types-BTeabLYr.js';
+import { A as AppServerEvent$1, J as JSONRPCErrorError$1, R as Result$1 } from './lib-nXlaKiS-.js';
+import { C as ClientRequestSerializationScope } from './common-CTyph5x8.js';
+
+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 TransportEvent = {
+    connectionId: ConnectionId;
+    origin: ConnectionOrigin;
+    type: "connection_opened";
+} | {
+    connectionId: ConnectionId;
+    type: "connection_closed";
+} | {
+    connectionId: ConnectionId;
+    message: JSONRPCMessage;
+    type: "incoming_message";
+};
+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 parseJsonRpcTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<JSONRPCMessage>;
+declare function parseJsonRpcMessage(value: unknown): ParsedTransportPayload<JSONRPCMessage>;
+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 function outgoingMessageToAppServerEvent(message: OutgoingMessage): AppServerEvent | null;
+
+declare class CodexAppServerRequestError extends Error {
+    readonly error: JSONRPCErrorError;
+    readonly status: number;
+    constructor(error: JSONRPCErrorError, status?: number);
+}
+declare function unsupportedMethodError(method: string, requestId: RequestId): JSONRPCErrorError;
+declare function errorToJsonRpcError(error: unknown): JSONRPCErrorError;
+
+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>;
+}
+declare function requestSerializationQueueKeyFromScope(connectionId: number | string, scope: ClientRequestSerializationScope): RequestSerializationQueueKey;
+
+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, context?: Context, request?: CodexAppServerRequestContext): Promise<McpResourceReadResponse | CodexAppServerDeferredResponse>;
+    mcpServerOauthLogin?(params: McpServerOauthLoginParams, context?: Context): Promise<McpServerOauthLoginResponse>;
+    mcpServerStatusList?(params: ListMcpServerStatusParams, context?: Context, request?: CodexAppServerRequestContext): Promise<ListMcpServerStatusResponse | CodexAppServerDeferredResponse>;
+    mcpServerToolCall?(params: McpServerToolCallParams, context?: Context, request?: CodexAppServerRequestContext): Promise<McpServerToolCallResponse | 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 function codexAppServerDeferredResponse(): CodexAppServerDeferredResponse;
+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;
+}
+
+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 TurnStartParamsWithClientMessageId = TurnStartParams & {
+    clientMessageId?: string;
+};
+type TurnStartParamsWithCollaborationMode = TurnStartParams & {
+    collaborationMode?: CollaborationMode;
+    collaboration_mode?: CollaborationMode;
+};
+declare function appServerUserInputToCoreUserInput(input: UserInput): UserInput$1;
+declare function threadIdFromStartParams(params: ThreadStartParams): ThreadId;
+declare function defaultId(): string;
+declare function valueOrNull<T>(value: T | null | undefined): T | null;
+declare function approvalPolicyString(value: unknown): string | null;
+declare function jsonRpcError(message: string, code: number, status: number): never;
+declare function steerErrorCode(kind: SteerInputErrorKind): number;
+
+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, context?: Context, request?: CodexAppServerRequestContext): Promise<McpResourceReadResponse | CodexAppServerDeferredResponse>;
+    private mcpResourceReadResponse;
+    mcpServerToolCall(params: McpServerToolCallParams, context?: Context, request?: CodexAppServerRequestContext): Promise<McpServerToolCallResponse | 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$1[];
+        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[] | Promise<DynamicToolSpec[]>;
+    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[] | Promise<DynamicToolSpec[]>;
+    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 { serializeJsonRpcError as $, type RequestSerializationQueueKey as A, RequestSerializationQueues as B, type CodexAppServerConnectionRequestOutcome as C, type RuntimeSession as D, ThreadScopedOutgoingMessageSender as E, type TransportEvent as F, TurnRequestProcessor as G, codexAppServerDeferredResponse as H, type InitializedConnectionSessionState as I, type JSONRPCError as J, createCodexAppServerRuntime as K, jsonRpcInternalError as L, McpRequestProcessor as M, jsonRpcInvalidRequestError as N, type OutgoingError as O, type ParsedClientTransportMessage as P, type QueuedOutgoingMessage as Q, type RequestContext as R, jsonRpcParseError as S, ThreadRequestProcessor as T, outgoingMessageToAppServerEvent as U, parseClientTransportPayload as V, parseJsonRpcMessage as W, parseJsonRpcTransportPayload as X, parseServerTransportPayload as Y, queuedOutgoingMessage as Z, requestSerializationQueueKeyFromScope as _, CodexAppServerConnectionSessionState as a, serializeJsonRpcResponse as a0, serializeOutgoingMessage as a1, type AppServerEvent as a2, CodexSessionTaskRunner as a3, type CodexSessionTaskRunnerCreateModelClientInput as a4, type CodexSessionTaskRunnerOptions as a5, type JSONRPCErrorError as a6, type McpRequestProcessorOptions as a7, type OutgoingMessageSenderOptions as a8, type OutgoingServerRequestHandle as a9, type ProcessorCreateSession as aa, type ProcessorEmit as ab, type Result as ac, type ThreadRequestProcessorOptions as ad, type TurnRequestProcessorOptions as ae, type TurnStartParamsWithClientMessageId as af, type TurnStartParamsWithCollaborationMode as ag, appServerUserInputToCoreUserInput as ah, approvalPolicyString as ai, defaultId as aj, errorToJsonRpcError as ak, jsonRpcError as al, steerErrorCode as am, threadIdFromStartParams as an, unsupportedMethodError as ao, valueOrNull as ap, type CodexAppServerDeferredResponse as b, type CodexAppServerEventSink as c, CodexAppServerMessageProcessor as d, type CodexAppServerMessageProcessorOptions as e, type CodexAppServerMethodHandlers as f, type CodexAppServerOutgoingSink as g, type CodexAppServerRequestContext as h, CodexAppServerRequestError as i, type CodexAppServerRuntime as j, type CodexAppServerRuntimeContext as k, type CodexAppServerRuntimeOptions as l, type ConnectionId as m, type ConnectionOrigin as n, type ConnectionRequestId as o, ConnectionRpcGate as p, ConnectionRpcGateClosedError as q, type JSONRPCMessage as r, type JSONRPCNotification as s, type JSONRPCRequest as t, type JSONRPCResponse as u, type OutgoingMessage as v, OutgoingMessageSender as w, type OutgoingResponse as x, type ParsedServerTransportMessage as y, type ParsedTransportPayload as z };