@caupulican/pi-ai 0.90.12 → 0.91.3

package/dist/providers/openai-responses-shared.js

@@ -3,6 +3,7 @@ import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { createToolNameMap } from "../utils/tool-names.js";
+import { commitSuccessfulAssistantParse } from "./provider-runtime.js";
 import { joinTextContent, transformMessages } from "./transform-messages.js";
 // =============================================================================
 // Utilities
@@ -279,6 +280,7 @@ export async function processResponsesStream(openaiStream, output, stream, model
     let currentBlock = null;
     let currentReasoningSummaryPartText = "";
     let sawTerminalResponseEvent = false;
+    let committedSuccessfulTerminal = false;
     const reasoningBlocksById = new Map();
     const blocks = output.content;
     const blockIndex = () => blocks.length - 1;
@@ -315,6 +317,196 @@ export async function processResponsesStream(openaiStream, output, stream, model
             block.thinkingSignature = JSON.stringify({ ...storedItem, encrypted_content: item.encrypted_content });
         }
     };
+    const finalizedOutputItemKeys = new Set();
+    const functionCallBlocksByItemId = new Map();
+    const functionCallBlocksByCallId = new Map();
+    const outputItemKeys = (item) => {
+        if (item.type === "reasoning" || item.type === "message") {
+            return item.id ? [`${item.type}:${item.id}`] : [];
+        }
+        if (item.type === "function_call") {
+            const keys = [];
+            if (item.id)
+                keys.push(`function_call:id:${item.id}`);
+            if (item.call_id)
+                keys.push(`function_call:call:${item.call_id}`);
+            keys.push(`function_call:${item.call_id ?? ""}|${item.id ?? ""}`);
+            return keys;
+        }
+        return [];
+    };
+    const registerFunctionCallBlock = (item, block) => {
+        if (item.id)
+            functionCallBlocksByItemId.set(item.id, block);
+        if (item.call_id)
+            functionCallBlocksByCallId.set(item.call_id, block);
+    };
+    const findFunctionCallBlock = (item) => {
+        const id = `${item.call_id}|${item.id}`;
+        const byExactId = output.content.find((candidate) => candidate.type === "toolCall" && candidate.id === id);
+        if (byExactId)
+            return byExactId;
+        if (item.id) {
+            const byItemId = functionCallBlocksByItemId.get(item.id);
+            if (byItemId)
+                return byItemId;
+        }
+        if (item.call_id) {
+            const byCallId = functionCallBlocksByCallId.get(item.call_id);
+            if (byCallId)
+                return byCallId;
+        }
+        if (currentBlock?.type === "toolCall")
+            return currentBlock;
+        return undefined;
+    };
+    const contentIndexOf = (block) => output.content.indexOf(block);
+    const applyCompletedOutputItem = (item, emit) => {
+        const keys = outputItemKeys(item);
+        if (keys.some((key) => finalizedOutputItemKeys.has(key)))
+            return;
+        if (item.type === "reasoning") {
+            if (item.summary) {
+                item.summary = item.summary
+                    .map((part) => ({ ...part, text: cleanReasoningSummaryText(part.text ?? "") }))
+                    .filter((part) => part.text.trim().length > 0);
+            }
+            const summaryText = normalizeReasoningSummaryText(item.summary);
+            const contentText = item.content?.map((part) => part.text).join("\n\n") || "";
+            let block = item.id ? reasoningBlocksById.get(item.id) : undefined;
+            if (!block && currentBlock?.type === "thinking")
+                block = currentBlock;
+            const isNew = !block;
+            if (!block) {
+                block = { type: "thinking", thinking: "" };
+                output.content.push(block);
+            }
+            block.thinking = summaryText || contentText || block.thinking;
+            block.thinkingSignature = JSON.stringify(item);
+            if (item.id)
+                reasoningBlocksById.set(item.id, block);
+            if (emit) {
+                const contentIndex = contentIndexOf(block);
+                if (isNew) {
+                    stream.push({ type: "thinking_start", contentIndex, partial: output });
+                }
+                stream.push({
+                    type: "thinking_end",
+                    contentIndex,
+                    content: block.thinking,
+                    partial: output,
+                });
+            }
+            if (currentBlock === block)
+                currentBlock = null;
+            for (const key of keys)
+                finalizedOutputItemKeys.add(key);
+            return;
+        }
+        if (item.type === "message") {
+            const text = (item.content ?? [])
+                .map((part) => (part.type === "output_text" ? part.text : part.refusal))
+                .join("");
+            let block;
+            if (currentBlock?.type === "text") {
+                block = currentBlock;
+            }
+            else if (item.id) {
+                block = output.content.find((candidate) => candidate.type === "text" && parseTextSignature(candidate.textSignature)?.id === item.id);
+            }
+            // xAI/Grok emits message.added + deltas, then function_call items, then
+            // message.done / response.output. currentBlock has already moved to the
+            // tool; the live text block must be reused or the same sentence is stored
+            // twice (unsigned before tools, signed after).
+            if (!block) {
+                block = [...output.content]
+                    .reverse()
+                    .find((candidate) => candidate.type === "text" &&
+                    !candidate.textSignature &&
+                    (candidate.text === "" ||
+                        text === "" ||
+                        text.startsWith(candidate.text) ||
+                        candidate.text.startsWith(text)));
+            }
+            const isNew = !block;
+            if (!block) {
+                block = { type: "text", text: "" };
+                output.content.push(block);
+            }
+            if (text.length > 0)
+                block.text = text;
+            if (item.id)
+                block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
+            if (emit) {
+                const contentIndex = contentIndexOf(block);
+                if (isNew) {
+                    stream.push({ type: "text_start", contentIndex, partial: output });
+                }
+                stream.push({ type: "text_end", contentIndex, content: block.text, partial: output });
+            }
+            if (currentBlock === block)
+                currentBlock = null;
+            for (const key of keys)
+                finalizedOutputItemKeys.add(key);
+            return;
+        }
+        const id = `${item.call_id}|${item.id}`;
+        let block = findFunctionCallBlock(item);
+        const isNew = !block;
+        if (!block) {
+            block = {
+                type: "toolCall",
+                id,
+                name: options?.toolNameMap?.toOriginalName(item.name) ?? item.name,
+                arguments: {},
+            };
+            output.content.push(block);
+        }
+        else {
+            block.id = id;
+            block.name = options?.toolNameMap?.toOriginalName(item.name) ?? item.name;
+        }
+        block.arguments = parseStreamingJson(block.partialJson || item.arguments || "{}");
+        delete block.partialJson;
+        registerFunctionCallBlock(item, block);
+        if (emit) {
+            const contentIndex = contentIndexOf(block);
+            if (isNew) {
+                stream.push({ type: "toolcall_start", contentIndex, partial: output });
+            }
+            stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
+        }
+        if (currentBlock === block)
+            currentBlock = null;
+        for (const key of keys)
+            finalizedOutputItemKeys.add(key);
+    };
+    const applyResponseOutput = (responseOutput) => {
+        for (const item of responseOutput) {
+            if (item.type === "reasoning" || item.type === "message" || item.type === "function_call") {
+                applyCompletedOutputItem(item, true);
+            }
+        }
+        if (!currentBlock)
+            return;
+        const contentIndex = blockIndex();
+        if (currentBlock.type === "text") {
+            stream.push({ type: "text_end", contentIndex, content: currentBlock.text, partial: output });
+        }
+        else if (currentBlock.type === "thinking") {
+            stream.push({
+                type: "thinking_end",
+                contentIndex,
+                content: currentBlock.thinking,
+                partial: output,
+            });
+        }
+        else {
+            delete currentBlock.partialJson;
+            stream.push({ type: "toolcall_end", contentIndex, toolCall: currentBlock, partial: output });
+        }
+        currentBlock = null;
+    };
     const finalizeResponse = (response) => {
         sawTerminalResponseEvent = true;
         backfillReasoningSignatures((response.output ?? []).filter((item) => item.type === "reasoning"));
@@ -362,235 +554,203 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 : (response?.service_tier ?? options.serviceTier);
             options.applyServiceTierPricing(output.usage, serviceTier);
         }
+        applyResponseOutput(response.output ?? []);
         // 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: "" };
-                currentReasoningSummaryPartText = "";
-                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: options?.toolNameMap?.toOriginalName(item.name) ?? item.name,
-                    arguments: {},
-                    partialJson: item.arguments || "",
-                };
-                output.content.push(currentBlock);
-                stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-            }
+        if (output.stopReason !== "error" && output.stopReason !== "aborted") {
+            committedSuccessfulTerminal = true;
+            commitSuccessfulAssistantParse(output);
         }
-        else if (event.type === "response.reasoning_summary_part.added") {
-            if (currentItem && currentItem.type === "reasoning") {
-                currentItem.summary = currentItem.summary || [];
-                currentItem.summary.push(event.part);
-                currentReasoningSummaryPartText = event.part.text ?? "";
+    };
+    try {
+        for await (const event of openaiStream) {
+            if (event.type === "response.created") {
+                output.responseId = event.response.id;
             }
-        }
-        else if (event.type === "response.reasoning_summary_text.delta") {
-            if (currentItem?.type === "reasoning") {
-                currentItem.summary = currentItem.summary || [];
-                const lastPart = currentItem.summary[currentItem.summary.length - 1];
-                if (lastPart) {
-                    lastPart.text += event.delta;
-                    currentReasoningSummaryPartText += event.delta;
+            else if (event.type === "response.output_item.added") {
+                const item = event.item;
+                if (item.type === "reasoning") {
+                    currentItem = item;
+                    currentBlock = { type: "thinking", thinking: "" };
+                    currentReasoningSummaryPartText = "";
+                    output.content.push(currentBlock);
+                    if (item.id)
+                        reasoningBlocksById.set(item.id, currentBlock);
+                    stream.push({ type: "thinking_start", contentIndex: blockIndex(), 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];
-                const partText = cleanReasoningSummaryText(lastPart?.text ?? currentReasoningSummaryPartText);
-                if (lastPart) {
-                    lastPart.text = partText;
+                else if (item.type === "message") {
+                    currentItem = item;
+                    currentBlock = { type: "text", text: "" };
+                    if (item.id) {
+                        currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
+                    }
+                    output.content.push(currentBlock);
+                    stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
                 }
-                if (partText.trim().length > 0) {
-                    const delta = `${partText}\n\n`;
-                    currentBlock.thinking += delta;
-                    stream.push({
-                        type: "thinking_delta",
-                        contentIndex: blockIndex(),
-                        delta,
-                        partial: output,
-                    });
+                else if (item.type === "function_call") {
+                    currentItem = item;
+                    currentBlock = {
+                        type: "toolCall",
+                        id: `${item.call_id}|${item.id}`,
+                        name: options?.toolNameMap?.toOriginalName(item.name) ?? item.name,
+                        arguments: {},
+                        partialJson: item.arguments || "",
+                    };
+                    output.content.push(currentBlock);
+                    registerFunctionCallBlock(item, currentBlock);
+                    stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
                 }
-                currentReasoningSummaryPartText = "";
             }
-        }
-        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.reasoning_summary_part.added") {
+                if (currentItem && currentItem.type === "reasoning") {
+                    currentItem.summary = currentItem.summary || [];
+                    currentItem.summary.push(event.part);
+                    currentReasoningSummaryPartText = event.part.text ?? "";
+                }
             }
-        }
-        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);
+            else if (event.type === "response.reasoning_summary_text.delta") {
+                if (currentItem?.type === "reasoning") {
+                    currentItem.summary = currentItem.summary || [];
+                    const lastPart = currentItem.summary[currentItem.summary.length - 1];
+                    if (lastPart) {
+                        lastPart.text += event.delta;
+                        currentReasoningSummaryPartText += event.delta;
+                    }
                 }
             }
-        }
-        else if (event.type === "response.output_text.delta") {
-            if (currentItem?.type === "message" && currentBlock?.type === "text") {
-                const lastPart = ensureMessageOutputTextPart();
-                if (lastPart) {
-                    currentBlock.text += event.delta;
-                    lastPart.text += event.delta;
-                    stream.push({
-                        type: "text_delta",
-                        contentIndex: blockIndex(),
-                        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];
+                    const partText = cleanReasoningSummaryText(lastPart?.text ?? currentReasoningSummaryPartText);
+                    if (lastPart) {
+                        lastPart.text = partText;
+                    }
+                    if (partText.trim().length > 0) {
+                        const delta = `${partText}\n\n`;
+                        currentBlock.thinking += delta;
+                        stream.push({
+                            type: "thinking_delta",
+                            contentIndex: blockIndex(),
+                            delta,
+                            partial: output,
+                        });
+                    }
+                    currentReasoningSummaryPartText = "";
                 }
             }
-        }
-        else if (event.type === "response.refusal.delta") {
-            if (currentItem?.type === "message" && currentBlock?.type === "text") {
-                const lastPart = ensureMessageRefusalPart();
-                if (lastPart) {
-                    currentBlock.text += event.delta;
-                    lastPart.refusal += event.delta;
+            else if (event.type === "response.reasoning_text.delta") {
+                if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+                    currentBlock.thinking += event.delta;
                     stream.push({
-                        type: "text_delta",
+                        type: "thinking_delta",
                         contentIndex: blockIndex(),
                         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,
-                });
+            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);
+                    }
+                }
             }
-        }
-        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) {
+            else if (event.type === "response.output_text.delta") {
+                if (currentItem?.type === "message" && currentBlock?.type === "text") {
+                    const lastPart = ensureMessageOutputTextPart();
+                    if (lastPart) {
+                        currentBlock.text += event.delta;
+                        lastPart.text += event.delta;
                         stream.push({
-                            type: "toolcall_delta",
+                            type: "text_delta",
                             contentIndex: blockIndex(),
-                            delta,
+                            delta: event.delta,
                             partial: output,
                         });
                     }
                 }
             }
-        }
-        else if (event.type === "response.output_item.done") {
-            const item = event.item;
-            if (item.type === "reasoning" && currentBlock?.type === "thinking") {
-                if (item.summary) {
-                    item.summary = item.summary
-                        .map((part) => ({ ...part, text: cleanReasoningSummaryText(part.text ?? "") }))
-                        .filter((part) => part.text.trim().length > 0);
+            else if (event.type === "response.refusal.delta") {
+                if (currentItem?.type === "message" && currentBlock?.type === "text") {
+                    const lastPart = ensureMessageRefusalPart();
+                    if (lastPart) {
+                        currentBlock.text += event.delta;
+                        lastPart.refusal += event.delta;
+                        stream.push({
+                            type: "text_delta",
+                            contentIndex: blockIndex(),
+                            delta: event.delta,
+                            partial: output,
+                        });
+                    }
                 }
-                const summaryText = normalizeReasoningSummaryText(item.summary);
-                const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
-                currentBlock.thinking = summaryText || contentText || currentBlock.thinking;
-                currentBlock.thinkingSignature = JSON.stringify(item);
-                reasoningBlocksById.set(item.id, currentBlock);
-                stream.push({
-                    type: "thinking_end",
-                    contentIndex: blockIndex(),
-                    content: currentBlock.thinking,
-                    partial: output,
-                });
-                currentBlock = null;
             }
-            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);
-                stream.push({
-                    type: "text_end",
-                    contentIndex: blockIndex(),
-                    content: currentBlock.text,
-                    partial: output,
-                });
-                currentBlock = null;
+            else if (event.type === "response.function_call_arguments.delta") {
+                if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
+                    currentBlock.partialJson = (currentBlock.partialJson ?? "") + event.delta;
+                    currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+                    stream.push({
+                        type: "toolcall_delta",
+                        contentIndex: blockIndex(),
+                        delta: event.delta,
+                        partial: output,
+                    });
+                }
             }
-            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 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 (previousPartialJson !== undefined && 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,
+                            });
+                        }
+                    }
                 }
-                else {
-                    toolCall = {
-                        type: "toolCall",
-                        id: `${item.call_id}|${item.id}`,
-                        name: options?.toolNameMap?.toOriginalName(item.name) ?? item.name,
-                        arguments: args,
-                    };
+            }
+            else if (event.type === "response.output_item.done") {
+                const item = event.item;
+                if (item.type === "reasoning" || item.type === "message" || item.type === "function_call") {
+                    applyCompletedOutputItem(item, true);
                 }
-                currentBlock = null;
-                stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+            }
+            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
+                    ? `${error.code || "unknown"}: ${error.message || "no message"}`
+                    : details?.reason
+                        ? `incomplete: ${details.reason}`
+                        : "Unknown error (no error details in response)";
+                throw new Error(msg);
             }
         }
-        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
-                ? `${error.code || "unknown"}: ${error.message || "no message"}`
-                : details?.reason
-                    ? `incomplete: ${details.reason}`
-                    : "Unknown error (no error details in response)";
-            throw new Error(msg);
-        }
+    }
+    catch (error) {
+        if (committedSuccessfulTerminal)
+            return;
+        throw error;
     }
     if (!sawTerminalResponseEvent) {
         throw new Error("OpenAI Responses stream ended before a terminal response event");