@jrkropp/codex-js 0.1.0

package/dist/session-BO6EZNK7.d.ts

@@ -0,0 +1,1829 @@
+import { aL as ThreadId, aM as AbsolutePathBuf, J as JsonValue, aN as ThreadSource, aO as UserInput, aP as ReasoningEffort, aQ as WindowsSandboxSetupMode, l as RequestId, aR as Thread, aS as Turn, S as ServerNotification, a as ServerRequest } from './thread_event_store-BIS0qzhi.js';
+
+type ClientInfo = {
+    name: string;
+    title: string | null;
+    version: string;
+};
+
+type FuzzyFileSearchParams = {
+    query: string;
+    roots: Array<string>;
+    cancellationToken: string | null;
+};
+
+type GetAuthStatusParams = {
+    includeToken: boolean | null;
+    refreshToken: boolean | null;
+};
+
+type GetConversationSummaryParams = {
+    rolloutPath: string;
+} | {
+    conversationId: ThreadId;
+};
+
+type GitDiffToRemoteParams = {
+    cwd: string;
+};
+
+/**
+ * Client-declared capabilities negotiated during initialize.
+ */
+type InitializeCapabilities = {
+    /**
+     * Opt into receiving experimental API methods and fields.
+     */
+    experimentalApi: boolean;
+    /**
+     * Exact notification method names that should be suppressed for this
+     * connection (for example `thread/started`).
+     */
+    optOutNotificationMethods?: Array<string> | null;
+};
+
+type InitializeParams = {
+    clientInfo: ClientInfo;
+    capabilities: InitializeCapabilities | null;
+};
+
+/**
+ * EXPERIMENTAL - list available apps/connectors.
+ */
+type AppsListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a reasonable server-side value.
+     */
+    limit?: number | null;
+    /**
+     * Optional thread id used to evaluate app feature gating from that thread's config.
+     */
+    threadId?: string | null;
+    /**
+     * When true, bypass app caches and fetch the latest data from sources.
+     */
+    forceRefetch?: boolean;
+};
+
+type CancelLoginAccountParams = {
+    loginId: string;
+};
+
+/**
+ * PTY size in character cells for `command/exec` PTY sessions.
+ */
+type CommandExecTerminalSize = {
+    /**
+     * Terminal height in character cells.
+     */
+    rows: number;
+    /**
+     * Terminal width in character cells.
+     */
+    cols: number;
+};
+
+type NetworkAccess = "restricted" | "enabled";
+
+type SandboxPolicy = {
+    "type": "dangerFullAccess";
+} | {
+    "type": "readOnly";
+    networkAccess: boolean;
+} | {
+    "type": "externalSandbox";
+    networkAccess: NetworkAccess;
+} | {
+    "type": "workspaceWrite";
+    writableRoots: Array<AbsolutePathBuf>;
+    networkAccess: boolean;
+    excludeTmpdirEnvVar: boolean;
+    excludeSlashTmp: boolean;
+};
+
+/**
+ * Run a standalone command (argv vector) in the server sandbox without
+ * creating a thread or turn.
+ *
+ * The final `command/exec` response is deferred until the process exits and is
+ * sent only after all `command/exec/outputDelta` notifications for that
+ * connection have been emitted.
+ */
+type CommandExecParams = {
+    command: Array<string>; /**
+     * Optional client-supplied, connection-scoped process id.
+     *
+     * Required for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up
+     * `command/exec/write`, `command/exec/resize`, and
+     * `command/exec/terminate` calls. When omitted, buffered execution gets an
+     * internal id that is not exposed to the client.
+     */
+    processId?: string | null; /**
+     * Enable PTY mode.
+     *
+     * This implies `streamStdin` and `streamStdoutStderr`.
+     */
+    tty?: boolean; /**
+     * Allow follow-up `command/exec/write` requests to write stdin bytes.
+     *
+     * Requires a client-supplied `processId`.
+     */
+    streamStdin?: boolean; /**
+     * Stream stdout/stderr via `command/exec/outputDelta` notifications.
+     *
+     * Streamed bytes are not duplicated into the final response and require a
+     * client-supplied `processId`.
+     */
+    streamStdoutStderr?: boolean; /**
+     * Optional per-stream stdout/stderr capture cap in bytes.
+     *
+     * When omitted, the server default applies. Cannot be combined with
+     * `disableOutputCap`.
+     */
+    outputBytesCap?: number | null; /**
+     * Disable stdout/stderr capture truncation for this request.
+     *
+     * Cannot be combined with `outputBytesCap`.
+     */
+    disableOutputCap?: boolean; /**
+     * Disable the timeout entirely for this request.
+     *
+     * Cannot be combined with `timeoutMs`.
+     */
+    disableTimeout?: boolean; /**
+     * Optional timeout in milliseconds.
+     *
+     * When omitted, the server default applies. Cannot be combined with
+     * `disableTimeout`.
+     */
+    timeoutMs?: number | null; /**
+     * Optional working directory. Defaults to the server cwd.
+     */
+    cwd?: string | null; /**
+     * Optional environment overrides merged into the server-computed
+     * environment.
+     *
+     * Matching names override inherited values. Set a key to `null` to unset
+     * an inherited variable.
+     */
+    env?: {
+        [key in string]?: string | null;
+    } | null; /**
+     * Optional initial PTY size in character cells. Only valid when `tty` is
+     * true.
+     */
+    size?: CommandExecTerminalSize | null; /**
+     * Optional sandbox policy for this command.
+     *
+     * Uses the same shape as thread/turn execution sandbox configuration and
+     * defaults to the user's configured policy when omitted. Cannot be
+     * combined with `permissionProfile`.
+     */
+    sandboxPolicy?: SandboxPolicy | null;
+};
+
+/**
+ * Resize a running PTY-backed `command/exec` session.
+ */
+type CommandExecResizeParams = {
+    /**
+     * Client-supplied, connection-scoped `processId` from the original
+     * `command/exec` request.
+     */
+    processId: string;
+    /**
+     * New PTY size in character cells.
+     */
+    size: CommandExecTerminalSize;
+};
+
+/**
+ * Terminate a running `command/exec` session.
+ */
+type CommandExecTerminateParams = {
+    /**
+     * Client-supplied, connection-scoped `processId` from the original
+     * `command/exec` request.
+     */
+    processId: string;
+};
+
+/**
+ * Write stdin bytes to a running `command/exec` session, close stdin, or
+ * both.
+ */
+type CommandExecWriteParams = {
+    /**
+     * Client-supplied, connection-scoped `processId` from the original
+     * `command/exec` request.
+     */
+    processId: string;
+    /**
+     * Optional base64-encoded stdin bytes to write.
+     */
+    deltaBase64?: string | null;
+    /**
+     * Close stdin after writing `deltaBase64`, if present.
+     */
+    closeStdin?: boolean;
+};
+
+/**
+ * EXPERIMENTAL - list collaboration mode presets.
+ */
+type CollaborationModeListParams = Record<string, never>;
+
+type MergeStrategy = "replace" | "upsert";
+
+type ConfigEdit = {
+    keyPath: string;
+    value: JsonValue;
+    mergeStrategy: MergeStrategy;
+};
+
+type ConfigBatchWriteParams = {
+    edits: Array<ConfigEdit>;
+    /**
+     * Path to the config file to write; defaults to the user's `config.toml` when omitted.
+     */
+    filePath?: string | null;
+    expectedVersion?: string | null;
+    /**
+     * When true, hot-reload the updated user config into all loaded threads after writing.
+     */
+    reloadUserConfig?: boolean;
+};
+
+type ConfigReadParams = {
+    includeLayers: boolean;
+    /**
+     * Optional working directory to resolve project config layers. If specified,
+     * return the effective config as seen from that directory (i.e., including any
+     * project layers between `cwd` and the project/repo root).
+     */
+    cwd?: string | null;
+};
+
+type ConfigValueWriteParams = {
+    keyPath: string;
+    value: JsonValue;
+    mergeStrategy: MergeStrategy;
+    /**
+     * Path to the config file to write; defaults to the user's `config.toml` when omitted.
+     */
+    filePath?: string | null;
+    expectedVersion?: string | null;
+};
+
+/**
+ * Protection policy for creating or loading a controller-local device key.
+ */
+type DeviceKeyProtectionPolicy = "hardware_only" | "allow_os_protected_nonextractable";
+
+/**
+ * Create a controller-local device key with a random key id.
+ */
+type DeviceKeyCreateParams = {
+    /**
+     * Defaults to `hardware_only` when omitted.
+     */
+    protectionPolicy?: DeviceKeyProtectionPolicy | null;
+    accountUserId: string;
+    clientId: string;
+};
+
+/**
+ * Fetch a controller-local device key public key by id.
+ */
+type DeviceKeyPublicParams = {
+    keyId: string;
+};
+
+/**
+ * Audience for a remote-control client connection device-key proof.
+ */
+type RemoteControlClientConnectionAudience = "remote_control_client_websocket";
+
+/**
+ * Audience for a remote-control client enrollment device-key proof.
+ */
+type RemoteControlClientEnrollmentAudience = "remote_control_client_enrollment";
+
+/**
+ * Structured payloads accepted by `device/key/sign`.
+ */
+type DeviceKeySignPayload = {
+    "type": "remoteControlClientConnection";
+    nonce: string;
+    audience: RemoteControlClientConnectionAudience;
+    /**
+     * Backend-issued websocket session id that this proof authorizes.
+     */
+    sessionId: string;
+    /**
+     * Origin of the backend endpoint that issued the challenge and will verify this proof.
+     */
+    targetOrigin: string;
+    /**
+     * Websocket route path that this proof authorizes.
+     */
+    targetPath: string;
+    accountUserId: string;
+    clientId: string;
+    /**
+     * Remote-control token expiration as Unix seconds.
+     */
+    tokenExpiresAt: number;
+    /**
+     * SHA-256 of the controller-scoped remote-control token, encoded as unpadded base64url.
+     */
+    tokenSha256Base64url: string;
+    /**
+     * Must contain exactly `remote_control_controller_websocket`.
+     */
+    scopes: Array<string>;
+} | {
+    "type": "remoteControlClientEnrollment";
+    nonce: string;
+    audience: RemoteControlClientEnrollmentAudience;
+    /**
+     * Backend-issued enrollment challenge id that this proof authorizes.
+     */
+    challengeId: string;
+    /**
+     * Origin of the backend endpoint that issued the challenge and will verify this proof.
+     */
+    targetOrigin: string;
+    /**
+     * HTTP route path that this proof authorizes.
+     */
+    targetPath: string;
+    accountUserId: string;
+    clientId: string;
+    /**
+     * SHA-256 of the requested device identity operation, encoded as unpadded base64url.
+     */
+    deviceIdentitySha256Base64url: string;
+    /**
+     * Enrollment challenge expiration as Unix seconds.
+     */
+    challengeExpiresAt: number;
+};
+
+/**
+ * Sign an accepted structured payload with a controller-local device key.
+ */
+type DeviceKeySignParams = {
+    keyId: string;
+    payload: DeviceKeySignPayload;
+};
+
+type ExperimentalFeatureEnablementSetParams = {
+    /**
+     * Process-wide runtime feature enablement keyed by canonical feature name.
+     *
+     * Only named features are updated. Omitted features are left unchanged.
+     * Send an empty map for a no-op.
+     */
+    enablement: {
+        [key in string]?: boolean;
+    };
+};
+
+type ExperimentalFeatureListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a reasonable server-side value.
+     */
+    limit?: number | null;
+};
+
+type ExternalAgentConfigDetectParams = {
+    /**
+     * If true, include detection under the user's home (~/.claude, ~/.codex, etc.).
+     */
+    includeHome?: boolean;
+    /**
+     * Zero or more working directories to include for repo-scoped detection.
+     */
+    cwds?: Array<string> | null;
+};
+
+type ExternalAgentConfigMigrationItemType = "AGENTS_MD" | "CONFIG" | "SKILLS" | "PLUGINS" | "MCP_SERVER_CONFIG" | "SUBAGENTS" | "HOOKS" | "COMMANDS" | "SESSIONS";
+
+type CommandMigration = {
+    name: string;
+};
+
+type HookMigration = {
+    name: string;
+};
+
+type McpServerMigration = {
+    name: string;
+};
+
+type PluginsMigration = {
+    marketplaceName: string;
+    pluginNames: Array<string>;
+};
+
+type SessionMigration = {
+    path: string;
+    cwd: string;
+    title: string | null;
+};
+
+type SubagentMigration = {
+    name: string;
+};
+
+type MigrationDetails = {
+    plugins: Array<PluginsMigration>;
+    sessions: Array<SessionMigration>;
+    mcpServers: Array<McpServerMigration>;
+    hooks: Array<HookMigration>;
+    subagents: Array<SubagentMigration>;
+    commands: Array<CommandMigration>;
+};
+
+type ExternalAgentConfigMigrationItem = {
+    itemType: ExternalAgentConfigMigrationItemType;
+    description: string;
+    /**
+     * Null or empty means home-scoped migration; non-empty means repo-scoped migration.
+     */
+    cwd: string | null;
+    details: MigrationDetails | null;
+};
+
+type ExternalAgentConfigImportParams = {
+    migrationItems: Array<ExternalAgentConfigMigrationItem>;
+};
+
+type FeedbackUploadParams = {
+    classification: string;
+    reason?: string | null;
+    threadId?: string | null;
+    includeLogs: boolean;
+    extraLogFiles?: Array<string> | null;
+    tags?: {
+        [key in string]?: string;
+    } | null;
+};
+
+/**
+ * Copy a file or directory tree on the host filesystem.
+ */
+type FsCopyParams = {
+    /**
+     * Absolute source path.
+     */
+    sourcePath: AbsolutePathBuf;
+    /**
+     * Absolute destination path.
+     */
+    destinationPath: AbsolutePathBuf;
+    /**
+     * Required for directory copies; ignored for file copies.
+     */
+    recursive?: boolean;
+};
+
+/**
+ * Create a directory on the host filesystem.
+ */
+type FsCreateDirectoryParams = {
+    /**
+     * Absolute directory path to create.
+     */
+    path: AbsolutePathBuf;
+    /**
+     * Whether parent directories should also be created. Defaults to `true`.
+     */
+    recursive?: boolean | null;
+};
+
+/**
+ * Request metadata for an absolute path.
+ */
+type FsGetMetadataParams = {
+    /**
+     * Absolute path to inspect.
+     */
+    path: AbsolutePathBuf;
+};
+
+/**
+ * List direct child names for a directory.
+ */
+type FsReadDirectoryParams = {
+    /**
+     * Absolute directory path to read.
+     */
+    path: AbsolutePathBuf;
+};
+
+/**
+ * Read a file from the host filesystem.
+ */
+type FsReadFileParams = {
+    /**
+     * Absolute path to read.
+     */
+    path: AbsolutePathBuf;
+};
+
+/**
+ * Remove a file or directory tree from the host filesystem.
+ */
+type FsRemoveParams = {
+    /**
+     * Absolute path to remove.
+     */
+    path: AbsolutePathBuf;
+    /**
+     * Whether directory removal should recurse. Defaults to `true`.
+     */
+    recursive?: boolean | null;
+    /**
+     * Whether missing paths should be ignored. Defaults to `true`.
+     */
+    force?: boolean | null;
+};
+
+/**
+ * Stop filesystem watch notifications for a prior `fs/watch`.
+ */
+type FsUnwatchParams = {
+    /**
+     * Watch identifier previously provided to `fs/watch`.
+     */
+    watchId: string;
+};
+
+/**
+ * Start filesystem watch notifications for an absolute path.
+ */
+type FsWatchParams = {
+    /**
+     * Connection-scoped watch identifier used for `fs/unwatch` and `fs/changed`.
+     */
+    watchId: string;
+    /**
+     * Absolute file or directory path to watch.
+     */
+    path: AbsolutePathBuf;
+};
+
+/**
+ * Write a file on the host filesystem.
+ */
+type FsWriteFileParams = {
+    /**
+     * Absolute path to write.
+     */
+    path: AbsolutePathBuf;
+    /**
+     * File contents encoded as base64.
+     */
+    dataBase64: string;
+};
+
+type GetAccountParams = {
+    /**
+     * When `true`, requests a proactive token refresh before returning.
+     *
+     * In managed auth mode this triggers the normal refresh-token flow. In
+     * external auth mode this flag is ignored. Clients should refresh tokens
+     * themselves and call `account/login/start` with `chatgptAuthTokens`.
+     */
+    refreshToken: boolean;
+};
+
+type HooksListParams = {
+    /**
+     * When empty, defaults to the current session working directory.
+     */
+    cwds?: Array<string>;
+};
+
+type McpServerStatusDetail = "full" | "toolsAndAuthOnly";
+
+type ListMcpServerStatusParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a server-defined value.
+     */
+    limit?: number | null;
+    /**
+     * Controls how much MCP inventory data to fetch for each server.
+     * Defaults to `Full` when omitted.
+     */
+    detail?: McpServerStatusDetail | null;
+};
+
+type LoginAccountParams = {
+    "type": "apiKey";
+    apiKey: string;
+} | {
+    "type": "chatgpt";
+    codexStreamlinedLogin?: boolean;
+} | {
+    "type": "chatgptDeviceCode";
+} | {
+    "type": "chatgptAuthTokens";
+    /**
+     * Access token (JWT) supplied by the client.
+     * This token is used for backend API requests and email extraction.
+     */
+    accessToken: string;
+    /**
+     * Workspace/account identifier supplied by the client.
+     */
+    chatgptAccountId: string;
+    /**
+     * Optional plan type supplied by the client.
+     *
+     * When `null`, Codex attempts to derive the plan type from access-token
+     * claims. If unavailable, the plan defaults to `unknown`.
+     */
+    chatgptPlanType?: string | null;
+};
+
+type MarketplaceAddParams = {
+    source: string;
+    refName?: string | null;
+    sparsePaths?: Array<string> | null;
+};
+
+type MarketplaceRemoveParams = {
+    marketplaceName: string;
+};
+
+type MarketplaceUpgradeParams = {
+    marketplaceName?: string | null;
+};
+
+type McpResourceReadParams = {
+    threadId?: string | null;
+    server: string;
+    uri: string;
+};
+
+type McpServerOauthLoginParams = {
+    name: string;
+    scopes?: Array<string> | null;
+    timeoutSecs?: bigint | null;
+};
+
+type McpServerToolCallParams = {
+    threadId: string;
+    server: string;
+    tool: string;
+    arguments?: JsonValue;
+    _meta?: JsonValue;
+};
+
+type ModelListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a reasonable server-side value.
+     */
+    limit?: number | null;
+    /**
+     * When true, include models that are hidden from the default picker list.
+     */
+    includeHidden?: boolean | null;
+};
+
+type ModelProviderCapabilitiesReadParams = Record<string, never>;
+
+type PluginInstallParams = {
+    marketplacePath?: AbsolutePathBuf | null;
+    remoteMarketplaceName?: string | null;
+    pluginName: string;
+};
+
+type PluginListMarketplaceKind = "local" | "workspace-directory" | "shared-with-me";
+
+type PluginListParams = {
+    /**
+     * Optional working directories used to discover repo marketplaces. When omitted,
+     * only home-scoped marketplaces and the official curated marketplace are considered.
+     */
+    cwds?: Array<AbsolutePathBuf> | null;
+    /**
+     * Optional marketplace kind filter. When omitted, only local marketplaces are queried, plus
+     * the default remote catalog when enabled by feature flag.
+     */
+    marketplaceKinds?: Array<PluginListMarketplaceKind> | null;
+};
+
+type PluginReadParams = {
+    marketplacePath?: AbsolutePathBuf | null;
+    remoteMarketplaceName?: string | null;
+    pluginName: string;
+};
+
+type PluginShareDeleteParams = {
+    remotePluginId: string;
+};
+
+type PluginShareListParams = Record<string, never>;
+
+type PluginShareDiscoverability = "LISTED" | "UNLISTED" | "PRIVATE";
+
+type PluginSharePrincipalType = "user" | "group" | "workspace";
+
+type PluginShareTarget = {
+    principalType: PluginSharePrincipalType;
+    principalId: string;
+};
+
+type PluginShareSaveParams = {
+    pluginPath: AbsolutePathBuf;
+    remotePluginId?: string | null;
+    discoverability?: PluginShareDiscoverability | null;
+    shareTargets?: Array<PluginShareTarget> | null;
+};
+
+type PluginShareUpdateTargetsParams = {
+    remotePluginId: string;
+    shareTargets: Array<PluginShareTarget>;
+};
+
+type PluginSkillReadParams = {
+    remoteMarketplaceName: string;
+    remotePluginId: string;
+    skillName: string;
+};
+
+type PluginUninstallParams = {
+    pluginId: string;
+};
+
+type ReviewDelivery = "inline" | "detached";
+
+type ReviewTarget = {
+    "type": "uncommittedChanges";
+} | {
+    "type": "baseBranch";
+    branch: string;
+} | {
+    "type": "commit";
+    sha: string;
+    /**
+     * Optional human-readable label (e.g., commit subject) for UIs.
+     */
+    title: string | null;
+} | {
+    "type": "custom";
+    instructions: string;
+};
+
+type ReviewStartParams = {
+    threadId: string;
+    target: ReviewTarget;
+    /**
+     * Where to run the review: inline (default) on the current thread or
+     * detached on a new thread (returned in `reviewThreadId`).
+     */
+    delivery?: ReviewDelivery | null;
+};
+
+type AddCreditsNudgeCreditType = "credits" | "usage_limit";
+
+type SendAddCreditsNudgeEmailParams = {
+    creditType: AddCreditsNudgeCreditType;
+};
+
+type SkillsConfigWriteParams = {
+    /**
+     * Path-based selector.
+     */
+    path?: AbsolutePathBuf | null;
+    /**
+     * Name-based selector.
+     */
+    name?: string | null;
+    enabled: boolean;
+};
+
+type SkillsListExtraRootsForCwd = {
+    cwd: string;
+    extraUserRoots: Array<string>;
+};
+
+type SkillsListParams = {
+    /**
+     * When empty, defaults to the current session working directory.
+     */
+    cwds?: Array<string>;
+    /**
+     * When true, bypass the skills cache and re-scan skills from disk.
+     */
+    forceReload?: boolean;
+    /**
+     * Optional per-cwd extra roots to scan as user-scoped skills.
+     */
+    perCwdExtraUserRoots?: Array<SkillsListExtraRootsForCwd> | null;
+};
+
+type ThreadApproveGuardianDeniedActionParams = {
+    threadId: string;
+    /**
+     * Serialized `codex_protocol::protocol::GuardianAssessmentEvent`.
+     */
+    event: JsonValue;
+};
+
+type ThreadArchiveParams = {
+    threadId: string;
+};
+
+type ThreadCompactStartParams = {
+    threadId: string;
+};
+
+/**
+ * Configures who approval requests are routed to for review. Examples
+ * include sandbox escapes, blocked network access, MCP approval prompts, and
+ * ARC escalations. Defaults to `user`. `auto_review` uses a carefully
+ * prompted subagent to gather relevant context and apply a risk-based
+ * decision framework before approving or denying the request.
+ */
+type ApprovalsReviewer = "user" | "auto_review" | "guardian_subagent";
+
+type AskForApproval = "untrusted" | "on-failure" | "on-request" | {
+    "granular": {
+        sandbox_approval: boolean;
+        rules: boolean;
+        skill_approval: boolean;
+        request_permissions: boolean;
+        mcp_elicitations: boolean;
+    };
+} | "never";
+
+type SandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+
+/**
+ * There are two ways to fork a thread:
+ * 1. By thread_id: load the thread from disk by thread_id and fork it into a new thread.
+ * 2. By path: load the thread from disk by path and fork it into a new thread.
+ *
+ * If using path, the thread_id param will be ignored.
+ *
+ * Prefer using thread_id whenever possible.
+ */
+type ThreadForkParams = {
+    threadId: string; /**
+     * Configuration overrides for the forked thread, if any.
+     */
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null; /**
+     * Override where approval requests are routed for review on this thread
+     * and subsequent turns.
+     */
+    approvalsReviewer?: ApprovalsReviewer | null;
+    sandbox?: SandboxMode | null;
+    config?: {
+        [key in string]?: JsonValue;
+    } | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    ephemeral?: boolean; /**
+     * Optional client-supplied analytics source classification for this forked thread.
+     */
+    threadSource?: ThreadSource | null;
+};
+
+type ThreadInjectItemsParams = {
+    threadId: string;
+    /**
+     * Raw Responses API items to append to the thread's model-visible history.
+     */
+    items: Array<JsonValue>;
+};
+
+type SortDirection = "asc" | "desc";
+
+type ThreadSortKey = "created_at" | "updated_at";
+
+type ThreadSourceKind = "cli" | "vscode" | "exec" | "appServer" | "subAgent" | "subAgentReview" | "subAgentCompact" | "subAgentThreadSpawn" | "subAgentOther" | "unknown";
+
+type ThreadListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a reasonable server-side value.
+     */
+    limit?: number | null;
+    /**
+     * Optional sort key; defaults to created_at.
+     */
+    sortKey?: ThreadSortKey | null;
+    /**
+     * Optional sort direction; defaults to descending (newest first).
+     */
+    sortDirection?: SortDirection | null;
+    /**
+     * Optional provider filter; when set, only sessions recorded under these
+     * providers are returned. When present but empty, includes all providers.
+     */
+    modelProviders?: Array<string> | null;
+    /**
+     * Optional source filter; when set, only sessions from these source kinds
+     * are returned. When omitted or empty, defaults to interactive sources.
+     */
+    sourceKinds?: Array<ThreadSourceKind> | null;
+    /**
+     * Optional archived filter; when set to true, only archived threads are returned.
+     * If false or null, only non-archived threads are returned.
+     */
+    archived?: boolean | null;
+    /**
+     * Optional cwd filter or filters; when set, only threads whose session cwd
+     * exactly matches one of these paths are returned.
+     */
+    cwd?: string | Array<string> | null;
+    /**
+     * If true, return from the state DB without scanning JSONL rollouts to
+     * repair thread metadata. Omitted or false preserves scan-and-repair
+     * behavior.
+     */
+    useStateDbOnly?: boolean;
+    /**
+     * Optional substring filter for the extracted thread title.
+     */
+    searchTerm?: string | null;
+};
+
+type ThreadLoadedListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to no limit.
+     */
+    limit?: number | null;
+};
+
+type ThreadMetadataGitInfoUpdateParams = {
+    /**
+     * Omit to leave the stored commit unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    sha?: string | null;
+    /**
+     * Omit to leave the stored branch unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    branch?: string | null;
+    /**
+     * Omit to leave the stored origin URL unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    originUrl?: string | null;
+};
+
+type ThreadMetadataUpdateParams = {
+    threadId: string;
+    /**
+     * Patch the stored Git metadata for this thread.
+     * Omit a field to leave it unchanged, set it to `null` to clear it, or
+     * provide a string to replace the stored value.
+     */
+    gitInfo?: ThreadMetadataGitInfoUpdateParams | null;
+};
+
+type ThreadReadParams = {
+    threadId: string;
+    /**
+     * When true, include turns and their items from rollout history.
+     */
+    includeTurns: boolean;
+};
+
+type Personality = "none" | "friendly" | "pragmatic";
+
+/**
+ * There are three ways to resume a thread:
+ * 1. By thread_id: load the thread from disk by thread_id and resume it.
+ * 2. By history: instantiate the thread from memory and resume it.
+ * 3. By path: load the thread from disk by path and resume it.
+ *
+ * The precedence is: history > path > thread_id.
+ * If using history or path, the thread_id param will be ignored.
+ *
+ * Prefer using thread_id whenever possible.
+ */
+type ThreadResumeParams = {
+    threadId: string; /**
+     * Configuration overrides for the resumed thread, if any.
+     */
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null; /**
+     * Override where approval requests are routed for review on this thread
+     * and subsequent turns.
+     */
+    approvalsReviewer?: ApprovalsReviewer | null;
+    sandbox?: SandboxMode | null;
+    config?: {
+        [key in string]?: JsonValue;
+    } | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    personality?: Personality | null;
+};
+
+type ThreadRollbackParams = {
+    threadId: string;
+    /**
+     * The number of turns to drop from the end of the thread. Must be >= 1.
+     *
+     * This only modifies the thread's history and does not revert local file changes
+     * that have been made by the agent. Clients are responsible for reverting these changes.
+     */
+    numTurns: number;
+};
+
+type ThreadSetNameParams = {
+    threadId: string;
+    name: string;
+};
+
+type ThreadShellCommandParams = {
+    threadId: string;
+    /**
+     * Shell command string evaluated by the thread's configured shell.
+     * Unlike `command/exec`, this intentionally preserves shell syntax
+     * such as pipes, redirects, and quoting. This runs unsandboxed with full
+     * access rather than inheriting the thread sandbox policy.
+     */
+    command: string;
+};
+
+type ThreadStartSource = "startup" | "clear";
+
+type ThreadStartParams = {
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null; /**
+     * Override where approval requests are routed for review on this thread
+     * and subsequent turns.
+     */
+    approvalsReviewer?: ApprovalsReviewer | null;
+    sandbox?: SandboxMode | null;
+    config?: {
+        [key in string]?: JsonValue;
+    } | null;
+    serviceName?: string | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    personality?: Personality | null;
+    ephemeral?: boolean | null;
+    sessionStartSource?: ThreadStartSource | null; /**
+     * Optional client-supplied analytics source classification for this thread.
+     */
+    threadSource?: ThreadSource | null;
+};
+
+type ThreadUnarchiveParams = {
+    threadId: string;
+};
+
+type ThreadUnsubscribeParams = {
+    threadId: string;
+};
+
+type TurnInterruptParams = {
+    threadId: string;
+    turnId: string;
+};
+
+/**
+ * A summary of the reasoning performed by the model. This can be useful for
+ * debugging and understanding the model's reasoning process.
+ * See https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries
+ */
+type ReasoningSummary = "auto" | "concise" | "detailed" | "none";
+
+type TurnStartParams = {
+    threadId: string;
+    input: Array<UserInput>; /**
+     * Override the working directory for this turn and subsequent turns.
+     */
+    cwd?: string | null; /**
+     * Override the approval policy for this turn and subsequent turns.
+     */
+    approvalPolicy?: AskForApproval | null; /**
+     * Override where approval requests are routed for review on this turn and
+     * subsequent turns.
+     */
+    approvalsReviewer?: ApprovalsReviewer | null; /**
+     * Override the sandbox policy for this turn and subsequent turns.
+     */
+    sandboxPolicy?: SandboxPolicy | null; /**
+     * Override the model for this turn and subsequent turns.
+     */
+    model?: string | null; /**
+     * Override the service tier for this turn and subsequent turns.
+     */
+    serviceTier?: string | null | null; /**
+     * Override the reasoning effort for this turn and subsequent turns.
+     */
+    effort?: ReasoningEffort | null; /**
+     * Override the reasoning summary for this turn and subsequent turns.
+     */
+    summary?: ReasoningSummary | null; /**
+     * Override the personality for this turn and subsequent turns.
+     */
+    personality?: Personality | null; /**
+     * Optional JSON Schema used to constrain the final assistant message for
+     * this turn.
+     */
+    outputSchema?: JsonValue | null;
+};
+
+type TurnSteerParams = {
+    threadId: string;
+    input: Array<UserInput>; /**
+     * Required active turn id precondition. The request fails when it does not
+     * match the currently active turn.
+     */
+    expectedTurnId: string;
+};
+
+type WindowsSandboxSetupStartParams = {
+    mode: WindowsSandboxSetupMode;
+    cwd?: AbsolutePathBuf | null;
+};
+
+/**
+ * Request from the client to the server.
+ */
+type ClientRequest = {
+    "method": "initialize";
+    id: RequestId;
+    params: InitializeParams;
+} | {
+    "method": "thread/start";
+    id: RequestId;
+    params: ThreadStartParams;
+} | {
+    "method": "thread/resume";
+    id: RequestId;
+    params: ThreadResumeParams;
+} | {
+    "method": "thread/fork";
+    id: RequestId;
+    params: ThreadForkParams;
+} | {
+    "method": "thread/archive";
+    id: RequestId;
+    params: ThreadArchiveParams;
+} | {
+    "method": "thread/unsubscribe";
+    id: RequestId;
+    params: ThreadUnsubscribeParams;
+} | {
+    "method": "thread/name/set";
+    id: RequestId;
+    params: ThreadSetNameParams;
+} | {
+    "method": "thread/metadata/update";
+    id: RequestId;
+    params: ThreadMetadataUpdateParams;
+} | {
+    "method": "thread/unarchive";
+    id: RequestId;
+    params: ThreadUnarchiveParams;
+} | {
+    "method": "thread/compact/start";
+    id: RequestId;
+    params: ThreadCompactStartParams;
+} | {
+    "method": "thread/shellCommand";
+    id: RequestId;
+    params: ThreadShellCommandParams;
+} | {
+    "method": "thread/approveGuardianDeniedAction";
+    id: RequestId;
+    params: ThreadApproveGuardianDeniedActionParams;
+} | {
+    "method": "thread/rollback";
+    id: RequestId;
+    params: ThreadRollbackParams;
+} | {
+    "method": "thread/list";
+    id: RequestId;
+    params: ThreadListParams;
+} | {
+    "method": "thread/loaded/list";
+    id: RequestId;
+    params: ThreadLoadedListParams;
+} | {
+    "method": "thread/read";
+    id: RequestId;
+    params: ThreadReadParams;
+} | {
+    "method": "thread/inject_items";
+    id: RequestId;
+    params: ThreadInjectItemsParams;
+} | {
+    "method": "skills/list";
+    id: RequestId;
+    params: SkillsListParams;
+} | {
+    "method": "hooks/list";
+    id: RequestId;
+    params: HooksListParams;
+} | {
+    "method": "marketplace/add";
+    id: RequestId;
+    params: MarketplaceAddParams;
+} | {
+    "method": "marketplace/remove";
+    id: RequestId;
+    params: MarketplaceRemoveParams;
+} | {
+    "method": "marketplace/upgrade";
+    id: RequestId;
+    params: MarketplaceUpgradeParams;
+} | {
+    "method": "plugin/list";
+    id: RequestId;
+    params: PluginListParams;
+} | {
+    "method": "plugin/read";
+    id: RequestId;
+    params: PluginReadParams;
+} | {
+    "method": "plugin/skill/read";
+    id: RequestId;
+    params: PluginSkillReadParams;
+} | {
+    "method": "plugin/share/save";
+    id: RequestId;
+    params: PluginShareSaveParams;
+} | {
+    "method": "plugin/share/updateTargets";
+    id: RequestId;
+    params: PluginShareUpdateTargetsParams;
+} | {
+    "method": "plugin/share/list";
+    id: RequestId;
+    params: PluginShareListParams;
+} | {
+    "method": "plugin/share/delete";
+    id: RequestId;
+    params: PluginShareDeleteParams;
+} | {
+    "method": "app/list";
+    id: RequestId;
+    params: AppsListParams;
+} | {
+    "method": "device/key/create";
+    id: RequestId;
+    params: DeviceKeyCreateParams;
+} | {
+    "method": "device/key/public";
+    id: RequestId;
+    params: DeviceKeyPublicParams;
+} | {
+    "method": "device/key/sign";
+    id: RequestId;
+    params: DeviceKeySignParams;
+} | {
+    "method": "fs/readFile";
+    id: RequestId;
+    params: FsReadFileParams;
+} | {
+    "method": "fs/writeFile";
+    id: RequestId;
+    params: FsWriteFileParams;
+} | {
+    "method": "fs/createDirectory";
+    id: RequestId;
+    params: FsCreateDirectoryParams;
+} | {
+    "method": "fs/getMetadata";
+    id: RequestId;
+    params: FsGetMetadataParams;
+} | {
+    "method": "fs/readDirectory";
+    id: RequestId;
+    params: FsReadDirectoryParams;
+} | {
+    "method": "fs/remove";
+    id: RequestId;
+    params: FsRemoveParams;
+} | {
+    "method": "fs/copy";
+    id: RequestId;
+    params: FsCopyParams;
+} | {
+    "method": "fs/watch";
+    id: RequestId;
+    params: FsWatchParams;
+} | {
+    "method": "fs/unwatch";
+    id: RequestId;
+    params: FsUnwatchParams;
+} | {
+    "method": "skills/config/write";
+    id: RequestId;
+    params: SkillsConfigWriteParams;
+} | {
+    "method": "plugin/install";
+    id: RequestId;
+    params: PluginInstallParams;
+} | {
+    "method": "plugin/uninstall";
+    id: RequestId;
+    params: PluginUninstallParams;
+} | {
+    "method": "turn/start";
+    id: RequestId;
+    params: TurnStartParams;
+} | {
+    "method": "turn/steer";
+    id: RequestId;
+    params: TurnSteerParams;
+} | {
+    "method": "turn/interrupt";
+    id: RequestId;
+    params: TurnInterruptParams;
+} | {
+    "method": "review/start";
+    id: RequestId;
+    params: ReviewStartParams;
+} | {
+    "method": "model/list";
+    id: RequestId;
+    params: ModelListParams;
+} | {
+    "method": "collaborationMode/list";
+    id: RequestId;
+    params: CollaborationModeListParams;
+} | {
+    "method": "modelProvider/capabilities/read";
+    id: RequestId;
+    params: ModelProviderCapabilitiesReadParams;
+} | {
+    "method": "experimentalFeature/list";
+    id: RequestId;
+    params: ExperimentalFeatureListParams;
+} | {
+    "method": "experimentalFeature/enablement/set";
+    id: RequestId;
+    params: ExperimentalFeatureEnablementSetParams;
+} | {
+    "method": "mcpServer/oauth/login";
+    id: RequestId;
+    params: McpServerOauthLoginParams;
+} | {
+    "method": "config/mcpServer/reload";
+    id: RequestId;
+    params: undefined;
+} | {
+    "method": "mcpServerStatus/list";
+    id: RequestId;
+    params: ListMcpServerStatusParams;
+} | {
+    "method": "mcpServer/resource/read";
+    id: RequestId;
+    params: McpResourceReadParams;
+} | {
+    "method": "mcpServer/tool/call";
+    id: RequestId;
+    params: McpServerToolCallParams;
+} | {
+    "method": "windowsSandbox/setupStart";
+    id: RequestId;
+    params: WindowsSandboxSetupStartParams;
+} | {
+    "method": "windowsSandbox/readiness";
+    id: RequestId;
+    params: undefined;
+} | {
+    "method": "account/login/start";
+    id: RequestId;
+    params: LoginAccountParams;
+} | {
+    "method": "account/login/cancel";
+    id: RequestId;
+    params: CancelLoginAccountParams;
+} | {
+    "method": "account/logout";
+    id: RequestId;
+    params: undefined;
+} | {
+    "method": "account/rateLimits/read";
+    id: RequestId;
+    params: undefined;
+} | {
+    "method": "account/sendAddCreditsNudgeEmail";
+    id: RequestId;
+    params: SendAddCreditsNudgeEmailParams;
+} | {
+    "method": "feedback/upload";
+    id: RequestId;
+    params: FeedbackUploadParams;
+} | {
+    "method": "command/exec";
+    id: RequestId;
+    params: CommandExecParams;
+} | {
+    "method": "command/exec/write";
+    id: RequestId;
+    params: CommandExecWriteParams;
+} | {
+    "method": "command/exec/terminate";
+    id: RequestId;
+    params: CommandExecTerminateParams;
+} | {
+    "method": "command/exec/resize";
+    id: RequestId;
+    params: CommandExecResizeParams;
+} | {
+    "method": "config/read";
+    id: RequestId;
+    params: ConfigReadParams;
+} | {
+    "method": "externalAgentConfig/detect";
+    id: RequestId;
+    params: ExternalAgentConfigDetectParams;
+} | {
+    "method": "externalAgentConfig/import";
+    id: RequestId;
+    params: ExternalAgentConfigImportParams;
+} | {
+    "method": "config/value/write";
+    id: RequestId;
+    params: ConfigValueWriteParams;
+} | {
+    "method": "config/batchWrite";
+    id: RequestId;
+    params: ConfigBatchWriteParams;
+} | {
+    "method": "configRequirements/read";
+    id: RequestId;
+    params: undefined;
+} | {
+    "method": "account/read";
+    id: RequestId;
+    params: GetAccountParams;
+} | {
+    "method": "getConversationSummary";
+    id: RequestId;
+    params: GetConversationSummaryParams;
+} | {
+    "method": "gitDiffToRemote";
+    id: RequestId;
+    params: GitDiffToRemoteParams;
+} | {
+    "method": "getAuthStatus";
+    id: RequestId;
+    params: GetAuthStatusParams;
+} | {
+    "method": "fuzzyFileSearch";
+    id: RequestId;
+    params: FuzzyFileSearchParams;
+};
+
+/**
+ * Initial collaboration mode to use when the TUI starts.
+ */
+type ModeKind = "plan" | "default";
+
+type InitializeResponse = {
+    userAgent: string;
+    /**
+     * Absolute path to the server's $CODEX_HOME directory.
+     */
+    codexHome: AbsolutePathBuf;
+    /**
+     * Platform family for the running app-server target, for example
+     * `"unix"` or `"windows"`.
+     */
+    platformFamily: string;
+    /**
+     * Operating system for the running app-server target, for example
+     * `"macos"`, `"linux"`, or `"windows"`.
+     */
+    platformOs: string;
+};
+
+/**
+ * A known resource that the server is capable of reading.
+ */
+type Resource = {
+    annotations?: JsonValue;
+    description?: string;
+    mimeType?: string;
+    name: string;
+    size?: number;
+    title?: string;
+    uri: string;
+    icons?: Array<JsonValue>;
+    _meta?: JsonValue;
+};
+
+/**
+ * Contents returned when reading a resource from an MCP server.
+ */
+type ResourceContent = {
+    /**
+     * The URI of this resource.
+     */
+    uri: string;
+    mimeType?: string;
+    text: string;
+    _meta?: JsonValue;
+} | {
+    /**
+     * The URI of this resource.
+     */
+    uri: string;
+    mimeType?: string;
+    blob: string;
+    _meta?: JsonValue;
+};
+
+/**
+ * A template description for resources available on the server.
+ */
+type ResourceTemplate = {
+    annotations?: JsonValue;
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+};
+
+/**
+ * Definition for a tool the client can call.
+ */
+type Tool = {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JsonValue;
+    outputSchema?: JsonValue;
+    annotations?: JsonValue;
+    icons?: Array<JsonValue>;
+    _meta?: JsonValue;
+};
+
+/**
+ * EXPERIMENTAL - collaboration mode preset metadata for clients.
+ */
+type CollaborationModeMask = {
+    name: string;
+    mode: ModeKind | null;
+    model: string | null;
+    reasoning_effort: ReasoningEffort | null | null;
+};
+
+/**
+ * EXPERIMENTAL - collaboration mode presets response.
+ */
+type CollaborationModeListResponse = {
+    data: Array<CollaborationModeMask>;
+};
+
+type McpAuthStatus = "unsupported" | "notLoggedIn" | "bearerToken" | "oAuth";
+
+type McpServerStatus = {
+    name: string;
+    tools: {
+        [key in string]?: Tool;
+    };
+    resources: Array<Resource>;
+    resourceTemplates: Array<ResourceTemplate>;
+    authStatus: McpAuthStatus;
+};
+
+type ListMcpServerStatusResponse = {
+    data: Array<McpServerStatus>;
+    /**
+     * Opaque cursor to pass to the next call to continue after the last item.
+     * If None, there are no more items to return.
+     */
+    nextCursor: string | null;
+};
+
+type McpResourceReadResponse = {
+    contents: Array<ResourceContent>;
+};
+
+type McpServerOauthLoginResponse = {
+    authorizationUrl: string;
+};
+
+type McpServerRefreshResponse = Record<string, never>;
+
+type McpServerToolCallResponse = {
+    content: Array<JsonValue>;
+    structuredContent?: JsonValue;
+    isError?: boolean;
+    _meta?: JsonValue;
+};
+
+type ThreadArchiveResponse = Record<string, never>;
+
+type ThreadCompactStartResponse = Record<string, never>;
+
+type ThreadListResponse = {
+    data: Array<Thread>;
+    /**
+     * Opaque cursor to pass to the next call to continue after the last item.
+     * if None, there are no more items to return.
+     */
+    nextCursor: string | null;
+    /**
+     * Opaque cursor to pass as `cursor` when reversing `sortDirection`.
+     * This is only populated when the page contains at least one thread.
+     * Use it with the opposite `sortDirection`; for timestamp sorts it anchors
+     * at the start of the page timestamp so same-second updates are not skipped.
+     */
+    backwardsCursor: string | null;
+};
+
+type ThreadMetadataUpdateResponse = {
+    thread: Thread;
+};
+
+type ThreadReadResponse = {
+    thread: Thread;
+};
+
+type ThreadResumeResponse = {
+    thread: Thread;
+    model: string;
+    modelProvider: string;
+    serviceTier: string | null;
+    cwd: AbsolutePathBuf; /**
+     * Instruction source files currently loaded for this thread.
+     */
+    instructionSources: Array<AbsolutePathBuf>;
+    approvalPolicy: AskForApproval; /**
+     * Reviewer currently used for approval requests on this thread.
+     */
+    approvalsReviewer: ApprovalsReviewer; /**
+     * Legacy sandbox policy retained for compatibility. Experimental clients
+     * should prefer `permissionProfile` when they need exact runtime
+     * permissions.
+     */
+    sandbox: SandboxPolicy;
+    reasoningEffort: ReasoningEffort | null;
+};
+
+type ThreadSetNameResponse = Record<string, never>;
+
+type ThreadStartResponse = {
+    thread: Thread;
+    model: string;
+    modelProvider: string;
+    serviceTier: string | null;
+    cwd: AbsolutePathBuf; /**
+     * Instruction source files currently loaded for this thread.
+     */
+    instructionSources: Array<AbsolutePathBuf>;
+    approvalPolicy: AskForApproval; /**
+     * Reviewer currently used for approval requests on this thread.
+     */
+    approvalsReviewer: ApprovalsReviewer; /**
+     * Legacy sandbox policy retained for compatibility. Experimental clients
+     * should prefer `permissionProfile` when they need exact runtime
+     * permissions.
+     */
+    sandbox: SandboxPolicy;
+    reasoningEffort: ReasoningEffort | null;
+};
+
+type ThreadUnarchiveResponse = {
+    thread: Thread;
+};
+
+type TurnInterruptResponse = Record<string, never>;
+
+type TurnStartResponse = {
+    turn: Turn;
+};
+
+type TurnSteerResponse = {
+    turnId: string;
+};
+
+type JsonRpcResult = unknown;
+type JSONRPCErrorError = {
+    code: number;
+    data?: unknown;
+    message: string;
+};
+type Result = JsonRpcResult;
+type AppServerEvent = {
+    skipped: number;
+    type: "lagged";
+} | {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    message: string;
+    type: "disconnected";
+};
+type TypedRequestError = {
+    method: string;
+    source: unknown;
+    type: "transport";
+} | {
+    method: string;
+    source: JSONRPCErrorError;
+    type: "server";
+} | {
+    method: string;
+    source: unknown;
+    type: "deserialize";
+};
+type AppServerRequestHandle = {
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+    request(request: ClientRequest): Promise<unknown>;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+};
+declare function requestTyped<T>(request: ClientRequest, send: (request: ClientRequest) => Promise<unknown>): Promise<T>;
+declare function serverNotificationRequiresDelivery(notification: ServerNotification): boolean;
+declare function requestMethodName(request: ClientRequest): string;
+
+type CodexAppServer = {
+    close?(): void;
+    events?(): AsyncIterable<AppServerEvent>;
+    nextEvent?(): Promise<AppServerEvent | null>;
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+    request(request: ClientRequest): Promise<unknown>;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+};
+declare class AppServerSession {
+    private readonly client;
+    private nextRequestIdValue;
+    constructor(client: CodexAppServer);
+    nextRequestId(): RequestId;
+    nextEvent(): Promise<AppServerEvent | null>;
+    events(): AsyncIterable<AppServerEvent> | null;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    initialize(params?: InitializeParams): Promise<InitializeResponse>;
+    threadStart(params: ThreadStartParams): Promise<ThreadStartResponse>;
+    threadResume(params: ThreadResumeParams): Promise<ThreadResumeResponse>;
+    threadList(params?: ThreadListParams): Promise<ThreadListResponse>;
+    collaborationModeList(params?: CollaborationModeListParams): Promise<CollaborationModeListResponse>;
+    configMcpServerReload(): Promise<McpServerRefreshResponse>;
+    mcpServerStatusList(params?: ListMcpServerStatusParams): Promise<ListMcpServerStatusResponse>;
+    mcpResourceRead(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    mcpServerToolCall(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    mcpServerOauthLogin(params: McpServerOauthLoginParams): Promise<McpServerOauthLoginResponse>;
+    threadRead(params: ThreadReadParams): Promise<ThreadReadResponse>;
+    threadNameSet(params: ThreadSetNameParams): Promise<ThreadSetNameResponse>;
+    threadArchive(params: ThreadArchiveParams): Promise<ThreadArchiveResponse>;
+    threadUnarchive(params: ThreadUnarchiveParams): Promise<ThreadUnarchiveResponse>;
+    threadMetadataUpdate(params: ThreadMetadataUpdateParams): Promise<ThreadMetadataUpdateResponse>;
+    turnStart(params: TurnStartParams): Promise<TurnStartResponse>;
+    turnSteer(params: TurnSteerParams): Promise<TurnSteerResponse>;
+    turnInterrupt(params: TurnInterruptParams): Promise<TurnInterruptResponse>;
+    threadCompactStart(params: ThreadCompactStartParams): Promise<ThreadCompactStartResponse>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+}
+
+export { type AppServerEvent as A, type ThreadSetNameParams as B, type CodexAppServer as C, type ThreadSetNameResponse as D, type ThreadReadParams as E, type ThreadReadResponse as F, type ThreadResumeParams as G, type ThreadResumeResponse as H, type InitializeParams as I, type JSONRPCErrorError as J, type ThreadStartResponse as K, type ListMcpServerStatusParams as L, type McpServerRefreshResponse as M, type ThreadUnarchiveParams as N, type ThreadUnarchiveResponse as O, type TurnInterruptParams as P, type TurnInterruptResponse as Q, type Result as R, type TurnStartResponse as S, type TypedRequestError as T, type TurnSteerParams as U, type TurnSteerResponse as V, type AppServerRequestHandle as a, AppServerSession as b, type ClientRequest as c, type InitializeResponse as d, requestTyped as e, type ThreadStartParams as f, type TurnStartParams as g, type CollaborationModeListParams as h, type CollaborationModeListResponse as i, type McpResourceReadParams as j, type McpResourceReadResponse as k, type McpServerOauthLoginParams as l, type McpServerOauthLoginResponse as m, type ListMcpServerStatusResponse as n, type McpServerToolCallParams as o, type McpServerToolCallResponse as p, type ThreadArchiveParams as q, requestMethodName as r, serverNotificationRequiresDelivery as s, type ThreadArchiveResponse as t, type ThreadCompactStartParams as u, type ThreadCompactStartResponse as v, type ThreadListParams as w, type ThreadListResponse as x, type ThreadMetadataUpdateParams as y, type ThreadMetadataUpdateResponse as z };