@jrkropp/codex-js 0.1.4 → 0.2.0

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

@@ -0,0 +1,77 @@
+export type RequestId = string | number;
+export type ElicitationAction = "accept" | "decline" | "cancel";
+export type ElicitationResponse = {
+    action: ElicitationAction;
+    content?: unknown;
+    meta?: unknown;
+};
+export type CreateElicitationRequestParams = {
+    type: "form";
+    meta?: unknown;
+    message: string;
+    requested_schema: {
+        properties?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+} | {
+    type: "url";
+    meta?: unknown;
+    message: string;
+    url: string;
+    elicitation_id?: string | null;
+};
+export type ElicitationRequestEvent = {
+    id: "mcp_elicitation_request";
+    msg: {
+        type: "elicitation_request";
+        turn_id: null;
+        server_name: string;
+        id: RequestId;
+        request: {
+            type: "form";
+            meta?: unknown;
+            message: string;
+            requested_schema: unknown;
+        } | {
+            type: "url";
+            meta?: unknown;
+            message: string;
+            url: string;
+            elicitation_id?: string | null;
+        };
+    };
+};
+export type ElicitationReviewRequest = {
+    server_name: string;
+    request_id: RequestId;
+    elicitation: CreateElicitationRequestParams;
+};
+export type ElicitationReviewer = {
+    review(request: ElicitationReviewRequest): Promise<ElicitationResponse | null | undefined>;
+};
+export type ElicitationReviewerHandle = ElicitationReviewer;
+export type ElicitationEventSink = ((event: ElicitationRequestEvent) => Promise<void> | void) | {
+    send(event: ElicitationRequestEvent): Promise<void> | void;
+};
+export type SendElicitation = (id: RequestId, elicitation: CreateElicitationRequestParams) => Promise<ElicitationResponse>;
+export declare class ElicitationRequestManager {
+    private readonly reviewer;
+    private readonly requests;
+    private approval_policy;
+    private permission_profile;
+    private auto_deny_value;
+    constructor(approval_policy: unknown, permission_profile: unknown, reviewer?: ElicitationReviewerHandle | null);
+    auto_deny(): boolean;
+    set_auto_deny(auto_deny: boolean): void;
+    set_approval_policy(approval_policy: unknown): void;
+    set_permission_profile(permission_profile: unknown): void;
+    resolve(server_name: string, id: RequestId, response: ElicitationResponse): Promise<void>;
+    make_sender(server_name: string, tx_event: ElicitationEventSink): SendElicitation;
+}
+export declare function elicitation_is_rejected_by_policy(approval_policy: unknown): boolean;
+export declare function can_auto_accept_elicitation(elicitation: CreateElicitationRequestParams): boolean;
+export type McpPermissionPromptAutoApproveContext = {
+    approvals_reviewer?: unknown;
+    tool_approval_mode?: string | null;
+};
+export declare function mcp_permission_prompt_is_auto_approved(approval_policy: unknown, permission_profile: unknown, context?: McpPermissionPromptAutoApproveContext): boolean;

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

@@ -0,0 +1,64 @@
+import type { McpServerTransportConfig } from "../rmcp_client.js";
+export type McpAuthStatus = "unsupported" | "notLoggedIn" | "bearerToken" | "oAuth";
+export type OAuthCredentialsStoreMode = unknown;
+export type McpServerConfig = {
+    enabled?: boolean;
+    transport: McpServerTransportConfig;
+    scopes?: readonly string[] | null;
+    oauth_tokens_present?: boolean | null;
+    startup_timeout_sec?: number | null;
+};
+export type CodexMcpAuthLike = {
+    uses_codex_backend?: boolean | (() => boolean | null | undefined) | null;
+};
+export type McpOAuthLoginConfig = {
+    url: string;
+    http_headers?: Record<string, string> | null;
+    env_http_headers?: Record<string, string> | null;
+    discovered_scopes?: string[] | null;
+};
+export type McpOAuthLoginSupport = {
+    type: "Supported";
+    config: McpOAuthLoginConfig;
+} | {
+    type: "Unsupported";
+} | {
+    type: "Unknown";
+    error: Error;
+};
+export declare const McpOAuthLoginSupport: {
+    readonly Supported: (config: McpOAuthLoginConfig) => McpOAuthLoginSupport;
+    readonly Unsupported: McpOAuthLoginSupport;
+    readonly Unknown: (error: unknown) => McpOAuthLoginSupport;
+};
+export declare const McpOAuthScopesSource: {
+    readonly Explicit: "Explicit";
+    readonly Configured: "Configured";
+    readonly Discovered: "Discovered";
+    readonly Empty: "Empty";
+};
+export type McpOAuthScopesSource = (typeof McpOAuthScopesSource)[keyof typeof McpOAuthScopesSource];
+export type ResolvedMcpOAuthScopes = {
+    scopes: string[];
+    source: McpOAuthScopesSource;
+};
+export type McpAuthStatusEntry = {
+    config: McpServerConfig;
+    auth_status: McpAuthStatus;
+};
+export declare class OAuthProviderError extends Error {
+    readonly error?: string | null | undefined;
+    readonly error_description?: string | null | undefined;
+    constructor(error?: string | null | undefined, error_description?: string | null | undefined);
+}
+export declare function oauth_login_support(transport: McpServerTransportConfig): Promise<McpOAuthLoginSupport>;
+export declare function discover_supported_scopes(transport: McpServerTransportConfig): Promise<string[] | null>;
+export declare function resolve_oauth_scopes(explicit_scopes?: readonly string[] | null, configured_scopes?: readonly string[] | null, discovered_scopes?: readonly string[] | null): ResolvedMcpOAuthScopes;
+export declare function should_retry_without_scopes(scopes: ResolvedMcpOAuthScopes, error: unknown): boolean;
+export declare function compute_auth_statuses(servers: ReadonlyMap<string, McpServerConfig> | Record<string, McpServerConfig> | Iterable<[string, McpServerConfig]>, store_mode?: OAuthCredentialsStoreMode, auth?: CodexMcpAuthLike | null): Promise<Map<string, McpAuthStatusEntry>>;
+export declare function compute_auth_status(server_name: string, config: McpServerConfig, _store_mode?: OAuthCredentialsStoreMode, has_runtime_auth?: boolean): Promise<McpAuthStatus>;
+export type StreamableHttpOAuthDiscovery = {
+    scopes_supported?: string[] | null;
+};
+export declare function discover_streamable_http_oauth(url: string, http_headers?: Record<string, string> | null, env_http_headers?: Record<string, string> | null): Promise<StreamableHttpOAuthDiscovery | null>;
+export declare function discovery_paths(base_path: string): string[];

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

@@ -0,0 +1,16 @@
+export declare const MCP_TOOL_NAME_PREFIX = "mcp";
+export declare const MCP_TOOL_NAME_DELIMITER = "__";
+export declare const CODEX_APPS_MCP_SERVER_NAME = "codex_apps";
+export declare function sanitize_responses_api_tool_name(name: string): string;
+export declare function qualified_mcp_tool_name_prefix(serverName: string): string;
+export * from "./auth.js";
+export declare class ToolPluginProvenance {
+    private readonly plugin_display_names_by_connector_id;
+    private readonly plugin_display_names_by_mcp_server_name;
+    constructor(input?: {
+        plugin_display_names_by_connector_id?: ReadonlyMap<string, readonly string[]> | Record<string, readonly string[]>;
+        plugin_display_names_by_mcp_server_name?: ReadonlyMap<string, readonly string[]> | Record<string, readonly string[]>;
+    });
+    plugin_display_names_for_connector_id(connectorId: string): readonly string[];
+    plugin_display_names_for_mcp_server_name(serverName: string): readonly string[];
+}

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

@@ -0,0 +1,221 @@
+import { ToolPluginProvenance } from "./mcp/mod.js";
+import { type CodexAppsToolsCacheContext } from "./codex_apps.js";
+import { ToolFilter, type ToolInfo } from "./tools.js";
+export declare const MCP_SANDBOX_STATE_META_CAPABILITY = "codex/sandbox-state-meta";
+export declare const MCP_TOOLS_LIST_DURATION_METRIC = "codex.mcp.tools.list.duration_ms";
+export declare const MCP_TOOLS_FETCH_UNCACHED_DURATION_METRIC = "codex.mcp.tools.fetch_uncached.duration_ms";
+export declare const DEFAULT_STARTUP_TIMEOUT = 30000;
+export declare const DEFAULT_TOOL_TIMEOUT = 120000;
+export type McpServerTransportConfig = {
+    type: "streamable_http";
+    url: string;
+    bearer_token_env_var?: string | null;
+    http_headers?: Record<string, string> | null;
+    env_http_headers?: Record<string, string> | null;
+    oauth_tokens_present?: boolean | null;
+} | {
+    type: "stdio";
+    command: string;
+    args?: readonly string[];
+    env?: Record<string, string> | null;
+    env_vars?: readonly string[];
+    cwd?: string | null;
+};
+export type McpServerConfig = {
+    transport: McpServerTransportConfig;
+    enabled?: boolean;
+    required?: boolean;
+    startup_timeout_sec?: number | null;
+    tool_timeout_sec?: number | null;
+    enabled_tools?: readonly string[] | null;
+    disabled_tools?: readonly string[] | null;
+    experimental_environment?: string | null;
+};
+export type McpRuntimeEnvironment = {
+    cwd?: string | null;
+    environment_id?: string | null;
+    remote?: boolean | null;
+};
+export type McpClientFactoryOptions = {
+    fetch?: typeof fetch;
+    environment?: Record<string, string | undefined>;
+    stdio_server_launcher?: StdioServerLauncher | null;
+    runtime_environment?: McpRuntimeEnvironment | null;
+};
+export type StdioServerLauncher = {
+    launch(server_name: string, config: Extract<McpServerTransportConfig, {
+        type: "stdio";
+    }>, runtime_environment?: McpRuntimeEnvironment | null): Promise<RmcpClientLike>;
+};
+export type McpJsonRpcMessage = {
+    jsonrpc: "2.0";
+    id?: string | number;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export type McpJsonRpcTransport = {
+    request(message: McpJsonRpcMessage, timeout?: number | null): Promise<McpJsonRpcMessage>;
+    notify?(message: McpJsonRpcMessage, timeout?: number | null): Promise<void>;
+    close?(): Promise<void> | void;
+};
+export type RmcpRawTool = {
+    name: string;
+    title?: string | null;
+    description?: string | null;
+    input_schema?: unknown;
+    meta?: unknown;
+    connector_id?: string | null;
+    connector_name?: string | null;
+    connector_description?: string | null;
+};
+export type RmcpListToolsResult = readonly ToolInfo[] | readonly RmcpRawTool[] | {
+    tools: readonly (ToolInfo | RmcpRawTool | ({
+        tool: RmcpRawTool;
+    } & Record<string, unknown>))[];
+};
+export type RmcpClientLike = {
+    initialize?: (timeout?: number | null) => Promise<RmcpInitializeResult>;
+    list_tools?: (params?: unknown, timeout?: number | null) => Promise<RmcpListToolsResult>;
+    call_tool?: (tool: string, arguments_: unknown, meta?: unknown, timeout?: number | null) => Promise<unknown>;
+    list_resources?: (params?: unknown, timeout?: number | null) => Promise<unknown>;
+    list_resource_templates?: (params?: unknown, timeout?: number | null) => Promise<unknown>;
+    read_resource?: (params: unknown, timeout?: number | null) => Promise<unknown>;
+    shutdown?: () => Promise<void> | void;
+};
+export type RmcpInitializeResult = {
+    instructions?: string | null;
+    capabilities?: {
+        experimental?: Record<string, unknown> | null;
+        [key: string]: unknown;
+    } | null;
+};
+export type ManagedClientInput = {
+    client?: RmcpClientLike | null;
+    tools?: readonly ToolInfo[];
+    tool_filter?: ToolFilter;
+    tool_timeout?: number | null;
+    server_instructions?: string | null;
+    server_supports_sandbox_state_meta_capability?: boolean;
+    codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+};
+export declare class ManagedClient {
+    readonly client: RmcpClientLike | null;
+    readonly tools: readonly ToolInfo[];
+    readonly tool_filter: ToolFilter;
+    readonly tool_timeout: number | null;
+    readonly server_instructions: string | null;
+    readonly server_supports_sandbox_state_meta_capability: boolean;
+    readonly codex_apps_tools_cache_context: CodexAppsToolsCacheContext | null;
+    constructor(input?: ManagedClientInput);
+    listed_tools(): ToolInfo[];
+    call_tool(tool: string, arguments_: unknown, meta?: unknown): Promise<unknown>;
+    list_resources(params?: unknown): Promise<unknown>;
+    list_resource_templates(params?: unknown): Promise<unknown>;
+    read_resource(params: unknown): Promise<unknown>;
+    shutdown(): Promise<void>;
+}
+export type AsyncManagedClientInput = {
+    client: ManagedClient | Promise<ManagedClient> | (() => ManagedClient | Promise<ManagedClient>);
+    startup_snapshot?: readonly ToolInfo[] | null;
+    tool_plugin_provenance?: ToolPluginProvenance;
+    cancel_token?: CancellationToken;
+};
+export type AsyncManagedClientStartupStatus = {
+    status: "starting";
+} | {
+    status: "ready";
+} | {
+    status: "cancelled";
+} | {
+    status: "failed";
+    error: string;
+};
+export declare class AsyncManagedClient {
+    private readonly client_promise;
+    private readonly startup_snapshot;
+    private readonly startup_complete;
+    private readonly tool_plugin_provenance;
+    private readonly cancel_token;
+    private startup_status_value;
+    constructor(input: AsyncManagedClientInput);
+    static from_managed_client(client: ManagedClient, startup_snapshot?: readonly ToolInfo[] | null): AsyncManagedClient;
+    static new(server_name: string, input: {
+        client: RmcpClientLike | Promise<RmcpClientLike> | (() => RmcpClientLike | Promise<RmcpClientLike>);
+        tool_filter?: ToolFilter;
+        tool_timeout?: number | null;
+        server_instructions?: string | null;
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        tool_plugin_provenance?: ToolPluginProvenance;
+    }): AsyncManagedClient;
+    static from_config(server_name: string, config: McpServerConfig, options?: {
+        codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+        tool_plugin_provenance?: ToolPluginProvenance;
+        client_factory_options?: McpClientFactoryOptions;
+    }): AsyncManagedClient;
+    client(): Promise<ManagedClient>;
+    shutdown(): Promise<void>;
+    startup_status(): AsyncManagedClientStartupStatus;
+    listed_tools(): Promise<ToolInfo[] | null>;
+    private startup_snapshot_while_initializing;
+    private listed_tools_from_client;
+    private annotate_tools;
+}
+export declare class StartupOutcomeError extends Error {
+    readonly kind: "Cancelled" | "Failed";
+    readonly error?: string | undefined;
+    private constructor();
+    static cancelled(): StartupOutcomeError;
+    static failed(error: string): StartupOutcomeError;
+}
+export declare class CancellationToken {
+    private cancelled;
+    cancel(): void;
+    is_cancelled(): boolean;
+    child_token(): CancellationToken;
+}
+export declare function elicitation_capability_for_server(): Record<string, never>;
+export declare function start_server_task(server_name: string, client: RmcpClientLike, params: {
+    startup_timeout?: number | null;
+    tool_timeout?: number | null;
+    tool_filter?: ToolFilter;
+    codex_apps_tools_cache_context?: CodexAppsToolsCacheContext | null;
+}): Promise<ManagedClient>;
+export declare function make_rmcp_client(server_name: string, config: McpServerConfig, options?: McpClientFactoryOptions): Promise<RmcpClientLike>;
+export declare class RmcpJsonRpcClient implements RmcpClientLike {
+    readonly transport: McpJsonRpcTransport;
+    private next_id;
+    constructor(transport: McpJsonRpcTransport);
+    initialize(timeout?: number | null): Promise<RmcpInitializeResult>;
+    list_tools(params?: unknown, timeout?: number | null): Promise<RmcpListToolsResult>;
+    call_tool(tool: string, arguments_: unknown, meta?: unknown, timeout?: number | null): Promise<unknown>;
+    list_resources(params?: unknown, timeout?: number | null): Promise<unknown>;
+    list_resource_templates(params?: unknown, timeout?: number | null): Promise<unknown>;
+    read_resource(params: unknown, timeout?: number | null): Promise<unknown>;
+    shutdown(): Promise<void>;
+    private request;
+    private notify;
+}
+export declare class StreamableHttpMcpTransport implements McpJsonRpcTransport {
+    private readonly fetch_impl;
+    private readonly headers;
+    constructor(input: {
+        url: string;
+        headers?: Record<string, string>;
+        fetch?: typeof fetch;
+    });
+    readonly url: string;
+    request(message: McpJsonRpcMessage, timeout?: number | null): Promise<McpJsonRpcMessage>;
+    notify(message: McpJsonRpcMessage, timeout?: number | null): Promise<void>;
+    private post;
+}
+export declare class UnsupportedStdioServerLauncher implements StdioServerLauncher {
+    launch(server_name: string): Promise<RmcpClientLike>;
+}
+export declare function list_tools_for_client_uncached(server_name: string, client: RmcpClientLike, timeout?: number | null, server_instructions?: string | null): Promise<ToolInfo[]>;
+export declare function validate_mcp_server_name(server_name: string): void;

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

@@ -0,0 +1,37 @@
+export declare const MCP_TOOLS_CACHE_WRITE_DURATION_METRIC = "codex.mcp.tools.cache_write.duration_ms";
+export type ToolInfo = {
+    server_name: string;
+    name: string;
+    callable_name?: string | null;
+    callable_namespace?: string | null;
+    namespace_description?: string | null;
+    title?: string | null;
+    description?: string | null;
+    input_schema?: unknown;
+    meta?: unknown;
+    connector_id?: string | null;
+    connector_name?: string | null;
+    plugin_display_names?: string[];
+    source_label?: string | null;
+    mcp_app_resource_uri?: string | null;
+};
+export type QualifiedToolInfo<T extends ToolInfo = ToolInfo> = T & {
+    callable_name: string;
+    callable_namespace: string;
+    plugin_display_names: string[];
+};
+export declare class ToolFilter {
+    readonly enabled: ReadonlySet<string> | null;
+    readonly disabled: ReadonlySet<string>;
+    constructor(enabled?: ReadonlySet<string> | null, disabled?: ReadonlySet<string>);
+    static from_config(config: {
+        enabled_tools?: readonly string[] | null;
+        disabled_tools?: readonly string[] | null;
+    }): ToolFilter;
+    allows(toolName: string): boolean;
+}
+export declare function declared_openai_file_input_param_names(meta: unknown): string[];
+export declare function tool_with_model_visible_input_schema<T extends ToolInfo>(tool: T): T;
+export declare function filter_tools<T extends ToolInfo>(tools: readonly T[], filter: ToolFilter): T[];
+export declare function qualify_tools<T extends ToolInfo>(tools: Iterable<T>): Map<string, QualifiedToolInfo<T>>;
+export declare function qualify_tool_infos<T extends ToolInfo>(tools: readonly T[]): Array<QualifiedToolInfo<T>>;

package/dist/internal/codex/config/src/config_toml.d.ts

@@ -0,0 +1,14 @@
+import type { ConfigToml } from "./types.js";
+export type { ConfigToml } from "./types.js";
+export type TomlValue = string | number | bigint | boolean | null | TomlValue[] | {
+    [key: string]: TomlValue;
+};
+export type TomlTable = {
+    [key: string]: TomlValue;
+};
+export declare function parse_config_toml(contents: string): ConfigToml;
+export declare function parse_toml_value(contents: string): TomlTable;
+export declare function serialize_config_toml(config: ConfigToml): string;
+export declare function empty_config_toml(): ConfigToml;
+export declare function config_toml_from_unknown(value: unknown): ConfigToml;
+export declare function isTomlTable(value: unknown): value is TomlTable;

package/dist/internal/codex/config/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./config_toml.js";
+export * from "./profile_toml.js";
+export * from "./permissions_toml.js";
+export * from "./types.js";
+export * from "./merge.js";
+export * from "./thread_config.js";
+export * from "./loader/mod.js";

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

@@ -0,0 +1,21 @@
+import { type ConfigLayerEntry, type ConfigLayerSource, type ConfigLayerStack, type ConfigOverrides, type LoaderOverrides } from "../types.js";
+import { type ThreadConfigLoader } from "../thread_config.js";
+export type ConfigFileReader = (path: string) => Promise<string | null> | string | null;
+export type LoadConfigLayersStateParams = {
+    codex_home?: string;
+    cwd?: string | null;
+    cli_overrides?: Array<[string, unknown]>;
+    overrides?: LoaderOverrides;
+    thread_config_loader?: ThreadConfigLoader;
+    read_file_text?: ConfigFileReader;
+    app_config?: {
+        file: string;
+        contents: string;
+    } | null;
+    startup_warnings?: string[];
+};
+export declare function load_config_layers_state(params?: LoadConfigLayersStateParams): Promise<ConfigLayerStack>;
+export declare function load_config(stack: ConfigLayerStack, overrides?: ConfigOverrides): Promise<import("../index.js").ResolvedConfig>;
+export declare function load_config_toml_for_required_layer(read_file_text: ConfigFileReader, name: ConfigLayerSource): Promise<ConfigLayerEntry>;
+export declare function load_config_toml_from_text(name: ConfigLayerSource, contents: string): ConfigLayerEntry;
+export declare function insert_layer_by_precedence(layers: ConfigLayerEntry[], layer: ConfigLayerEntry): void;

package/dist/internal/codex/config/src/merge.d.ts

@@ -0,0 +1,22 @@
+import type { ConfigLayerEntry, ConfigLayerSource, ConfigLayerStack, ConfigLayerStackOrdering, ConfigOverrides, ConfigToml, ResolvedConfig } from "./types.js";
+import type { PermissionProfile } from "../../core/src/protocol.js";
+import { type WebSearchConfig, type WebSearchMode } from "../../core/src/tools/spec_plan_types.js";
+export declare function config_layer_source_precedence(source: ConfigLayerSource): number;
+export declare function ConfigLayerEntry_new(name: ConfigLayerSource, config: ConfigToml): ConfigLayerEntry;
+export declare function ConfigLayerEntry_new_with_raw_toml(name: ConfigLayerSource, config: ConfigToml, raw_toml: string): ConfigLayerEntry;
+export declare function ConfigLayerEntry_new_disabled(name: ConfigLayerSource, config: ConfigToml, disabled_reason: string): ConfigLayerEntry;
+export declare function ConfigLayerEntry_is_disabled(layer: ConfigLayerEntry): boolean;
+export declare function ConfigLayerStack_new(layers?: ConfigLayerEntry[], startup_warnings?: string[]): ConfigLayerStack;
+export declare function ConfigLayerStack_get_layers(stack: ConfigLayerStack, ordering: ConfigLayerStackOrdering, include_disabled?: boolean): ConfigLayerEntry[];
+export declare function ConfigLayerStack_effective_config(stack: ConfigLayerStack): ConfigToml;
+export declare function merge_config_layers(stack: ConfigLayerStack, overrides?: ConfigOverrides): ResolvedConfig;
+export declare function merge_toml_values(base: ConfigToml, overlay: ConfigToml): ConfigToml;
+export declare function resolve_config(config: ConfigToml, startupWarnings?: string[], overrides?: ConfigOverrides): ResolvedConfig;
+export declare function resolve_web_search_mode(config: Pick<ConfigToml, "features" | "web_search">): WebSearchMode | null;
+export declare function resolve_web_search_config(config: Pick<ConfigToml, "tools">): WebSearchConfig | null;
+export declare function resolve_web_search_mode_for_turn(input: {
+    allowed_modes?: readonly WebSearchMode[] | null;
+    permission_profile?: PermissionProfile | null;
+    web_search_mode: WebSearchMode;
+}): WebSearchMode;
+export declare function build_cli_overrides_layer(cli_overrides: Array<[string, unknown]>): ConfigToml;

package/dist/internal/codex/config/src/permissions_toml.d.ts

@@ -0,0 +1,6 @@
+import type { ActivePermissionProfile, PermissionProfile, SandboxPolicy } from "../../core/src/protocol.js";
+export type PermissionsToml = {
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    sandbox_policy?: SandboxPolicy | null;
+};

package/dist/internal/codex/config/src/profile_toml.d.ts

@@ -0,0 +1 @@
+export type { ConfigProfile } from "./types.js";

package/dist/internal/codex/config/src/thread_config.d.ts

@@ -0,0 +1,43 @@
+import type { ThreadId } from "../../core/src/ids.js";
+import type { ConfigLayerEntry, ConfigToml } from "./types.js";
+export type ThreadConfigContext = {
+    thread_id: ThreadId | null;
+    cwd: string | null;
+};
+export type SessionThreadConfig = ConfigToml & {
+    model_provider?: string;
+    model_providers?: Record<string, unknown>;
+    features?: Record<string, unknown>;
+};
+export type UserThreadConfig = ConfigToml;
+export type ThreadConfigSource = {
+    type: "Session";
+    config: SessionThreadConfig;
+} | {
+    type: "User";
+    config: UserThreadConfig;
+};
+export type ThreadConfigLoadErrorCode = "Auth" | "Timeout" | "Parse" | "RequestFailed" | "Internal";
+export declare class ThreadConfigLoadError extends Error {
+    readonly code: ThreadConfigLoadErrorCode;
+    readonly status_code: number | null;
+    constructor(code: ThreadConfigLoadErrorCode, message: string, status_code?: number | null);
+}
+export interface ThreadConfigLoader {
+    load(context: ThreadConfigContext): Promise<ThreadConfigSource[]> | ThreadConfigSource[];
+    load_config_layers(context: ThreadConfigContext): Promise<ConfigLayerEntry[]> | ConfigLayerEntry[];
+}
+export declare abstract class BaseThreadConfigLoader implements ThreadConfigLoader {
+    abstract load(context: ThreadConfigContext): Promise<ThreadConfigSource[]> | ThreadConfigSource[];
+    load_config_layers(context: ThreadConfigContext): Promise<ConfigLayerEntry[]>;
+}
+export declare class StaticThreadConfigLoader extends BaseThreadConfigLoader {
+    private readonly sources;
+    constructor(sources?: ThreadConfigSource[]);
+    load(context: ThreadConfigContext): ThreadConfigSource[];
+}
+export declare class NoopThreadConfigLoader extends BaseThreadConfigLoader {
+    static readonly instance: NoopThreadConfigLoader;
+    load(context: ThreadConfigContext): ThreadConfigSource[];
+}
+export declare function thread_config_source_to_layer(source: ThreadConfigSource): ConfigLayerEntry | null;

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

@@ -0,0 +1,121 @@
+import type { ActivePermissionProfile, ApprovalsReviewer, AskForApproval, BaseInstructions, DynamicToolSpec, PermissionProfile, Personality, ReasoningEffortConfig, ReasoningSummaryConfig, SandboxPolicy, ServiceTier, SessionSource, TruncationPolicy, TurnEnvironmentSelection, WindowsSandboxLevel } from "../../core/src/protocol.js";
+import type { CollaborationMode } from "../../core/src/config-types.js";
+import type { DefaultToolsConfigInput, ToolsConfig } from "../../core/src/tools/spec_plan_types.js";
+import type { WebSearchMode, WebSearchToolConfig } from "../../app-server-protocol/schema/typescript/index.js";
+export declare const CONFIG_TOML_FILE = "config.toml";
+export type ConfigLayerSource = {
+    type: "Mdm";
+    domain: string;
+    key: string;
+} | {
+    type: "System";
+    file: string;
+} | {
+    type: "User";
+    file: string;
+} | {
+    type: "Project";
+    dot_codex_folder: string;
+} | {
+    type: "SessionFlags";
+} | {
+    type: "LegacyManagedConfigTomlFromFile";
+    file: string;
+} | {
+    type: "LegacyManagedConfigTomlFromMdm";
+};
+export type ConfigLayerMetadata = {
+    name: ConfigLayerSource;
+    version: string;
+};
+export type ConfigLayerEntry = {
+    name: ConfigLayerSource;
+    config: ConfigToml;
+    raw_toml?: string | null;
+    version: string;
+    disabled_reason?: string | null;
+};
+export type ConfigLayerStack = {
+    layers: ConfigLayerEntry[];
+    startup_warnings: string[];
+};
+export declare const ConfigLayerStackOrdering: {
+    readonly LowestPrecedenceFirst: "LowestPrecedenceFirst";
+    readonly HighestPrecedenceFirst: "HighestPrecedenceFirst";
+};
+export type ConfigLayerStackOrdering = (typeof ConfigLayerStackOrdering)[keyof typeof ConfigLayerStackOrdering];
+export type ConfigOverrides = ConfigToml;
+export type ConfigToml = {
+    model?: string;
+    review_model?: string;
+    model_provider?: string;
+    service_tier?: ServiceTier | null;
+    model_reasoning_effort?: ReasoningEffortConfig | null;
+    plan_mode_reasoning_effort?: ReasoningEffortConfig | null;
+    model_reasoning_summary?: ReasoningSummaryConfig;
+    personality?: Personality | null;
+    approval_policy?: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy?: SandboxPolicy | null;
+    sandbox_mode?: SandboxPolicy["mode"] | null;
+    default_permissions?: string | null;
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    cwd?: string;
+    instructions?: string | null;
+    model_instructions_file?: string | null;
+    model_instructions_file_contents?: string | null;
+    base_instructions?: BaseInstructions | string | null;
+    developer_instructions?: string | null;
+    user_instructions?: string | null;
+    collaboration_mode?: CollaborationMode | null;
+    session_source?: SessionSource;
+    environments?: TurnEnvironmentSelection[];
+    dynamic_tools?: DynamicToolSpec[];
+    final_output_json_schema?: unknown;
+    truncation_policy?: TruncationPolicy | null;
+    web_search?: WebSearchMode | null;
+    tools?: ToolsToml | null;
+    features?: FeaturesToml | null;
+    profiles?: Record<string, ConfigProfile>;
+    profile?: string | null;
+    compact_prompt?: string | null;
+    include_permissions_instructions?: boolean;
+    include_environment_context?: boolean;
+    include_apps_instructions?: boolean;
+    include_skill_instructions?: boolean;
+};
+export type ConfigProfile = Omit<ConfigToml, "profiles" | "profile">;
+export type ToolsToml = Omit<DefaultToolsConfigInput, "web_search"> & {
+    web_search?: Partial<WebSearchToolConfig> | boolean | null;
+};
+export type FeaturesToml = Record<string, unknown>;
+export type ResolvedConfig = Required<Pick<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source">> & Omit<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source"> & {
+    base_instructions: BaseInstructions;
+    base_instructions_source: "config" | "model_instructions_file" | "default";
+    service_tier: ServiceTier | null;
+    reasoning_effort: ReasoningEffortConfig | null;
+    reasoning_summary: ReasoningSummaryConfig;
+    developer_instructions: string | null;
+    user_instructions: string | null;
+    personality: Personality | null;
+    sandbox_policy: SandboxPolicy;
+    permission_profile: PermissionProfile;
+    active_permission_profile: ActivePermissionProfile | null;
+    windows_sandbox_level: WindowsSandboxLevel | null;
+    collaboration_mode: CollaborationMode;
+    environments: TurnEnvironmentSelection[];
+    dynamic_tools: DynamicToolSpec[];
+    final_output_json_schema?: unknown;
+    truncation_policy: TruncationPolicy | null;
+    web_search_mode: WebSearchMode;
+    tools: ToolsConfig;
+    startup_warnings: string[];
+};
+export declare function createConfigLayerStack(layers?: ConfigLayerEntry[], startup_warnings?: string[]): ConfigLayerStack;
+export type LoaderOverrides = {
+    ignore_user_config?: boolean;
+    ignore_managed_requirements?: boolean;
+    ignore_user_and_project_exec_policy_rules?: boolean;
+};

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

@@ -0,0 +1,3 @@
+import type { ThreadId } from "../ids.js";
+import type { AgentRegistry } from "./registry.js";
+export declare function resolve_agent_target(registry: AgentRegistry, target: string): ThreadId | null;