@ai-sdk/provider-utils 5.0.49 → 5.0.50

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ai-sdk/provider-utils
 
+## 5.0.50
+
+### Patch Changes
+
+- e3605f6: Fix streamed tool calls with missing, blank, or repeated IDs.
+- Updated dependencies [525efc5]
+  - @ai-sdk/provider@4.0.19
+
 ## 5.0.49
 
 ### Patch Changes

package/dist/index.d.ts

@@ -2470,6 +2470,7 @@ interface StreamingToolCallDelta {
 interface StreamingToolCallTrackerOptions<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
     /**
      * ID generator function for tool call IDs.
+     * Blank or repeated outputs are converted to usable unique IDs.
      * Defaults to the standard generateId.
      */
     generateId?: () => string;
@@ -2501,13 +2502,15 @@ type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<
  * emits tool-input-start/delta/end and tool-call events, and finalizes
  * unfinished tool calls on flush.
  *
- * Used by openai, openai-compatible, groq, deepseek, and alibaba providers.
+ * Used by openai, openai-compatible, groq, deepseek, alibaba, mistral, and
+ * moonshotai providers.
  */
 declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
     private toolCalls;
     private toolCallsById;
     private toolCallsByIndex;
-    private latestToolCall;
+    private usedToolCallIds;
+    private nextGeneratedIdSuffixes;
     private readonly controller;
     private readonly _generateId;
     private readonly typeValidation;
@@ -2525,7 +2528,27 @@ declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = St
      * flush handler to ensure all tool calls are properly completed.
      */
     flush(): void;
+    /**
+     * Correlation precedence for streamed deltas:
+     *
+     * | ID evidence | index/name evidence | start evidence | resolution |
+     * | --- | --- | --- | --- |
+     * | known | matching | any | matching call, new call, or ambiguity |
+     * | known | conflicting | named | new call |
+     * | unseen | matching | structured start | new call |
+     * | unseen | matching | continuation | matching call or ambiguity |
+     * | absent | matching | any | matching call, new call, or ambiguity |
+     * | absent | absent | named | new call |
+     * | absent | absent | unnamed | sole unfinished call, new call, or ambiguity |
+     */
+    private resolveToolCall;
+    private filterToolCallsByName;
+    private resolveMatchingToolCall;
     private processNewToolCall;
+    private associateWireId;
+    private associateIndex;
+    private createToolCallId;
+    private getNonBlankString;
     private processExistingToolCall;
     private finishToolCall;
 }

package/dist/index.js

@@ -503,7 +503,7 @@ function handleFetchError({
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.49" : "0.0.0-test";
+var VERSION = true ? "5.0.50" : "0.0.0-test";
 
 // src/normalize-headers.ts
 function normalizeHeaders(headers) {
@@ -4249,11 +4249,84 @@ function resolveSync(value) {
 import {
   InvalidResponseDataError
 } from "@ai-sdk/provider";
+
+// src/streaming-tool-call-argument-state.ts
+function startsWithStructuredValue(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const firstCharacter = value.trimStart()[0];
+  return firstCharacter === "{" || firstCharacter === "[";
+}
+var StreamingToolCallArgumentState = class {
+  constructor(initialValue = "") {
+    this.structure = { kind: "undetermined" };
+    this.append(initialValue);
+  }
+  get hasCompleteStructuredValue() {
+    return this.structure.kind === "structured" && this.structure.complete === true;
+  }
+  append(delta) {
+    let nextStructure = this.structure;
+    for (const character of delta) {
+      if (nextStructure.kind === "undetermined") {
+        if (/\s/.test(character)) {
+          continue;
+        }
+        if (character !== "{" && character !== "[") {
+          nextStructure = { kind: "other" };
+          continue;
+        }
+        nextStructure = {
+          kind: "structured",
+          stack: [character],
+          inString: false,
+          escaped: false,
+          complete: false
+        };
+        continue;
+      }
+      if (nextStructure.kind !== "structured" || nextStructure.complete) {
+        continue;
+      }
+      if (nextStructure.inString) {
+        if (nextStructure.escaped) {
+          nextStructure.escaped = false;
+        } else if (character === "\\") {
+          nextStructure.escaped = true;
+        } else if (character === '"') {
+          nextStructure.inString = false;
+        }
+        continue;
+      }
+      if (character === '"') {
+        nextStructure.inString = true;
+      } else if (character === "{" || character === "[") {
+        nextStructure.stack.push(character);
+      } else if (character === "}" || character === "]") {
+        const expectedOpening = character === "}" ? "{" : "[";
+        if (nextStructure.stack.at(-1) !== expectedOpening) {
+          nextStructure = { kind: "other" };
+          continue;
+        }
+        nextStructure.stack.pop();
+        if (nextStructure.stack.length === 0) {
+          nextStructure.complete = true;
+        }
+      }
+    }
+    this.structure = nextStructure;
+  }
+};
+
+// src/streaming-tool-call-tracker.ts
 var StreamingToolCallTracker = class {
   constructor(controller, options = {}) {
-    this.toolCalls = /* @__PURE__ */ new Set();
+    this.toolCalls = [];
     this.toolCallsById = /* @__PURE__ */ new Map();
     this.toolCallsByIndex = /* @__PURE__ */ new Map();
+    this.usedToolCallIds = /* @__PURE__ */ new Set();
+    this.nextGeneratedIdSuffixes = /* @__PURE__ */ new Map();
     this.controller = controller;
     this._generateId = options.generateId ?? generateId;
     this.typeValidation = options.typeValidation ?? "none";
@@ -4266,30 +4339,162 @@ var StreamingToolCallTracker = class {
    * events as appropriate.
    */
   processDelta(toolCallDelta) {
-    const { id, index } = toolCallDelta;
-    let toolCall = id != null && id.length > 0 ? this.toolCallsById.get(id) : index != null ? this.toolCallsByIndex.get(index) : this.latestToolCall;
-    if (toolCall == null) {
-      toolCall = this.processNewToolCall(toolCallDelta);
+    const wireName = toolCallDelta.function?.name;
+    const hasBlankName = typeof wireName === "string" && wireName.trim().length === 0;
+    const wireId = this.getNonBlankString(toolCallDelta.id);
+    const name3 = this.getNonBlankString(wireName);
+    const { index } = toolCallDelta;
+    const resolution = this.resolveToolCall({
+      wireId,
+      index,
+      name: name3,
+      hasExplicitCallStart: name3 != null && startsWithStructuredValue(toolCallDelta.function?.arguments)
+    });
+    if (resolution.kind === "ambiguous") {
+      return;
+    }
+    let toolCall;
+    if (resolution.kind === "new") {
+      if (hasBlankName) {
+        return;
+      }
+      toolCall = this.processNewToolCall(toolCallDelta, {
+        wireId,
+        index,
+        name: name3
+      });
     } else {
+      toolCall = resolution.toolCall;
+      if (wireId != null) {
+        this.associateWireId(toolCall, wireId);
+      }
       this.processExistingToolCall(toolCall, toolCallDelta);
     }
     if (index != null) {
-      this.toolCallsByIndex.set(index, toolCall);
+      this.associateIndex(toolCall, index);
     }
-    this.latestToolCall = toolCall;
   }
   /**
    * Finalize any unfinished tool calls. Should be called during the stream's
    * flush handler to ensure all tool calls are properly completed.
    */
   flush() {
-    for (const toolCall of this.toolCalls) {
+    const toolCalls = this.toolCalls.every((toolCall) => toolCall.index != null) ? [...this.toolCalls].sort(
+      (a, b) => a.index - b.index || a.sequence - b.sequence
+    ) : this.toolCalls;
+    for (const toolCall of toolCalls) {
       if (!toolCall.hasFinished) {
         this.finishToolCall(toolCall);
       }
     }
   }
-  processNewToolCall(toolCallDelta) {
+  /**
+   * Correlation precedence for streamed deltas:
+   *
+   * | ID evidence | index/name evidence | start evidence | resolution |
+   * | --- | --- | --- | --- |
+   * | known | matching | any | matching call, new call, or ambiguity |
+   * | known | conflicting | named | new call |
+   * | unseen | matching | structured start | new call |
+   * | unseen | matching | continuation | matching call or ambiguity |
+   * | absent | matching | any | matching call, new call, or ambiguity |
+   * | absent | absent | named | new call |
+   * | absent | absent | unnamed | sole unfinished call, new call, or ambiguity |
+   */
+  resolveToolCall({
+    wireId,
+    index,
+    name: name3,
+    hasExplicitCallStart
+  }) {
+    const indexedToolCalls = index != null ? this.toolCallsByIndex.get(index) : void 0;
+    const matchingIndexedToolCalls = this.filterToolCallsByName(
+      indexedToolCalls,
+      name3
+    );
+    if (wireId != null) {
+      const toolCallsWithId = this.toolCallsById.get(wireId);
+      if (toolCallsWithId != null) {
+        if (index != null) {
+          const matchingToolCalls = matchingIndexedToolCalls.filter(
+            (toolCall) => toolCallsWithId.has(toolCall)
+          );
+          const matchingToolCall = this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
+          if (matchingToolCall.kind !== "new") {
+            return matchingToolCall;
+          }
+          if (name3 != null) {
+            return { kind: "new" };
+          }
+          if (indexedToolCalls != null) {
+            return { kind: "ambiguous" };
+          }
+          return this.resolveMatchingToolCall([...toolCallsWithId], false);
+        }
+        if (name3 != null) {
+          const matchingToolCalls = [...toolCallsWithId].filter(
+            (toolCall) => toolCall.function.name === name3
+          );
+          return this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
+        }
+        return this.resolveMatchingToolCall([...toolCallsWithId], false);
+      }
+      if (matchingIndexedToolCalls.length > 0) {
+        return hasExplicitCallStart ? { kind: "new" } : this.resolveMatchingToolCall(matchingIndexedToolCalls, false);
+      }
+      return { kind: "new" };
+    }
+    if (indexedToolCalls != null) {
+      return this.resolveMatchingToolCall(
+        matchingIndexedToolCalls,
+        hasExplicitCallStart
+      );
+    }
+    if (name3 != null) {
+      return { kind: "new" };
+    }
+    const unfinishedToolCalls = this.toolCalls.filter(
+      (toolCall) => !toolCall.hasFinished
+    );
+    if (unfinishedToolCalls.length === 1) {
+      return { kind: "existing", toolCall: unfinishedToolCalls[0] };
+    }
+    return unfinishedToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
+  }
+  filterToolCallsByName(toolCalls, name3) {
+    if (toolCalls == null) {
+      return [];
+    }
+    return [...toolCalls].filter(
+      (toolCall) => name3 == null || toolCall.function.name === name3
+    );
+  }
+  resolveMatchingToolCall(toolCalls, hasExplicitCallStart) {
+    if (toolCalls.length === 0) {
+      return { kind: "new" };
+    }
+    if (!hasExplicitCallStart) {
+      return toolCalls.length === 1 ? { kind: "existing", toolCall: toolCalls[0] } : { kind: "ambiguous" };
+    }
+    const continuableToolCalls = toolCalls.filter(
+      (toolCall) => !toolCall.argumentState.hasCompleteStructuredValue
+    );
+    if (continuableToolCalls.length === 1) {
+      return { kind: "existing", toolCall: continuableToolCalls[0] };
+    }
+    return continuableToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
+  }
+  processNewToolCall(toolCallDelta, {
+    wireId,
+    index,
+    name: name3
+  }) {
     if (this.typeValidation === "required") {
       if (toolCallDelta.type !== "function") {
         throw new InvalidResponseDataError({
@@ -4305,37 +4510,36 @@ var StreamingToolCallTracker = class {
         });
       }
     }
-    if (toolCallDelta.id == null) {
-      throw new InvalidResponseDataError({
-        data: toolCallDelta,
-        message: `Expected 'id' to be a string.`
-      });
-    }
-    if (toolCallDelta.function?.name == null) {
+    if (name3 == null) {
       throw new InvalidResponseDataError({
         data: toolCallDelta,
         message: `Expected 'function.name' to be a string.`
       });
     }
+    const id = this.createToolCallId(wireId);
     this.controller.enqueue({
       type: "tool-input-start",
-      id: toolCallDelta.id,
-      toolName: toolCallDelta.function.name
+      id,
+      toolName: name3
     });
     const metadata = this.extractMetadata?.(toolCallDelta);
+    const initialArguments = toolCallDelta.function?.arguments ?? "";
     const toolCall = {
-      id: toolCallDelta.id,
+      id,
+      index: index ?? void 0,
+      sequence: this.toolCalls.length,
       type: "function",
       function: {
-        name: toolCallDelta.function.name,
-        arguments: toolCallDelta.function.arguments ?? ""
+        name: name3,
+        arguments: initialArguments
       },
+      argumentState: new StreamingToolCallArgumentState(initialArguments),
       hasFinished: false,
       metadata
     };
-    this.toolCalls.add(toolCall);
-    if (toolCall.id.length > 0) {
-      this.toolCallsById.set(toolCall.id, toolCall);
+    this.toolCalls.push(toolCall);
+    if (wireId != null) {
+      this.associateWireId(toolCall, wireId);
     }
     if (toolCall.function.arguments.length > 0) {
       this.controller.enqueue({
@@ -4346,11 +4550,53 @@ var StreamingToolCallTracker = class {
     }
     return toolCall;
   }
+  associateWireId(toolCall, wireId) {
+    let toolCallsWithId = this.toolCallsById.get(wireId);
+    if (toolCallsWithId == null) {
+      toolCallsWithId = /* @__PURE__ */ new Set();
+      this.toolCallsById.set(wireId, toolCallsWithId);
+    }
+    toolCallsWithId.add(toolCall);
+  }
+  associateIndex(toolCall, index) {
+    let toolCallsWithIndex = this.toolCallsByIndex.get(index);
+    if (toolCallsWithIndex == null) {
+      toolCallsWithIndex = /* @__PURE__ */ new Set();
+      this.toolCallsByIndex.set(index, toolCallsWithIndex);
+    }
+    toolCallsWithIndex.add(toolCall);
+  }
+  createToolCallId(wireId) {
+    if (wireId != null && !this.usedToolCallIds.has(wireId)) {
+      this.usedToolCallIds.add(wireId);
+      return wireId;
+    }
+    const generatedId = this.getNonBlankString(this._generateId()) ?? "tool-call";
+    if (!this.usedToolCallIds.has(generatedId)) {
+      this.usedToolCallIds.add(generatedId);
+      return generatedId;
+    }
+    const initialSuffix = this.nextGeneratedIdSuffixes.get(generatedId) ?? 1;
+    const maximumSuffix = initialSuffix + this.usedToolCallIds.size;
+    for (let suffix = initialSuffix; suffix <= maximumSuffix; suffix++) {
+      const suffixedId = `${generatedId}-${suffix}`;
+      if (!this.usedToolCallIds.has(suffixedId)) {
+        this.usedToolCallIds.add(suffixedId);
+        this.nextGeneratedIdSuffixes.set(generatedId, suffix + 1);
+        return suffixedId;
+      }
+    }
+    throw new Error("Failed to create a unique tool call ID.");
+  }
+  getNonBlankString(value) {
+    return value != null && value.trim().length > 0 ? value : void 0;
+  }
   processExistingToolCall(toolCall, toolCallDelta) {
     if (toolCall.hasFinished) {
       return;
     }
     if (toolCallDelta.function?.arguments != null) {
+      toolCall.argumentState.append(toolCallDelta.function.arguments);
       toolCall.function.arguments += toolCallDelta.function.arguments;
       this.controller.enqueue({
         type: "tool-input-delta",
@@ -4369,7 +4615,7 @@ var StreamingToolCallTracker = class {
     );
     this.controller.enqueue({
       type: "tool-call",
-      toolCallId: toolCall.id ?? this._generateId(),
+      toolCallId: toolCall.id,
       toolName: toolCall.function.name,
       input: toolCall.function.arguments,
       ...providerMetadata ? { providerMetadata } : {}