@cydm/pie 1.0.40 → 1.0.42

package/dist/chunks/{chunk-7IFMKPHH.js → chunk-JVLAKTAS.js}

@@ -3,7 +3,7 @@ import {
   EventStream,
   streamSimple,
   validateToolArguments
-} from "./chunk-HPTWCKJE.js";
+} from "./chunk-NGQ3PUOC.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {

package/dist/chunks/{chunk-TG2EQLX2.js → chunk-LZQXQOPJ.js}

@@ -12,7 +12,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)

package/dist/chunks/{chunk-HPTWCKJE.js → chunk-NGQ3PUOC.js}

@@ -4,7 +4,7 @@ import {
   __export,
   __require,
   __toESM
-} from "./chunk-TG2EQLX2.js";
+} from "./chunk-LZQXQOPJ.js";
 
 // ../../node_modules/partial-json/dist/options.js
 var require_options = __commonJS({
@@ -3338,9 +3338,9 @@ var NodeFileSystem = class {
     if (length === 0) return new Uint8Array();
     const handle = await getNodeFs().promises.open(path, "r");
     try {
-      const buffer = Buffer.allocUnsafe(length);
-      const { bytesRead } = await handle.read(buffer, 0, length, 0);
-      return new Uint8Array(buffer.subarray(0, bytesRead));
+      const view = new Uint8Array(length);
+      const { bytesRead } = await handle.read(view, 0, length, 0);
+      return view.subarray(0, bytesRead);
     } finally {
       await handle.close();
     }
@@ -3805,7 +3805,10 @@ var PuerTSFileSystem = class {
     while (offset < length) {
       const requested = Math.min(length - offset, 65536);
       if (offset > 0 && typeof bridge.ReadRangeHex !== "function") {
-        throw new Error("The Unity file bridge cannot read prefixes beyond 64 KiB. Update PieFileBridge with ReadRangeHex.");
+        console.warn(
+          `[pie] readFilePrefix truncated at 64 KiB: the Unity file bridge is missing ReadRangeHex. Update the Pie package so PieFileBridge matches the runtime bundle. (requested ${length} bytes of '${path}')`
+        );
+        break;
       }
       const hex = String((offset === 0 ? bridge.ReadPrefixHex(normalizedPath, requested) : bridge.ReadRangeHex(normalizedPath, offset, requested)) ?? "");
       if (hex.length % 2 !== 0) throw new Error("The Unity file bridge returned an invalid hex prefix.");
@@ -4162,6 +4165,7 @@ function isAbortErrorMessage(message) {
 var nodeHttps = null;
 var nodeHttp = null;
 var nodeUrl = null;
+var nodeStringDecoder = null;
 function getNodeHttps() {
   if (!nodeHttps) {
     nodeHttps = require3("https");
@@ -4180,6 +4184,12 @@ function getNodeUrl() {
   }
   return nodeUrl;
 }
+function getNodeStringDecoder() {
+  if (!nodeStringDecoder) {
+    nodeStringDecoder = require3("string_decoder");
+  }
+  return nodeStringDecoder;
+}
 var globalHttpsAgent = null;
 var globalHttpAgent = null;
 var agentStats = {
@@ -4322,8 +4332,9 @@ var NodeHttpClient = class {
             const sseStartTime = Date.now();
             let totalBytes = 0;
             let lineCount = 0;
-            let bufferChunks = [];
-            let bufferLength = 0;
+            const { StringDecoder } = getNodeStringDecoder();
+            const decoder = new StringDecoder("utf8");
+            let textBuffer = "";
             const lineQueue = [];
             let queueHead = 0;
             let done = false;
@@ -4343,23 +4354,21 @@ var NodeHttpClient = class {
               logHttp("ERROR", `Request [${requestId}] SSE stream error`, { error: e.message });
             };
             const flushBuffer = (final = false) => {
-              if (bufferLength === 0) return;
-              const buffer = Buffer.concat(bufferChunks, bufferLength);
-              const bufferStr = buffer.toString("utf-8");
-              const lines = bufferStr.split("\n");
+              if (final) {
+                textBuffer += decoder.end();
+              }
+              if (textBuffer.length === 0) return;
+              const lines = textBuffer.split("\n");
               const lastLine = lines.pop();
               if (final) {
                 if (lastLine !== void 0 && lastLine.length > 0) {
                   lines.push(lastLine);
                 }
-                bufferChunks = [];
-                bufferLength = 0;
+                textBuffer = "";
               } else if (lastLine !== void 0) {
-                bufferChunks = [Buffer.from(lastLine)];
-                bufferLength = lastLine.length;
+                textBuffer = lastLine;
               } else {
-                bufferChunks = [];
-                bufferLength = 0;
+                textBuffer = "";
               }
               for (const line of lines) {
                 lineQueue.push(line);
@@ -4379,17 +4388,15 @@ var NodeHttpClient = class {
             }
             res.on("data", (chunk) => {
               totalBytes += chunk.length;
-              bufferChunks.push(chunk);
-              bufferLength += chunk.length;
-              if (bufferLength > 16384 || chunk.includes(10)) {
+              const decoded = decoder.write(chunk);
+              textBuffer += decoded;
+              if (textBuffer.length > 16384 || decoded.includes("\n")) {
                 flushBuffer();
               }
               wake({ done: false, value: void 0 });
             });
             res.on("end", () => {
-              if (bufferLength > 0) {
-                flushBuffer(true);
-              }
+              flushBuffer(true);
               if (!res.complete) {
                 failStream(new Error("SSE stream ended before response completed"));
                 return;
@@ -5212,6 +5219,8 @@ function detectCompat(_model) {
     requiresAssistantAfterToolResult: false,
     requiresThinkingAsText: true,
     supportsStrictMode: true,
+    streamRequiresDone: true,
+    streamRequiresFinishReason: true,
     cacheCapability: NO_CACHE_CAPABILITY
   };
 }
@@ -5229,6 +5238,8 @@ function getCompat(model) {
     requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
     requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
     supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
+    streamRequiresDone: model.compat.streamRequiresDone ?? detected.streamRequiresDone,
+    streamRequiresFinishReason: model.compat.streamRequiresFinishReason ?? detected.streamRequiresFinishReason,
     cacheCapability: model.compat.cacheCapability ?? detected.cacheCapability
   };
 }
@@ -5539,7 +5550,7 @@ function hasAssistantContent(message) {
       return block.text.trim().length > 0;
     }
     if (block.type === "thinking") {
-      return block.thinking.trim().length > 0;
+      return false;
     }
     if (block.type === "toolCall") {
       return block.name.trim().length > 0;
@@ -5548,6 +5559,9 @@ function hasAssistantContent(message) {
   });
 }
 function assertAssistantHasContent(message) {
+  if (message.stopReason === "length") {
+    return;
+  }
   if (!hasAssistantContent(message)) {
     throw new EmptyAssistantContentError();
   }
@@ -5571,6 +5585,14 @@ function logEmptyAssistantContentError(error, model, options) {
 
 // ../../packages/ai/src/providers/openai-compat.ts
 var DEFAULT_OPENAI_COMPAT_STREAM_TIMEOUT_MS = 10 * 60 * 1e3;
+var OPENAI_COMPAT_PROTOCOL_ERROR_CODE = "provider_response_protocol_error";
+var OpenAICompatProtocolError = class extends Error {
+  code = OPENAI_COMPAT_PROTOCOL_ERROR_CODE;
+  constructor(message) {
+    super(`${OPENAI_COMPAT_PROTOCOL_ERROR_CODE}: ${message}`);
+    this.name = "OpenAICompatProtocolError";
+  }
+};
 function getOpenAICompatStreamTimeoutMs() {
   const value = Number(process.env.PIE_OPENAI_COMPAT_STREAM_TIMEOUT_MS || "");
   return Number.isFinite(value) && value > 0 ? value : DEFAULT_OPENAI_COMPAT_STREAM_TIMEOUT_MS;
@@ -5623,6 +5645,44 @@ function formatOpenAIStreamError(error) {
   }
   return metadata.length > 0 ? `${message} (${metadata.join(", ")})` : message;
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createProtocolError(message) {
+  return new OpenAICompatProtocolError(message);
+}
+function parseSSEDataLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith(":")) return null;
+  if (!trimmed.startsWith("data:")) return null;
+  const data = trimmed.slice(5);
+  return data.startsWith(" ") ? data.slice(1) : data;
+}
+function parseFinalToolArguments(partialArgs, toolName) {
+  const text = partialArgs.trim();
+  if (!text) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw createProtocolError(`OpenAI-compatible stream returned incomplete or invalid JSON arguments for tool "${toolName || "unknown"}": ${message}`);
+  }
+  if (!isRecord(parsed)) {
+    throw createProtocolError(`OpenAI-compatible stream returned non-object JSON arguments for tool "${toolName || "unknown"}".`);
+  }
+  return parsed;
+}
+function tryParseFinalToolArguments(partialArgs) {
+  const text = partialArgs.trim();
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 var streamOpenAICompletions = (model, context, options) => {
   const stream = new AssistantMessageEventStream();
   (async () => {
@@ -5673,8 +5733,94 @@ var streamOpenAICompletions = (model, context, options) => {
       let currentBlock = null;
       const blocks = output.content;
       const blockIndex = () => blocks.length - 1;
-      const toolCalls = /* @__PURE__ */ new Map();
+      const toolCallEntries = [];
+      const toolCallsByIndex = /* @__PURE__ */ new Map();
+      const toolCallsById = /* @__PURE__ */ new Map();
       let usageSnapshot = {};
+      let sawDone = false;
+      let sawFinishReason = false;
+      let rawFinishReason = null;
+      const createToolCallEntry = (toolCall, index) => {
+        const block = {
+          type: "toolCall",
+          id: toolCall.id || "",
+          name: toolCall.function?.name || "",
+          arguments: {}
+        };
+        output.content.push(block);
+        const entry = { block, partialArgs: "", contentIndex: blockIndex(), index };
+        toolCallEntries.push(entry);
+        stream.push({
+          type: "toolcall_start",
+          contentIndex: entry.contentIndex,
+          partial: output
+        });
+        return entry;
+      };
+      const bindToolCallIndex = (index, entry) => {
+        const existing = toolCallsByIndex.get(index);
+        if (existing && existing !== entry) {
+          throw createProtocolError(`OpenAI-compatible stream reused tool call index ${index} for multiple calls.`);
+        }
+        if (entry.index !== void 0 && entry.index !== index) {
+          throw createProtocolError(`OpenAI-compatible stream moved tool call "${entry.block.id || entry.block.name || "unknown"}" from index ${entry.index} to ${index}.`);
+        }
+        entry.index = index;
+        toolCallsByIndex.set(index, entry);
+      };
+      const rememberToolCallId = (id, entry) => {
+        const existing = toolCallsById.get(id);
+        if (existing && existing !== entry) {
+          throw createProtocolError(`OpenAI-compatible stream reused tool call id "${id}" for multiple calls.`);
+        }
+        if (entry.block.id && entry.block.id !== id) {
+          throw createProtocolError(`OpenAI-compatible stream changed tool call id from "${entry.block.id}" to "${id}".`);
+        }
+        entry.block.id = id;
+        toolCallsById.set(id, entry);
+      };
+      const resolveToolCallEntry = (toolCall, toolCallCount) => {
+        const id = typeof toolCall.id === "string" && toolCall.id.length > 0 ? toolCall.id : "";
+        if (Number.isInteger(toolCall.index) && toolCall.index >= 0) {
+          let entry = toolCallsByIndex.get(toolCall.index);
+          if (entry && id && entry.block.id && entry.block.id !== id) {
+            throw createProtocolError(`OpenAI-compatible stream changed tool call id at index ${toolCall.index} from "${entry.block.id}" to "${id}".`);
+          }
+          if (!entry && id) {
+            entry = toolCallsById.get(id);
+            if (entry) bindToolCallIndex(toolCall.index, entry);
+          }
+          if (!entry) {
+            entry = createToolCallEntry(toolCall, toolCall.index);
+            bindToolCallIndex(toolCall.index, entry);
+          }
+          if (id) rememberToolCallId(id, entry);
+          return entry;
+        }
+        if (id) {
+          let entry = toolCallsById.get(id);
+          if (!entry) {
+            const unpaired = toolCallEntries.filter((candidate) => !candidate.block.id);
+            if (unpaired.length === 1) {
+              rememberToolCallId(id, unpaired[0]);
+              return unpaired[0];
+            }
+            if (unpaired.length > 1) {
+              throw createProtocolError(`OpenAI-compatible stream returned tool call id "${id}" without an index while multiple unnamed calls are in flight; the call cannot be disambiguated.`);
+            }
+            entry = createToolCallEntry(toolCall);
+            rememberToolCallId(id, entry);
+          }
+          return entry;
+        }
+        if (toolCallEntries.length === 1) {
+          return toolCallEntries[0];
+        }
+        if (toolCallEntries.length === 0 && toolCallCount === 1) {
+          return createToolCallEntry(toolCall);
+        }
+        throw createProtocolError("OpenAI-compatible stream returned tool call deltas without index or id and the call could not be disambiguated.");
+      };
       const finishCurrentBlock = (block) => {
         if (block) {
           if (block.type === "text") {
@@ -5699,155 +5845,166 @@ var streamOpenAICompletions = (model, context, options) => {
       }
       for await (const line of response.readSSELines(options?.signal)) {
         {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed.startsWith(":")) continue;
-          if (trimmed.startsWith("data: ")) {
-            const data = trimmed.slice(6);
-            if (data === "[DONE]") break;
-            let chunk;
-            try {
-              chunk = JSON.parse(data);
-            } catch {
-              continue;
-            }
-            if (chunk?.error) {
-              throw new Error(formatOpenAIStreamError(chunk.error));
+          const data = parseSSEDataLine(line);
+          if (data === null) continue;
+          if (data === "[DONE]") {
+            sawDone = true;
+            break;
+          }
+          let chunk;
+          try {
+            chunk = JSON.parse(data);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw createProtocolError(`OpenAI-compatible stream returned malformed SSE JSON: ${message}`);
+          }
+          if (chunk?.error) {
+            throw new Error(formatOpenAIStreamError(chunk.error));
+          }
+          if (chunk.usage) {
+            usageSnapshot = mergeOpenAIUsage(usageSnapshot, chunk.usage);
+            const normalizedUsage = normalizeOpenAIUsage(usageSnapshot);
+            output.usage = {
+              input: normalizedUsage.input,
+              output: normalizedUsage.output,
+              cacheRead: normalizedUsage.cacheRead,
+              cacheWrite: 0,
+              totalTokens: normalizedUsage.totalTokens,
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+            };
+            output.usage.cost = calculateCost(model, output.usage);
+            if (process.env.PIE_DEBUG_CACHE) {
+              const normalizedPromptTokens = normalizedUsage.input + normalizedUsage.cacheRead;
+              console.error("[CACHE DEBUG] Response usage:", JSON.stringify({
+                input_tokens: normalizedUsage.input,
+                output_tokens: normalizedUsage.output,
+                cached_tokens: normalizedUsage.cacheRead,
+                cache_hit_rate: normalizedPromptTokens > 0 ? `${(normalizedUsage.cacheRead / normalizedPromptTokens * 100).toFixed(1)}%` : "N/A"
+              }, null, 2));
             }
-            if (chunk.usage) {
-              usageSnapshot = mergeOpenAIUsage(usageSnapshot, chunk.usage);
-              const normalizedUsage = normalizeOpenAIUsage(usageSnapshot);
-              output.usage = {
-                input: normalizedUsage.input,
-                output: normalizedUsage.output,
-                cacheRead: normalizedUsage.cacheRead,
-                cacheWrite: 0,
-                totalTokens: normalizedUsage.totalTokens,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-              };
-              output.usage.cost = calculateCost(model, output.usage);
-              if (process.env.PIE_DEBUG_CACHE) {
-                const normalizedPromptTokens = normalizedUsage.input + normalizedUsage.cacheRead;
-                console.error("[CACHE DEBUG] Response usage:", JSON.stringify({
-                  input_tokens: normalizedUsage.input,
-                  output_tokens: normalizedUsage.output,
-                  cached_tokens: normalizedUsage.cacheRead,
-                  cache_hit_rate: normalizedPromptTokens > 0 ? `${(normalizedUsage.cacheRead / normalizedPromptTokens * 100).toFixed(1)}%` : "N/A"
-                }, null, 2));
+          }
+          const choice = chunk.choices?.[0];
+          if (!choice) continue;
+          if (choice.finish_reason) {
+            sawFinishReason = true;
+            rawFinishReason = String(choice.finish_reason);
+            output.stopReason = mapOpenAIStopReason(choice.finish_reason);
+          }
+          if (choice.delta) {
+            if (choice.delta.content !== null && choice.delta.content !== void 0 && choice.delta.content.length > 0) {
+              if (!currentBlock || currentBlock.type !== "text") {
+                finishCurrentBlock(currentBlock);
+                currentBlock = { type: "text", text: "" };
+                output.content.push(currentBlock);
+                stream.push({
+                  type: "text_start",
+                  contentIndex: blockIndex(),
+                  partial: output
+                });
+              }
+              if (currentBlock.type === "text") {
+                currentBlock.text += choice.delta.content;
+                stream.push({
+                  type: "text_delta",
+                  contentIndex: blockIndex(),
+                  delta: choice.delta.content,
+                  partial: output
+                });
               }
             }
-            const choice = chunk.choices?.[0];
-            if (!choice) continue;
-            if (choice.finish_reason) {
-              output.stopReason = mapOpenAIStopReason(choice.finish_reason);
+            const reasoningFields = [
+              "reasoning_content",
+              "reasoning",
+              "reasoning_text"
+            ];
+            let foundReasoningField = null;
+            for (const field of reasoningFields) {
+              if (choice.delta[field] !== null && choice.delta[field] !== void 0 && choice.delta[field].length > 0) {
+                foundReasoningField = field;
+                break;
+              }
             }
-            if (choice.delta) {
-              if (choice.delta.content !== null && choice.delta.content !== void 0 && choice.delta.content.length > 0) {
-                if (!currentBlock || currentBlock.type !== "text") {
-                  finishCurrentBlock(currentBlock);
-                  currentBlock = { type: "text", text: "" };
-                  output.content.push(currentBlock);
-                  stream.push({
-                    type: "text_start",
-                    contentIndex: blockIndex(),
-                    partial: output
-                  });
-                }
-                if (currentBlock.type === "text") {
-                  currentBlock.text += choice.delta.content;
-                  stream.push({
-                    type: "text_delta",
-                    contentIndex: blockIndex(),
-                    delta: choice.delta.content,
-                    partial: output
-                  });
-                }
+            if (foundReasoningField) {
+              if (!currentBlock || currentBlock.type !== "thinking") {
+                finishCurrentBlock(currentBlock);
+                currentBlock = {
+                  type: "thinking",
+                  thinking: "",
+                  thinkingSignature: foundReasoningField
+                };
+                output.content.push(currentBlock);
+                stream.push({
+                  type: "thinking_start",
+                  contentIndex: blockIndex(),
+                  partial: output
+                });
               }
-              const reasoningFields = [
-                "reasoning_content",
-                "reasoning",
-                "reasoning_text"
-              ];
-              let foundReasoningField = null;
-              for (const field of reasoningFields) {
-                if (choice.delta[field] !== null && choice.delta[field] !== void 0 && choice.delta[field].length > 0) {
-                  foundReasoningField = field;
-                  break;
-                }
+              if (currentBlock.type === "thinking") {
+                const delta = choice.delta[foundReasoningField];
+                currentBlock.thinking += delta;
+                stream.push({
+                  type: "thinking_delta",
+                  contentIndex: blockIndex(),
+                  delta,
+                  partial: output
+                });
               }
-              if (foundReasoningField) {
-                if (!currentBlock || currentBlock.type !== "thinking") {
-                  finishCurrentBlock(currentBlock);
-                  currentBlock = {
-                    type: "thinking",
-                    thinking: "",
-                    thinkingSignature: foundReasoningField
-                  };
-                  output.content.push(currentBlock);
-                  stream.push({
-                    type: "thinking_start",
-                    contentIndex: blockIndex(),
-                    partial: output
-                  });
-                }
-                if (currentBlock.type === "thinking") {
-                  const delta = choice.delta[foundReasoningField];
-                  currentBlock.thinking += delta;
+            }
+            if (choice.delta.tool_calls) {
+              const deltaToolCalls = choice.delta.tool_calls;
+              for (const toolCall of deltaToolCalls) {
+                finishCurrentBlock(currentBlock);
+                currentBlock = null;
+                const entry = resolveToolCallEntry(toolCall, deltaToolCalls.length);
+                if (entry) {
+                  if (toolCall.id) rememberToolCallId(toolCall.id, entry);
+                  if (toolCall.function?.name) {
+                    if (entry.block.name && entry.block.name !== toolCall.function.name) {
+                      throw createProtocolError(`OpenAI-compatible stream changed tool call name from "${entry.block.name}" to "${toolCall.function.name}".`);
+                    }
+                    entry.block.name = toolCall.function.name;
+                  }
+                  let delta = "";
+                  if (toolCall.function?.arguments) {
+                    delta = toolCall.function.arguments;
+                    entry.partialArgs += delta;
+                    entry.block.arguments = parseStreamingJson(entry.partialArgs);
+                  }
                   stream.push({
-                    type: "thinking_delta",
-                    contentIndex: blockIndex(),
+                    type: "toolcall_delta",
+                    contentIndex: entry.contentIndex,
                     delta,
                     partial: output
                   });
                 }
               }
-              if (choice.delta.tool_calls) {
-                for (const [toolCallPosition, toolCall] of choice.delta.tool_calls.entries()) {
-                  const toolCallIndex = Number.isInteger(toolCall.index) && toolCall.index >= 0 ? toolCall.index : toolCallPosition;
-                  finishCurrentBlock(currentBlock);
-                  currentBlock = null;
-                  let entry = toolCalls.get(toolCallIndex);
-                  if (!entry) {
-                    const block = {
-                      type: "toolCall",
-                      id: toolCall.id || "",
-                      name: toolCall.function?.name || "",
-                      arguments: {}
-                    };
-                    output.content.push(block);
-                    entry = { block, partialArgs: "", contentIndex: blockIndex() };
-                    toolCalls.set(toolCallIndex, entry);
-                    stream.push({
-                      type: "toolcall_start",
-                      contentIndex: entry.contentIndex,
-                      partial: output
-                    });
-                  }
-                  if (entry) {
-                    if (toolCall.id) entry.block.id = toolCall.id;
-                    if (toolCall.function?.name)
-                      entry.block.name = toolCall.function.name;
-                    let delta = "";
-                    if (toolCall.function?.arguments) {
-                      delta = toolCall.function.arguments;
-                      entry.partialArgs += delta;
-                      entry.block.arguments = parseStreamingJson(entry.partialArgs);
-                    }
-                    stream.push({
-                      type: "toolcall_delta",
-                      contentIndex: entry.contentIndex,
-                      delta,
-                      partial: output
-                    });
-                  }
-                }
-              }
             }
           }
         }
       }
       finishCurrentBlock(currentBlock);
-      for (const { block, partialArgs, contentIndex } of toolCalls.values()) {
-        block.arguments = parseStreamingJson(partialArgs);
+      if (compat.streamRequiresDone && !sawDone) {
+        throw createProtocolError(`OpenAI-compatible stream ended without data: [DONE]${rawFinishReason ? ` (last finish_reason=${rawFinishReason})` : ""}. Set compat.streamRequiresDone=false for gateways that legitimately omit the terminator.`);
+      }
+      if (compat.streamRequiresFinishReason && !sawFinishReason) {
+        throw createProtocolError("OpenAI-compatible stream ended without finish_reason. Set compat.streamRequiresFinishReason=false for endpoints that omit it.");
+      }
+      if (output.stopReason === "toolUse" && toolCallEntries.length === 0) {
+        throw createProtocolError(`OpenAI-compatible stream ended with finish_reason=${rawFinishReason} but did not include any tool calls.`);
+      }
+      if (output.stopReason === "length" && toolCallEntries.length > 0) {
+        const hasTruncatedArgs = toolCallEntries.some(
+          ({ partialArgs }) => tryParseFinalToolArguments(partialArgs) === null
+        );
+        if (hasTruncatedArgs) {
+          throw new Error("OpenAI-compatible stream ended with finish_reason=length before tool call arguments were complete. Increase maxTokens or reduce prompt size.");
+        }
+      }
+      for (const { block, partialArgs, contentIndex } of toolCallEntries) {
+        if (!block.name.trim()) {
+          throw createProtocolError("OpenAI-compatible stream returned a tool call without a function name.");
+        }
+        block.arguments = parseFinalToolArguments(partialArgs, block.name);
         stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
       }
       if (output.stopReason !== "error" && output.stopReason !== "aborted" && output.content.some((block) => block.type === "toolCall")) {
@@ -9772,6 +9929,7 @@ export {
   EventStream,
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
+  OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   streamSimple,
   completeSimple,
   MODEL_CLASS_FALLBACK_ORDER,

package/dist/chunks/{chunk-F6VAOGFL.js → chunk-VYAW6RAX.js}

@@ -8,10 +8,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-SNSSIR3E.js";
+} from "./chunk-2GVFMYIV.js";
 import {
   Type
-} from "./chunk-HPTWCKJE.js";
+} from "./chunk-NGQ3PUOC.js";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";