@agentionai/agents 1.11.0 → 1.13.0

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;
@@ -87,6 +186,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             user,
             builtInTools,
             apiKey: config.apiKey,
+            baseURL,
             temperature: config.temperature,
             topP: config.topP,
             seed: config.seed,
@@ -111,6 +211,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 +220,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 +259,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.
@@ -190,6 +357,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
         this.resetTokenUsage();
+        this.resetPartialTurn();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         // Start visualization reporting
@@ -216,7 +384,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,
@@ -241,16 +409,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;
@@ -343,7 +511,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,
@@ -360,8 +528,8 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 }
                 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;
                     }
@@ -461,6 +629,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
     async *executeStream(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         this.resetTokenUsage();
+        this.resetPartialTurn();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -488,7 +657,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
                     this.vizEventId = undefined;
                 }
-                throw abortError;
+                throw this.withPartialTurn(abortError);
             }
             if (error instanceof AgentError_1.AgentError) {
                 this.emit(AgentEvent_1.AgentEvent.ERROR, error);
@@ -496,17 +665,17 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
                     this.vizEventId = undefined;
                 }
-                throw error;
+                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 apiError;
+                throw this.withPartialTurn(apiError);
             }
             const executionError = new AgentError_1.ExecutionError(`OpenAI error: ${error instanceof Error ? error.message : "Unknown error"}`);
             this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
@@ -514,7 +683,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
                 this.vizEventId = undefined;
             }
-            throw executionError;
+            throw this.withPartialTurn(executionError);
         }
         finally {
             this.history.endExecution();
@@ -523,7 +692,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,
@@ -534,70 +703,131 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             top_p: this.config.topP,
             user: this.config.user,
             ...this.buildReasoningParams("auto"),
-        }, { signal: options?.signal });
+        }), { signal: options?.signal });
         let completedEvent = null;
-        for await (const event of stream) {
-            if (event.type === "response.output_text.delta") {
-                this.markFirstToken();
-                this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
-                yield { type: "text", content: event.delta };
+        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,
+        // and a reasoning summary can be minutes of generation.
+        let textDelta = "";
+        let reasoningDelta = "";
+        const partialCalls = new Map();
+        // Set once this frame's assistant message reaches history.
+        let committed = false;
+        let failure;
+        try {
+            for await (const event of stream) {
+                if (event.type === "response.output_text.delta") {
+                    this.markFirstToken();
+                    // Accumulated as well as yielded purely so the `finally` below can hand
+                    // it back if the stream dies: the committed turn is rebuilt from
+                    // `response.completed`, which never arrives on a failure.
+                    textDelta += event.delta;
+                    this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
+                    yield { type: "text", content: event.delta };
+                }
+                if (event.type === "response.reasoning_summary_text.delta") {
+                    this.markFirstToken();
+                    reasoningDelta += event.delta;
+                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
+                    yield { type: "reasoning", content: event.delta };
+                }
+                if (event.type === "response.output_item.added") {
+                    const item = event.item;
+                    if (item.type === "function_call") {
+                        partialCalls.set(event.output_index, {
+                            id: item.call_id || item.id || "",
+                            name: item.name ?? "",
+                            arguments: "",
+                        });
+                    }
+                }
+                if (event.type === "response.function_call_arguments.delta") {
+                    const acc = partialCalls.get(event.output_index);
+                    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) {
+                        this.accumulateUsage(this.parseUsage(event.response.usage));
+                    }
+                }
+                if (event.type === "response.incomplete") {
+                    throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens);
+                }
             }
-            if (event.type === "response.reasoning_summary_text.delta") {
-                this.markFirstToken();
-                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
-                yield { type: "reasoning", content: event.delta };
+            // The SDK's stream iterator swallows the abort and simply stops yielding.
+            // Without this the turn would fail as a malformed stream instead of a
+            // cancellation — checked here so the tokens already spent are reported.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+            if (!completedEvent) {
+                throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
             }
-            if (event.type === "response.completed") {
-                completedEvent = event;
-                if (event.response.usage) {
-                    this.accumulateUsage(this.parseUsage(event.response.usage));
+            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,
+                // so a cancelled run leaves no unanswered function call in history.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+                this.currentToolCallCount += toolCalls.length;
+                const functionCalls = toolCalls.map((tc) => ({
+                    id: tc.id || tc.call_id,
+                    call_id: tc.call_id,
+                    name: tc.name,
+                    arguments: tc.arguments,
+                }));
+                const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
+                this.addToHistory(assistantEntry);
+                committed = true;
+                const toolResults = await this.handleToolUse(toolCalls, options);
+                for (const result of toolResults) {
+                    this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
                 }
+                yield* this.streamTurn(options);
             }
-            if (event.type === "response.incomplete") {
-                throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens);
+            else {
+                const textContent = response.output_text || "";
+                const entry = transformers_1.openAiTransformer.fromProviderMessage("assistant", textContent);
+                this.addToHistory(entry);
+                committed = true;
+                this.emit(AgentEvent_1.AgentEvent.DONE, response, this.lastTokenUsage);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                        input: this.lastTokenUsage?.input_tokens || 0,
+                        output: this.lastTokenUsage?.output_tokens || 0,
+                        total: this.lastTokenUsage?.total_tokens || 0,
+                    }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                    this.vizEventId = undefined;
+                }
             }
         }
-        // The SDK's stream iterator swallows the abort and simply stops yielding.
-        // Without this the turn would fail as a malformed stream instead of a
-        // cancellation — checked here so the tokens already spent are reported.
-        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-        if (!completedEvent) {
-            throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
-        }
-        const response = completedEvent.response;
-        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,
-            // so a cancelled run leaves no unanswered function call in history.
-            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
-            this.currentToolCallCount += toolCalls.length;
-            const functionCalls = toolCalls.map((tc) => ({
-                id: tc.id || tc.call_id,
-                call_id: tc.call_id,
-                name: tc.name,
-                arguments: tc.arguments,
-            }));
-            const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
-            this.addToHistory(assistantEntry);
-            const toolResults = await this.handleToolUse(toolCalls, options);
-            for (const result of toolResults) {
-                this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
-            }
-            yield* this.streamTurn(options);
+        catch (error) {
+            failure = error;
+            throw error;
         }
-        else {
-            const textContent = response.output_text || "";
-            const entry = transformers_1.openAiTransformer.fromProviderMessage("assistant", textContent);
-            this.addToHistory(entry);
-            this.emit(AgentEvent_1.AgentEvent.DONE, response, this.lastTokenUsage);
-            if (this.vizEventId) {
-                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
-                    input: this.lastTokenUsage?.input_tokens || 0,
-                    output: this.lastTokenUsage?.output_tokens || 0,
-                    total: this.lastTokenUsage?.total_tokens || 0,
-                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
-                this.vizEventId = undefined;
+        finally {
+            if (!committed) {
+                this.capturePartialTurn({
+                    text: textDelta,
+                    reasoning: reasoningDelta,
+                    toolCalls: Array.from(partialCalls.entries())
+                        .sort(([a], [b]) => a - b)
+                        .map(([, tc]) => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    })),
+                    reason: this.partialTurnReason(failure, options?.signal),
+                    error: failure,
+                });
             }
         }
     }