@jrkropp/codex-js 0.1.4 → 0.3.0

package/dist/internal/codex/core/src/agent/control.d.ts

@@ -0,0 +1,76 @@
+import type { ThreadId } from "../ids.js";
+import type { RolloutItem } from "../protocol.js";
+import { Mailbox, type InterAgentCommunication } from "./mailbox.js";
+import { AgentPath } from "./role.js";
+import { AgentRegistry, type LiveAgent, type ListedAgent, type AgentMetadata } from "./registry.js";
+export declare const SpawnAgentForkMode: {
+    readonly FullHistory: "full_history";
+    readonly LastNTurns: "last_n_turns";
+};
+export type SpawnAgentForkMode = {
+    type: typeof SpawnAgentForkMode.FullHistory;
+} | {
+    type: typeof SpawnAgentForkMode.LastNTurns;
+    turns: number;
+};
+export type SpawnAgentOptions = {
+    fork_parent_spawn_call_id?: string | null;
+    fork_mode?: SpawnAgentForkMode | null;
+    environments?: unknown[] | null;
+};
+export type AgentControlExecutor = {
+    spawn_agent?(input: {
+        initial_operation: unknown;
+        session_source?: unknown;
+        options?: SpawnAgentOptions;
+    }): Promise<LiveAgent>;
+    send_input?(input: {
+        target: ThreadId;
+        message?: string | null;
+        items?: unknown[] | null;
+        interrupt?: boolean;
+    }): Promise<unknown>;
+    wait_agent?(input: {
+        targets: ThreadId[];
+        timeout_ms?: number | null;
+    }): Promise<unknown>;
+    close_agent?(input: {
+        target: ThreadId;
+    }): Promise<unknown>;
+    resume_agent?(input: {
+        id: ThreadId;
+    }): Promise<unknown>;
+};
+export declare class AgentControl {
+    private readonly executor;
+    readonly registry: AgentRegistry;
+    readonly mailbox: Mailbox;
+    constructor(executor?: AgentControlExecutor | null);
+    static empty(): AgentControl;
+    spawn_agent_with_metadata(input: {
+        initial_operation: unknown;
+        session_source?: unknown;
+        options?: SpawnAgentOptions;
+    }): Promise<LiveAgent>;
+    send_input(input: {
+        target: ThreadId;
+        message?: string | null;
+        items?: unknown[] | null;
+        interrupt?: boolean;
+    }): Promise<unknown>;
+    wait_agent(input: {
+        targets: ThreadId[];
+        timeout_ms?: number | null;
+    }): Promise<unknown>;
+    close_agent(input: {
+        target: ThreadId;
+    }): Promise<unknown>;
+    resume_agent(input: {
+        id: ThreadId;
+    }): Promise<unknown>;
+    list_agents(): ListedAgent[];
+    send_mail(communication: Omit<InterAgentCommunication, "seq">): number;
+}
+export type { AgentMetadata, LiveAgent, ListedAgent };
+export { AgentPath };
+export declare function keep_forked_rollout_item(item: RolloutItem): boolean;

package/dist/internal/codex/core/src/agent/mailbox.d.ts

@@ -0,0 +1,28 @@
+import type { AgentPath } from "./role.js";
+export type InterAgentCommunication = {
+    author: AgentPath;
+    recipient: AgentPath;
+    items: unknown[];
+    content: string;
+    trigger_turn: boolean;
+    seq?: number;
+};
+export declare class Mailbox {
+    private readonly pending;
+    private next_seq;
+    static new(): {
+        mailbox: Mailbox;
+        receiver: MailboxReceiver;
+    };
+    send(communication: Omit<InterAgentCommunication, "seq">): number;
+    drain(): InterAgentCommunication[];
+    has_pending(): boolean;
+    has_pending_trigger_turn(): boolean;
+}
+export declare class MailboxReceiver {
+    private readonly mailbox;
+    constructor(mailbox: Mailbox);
+    has_pending(): boolean;
+    has_pending_trigger_turn(): boolean;
+    drain(): InterAgentCommunication[];
+}

package/dist/internal/codex/core/src/agent/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./agent_resolver.js";
+export * from "./control.js";
+export * from "./mailbox.js";
+export * from "./registry.js";
+export * from "./role.js";
+export * from "./status.js";

package/dist/internal/codex/core/src/agent/registry.d.ts

@@ -0,0 +1,54 @@
+import type { ThreadId } from "../ids.js";
+import { AgentPath } from "./role.js";
+export type AgentMetadata = {
+    agent_id?: ThreadId | null;
+    agent_path?: AgentPath | null;
+    agent_nickname?: string | null;
+    agent_role?: string | null;
+    last_task_message?: string | null;
+};
+export type LiveAgent = {
+    thread_id: ThreadId;
+    metadata: AgentMetadata;
+    status: AgentStatus;
+};
+export type ListedAgent = {
+    agent_name: string;
+    agent_status: AgentStatus;
+    last_task_message?: string | null;
+};
+export declare const AgentStatus: {
+    readonly Running: "running";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+    readonly Closed: "closed";
+    readonly Cancelled: "cancelled";
+};
+export type AgentStatus = (typeof AgentStatus)[keyof typeof AgentStatus];
+export declare class AgentRegistry {
+    private readonly agent_tree;
+    private readonly used_agent_nicknames;
+    private total_count;
+    private nickname_reset_count;
+    reserve_spawn_slot(max_threads?: number | null): SpawnReservation;
+    release_spawned_thread(thread_id: ThreadId): void;
+    release_spawn_slot(): void;
+    register_root_thread(thread_id: ThreadId): void;
+    agent_id_for_path(agent_path: AgentPath): ThreadId | null;
+    agent_metadata_for_thread(thread_id: ThreadId): AgentMetadata | null;
+    live_agents(): AgentMetadata[];
+    update_last_task_message(thread_id: ThreadId, last_task_message: string): void;
+    register_spawned_thread(agent_metadata: AgentMetadata): void;
+    reserve_agent_nickname(names: readonly string[], preferred?: string | null): string | null;
+    reserve_agent_path(agent_path: AgentPath): void;
+    private reset_and_select_nickname;
+}
+export declare class SpawnReservation {
+    private readonly registry;
+    private active;
+    constructor(registry: AgentRegistry);
+    commit(metadata: AgentMetadata): void;
+    release(): void;
+}
+export declare function next_thread_spawn_depth(session_source: unknown): number;
+export declare function exceeds_thread_spawn_depth_limit(depth: number, max_depth: number): boolean;

package/dist/internal/codex/core/src/agent/role.d.ts

@@ -0,0 +1,19 @@
+export declare class AgentPath {
+    private readonly value;
+    static readonly ROOT = "/root";
+    private constructor();
+    static root(): AgentPath;
+    static parse(value: string): AgentPath;
+    isRoot(): boolean;
+    toString(): string;
+}
+export declare const DEFAULT_ROLE_NAME = "default";
+export type AgentRoleConfig = {
+    name: string;
+    description?: string | null;
+    instructions?: string | null;
+    nickname_candidates?: string[] | null;
+};
+export declare function resolve_role_config(roles: Record<string, AgentRoleConfig> | null | undefined, role_name?: string): AgentRoleConfig | null;
+export declare function builtin_agent_roles(): Record<string, AgentRoleConfig>;
+export declare function default_agent_nickname_list(): string[];

package/dist/internal/codex/core/src/agent/status.d.ts

@@ -0,0 +1,3 @@
+import { AgentStatus } from "./registry.js";
+export declare function is_final(status: AgentStatus): boolean;
+export declare function agent_status_from_event(event: unknown): AgentStatus;

package/dist/internal/codex/core/src/auth.d.ts

@@ -0,0 +1,65 @@
+export declare const AuthMode: {
+    readonly ApiKey: "apiKey";
+    readonly Chatgpt: "chatgpt";
+};
+export declare const CODEX_CHATGPT_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export declare const CODEX_CHATGPT_OAUTH_ISSUER = "https://auth.openai.com";
+export declare const CODEX_CHATGPT_OAUTH_SCOPE = "openid profile email offline_access api.connectors.read api.connectors.invoke";
+export declare const CODEX_CHATGPT_OAUTH_PRIMARY_PORT = 1455;
+export declare const CODEX_CHATGPT_OAUTH_FALLBACK_PORT = 1457;
+export declare const CODEX_CHATGPT_OAUTH_CALLBACK_PATH = "/auth/callback";
+export declare const CODEX_CHATGPT_OAUTH_ORIGINATOR = "codex_cli_rs";
+export type AuthMode = (typeof AuthMode)[keyof typeof AuthMode];
+export type PlanType = "free" | "plus" | "pro" | "team" | "enterprise" | "edu" | "unknown";
+export type TokenData = {
+    access_token: string;
+    refresh_token: string;
+    id_token: string;
+    account_id?: string | null;
+    expires_at?: number | null;
+};
+export type AuthDotJson = {
+    auth_mode?: AuthMode | null;
+    openai_api_key?: string | null;
+    tokens?: TokenData | null;
+    last_refresh?: string | null;
+};
+export type CodexAuth = {
+    type: typeof AuthMode.ApiKey;
+    api_key: string;
+} | {
+    type: typeof AuthMode.Chatgpt;
+    auth: AuthDotJson;
+    account_id?: string | null;
+    email?: string | null;
+    plan_type?: PlanType | null;
+};
+export type ProviderAccount = {
+    type: typeof AuthMode.ApiKey;
+} | {
+    type: typeof AuthMode.Chatgpt;
+    email: string;
+    plan_type: PlanType;
+};
+export type ProviderAccountState = {
+    account: ProviderAccount | null;
+    requires_openai_auth: boolean;
+};
+export type GetAccountResponse = ProviderAccountState;
+export type ChatgptOAuthTokenExchangeRequest = {
+    code: string;
+    redirect_uri: string;
+    code_verifier: string;
+};
+export type ChatgptOAuthTokenExchangeResponse = {
+    credential_jwe: string;
+    account: ProviderAccountState;
+};
+export declare function resolvedAuthMode(auth: AuthDotJson): AuthMode;
+export declare function parseJwtPayload(token: string): Record<string, unknown>;
+export declare function openAiAuthClaims(token: string): Record<string, unknown>;
+export declare function normalizePlanType(value: unknown): PlanType;
+export declare function chatgptAuthFromAuthDotJson(auth: AuthDotJson): CodexAuth;
+export declare function codexAuthToAccountState(auth: CodexAuth | null): ProviderAccountState;
+export declare function authDotJsonToOpenAiApiKey(auth: AuthDotJson): string | null;
+export declare function authDotJsonToBearerToken(auth: AuthDotJson): string | null;

package/dist/internal/codex/core/src/client.d.ts

@@ -0,0 +1,129 @@
+import { type ModelProvider } from "./model-provider.js";
+import type { ResponseItem } from "./protocol.js";
+import type { TurnContext } from "./session/turn-context.js";
+import type { ThreadId } from "./ids.js";
+import type { Prompt, ResponsesApiRequest, ResponseStream, TurnState } from "../../codex-api/src/common.js";
+import { ResponsesClient, type ResponsesOptions } from "../../codex-api/src/endpoint/responses.js";
+import { ResponsesWebsocketClient, type ResponsesWebsocketConnection } from "../../codex-api/src/endpoint/responses_websocket.js";
+export { ResponsesClient } from "../../codex-api/src/endpoint/responses.js";
+export type { ResponsesClientInput, ResponsesOptions, } from "../../codex-api/src/endpoint/responses.js";
+export { ResponsesWebsocketClient, ResponsesWebsocketConnection, } from "../../codex-api/src/endpoint/responses_websocket.js";
+export type { ResponsesWebsocketClientInput } from "../../codex-api/src/endpoint/responses_websocket.js";
+export type { Prompt, ResponseCreateWsRequest, ResponseEvent, ResponseProcessedWsRequest, ResponsesApiRequest, ResponseStream, ResponsesWsRequest, } from "../../codex-api/src/common.js";
+export declare const OPENAI_BETA_HEADER = "OpenAI-Beta";
+export declare const X_CODEX_INSTALLATION_ID_HEADER = "x-codex-installation-id";
+export declare const X_CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
+export declare const X_CODEX_TURN_METADATA_HEADER = "x-codex-turn-metadata";
+export declare const X_CODEX_PARENT_THREAD_ID_HEADER = "x-codex-parent-thread-id";
+export declare const X_CODEX_WINDOW_ID_HEADER = "x-codex-window-id";
+export declare const X_OPENAI_SUBAGENT_HEADER = "x-openai-subagent";
+export declare const X_RESPONSESAPI_INCLUDE_TIMING_METRICS_HEADER = "x-responsesapi-include-timing-metrics";
+export declare const RESPONSES_WEBSOCKETS_V2_BETA_HEADER_VALUE = "responses_websockets=2026-02-06";
+export declare const CHATGPT_CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+export declare const CODEX_USER_AGENT = "codex_cli_rs/0.128.0 (Mac OS 15.7.3; arm64) dumb";
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type CreateModelClientInput = {
+    apiKey: string;
+    baseUrl?: string;
+    chatgptAccountId?: string | null;
+    fedramp?: boolean;
+    fetch?: FetchLike;
+    provider?: ModelProvider;
+    sessionId: string;
+    threadId: ThreadId | string;
+    installationId: string;
+    includeTimingMetrics?: boolean;
+    betaFeaturesHeader?: string | null;
+};
+export type ModelClientSessionHandle = {
+    prewarm_websocket(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<void>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<ResponseStream>;
+    release(): void;
+};
+export type ModelClient = {
+    new_session(turn?: TurnContext): ModelClientSessionHandle;
+    responses_websocket_enabled(): boolean;
+    force_http_fallback(): boolean;
+};
+export declare function createModelClient(input: CreateModelClientInput): ModelClient;
+type LastResponse = {
+    response_id: string;
+    items_added: ResponseItem[];
+};
+type WebsocketSession = {
+    connection: ResponsesWebsocketConnection | null;
+    last_request: ResponsesApiRequest | null;
+    last_response: LastResponse | null;
+    connection_reused: boolean;
+};
+declare class CodexModelClient implements ModelClient {
+    private readonly provider;
+    private readonly runtime;
+    private readonly apiKey;
+    private readonly chatgptAccountId;
+    private readonly fedramp;
+    private readonly fetcher?;
+    private readonly sessionId;
+    private readonly threadId;
+    private readonly installationId;
+    private readonly includeTimingMetrics;
+    private readonly betaFeaturesHeader;
+    private disableWebsockets;
+    private windowGeneration;
+    private cachedWebsocketSession;
+    constructor(input: CreateModelClientInput);
+    new_session(turn?: TurnContext): ModelClientSession;
+    responses_websocket_enabled(): boolean;
+    force_http_fallback(): boolean;
+    set_window_generation(windowGeneration: number): void;
+    advance_window_generation(): void;
+    current_window_id(): string;
+    stream_max_retries(): number;
+    websocket_connect_timeout_ms(): number;
+    take_cached_websocket_session(): WebsocketSession;
+    store_cached_websocket_session(websocketSession: WebsocketSession): void;
+    build_responses_request(prompt: Prompt, turn: TurnContext): ResponsesApiRequest;
+    build_responses_options(turn: TurnContext, turnState: TurnState, turnMetadataHeader?: string | null): ResponsesOptions;
+    build_websocket_headers(turn: TurnContext, turnState: TurnState, turnMetadataHeader?: string | null): Headers;
+    build_ws_client_metadata(turn: TurnContext, turnMetadataHeader?: string | null): Record<string, string>;
+    new_responses_client(): ResponsesClient;
+    new_responses_websocket_client(): ResponsesWebsocketClient;
+    private build_responses_headers;
+}
+export declare class ModelClientSession {
+    private readonly client;
+    private readonly turn?;
+    private websocketSession;
+    private readonly turnState;
+    private released;
+    constructor(client: CodexModelClient, turn?: TurnContext | undefined, websocketSession?: WebsocketSession);
+    prewarm_websocket(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<void>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream(prompt: Prompt, options?: {
+        signal?: AbortSignal;
+        turn?: TurnContext;
+        turn_metadata_header?: string | null;
+    }): Promise<ResponseStream>;
+    release(): void;
+    private stream_responses_api;
+    private stream_responses_websocket;
+    private websocket_connection;
+    private codex_client;
+    private prepare_websocket_request;
+    private get_incremental_items;
+    private reset_websocket_session;
+    private try_switch_fallback_transport;
+}

package/dist/internal/codex/core/src/collaboration-mode-presets.d.ts

@@ -0,0 +1,9 @@
+import { type CollaborationMode, type CollaborationModeMask, ModeKind } from "./config-types.js";
+export declare function builtinCollaborationModePresets(): CollaborationModeMask[];
+export declare function collaborationModePresetForMode(mode: ModeKind): CollaborationModeMask | null;
+export declare function normalizeCollaborationMode(input: {
+    collaborationMode?: CollaborationMode | null;
+    model: string;
+    reasoningEffort?: string | null;
+}): CollaborationMode;
+export declare function defaultModeInstructions(): string;

package/dist/internal/codex/core/src/compact-task-runner.d.ts

@@ -0,0 +1,18 @@
+import type { ResponseItem } from "./models.js";
+import type { RolloutItem, Submission } from "./protocol.js";
+import type { Session } from "./session/session.js";
+import type { TurnContext } from "./session/turn-context.js";
+import type { ModelClient } from "./client.js";
+export type CompactTaskResult = {
+    summary: string;
+    replacement_history: ResponseItem[];
+};
+export declare function run_compact_task(params: {
+    modelClient: ModelClient;
+    session: Session;
+    history: RolloutItem[];
+    submission: Submission;
+    turn?: TurnContext;
+    signal?: AbortSignal;
+    completeTurn?: boolean;
+}): Promise<CompactTaskResult>;

package/dist/internal/codex/core/src/compact.d.ts

@@ -0,0 +1,12 @@
+import type { ResponseItem } from "./models.js";
+export declare const SUMMARIZATION_PROMPT: string;
+export declare const SUMMARY_PREFIX: string;
+export declare function compactedThreadWarning(): string;
+export declare function contentItemsToText(content: readonly ResponseItemMessageContent[]): string | null;
+export declare function collectUserMessages(items: readonly ResponseItem[]): string[];
+export declare function isSummaryMessage(message: string): boolean;
+export declare function buildCompactedHistory(initialContext: ResponseItem[], userMessages: readonly string[], summaryText: string): ResponseItem[];
+type ResponseItemMessageContent = Extract<ResponseItem, {
+    type: "message";
+}>["content"][number];
+export {};

package/dist/internal/codex/core/src/config/agent_roles.d.ts

@@ -0,0 +1,6 @@
+export type AgentRole = {
+    name: string;
+    description?: string | null;
+    instructions?: string | null;
+};
+export type AgentRoles = Record<string, AgentRole>;

package/dist/internal/codex/core/src/config/managed_features.d.ts

@@ -0,0 +1,7 @@
+export type ManagedFeature = {
+    name: string;
+    enabled: boolean;
+    source?: string | null;
+};
+export type ManagedFeatures = Record<string, ManagedFeature>;
+export declare function emptyManagedFeatures(): ManagedFeatures;

package/dist/internal/codex/core/src/config/mod.d.ts

@@ -0,0 +1,9 @@
+export * from "./permissions.js";
+export * from "./managed_features.js";
+export * from "./network_proxy_spec.js";
+export * from "./agent_roles.js";
+import type { ResolvedConfig } from "../../../config/src/index.js";
+export { resolve_web_search_mode_for_turn } from "../../../config/src/index.js";
+export declare function tools_config_from_config(config: ResolvedConfig): Omit<import("../index.js").DefaultToolsConfigInput, "web_search"> & {
+    web_search?: Partial<import("../../../app-server-protocol/schema/typescript/index.js").WebSearchToolConfig> | boolean | null;
+} & import("../index.js").ToolsConfig;

package/dist/internal/codex/core/src/config/network_proxy_spec.d.ts

@@ -0,0 +1,5 @@
+export type NetworkProxySpec = {
+    mode: "disabled" | "default" | "custom";
+    url?: string | null;
+};
+export declare function defaultNetworkProxySpec(): NetworkProxySpec;

package/dist/internal/codex/core/src/config/permissions.d.ts

@@ -0,0 +1,30 @@
+import type { PermissionProfile, PermissionProfileBuiltinName, SandboxPolicy } from "../protocol.js";
+export declare const BUILT_IN_READ_ONLY_PROFILE = ":read-only";
+export declare const BUILT_IN_WORKSPACE_PROFILE = ":workspace";
+export declare const BUILT_IN_DANGER_NO_SANDBOX_PROFILE = ":danger-no-sandbox";
+export declare function defaultBuiltinPermissionProfileName(input?: {
+    trusted?: boolean | null;
+    untrusted?: boolean | null;
+}): PermissionProfileBuiltinName;
+export declare function readOnlyPermissionProfile(): PermissionProfile;
+export declare function workspaceWritePermissionProfile(): PermissionProfile;
+export declare function disabledPermissionProfile(): PermissionProfile;
+export declare function builtinPermissionProfile(name: PermissionProfileBuiltinName): PermissionProfile;
+export declare function permissionProfileFromLegacySandboxPolicy(sandboxPolicy: SandboxPolicy | null | undefined): PermissionProfile;
+export declare function legacySandboxPolicyFromPermissionProfile(permissionProfile: PermissionProfile | null | undefined, cwd?: string): SandboxPolicy;
+export declare function effectivePermissionProfile(input: {
+    permission_profile?: PermissionProfile | null;
+    sandbox_policy?: SandboxPolicy | null;
+}): PermissionProfile;
+export declare function builtinPermissionProfileNameFromProfile(permissionProfile: PermissionProfile | null | undefined): PermissionProfileBuiltinName;
+export declare function activePermissionProfileForBuiltin(id: PermissionProfileBuiltinName): {
+    id: PermissionProfileBuiltinName;
+    extends: null;
+    modifications: never[];
+};
+export declare function active_permission_profile(permissionProfile: PermissionProfile | null | undefined): {
+    id: PermissionProfileBuiltinName;
+    extends: null;
+    modifications: never[];
+};
+export declare function validatePermissionProfile(permissionProfile: PermissionProfile | null | undefined): string[];

package/dist/internal/codex/core/src/config-types.d.ts

@@ -0,0 +1,28 @@
+export declare const ModeKind: {
+    readonly Plan: "plan";
+    readonly Default: "default";
+};
+export type ModeKind = (typeof ModeKind)[keyof typeof ModeKind];
+export type ReasoningEffort = string;
+export type CollaborationModeSettings = {
+    model: string;
+    reasoning_effort: ReasoningEffort | null;
+    developer_instructions: string | null;
+};
+export type CollaborationMode = {
+    mode: ModeKind;
+    settings: CollaborationModeSettings;
+};
+export type CollaborationModeMask = {
+    name: string;
+    mode?: ModeKind | null;
+    model?: string | null;
+    reasoning_effort?: ReasoningEffort | null | undefined;
+    developer_instructions?: string | null | undefined;
+};
+export declare const TUI_VISIBLE_COLLABORATION_MODES: readonly ["default", "plan"];
+export declare function allowsRequestUserInput(mode: ModeKind): boolean;
+export declare function modeDisplayName(mode: ModeKind): string;
+export declare function collaborationModeWithUpdates(collaborationMode: CollaborationMode, model?: string | null, effort?: ReasoningEffort | null | undefined, developerInstructions?: string | null | undefined): CollaborationMode;
+export declare function applyCollaborationModeMask(collaborationMode: CollaborationMode, mask: CollaborationModeMask): CollaborationMode;
+export declare function collaborationModeForModel(model: string, effort?: ReasoningEffort | null, mode?: ModeKind, developerInstructions?: string | null): CollaborationMode;

package/dist/internal/codex/core/src/context/collaboration-mode-instructions.d.ts

@@ -0,0 +1,10 @@
+import type { CollaborationMode } from "../config-types.js";
+import type { ResponseItem } from "../models.js";
+export declare class CollaborationModeInstructions {
+    private readonly instructions;
+    private constructor();
+    static fromCollaborationMode(collaborationMode: CollaborationMode | null): CollaborationModeInstructions | null;
+    toResponseItem(): ResponseItem;
+    toText(): string;
+    private toFragment;
+}

package/dist/internal/codex/core/src/context/context-updates.d.ts

@@ -0,0 +1,10 @@
+import type { ResponseItem, TurnContextItem } from "../protocol.js";
+import type { TurnContext } from "../session/turn-context.js";
+import type { PreviousTurnSettings } from "../session/rollout-reconstruction.js";
+import { ContextualUserFragment } from "./fragment.js";
+export declare class ModelSwitchInstructions extends ContextualUserFragment {
+    constructor(text: string);
+}
+export declare function buildInitialContextItems(turnContext: TurnContext): ResponseItem[];
+export declare function buildSettingsUpdateItems(previous: TurnContextItem | null | undefined, previousTurnSettings: PreviousTurnSettings | null | undefined, next: TurnContext): ResponseItem[];
+export declare function buildModelInstructionsUpdateItem(previousTurnSettings: PreviousTurnSettings | null | undefined, next: TurnContext): string | null;

package/dist/internal/codex/core/src/context/environment-context.d.ts

@@ -0,0 +1,24 @@
+import type { TurnContext } from "../session/turn-context.js";
+import type { TurnContextItem } from "../protocol.js";
+import { ContextualUserFragment } from "./fragment.js";
+export declare const ENVIRONMENT_CONTEXT_OPEN_TAG = "<environment_context>";
+export declare const ENVIRONMENT_CONTEXT_CLOSE_TAG = "</environment_context>";
+export type EnvironmentContextEnvironment = {
+    id?: string;
+    cwd: string;
+    shell: string;
+};
+export type NetworkContext = {
+    allowed_domains: string[];
+    denied_domains: string[];
+};
+export declare class EnvironmentContext extends ContextualUserFragment {
+    constructor(params: {
+        environments: EnvironmentContextEnvironment[];
+        current_date?: string | null;
+        timezone?: string | null;
+        network?: NetworkContext | null;
+    });
+    static fromTurnContext(turnContext: TurnContext): EnvironmentContext;
+    static fromTurnContextItem(item: TurnContextItem): EnvironmentContext;
+}

package/dist/internal/codex/core/src/context/fragment.d.ts

@@ -0,0 +1,22 @@
+import type { ResponseItem } from "../models.js";
+export type ContextualUserFragmentParams = {
+    role: string;
+    start_marker: string;
+    end_marker: string;
+    body: () => string;
+};
+export declare class ContextualUserFragment {
+    readonly role: string;
+    readonly start_marker: string;
+    readonly end_marker: string;
+    private readonly bodyFn;
+    constructor(params: ContextualUserFragmentParams);
+    body(): string;
+    matchesText(text: string): boolean;
+    render(): string;
+    toResponseItem(): ResponseItem;
+}
+export declare function contextualFragmentMatchesText(text: string, markers: {
+    start_marker: string;
+    end_marker: string;
+}): boolean;

package/dist/internal/codex/core/src/context/permissions-instructions.d.ts

@@ -0,0 +1,8 @@
+import type { TurnContext } from "../session/turn-context.js";
+import { ContextualUserFragment } from "./fragment.js";
+export declare class PermissionsInstructions extends ContextualUserFragment {
+    constructor(text: string);
+    static fromTurnContext(turnContext: TurnContext, options?: {
+        request_permissions_tool_enabled?: boolean;
+    }): PermissionsInstructions;
+}

package/dist/internal/codex/core/src/context/prompt-context.d.ts

@@ -0,0 +1,8 @@
+import type { ResponseItem } from "../models.js";
+import type { BaseInstructions } from "../protocol.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { CollaborationModeInstructions } from "./collaboration-mode-instructions.js";
+export declare function buildPromptBaseInstructions(turnContext: TurnContext): BaseInstructions;
+export declare function buildPromptInputWithContext(input: ResponseItem[], turnContext: TurnContext): ResponseItem[];
+export declare function buildCollaborationModeInstructions(turnContext: TurnContext): ResponseItem | null;
+export { CollaborationModeInstructions };

package/dist/internal/codex/core/src/context/turn-aborted.d.ts

@@ -0,0 +1,3 @@
+import type { ResponseItem } from "../models.js";
+export declare const TURN_ABORTED_INTERRUPTED_GUIDANCE = "The user interrupted the previous turn on purpose. Any running unified exec processes may still be running in the background. If any tools/commands were aborted, they may have partially executed.";
+export declare function turnAbortedResponseItem(guidance?: string): ResponseItem;

package/dist/internal/codex/core/src/context/user-instructions.d.ts

@@ -0,0 +1,7 @@
+import { ContextualUserFragment } from "./fragment.js";
+export declare class UserInstructions extends ContextualUserFragment {
+    constructor(params: {
+        directory: string;
+        text: string;
+    });
+}