@cydm/pie 1.0.39 → 1.0.41

package/dist/builtin/extensions/ask-user/index.js

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-SNSSIR3E.js";
-import "../../../chunks/chunk-7IFMKPHH.js";
-import "../../../chunks/chunk-HPTWCKJE.js";
+} from "../../../chunks/chunk-OBCFKF6H.js";
+import "../../../chunks/chunk-E3ELBCCX.js";
+import "../../../chunks/chunk-YCPKJCUB.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/ask-user/index.ts

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,11 +7,11 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-SNSSIR3E.js";
-import "../../../chunks/chunk-7IFMKPHH.js";
+} from "../../../chunks/chunk-OBCFKF6H.js";
+import "../../../chunks/chunk-E3ELBCCX.js";
 import {
   Type
-} from "../../../chunks/chunk-HPTWCKJE.js";
+} from "../../../chunks/chunk-YCPKJCUB.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/plan-mode/index.ts

package/dist/builtin/extensions/subagent/index.js

@@ -1,13 +1,13 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-F6VAOGFL.js";
+} from "../../../chunks/chunk-4WGEYDPO.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-SNSSIR3E.js";
-import "../../../chunks/chunk-7IFMKPHH.js";
-import "../../../chunks/chunk-HPTWCKJE.js";
+} from "../../../chunks/chunk-OBCFKF6H.js";
+import "../../../chunks/chunk-E3ELBCCX.js";
+import "../../../chunks/chunk-YCPKJCUB.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/subagent/index.ts

package/dist/builtin/extensions/todo/index.js

@@ -7,9 +7,9 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-SNSSIR3E.js";
-import "../../../chunks/chunk-7IFMKPHH.js";
-import "../../../chunks/chunk-HPTWCKJE.js";
+} from "../../../chunks/chunk-OBCFKF6H.js";
+import "../../../chunks/chunk-E3ELBCCX.js";
+import "../../../chunks/chunk-YCPKJCUB.js";
 import "../../../chunks/chunk-TG2EQLX2.js";
 
 // builtin/extensions/todo/index.ts

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

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

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

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

package/dist/chunks/{chunk-SNSSIR3E.js → chunk-OBCFKF6H.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   Agent
-} from "./chunk-7IFMKPHH.js";
+} from "./chunk-E3ELBCCX.js";
 import {
   FileSystemGateway,
   Type,
@@ -11,7 +11,7 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-HPTWCKJE.js";
+} from "./chunk-YCPKJCUB.js";
 import {
   __commonJS,
   __toESM

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

@@ -4162,6 +4162,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 +4181,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 +4329,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 +4351,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 +4385,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;
@@ -5539,7 +5543,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 +5552,9 @@ function hasAssistantContent(message) {
   });
 }
 function assertAssistantHasContent(message) {
+  if (message.stopReason === "length") {
+    return;
+  }
   if (!hasAssistantContent(message)) {
     throw new EmptyAssistantContentError();
   }
@@ -5571,6 +5578,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 +5638,34 @@ 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;
+}
 var streamOpenAICompletions = (model, context, options) => {
   const stream = new AssistantMessageEventStream();
   (async () => {
@@ -5673,8 +5716,86 @@ 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) {
+            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 +5820,161 @@ 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 (!sawDone) {
+        throw createProtocolError(`OpenAI-compatible stream ended without data: [DONE]${rawFinishReason ? ` (last finish_reason=${rawFinishReason})` : ""}.`);
+      }
+      if (!sawFinishReason) {
+        throw createProtocolError("OpenAI-compatible stream ended without finish_reason.");
+      }
+      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) {
+        throw new Error("OpenAI-compatible stream ended with finish_reason=length before tool calls could be safely executed.");
+      }
+      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 +9899,7 @@ export {
   EventStream,
   getModelCacheCapability,
   EMPTY_ASSISTANT_CONTENT_ERROR,
+  OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   streamSimple,
   completeSimple,
   MODEL_CLASS_FALLBACK_ORDER,

package/dist/chunks/{src-N6MKSRB3.js → src-NHRMBQAJ.js}

@@ -3,8 +3,8 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-7IFMKPHH.js";
-import "./chunk-HPTWCKJE.js";
+} from "./chunk-E3ELBCCX.js";
+import "./chunk-YCPKJCUB.js";
 import "./chunk-TG2EQLX2.js";
 export {
   Agent,

package/dist/chunks/{test-stream-6F6VZ44U.js → test-stream-I6S23PTW.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-HPTWCKJE.js";
+} from "./chunk-YCPKJCUB.js";
 import "./chunk-TG2EQLX2.js";
 
 // src/app/test-stream.ts

package/dist/cli.js

@@ -19,7 +19,7 @@ import {
   getThemesDir,
   migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-F6VAOGFL.js";
+} from "./chunks/chunk-4WGEYDPO.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -69,8 +69,8 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-SNSSIR3E.js";
-import "./chunks/chunk-7IFMKPHH.js";
+} from "./chunks/chunk-OBCFKF6H.js";
+import "./chunks/chunk-E3ELBCCX.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -87,6 +87,7 @@ import {
   Kind,
   MODEL_CLASS_FALLBACK_ORDER,
   Never,
+  OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   Ref,
   TransformDecode,
   TransformDecodeCheckError,
@@ -105,7 +106,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-HPTWCKJE.js";
+} from "./chunks/chunk-YCPKJCUB.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -67414,6 +67415,12 @@ function classifyCliFailure(context) {
       terminal: false
     });
   }
+  if (errorMessage3.includes(OPENAI_COMPAT_PROTOCOL_ERROR_CODE)) {
+    return createClassification("provider_transient", errorMessage3, {
+      retryable: true,
+      terminal: false
+    });
+  }
   if (PROVIDER_TRANSIENT_ERROR_PATTERN.test(errorMessage3)) {
     return createClassification("provider_transient", errorMessage3, {
       retryable: true,
@@ -69382,7 +69389,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-N6MKSRB3.js");
+    const { Agent } = await import("./chunks/src-NHRMBQAJ.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -70103,7 +70110,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-N6MKSRB3.js");
+  const { Agent: AgentClass } = await import("./chunks/src-NHRMBQAJ.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -71053,7 +71060,7 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-N6MKSRB3.js");
+    const { Agent: AgentClass } = await import("./chunks/src-NHRMBQAJ.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
     recordCliCompositionStep(runtime.compositionTrace, {
@@ -71685,7 +71692,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-6F6VZ44U.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-I6S23PTW.js")).createTestStreamFnFromSequenceEnv();
 }
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "1.0.39",
+	"version": "1.0.41",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {