@psnext/slingcli 2.5.20260623-1 → 2.5.20260705-1

package/node_modules/@earendil-works/pi-ai/dist/api/openai-completions.js

@@ -1,11 +1,11 @@
 import OpenAI from "openai";
 import { calculateCost, clampThinkingLevel } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -15,6 +15,23 @@ import { transformMessages } from "./transform-messages.js";
  * This is needed because Anthropic (via proxy) requires the tools param
  * to be present when messages include tool_calls or tool role messages.
  */
+function hasHeader(headers, name) {
+    if (!headers)
+        return false;
+    const expected = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+            return true;
+    }
+    return false;
+}
+function getClientApiKey(provider, apiKey, headers) {
+    if (apiKey)
+        return apiKey;
+    if (hasHeader(headers, "authorization") || hasHeader(headers, "cf-aig-authorization"))
+        return "unused";
+    throw new Error(`No API key for provider: ${provider}`);
+}
 function hasToolHistory(messages) {
     for (const msg of messages) {
         if (msg.role === "toolResult") {
@@ -81,14 +98,11 @@ export const stream = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey;
-            if (!apiKey) {
-                throw new Error(`No API key for provider: ${model.provider}`);
-            }
+            const apiKey = getClientApiKey(model.provider, options?.apiKey, options?.headers);
             const compat = getCompat(model);
             const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
             const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat, options?.env);
+            const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
             let params = buildParams(model, context, options, compat, cacheRetention);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
@@ -353,11 +367,15 @@ export const stream = (model, context, options) => {
                 delete block.streamIndex;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = formatProviderError(normalizeProviderError(error));
             // Some providers via OpenRouter give additional information in this field.
+            // normalizeProviderError already stringifies the parsed body (error.error)
+            // into errorMessage, so only append the raw metadata when it is not already
+            // present to avoid double-printing it.
             const rawMetadata = error?.error?.metadata?.raw;
-            if (rawMetadata)
+            if (rawMetadata && !output.errorMessage.includes(String(rawMetadata))) {
                 output.errorMessage += `\n${rawMetadata}`;
+            }
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -365,11 +383,8 @@ export const stream = (model, context, options) => {
     return stream;
 };
 export const streamSimple = (model, context, options) => {
-    const apiKey = options?.apiKey;
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
-    }
-    const base = buildBaseOptions(model, options, apiKey);
+    getClientApiKey(model.provider, options?.apiKey, options?.headers);
+    const base = buildBaseOptions(model, context, options, options?.apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     const toolChoice = options?.toolChoice;
@@ -379,7 +394,7 @@ export const streamSimple = (model, context, options) => {
         toolChoice,
     });
 };
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model), env) {
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
     const headers = { ...model.headers };
     if (model.provider === "github-copilot") {
         const hasImages = hasCopilotVisionInput(context.messages);
@@ -398,18 +413,11 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
     if (optionsHeaders) {
         Object.assign(headers, optionsHeaders);
     }
-    const defaultHeaders = model.provider === "cloudflare-ai-gateway"
-        ? {
-            ...headers,
-            Authorization: headers.Authorization ?? null,
-            "cf-aig-authorization": `Bearer ${apiKey}`,
-        }
-        : headers;
     return new OpenAI({
         apiKey,
-        baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model, env) : model.baseUrl,
+        baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
-        defaultHeaders,
+        defaultHeaders: headers,
     });
 }
 function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env)) {
@@ -460,7 +468,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
     }
     if (compat.thinkingFormat === "zai" && model.reasoning) {
         const zaiParams = params;
-        zaiParams.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
+        zaiParams.thinking = options?.reasoningEffort ? { type: "enabled", clear_thinking: false } : { type: "disabled" };
         if (options?.reasoningEffort && compat.supportsReasoningEffort) {
             const mappedEffort = model.thinkingLevelMap?.[options.reasoningEffort];
             const effort = mappedEffort === undefined ? options.reasoningEffort : mappedEffort;
@@ -545,7 +553,7 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
         params.provider = model.compat.openRouterRouting;
     }
     // Vercel AI Gateway provider routing preferences
-    if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
+    if (model.compat?.vercelGatewayRouting) {
         const routing = model.compat.vercelGatewayRouting;
         if (routing.only || routing.order) {
             const gatewayOptions = {};
@@ -913,6 +921,7 @@ function parseChunkUsage(rawUsage, model) {
         output: outputTokens,
         cacheRead: cacheReadTokens,
         cacheWrite: cacheWriteTokens,
+        reasoning: rawUsage.completion_tokens_details?.reasoning_tokens || 0,
         totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };
@@ -943,9 +952,9 @@ function mapStopReason(reason) {
     }
 }
 /**
- * Detect compatibility settings from provider and baseUrl for known providers.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- * Returns a fully resolved OpenAICompletionsCompat object with all fields set.
+ * Auto-detect compatibility settings from provider name and baseUrl.
+ * Used as the base when model.compat is not set; explicit model.compat
+ * entries override these detected values.
  */
 function detectCompat(model) {
     const provider = model.provider;
@@ -1018,7 +1027,7 @@ function detectCompat(model) {
 }
 /**
  * Get resolved compatibility settings for a model.
- * Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
+ * Auto-detects from provider/URL then overrides with explicit model.compat.
  */
 function getCompat(model) {
     const detected = detectCompat(model);

package/node_modules/@earendil-works/pi-ai/dist/api/openai-responses-shared.js

@@ -214,254 +214,236 @@ export function convertResponsesTools(tools, options) {
         strict,
     }));
 }
-// =============================================================================
-// Stream processing
-// =============================================================================
 export async function processResponsesStream(openaiStream, output, stream, model, options) {
-    let currentItem = null;
-    let currentBlock = null;
-    const blocks = output.content;
-    const blockIndex = () => blocks.length - 1;
+    let sawTerminalResponseEvent = false;
+    const outputSlots = new Map();
+    const getSlot = (outputIndex, type) => {
+        const slot = outputSlots.get(outputIndex);
+        return slot?.type === type ? slot : undefined;
+    };
+    const createSlot = (outputIndex, item) => {
+        if (item.type === "reasoning") {
+            const block = { type: "thinking", thinking: "" };
+            output.content.push(block);
+            const slot = {
+                type: "thinking",
+                block,
+                contentIndex: output.content.length - 1,
+            };
+            outputSlots.set(outputIndex, slot);
+            stream.push({ type: "thinking_start", contentIndex: slot.contentIndex, partial: output });
+            return slot;
+        }
+        if (item.type === "message") {
+            const block = { type: "text", text: "" };
+            output.content.push(block);
+            const slot = { type: "text", block, contentIndex: output.content.length - 1 };
+            outputSlots.set(outputIndex, slot);
+            stream.push({ type: "text_start", contentIndex: slot.contentIndex, partial: output });
+            return slot;
+        }
+        if (item.type === "function_call") {
+            const block = {
+                type: "toolCall",
+                id: `${item.call_id}|${item.id}`,
+                name: item.name,
+                arguments: {},
+                partialJson: item.arguments || "",
+            };
+            output.content.push(block);
+            const slot = {
+                type: "toolCall",
+                block,
+                contentIndex: output.content.length - 1,
+            };
+            outputSlots.set(outputIndex, slot);
+            stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+            return slot;
+        }
+        return undefined;
+    };
+    const getOrCreateSlot = (outputIndex, item) => {
+        return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
+    };
+    const finalizeResponse = (response) => {
+        sawTerminalResponseEvent = true;
+        if (response?.id) {
+            output.responseId = response.id;
+        }
+        if (response?.usage) {
+            const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+            output.usage = {
+                // OpenAI includes cached tokens in input_tokens, so subtract to get non-cached input
+                input: (response.usage.input_tokens || 0) - cachedTokens,
+                output: response.usage.output_tokens || 0,
+                cacheRead: cachedTokens,
+                cacheWrite: 0,
+                reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+                totalTokens: response.usage.total_tokens || 0,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            };
+        }
+        calculateCost(model, output.usage);
+        if (options?.applyServiceTierPricing) {
+            const serviceTier = options.resolveServiceTier
+                ? options.resolveServiceTier(response?.service_tier, options.serviceTier)
+                : (response?.service_tier ?? options.serviceTier);
+            options.applyServiceTierPricing(output.usage, serviceTier);
+        }
+        // Map status to stop reason
+        output.stopReason = mapStopReason(response?.status);
+        if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+            output.stopReason = "toolUse";
+        }
+    };
     for await (const event of openaiStream) {
         if (event.type === "response.created") {
             output.responseId = event.response.id;
         }
         else if (event.type === "response.output_item.added") {
-            const item = event.item;
-            if (item.type === "reasoning") {
-                currentItem = item;
-                currentBlock = { type: "thinking", thinking: "" };
-                output.content.push(currentBlock);
-                stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-            }
-            else if (item.type === "message") {
-                currentItem = item;
-                currentBlock = { type: "text", text: "" };
-                output.content.push(currentBlock);
-                stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-            }
-            else if (item.type === "function_call") {
-                currentItem = item;
-                currentBlock = {
-                    type: "toolCall",
-                    id: `${item.call_id}|${item.id}`,
-                    name: item.name,
-                    arguments: {},
-                    partialJson: item.arguments || "",
-                };
-                output.content.push(currentBlock);
-                stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-            }
-        }
-        else if (event.type === "response.reasoning_summary_part.added") {
-            if (currentItem && currentItem.type === "reasoning") {
-                currentItem.summary = currentItem.summary || [];
-                currentItem.summary.push(event.part);
-            }
+            createSlot(event.output_index, event.item);
         }
         else if (event.type === "response.reasoning_summary_text.delta") {
-            if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-                currentItem.summary = currentItem.summary || [];
-                const lastPart = currentItem.summary[currentItem.summary.length - 1];
-                if (lastPart) {
-                    currentBlock.thinking += event.delta;
-                    lastPart.text += event.delta;
-                    stream.push({
-                        type: "thinking_delta",
-                        contentIndex: blockIndex(),
-                        delta: event.delta,
-                        partial: output,
-                    });
-                }
-            }
+            const slot = getSlot(event.output_index, "thinking");
+            if (!slot)
+                continue;
+            slot.block.thinking += event.delta;
+            stream.push({
+                type: "thinking_delta",
+                contentIndex: slot.contentIndex,
+                delta: event.delta,
+                partial: output,
+            });
         }
         else if (event.type === "response.reasoning_summary_part.done") {
-            if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-                currentItem.summary = currentItem.summary || [];
-                const lastPart = currentItem.summary[currentItem.summary.length - 1];
-                if (lastPart) {
-                    currentBlock.thinking += "\n\n";
-                    lastPart.text += "\n\n";
-                    stream.push({
-                        type: "thinking_delta",
-                        contentIndex: blockIndex(),
-                        delta: "\n\n",
-                        partial: output,
-                    });
-                }
-            }
+            const slot = getSlot(event.output_index, "thinking");
+            if (!slot)
+                continue;
+            slot.block.thinking += "\n\n";
+            stream.push({
+                type: "thinking_delta",
+                contentIndex: slot.contentIndex,
+                delta: "\n\n",
+                partial: output,
+            });
         }
         else if (event.type === "response.reasoning_text.delta") {
-            if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-                currentBlock.thinking += event.delta;
-                stream.push({
-                    type: "thinking_delta",
-                    contentIndex: blockIndex(),
-                    delta: event.delta,
-                    partial: output,
-                });
-            }
-        }
-        else if (event.type === "response.content_part.added") {
-            if (currentItem?.type === "message") {
-                currentItem.content = currentItem.content || [];
-                // Filter out ReasoningText, only accept output_text and refusal
-                if (event.part.type === "output_text" || event.part.type === "refusal") {
-                    currentItem.content.push(event.part);
-                }
-            }
+            const slot = getSlot(event.output_index, "thinking");
+            if (!slot)
+                continue;
+            slot.block.thinking += event.delta;
+            stream.push({
+                type: "thinking_delta",
+                contentIndex: slot.contentIndex,
+                delta: event.delta,
+                partial: output,
+            });
         }
         else if (event.type === "response.output_text.delta") {
-            if (currentItem?.type === "message" && currentBlock?.type === "text") {
-                if (!currentItem.content || currentItem.content.length === 0) {
-                    continue;
-                }
-                const lastPart = currentItem.content[currentItem.content.length - 1];
-                if (lastPart?.type === "output_text") {
-                    currentBlock.text += event.delta;
-                    lastPart.text += event.delta;
-                    stream.push({
-                        type: "text_delta",
-                        contentIndex: blockIndex(),
-                        delta: event.delta,
-                        partial: output,
-                    });
-                }
-            }
+            const slot = getSlot(event.output_index, "text");
+            if (!slot)
+                continue;
+            slot.block.text += event.delta;
+            stream.push({
+                type: "text_delta",
+                contentIndex: slot.contentIndex,
+                delta: event.delta,
+                partial: output,
+            });
         }
         else if (event.type === "response.refusal.delta") {
-            if (currentItem?.type === "message" && currentBlock?.type === "text") {
-                if (!currentItem.content || currentItem.content.length === 0) {
-                    continue;
-                }
-                const lastPart = currentItem.content[currentItem.content.length - 1];
-                if (lastPart?.type === "refusal") {
-                    currentBlock.text += event.delta;
-                    lastPart.refusal += event.delta;
-                    stream.push({
-                        type: "text_delta",
-                        contentIndex: blockIndex(),
-                        delta: event.delta,
-                        partial: output,
-                    });
-                }
-            }
+            const slot = getSlot(event.output_index, "text");
+            if (!slot)
+                continue;
+            slot.block.text += event.delta;
+            stream.push({
+                type: "text_delta",
+                contentIndex: slot.contentIndex,
+                delta: event.delta,
+                partial: output,
+            });
         }
         else if (event.type === "response.function_call_arguments.delta") {
-            if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-                currentBlock.partialJson += event.delta;
-                currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-                stream.push({
-                    type: "toolcall_delta",
-                    contentIndex: blockIndex(),
-                    delta: event.delta,
-                    partial: output,
-                });
-            }
+            const slot = getSlot(event.output_index, "toolCall");
+            if (!slot)
+                continue;
+            slot.block.partialJson += event.delta;
+            slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+            stream.push({
+                type: "toolcall_delta",
+                contentIndex: slot.contentIndex,
+                delta: event.delta,
+                partial: output,
+            });
         }
         else if (event.type === "response.function_call_arguments.done") {
-            if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-                const previousPartialJson = currentBlock.partialJson;
-                currentBlock.partialJson = event.arguments;
-                currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
-                if (event.arguments.startsWith(previousPartialJson)) {
-                    const delta = event.arguments.slice(previousPartialJson.length);
-                    if (delta.length > 0) {
-                        stream.push({
-                            type: "toolcall_delta",
-                            contentIndex: blockIndex(),
-                            delta,
-                            partial: output,
-                        });
-                    }
+            const slot = getSlot(event.output_index, "toolCall");
+            if (!slot)
+                continue;
+            const previousPartialJson = slot.block.partialJson;
+            slot.block.partialJson = event.arguments;
+            slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+            if (event.arguments.startsWith(previousPartialJson)) {
+                const delta = event.arguments.slice(previousPartialJson.length);
+                if (delta.length > 0) {
+                    stream.push({
+                        type: "toolcall_delta",
+                        contentIndex: slot.contentIndex,
+                        delta,
+                        partial: output,
+                    });
                 }
             }
         }
         else if (event.type === "response.output_item.done") {
             const item = event.item;
-            if (item.type === "reasoning" && currentBlock?.type === "thinking") {
+            const slot = getOrCreateSlot(event.output_index, item);
+            if (item.type === "reasoning" && slot?.type === "thinking") {
                 const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
                 const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
-                currentBlock.thinking = summaryText || contentText || currentBlock.thinking;
-                currentBlock.thinkingSignature = JSON.stringify(item);
+                slot.block.thinking = summaryText || contentText || slot.block.thinking;
+                slot.block.thinkingSignature = JSON.stringify(item);
                 stream.push({
                     type: "thinking_end",
-                    contentIndex: blockIndex(),
-                    content: currentBlock.thinking,
+                    contentIndex: slot.contentIndex,
+                    content: slot.block.thinking,
                     partial: output,
                 });
-                currentBlock = null;
+                outputSlots.delete(event.output_index);
             }
-            else if (item.type === "message" && currentBlock?.type === "text") {
-                currentBlock.text =
-                    item.content?.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("") || "";
-                currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
+            else if (item.type === "message" && slot?.type === "text") {
+                slot.block.text = item.content?.map((c) => (c.type === "output_text" ? c.text : c.refusal)).join("") || "";
+                slot.block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
                 stream.push({
                     type: "text_end",
-                    contentIndex: blockIndex(),
-                    content: currentBlock.text,
+                    contentIndex: slot.contentIndex,
+                    content: slot.block.text,
                     partial: output,
                 });
-                currentBlock = null;
+                outputSlots.delete(event.output_index);
             }
-            else if (item.type === "function_call") {
-                const args = currentBlock?.type === "toolCall" && currentBlock.partialJson
-                    ? parseStreamingJson(currentBlock.partialJson)
-                    : parseStreamingJson(item.arguments || "{}");
-                let toolCall;
-                if (currentBlock?.type === "toolCall") {
-                    // Finalize in-place and strip the scratch buffer so replay only
-                    // carries parsed arguments.
-                    currentBlock.arguments = args;
-                    delete currentBlock.partialJson;
-                    toolCall = currentBlock;
-                }
-                else {
-                    toolCall = {
-                        type: "toolCall",
-                        id: `${item.call_id}|${item.id}`,
-                        name: item.name,
-                        arguments: args,
-                    };
-                }
-                currentBlock = null;
-                stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+            else if (item.type === "function_call" && slot?.type === "toolCall") {
+                slot.block.arguments = parseStreamingJson(item.arguments || slot.block.partialJson || "{}");
+                // Finalize in-place and strip the scratch buffer so replay only
+                // carries parsed arguments.
+                delete slot.block.partialJson;
+                stream.push({
+                    type: "toolcall_end",
+                    contentIndex: slot.contentIndex,
+                    toolCall: slot.block,
+                    partial: output,
+                });
+                outputSlots.delete(event.output_index);
             }
         }
-        else if (event.type === "response.completed") {
-            const response = event.response;
-            if (response?.id) {
-                output.responseId = response.id;
-            }
-            if (response?.usage) {
-                const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
-                output.usage = {
-                    // OpenAI includes cached tokens in input_tokens, so subtract to get non-cached input
-                    input: (response.usage.input_tokens || 0) - cachedTokens,
-                    output: response.usage.output_tokens || 0,
-                    cacheRead: cachedTokens,
-                    cacheWrite: 0,
-                    totalTokens: response.usage.total_tokens || 0,
-                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                };
-            }
-            calculateCost(model, output.usage);
-            if (options?.applyServiceTierPricing) {
-                const serviceTier = options.resolveServiceTier
-                    ? options.resolveServiceTier(response?.service_tier, options.serviceTier)
-                    : (response?.service_tier ?? options.serviceTier);
-                options.applyServiceTierPricing(output.usage, serviceTier);
-            }
-            // Map status to stop reason
-            output.stopReason = mapStopReason(response?.status);
-            if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
-                output.stopReason = "toolUse";
-            }
+        else if (event.type === "response.completed" || event.type === "response.incomplete") {
+            finalizeResponse(event.response);
         }
         else if (event.type === "error") {
             throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
         }
         else if (event.type === "response.failed") {
+            sawTerminalResponseEvent = true;
             const error = event.response?.error;
             const details = event.response?.incomplete_details;
             const msg = error
@@ -472,6 +454,9 @@ export async function processResponsesStream(openaiStream, output, stream, model
             throw new Error(msg);
         }
     }
+    if (!sawTerminalResponseEvent) {
+        throw new Error("OpenAI Responses stream ended before a terminal response event");
+    }
 }
 function mapStopReason(status) {
     if (!status)