@agentionai/agents 1.12.0 → 1.14.0

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

@@ -2,14 +2,30 @@ import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent"
 import { ExecuteOptions } from "../cancellation";
 import { History, MessageContent } from "../../history/History";
 import { type BuiltInTool } from "../../tools/BuiltInTool";
-import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
+import { Tool, Response, ResponseInputItem, ResponseUsage } from "openai/resources/responses/responses";
 import type { Model as OpenAIModelCard } from "openai/resources/models";
 import { OpenAIModel, ReasoningEffort, ReasoningEffortFor } from "../model-types";
 import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
-type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
-    apiKey: string;
+export type AgentConfig<M extends OpenAIModel = OpenAIModel> = Omit<BaseAgentConfig, "apiKey"> & {
+    /**
+     * Platform API key, or an async function returning one.
+     *
+     * A function is re-invoked before every request, so a rotating or refreshed
+     * credential stays current across a long run — which is how `CodexAgent`
+     * keeps a ChatGPT OAuth token alive.
+     */
+    apiKey: string | (() => Promise<string>);
     model?: M;
     maxTokens?: number;
+    /**
+     * Override the API base URL. Defaults to the SDK's `api.openai.com/v1`.
+     */
+    baseURL?: string;
+    /**
+     * Replace the `fetch` used for every request — for interception, proxying, or
+     * normalising a non-OpenAI host's error bodies (see {@link wrapErrorBodyFetch}).
+     */
+    fetch?: typeof fetch;
     disableParallelToolUse?: boolean;
     /**
      * Ask for the least reasoning the configured model supports (e.g. `minimal` on
@@ -30,6 +46,26 @@ type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
      * @see lib/tools/BuiltInTool.ts
      */
     builtInTools?: BuiltInTool[];
+    /**
+     * Cache-routing key sent as `prompt_cache_key`. Requests sharing a key are
+     * steered to the same cache, which raises the prompt-cache hit rate for a
+     * long conversation or a fleet of agents that share a system prompt and tool
+     * belt. Any stable string works — a conversation id is the usual choice.
+     *
+     * Left unset by default: caching still happens without it, this only
+     * improves the routing.
+     *
+     * @see https://platform.openai.com/docs/guides/prompt-caching
+     */
+    promptCacheKey?: string;
+    /**
+     * How long cached prefixes stay warm. `"24h"` opts into extended retention;
+     * the default (`undefined`, i.e. the API's `in-memory`) expires a prefix
+     * within minutes.
+     *
+     * Ignored by the ChatGPT/Codex backend, which manages its own cache.
+     */
+    promptCacheRetention?: "in-memory" | "24h";
 };
 /**
  * Lowest `reasoning.effort` the given model accepts, used to resolve
@@ -47,6 +83,52 @@ type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
  * `reasoningEffort` explicitly to override.
  */
 export declare function lowestReasoningEffort(model: string | undefined): ReasoningEffort | undefined;
+/**
+ * `usage.input_tokens_details` as the wire actually carries it.
+ *
+ * The SDK's `ResponseUsage.InputTokensDetails` declares `cached_tokens` alone,
+ * but the ChatGPT/Codex backend also reports `cache_write_tokens` (observed
+ * live on 2026-09-10). Declared here rather than cast at the use site, and
+ * every field optional because a non-OpenAI host behind this SDK may report
+ * neither.
+ */
+export type OpenAIInputTokensDetails = {
+    /** Prompt tokens served from cache. */
+    cached_tokens?: number;
+    /** Prompt tokens written to cache. Codex backend only. */
+    cache_write_tokens?: number;
+};
+/**
+ * `fetch` wrapper that rewrites a non-OpenAI-shaped error body into the shape
+ * the SDK can read.
+ *
+ * `APIError.generate` takes the message from `body.error` and throws the rest
+ * away (`openai/core/error.js`), so a backend that reports failures as
+ * `{"detail": "..."}` — which the ChatGPT Codex endpoint does, for all four of
+ * its body validations plus auth failures — surfaces as the useless
+ * `400 status code (no body)`. Nesting the original body under `error` puts the
+ * real reason back in the thrown error.
+ *
+ * Only touches error responses; successful (streaming) responses pass straight
+ * through untouched.
+ */
+export declare function wrapErrorBodyFetch(baseFetch?: typeof fetch): typeof fetch;
+/**
+ * Pull a human-readable message out of an OpenAI-shaped error.
+ *
+ * `api.openai.com` answers with `{ error: { message, code } }`, but not every
+ * host behind this SDK does — the ChatGPT Codex backend reports its validation
+ * failures as `{ detail: "Instructions are required" }`. Reading
+ * `error.error.message` blindly turns those into a `TypeError` that hides the
+ * real cause, so every field is probed defensively and the SDK's own `message`
+ * is the last resort.
+ */
+export declare function describeOpenAIError(error: unknown): {
+    message: string;
+    code?: string;
+    status?: number;
+    body?: unknown;
+};
 /**
  * Agent for OpenAI models using the Responses API.
  *
@@ -62,7 +144,7 @@ export declare function lowestReasoningEffort(model: string | undefined): Reason
  * const response = await agent.execute("Hello!");
  * ```
  */
-export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends BaseAgent {
+export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel, TModelCard = OpenAIModelCard> extends BaseAgent {
     private client;
     /**
      * Resolved runtime config. Deliberately not narrowed by `M` — the constructor
@@ -75,6 +157,19 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
     private vizEventId?;
     /** Count of tool calls in current execution */
     private currentToolCallCount;
+    /**
+     * Whether a non-streaming call must be issued as a stream and collapsed.
+     * `false` here; `CodexAgent` overrides it, since that backend refuses
+     * `stream: false` outright.
+     */
+    protected get forceStreaming(): boolean;
+    /**
+     * Last chance to reshape a request body before it goes out. Identity here —
+     * `CodexAgent` overrides it to satisfy that backend's extra validations.
+     */
+    protected transformRequestParams<T extends {
+        input: ResponseInputItem[];
+    }>(params: T): T;
     constructor(config: Omit<AgentConfig<M>, "vendor">, history?: History);
     /**
      * List the models available to this API key.
@@ -83,7 +178,9 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
      * image models alike — so filter by `id` if you only want the ones this
      * agent can drive.
      */
-    listModels(): Promise<ModelInfo<OpenAIModelCard>[]>;
+    listModels(): Promise<ModelInfo<TModelCard>[]>;
+    /** The configured key, resolving the function form if that is what was given. */
+    protected resolveApiKey(): Promise<string>;
     protected getToolDefinitions(): Tool[];
     /**
      * Combine locally-executed tool definitions with provider-defined
@@ -94,6 +191,28 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
      * uses for its own `ToolUnion[]`.
      */
     protected getAllToolDefinitions(): Tool[];
+    /**
+     * Rebuild a terminal response's `output` from the items streamed alongside it.
+     *
+     * The Codex backend sends `response.completed` with `output: []` and no
+     * `output_text`, unlike the platform API which fills both in — the content
+     * only ever arrives as `response.output_item.done` events. Everything
+     * downstream (tool-call detection, the text written to history) reads
+     * `output`, so without this a Codex turn silently commits an empty assistant
+     * message and drops every tool call.
+     *
+     * A no-op wherever `output` is already populated, so the platform path is
+     * untouched.
+     */
+    private repairStreamedOutput;
+    /**
+     * Issue a non-streaming Responses API call.
+     *
+     * When {@link forceStreaming} is set the request is streamed and the terminal
+     * event's `response` handed back instead — giving callers the same `Response`
+     * either way, at the cost of buffering the turn.
+     */
+    private createResponse;
     /**
      * Build the `reasoning` field for a Responses API request, as an object to
      * spread into the request params.
@@ -111,6 +230,15 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
      * emits `response.reasoning_summary_text.delta` events when it is set.
      */
     private buildReasoningParams;
+    /**
+     * Prompt-caching parameters, omitted entirely when unconfigured so a request
+     * stays byte-identical to what earlier versions sent.
+     *
+     * Caching itself is automatic and needs no opt-in — these only influence
+     * which cache a request is routed to and how long the prefix stays warm. What
+     * was actually reused comes back on `lastTokenUsage.cache_read_tokens`.
+     */
+    private buildCacheParams;
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[], options?: ExecuteOptions): Promise<string>;
     protected handleResponse(response: Response, options?: ExecuteOptions): Promise<string>;
@@ -131,5 +259,4 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
     private streamTurn;
     protected parseUsage(input: ResponseUsage): TokenUsage;
 }
-export {};
 //# sourceMappingURL=OpenAiAgent.d.ts.map

package/dist/agents/openai/OpenAiAgent.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAiAgent = void 0;
 exports.lowestReasoningEffort = lowestReasoningEffort;
+exports.wrapErrorBodyFetch = wrapErrorBodyFetch;
+exports.describeOpenAIError = describeOpenAIError;
 const openai_1 = __importDefault(require("openai"));
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
@@ -38,6 +40,81 @@ function lowestReasoningEffort(model) {
     const group = model_types_1.OPENAI_REASONING_SUPPORT.find((entry) => entry.models.includes(base));
     return group?.efforts[0];
 }
+/**
+ * `fetch` wrapper that rewrites a non-OpenAI-shaped error body into the shape
+ * the SDK can read.
+ *
+ * `APIError.generate` takes the message from `body.error` and throws the rest
+ * away (`openai/core/error.js`), so a backend that reports failures as
+ * `{"detail": "..."}` — which the ChatGPT Codex endpoint does, for all four of
+ * its body validations plus auth failures — surfaces as the useless
+ * `400 status code (no body)`. Nesting the original body under `error` puts the
+ * real reason back in the thrown error.
+ *
+ * Only touches error responses; successful (streaming) responses pass straight
+ * through untouched.
+ */
+function wrapErrorBodyFetch(baseFetch = fetch) {
+    return async (input, init) => {
+        const res = await baseFetch(input, init);
+        if (res.ok)
+            return res;
+        const text = await res.text().catch(() => "");
+        let body = text;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed && typeof parsed === "object" && !("error" in parsed)) {
+                body = JSON.stringify({
+                    error: {
+                        message: typeof parsed.detail === "string"
+                            ? parsed.detail
+                            : JSON.stringify(parsed),
+                        ...parsed,
+                    },
+                });
+            }
+        }
+        catch {
+            // Not JSON (an HTML error page, say) — hand the text back unchanged so
+            // the SDK reports it as the message.
+        }
+        // Reading the body consumed it, so the Response has to be rebuilt. Drop the
+        // length/encoding headers, which no longer describe the new payload.
+        const headers = new Headers(res.headers);
+        headers.delete("content-length");
+        headers.delete("content-encoding");
+        // `globalThis.Response`, not `Response`: this module imports the Responses
+        // API's `Response` *type*, which shadows the global class name here.
+        return new globalThis.Response(body, {
+            status: res.status,
+            statusText: res.statusText,
+            headers,
+        });
+    };
+}
+/**
+ * Pull a human-readable message out of an OpenAI-shaped error.
+ *
+ * `api.openai.com` answers with `{ error: { message, code } }`, but not every
+ * host behind this SDK does — the ChatGPT Codex backend reports its validation
+ * failures as `{ detail: "Instructions are required" }`. Reading
+ * `error.error.message` blindly turns those into a `TypeError` that hides the
+ * real cause, so every field is probed defensively and the SDK's own `message`
+ * is the last resort.
+ */
+function describeOpenAIError(error) {
+    const err = error;
+    const body = err?.error;
+    const fromBody = typeof body === "string"
+        ? body
+        : (body?.message ?? body?.detail ?? undefined);
+    return {
+        message: fromBody ?? err?.detail ?? err?.message ?? "Unknown error",
+        code: typeof body === "object" ? body?.code : undefined,
+        status: err?.status,
+        body: body ?? err?.detail,
+    };
+}
 /**
  * Agent for OpenAI models using the Responses API.
  *
@@ -54,17 +131,39 @@ function lowestReasoningEffort(model) {
  * ```
  */
 class OpenAiAgent extends BaseAgent_1.BaseAgent {
+    /**
+     * Whether a non-streaming call must be issued as a stream and collapsed.
+     * `false` here; `CodexAgent` overrides it, since that backend refuses
+     * `stream: false` outright.
+     */
+    get forceStreaming() {
+        return false;
+    }
+    /**
+     * Last chance to reshape a request body before it goes out. Identity here —
+     * `CodexAgent` overrides it to satisfy that backend's extra validations.
+     */
+    transformRequestParams(params) {
+        return params;
+    }
     constructor(config, history) {
+        // Cast: `BaseAgentConfig.apiKey` is `string`, while this agent also accepts
+        // a token-returning function. BaseAgent never reads the field — it only
+        // declares it — so widening the base config for one provider would be the
+        // more invasive fix.
         super({ ...config, vendor: "openai" }, history);
         /** Count of tool calls in current execution */
         this.currentToolCallCount = 0;
+        // Merge flat config (deprecated) with nested vendorConfig
+        // Flat config takes precedence for backward compatibility
+        const vendorConfig = config.vendorConfig?.openai || {};
+        const baseURL = config.baseURL ?? vendorConfig.baseURL;
         this.client = new openai_1.default({
             apiKey: config.apiKey,
+            baseURL,
             defaultHeaders: config.defaultHeaders,
+            fetch: config.fetch,
         });
-        // Merge flat config (deprecated) with nested vendorConfig
-        // Flat config takes precedence for backward compatibility
-        const vendorConfig = config.vendorConfig?.openai || {};
         const disableParallelToolUse = config.disableParallelToolUse ??
             vendorConfig.disableParallelToolUse ??
             false;
@@ -72,6 +171,8 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         const reasoningEffort = config.reasoningEffort ?? vendorConfig.reasoningEffort;
         const user = config.user ?? vendorConfig.user;
         const builtInTools = config.builtInTools ?? vendorConfig.builtInTools;
+        const promptCacheKey = config.promptCacheKey ?? vendorConfig.promptCacheKey;
+        const promptCacheRetention = config.promptCacheRetention ?? vendorConfig.promptCacheRetention;
         this.config = {
             model: config.model || "gpt-4.1-mini",
             // No default. `max_output_tokens` is optional on the Responses API, and
@@ -86,7 +187,10 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             reasoningEffort,
             user,
             builtInTools,
+            promptCacheKey,
+            promptCacheRetention,
             apiKey: config.apiKey,
+            baseURL,
             temperature: config.temperature,
             topP: config.topP,
             seed: config.seed,
@@ -111,6 +215,8 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 id: model.id,
                 created: model.created ? new Date(model.created * 1000) : undefined,
                 ownedBy: model.owned_by,
+                // Cast: this implementation always returns OpenAI's own cards; a
+                // subclass that reports a different shape overrides the whole method.
                 raw: model,
             }));
         }
@@ -118,6 +224,11 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             throw new AgentError_1.ExecutionError(`Failed to list OpenAI models: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
     }
+    /** The configured key, resolving the function form if that is what was given. */
+    async resolveApiKey() {
+        const key = this.config.apiKey;
+        return typeof key === "function" ? await key() : (key ?? "");
+    }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => {
             const prompt = tool.getPrompt();
@@ -152,6 +263,66 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             ...(this.config.builtInTools ?? []),
         ];
     }
+    /**
+     * Rebuild a terminal response's `output` from the items streamed alongside it.
+     *
+     * The Codex backend sends `response.completed` with `output: []` and no
+     * `output_text`, unlike the platform API which fills both in — the content
+     * only ever arrives as `response.output_item.done` events. Everything
+     * downstream (tool-call detection, the text written to history) reads
+     * `output`, so without this a Codex turn silently commits an empty assistant
+     * message and drops every tool call.
+     *
+     * A no-op wherever `output` is already populated, so the platform path is
+     * untouched.
+     */
+    repairStreamedOutput(response, streamedItems) {
+        if (response.output?.length || streamedItems.length === 0)
+            return response;
+        const output = streamedItems;
+        const outputText = output
+            .filter((item) => item.type === "message")
+            .flatMap((item) => ("content" in item ? (item.content ?? []) : []))
+            .filter((part) => part?.type === "output_text")
+            .map((part) => ("text" in part ? part.text : ""))
+            .join("");
+        return { ...response, output, output_text: outputText };
+    }
+    /**
+     * Issue a non-streaming Responses API call.
+     *
+     * When {@link forceStreaming} is set the request is streamed and the terminal
+     * event's `response` handed back instead — giving callers the same `Response`
+     * either way, at the cost of buffering the turn.
+     */
+    async createResponse(params, requestOptions) {
+        const body = this.transformRequestParams(params);
+        if (!this.forceStreaming) {
+            return this.client.responses.create({ ...body, stream: false }, requestOptions);
+        }
+        const stream = (await this.client.responses.create({ ...body, stream: true }, requestOptions));
+        let terminal;
+        const streamedItems = [];
+        for await (const event of stream) {
+            // Collected because the Codex backend leaves `output` empty on the
+            // terminal event — see repairStreamedOutput().
+            if (event.type === "response.output_item.done") {
+                streamedItems.push(event.item);
+            }
+            // `incomplete` and `failed` carry a Response too — handleResponse()
+            // already reads `status` off it, so let it report the reason rather than
+            // failing here with a vaguer message.
+            if (event.type === "response.completed" ||
+                event.type === "response.incomplete" ||
+                event.type === "response.failed") {
+                terminal = event.response;
+            }
+        }
+        if (!terminal) {
+            throw new AgentError_1.ExecutionError("OpenAI stream ended without a terminal response event");
+        }
+        return this.repairStreamedOutput(terminal, streamedItems);
+    }
     /**
      * Build the `reasoning` field for a Responses API request, as an object to
      * spread into the request params.
@@ -183,6 +354,24 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             },
         };
     }
+    /**
+     * Prompt-caching parameters, omitted entirely when unconfigured so a request
+     * stays byte-identical to what earlier versions sent.
+     *
+     * Caching itself is automatic and needs no opt-in — these only influence
+     * which cache a request is routed to and how long the prefix stays warm. What
+     * was actually reused comes back on `lastTokenUsage.cache_read_tokens`.
+     */
+    buildCacheParams() {
+        return {
+            ...(this.config.promptCacheKey
+                ? { prompt_cache_key: this.config.promptCacheKey }
+                : {}),
+            ...(this.config.promptCacheRetention
+                ? { prompt_cache_retention: this.config.promptCacheRetention }
+                : {}),
+        };
+    }
     async process(_input) {
         return "";
     }
@@ -217,7 +406,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         try {
             const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
             this.startTurnTimer();
-            const response = await this.client.responses.create({
+            const response = await this.createResponse({
                 model: this.config.model,
                 max_output_tokens: this.config.maxTokens,
                 input: inputMessages,
@@ -228,6 +417,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                 user: this.config.user,
                 ...this.buildReasoningParams(),
+                ...this.buildCacheParams(),
             }, { signal: options?.signal });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response, options);
@@ -242,16 +432,16 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 throw abortError;
             }
             if (error && typeof error === "object" && "error" in error) {
-                const openAIError = error;
-                const apiError = new AgentError_1.ApiError(`OpenAI API error: ${openAIError.error.message || "Unknown error"}`, openAIError.status, openAIError.error);
-                if (openAIError.error.code === "insufficient_quota") {
+                const openAIError = describeOpenAIError(error);
+                const apiError = new AgentError_1.ApiError(`OpenAI API error: ${openAIError.message}`, openAIError.status, openAIError.body);
+                if (openAIError.code === "insufficient_quota") {
                     apiError.message =
                         "OpenAI API quota exceeded. Please check your billing details.";
                 }
                 this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
                 // Report error to viz
                 if (this.vizEventId) {
-                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.error.code === "rate_limit_exceeded");
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.code === "rate_limit_exceeded");
                     this.vizEventId = undefined;
                 }
                 throw apiError;
@@ -344,7 +534,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 try {
                     const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
                     this.startTurnTimer();
-                    const newResponse = await this.client.responses.create({
+                    const newResponse = await this.createResponse({
                         model: this.config.model,
                         max_output_tokens: this.config.maxTokens,
                         input: inputMessages,
@@ -355,14 +545,15 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                         // Note: Responses API doesn't support seed, presence_penalty, frequency_penalty, stop
                         user: this.config.user,
                         ...this.buildReasoningParams(),
+                        ...this.buildCacheParams(),
                     }, { signal: options?.signal });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse, options);
                 }
                 catch (error) {
                     if (error && typeof error === "object" && "error" in error) {
-                        const openAIError = error;
-                        const apiError = new AgentError_1.ApiError(`OpenAI API error during tool response: ${openAIError.error.message || "Unknown error"}`, openAIError.status, openAIError.error);
+                        const openAIError = describeOpenAIError(error);
+                        const apiError = new AgentError_1.ApiError(`OpenAI API error during tool response: ${openAIError.message}`, openAIError.status, openAIError.body);
                         this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
                         throw apiError;
                     }
@@ -501,11 +692,11 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 throw this.withPartialTurn(error);
             }
             if (error && typeof error === "object" && "error" in error) {
-                const openAIError = error;
-                const apiError = new AgentError_1.ApiError(`OpenAI API error: ${openAIError.error.message || "Unknown error"}`, openAIError.status, openAIError.error);
+                const openAIError = describeOpenAIError(error);
+                const apiError = new AgentError_1.ApiError(`OpenAI API error: ${openAIError.message}`, openAIError.status, openAIError.body);
                 this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
                 if (this.vizEventId) {
-                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.error.code === "rate_limit_exceeded");
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.code === "rate_limit_exceeded");
                     this.vizEventId = undefined;
                 }
                 throw this.withPartialTurn(apiError);
@@ -525,7 +716,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
     async *streamTurn(options) {
         const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.getEntries());
         this.startTurnTimer();
-        const stream = await this.client.responses.create({
+        const stream = await this.client.responses.create(this.transformRequestParams({
             model: this.config.model,
             max_output_tokens: this.config.maxTokens,
             input: inputMessages,
@@ -536,8 +727,10 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             top_p: this.config.topP,
             user: this.config.user,
             ...this.buildReasoningParams("auto"),
-        }, { signal: options?.signal });
+            ...this.buildCacheParams(),
+        }), { signal: options?.signal });
         let completedEvent = null;
+        const streamedItems = [];
         // The Responses API builds the committed turn out of `response.completed`,
         // which only arrives on success, so the deltas are mirrored here as well:
         // without them a stream that dies mid-flight leaves nothing behind at all,
@@ -580,6 +773,11 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                     if (acc)
                         acc.arguments += event.delta;
                 }
+                if (event.type === "response.output_item.done") {
+                    // The Codex backend leaves `output` empty on the terminal event, so
+                    // the finished items are kept here — see repairStreamedOutput().
+                    streamedItems.push(event.item);
+                }
                 if (event.type === "response.completed") {
                     completedEvent = event;
                     if (event.response.usage) {
@@ -597,7 +795,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             if (!completedEvent) {
                 throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
             }
-            const response = completedEvent.response;
+            const response = this.repairStreamedOutput(completedEvent.response, streamedItems);
             const toolCalls = response.output.filter((o) => o.type === "function_call");
             if (toolCalls.length > 0) {
                 // As in handleResponse(): bail out before the assistant turn is written,
@@ -659,12 +857,16 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         }
     }
     parseUsage(input) {
+        const inputDetails = input.input_tokens_details;
         return {
             input_tokens: input.input_tokens,
             output_tokens: input.output_tokens,
             total_tokens: input.total_tokens,
             // Reasoning tokens are already counted inside `output_tokens`.
             reasoning_tokens: input.output_tokens_details?.reasoning_tokens,
+            // Cache counts are part of `input_tokens`, not extra on top of it.
+            cache_read_tokens: inputDetails?.cached_tokens,
+            cache_write_tokens: inputDetails?.cache_write_tokens,
         };
     }
 }