@jrkropp/codex-js 0.1.0 → 0.1.2

package/dist/server/index.d.ts

@@ -1,15 +1,33 @@
-import { J as JsonValue, M as McpServerRefreshConfig, B as McpRuntimeEnvironment, F as McpServerStatusListOptions, G as McpServerStatus, H as McpResourceListParams, I as McpResourceListResponse, K as McpResourceTemplateListResponse, O as McpResourceReadParams, P as McpResourceReadResponse, Q as McpServerToolCallParams, V as McpServerToolCallResponse, W as McpToolInfo, X as McpRequestId, Y as McpServerElicitationResponse, Z as McpResourceInfo, _ as McpResourceTemplateInfo, T as ThreadId, C as CreateThreadParams, R as ResumeThreadParams, $ as RolloutItem, b as StoredThreadHistory, d as StoredThread, a0 as ThreadMemoryMode, a1 as ThreadMetadataPatch, l as RequestId, a as ServerRequest, S as ServerNotification, a2 as ServiceTier, a3 as ReasoningEffortConfig, a4 as ReasoningSummaryConfig, a5 as Personality, a6 as AskForApproval, a7 as ApprovalsReviewer, a8 as SandboxPolicy, a9 as PermissionProfile, aa as ActivePermissionProfile, ab as WindowsSandboxLevel, ac as BaseInstructions, w as CollaborationMode, ad as SessionSource, ae as TurnEnvironmentSelection, af as DynamicToolSpec$1, ag as TruncationPolicy, ah as ThreadGoal, ai as ThreadGoalStatus, aj as HookEventName, ak as HookSource, al as HookRunStatus, am as HookOutputEntry, an as HookRunSummary, ao as HookCompletedEvent, r as UserInput, ap as TokenUsage, aq as RequestUserInputResponse, ar as DynamicToolResponse, as as RequestPermissionsResponse, at as RequestPermissionProfile, au as EventMsg, av as Op, aw as Submission, ax as NormalizedRequestUserInputArgs, ay as RequestPermissionsArgs, az as McpServerElicitationRequest, aA as CompactedItem, aB as ResponseItem, aC as RateLimitSnapshot, aD as TokenUsageInfo, aE as TurnContextItem, aF as ModeKind, aG as W3cTraceContext } from '../thread_event_store-BIS0qzhi.js';
-export { aH as ThreadEventPersistenceMode, m as ThreadEventSnapshot, n as ThreadEventStore, aI as ThreadHistoryBuilder, aJ as asThreadId, aK as deniedRequestPermissionsResponse } from '../thread_event_store-BIS0qzhi.js';
-import { c as ClientRequest, h as CollaborationModeListParams, i as CollaborationModeListResponse, I as InitializeParams, d as InitializeResponse, M as McpServerRefreshResponse, j as McpResourceReadParams$1, k as McpResourceReadResponse$1, l as McpServerOauthLoginParams, m as McpServerOauthLoginResponse, L as ListMcpServerStatusParams, n as ListMcpServerStatusResponse, o as McpServerToolCallParams$1, p as McpServerToolCallResponse$1, q as ThreadArchiveParams, t as ThreadArchiveResponse, u as ThreadCompactStartParams, v as ThreadCompactStartResponse, w as ThreadListParams, x as ThreadListResponse, y as ThreadMetadataUpdateParams, z as ThreadMetadataUpdateResponse, B as ThreadSetNameParams, D as ThreadSetNameResponse, E as ThreadReadParams, F as ThreadReadResponse, G as ThreadResumeParams, H as ThreadResumeResponse, f as ThreadStartParams, K as ThreadStartResponse, N as ThreadUnarchiveParams, O as ThreadUnarchiveResponse, P as TurnInterruptParams, Q as TurnInterruptResponse, g as TurnStartParams, S as TurnStartResponse, U as TurnSteerParams, V as TurnSteerResponse, A as AppServerEvent$1, J as JSONRPCErrorError$1, R as Result$1 } from '../session-BO6EZNK7.js';
-export { b as AppServerSession, C as CodexAppServer } from '../session-BO6EZNK7.js';
-export { D as DynamicToolCallResponse } from '../DynamicToolCallResponse-D2OVpa4p.js';
-import { T as ThreadStore } from '../store-H2cQxdpe.js';
+import { s as ReasoningEffort, J as JsonValue, M as McpServerRefreshConfig, t as McpRuntimeEnvironment$1, u as McpServerStatusListOptions, v as McpServerStatus, w as McpResourceListParams, x as McpResourceListResponse, y as McpResourceTemplateListResponse, z as McpResourceReadParams, B as McpResourceReadResponse, E as McpServerToolCallParams, F as McpServerToolCallResponse, G as McpToolInfo, H as McpRequestId, I as McpServerElicitationResponse, K as McpResourceInfo, N as McpResourceTemplateInfo, T as ThreadId, C as CreateThreadParams, R as ResumeThreadParams, O as RolloutItem, b as StoredThreadHistory, d as StoredThread, P as ThreadMemoryMode, Q as ThreadMetadataPatch, V as CollaborationModeMask, W as ModeKind$1, o as CollaborationMode$1, j as RequestId$1, a as ServerRequest, S as ServerNotification, X as ServiceTier, Y as ReasoningEffortConfig, Z as ReasoningSummaryConfig, _ as Personality, $ as AskForApproval, a0 as ApprovalsReviewer, a1 as SandboxPolicy, a2 as PermissionProfile, a3 as ActivePermissionProfile, a4 as WindowsSandboxLevel, a5 as BaseInstructions, a6 as SessionSource, a7 as TurnEnvironmentSelection, a8 as DynamicToolSpec$1, a9 as TruncationPolicy, aa as ThreadGoal, ab as ThreadGoalStatus, ac as HookEventName, ad as HookSource, ae as HookRunStatus, af as HookOutputEntry, ag as HookRunSummary, ah as HookCompletedEvent, l as UserInput, ai as TokenUsage, aj as RequestUserInputResponse, ak as DynamicToolResponse, al as RequestPermissionsResponse, am as RequestPermissionProfile, an as EventMsg, ao as Op, ap as Submission, aq as NormalizedRequestUserInputArgs, ar as RequestPermissionsArgs, as as McpServerElicitationRequest, at as CompactedItem, au as ResponseItem, av as RateLimitSnapshot, aw as TokenUsageInfo, ax as TurnContextItem, ay as W3cTraceContext } from '../thread_event_store-B9CoQUIA.js';
+export { A as AppendThreadItemsParams, h as ArchiveThreadParams, az as DynamicToolCallParams, aA as DynamicToolSpecWire, f as ListThreadsParams, L as LoadThreadHistoryParams, e as ReadThreadByRolloutPathParams, c as ReadThreadParams, aB as RealtimeEvent, aC as RenderedThreadConnectionStatus, aD as RenderedThreadState, aE as ServerNotificationThreadTarget, aF as SortDirection, aG as TUI_VISIBLE_COLLABORATION_MODES, aH as Thread, aI as ThreadBufferedEvent, aJ as ThreadEventPersistenceMode, p as ThreadEventSnapshot, aK as ThreadEventStore, aL as ThreadHistoryBuilder, aM as ThreadItem, g as ThreadPage, aN as ThreadPersistenceMetadata, aO as ThreadSortKey, aP as ThreadTokenUsageSnapshot, aQ as Turn, U as UpdateThreadMetadataParams, aR as UserInput, aS as allowsRequestUserInput, aT as applyCollaborationModeMask, aU as applyEventMsgToRenderedThread, aV as asThreadId, aW as collaborationModeForModel, aX as collaborationModeWithUpdates, aY as createRenderedThreadState, aZ as deniedRequestPermissionsResponse, a_ as renderThreadFromHistory, a$ as serverNotificationThreadTarget, b0 as serverRequestThreadId, b1 as setRenderedThreadConnectionStatus, b2 as threadEventSnapshotHasStarted } from '../thread_event_store-B9CoQUIA.js';
+import { M as ModeKind, c as ClientRequest, d as CollaborationModeListParams, e as CollaborationModeListResponse, I as InitializeParams, f as InitializeResponse, g as McpServerRefreshResponse, h as McpResourceReadParams$1, i as McpResourceReadResponse$1, j as McpServerOauthLoginParams, k as McpServerOauthLoginResponse, L as ListMcpServerStatusParams, l as ListMcpServerStatusResponse, m as McpServerToolCallParams$1, n as McpServerToolCallResponse$1, o as ThreadArchiveParams, p as ThreadArchiveResponse, q as ThreadCompactStartParams, r as ThreadCompactStartResponse, s as ThreadListParams, t as ThreadListResponse, u as ThreadMetadataUpdateParams, v as ThreadMetadataUpdateResponse, w as ThreadSetNameParams, x as ThreadSetNameResponse, y as ThreadReadParams, z as ThreadReadResponse, B as ThreadResumeParams, D as ThreadResumeResponse, a as ThreadStartParams, E as ThreadStartResponse, F as ThreadUnarchiveParams, G as ThreadUnarchiveResponse, H as TurnInterruptParams, K as TurnInterruptResponse, b as TurnStartParams, N as TurnStartResponse, O as TurnSteerParams, P as TurnSteerResponse, A as AppServerEvent$1, J as JSONRPCErrorError$1, R as Result$1 } from '../session-DPhHN7RZ.js';
+export { Q as AppServerCollaborationModeMask, S as AppServerMcpServerStatus, U as AppServerRequestHandle, V as AppServerSession, C as CodexAppServer, T as ToolRequestUserInputResponse, W as TypedRequestError, X as requestMethodName, Y as requestTyped, Z as serverNotificationRequiresDelivery } from '../session-DPhHN7RZ.js';
+export { A as AppServerRequestResolution, C as CommandExecutionRequestApprovalResponse, D as DynamicToolCallResponse, F as FileChangeRequestApprovalResponse, M as McpServerElicitationRequestResponse, P as PendingAppServerRequests, a as PermissionsRequestApprovalResponse, R as ResolvedAppServerRequest, U as UnsupportedAppServerRequest } from '../index-CB9la6xE.js';
+import { T as ThreadStore } from '../store-GYldc9EJ.js';
+export { a as CodexAppServerClientConnectionStatus, C as CodexAppServerClientOptions, b as CodexAppServerClientTransportError, c as createCodexAppServerClient, p as parseCodexAppServerEvent } from '../remote-_6TDvg-g.js';
 export { InMemoryThreadStore, InMemoryThreadStoreCalls, LocalThreadStore, LocalThreadStoreConfig } from '../testing/index.js';
 
 type ClientNotification = {
     "method": "initialized";
 };
 
+/**
+ * Settings for a collaboration mode.
+ */
+type Settings = {
+    model: string;
+    reasoning_effort: ReasoningEffort | null;
+    developer_instructions: string | null;
+};
+
+/**
+ * Collaboration mode for a Codex session.
+ */
+type CollaborationMode = {
+    mode: ModeKind;
+    settings: Settings;
+};
+
 type WebSearchContextSize = "low" | "medium" | "high";
 
 type WebSearchLocation = {
@@ -86,8 +104,346 @@ type ToolSpec = LoadableToolSpec | {
     type: "custom";
 });
 
+type ToolInfo = {
+    server_name: string;
+    name: string;
+    callable_name?: string | null;
+    callable_namespace?: string | null;
+    namespace_description?: string | null;
+    title?: string | null;
+    description?: string | null;
+    input_schema?: unknown;
+    meta?: unknown;
+    connector_id?: string | null;
+    connector_name?: string | null;
+    plugin_display_names?: string[];
+    source_label?: string | null;
+    mcp_app_resource_uri?: string | null;
+};
+declare class ToolFilter {
+    readonly enabled: ReadonlySet<string> | null;
+    readonly disabled: ReadonlySet<string>;
+    constructor(enabled?: ReadonlySet<string> | null, disabled?: ReadonlySet<string>);
+    static from_config(config: {
+        enabled_tools?: readonly string[] | null;
+        disabled_tools?: readonly string[] | null;
+    }): ToolFilter;
+    allows(toolName: string): boolean;
+}
+
+type CodexAppsToolsCacheKey = {
+    account_id?: string | null;
+    chatgpt_user_id?: string | null;
+    is_workspace_account: boolean;
+};
+type CodexAppsToolsCacheStorage = {
+    read(path: string): string | Uint8Array | null | undefined;
+    write(path: string, bytes: string): void;
+};
+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;
+}
+
+type McpServerTransportConfig = {
+    type: "streamable_http";
+    url: string;
+    bearer_token_env_var?: string | null;
+    http_headers?: Record<string, string> | null;
+    env_http_headers?: Record<string, string> | null;
+    oauth_tokens_present?: boolean | null;
+} | {
+    type: "stdio";
+    command: string;
+    args?: readonly string[];
+    env?: Record<string, string> | null;
+    env_vars?: readonly string[];
+    cwd?: string | null;
+};
+type McpServerConfig = {
+    transport: McpServerTransportConfig;
+    enabled?: boolean;
+    required?: boolean;
+    startup_timeout_sec?: number | null;
+    tool_timeout_sec?: number | null;
+    enabled_tools?: readonly string[] | null;
+    disabled_tools?: readonly string[] | null;
+    experimental_environment?: string | null;
+};
+type McpRuntimeEnvironment = {
+    cwd?: string | null;
+    environment_id?: string | null;
+    remote?: boolean | null;
+};
+type McpClientFactoryOptions = {
+    fetch?: typeof fetch;
+    environment?: Record<string, string | undefined>;
+    stdio_server_launcher?: StdioServerLauncher | null;
+    runtime_environment?: McpRuntimeEnvironment | null;
+};
+type StdioServerLauncher = {
+    launch(server_name: string, config: Extract<McpServerTransportConfig, {
+        type: "stdio";
+    }>, runtime_environment?: McpRuntimeEnvironment | null): Promise<RmcpClientLike>;
+};
+type RmcpRawTool = {
+    name: string;
+    title?: string | null;
+    description?: string | null;
+    input_schema?: unknown;
+    meta?: unknown;
+    connector_id?: string | null;
+    connector_name?: string | null;
+    connector_description?: string | null;
+};
+type RmcpListToolsResult = readonly ToolInfo[] | readonly RmcpRawTool[] | {
+    tools: readonly (ToolInfo | RmcpRawTool | ({
+        tool: RmcpRawTool;
+    } & Record<string, unknown>))[];
+};
+type RmcpClientLike = {
+    initialize?: (timeout?: number | null) => Promise<RmcpInitializeResult>;
+    list_tools?: (params?: unknown, timeout?: number | null) => Promise<RmcpListToolsResult>;
+    call_tool?: (tool: string, arguments_: unknown, meta?: unknown, timeout?: number | null) => Promise<unknown>;
+    list_resources?: (params?: unknown, timeout?: number | null) => Promise<unknown>;
+    list_resource_templates?: (params?: unknown, timeout?: number | null) => Promise<unknown>;
+    read_resource?: (params: unknown, timeout?: number | null) => Promise<unknown>;
+    shutdown?: () => Promise<void> | void;
+};
+type RmcpInitializeResult = {
+    instructions?: string | null;
+    capabilities?: {
+        experimental?: Record<string, unknown> | null;
+        [key: string]: unknown;
+    } | null;
+};
+type ManagedClientInput = {
+    client?: RmcpClientLike | null;
+    tools?: readonly ToolInfo[];
+    tool_filter?: ToolFilter;
+    tool_timeout?: number | null;
+    server_instructions?: string | null;
+    server_supports_sandbox_state_meta_capability?: boolean;
+    codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+};
+declare class ManagedClient {
+    readonly client: RmcpClientLike | null;
+    readonly tools: readonly ToolInfo[];
+    readonly tool_filter: ToolFilter;
+    readonly tool_timeout: number | null;
+    readonly server_instructions: string | null;
+    readonly server_supports_sandbox_state_meta_capability: boolean;
+    readonly codex_apps_tools_cache_context: CodexAppsToolsCacheContext | null;
+    constructor(input?: ManagedClientInput);
+    listed_tools(): ToolInfo[];
+    call_tool(tool: string, arguments_: unknown, meta?: unknown): Promise<unknown>;
+    list_resources(params?: unknown): Promise<unknown>;
+    list_resource_templates(params?: unknown): Promise<unknown>;
+    read_resource(params: unknown): Promise<unknown>;
+    shutdown(): Promise<void>;
+}
+type AsyncManagedClientInput = {
+    client: ManagedClient | Promise<ManagedClient> | (() => ManagedClient | Promise<ManagedClient>);
+    startup_snapshot?: readonly ToolInfo[] | null;
+    tool_plugin_provenance?: ToolPluginProvenance;
+    cancel_token?: CancellationToken;
+};
+type AsyncManagedClientStartupStatus = {
+    status: "starting";
+} | {
+    status: "ready";
+} | {
+    status: "cancelled";
+} | {
+    status: "failed";
+    error: string;
+};
+declare class AsyncManagedClient {
+    private readonly client_promise;
+    private readonly startup_snapshot;
+    private readonly startup_complete;
+    private readonly tool_plugin_provenance;
+    private readonly cancel_token;
+    private startup_status_value;
+    constructor(input: AsyncManagedClientInput);
+    static from_managed_client(client: ManagedClient, startup_snapshot?: readonly ToolInfo[] | null): AsyncManagedClient;
+    static new(server_name: string, input: {
+        client: RmcpClientLike | Promise<RmcpClientLike> | (() => RmcpClientLike | Promise<RmcpClientLike>);
+        tool_filter?: ToolFilter;
+        tool_timeout?: number | null;
+        server_instructions?: string | null;
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        tool_plugin_provenance?: ToolPluginProvenance;
+    }): AsyncManagedClient;
+    static from_config(server_name: string, config: McpServerConfig, options?: {
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        tool_plugin_provenance?: ToolPluginProvenance;
+        client_factory_options?: McpClientFactoryOptions;
+    }): AsyncManagedClient;
+    client(): Promise<ManagedClient>;
+    shutdown(): Promise<void>;
+    startup_status(): AsyncManagedClientStartupStatus;
+    listed_tools(): Promise<ToolInfo[] | null>;
+    private startup_snapshot_while_initializing;
+    private listed_tools_from_client;
+    private annotate_tools;
+}
+declare class CancellationToken {
+    private cancelled;
+    cancel(): void;
+    is_cancelled(): boolean;
+    child_token(): CancellationToken;
+}
+
+declare class ToolPluginProvenance {
+    private readonly plugin_display_names_by_connector_id;
+    private readonly plugin_display_names_by_mcp_server_name;
+    constructor(input?: {
+        plugin_display_names_by_connector_id?: ReadonlyMap<string, readonly string[]> | Record<string, readonly string[]>;
+        plugin_display_names_by_mcp_server_name?: ReadonlyMap<string, readonly string[]> | Record<string, readonly string[]>;
+    });
+    plugin_display_names_for_connector_id(connectorId: string): readonly string[];
+    plugin_display_names_for_mcp_server_name(serverName: string): readonly string[];
+}
+
+type RequestId = string | number;
+type ElicitationAction = "accept" | "decline" | "cancel";
+type ElicitationResponse = {
+    action: ElicitationAction;
+    content?: unknown;
+    meta?: unknown;
+};
+type CreateElicitationRequestParams = {
+    type: "form";
+    meta?: unknown;
+    message: string;
+    requested_schema: {
+        properties?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+} | {
+    type: "url";
+    meta?: unknown;
+    message: string;
+    url: string;
+    elicitation_id?: string | null;
+};
+type ElicitationRequestEvent = {
+    id: "mcp_elicitation_request";
+    msg: {
+        type: "elicitation_request";
+        turn_id: null;
+        server_name: string;
+        id: RequestId;
+        request: {
+            type: "form";
+            meta?: unknown;
+            message: string;
+            requested_schema: unknown;
+        } | {
+            type: "url";
+            meta?: unknown;
+            message: string;
+            url: string;
+            elicitation_id?: string | null;
+        };
+    };
+};
+type ElicitationReviewRequest = {
+    server_name: string;
+    request_id: RequestId;
+    elicitation: CreateElicitationRequestParams;
+};
+type ElicitationReviewer = {
+    review(request: ElicitationReviewRequest): Promise<ElicitationResponse | null | undefined>;
+};
+type ElicitationReviewerHandle = ElicitationReviewer;
+type ElicitationEventSink = ((event: ElicitationRequestEvent) => Promise<void> | void) | {
+    send(event: ElicitationRequestEvent): Promise<void> | void;
+};
+type SendElicitation = (id: RequestId, elicitation: CreateElicitationRequestParams) => Promise<ElicitationResponse>;
+declare class ElicitationRequestManager {
+    private readonly reviewer;
+    private readonly requests;
+    private approval_policy;
+    private permission_profile;
+    private auto_deny_value;
+    constructor(approval_policy: unknown, permission_profile: unknown, reviewer?: ElicitationReviewerHandle | null);
+    auto_deny(): boolean;
+    set_auto_deny(auto_deny: boolean): void;
+    set_approval_policy(approval_policy: unknown): void;
+    set_permission_profile(permission_profile: unknown): void;
+    resolve(server_name: string, id: RequestId, response: ElicitationResponse): Promise<void>;
+    make_sender(server_name: string, tx_event: ElicitationEventSink): SendElicitation;
+}
+
+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;
+};
+type McpStartupFailure = {
+    server: string;
+    error: string;
+};
+type McpStartupStatus = AsyncManagedClientStartupStatus;
+declare class McpConnectionManager$1 {
+    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$1;
+    static from_managed_clients(clients: ReadonlyMap<string, ManagedClient> | Record<string, ManagedClient>): McpConnectionManager$1;
+    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$1;
+    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$1;
+    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;
+}
+
 interface McpConnectionManager {
-    refresh_mcp_servers_now(config: McpServerRefreshConfig, environment: McpRuntimeEnvironment): Promise<void>;
+    refresh_mcp_servers_now(config: McpServerRefreshConfig, environment: McpRuntimeEnvironment$1): Promise<void>;
     list_server_statuses(options?: McpServerStatusListOptions): Promise<McpServerStatus[]>;
     list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
     list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
@@ -111,6 +467,27 @@ declare class EmptyMcpConnectionManager implements McpConnectionManager {
     resolve_elicitation(serverName: string): Promise<void>;
     shutdown(): Promise<void>;
 }
+type CodexMcpConnectionManagerAdapterOptions = {
+    client_factory_options?: McpClientFactoryOptions;
+};
+declare class CodexMcpConnectionManagerAdapter implements McpConnectionManager {
+    private manager;
+    private readonly client_factory_options?;
+    private configured_servers;
+    private auth_statuses;
+    constructor(manager?: McpConnectionManager$1, options?: CodexMcpConnectionManagerAdapterOptions);
+    refresh_mcp_servers_now(config: McpServerRefreshConfig, environment: McpRuntimeEnvironment$1): Promise<void>;
+    list_server_statuses(options?: McpServerStatusListOptions): Promise<McpServerStatus[]>;
+    list_resources(params: McpResourceListParams): Promise<McpResourceListResponse>;
+    list_resource_templates(params: McpResourceListParams): Promise<McpResourceTemplateListResponse>;
+    read_resource(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    call_tool(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    resolve_tool_info(serverName: string, toolName: string): Promise<McpToolInfo | null>;
+    list_tools(): Promise<McpToolInfo[]>;
+    resolve_elicitation(serverName: string, id: McpRequestId, response: McpServerElicitationResponse): Promise<void>;
+    shutdown(): Promise<void>;
+    required_startup_failures(required_servers: readonly string[]): Promise<McpStartupFailure[]>;
+}
 type StaticMcpConnectionManagerOptions = {
     resources?: Record<string, ReadonlyArray<McpResourceInfo>>;
     resource_templates?: Record<string, ReadonlyArray<McpResourceTemplateInfo>>;
@@ -152,6 +529,13 @@ declare class LiveThread {
     localRolloutPath(): Promise<string | null>;
 }
 
+declare const CODEX_CHATGPT_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+declare const CODEX_CHATGPT_OAUTH_ISSUER = "https://auth.openai.com";
+declare const CODEX_CHATGPT_OAUTH_SCOPE = "openid profile email offline_access api.connectors.read api.connectors.invoke";
+declare const CODEX_CHATGPT_OAUTH_PRIMARY_PORT = 1455;
+declare const CODEX_CHATGPT_OAUTH_FALLBACK_PORT = 1457;
+declare const CODEX_CHATGPT_OAUTH_CALLBACK_PATH = "/auth/callback";
+declare const CODEX_CHATGPT_OAUTH_ORIGINATOR = "codex_cli_rs";
 declare const AuthMode: {
     readonly ApiKey: "apiKey";
     readonly Chatgpt: "chatgpt";
@@ -192,6 +576,21 @@ type ProviderAccountState = {
     account: ProviderAccount | null;
     requires_openai_auth: boolean;
 };
+type ChatgptOAuthTokenExchangeResponse = {
+    credential_jwe: string;
+    account: ProviderAccountState;
+};
+
+declare function builtinCollaborationModePresets(): CollaborationModeMask[];
+declare function collaborationModePresetForMode(mode: ModeKind$1): CollaborationModeMask | null;
+declare function normalizeCollaborationMode(input: {
+    collaborationMode?: CollaborationMode$1 | null;
+    model: string;
+    reasoningEffort?: string | null;
+}): CollaborationMode$1;
+declare function defaultModeInstructions(): string;
+
+declare const CODEX_PLAN_MODE_INSTRUCTIONS = "# Plan Mode (Conversational)\n\nYou work in 3 phases, and you should *chat your way* to a great plan before finalizing it. A great plan is very detailed\u2014intent- and implementation-wise\u2014so that it can be handed to another engineer or agent to be implemented right away. It must be **decision complete**, where the implementer does not need to make any decisions.\n\n## Mode rules (strict)\n\nYou are in **Plan Mode** until a developer message explicitly ends it.\n\nPlan Mode is not changed by user intent, tone, or imperative language. If a user asks for execution while still in Plan Mode, treat it as a request to **plan the execution**, not perform it.\n\n## Plan Mode vs update_plan tool\n\nPlan Mode is a collaboration mode that can involve requesting user input and eventually issuing a `<proposed_plan>` block.\n\nSeparately, `update_plan` is a checklist/progress/TODOs tool; it does not enter or exit Plan Mode. Do not confuse it with Plan mode or try to use it while in Plan mode. If you try to use `update_plan` in Plan mode, it will return an error.\n\n## Execution vs. mutation in Plan Mode\n\nYou may explore and execute **non-mutating** actions that improve the plan. You must not perform **mutating** actions.\n\n### Allowed (non-mutating, plan-improving)\n\nActions that gather truth, reduce ambiguity, or validate feasibility without changing repo-tracked state. Examples:\n\n* Reading or searching files, configs, schemas, types, manifests, and docs\n* Static analysis, inspection, and repo exploration\n* Dry-run style commands when they do not edit repo-tracked files\n* Tests, builds, or checks that may write to caches or build artifacts (for example, `target/`, `.cache/`, or snapshots) so long as they do not edit repo-tracked files\n\n### Not allowed (mutating, plan-executing)\n\nActions that implement the plan or change repo-tracked state. Examples:\n\n* Editing or writing files\n* Running formatters or linters that rewrite files\n* Applying patches, migrations, or codegen that updates repo-tracked files\n* Side-effectful commands whose purpose is to carry out the plan rather than refine it\n\nWhen in doubt: if the action would reasonably be described as \"doing the work\" rather than \"planning the work,\" do not do it.\n\n## PHASE 1 \u2014 Ground in the environment (explore first, ask second)\n\nBegin by grounding yourself in the actual environment. Eliminate unknowns in the prompt by discovering facts, not by asking the user. Resolve all questions that can be answered through exploration or inspection. Identify missing or ambiguous details only if they cannot be derived from the environment. Silent exploration between turns is allowed and encouraged.\n\nBefore asking the user any question, perform at least one targeted non-mutating exploration pass (for example: search relevant files, inspect likely entrypoints/configs, confirm current implementation shape), unless no local environment/repo is available.\n\nException: you may ask clarifying questions about the user's prompt before exploring, ONLY if there are obvious ambiguities or contradictions in the prompt itself. However, if ambiguity might be resolved by exploring, always prefer exploring first.\n\nDo not ask questions that can be answered from the repo or system (for example, \"where is this struct?\" or \"which UI component should we use?\" when exploration can make it clear). Only ask once you have exhausted reasonable non-mutating exploration.\n\n## PHASE 2 \u2014 Intent chat (what they actually want)\n\n* Keep asking until you can clearly state: goal + success criteria, audience, in/out of scope, constraints, current state, and the key preferences/tradeoffs.\n* Bias toward questions over guessing: if any high-impact ambiguity remains, do NOT plan yet\u2014ask.\n\n## PHASE 3 \u2014 Implementation chat (what/how we\u2019ll build)\n\n* Once intent is stable, keep asking until the spec is decision complete: approach, interfaces (APIs/schemas/I/O), data flow, edge cases/failure modes, testing + acceptance criteria, rollout/monitoring, and any migrations/compat constraints.\n\n## Asking questions\n\nCritical rules:\n\n* Strongly prefer using the `request_user_input` tool to ask any questions.\n* Offer only meaningful multiple\u2011choice options; don\u2019t include filler choices that are obviously wrong or irrelevant.\n* In rare cases where an unavoidable, important question can\u2019t be expressed with reasonable multiple\u2011choice options (due to extreme ambiguity), you may ask it directly without the tool.\n\nYou SHOULD ask many questions, but each question must:\n\n* materially change the spec/plan, OR\n* confirm/lock an assumption, OR\n* choose between meaningful tradeoffs.\n* not be answerable by non-mutating commands.\n\nUse the `request_user_input` tool only for decisions that materially change the plan, for confirming important assumptions, or for information that cannot be discovered via non-mutating exploration.\n\n## Two kinds of unknowns (treat differently)\n\n1. **Discoverable facts** (repo/system truth): explore first.\n\n   * Before asking, run targeted searches and check likely sources of truth (configs/manifests/entrypoints/schemas/types/constants).\n   * Ask only if: multiple plausible candidates; nothing found but you need a missing identifier/context; or ambiguity is actually product intent.\n   * If asking, present concrete candidates (paths/service names) + recommend one.\n   * Never ask questions you can answer from your environment (e.g., \u201Cwhere is this struct\u201D).\n\n2. **Preferences/tradeoffs** (not discoverable): ask early.\n\n   * These are intent or implementation preferences that cannot be derived from exploration.\n   * Provide 2\u20134 mutually exclusive options + a recommended default.\n   * If unanswered, proceed with the recommended option and record it as an assumption in the final plan.\n\n## Finalization rule\n\nOnly output the final plan when it is decision complete and leaves no decisions to the implementer.\n\nWhen you present the official plan, wrap it in a `<proposed_plan>` block so the client can render it specially:\n\n1) The opening tag must be on its own line.\n2) Start the plan content on the next line (no text on the same line as the tag).\n3) The closing tag must be on its own line.\n4) Use Markdown inside the block.\n5) Keep the tags exactly as `<proposed_plan>` and `</proposed_plan>` (do not translate or rename them), even if the plan content is in another language.\n\nExample:\n\n<proposed_plan>\nplan content\n</proposed_plan>\n\nplan content should be human and agent digestible. The final plan must be plan-only, concise by default, and include:\n\n* A clear title\n* A brief summary section\n* Important changes or additions to public APIs/interfaces/types\n* Test cases and scenarios\n* Explicit assumptions and defaults chosen where needed\n\nWhen possible, prefer a compact structure with 3-5 short sections, usually: Summary, Key Changes or Implementation Changes, Test Plan, and Assumptions. Do not include a separate Scope section unless scope boundaries are genuinely important to avoid mistakes.\n\nPrefer grouped implementation bullets by subsystem or behavior over file-by-file inventories. Mention files only when needed to disambiguate a non-obvious change, and avoid naming more than 3 paths unless extra specificity is necessary to prevent mistakes. Prefer behavior-level descriptions over symbol-by-symbol removal lists. For v1 feature-addition plans, do not invent detailed schema, validation, precedence, fallback, or wire-shape policy unless the request establishes it or it is needed to prevent a concrete implementation mistake; prefer the intended capability and minimum interface/behavior changes.\n\nKeep bullets short and avoid explanatory sub-bullets unless they are needed to prevent ambiguity. Prefer the minimum detail needed for implementation safety, not exhaustive coverage. Within each section, compress related changes into a few high-signal bullets and omit branch-by-branch logic, repeated invariants, and long lists of unaffected behavior unless they are necessary to prevent a likely implementation mistake. Avoid repeated repo facts and irrelevant edge-case or rollout detail. For straightforward refactors, keep the plan to a compact summary, key edits, tests, and assumptions. If the user asks for more detail, then expand.\n\nDo not ask \"should I proceed?\" in the final output. The user can easily switch out of Plan mode and request implementation if you have included a `<proposed_plan>` block in your response. Alternatively, they can decide to stay in Plan mode and continue refining the plan.\n\nOnly produce at most one `<proposed_plan>` block per turn, and only when you are presenting a complete spec.\n\nIf the user stays in Plan mode and asks for revisions after a prior `<proposed_plan>`, any new `<proposed_plan>` must be a complete replacement.";
 
 type ClientRequestSerializationScope = {
     key: string;
@@ -218,7 +617,7 @@ type ClientRequestSerializationScope = {
     serverName: string;
     type: "mcpOauth";
 };
-declare function clientRequestId(request: ClientRequest): RequestId;
+declare function clientRequestId(request: ClientRequest): RequestId$1;
 declare function clientRequestMethod(request: ClientRequest): string;
 declare function clientRequestExperimentalReason(request: ClientRequest | {
     method: string;
@@ -237,12 +636,12 @@ type JSONRPCErrorError = {
 type Result = unknown;
 type ConnectionId = number;
 type OutgoingResponse = {
-    id: RequestId;
+    id: RequestId$1;
     result: Result;
 };
 type OutgoingError = {
     error: JSONRPCErrorError;
-    id: RequestId;
+    id: RequestId$1;
 };
 type OutgoingMessage = ServerRequest | ServerNotification | OutgoingResponse | OutgoingError;
 type QueuedOutgoingMessage = {
@@ -252,7 +651,7 @@ type QueuedOutgoingMessage = {
 
 type ConnectionOrigin = "stdio" | "inProcess" | "webSocket" | "remoteControl";
 type JSONRPCRequest = {
-    id: RequestId;
+    id: RequestId$1;
     method: string;
     params?: unknown;
 };
@@ -261,14 +660,26 @@ type JSONRPCNotification = {
     params?: unknown;
 };
 type JSONRPCResponse = {
-    id: RequestId;
+    id: RequestId$1;
     result: Result;
 };
 type JSONRPCError = {
     error: JSONRPCErrorError;
-    id: RequestId | null;
+    id: RequestId$1 | 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";
@@ -300,14 +711,16 @@ type ParsedTransportPayload<T> = {
     type: "ok";
 } | {
     error: JSONRPCErrorError;
-    id: RequestId | null;
+    id: RequestId$1 | 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 serializeJsonRpcResponse(id: RequestId$1, result: Result): string;
+declare function serializeJsonRpcError(id: RequestId$1 | null, error: JSONRPCErrorError): string;
 declare function queuedOutgoingMessage(message: OutgoingMessage, writeComplete?: () => void): QueuedOutgoingMessage;
 declare function jsonRpcParseError(message: string): JSONRPCErrorError;
 declare function jsonRpcInvalidRequestError(message: string): JSONRPCErrorError;
@@ -328,11 +741,11 @@ type AppServerEvent = {
 };
 type ConnectionRequestId = {
     connectionId: ConnectionId;
-    requestId: RequestId;
+    requestId: RequestId$1;
 };
 type RequestContext = {
     connectionId: ConnectionId;
-    requestId: RequestId;
+    requestId: RequestId$1;
 };
 type OutgoingServerRequestHandle = {
     request: ServerRequest;
@@ -360,9 +773,9 @@ declare class OutgoingMessageSender {
     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;
+    notifyClientResponse(id: RequestId$1, result: Result): Promise<void>;
+    notifyClientError(id: RequestId$1, error: JSONRPCErrorError): Promise<void>;
+    cancelRequest(id: RequestId$1): boolean;
     connectionClosed(connectionId: ConnectionId): void;
     cancelRequestsForThread(threadId: ThreadId, error?: JSONRPCErrorError): void;
     pendingRequestsForThread(threadId: ThreadId): ServerRequest[];
@@ -381,6 +794,7 @@ declare class ThreadScopedOutgoingMessageSender {
     abortPendingServerRequests(error?: JSONRPCErrorError): void;
     pendingRequests(): ServerRequest[];
 }
+declare function outgoingMessageToAppServerEvent(message: OutgoingMessage): AppServerEvent | null;
 
 declare class CodexAppServerRequestError extends Error {
     readonly error: JSONRPCErrorError;
@@ -405,6 +819,7 @@ 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;
@@ -470,6 +885,7 @@ type CodexAppServerConnectionRequestOutcome = {
 type CodexAppServerDeferredResponse = {
     readonly __codexAppServerDeferredResponse: true;
 };
+declare function codexAppServerDeferredResponse(): CodexAppServerDeferredResponse;
 declare class CodexAppServerMessageProcessor<Context = unknown> {
     readonly connectionId: ConnectionId;
     readonly requestSerializationQueues: RequestSerializationQueues;
@@ -750,6 +1166,7 @@ type ModelPreset = {
     is_default: boolean;
     supported_in_api: boolean;
 };
+type Model = ModelPreset;
 type ModelListParams = {
     cursor?: string | null;
     limit?: number | null;
@@ -801,7 +1218,7 @@ type ConfigToml = {
     base_instructions?: BaseInstructions | string | null;
     developer_instructions?: string | null;
     user_instructions?: string | null;
-    collaboration_mode?: CollaborationMode | null;
+    collaboration_mode?: CollaborationMode$1 | null;
     session_source?: SessionSource;
     environments?: TurnEnvironmentSelection[];
     dynamic_tools?: DynamicToolSpec$1[];
@@ -836,7 +1253,7 @@ type ResolvedConfig = Required<Pick<ConfigToml, "model" | "model_provider" | "ap
     permission_profile: PermissionProfile;
     active_permission_profile: ActivePermissionProfile | null;
     windows_sandbox_level: WindowsSandboxLevel | null;
-    collaboration_mode: CollaborationMode;
+    collaboration_mode: CollaborationMode$1;
     environments: TurnEnvironmentSelection[];
     dynamic_tools: DynamicToolSpec$1[];
     final_output_json_schema?: unknown;
@@ -1139,7 +1556,7 @@ type SessionSettingsUpdate = {
     effort?: ReasoningEffortConfig | null;
     summary?: ReasoningSummaryConfig;
     service_tier?: ServiceTier | null;
-    collaboration_mode?: CollaborationMode;
+    collaboration_mode?: CollaborationMode$1;
     personality?: Personality | null;
     environments?: TurnEnvironmentSelection[];
     persist_environments?: boolean;
@@ -1154,7 +1571,7 @@ type SessionConfiguration = {
     provider: string;
     model: string;
     model_info?: ModelInfo | null;
-    collaboration_mode: CollaborationMode;
+    collaboration_mode: CollaborationMode$1;
     reasoning_effort?: ReasoningEffortConfig | null;
     reasoning_summary: ReasoningSummaryConfig;
     service_tier?: ServiceTier | null;
@@ -1237,7 +1654,7 @@ declare class Session {
     has_pending_input(): Promise<boolean>;
     queue_response_items_for_next_turn(items: UserInput[]): Promise<void>;
     take_queued_response_items_for_next_turn(): Promise<UserInput[]>;
-    collaboration_mode(): CollaborationMode;
+    collaboration_mode(): CollaborationMode$1;
     granted_session_permissions(): RequestPermissionProfile[];
     hooks(): Hooks;
     agentControl(): AgentControl;
@@ -1245,7 +1662,7 @@ declare class Session {
     strict_auto_review_enabled_for_turn(): boolean;
     request_user_input(turnContext: TurnContext, callId: string, args: NormalizedRequestUserInputArgs): Promise<RequestUserInputResponse | null>;
     request_permissions(turnContext: TurnContext, callId: string, args: RequestPermissionsArgs): Promise<RequestPermissionsResponse | null>;
-    refresh_mcp_servers_now(turnContext: TurnContext, config: McpServerRefreshConfig, environment?: McpRuntimeEnvironment): Promise<void>;
+    refresh_mcp_servers_now(turnContext: TurnContext, config: McpServerRefreshConfig, environment?: McpRuntimeEnvironment$1): Promise<void>;
     refresh_mcp_servers_if_requested(turnContext: TurnContext, config?: McpServerRefreshConfig | null): Promise<void>;
     list_mcp_server_statuses(): Promise<McpServerStatus[]>;
     list_mcp_tools(): Promise<McpToolInfo[]>;
@@ -1332,7 +1749,7 @@ type WebSearchConfig = {
 type ToolsConfig = {
     namespace_tools: boolean;
     request_permissions_tool_enabled: boolean;
-    request_user_input_available_modes: readonly ModeKind[];
+    request_user_input_available_modes: readonly ModeKind$1[];
     search_tool: boolean;
     web_search_mode: WebSearchMode | null;
     web_search_tool_type: WebSearchToolType;
@@ -1350,7 +1767,7 @@ type DefaultToolsConfigInput = {
     image_generation?: boolean;
     web_search?: boolean;
     request_permissions_tool_enabled?: boolean;
-    request_user_input_available_modes?: readonly ModeKind[];
+    request_user_input_available_modes?: readonly ModeKind$1[];
     search_tool?: boolean;
     web_search_mode?: WebSearchMode | null;
     web_search_tool_type?: WebSearchToolType;
@@ -1392,7 +1809,7 @@ type TurnContextParams = {
     model: string;
     model_info?: ModelInfo | null;
     personality?: Personality | null;
-    collaboration_mode?: CollaborationMode | null;
+    collaboration_mode?: CollaborationMode$1 | null;
     effort?: ReasoningEffortConfig | null;
     summary: ReasoningSummaryConfig;
     service_tier?: ServiceTier | null;
@@ -1421,7 +1838,7 @@ declare class TurnContext {
     readonly model: string;
     readonly model_info: ModelInfo;
     readonly personality?: Personality | null;
-    readonly collaboration_mode?: CollaborationMode | null;
+    readonly collaboration_mode?: CollaborationMode$1 | null;
     readonly effort?: ReasoningEffortConfig | null;
     readonly summary: ReasoningSummaryConfig;
     readonly service_tier?: ServiceTier | null;
@@ -1996,4 +2413,4 @@ type CodexAppServerRuntime<Context = CodexAppServerRuntimeContext> = {
 };
 declare function createCodexAppServerRuntime<Context = CodexAppServerRuntimeContext>(options: CodexAppServerRuntimeOptions<Context>): CodexAppServerRuntime<Context>;
 
-export { type DynamicToolSpec as AppServerDynamicToolSpec, AppServerEvent$1 as AppServerEvent, ClientRequest, CodexAppServerConnectionSessionState, type CodexAppServerEventSink, CodexAppServerMessageProcessor, type CodexAppServerMessageProcessorOptions, type CodexAppServerMethodHandlers, type CodexAppServerOutgoingSink, type CodexAppServerRequestContext, CodexAppServerRequestError, type CodexAppServerRuntime, type CodexAppServerRuntimeContext, type CodexAppServerRuntimeOptions, type ConnectionId, type ConnectionOrigin, ConnectionRpcGate, ConnectionRpcGateClosedError, type CreateModelClientInput, DynamicToolSpec$1 as DynamicToolSpec, EmptyMcpConnectionManager, type Event, EventMsg, type JSONRPCError, JSONRPCErrorError$1 as JSONRPCErrorError, type JSONRPCMessage, LiveThread, McpRequestProcessor, type ModelClient, ModelClientSession, type ModelClientSessionHandle, OutgoingMessageSender, type RequestContext, RequestId, RequestSerializationQueues, type ResponseEvent, type ResponseStream, ResponsesClient, ResponsesWebsocketClient, ResponsesWebsocketConnection, Result$1 as Result, type RuntimeSession, ServerNotification, ServerRequest, StaticMcpConnectionManager, ThreadId, ThreadMemoryMode, ThreadRequestProcessor, ThreadScopedOutgoingMessageSender, ThreadStore, TurnRequestProcessor, TurnStartParams, TurnStartResponse, clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, createCodexAppServerRuntime, createModelClient, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, parseClientTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage };
+export { type CollaborationMode as AppServerCollaborationMode, type DynamicToolSpec as AppServerDynamicToolSpec, AppServerEvent$1 as AppServerEvent, ModeKind as AppServerModeKind, type AuthDotJson, AuthMode, BaseInstructions, CODEX_CHATGPT_OAUTH_CALLBACK_PATH, CODEX_CHATGPT_OAUTH_CLIENT_ID, CODEX_CHATGPT_OAUTH_FALLBACK_PORT, CODEX_CHATGPT_OAUTH_ISSUER, CODEX_CHATGPT_OAUTH_ORIGINATOR, CODEX_CHATGPT_OAUTH_PRIMARY_PORT, CODEX_CHATGPT_OAUTH_SCOPE, CODEX_PLAN_MODE_INSTRUCTIONS, type ChatgptOAuthTokenExchangeResponse, ClientRequest, type ClientRequestSerializationScope, type CodexAppServerConnectionRequestOutcome, CodexAppServerConnectionSessionState, type CodexAppServerDeferredResponse, type CodexAppServerEventSink, CodexAppServerMessageProcessor, type CodexAppServerMessageProcessorOptions, type CodexAppServerMethodHandlers, type CodexAppServerOutgoingSink, type CodexAppServerRequestContext, CodexAppServerRequestError, type CodexAppServerRuntime, type CodexAppServerRuntimeContext, type CodexAppServerRuntimeOptions, type CodexAuth, CodexMcpConnectionManagerAdapter, CollaborationMode$1 as CollaborationMode, CollaborationModeListParams, CollaborationModeListResponse, CollaborationModeMask, type ConnectionId, type ConnectionOrigin, type ConnectionRequestId, ConnectionRpcGate, ConnectionRpcGateClosedError, UserInput as CoreUserInput, type CreateModelClientInput, CreateThreadParams, DynamicToolSpec$1 as DynamicToolSpec, EmptyMcpConnectionManager, type Event, EventMsg, InitializeParams, InitializeResponse, type InitializedConnectionSessionState, type JSONRPCError, JSONRPCErrorError$1 as JSONRPCErrorError, type JSONRPCMessage, type JSONRPCNotification, type JSONRPCRequest, type JSONRPCResponse, ListMcpServerStatusParams, ListMcpServerStatusResponse, LiveThread, type McpConnectionManager, McpRequestProcessor, McpResourceInfo, McpResourceReadParams$1 as McpResourceReadParams, McpResourceReadResponse$1 as McpResourceReadResponse, McpResourceTemplateInfo, McpRuntimeEnvironment$1 as McpRuntimeEnvironment, McpServerOauthLoginParams, McpServerOauthLoginResponse, McpServerRefreshConfig, McpServerRefreshResponse, McpServerStatus, McpServerStatusListOptions, McpServerToolCallParams$1 as McpServerToolCallParams, McpServerToolCallResponse$1 as McpServerToolCallResponse, McpToolInfo, ModeKind$1 as ModeKind, type Model, type ModelClient, ModelClientSession, type ModelClientSessionHandle, type ModelPreset, Op, type OutgoingError, type OutgoingMessage, OutgoingMessageSender, type OutgoingResponse, type ParsedClientTransportMessage, type ParsedServerTransportMessage, type ParsedTransportPayload, type Prompt, type ProviderAccountState, type QueuedOutgoingMessage, type RequestContext, RequestId$1 as RequestId, type RequestSerializationQueueKey, RequestSerializationQueues, type ResponseCreateWsRequest, type ResponseEvent, type ResponseProcessedWsRequest, type ResponseStream, type ResponsesApiRequest, ResponsesClient, type ResponsesClientInput, ResponsesWebsocketClient, ResponsesWebsocketConnection, type ResponsesWsRequest, Result$1 as Result, ResumeThreadParams, RolloutItem, type RuntimeSession, SandboxPolicy, ServerNotification, ServerRequest, StaticMcpConnectionManager, StoredThread, StoredThreadHistory, Submission, ThreadArchiveParams, ThreadArchiveResponse, ThreadCompactStartParams, ThreadCompactStartResponse, ThreadId, ThreadListParams, ThreadListResponse, ThreadMemoryMode, ThreadMetadataPatch, ThreadMetadataUpdateParams, ThreadMetadataUpdateResponse, ThreadReadParams, ThreadReadResponse, ThreadRequestProcessor, ThreadResumeParams, ThreadResumeResponse, ThreadScopedOutgoingMessageSender, ThreadSetNameParams, ThreadSetNameResponse, ThreadStartParams, ThreadStartResponse, ThreadStore, ThreadUnarchiveParams, ThreadUnarchiveResponse, type TransportEvent, TurnInterruptParams, TurnInterruptResponse, TurnRequestProcessor, TurnStartParams, TurnStartResponse, TurnSteerParams, TurnSteerResponse, type WebSearchMode$1 as WebSearchMode, type WebSearchToolConfig, builtinCollaborationModePresets, clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, codexAppServerDeferredResponse, builtinCollaborationModePresets as codexBuiltinCollaborationModePresets, collaborationModePresetForMode, createCodexAppServerRuntime, createModelClient, defaultModeInstructions, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, normalizeCollaborationMode, outgoingMessageToAppServerEvent, parseClientTransportPayload, parseJsonRpcMessage, parseJsonRpcTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, requestSerializationQueueKeyFromScope, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage };