pi-freeflow 1.33.2 → 1.33.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.33.3
+
+### Patch Changes
+
+- Fix tool calls being rejected with an invalid-arguments error when a model makes several calls in one turn. Some models label every parallel call `0`, so the pieces of different calls were joined together and arrived as one unreadable blob — a planning tool could then reject every update, even a minimal one, and leave its task list stuck mid-turn. Calls are now kept apart by their own identifier, and a call whose text arrives in several pieces still reassembles whole.
+
 ## 1.33.2
 
 ### Patch Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.33.2",
+  "version": "1.33.3",
   "description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
   "main": "extensions/index.ts",
   "types": "src/index.ts",

package/src/opencode-fingerprint.ts

@@ -564,10 +564,16 @@ export function sseToChatCompletionJson(
  let reasoningContent = "";
  let role = "assistant";
  let usage: unknown = undefined;
+ // Keyed by tool-call id whenever the provider sends one. Index is NOT
+ // trustworthy: free models routinely label every parallel call `index: 0`,
+ // and merging their fragments produces one unparseable argument blob
+ // (observed live: `{"i":"a","op":"done"}{"i":"b","op":"done"}`). Index is
+ // only the fallback for providers that omit an id entirely.
  const toolCallsMap = new Map<
-  number,
+  string,
   { id: string; type: string; function: { name: string; arguments: string } }
  >();
+ const keyByIndex = new Map<number, string>();
 
  for (const ev of events) {
   if (ev.data === "[DONE]") continue;
@@ -591,8 +597,15 @@ export function sseToChatCompletionJson(
       }
       if (Array.isArray(delta.tool_calls)) {
        for (const tc of delta.tool_calls) {
-        const idx = tc.index ?? 0;
-        const existing = toolCallsMap.get(idx) ?? {
+        // The first delta of a call carries its id; later deltas carry only
+        // `arguments`. A later id-less delta therefore belongs to whatever
+        // call this index already opened.
+        const idx = typeof tc.index === "number" ? tc.index : 0;
+        const hasId = typeof tc.id === "string" && tc.id !== "";
+        let key = hasId ? `id:${tc.id}` : keyByIndex.get(idx);
+        if (key === undefined) key = `idx:${idx}`;
+        if (hasId) keyByIndex.set(idx, key);
+        const existing = toolCallsMap.get(key) ?? {
          id: tc.id || "",
          type: tc.type || "function",
          function: { name: "", arguments: "" },
@@ -601,7 +614,7 @@ export function sseToChatCompletionJson(
         if (tc.type) existing.type = tc.type;
         if (tc.function?.name) existing.function.name += tc.function.name;
         if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
-        toolCallsMap.set(idx, existing);
+        toolCallsMap.set(key, existing);
        }
       }
      }
@@ -617,9 +630,9 @@ export function sseToChatCompletionJson(
   }
  }
 
- const toolCalls = Array.from(toolCallsMap.entries())
-  .sort(([a], [b]) => a - b)
-  .map(([, tc]) => tc);
+ // Map insertion order is emission order, which is what the host expects. The
+ // previous numeric sort assumed the keys were indices; they are now ids.
+ const toolCalls = Array.from(toolCallsMap.values());
 
  const message: Record<string, unknown> = {
   role,