@agentionai/agents 1.12.0 → 1.14.0

package/dist/agents/Agent.d.ts

@@ -42,7 +42,7 @@ type OpenRouterAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & OpenRou
 };
 type AgentConfig = ClaudeAgentConfig | OpenAIAgentConfig | GeminiAgentConfig | MistralAgentConfig | OllamaAgentConfig | LlamaCppAgentConfig | OpenRouterAgentConfig;
 export declare class Agent {
-    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | MistralAgent | OllamaAgent | LlamaCppAgent | OpenRouterAgent | OpenAiAgent<(string & {}) | "gpt-5-pro" | "gpt-5.2-pro" | "gpt-5.4-pro" | "gpt-5.5-pro" | "o1" | "o1-pro" | "o3" | "o3-mini" | "o4-mini" | "gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5.1" | "gpt-5.2" | "gpt-5.4" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5.5" | "gpt-5.6" | "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini">;
+    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | MistralAgent | OllamaAgent | LlamaCppAgent | OpenRouterAgent | OpenAiAgent<(string & {}) | "gpt-5-pro" | "gpt-5.2-pro" | "gpt-5.4-pro" | "gpt-5.5-pro" | "o1" | "o1-pro" | "o3" | "o3-mini" | "o4-mini" | "gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5.1" | "gpt-5.2" | "gpt-5.4" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5.5" | "gpt-5.6" | "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4.1-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1-preview" | "o1-mini", import("openai/resources/models").Model>;
 }
 export {};
 //# sourceMappingURL=Agent.d.ts.map

package/dist/agents/AgentConfig.d.ts

@@ -137,6 +137,40 @@ export interface OpenAISpecificConfig {
      * see `lib/tools/BuiltInTool.ts`.
      */
     builtInTools?: BuiltInTool[];
+    /**
+     * Cache-routing key sent as `prompt_cache_key`. Requests sharing a key are
+     * steered to the same prompt cache, raising the hit rate for a long
+     * conversation or a fleet of agents sharing a system prompt and tool belt.
+     */
+    promptCacheKey?: string;
+    /**
+     * How long cached prefixes stay warm — `"24h"` opts into extended retention.
+     * Ignored by the ChatGPT/Codex backend, which manages its own cache.
+     */
+    promptCacheRetention?: "in-memory" | "24h";
+    /**
+     * Override the API base URL. Defaults to `api.openai.com/v1`; `CodexAgent`
+     * defaults it to `https://chatgpt.com/backend-api/codex`, and setting it
+     * there points at a Codex proxy instead.
+     */
+    baseURL?: string;
+    /**
+     * `CodexAgent` only: ChatGPT workspace to bill, sent as the
+     * `chatgpt-account-id` header.
+     */
+    accountId?: string;
+    /**
+     * `CodexAgent` only: client identifier sent as the `originator` header.
+     * OpenAI varies the model catalog by originator.
+     *
+     * @default "codex_cli_rs"
+     */
+    originator?: string;
+    /**
+     * `client_version` sent to the Codex models endpoint, which requires one and
+     * hides models newer than the version claimed.
+     */
+    clientVersion?: string;
 }
 /**
  * Vendor-specific configuration for Mistral

package/dist/agents/AgentEvent.d.ts

@@ -17,6 +17,12 @@ export declare class AgentEvent {
      * to history. The listener receives the `PartialTurn` that was salvaged.
      */
     static PARTIAL_TURN: string;
+    /**
+     * The provider reported how much of the account's allowance is left. Emitted
+     * by `CodexAgent`, whose backend returns rate-limit and credit headers on
+     * every response; the listener receives a `CodexUsageLimits`.
+     */
+    static USAGE_LIMITS: string;
     private defaultPrevented;
     constructor(target: BaseAgent<any>);
     preventDefault(): void;

package/dist/agents/AgentEvent.js

@@ -30,4 +30,10 @@ AgentEvent.REASONING_CHUNK = "reasoning_chunk";
  * to history. The listener receives the `PartialTurn` that was salvaged.
  */
 AgentEvent.PARTIAL_TURN = "partial_turn";
+/**
+ * The provider reported how much of the account's allowance is left. Emitted
+ * by `CodexAgent`, whose backend returns rate-limit and credit headers on
+ * every response; the listener receives a `CodexUsageLimits`.
+ */
+AgentEvent.USAGE_LIMITS = "usage_limits";
 //# sourceMappingURL=AgentEvent.js.map

package/dist/agents/BaseAgent.d.ts

@@ -41,6 +41,24 @@ export type TokenUsage = {
      * for instance, folds thinking tokens into `output_tokens`.
      */
     reasoning_tokens?: number;
+    /**
+     * Prompt tokens the provider served from its own cache instead of processing
+     * afresh — a subset of `input_tokens`, not an addition to them, and normally
+     * billed at a discount.
+     *
+     * `0` is a real answer ("nothing hit the cache"); `undefined` means the
+     * provider said nothing about caching at all.
+     */
+    cache_read_tokens?: number;
+    /**
+     * Prompt tokens this call wrote *into* the provider's cache, where the
+     * provider reports writes separately from reads. Also a subset of
+     * `input_tokens` on the OpenAI-shaped providers.
+     *
+     * Rarer than `cache_read_tokens` — of the providers wired here only the
+     * ChatGPT/Codex backend reports it, and the platform Responses API does not.
+     */
+    cache_write_tokens?: number;
     /**
      * USD billed for this usage, straight from the provider's own accounting —
      * not derived from a local price table. Undefined where the provider

package/dist/agents/BaseAgent.js

@@ -253,6 +253,8 @@ class BaseAgent extends events_1.default {
                 output_tokens: previous.output_tokens + timed.output_tokens,
                 total_tokens: previous.total_tokens + timed.total_tokens,
                 reasoning_tokens: sumOptional(previous.reasoning_tokens, timed.reasoning_tokens),
+                cache_read_tokens: sumOptional(previous.cache_read_tokens, timed.cache_read_tokens),
+                cache_write_tokens: sumOptional(previous.cache_write_tokens, timed.cache_write_tokens),
                 cost_usd: sumOptional(previous.cost_usd, timed.cost_usd),
                 timeToFirstTokenMs: sumOptional(previous.timeToFirstTokenMs, timed.timeToFirstTokenMs),
                 generationMs: sumOptional(previous.generationMs, timed.generationMs),

package/dist/agents/openai/CodexAgent.d.ts

@@ -0,0 +1,169 @@
+import { History } from "../../history/History";
+import { ModelInfo } from "../BaseAgent";
+import { ResponseInputItem } from "openai/resources/responses/responses";
+import { OpenAIModel } from "../model-types";
+import { AgentConfig as OpenAiAgentConfig, OpenAiAgent } from "./OpenAiAgent";
+import { CodexCredentials, CodexModelCard, CodexTokenProviderOptions } from "./codex-auth";
+import { CodexUsageLimits } from "./codex-usage";
+/**
+ * Models the ChatGPT-backed Codex backend serves.
+ *
+ * A different namespace from the platform API's — every platform id
+ * (`gpt-5.6`, `gpt-4.1-mini`, even `gpt-5.1-codex`) is rejected here with
+ * *"model is not supported when using Codex with a ChatGPT account"*. Probed
+ * live on 2026-09-09; `(string & {})` keeps a newer model usable without a
+ * release, while still autocompleting the known ones.
+ */
+export type CodexModel = "gpt-5.6-luna" | "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.5" | "gpt-6-astra" | "codex-auto-review" | (string & Record<never, never>);
+/**
+ * Reasoning efforts the Codex models accept — a different set from the platform
+ * API's, and uniform across these models rather than per-family. Each model's
+ * live list is on `ModelInfo.raw.supported_reasoning_levels`.
+ */
+export type CodexReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type CodexAgentConfig = Omit<OpenAiAgentConfig, "model" | "reasoningEffort" | "fetch" | "vendor"> & {
+    /** @default "gpt-5.6-luna" */
+    model?: CodexModel;
+    /**
+     * How hard the model should think. `medium` if unset — the backend's own
+     * default for these models.
+     */
+    reasoningEffort?: CodexReasoningEffort;
+    /**
+     * ChatGPT workspace to bill, sent as the `chatgpt-account-id` header. Take it
+     * from {@link loadCodexCredentials}; the backend may reject a request without
+     * one.
+     */
+    accountId?: string;
+    /**
+     * Client identifier sent as `originator`. OpenAI gates parts of the model
+     * catalog on this, so the default mirrors the Codex CLI.
+     *
+     * @default CODEX_ORIGINATOR
+     */
+    originator?: string;
+    /**
+     * `client_version` for the models endpoint, which 400s without one and hides
+     * models newer than the version claimed.
+     *
+     * @default CODEX_CLIENT_VERSION
+     */
+    clientVersion?: string;
+};
+/**
+ * Agent for OpenAI models reached through a **ChatGPT subscription** rather
+ * than a platform API key.
+ *
+ * Talks to `https://chatgpt.com/backend-api/codex`, the endpoint OpenAI's Codex
+ * CLI uses, so calls are billed against the subscription instead of an API
+ * account. It speaks the Responses API, hence the `OpenAiAgent` base — but the
+ * two are far enough apart that mixing them in one class meant lying to the
+ * type system about which models exist:
+ *
+ * | | platform | Codex |
+ * |---|---|---|
+ * | models | `gpt-5.6`, `gpt-4.1-mini`, … | `gpt-5.6-luna/sol/terra`, … — disjoint sets |
+ * | body | as written | `instructions` required, `stream: true`, no `max_output_tokens` |
+ * | errors | `{error: {…}}` | `{detail: …}` |
+ * | terminal event | `output` populated | `output: []`; content arrives as items |
+ * | models endpoint | `/v1/models` | `/models?client_version=…` |
+ *
+ * Nothing here is a documented public API and OpenAI can change it without
+ * notice; {@link OpenAiAgent} with a platform key remains the supported path.
+ *
+ * @example
+ * ```typescript
+ * // Reads the credentials `codex login` stored, and keeps the token fresh.
+ * const agent = await CodexAgent.fromCodexCli({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ * });
+ *
+ * console.log(await agent.execute("Hello!"));
+ * ```
+ */
+export declare class CodexAgent extends OpenAiAgent<OpenAIModel, CodexModelCard> {
+    private readonly accountId?;
+    private readonly originator;
+    private readonly clientVersion;
+    private readonly codexBaseURL;
+    /**
+     * Quota state written by the fetch wrapper installed in the constructor.
+     *
+     * A holder object rather than a field because the wrapper is built *before*
+     * `super()` — the base constructor creates the SDK client, so the wrapper has
+     * to exist by then, and `this` is not available yet. `notify` is attached
+     * afterwards, once emitting is possible.
+     */
+    private readonly limits;
+    constructor(config: CodexAgentConfig, history?: History);
+    /**
+     * What the most recent response said about the subscription's remaining
+     * allowance — this backend's answer to "what did that cost?".
+     *
+     * A ChatGPT subscription is not priced per request, so
+     * `lastTokenUsage.cost_usd` is undefined here and always will be. What a call
+     * spends is plan allowance, reported as two rolling windows (5-hourly and
+     * weekly) plus the credit balance that takes over once they are used up.
+     *
+     * Unlike `lastTokenUsage`, this is **not** reset per run: it describes the
+     * account, not the turn, so it keeps the last value seen until another call
+     * updates it. `undefined` before the first call, and after calls that carried
+     * no quota headers — `listModels()` is one, so only `execute()` /
+     * `executeStream()` refresh it. `AgentEvent.USAGE_LIMITS` fires on every
+     * update, including the ones on a failed request.
+     *
+     * @example
+     * ```typescript
+     * await agent.execute("Hello!");
+     * const limits = agent.lastUsageLimits;
+     * console.log(`${limits?.primary?.usedPercent}% of the 5h window used`);
+     * ```
+     */
+    get lastUsageLimits(): CodexUsageLimits | undefined;
+    /**
+     * Build an agent from the credentials `codex login` stored, wrapped in a
+     * provider that refreshes the access token as it ages out.
+     *
+     * @throws if no credentials are present — run `codex login` first.
+     */
+    static fromCodexCli(config: Omit<CodexAgentConfig, "apiKey" | "accountId"> & {
+        /** Read `auth.json` from somewhere other than `$CODEX_HOME`. */
+        codexHome?: string;
+        /** Forwarded to {@link createCodexTokenProvider}. */
+        tokenOptions?: CodexTokenProviderOptions;
+    }, history?: History): Promise<CodexAgent>;
+    /** Build an agent from credentials obtained however you like. */
+    static fromCredentials(credentials: CodexCredentials, config: Omit<CodexAgentConfig, "apiKey" | "accountId"> & {
+        tokenOptions?: CodexTokenProviderOptions;
+    }, history?: History): CodexAgent;
+    /** This backend refuses `stream: false` outright. */
+    protected get forceStreaming(): boolean;
+    /**
+     * Satisfy the backend's extra body validations, each of which is otherwise a
+     * bare `400`: *"Instructions are required"*, *"Input must be a list"*,
+     * *"Store must be set to false"*, *"Stream must be set to true"*,
+     * *"Unsupported parameter: max_output_tokens"*.
+     *
+     * `store: false` and a list-shaped `input` already hold at every call site in
+     * the base class.
+     */
+    protected transformRequestParams<T extends {
+        input: ResponseInputItem[];
+    }>(params: T): T;
+    /**
+     * List the models this ChatGPT account may drive.
+     *
+     * Neither the endpoint nor the shape matches the platform API's
+     * `/v1/models`: it needs a `client_version` query parameter (400s without
+     * one) and returns richer cards — the context window for this account's
+     * plan, the reasoning efforts the model accepts, the plans it is available
+     * in. The SDK has no method for it, so this goes out through `fetch`.
+     *
+     * Models whose `minimal_client_version` exceeds {@link clientVersion} are
+     * omitted by the server, not here.
+     */
+    listModels(): Promise<ModelInfo<CodexModelCard>[]>;
+}
+//# sourceMappingURL=CodexAgent.d.ts.map

package/dist/agents/openai/CodexAgent.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAgent = void 0;
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const OpenAiAgent_1 = require("./OpenAiAgent");
+const codex_auth_1 = require("./codex-auth");
+const codex_usage_1 = require("./codex-usage");
+/**
+ * Agent for OpenAI models reached through a **ChatGPT subscription** rather
+ * than a platform API key.
+ *
+ * Talks to `https://chatgpt.com/backend-api/codex`, the endpoint OpenAI's Codex
+ * CLI uses, so calls are billed against the subscription instead of an API
+ * account. It speaks the Responses API, hence the `OpenAiAgent` base — but the
+ * two are far enough apart that mixing them in one class meant lying to the
+ * type system about which models exist:
+ *
+ * | | platform | Codex |
+ * |---|---|---|
+ * | models | `gpt-5.6`, `gpt-4.1-mini`, … | `gpt-5.6-luna/sol/terra`, … — disjoint sets |
+ * | body | as written | `instructions` required, `stream: true`, no `max_output_tokens` |
+ * | errors | `{error: {…}}` | `{detail: …}` |
+ * | terminal event | `output` populated | `output: []`; content arrives as items |
+ * | models endpoint | `/v1/models` | `/models?client_version=…` |
+ *
+ * Nothing here is a documented public API and OpenAI can change it without
+ * notice; {@link OpenAiAgent} with a platform key remains the supported path.
+ *
+ * @example
+ * ```typescript
+ * // Reads the credentials `codex login` stored, and keeps the token fresh.
+ * const agent = await CodexAgent.fromCodexCli({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ * });
+ *
+ * console.log(await agent.execute("Hello!"));
+ * ```
+ */
+class CodexAgent extends OpenAiAgent_1.OpenAiAgent {
+    constructor(config, history) {
+        const vendorConfig = config.vendorConfig?.openai ?? {};
+        const accountId = config.accountId ?? vendorConfig.accountId;
+        const originator = config.originator ?? vendorConfig.originator ?? codex_auth_1.CODEX_ORIGINATOR;
+        const baseURL = config.baseURL ?? vendorConfig.baseURL ?? codex_auth_1.CODEX_BASE_URL;
+        // Filled by the fetch wrapper below and adopted as `this.limits` once
+        // `super()` has run.
+        const limits = {};
+        // Everything host-specific is passed *into* the base constructor rather
+        // than supplied by an override: the base runs before this class's fields
+        // are assigned, so an override could not read them.
+        super({
+            ...config,
+            model: config.model ?? "gpt-5.6-luna",
+            reasoningEffort: config.reasoningEffort,
+            baseURL,
+            defaultHeaders: {
+                ...(accountId ? { "chatgpt-account-id": accountId } : {}),
+                "OpenAI-Beta": "responses=experimental",
+                originator,
+                // Every Codex request is a stream; the SDK would send
+                // `application/json`, which no reference client does.
+                Accept: "text/event-stream",
+                ...config.defaultHeaders,
+            },
+            // Two wrappers, innermost first: normalise this backend's `{detail: …}`
+            // error bodies (which the SDK otherwise drops on the floor — see
+            // wrapErrorBodyFetch()), then read the `x-codex-*` quota headers off
+            // every response on the way back out.
+            fetch: (0, codex_usage_1.observeHeadersFetch)((headers) => {
+                const parsed = (0, codex_usage_1.parseCodexUsageLimits)(headers);
+                if (!parsed)
+                    return;
+                limits.latest = parsed;
+                limits.notify?.(parsed);
+            }, (0, OpenAiAgent_1.wrapErrorBodyFetch)()),
+            // Cast: the codex-specific keys (accountId, originator, clientVersion)
+            // are not part of the base config, and `vendor` is supplied by it.
+        }, history);
+        this.limits = limits;
+        // Only now can the wrapper emit; anything parsed before this point is still
+        // on `limits.latest`.
+        limits.notify = (usageLimits) => this.emit(AgentEvent_1.AgentEvent.USAGE_LIMITS, usageLimits);
+        this.accountId = accountId;
+        this.originator = originator;
+        this.clientVersion =
+            config.clientVersion ?? vendorConfig.clientVersion ?? codex_auth_1.CODEX_CLIENT_VERSION;
+        this.codexBaseURL = baseURL;
+    }
+    /**
+     * What the most recent response said about the subscription's remaining
+     * allowance — this backend's answer to "what did that cost?".
+     *
+     * A ChatGPT subscription is not priced per request, so
+     * `lastTokenUsage.cost_usd` is undefined here and always will be. What a call
+     * spends is plan allowance, reported as two rolling windows (5-hourly and
+     * weekly) plus the credit balance that takes over once they are used up.
+     *
+     * Unlike `lastTokenUsage`, this is **not** reset per run: it describes the
+     * account, not the turn, so it keeps the last value seen until another call
+     * updates it. `undefined` before the first call, and after calls that carried
+     * no quota headers — `listModels()` is one, so only `execute()` /
+     * `executeStream()` refresh it. `AgentEvent.USAGE_LIMITS` fires on every
+     * update, including the ones on a failed request.
+     *
+     * @example
+     * ```typescript
+     * await agent.execute("Hello!");
+     * const limits = agent.lastUsageLimits;
+     * console.log(`${limits?.primary?.usedPercent}% of the 5h window used`);
+     * ```
+     */
+    get lastUsageLimits() {
+        return this.limits.latest;
+    }
+    /**
+     * Build an agent from the credentials `codex login` stored, wrapped in a
+     * provider that refreshes the access token as it ages out.
+     *
+     * @throws if no credentials are present — run `codex login` first.
+     */
+    static async fromCodexCli(config, history) {
+        const credentials = await (0, codex_auth_1.loadCodexCredentials)(config.codexHome);
+        return CodexAgent.fromCredentials(credentials, config, history);
+    }
+    /** Build an agent from credentials obtained however you like. */
+    static fromCredentials(credentials, config, history) {
+        const tokens = (0, codex_auth_1.createCodexTokenProvider)(credentials, config.tokenOptions);
+        return new CodexAgent({
+            ...config,
+            // The function form: the SDK re-invokes it before every request, so a
+            // long run outlives the ~1h token.
+            apiKey: tokens.getToken,
+            accountId: credentials.accountId,
+        }, history);
+    }
+    /** This backend refuses `stream: false` outright. */
+    get forceStreaming() {
+        return true;
+    }
+    /**
+     * Satisfy the backend's extra body validations, each of which is otherwise a
+     * bare `400`: *"Instructions are required"*, *"Input must be a list"*,
+     * *"Store must be set to false"*, *"Stream must be set to true"*,
+     * *"Unsupported parameter: max_output_tokens"*.
+     *
+     * `store: false` and a list-shaped `input` already hold at every call site in
+     * the base class.
+     */
+    transformRequestParams(params) {
+        // Read from history rather than getSystemMessage(): that is the message
+        // being stripped from `input` below, and a caller may have replaced it.
+        const systemMessage = this.history.getSystemMessage() ?? this.getSystemMessage();
+        // Rejected outright, so it cannot merely be left undefined when the caller
+        // set `maxTokens`.
+        const { max_output_tokens: _dropped, ...rest } = params;
+        return {
+            ...rest,
+            // Must be present and non-empty.
+            instructions: systemMessage?.trim()
+                ? systemMessage
+                : "You are a helpful assistant.",
+            // The system prompt travels in `instructions` now, so drop the copy the
+            // transformer put in `input` rather than sending it twice.
+            input: params.input.filter((item) => !(typeof item === "object" &&
+                item !== null &&
+                "role" in item &&
+                item.role === "system")),
+        };
+    }
+    /**
+     * List the models this ChatGPT account may drive.
+     *
+     * Neither the endpoint nor the shape matches the platform API's
+     * `/v1/models`: it needs a `client_version` query parameter (400s without
+     * one) and returns richer cards — the context window for this account's
+     * plan, the reasoning efforts the model accepts, the plans it is available
+     * in. The SDK has no method for it, so this goes out through `fetch`.
+     *
+     * Models whose `minimal_client_version` exceeds {@link clientVersion} are
+     * omitted by the server, not here.
+     */
+    async listModels() {
+        try {
+            const token = await this.resolveApiKey();
+            const url = `${this.codexBaseURL}/models?client_version=${encodeURIComponent(this.clientVersion)}`;
+            const res = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    ...(this.accountId ? { "chatgpt-account-id": this.accountId } : {}),
+                    originator: this.originator,
+                },
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new Error(`${res.status} ${res.statusText}${body ? `: ${body.slice(0, 300)}` : ""}`);
+            }
+            const data = (await res.json());
+            return (data.models ?? []).map((model) => ({
+                id: model.slug,
+                displayName: model.display_name,
+                // The plan's window, not the model's ceiling — `max_context_window` is
+                // on `raw` for anyone who needs the larger number.
+                contextLength: model.context_window,
+                capabilities: {
+                    chat: true,
+                    tools: true,
+                    vision: model.input_modalities?.includes("image"),
+                    thinking: (model.supported_reasoning_levels?.length ?? 0) > 0,
+                },
+                raw: model,
+            }));
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list Codex models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+}
+exports.CodexAgent = CodexAgent;
+//# sourceMappingURL=CodexAgent.js.map