@jrkropp/codex-js 0.1.4 → 0.3.0

package/dist/internal/codex/app-server/src/app_server_event_mapping.d.ts

@@ -0,0 +1,5 @@
+import type { EventMsg } from "../../core/src/protocol.js";
+import { serverRequestResolvedNotification, type AppServerProtocolEvent, type EventMappingContext, type ServerRequestCoreTarget } from "../../app-server-protocol/src/protocol/event-mapping.js";
+export type { AppServerProtocolEvent, EventMappingContext, ServerRequestCoreTarget, };
+export declare function mapCoreEventToAppServerEvents(msg: EventMsg, context: EventMappingContext): AppServerProtocolEvent[];
+export { serverRequestResolvedNotification };

package/dist/internal/codex/app-server/src/connection_rpc_gate.d.ts

@@ -0,0 +1,11 @@
+export declare class ConnectionRpcGateClosedError extends Error {
+    constructor();
+}
+export declare class ConnectionRpcGate {
+    private accepting;
+    private inFlight;
+    private readonly shutdownWaiters;
+    isAccepting(): boolean;
+    run<T>(work: () => Promise<T> | T): Promise<T>;
+    shutdown(): Promise<void>;
+}

package/dist/internal/codex/app-server/src/dynamic_tools.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicToolCallResponse } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { DynamicToolResponse as CoreDynamicToolResponse } from "../../core/src/protocol/dynamic_tools.js";
+export declare function coreDynamicToolResponseFromAppServerResponse(value: unknown): CoreDynamicToolResponse;
+export declare function decodeDynamicToolCallResponse(value: unknown): DynamicToolCallResponse;
+export declare function fallbackDynamicToolCallResponse(message: string): DynamicToolCallResponse;

package/dist/internal/codex/app-server/src/message_processor.d.ts

@@ -0,0 +1,99 @@
+import type { ClientRequest, InitializeParams, InitializeResponse } from "../../app-server-protocol/schema/typescript/index.js";
+import type { CollaborationModeListParams, CollaborationModeListResponse, ListMcpServerStatusParams, ListMcpServerStatusResponse, McpResourceReadParams, McpResourceReadResponse, McpServerOauthLoginParams, McpServerOauthLoginResponse, McpServerRefreshResponse, McpServerToolCallParams, McpServerToolCallResponse, ThreadArchiveParams, ThreadArchiveResponse, ThreadCompactStartParams, ThreadCompactStartResponse, ThreadListParams, ThreadListResponse, ThreadMetadataUpdateParams, ThreadMetadataUpdateResponse, ThreadReadParams, ThreadReadResponse, ThreadResumeParams, ThreadResumeResponse, ThreadSetNameParams, ThreadSetNameResponse, ThreadStartParams, ThreadStartResponse, ThreadUnarchiveParams, ThreadUnarchiveResponse, TurnInterruptParams, TurnInterruptResponse, TurnStartParams, TurnStartResponse, TurnSteerParams, TurnSteerResponse } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import { ConnectionRpcGate } from "./connection_rpc_gate.js";
+import { RequestSerializationQueues } from "./request_serialization.js";
+import type { ConnectionId, ConnectionRequestId, JSONRPCErrorError, OutgoingMessageSender } from "./outgoing_message.js";
+export type CodexAppServerRequestContext = {
+    connectionId: ConnectionId;
+    outgoing: OutgoingMessageSender;
+    requestId: ConnectionRequestId;
+    session: CodexAppServerConnectionSessionState;
+};
+export 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>;
+};
+export type InitializedConnectionSessionState = {
+    appServerClientName: string;
+    clientVersion: string;
+    experimentalApiEnabled: boolean;
+    optedOutNotificationMethods: ReadonlySet<string>;
+};
+export type CodexAppServerConnectionSnapshot = {
+    initialized: InitializedConnectionSessionSnapshot | null;
+};
+export type InitializedConnectionSessionSnapshot = {
+    appServerClientName: string;
+    clientVersion: string;
+    experimentalApiEnabled: boolean;
+    optedOutNotificationMethods: string[];
+};
+export 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;
+    snapshot(): CodexAppServerConnectionSnapshot;
+    static fromSnapshot(snapshot?: CodexAppServerConnectionSnapshot | null): CodexAppServerConnectionSessionState;
+}
+export type CodexAppServerMessageProcessorOptions<Context = unknown> = {
+    connectionId?: ConnectionId;
+    handlers: CodexAppServerMethodHandlers<Context>;
+    initializeResponse?: InitializeResponse | (() => InitializeResponse);
+    outgoing?: OutgoingMessageSender;
+    requestSerializationQueues?: RequestSerializationQueues;
+    session?: CodexAppServerConnectionSessionState;
+};
+export type CodexAppServerConnectionRequestOutcome = {
+    result: unknown;
+    type: "response";
+} | {
+    type: "deferred";
+} | {
+    error: JSONRPCErrorError;
+    type: "error";
+};
+export type CodexAppServerDeferredResponse = {
+    readonly __codexAppServerDeferredResponse: true;
+};
+export declare function codexAppServerDeferredResponse(): CodexAppServerDeferredResponse;
+export 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;
+}

package/dist/internal/codex/app-server/src/outgoing_message.d.ts

@@ -0,0 +1,73 @@
+import type { RequestId, ServerNotification, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+import type { ConnectionId, JSONRPCErrorError, OutgoingMessage, Result } from "../../app-server-transport/src/outgoing_message.js";
+import type { ThreadId } from "../../core/src/ids.js";
+export type { ConnectionId, JSONRPCErrorError, OutgoingError, OutgoingMessage, OutgoingResponse, QueuedOutgoingMessage, Result, } from "../../app-server-transport/src/outgoing_message.js";
+export type AppServerEvent = {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    skipped: number;
+    type: "lagged";
+} | {
+    message: string;
+    type: "disconnected";
+};
+export type ConnectionRequestId = {
+    connectionId: ConnectionId;
+    requestId: RequestId;
+};
+export type RequestContext = {
+    connectionId: ConnectionId;
+    requestId: RequestId;
+};
+export type OutgoingServerRequestHandle = {
+    request: ServerRequest;
+    result: Promise<Result>;
+};
+export type OutgoingMessageSenderOptions = {
+    send: (message: OutgoingMessage, context: {
+        connectionIds?: ConnectionId[];
+        context?: unknown;
+        threadId?: ThreadId;
+    }) => Promise<void> | void;
+};
+export 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;
+}
+export 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[];
+}
+export declare function outgoingMessageToAppServerEvent(message: OutgoingMessage): AppServerEvent | null;

package/dist/internal/codex/app-server/src/request_processors/common.d.ts

@@ -0,0 +1,25 @@
+import { SteerInputErrorKind, type Session, type Submission, type ThreadId, type UserInput as CoreUserInput } from "../../../core/src/index.js";
+import type { CollaborationMode } from "../../../core/src/config-types.js";
+import type { ThreadCompactStartParams, ThreadResumeParams, ThreadStartParams, TurnStartParams, UserInput } from "../../../app-server-protocol/schema/typescript/v2/index.js";
+import type { AppServerEvent } from "../outgoing_message.js";
+export type RuntimeSession = {
+    abortController: AbortController | null;
+    runPromise: Promise<unknown> | null;
+    session: Session;
+};
+export type ProcessorEmit<Context> = (threadId: ThreadId, event: AppServerEvent, context?: Context) => Promise<void>;
+export type ProcessorCreateSession<Context> = (threadId: ThreadId, params: ThreadStartParams | ThreadResumeParams | TurnStartParams | ThreadCompactStartParams, context?: Context, submission?: Submission) => Promise<Session>;
+export type TurnStartParamsWithClientMessageId = TurnStartParams & {
+    clientMessageId?: string;
+};
+export type TurnStartParamsWithCollaborationMode = TurnStartParams & {
+    collaborationMode?: CollaborationMode;
+    collaboration_mode?: CollaborationMode;
+};
+export declare function appServerUserInputToCoreUserInput(input: UserInput): CoreUserInput;
+export declare function threadIdFromStartParams(params: ThreadStartParams): ThreadId;
+export declare function defaultId(): string;
+export declare function valueOrNull<T>(value: T | null | undefined): T | null;
+export declare function approvalPolicyString(value: unknown): string | null;
+export declare function jsonRpcError(message: string, code: number, status: number): never;
+export declare function steerErrorCode(kind: SteerInputErrorKind): number;

package/dist/internal/codex/app-server/src/request_processors/mcp_processor.d.ts

@@ -0,0 +1,32 @@
+import type { McpResourceReadParams, McpResourceReadResponse, McpServerOauthLoginParams, McpServerOauthLoginResponse, McpServerRefreshResponse, McpServerToolCallParams, McpServerToolCallResponse, ListMcpServerStatusParams, ListMcpServerStatusResponse } from "../../../app-server-protocol/schema/typescript/v2/index.js";
+import { type McpConnectionManager, type ThreadStore } from "../../../core/src/index.js";
+import { type CodexAppServerDeferredResponse, type CodexAppServerRequestContext } from "../message_processor.js";
+export 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;
+};
+export 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;
+}

package/dist/internal/codex/app-server/src/request_processors/request_errors.d.ts

@@ -0,0 +1,9 @@
+import type { RequestId } from "../../../app-server-protocol/schema/typescript/index.js";
+import type { JSONRPCErrorError } from "../outgoing_message.js";
+export declare class CodexAppServerRequestError extends Error {
+    readonly error: JSONRPCErrorError;
+    readonly status: number;
+    constructor(error: JSONRPCErrorError, status?: number);
+}
+export declare function unsupportedMethodError(method: string, requestId: RequestId): JSONRPCErrorError;
+export declare function errorToJsonRpcError(error: unknown): JSONRPCErrorError;

package/dist/internal/codex/app-server/src/request_processors/thread_processor.d.ts

@@ -0,0 +1,38 @@
+import { type CreateThreadParams, type DynamicToolSpec, type ThreadId, type ThreadStore } from "../../../core/src/index.js";
+import type { ThreadArchiveParams, ThreadArchiveResponse, ThreadCompactStartParams, ThreadCompactStartResponse, ThreadListParams, ThreadListResponse, ThreadMetadataUpdateParams, ThreadMetadataUpdateResponse, ThreadReadParams, ThreadReadResponse, ThreadResumeParams, ThreadResumeResponse, ThreadSetNameParams, ThreadSetNameResponse, ThreadStartParams, ThreadStartResponse, ThreadUnarchiveParams, ThreadUnarchiveResponse } from "../../../app-server-protocol/schema/typescript/v2/index.js";
+import type { CodexSessionTaskRunner } from "../session_task_runner.js";
+import { type ProcessorCreateSession, type ProcessorEmit, type RuntimeSession } from "./common.js";
+export 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>;
+};
+export 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;
+}

package/dist/internal/codex/app-server/src/request_processors/token_usage_replay.d.ts

@@ -0,0 +1,22 @@
+import type { ServerNotification } from "../../../app-server-protocol/schema/typescript/index.js";
+import type { Thread, Turn } from "../../../app-server-protocol/schema/typescript/v2/index.js";
+import type { ThreadId } from "../../../core/src/ids.js";
+import type { RolloutItem, TokenUsageInfo } from "../../../core/src/protocol.js";
+export type TokenUsageTurnOwner = {
+    id: string;
+    position: number | null;
+};
+export declare function latest_token_usage_turn_id_from_rollout_items(rolloutItems: readonly RolloutItem[], turns: readonly Turn[]): string | null;
+export declare function latest_token_usage_turn_id(thread: Thread): string;
+export declare function last_token_info_from_rollout_items(rolloutItems: readonly RolloutItem[]): TokenUsageInfo | null;
+export declare function thread_token_usage_updated_notification_from_info(input: {
+    thread: Thread;
+    threadId: ThreadId | string;
+    tokenUsageInfo: TokenUsageInfo;
+    tokenUsageTurnId?: string | null;
+}): ServerNotification;
+export declare function thread_token_usage_updated_notification_from_rollout_items(input: {
+    rolloutItems: readonly RolloutItem[];
+    thread: Thread;
+    threadId: ThreadId | string;
+}): ServerNotification | null;

package/dist/internal/codex/app-server/src/request_processors/turn_processor.d.ts

@@ -0,0 +1,21 @@
+import { type ThreadId } from "../../../core/src/index.js";
+import type { TurnInterruptParams, TurnInterruptResponse, TurnStartParams, TurnStartResponse, TurnSteerParams, TurnSteerResponse } from "../../../app-server-protocol/schema/typescript/v2/index.js";
+import type { CodexSessionTaskRunner } from "../session_task_runner.js";
+import { type ProcessorCreateSession, type RuntimeSession } from "./common.js";
+export type TurnRequestProcessorOptions<Context> = {
+    createSession: ProcessorCreateSession<Context>;
+    onRuntimeError?: (error: unknown, context: {
+        context?: Context;
+        threadId?: ThreadId;
+    }) => void;
+    sessions: Map<ThreadId, RuntimeSession>;
+    taskRunner: CodexSessionTaskRunner<Context>;
+};
+export 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;
+}

package/dist/internal/codex/app-server/src/request_processors.d.ts

@@ -0,0 +1,5 @@
+export * from "./request_processors/common.js";
+export * from "./request_processors/mcp_processor.js";
+export * from "./request_processors/request_errors.js";
+export * from "./request_processors/thread_processor.js";
+export * from "./request_processors/turn_processor.js";

package/dist/internal/codex/app-server/src/request_serialization.d.ts

@@ -0,0 +1,7 @@
+import type { ClientRequestSerializationScope } from "../../app-server-protocol/src/protocol/index.js";
+export type RequestSerializationQueueKey = string;
+export declare class RequestSerializationQueues {
+    private readonly tails;
+    enqueue<T>(key: RequestSerializationQueueKey, work: () => Promise<T> | T): Promise<T>;
+}
+export declare function requestSerializationQueueKeyFromScope(connectionId: number | string, scope: ClientRequestSerializationScope): RequestSerializationQueueKey;

package/dist/internal/codex/app-server/src/runtime.d.ts

@@ -0,0 +1,96 @@
+import { Session, type CreateThreadParams, type DynamicToolSpec, type Event, type McpConnectionManager, type SessionConfiguration, type Submission, type ThreadId, type ThreadStore } from "../../core/src/index.js";
+import { type ModelClient } from "../../core/src/index.js";
+import type { AppServerEvent, JSONRPCErrorError, Result } from "../../app-server-client/src/lib.js";
+import { type ConnectionId, type OutgoingMessage } from "./outgoing_message.js";
+import type { ThreadCompactStartParams, McpServerOauthLoginParams, McpServerOauthLoginResponse, ThreadResumeParams, ThreadStartParams, TurnStartParams } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import { CodexAppServerConnectionSessionState, CodexAppServerMessageProcessor, type CodexAppServerMethodHandlers } from "./message_processor.js";
+import type { InitializeParams, InitializeResponse } from "../../app-server-protocol/schema/typescript/index.js";
+export type CodexAppServerRuntimeContext = unknown;
+export type CodexAppServerEventSink<Context = CodexAppServerRuntimeContext> = (event: AppServerEvent, context: {
+    context?: Context;
+    threadId: ThreadId;
+}) => Promise<void> | void;
+export type CodexAppServerOutgoingSink<Context = CodexAppServerRuntimeContext> = (message: OutgoingMessage, context: {
+    connectionIds?: ConnectionId[];
+    context?: Context;
+    threadId?: ThreadId;
+}) => Promise<void> | void;
+export 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;
+};
+export 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;
+        requestId: string | number;
+        threadId: ThreadId | string;
+    }, context?: Context): Promise<void>;
+    resolveServerRequest(params: {
+        requestId: string | number;
+        result: Result;
+        threadId: ThreadId | string;
+    }, context?: Context): Promise<void>;
+};
+export declare function createCodexAppServerRuntime<Context = CodexAppServerRuntimeContext>(options: CodexAppServerRuntimeOptions<Context>): CodexAppServerRuntime<Context>;

package/dist/internal/codex/app-server/src/server_request_response.d.ts

@@ -0,0 +1,30 @@
+import type { RequestId, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+import type { Submission } from "../../core/src/protocol.js";
+import type { JSONRPCErrorError } from "../../app-server-client/src/lib.js";
+export type ServerRequestResponseTarget = {
+    responseId: string;
+    type: "user_input";
+} | {
+    callId: string;
+    type: "request_permissions";
+} | {
+    callId: string;
+    type: "dynamic_tool";
+} | {
+    requestId: string | number;
+    serverName: string;
+    type: "mcp_elicitation";
+};
+export declare function submissionFromServerRequestResult(input: {
+    request: ServerRequest | null;
+    requestId: RequestId;
+    result: unknown;
+    target?: ServerRequestResponseTarget | null;
+}): Submission;
+export declare function submissionFromServerRequestError(input: {
+    error: JSONRPCErrorError;
+    request: ServerRequest | null;
+    requestId: RequestId;
+    target?: ServerRequestResponseTarget | null;
+}): Submission;
+export declare function isServerRequestResponseSubmission(submission: Submission): boolean;

package/dist/internal/codex/app-server/src/session_factory.d.ts

@@ -0,0 +1,30 @@
+import { Session, type Event, type McpConnectionManager, type SessionConfiguration, type Submission, type ThreadId, type ThreadStore } from "../../core/src/index.js";
+import type { ThreadCompactStartParams, ThreadResumeParams, ThreadStartParams, TurnStartParams } from "../../app-server-protocol/schema/typescript/v2/index.js";
+export type CodexSessionRequestParams = ThreadStartParams | ThreadResumeParams | TurnStartParams | ThreadCompactStartParams;
+export type CodexSessionFactoryOptions<Context = unknown> = {
+    buildSessionConfiguration?: (input: {
+        context?: Context;
+        params: CodexSessionRequestParams;
+        thread: Awaited<ReturnType<ThreadStore["readThread"]>>;
+    }) => Partial<SessionConfiguration> | Promise<Partial<SessionConfiguration>>;
+    createSession?: (input: {
+        context?: Context;
+        eventSink: (event: Event) => void;
+        params: CodexSessionRequestParams;
+        submission?: Submission;
+        threadId: ThreadId;
+    }) => Session | Promise<Session>;
+    emitCoreEvent: (threadId: ThreadId, event: Event, context?: Context) => void;
+    mcpConnectionManager?: McpConnectionManager | null;
+    store: ThreadStore;
+};
+export declare class CodexSessionFactory<Context = unknown> {
+    private readonly options;
+    constructor(options: CodexSessionFactoryOptions<Context>);
+    createSession: (input: {
+        context?: Context;
+        params: CodexSessionRequestParams;
+        submission?: Submission;
+        threadId: ThreadId;
+    }) => Promise<Session>;
+}

package/dist/internal/codex/app-server/src/session_task_runner.d.ts

@@ -0,0 +1,44 @@
+import { type Session, type Submission, type ThreadId, type ThreadStore, type TurnContext, type UserInput } from "../../core/src/index.js";
+import type { ModelClient } from "../../core/src/index.js";
+import type { ThreadCompactStartParams, TurnStartParams } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { RuntimeSession } from "./request_processors/common.js";
+export type CodexSessionTaskRunnerCreateModelClientInput<Context> = {
+    context?: Context;
+    session: Session;
+    threadId: ThreadId;
+};
+export 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;
+};
+export 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;
+}

package/dist/internal/codex/app-server/src/thread_state.d.ts

@@ -0,0 +1,56 @@
+import type { RequestId } from "../../app-server-protocol/schema/typescript/index.js";
+import type { Turn } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { ThreadId } from "../../core/src/ids.js";
+import type { EventMsg } from "../../core/src/protocol.js";
+export type PendingInterruptQueue = RequestId[];
+export type PendingThreadResumeRequest = {
+    includeTurns: boolean;
+    requestId: RequestId;
+    threadId: ThreadId;
+};
+export type ThreadListenerCommand = {
+    request: PendingThreadResumeRequest;
+    type: "send_thread_resume_response";
+} | {
+    requestId: RequestId;
+    type: "resolve_server_request";
+};
+export type TurnSummary = {
+    lastError: {
+        message: string;
+    } | null;
+    startedAt: number | null;
+};
+export type ThreadStateTrackResult = {
+    activeTurn: Turn | null;
+    terminalTurn: Turn | null;
+};
+export declare class ThreadState {
+    pendingInterrupts: PendingInterruptQueue;
+    turnSummary: TurnSummary;
+    lastTerminalTurnId: string | null;
+    experimentalRawEvents: boolean;
+    listenerGeneration: number;
+    private currentTurnHistory;
+    private listenerActive;
+    setListener(): number;
+    clearListener(): void;
+    hasListener(): boolean;
+    setExperimentalRawEvents(enabled: boolean): void;
+    activeTurnSnapshot(): Turn | null;
+    trackCurrentTurnEvent(eventTurnId: string, event: EventMsg): ThreadStateTrackResult;
+}
+export declare class ThreadStateManager {
+    private readonly liveConnections;
+    private readonly threads;
+    private readonly threadIdsByConnection;
+    connectionInitialized(connectionId: number): void;
+    threadState(threadId: ThreadId): ThreadState;
+    removeThreadState(threadId: ThreadId): void;
+    clearAllListeners(): void;
+    subscribedConnectionIds(threadId: ThreadId): number[];
+    tryEnsureConnectionSubscribed(threadId: ThreadId, connectionId: number, experimentalRawEvents?: boolean): ThreadState | null;
+    unsubscribeConnectionFromThread(threadId: ThreadId, connectionId: number): boolean;
+    removeConnection(connectionId: number): ThreadId[];
+    private threadEntry;
+}