@janole/ai-sdk-provider-codex-asp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,672 @@
+import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, LanguageModelV3StreamPart, LanguageModelV3Prompt, ProviderV3 } from '@ai-sdk/provider';
+
+/** Base error type for this provider package. */
+declare class CodexProviderError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Error used for methods intentionally left as stubs in early PRs. */
+declare class CodexNotImplementedError extends CodexProviderError {
+    constructor(method: string);
+}
+
+type AskForApproval = "untrusted" | "on-failure" | "on-request" | "never";
+
+type ExecPolicyAmendment = Array<string>;
+
+type CommandExecutionApprovalDecision = "accept" | "acceptForSession" | {
+    "acceptWithExecpolicyAmendment": {
+        execpolicy_amendment: ExecPolicyAmendment;
+    };
+} | "decline" | "cancel";
+
+type CommandAction = {
+    "type": "read";
+    command: string;
+    name: string;
+    path: string;
+} | {
+    "type": "listFiles";
+    command: string;
+    path: string | null;
+} | {
+    "type": "search";
+    command: string;
+    query: string | null;
+    path: string | null;
+} | {
+    "type": "unknown";
+    command: string;
+};
+
+type CommandExecutionRequestApprovalParams = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    /**
+     * Unique identifier for this specific approval callback.
+     *
+     * For regular shell/unified_exec approvals, this is null.
+     *
+     * For zsh-exec-bridge subcommand approvals, multiple callbacks can belong to
+     * one parent `itemId`, so `approvalId` is a distinct opaque callback id
+     * (a UUID) used to disambiguate routing.
+     */
+    approvalId?: string | null;
+    /**
+     * Optional explanatory reason (e.g. request for network access).
+     */
+    reason?: string | null;
+    /**
+     * The command to be executed.
+     */
+    command?: string | null;
+    /**
+     * The command's working directory.
+     */
+    cwd?: string | null;
+    /**
+     * Best-effort parsed command actions for friendly display.
+     */
+    commandActions?: Array<CommandAction> | null;
+    /**
+     * Optional proposed execpolicy amendment to allow similar commands without prompting.
+     */
+    proposedExecpolicyAmendment?: ExecPolicyAmendment | null;
+};
+
+type CommandExecutionRequestApprovalResponse = {
+    decision: CommandExecutionApprovalDecision;
+};
+
+type FileChangeApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
+
+type FileChangeRequestApprovalParams = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    /**
+     * Optional explanatory reason (e.g. request for extra write access).
+     */
+    reason?: string | null;
+    /**
+     * [UNSTABLE] When set, the agent is asking the user to allow writes under this root
+     * for the remainder of the session (unclear if this is honored today).
+     */
+    grantRoot?: string | null;
+};
+
+type FileChangeRequestApprovalResponse = {
+    decision: FileChangeApprovalDecision;
+};
+
+type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+
+/**
+ * Hand-maintained subset of the Codex app-server protocol types.
+ *
+ * Only includes types this provider actively uses. When adding new types,
+ * check the full generated set first:
+ *
+ *   npm run codex:generate-types
+ *
+ * The generated types land in src/protocol/app-server-protocol/ (gitignored)
+ * and serve as the authoritative reference. V2 types (camelCase) are in the v2/ subdirectory.
+ */
+
+interface JsonRpcMessageBase {
+    id?: number | string;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface CodexInitializeParams {
+    clientInfo: {
+        name: string;
+        version: string;
+        title?: string;
+    };
+    capabilities?: {
+        experimentalApi?: boolean;
+    };
+}
+interface CodexInitializeResult {
+    serverInfo?: {
+        name: string;
+        version: string;
+    };
+}
+interface CodexInitializedNotification {
+    method: "initialized";
+    params?: Record<string, never>;
+}
+interface CodexDynamicToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+interface CodexThreadStartParams {
+    model?: string;
+    cwd?: string;
+    approvalPolicy?: AskForApproval;
+    sandbox?: SandboxMode;
+    dynamicTools?: CodexDynamicToolDefinition[];
+    developerInstructions?: string;
+}
+interface CodexThreadStartResult {
+    threadId: string;
+    tools?: CodexDynamicToolDefinition[];
+}
+interface CodexThreadResumeParams {
+    threadId: string;
+    persistExtendedHistory: boolean;
+    developerInstructions?: string;
+}
+interface CodexThreadResumeResult {
+    thread?: {
+        id?: string;
+    };
+    threadId?: string;
+}
+interface CodexTurnInputText {
+    type: "text";
+    text: string;
+    text_elements: Array<{
+        start: number;
+        end: number;
+        type: "mention" | "skill";
+    }>;
+}
+interface CodexTurnInputImage {
+    type: "image";
+    url: string;
+}
+interface CodexTurnInputLocalImage {
+    type: "localImage";
+    path: string;
+}
+interface CodexTurnInputSkill {
+    type: "skill";
+    name: string;
+    path: string;
+}
+interface CodexTurnInputMention {
+    type: "mention";
+    name: string;
+    path: string;
+}
+type CodexTurnInputItem = CodexTurnInputText | CodexTurnInputImage | CodexTurnInputLocalImage | CodexTurnInputSkill | CodexTurnInputMention;
+interface CodexTurnStartParams {
+    threadId: string;
+    input: CodexTurnInputItem[];
+}
+interface CodexTurnStartResult {
+    turnId: string;
+}
+interface CodexTurnStartedNotification {
+    method: "turn/started";
+    params: {
+        threadId: string;
+        turnId: string;
+    };
+}
+interface CodexTurnCompletedNotification {
+    method: "turn/completed";
+    params: {
+        threadId: string;
+        turnId: string;
+        status: "completed" | "interrupted" | "failed";
+    };
+}
+interface CodexItemStartedNotification {
+    method: "item/started";
+    params: {
+        threadId: string;
+        turnId: string;
+        itemId: string;
+        itemType: string;
+    };
+}
+interface CodexItemCompletedNotification {
+    method: "item/completed";
+    params: {
+        threadId: string;
+        turnId: string;
+        itemId: string;
+        itemType: string;
+    };
+}
+interface CodexAgentMessageDeltaNotification {
+    method: "item/agentMessage/delta";
+    params: {
+        threadId: string;
+        turnId: string;
+        itemId: string;
+        delta: string;
+    };
+}
+interface CodexToolCallStartedNotification {
+    method: "item/tool/callStarted";
+    params: {
+        callId: string;
+        tool: string;
+    };
+}
+interface CodexToolCallDeltaNotification {
+    method: "item/tool/callDelta";
+    params: {
+        callId: string;
+        delta: string;
+    };
+}
+interface CodexToolCallFinishedNotification {
+    method: "item/tool/callFinished";
+    params: {
+        callId: string;
+    };
+}
+interface CodexToolCallRequestParams {
+    threadId?: string;
+    turnId?: string;
+    callId?: string;
+    tool?: string;
+    toolName?: string;
+    arguments?: unknown;
+    input?: unknown;
+}
+type CodexToolResultContentItem = {
+    type: "inputText";
+    text: string;
+} | {
+    type: "inputImage";
+    imageUrl: string;
+};
+interface CodexToolCallResult {
+    success: boolean;
+    contentItems: CodexToolResultContentItem[];
+}
+type CodexNotification = CodexInitializedNotification | CodexTurnStartedNotification | CodexTurnCompletedNotification | CodexItemStartedNotification | CodexItemCompletedNotification | CodexAgentMessageDeltaNotification | CodexToolCallStartedNotification | CodexToolCallDeltaNotification | CodexToolCallFinishedNotification;
+
+type JsonRpcId = string | number;
+interface JsonRpcRequest {
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcNotification {
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcSuccessResponse {
+    id: JsonRpcId;
+    result: unknown;
+}
+interface JsonRpcErrorResponse {
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type CodexTransportEventMap = {
+    message: (message: JsonRpcMessage) => void;
+    error: (error: unknown) => void;
+    close: (code: number | null, signal: NodeJS.Signals | null) => void;
+};
+interface CodexTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: JsonRpcMessage): Promise<void>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    on<K extends keyof CodexTransportEventMap>(event: K, listener: CodexTransportEventMap[K]): () => void;
+}
+
+declare class JsonRpcError extends CodexProviderError {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    });
+}
+interface AppServerClientSettings {
+    requestTimeoutMs?: number;
+}
+type NotificationHandler = (params: unknown) => void | Promise<void>;
+type AnyNotificationHandler = (method: string, params: unknown) => void | Promise<void>;
+type RequestHandler = (params: unknown, request: JsonRpcRequest) => unknown;
+type ToolCallRequestHandler = (params: CodexToolCallRequestParams, request: JsonRpcRequest) => CodexToolCallResult | Promise<CodexToolCallResult>;
+declare class AppServerClient {
+    private readonly transport;
+    private readonly requestTimeoutMs;
+    private nextId;
+    private readonly pendingRequests;
+    private readonly notificationHandlers;
+    private readonly anyNotificationHandlers;
+    private readonly requestHandlers;
+    private removeMessageListener;
+    private removeErrorListener;
+    constructor(transport: CodexTransport, settings?: AppServerClientSettings);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    request<TResult>(method: string, params?: unknown, timeoutMs?: number): Promise<TResult>;
+    notification(method: string, params?: unknown): Promise<void>;
+    onNotification(method: string, handler: NotificationHandler): () => void;
+    onAnyNotification(handler: AnyNotificationHandler): () => void;
+    onRequest(method: string, handler: RequestHandler): () => void;
+    onToolCallRequest(handler: ToolCallRequestHandler): () => void;
+    private handleMessage;
+    private handleResponse;
+    private handleNotification;
+    private handleInboundRequest;
+}
+
+interface CodexCommandApprovalRequest {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    approvalId?: string | null;
+    reason?: string | null;
+    command?: string | null;
+    cwd?: string | null;
+}
+interface CodexFileChangeApprovalRequest {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    reason?: string | null;
+    grantRoot?: string | null;
+}
+type CommandApprovalHandler = (request: CodexCommandApprovalRequest) => CommandExecutionApprovalDecision | Promise<CommandExecutionApprovalDecision>;
+type FileChangeApprovalHandler = (request: CodexFileChangeApprovalRequest) => FileChangeApprovalDecision | Promise<FileChangeApprovalDecision>;
+interface ApprovalsDispatcherSettings {
+    onCommandApproval?: CommandApprovalHandler;
+    onFileChangeApproval?: FileChangeApprovalHandler;
+}
+declare class ApprovalsDispatcher {
+    private readonly onCommandApproval;
+    private readonly onFileChangeApproval;
+    constructor(settings?: ApprovalsDispatcherSettings);
+    attach(client: AppServerClient): () => void;
+}
+
+interface CodexWorkerSettings {
+    transportFactory: () => CodexTransport;
+    idleTimeoutMs: number;
+}
+interface PendingToolCall {
+    requestId: JsonRpcId;
+    callId: string;
+    toolName: string;
+    args: unknown;
+    threadId: string;
+}
+declare class CodexWorker {
+    state: "idle" | "busy" | "disconnected";
+    initialized: boolean;
+    initializeResult: unknown;
+    pendingToolCall: PendingToolCall | null;
+    private inner;
+    private readonly settings;
+    private idleTimer;
+    private sessionListeners;
+    constructor(settings: CodexWorkerSettings);
+    ensureConnected(): Promise<void>;
+    acquire(): void;
+    release(): void;
+    markInitialized(result: unknown): void;
+    onSession<K extends keyof CodexTransportEventMap>(event: K, listener: CodexTransportEventMap[K]): () => void;
+    clearSessionListeners(): void;
+    sendMessage(message: JsonRpcMessage): Promise<void>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+interface CodexWorkerPoolSettings {
+    poolSize?: number;
+    transportFactory: () => CodexTransport;
+    idleTimeoutMs?: number;
+}
+declare class CodexWorkerPool {
+    private readonly workers;
+    private shutdownCalled;
+    constructor(settings: CodexWorkerPoolSettings);
+    acquire(): CodexWorker;
+    release(worker: CodexWorker): void;
+    shutdown(): Promise<void>;
+}
+
+interface PersistentTransportSettings {
+    pool: CodexWorkerPool;
+}
+declare class PersistentTransport implements CodexTransport {
+    private readonly pool;
+    private worker;
+    private pendingInitializeId;
+    private initializeIntercepted;
+    private readonly messageListeners;
+    private readonly errorListeners;
+    private readonly closeListeners;
+    constructor(settings: PersistentTransportSettings);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: JsonRpcMessage): Promise<void>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    on<K extends keyof CodexTransportEventMap>(event: K, listener: CodexTransportEventMap[K]): () => void;
+    getPendingToolCall(): PendingToolCall | null;
+    respondToToolCall(result: CodexToolCallResult): Promise<void>;
+    parkToolCall(pending: PendingToolCall): void;
+}
+
+interface StdioTransportSettings {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+declare class StdioTransport implements CodexTransport {
+    private readonly settings;
+    private process;
+    private readonly listeners;
+    private stdoutBuffer;
+    constructor(settings?: StdioTransportSettings);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: JsonRpcMessage): Promise<void>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    on<K extends keyof CodexTransportEventMap>(event: K, listener: CodexTransportEventMap[K]): () => void;
+    private handleStdoutChunk;
+    private emit;
+}
+
+interface WebSocketTransportSettings {
+    url?: string;
+    headers?: Record<string, string>;
+}
+declare class WebSocketTransport implements CodexTransport {
+    private readonly settings;
+    private socket;
+    private readonly listeners;
+    constructor(settings?: WebSocketTransportSettings);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendMessage(message: JsonRpcMessage): Promise<void>;
+    sendNotification(method: string, params?: unknown): Promise<void>;
+    on<K extends keyof CodexTransportEventMap>(event: K, listener: CodexTransportEventMap[K]): () => void;
+    private handleIncomingMessage;
+    private emit;
+}
+
+interface DynamicToolExecutionContext {
+    threadId?: string;
+    turnId?: string;
+    callId?: string;
+    toolName: string;
+}
+type DynamicToolHandler = (args: unknown, context: DynamicToolExecutionContext) => Promise<CodexToolCallResult>;
+/** Full tool definition: schema advertised to Codex + local execution handler. */
+interface DynamicToolDefinition {
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute: DynamicToolHandler;
+}
+interface DynamicToolsDispatcherSettings {
+    /** Tools with full schema advertised to Codex. Handlers are registered automatically. */
+    tools?: Record<string, DynamicToolDefinition>;
+    /** Legacy handler-only registration (no schema). Tools are not advertised to Codex. */
+    handlers?: Record<string, DynamicToolHandler>;
+    timeoutMs?: number;
+}
+declare class DynamicToolsDispatcher {
+    private readonly handlers;
+    private readonly timeoutMs;
+    constructor(settings?: DynamicToolsDispatcherSettings);
+    register(name: string, handler: DynamicToolHandler): void;
+    attach(client: AppServerClient): () => void;
+    dispatch(params: CodexToolCallRequestParams): Promise<CodexToolCallResult>;
+}
+
+interface CodexLanguageModelSettings {
+}
+interface CodexThreadDefaults {
+    cwd?: string;
+    approvalPolicy?: AskForApproval;
+    sandbox?: SandboxMode;
+}
+interface CodexModelConfig {
+    provider: string;
+    providerSettings: {
+        defaultModel?: string;
+        clientInfo?: {
+            name: string;
+            version: string;
+            title?: string;
+        };
+        experimentalApi?: boolean;
+        transport?: {
+            type?: "stdio" | "websocket";
+            stdio?: StdioTransportSettings;
+            websocket?: WebSocketTransportSettings;
+        };
+        defaultThreadSettings?: CodexThreadDefaults;
+        transportFactory?: () => CodexTransport;
+        tools?: Record<string, DynamicToolDefinition>;
+        toolHandlers?: Record<string, DynamicToolHandler>;
+        toolTimeoutMs?: number;
+        approvals?: {
+            onCommandApproval?: CommandApprovalHandler;
+            onFileChangeApproval?: FileChangeApprovalHandler;
+        };
+    };
+}
+declare class CodexLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion: "v3";
+    readonly provider: string;
+    readonly modelId: string;
+    readonly supportedUrls: Record<string, RegExp[]>;
+    private readonly settings;
+    private readonly config;
+    constructor(modelId: string, settings: CodexLanguageModelSettings, config: CodexModelConfig);
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    private registerCrossCallToolHandler;
+    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+}
+
+/** Package name from package.json. */
+declare const PACKAGE_NAME: string;
+/** Package version from package.json. */
+declare const PACKAGE_VERSION: string;
+
+interface CodexEventMapperInput {
+    method: string;
+    params?: unknown;
+}
+declare class CodexEventMapper {
+    private streamStarted;
+    private readonly openTextParts;
+    private threadId;
+    setThreadId(threadId: string): void;
+    map(event: CodexEventMapperInput): LanguageModelV3StreamPart[];
+}
+
+/**
+ * Extracts system messages from the prompt and concatenates them into a single
+ * string suitable for `developerInstructions` on `thread/start` or
+ * `thread/resume`.  Returns `undefined` when no system content is present.
+ */
+declare function mapSystemPrompt(prompt: LanguageModelV3Prompt): string | undefined;
+/**
+ * Maps the prompt to the `input` array for a `turn/start` request.
+ *
+ * System messages are **not** included here — they are routed to
+ * `developerInstructions` via {@link mapSystemPrompt} instead.
+ *
+ * @param isResume - When true the thread already holds the full history on
+ *   disk, so only the last user message is extracted and sent.  When false
+ *   (fresh thread) all user text is folded into a single item.
+ */
+declare function mapPromptToTurnInput(prompt: LanguageModelV3Prompt, isResume?: boolean): CodexTurnInputItem[];
+
+declare const CODEX_PROVIDER_ID = "codex-app-server";
+declare function codexProviderMetadata(threadId: string | undefined): {
+    "codex-app-server": {
+        threadId: string;
+    };
+} | undefined;
+declare function withProviderMetadata<T extends LanguageModelV3StreamPart>(part: T, threadId: string | undefined): T;
+
+interface CodexProviderSettings {
+    defaultModel?: string;
+    clientInfo?: {
+        name: string;
+        version: string;
+        title?: string;
+    };
+    experimentalApi?: boolean;
+    transport?: {
+        type?: "stdio" | "websocket";
+        stdio?: StdioTransportSettings;
+        websocket?: WebSocketTransportSettings;
+    };
+    defaultThreadSettings?: CodexThreadDefaults;
+    transportFactory?: () => CodexTransport;
+    /** Tools with schema (description + inputSchema) advertised to Codex + local handlers. */
+    tools?: Record<string, DynamicToolDefinition>;
+    /** Legacy: handler-only tools, not advertised to Codex. Use `tools` for full schema support. */
+    toolHandlers?: Record<string, DynamicToolHandler>;
+    toolTimeoutMs?: number;
+    approvals?: {
+        onCommandApproval?: CommandApprovalHandler;
+        onFileChangeApproval?: FileChangeApprovalHandler;
+    };
+    persistent?: {
+        poolSize?: number;
+        idleTimeoutMs?: number;
+        scope?: "provider" | "global";
+        key?: string;
+    };
+}
+interface CodexProvider extends ProviderV3 {
+    (modelId: string, settings?: CodexLanguageModelSettings): CodexLanguageModel;
+    chat(modelId: string, settings?: CodexLanguageModelSettings): CodexLanguageModel;
+    readonly settings: Readonly<CodexProviderSettings>;
+    shutdown(): Promise<void>;
+}
+declare function createCodexAppServer(settings?: CodexProviderSettings): CodexProvider;
+declare const codexAppServer: CodexProvider;
+/**
+ * Backward-compatible alias kept during migration from scaffold naming.
+ */
+declare const createCodexProvider: typeof createCodexAppServer;
+
+export { AppServerClient, type AppServerClientSettings, ApprovalsDispatcher, type ApprovalsDispatcherSettings, type AskForApproval, CODEX_PROVIDER_ID, type CodexAgentMessageDeltaNotification, type CodexCommandApprovalRequest, type CodexDynamicToolDefinition, CodexEventMapper, type CodexEventMapperInput, type CodexFileChangeApprovalRequest, type CodexInitializeParams, type CodexInitializeResult, type CodexInitializedNotification, type CodexItemCompletedNotification, type CodexItemStartedNotification, CodexLanguageModel, type CodexLanguageModelSettings, type CodexModelConfig, CodexNotImplementedError, type CodexNotification, type CodexProvider, CodexProviderError, type CodexProviderSettings, type CodexThreadDefaults, type CodexThreadResumeParams, type CodexThreadResumeResult, type CodexThreadStartParams, type CodexThreadStartResult, type CodexToolCallDeltaNotification, type CodexToolCallFinishedNotification, type CodexToolCallRequestParams, type CodexToolCallResult, type CodexToolCallStartedNotification, type CodexToolResultContentItem, type CodexTransport, type CodexTransportEventMap, type CodexTurnCompletedNotification, type CodexTurnInputImage, type CodexTurnInputItem, type CodexTurnInputLocalImage, type CodexTurnInputMention, type CodexTurnInputSkill, type CodexTurnInputText, type CodexTurnStartParams, type CodexTurnStartResult, type CodexTurnStartedNotification, CodexWorker, CodexWorkerPool, type CodexWorkerPoolSettings, type CodexWorkerSettings, type CommandApprovalHandler, type CommandExecutionApprovalDecision, type CommandExecutionRequestApprovalParams, type CommandExecutionRequestApprovalResponse, type DynamicToolDefinition, type DynamicToolExecutionContext, type DynamicToolHandler, DynamicToolsDispatcher, type DynamicToolsDispatcherSettings, type FileChangeApprovalDecision, type FileChangeApprovalHandler, type FileChangeRequestApprovalParams, type FileChangeRequestApprovalResponse, JsonRpcError, type JsonRpcErrorResponse, type JsonRpcId, type JsonRpcMessage, type JsonRpcMessageBase, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccessResponse, PACKAGE_NAME, PACKAGE_VERSION, type PendingToolCall, PersistentTransport, type PersistentTransportSettings, type SandboxMode, StdioTransport, type StdioTransportSettings, WebSocketTransport, type WebSocketTransportSettings, codexAppServer, codexProviderMetadata, createCodexAppServer, createCodexProvider, mapPromptToTurnInput, mapSystemPrompt, withProviderMetadata };