@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/internal/codex/app-server-protocol/src/protocol/event-mapping.d.ts

@@ -0,0 +1,41 @@
+import type { EventMsg, TokenUsageInfo } from "../../../core/src/protocol.js";
+import type { ServerNotification, ServerRequest } from "../../schema/typescript/index.js";
+import type { ThreadItem, ThreadTokenUsage, Turn } from "../../schema/typescript/v2/index.js";
+export type ServerRequestCoreTarget = {
+    responseId: string;
+    type: "user_input";
+} | {
+    callId: string;
+    type: "request_permissions";
+} | {
+    callId: string;
+    type: "dynamic_tool";
+} | {
+    requestId: string | number;
+    serverName: string;
+    type: "mcp_elicitation";
+};
+export type AppServerProtocolEvent = {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    coreTarget?: ServerRequestCoreTarget;
+    request: ServerRequest;
+    type: "server_request";
+};
+export type EventMappingContext = {
+    activeTurn?: Turn | null;
+    threadId: string;
+    terminalTurn?: Turn | null;
+    turnId?: string | null;
+};
+export declare function eventMsgToAppServerEvents(msg: EventMsg, context: EventMappingContext): AppServerProtocolEvent[];
+export declare function eventMsgToAppServerEvent(msg: EventMsg, context: EventMappingContext): AppServerProtocolEvent;
+export declare const eventMsgToServerProtocolEvent: typeof eventMsgToAppServerEvent;
+export declare const eventMsgToServerProtocolEvents: typeof eventMsgToAppServerEvents;
+export declare function serverRequestResolvedNotification(input: {
+    requestId: string | number;
+    threadId: string;
+}): AppServerProtocolEvent;
+export declare function threadTokenUsageFromTokenUsageInfo(info: TokenUsageInfo): ThreadTokenUsage;
+export declare function coreTurnItemToThreadItem(item: unknown): ThreadItem | null;

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

@@ -0,0 +1,3 @@
+export * from "./event-mapping.js";
+export * from "./thread-resume.js";
+export * from "./common.js";

package/dist/internal/codex/app-server-protocol/src/protocol/thread-resume.d.ts

@@ -0,0 +1,11 @@
+import type { Thread, ThreadResumeResponse, Turn } from "../../schema/typescript/v2/index.js";
+import type { StoredThread, StoredThreadHistory } from "../../../core/src/thread-store/index.js";
+import type { Turn as CoreTurn } from "../../../core/src/thread-history-builder.js";
+export type ThreadResumeSnapshotInput = {
+    history: StoredThreadHistory;
+    thread: StoredThread;
+};
+export declare function buildThreadResumeResponseFromHistory(input: ThreadResumeSnapshotInput): ThreadResumeResponse;
+export declare function threadHistoryToAppServerThread(input: ThreadResumeSnapshotInput): Thread;
+export declare function renderableHistoryFromAppServerThread(thread: Thread): StoredThreadHistory;
+export declare function appServerTurnFromCoreTurn(turn: CoreTurn): Turn;

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

@@ -0,0 +1,27 @@
+import type { RequestId, ServerNotification, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+export type JSONRPCErrorError = {
+    code: number;
+    data?: unknown;
+    message: string;
+};
+export type Result = unknown;
+export type ConnectionId = number;
+export type OutgoingResponse = {
+    id: RequestId;
+    result: Result;
+};
+export type OutgoingError = {
+    error: JSONRPCErrorError;
+    id: RequestId;
+};
+export type OutgoingMessage = ServerRequest | ServerNotification | OutgoingResponse | OutgoingError;
+export type QueuedOutgoingMessage = {
+    message: OutgoingMessage;
+    writeComplete?: () => void;
+};
+export declare const codexReference: {
+    readonly crate: "app-server-transport";
+    readonly referencePath: "app-server-transport/src/outgoing_message.rs";
+    readonly reason: "transport-level outgoing message types ported to TypeScript";
+    readonly status: "implemented";
+};

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

@@ -0,0 +1,78 @@
+import type { ClientNotification, ClientRequest, RequestId, ServerNotification, ServerRequest } from "../../../app-server-protocol/schema/typescript/index.js";
+import type { ConnectionId, JSONRPCErrorError, OutgoingMessage, QueuedOutgoingMessage, Result } from "../outgoing_message.js";
+export type ConnectionOrigin = "stdio" | "inProcess" | "webSocket" | "remoteControl";
+export type JSONRPCRequest = {
+    id: RequestId;
+    method: string;
+    params?: unknown;
+};
+export type JSONRPCNotification = {
+    method: string;
+    params?: unknown;
+};
+export type JSONRPCResponse = {
+    id: RequestId;
+    result: Result;
+};
+export type JSONRPCError = {
+    error: JSONRPCErrorError;
+    id: RequestId | null;
+};
+export type JSONRPCMessage = JSONRPCRequest | JSONRPCNotification | JSONRPCResponse | JSONRPCError;
+export type TransportEvent = {
+    connectionId: ConnectionId;
+    origin: ConnectionOrigin;
+    type: "connection_opened";
+} | {
+    connectionId: ConnectionId;
+    type: "connection_closed";
+} | {
+    connectionId: ConnectionId;
+    message: JSONRPCMessage;
+    type: "incoming_message";
+};
+export type ParsedServerTransportMessage = {
+    request: ClientRequest;
+    type: "client_request";
+} | {
+    notification: ClientNotification;
+    type: "client_notification";
+} | {
+    response: JSONRPCResponse;
+    type: "response";
+} | {
+    error: JSONRPCError;
+    type: "error";
+};
+export type ParsedClientTransportMessage = {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    response: JSONRPCResponse;
+    type: "response";
+} | {
+    error: JSONRPCError;
+    type: "error";
+};
+export type ParsedTransportPayload<T> = {
+    message: T;
+    type: "ok";
+} | {
+    error: JSONRPCErrorError;
+    id: RequestId | null;
+    type: "invalid";
+};
+export declare function parseJsonRpcTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<JSONRPCMessage>;
+export declare function parseJsonRpcMessage(value: unknown): ParsedTransportPayload<JSONRPCMessage>;
+export declare function parseServerTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<ParsedServerTransportMessage>;
+export declare function parseClientTransportPayload(payload: string | ArrayBuffer | ArrayBufferView | unknown): ParsedTransportPayload<ParsedClientTransportMessage>;
+export declare function serializeOutgoingMessage(message: OutgoingMessage): string;
+export declare function serializeJsonRpcResponse(id: RequestId, result: Result): string;
+export declare function serializeJsonRpcError(id: RequestId | null, error: JSONRPCErrorError): string;
+export declare function queuedOutgoingMessage(message: OutgoingMessage, writeComplete?: () => void): QueuedOutgoingMessage;
+export declare function jsonRpcParseError(message: string): JSONRPCErrorError;
+export declare function jsonRpcInvalidRequestError(message: string): JSONRPCErrorError;
+export declare function jsonRpcInternalError(message: string): JSONRPCErrorError;

package/dist/internal/codex/codex-api/src/common.d.ts

@@ -0,0 +1,100 @@
+import type { BaseInstructions, RateLimitSnapshot, ResponseItem, ToolSpec, TokenUsage } from "../../core/src/index.js";
+export declare const WS_REQUEST_HEADER_TRACEPARENT_CLIENT_METADATA_KEY = "ws_request_header_traceparent";
+export declare const WS_REQUEST_HEADER_TRACESTATE_CLIENT_METADATA_KEY = "ws_request_header_tracestate";
+export type Prompt = {
+    input: ResponseItem[];
+    tools: ToolSpec[];
+    parallel_tool_calls: boolean;
+    base_instructions: BaseInstructions;
+};
+export 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;
+};
+export type ResponseStream = AsyncIterable<ResponseEvent> & {
+    upstream_request_id?: string | null;
+};
+export type TurnState = {
+    get(): string | null;
+    set(value: string): void;
+};
+export 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>;
+};
+export type ResponseCreateWsRequest = Omit<ResponsesApiRequest, "stream"> & {
+    stream: true;
+    previous_response_id?: string;
+    generate?: boolean;
+};
+export type ResponseProcessedWsRequest = {
+    response_id: string;
+};
+export type ResponsesWsRequest = ({
+    type: "response.create";
+} & ResponseCreateWsRequest) | ({
+    type: "response.processed";
+} & ResponseProcessedWsRequest);
+export type W3cTraceContext = {
+    traceparent?: string | null;
+    tracestate?: string | null;
+};
+export declare function responseCreateWsRequestFromResponsesApiRequest(request: ResponsesApiRequest): ResponseCreateWsRequest;
+export declare function response_create_client_metadata(client_metadata: Record<string, string> | null | undefined, trace?: W3cTraceContext | null): Record<string, string> | undefined;

package/dist/internal/codex/codex-api/src/endpoint/responses.d.ts

@@ -0,0 +1,28 @@
+import type { ProviderRuntimeConfig, SessionSource } from "../../../core/src/index.js";
+import type { ResponsesApiRequest, ResponseStream, TurnState } from "../common.js";
+export type Compression = "none" | "zstd";
+export 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;
+};
+export 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>;
+};
+export 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>;
+}

package/dist/internal/codex/codex-api/src/endpoint/responses_websocket.d.ts

@@ -0,0 +1,54 @@
+import type { ProviderRuntimeConfig } from "../../../core/src/index.js";
+import type { ResponseStream, ResponsesWsRequest, TurnState } from "../common.js";
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type WorkerWebSocket = WebSocket & {
+    accept?: (options?: unknown) => void;
+    binaryType?: BinaryType;
+};
+export type ResponsesWebsocketClientInput = {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    fetch?: FetchLike;
+};
+export 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;
+}
+export 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;
+}
+export 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>;
+}
+export {};

package/dist/internal/codex/codex-api/src/error.d.ts

@@ -0,0 +1,21 @@
+export type ApiErrorCode = "transport" | "api" | "stream" | "context_window_exceeded" | "quota_exceeded" | "usage_not_included" | "retryable" | "rate_limit" | "invalid_request" | "cyber_policy" | "server_overloaded";
+export declare class ApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status?: number;
+    readonly delay_ms?: number | null;
+    constructor(input: {
+        code: ApiErrorCode;
+        message: string;
+        status?: number;
+        delay_ms?: number | null;
+    });
+    static transport(message: string): ApiError;
+    static api(status: number, message: string): ApiError;
+    static stream(message: string): ApiError;
+    static retryable(message: string, delay_ms?: number | null): ApiError;
+}
+export declare function apiErrorFromResponsePayload(status: number, payload: unknown): ApiError;
+export declare function apiErrorFromResponsesEvent(event: Record<string, unknown>): ApiError;
+export declare function apiErrorFromUnknown(error: unknown): ApiError;
+export declare function htmlChallengeApiError(): ApiError;
+export declare function isRetryableApiError(error: ApiError): boolean;

package/dist/internal/codex/codex-api/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./endpoint/responses.js";
+export * from "./endpoint/responses_websocket.js";
+export * from "./common.js";
+export * from "./stream_events_utils.js";
+export * from "./requests/responses.js";
+export * from "./error.js";
+export * from "./provider.js";
+export * from "./rate_limits.js";
+export * from "./sse/responses.js";

package/dist/internal/codex/codex-api/src/provider.d.ts

@@ -0,0 +1,22 @@
+import type { ProviderRuntimeConfig } from "../../core/src/index.js";
+export declare function responsesUrlWithQuery(runtime: ProviderRuntimeConfig): string;
+export declare function websocketUrlForPath(runtime: ProviderRuntimeConfig, path: string): string;
+export declare function providerRequestHeaders(input: {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    extra_headers?: HeadersInit;
+}): Headers;
+export declare function providerWebsocketHeaders(input: {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    extra_headers?: HeadersInit;
+    default_headers?: HeadersInit;
+}): Headers;

package/dist/internal/codex/codex-api/src/rate_limits.d.ts

@@ -0,0 +1,3 @@
+import type { RateLimitSnapshot } from "../../core/src/index.js";
+export declare function parseAllRateLimits(headers: Headers): RateLimitSnapshot[];
+export declare function parseRateLimitEventPayload(event: Record<string, unknown>): RateLimitSnapshot | null;

package/dist/internal/codex/codex-api/src/requests/responses.d.ts

@@ -0,0 +1,16 @@
+import type { ResponseItem, ResponseItemWire } from "../../../core/src/index.js";
+import type { ResponsesApiRequest, ResponsesWsRequest } from "../common.js";
+export type ResponsesApiWireRequest = Omit<ResponsesApiRequest, "input" | "instructions" | "service_tier" | "prompt_cache_key" | "text" | "client_metadata"> & {
+    instructions?: string;
+    input: ResponseItemWire[];
+    service_tier?: string;
+    prompt_cache_key?: string;
+    text?: unknown;
+    client_metadata?: Record<string, string>;
+    previous_response_id?: string;
+    generate?: boolean;
+};
+export declare function serializeResponsesApiRequest(request: ResponsesApiRequest): ResponsesApiWireRequest;
+export declare function serializeResponseItemForResponsesApi(item: ResponseItem): ResponseItemWire;
+export declare function attachItemIds(payloadJson: unknown, originalItems: ResponseItem[]): void;
+export declare function serializeResponsesWsRequest(request: ResponsesWsRequest): Record<string, unknown>;

package/dist/internal/codex/codex-api/src/sse/responses.d.ts

@@ -0,0 +1,13 @@
+import type { ResponseEvent, ResponseStream } from "../common.js";
+export type SpawnResponseStreamInput = {
+    headers?: Headers | null;
+    chunks: AsyncIterable<string>;
+    idle_timeout_ms?: number | null;
+    require_completed?: boolean;
+};
+export declare function spawnResponseStream(input: SpawnResponseStreamInput): ResponseStream;
+export declare function responseEventsFromSseTextChunks(chunks: AsyncIterable<string>, options?: {
+    headers?: Headers | null;
+    idle_timeout_ms?: number | null;
+    require_completed?: boolean;
+}): AsyncGenerator<ResponseEvent>;

package/dist/internal/codex/codex-api/src/stream_events_utils.d.ts

@@ -0,0 +1,23 @@
+import type { EventMsg, ResponseItem, RolloutItem, Submission, UserInput } from "../../core/src/index.js";
+export { responseInputToResponseItem } from "../../core/src/index.js";
+export declare function modelInputFromHistoryAndSubmission(history: RolloutItem[], submission: Submission): ResponseItem[];
+export declare function modelInputFromHistory(history: RolloutItem[]): ResponseItem[];
+export declare function inputFromSubmission(submission: Submission): ResponseItem[];
+export declare function userMessageEventAsResponseInput(event: EventMsg & {
+    type: "user_message";
+}): ResponseItem;
+export declare function userInputAsResponseInput(items: UserInput[]): ResponseItem;
+export declare function outputTextDeltaFromStreamEvent(event: unknown): {
+    text: string;
+    item_id?: string;
+} | null;
+export type OpenAiResponseLike = {
+    output?: unknown;
+};
+export declare function responseOutputItemsFromResponse(response: OpenAiResponseLike): ResponseItem[];
+export declare function rawAssistantOutputTextFromItem(item: ResponseItem): string | null;
+export type ProposedPlanExtraction = {
+    assistantText: string;
+    planText: string | null;
+};
+export declare function extractProposedPlanFromText(text: string): ProposedPlanExtraction;

package/dist/internal/codex/codex-mcp/src/auth_elicitation.d.ts

@@ -0,0 +1,41 @@
+export declare const MCP_TOOL_CODEX_APPS_META_KEY = "_codex_apps";
+export declare const CONNECTOR_AUTH_FAILURE_META_KEY = "connector_auth_failure";
+export declare const CONNECTOR_AUTH_FAILURE_IS_AUTH_FAILURE_KEY = "is_auth_failure";
+export declare const CONNECTOR_AUTH_FAILURE_AUTH_REASON_KEY = "auth_reason";
+export declare const CONNECTOR_AUTH_FAILURE_CONNECTOR_ID_KEY = "connector_id";
+export declare const CONNECTOR_AUTH_FAILURE_LINK_ID_KEY = "link_id";
+export declare const CONNECTOR_AUTH_FAILURE_ERROR_CODE_KEY = "error_code";
+export declare const CONNECTOR_AUTH_FAILURE_ERROR_HTTP_STATUS_CODE_KEY = "error_http_status_code";
+export declare const CONNECTOR_AUTH_FAILURE_ERROR_ACTION_KEY = "error_action";
+export type CallToolResult = {
+    content?: unknown[];
+    structured_content?: unknown;
+    is_error?: boolean | null;
+    meta?: unknown;
+};
+export type CodexAppsConnectorAuthFailure = {
+    connector_id: string;
+    connector_name: string;
+    install_url: string;
+    auth_reason?: string | null;
+    link_id?: string | null;
+    error_code?: string | null;
+    error_http_status_code?: number | null;
+    error_action?: string | null;
+};
+export type CodexAppsAuthElicitation = {
+    meta: unknown;
+    message: string;
+    url: string;
+    elicitation_id: string;
+};
+export type CodexAppsAuthElicitationPlan = {
+    auth_failure: CodexAppsConnectorAuthFailure;
+    elicitation: CodexAppsAuthElicitation;
+};
+export declare function connector_auth_failure_from_tool_result(result: CallToolResult, connector_id?: string | null, connector_name?: string | null, install_url?: string | null): CodexAppsConnectorAuthFailure | null;
+export declare function build_auth_elicitation_plan(call_id: string, result: CallToolResult, connector_id?: string | null, connector_name?: string | null, install_url?: string | null): CodexAppsAuthElicitationPlan | null;
+export declare function build_auth_elicitation(call_id: string, auth_failure: CodexAppsConnectorAuthFailure): CodexAppsAuthElicitation;
+export declare function auth_elicitation_completed_result(auth_failure: CodexAppsConnectorAuthFailure, meta?: unknown): CallToolResult;
+export declare function auth_elicitation_id(call_id: string): string;
+export declare function auth_elicitation_message(auth_failure: CodexAppsConnectorAuthFailure): string;

package/dist/internal/codex/codex-mcp/src/codex_apps.d.ts

@@ -0,0 +1,57 @@
+import type { ToolInfo } from "./tools.js";
+export declare const CODEX_APPS_TOOLS_CACHE_SCHEMA_VERSION = 2;
+export declare const CODEX_APPS_TOOLS_CACHE_DIR = "cache/codex_apps_tools";
+export type CodexAuthLike = {
+    account_id?: string | null;
+    chatgpt_user_id?: string | null;
+    is_workspace_account?: boolean | (() => boolean | null | undefined) | null;
+    get_account_id?: () => string | null | undefined;
+    get_chatgpt_user_id?: () => string | null | undefined;
+};
+export type CodexAppsToolsCacheKey = {
+    account_id?: string | null;
+    chatgpt_user_id?: string | null;
+    is_workspace_account: boolean;
+};
+export declare function codex_apps_tools_cache_key(auth?: CodexAuthLike | null): CodexAppsToolsCacheKey;
+export declare function filter_non_codex_apps_mcp_tools_only(mcpTools: ReadonlyMap<string, ToolInfo> | Record<string, ToolInfo>): Map<string, ToolInfo>;
+export type CodexAppsToolsCacheStorage = {
+    read(path: string): string | Uint8Array | null | undefined;
+    write(path: string, bytes: string): void;
+};
+export declare class InMemoryCodexAppsToolsCacheStorage implements CodexAppsToolsCacheStorage {
+    private readonly files;
+    read(path: string): string | null;
+    write(path: string, bytes: string): void;
+}
+export declare class CodexAppsToolsCacheContext {
+    readonly codex_home: string;
+    readonly user_key: CodexAppsToolsCacheKey;
+    readonly storage: CodexAppsToolsCacheStorage | null;
+    constructor(codex_home: string, user_key: CodexAppsToolsCacheKey, storage?: CodexAppsToolsCacheStorage | null);
+    cache_path(): string;
+}
+export type CachedCodexAppsToolsLoad = {
+    type: "Hit";
+    tools: ToolInfo[];
+} | {
+    type: "Missing";
+} | {
+    type: "Invalid";
+};
+export declare const CachedCodexAppsToolsLoad: {
+    readonly Hit: (tools: ToolInfo[]) => CachedCodexAppsToolsLoad;
+    readonly Missing: CachedCodexAppsToolsLoad;
+    readonly Invalid: CachedCodexAppsToolsLoad;
+};
+export declare function normalize_codex_apps_tool_title(server_name: string, connector_name: string | null | undefined, value: string): string;
+export declare function normalize_codex_apps_callable_name(server_name: string, tool_name: string, connector_id?: string | null, connector_name?: string | null): string;
+export declare function normalize_codex_apps_callable_namespace(server_name: string, connector_name?: string | null): string;
+export declare function write_cached_codex_apps_tools_if_needed(server_name: string, cache_context: CodexAppsToolsCacheContext | null | undefined, tools: readonly ToolInfo[]): void;
+export declare function load_startup_cached_codex_apps_tools_snapshot(server_name: string, cache_context: CodexAppsToolsCacheContext | null | undefined): ToolInfo[] | null;
+export declare function read_cached_codex_apps_tools(cache_context: CodexAppsToolsCacheContext): ToolInfo[] | null;
+export declare function load_cached_codex_apps_tools(cache_context: CodexAppsToolsCacheContext): CachedCodexAppsToolsLoad;
+export declare function write_cached_codex_apps_tools(cache_context: CodexAppsToolsCacheContext, tools: readonly ToolInfo[]): void;
+export declare function filter_disallowed_codex_apps_tools(tools: ToolInfo[]): ToolInfo[];
+export declare function sanitize_name(name: string): string;
+export declare function is_connector_id_allowed(connector_id: string, first_party_chat_originator?: boolean): boolean;

package/dist/internal/codex/codex-mcp/src/connection_manager.d.ts

@@ -0,0 +1,72 @@
+import { ToolPluginProvenance } from "./mcp/mod.js";
+import { ElicitationRequestManager, type ElicitationResponse } from "./elicitation.js";
+import type { McpAuthStatusEntry } from "./mcp/auth.js";
+import { type CodexAppsToolsCacheContext } from "./codex_apps.js";
+import { AsyncManagedClient, ManagedClient, type AsyncManagedClientStartupStatus, type McpClientFactoryOptions, type McpServerConfig, type McpServerTransportConfig, type RmcpClientLike } from "./rmcp_client.js";
+import { ToolFilter, type ToolInfo } from "./tools.js";
+export type McpConnectionManagerInput = {
+    clients?: ReadonlyMap<string, AsyncManagedClient> | Record<string, AsyncManagedClient>;
+    server_origins?: ReadonlyMap<string, string> | Record<string, string>;
+    host_owned_codex_apps_enabled?: boolean;
+    elicitation_requests?: ElicitationRequestManager | null;
+};
+export type McpStartupFailure = {
+    server: string;
+    error: string;
+};
+export type McpStartupStatus = AsyncManagedClientStartupStatus;
+export declare class McpConnectionManager {
+    readonly clients: Map<string, AsyncManagedClient>;
+    private readonly server_origins;
+    private readonly elicitation_requests;
+    private host_owned_codex_apps_enabled;
+    private startup_cancelled;
+    constructor(input?: McpConnectionManagerInput);
+    static new_uninitialized(): McpConnectionManager;
+    static from_managed_clients(clients: ReadonlyMap<string, ManagedClient> | Record<string, ManagedClient>): McpConnectionManager;
+    static from_rmcp_clients(clients: ReadonlyMap<string, RmcpClientLike> | Record<string, RmcpClientLike>, options?: {
+        tool_filter_by_server?: ReadonlyMap<string, ToolFilter> | Record<string, ToolFilter>;
+        tool_timeout?: number | null;
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        tool_plugin_provenance?: ToolPluginProvenance;
+    }): McpConnectionManager;
+    static from_config(mcp_servers: ReadonlyMap<string, McpServerConfig> | Record<string, McpServerConfig>, options?: {
+        client_factory_options?: McpClientFactoryOptions;
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        host_owned_codex_apps_enabled?: boolean;
+        tool_plugin_provenance?: ToolPluginProvenance;
+        elicitation_requests?: ElicitationRequestManager | null;
+    }): McpConnectionManager;
+    has_servers(): boolean;
+    begin_shutdown(): Promise<void>;
+    shutdown(): Promise<void>;
+    server_origin(server_name: string): string | null;
+    is_host_owned_codex_apps_server(server_name: string): boolean;
+    set_approval_policy(approval_policy: unknown): void;
+    set_permission_profile(permission_profile: unknown): void;
+    elicitations_auto_deny(): boolean;
+    set_elicitations_auto_deny(auto_deny: boolean): void;
+    resolve_elicitation(server_name: string, id: string | number, response: ElicitationResponse): Promise<void>;
+    wait_for_server_ready(server_name: string, timeout_ms?: number): Promise<boolean>;
+    required_startup_failures(required_servers: readonly string[]): Promise<McpStartupFailure[]>;
+    startup_statuses(): Map<string, McpStartupStatus>;
+    list_all_tools(): Promise<Map<string, ToolInfo>>;
+    hard_refresh_codex_apps_tools_cache(): Promise<Map<string, ToolInfo>>;
+    list_all_resources(): Promise<Map<string, unknown[]>>;
+    list_all_resource_templates(): Promise<Map<string, unknown[]>>;
+    call_tool(server: string, tool: string, arguments_: unknown, meta?: unknown): Promise<unknown>;
+    server_supports_sandbox_state_meta_capability(server: string): Promise<boolean>;
+    list_resources(server: string, params?: unknown): Promise<unknown>;
+    list_resource_templates(server: string, params?: unknown): Promise<unknown>;
+    read_resource(server: string, params: unknown): Promise<unknown>;
+    resolve_tool_info(tool_name: string | {
+        namespace?: string | null;
+        name: string;
+    }): Promise<ToolInfo | null>;
+    private client_by_name;
+}
+export declare function transport_origin(transport: McpServerTransportConfig): string | null;
+export declare function mcp_init_error_display(server_name: string, entry: McpAuthStatusEntry | null | undefined, err: unknown): string;
+export declare function startup_outcome_error_message(error: unknown): string;
+export declare function is_mcp_client_auth_required_error(error: unknown): boolean;
+export declare function is_mcp_client_startup_timeout_error(error: unknown): boolean;