@agentionai/agents 1.12.0 → 1.13.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,29 @@ export interface OpenAISpecificConfig {
      * see `lib/tools/BuiltInTool.ts`.
      */
     builtInTools?: BuiltInTool[];
+    /**
+     * 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/openai/CodexAgent.d.ts

@@ -0,0 +1,135 @@
+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";
+/**
+ * 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;
+    constructor(config: CodexAgentConfig, history?: History);
+    /**
+     * 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,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAgent = void 0;
+const AgentError_1 = require("../errors/AgentError");
+const OpenAiAgent_1 = require("./OpenAiAgent");
+const codex_auth_1 = require("./codex-auth");
+/**
+ * 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;
+        // 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,
+            },
+            // This backend reports failures as `{detail: …}`, which the SDK drops
+            // on the floor — see wrapErrorBodyFetch().
+            fetch: (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.accountId = accountId;
+        this.originator = originator;
+        this.clientVersion =
+            config.clientVersion ?? vendorConfig.clientVersion ?? codex_auth_1.CODEX_CLIENT_VERSION;
+        this.codexBaseURL = baseURL;
+    }
+    /**
+     * 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

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
@@ -47,6 +63,37 @@ type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
  * `reasoningEffort` explicitly to override.
  */
 export declare function lowestReasoningEffort(model: string | undefined): ReasoningEffort | undefined;
+/**
+ * `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 +109,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 +122,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 +143,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 +156,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.
@@ -131,5 +215,4 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
     private streamTurn;
     protected parseUsage(input: ResponseUsage): TokenUsage;
 }
-export {};
 //# sourceMappingURL=OpenAiAgent.d.ts.map