@ai-sdk/provider-utils 5.0.49 → 5.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.49",
+  "version": "5.0.50",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -37,7 +37,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.18",
+    "@ai-sdk/provider": "4.0.19",
     "@standard-schema/spec": "^1.1.0",
     "@workflow/serde": "4.1.0",
     "eventsource-parser": "^3.0.8",

package/src/streaming-tool-call-argument-state.ts

@@ -0,0 +1,100 @@
+type ArgumentStructure =
+  | { kind: 'undetermined' }
+  | { kind: 'other' }
+  | {
+      kind: 'structured';
+      stack: Array<'{' | '['>;
+      inString: boolean;
+      escaped: boolean;
+      complete: boolean;
+    };
+
+export function startsWithStructuredValue(
+  value: string | null | undefined,
+): boolean {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  const firstCharacter = value.trimStart()[0];
+  return firstCharacter === '{' || firstCharacter === '[';
+}
+
+/**
+ * Incrementally tracks whether streamed tool-call arguments contain a complete
+ * structured JSON value. This is intentionally structural rather than a JSON
+ * parse: a currently parsable scalar can still be the prefix of a later value.
+ */
+export class StreamingToolCallArgumentState {
+  private structure: ArgumentStructure = { kind: 'undetermined' };
+
+  constructor(initialValue = '') {
+    this.append(initialValue);
+  }
+
+  get hasCompleteStructuredValue(): boolean {
+    return (
+      this.structure.kind === 'structured' && this.structure.complete === true
+    );
+  }
+
+  append(delta: string): void {
+    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;
+  }
+}

package/src/streaming-tool-call-tracker.ts

@@ -4,6 +4,10 @@ import {
   type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import { generateId as defaultGenerateId } from './generate-id';
+import {
+  startsWithStructuredValue,
+  StreamingToolCallArgumentState,
+} from './streaming-tool-call-argument-state';
 
 /**
  * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
@@ -23,6 +27,7 @@ export interface StreamingToolCallTrackerOptions<
 > {
   /**
    * ID generator function for tool call IDs.
+   * Blank or repeated outputs are converted to usable unique IDs.
    * Defaults to the standard generateId.
    */
   generateId?: () => string;
@@ -55,12 +60,20 @@ export interface StreamingToolCallTrackerOptions<
 
 interface TrackedToolCall {
   id: string;
+  index?: number;
+  sequence: number;
   type: 'function';
   function: { name: string; arguments: string };
+  argumentState: StreamingToolCallArgumentState;
   hasFinished: boolean;
   metadata?: SharedV4ProviderMetadata;
 }
 
+type ToolCallResolution =
+  | { kind: 'existing'; toolCall: TrackedToolCall }
+  | { kind: 'new' }
+  | { kind: 'ambiguous' };
+
 type StreamingToolCallTrackerController = Pick<
   TransformStreamDefaultController<LanguageModelV4StreamPart>,
   'enqueue'
@@ -72,15 +85,17 @@ type StreamingToolCallTrackerController = Pick<
  * 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.
  */
 export class StreamingToolCallTracker<
   DELTA extends StreamingToolCallDelta = StreamingToolCallDelta,
 > {
-  private toolCalls = new Set<TrackedToolCall>();
-  private toolCallsById = new Map<string, TrackedToolCall>();
-  private toolCallsByIndex = new Map<number, TrackedToolCall>();
-  private latestToolCall: TrackedToolCall | undefined;
+  private toolCalls: TrackedToolCall[] = [];
+  private toolCallsById = new Map<string, Set<TrackedToolCall>>();
+  private toolCallsByIndex = new Map<number, Set<TrackedToolCall>>();
+  private usedToolCallIds = new Set<string>();
+  private nextGeneratedIdSuffixes = new Map<string, number>();
   private readonly controller: StreamingToolCallTrackerController;
   private readonly _generateId: () => string;
   private readonly typeValidation: 'none' | 'if-present' | 'required';
@@ -108,24 +123,51 @@ export class StreamingToolCallTracker<
    * events as appropriate.
    */
   processDelta(toolCallDelta: DELTA): void {
-    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 name = this.getNonBlankString(wireName);
+    const { index } = toolCallDelta;
+
+    const resolution = this.resolveToolCall({
+      wireId,
+      index,
+      name,
+      hasExplicitCallStart:
+        name != null &&
+        startsWithStructuredValue(toolCallDelta.function?.arguments),
+    });
+
+    if (resolution.kind === 'ambiguous') {
+      return;
+    }
+
+    let toolCall: TrackedToolCall;
+    if (resolution.kind === 'new') {
+      // Blank names cannot start a usable call, but some providers repeat a
+      // blank name on continuations. Correlate those continuations first, then
+      // ignore only the unmatched blank-name delta.
+      if (hasBlankName) {
+        return;
+      }
+
+      toolCall = this.processNewToolCall(toolCallDelta, {
+        wireId,
+        index,
+        name,
+      });
     } 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;
   }
 
   /**
@@ -133,14 +175,191 @@ export class StreamingToolCallTracker<
    * flush handler to ensure all tool calls are properly completed.
    */
   flush(): void {
-    for (const toolCall of this.toolCalls) {
+    // Index order is reliable only when every call has an index. For mixed
+    // streams, keep insertion order rather than moving all index-less calls
+    // behind indexed calls.
+    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);
       }
     }
   }
 
-  private processNewToolCall(toolCallDelta: DELTA): TrackedToolCall {
+  /**
+   * 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({
+    wireId,
+    index,
+    name,
+    hasExplicitCallStart,
+  }: {
+    wireId: string | undefined;
+    index: number | null | undefined;
+    name: string | undefined;
+    hasExplicitCallStart: boolean;
+  }): ToolCallResolution {
+    const indexedToolCalls =
+      index != null ? this.toolCallsByIndex.get(index) : undefined;
+    const matchingIndexedToolCalls = this.filterToolCallsByName(
+      indexedToolCalls,
+      name,
+    );
+
+    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;
+          }
+
+          // A named delta with a distinct index starts a new call even when its
+          // wire ID and function name repeat. Providers may reuse IDs across
+          // parallel calls, so the ID/name pair cannot override index evidence.
+          if (name != null) {
+            return { kind: 'new' };
+          }
+
+          // Conflicting labels on a continuation cannot be resolved safely.
+          if (indexedToolCalls != null) {
+            return { kind: 'ambiguous' };
+          }
+
+          return this.resolveMatchingToolCall([...toolCallsWithId], false);
+        }
+
+        if (name != null) {
+          const matchingToolCalls = [...toolCallsWithId].filter(
+            toolCall => toolCall.function.name === name,
+          );
+
+          return this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart,
+          );
+        }
+
+        return this.resolveMatchingToolCall([...toolCallsWithId], false);
+      }
+
+      if (matchingIndexedToolCalls.length > 0) {
+        // A previously unseen ID plus a named structured argument start is
+        // stronger evidence of a distinct call than a reused index/name. This
+        // also keeps interleaved same-name calls separate while still allowing
+        // IDs to change on ordinary continuation fragments.
+        return hasExplicitCallStart
+          ? { kind: 'new' }
+          : this.resolveMatchingToolCall(matchingIndexedToolCalls, false);
+      }
+
+      return { kind: 'new' };
+    }
+
+    if (indexedToolCalls != null) {
+      // Repeated names are valid on continuations. A different name at the
+      // same index is evidence of a new call from a provider that reuses
+      // indices across parallel calls.
+      return this.resolveMatchingToolCall(
+        matchingIndexedToolCalls,
+        hasExplicitCallStart,
+      );
+    }
+
+    if (name != 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' };
+  }
+
+  private filterToolCallsByName(
+    toolCalls: Set<TrackedToolCall> | undefined,
+    name: string | undefined,
+  ): TrackedToolCall[] {
+    if (toolCalls == null) {
+      return [];
+    }
+
+    return [...toolCalls].filter(
+      toolCall => name == null || toolCall.function.name === name,
+    );
+  }
+
+  private resolveMatchingToolCall(
+    toolCalls: TrackedToolCall[],
+    hasExplicitCallStart: boolean,
+  ): ToolCallResolution {
+    if (toolCalls.length === 0) {
+      return { kind: 'new' };
+    }
+
+    if (!hasExplicitCallStart) {
+      return toolCalls.length === 1
+        ? { kind: 'existing', toolCall: toolCalls[0] }
+        : { kind: 'ambiguous' };
+    }
+
+    // A repeated name can occur on continuations. A fresh structured
+    // argument prefix is evidence of another call only after the matching call
+    // has completed its own structured argument payload.
+    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' };
+  }
+
+  private processNewToolCall(
+    toolCallDelta: DELTA,
+    {
+      wireId,
+      index,
+      name,
+    }: {
+      wireId: string | undefined;
+      index: number | null | undefined;
+      name: string | undefined;
+    },
+  ): TrackedToolCall {
     if (this.typeValidation === 'required') {
       if (toolCallDelta.type !== 'function') {
         throw new InvalidResponseDataError({
@@ -157,41 +376,40 @@ export class StreamingToolCallTracker<
       }
     }
 
-    if (toolCallDelta.id == null) {
-      throw new InvalidResponseDataError({
-        data: toolCallDelta,
-        message: `Expected 'id' to be a string.`,
-      });
-    }
-
-    if (toolCallDelta.function?.name == null) {
+    if (name == 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: name,
     });
 
     const metadata = this.extractMetadata?.(toolCallDelta);
 
+    const initialArguments = toolCallDelta.function?.arguments ?? '';
     const toolCall: TrackedToolCall = {
-      id: toolCallDelta.id,
+      id,
+      index: index ?? undefined,
+      sequence: this.toolCalls.length,
       type: 'function',
       function: {
-        name: toolCallDelta.function.name,
-        arguments: toolCallDelta.function.arguments ?? '',
+        name,
+        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);
     }
 
     // Emit initial delta if arguments already present
@@ -210,6 +428,64 @@ export class StreamingToolCallTracker<
     return toolCall;
   }
 
+  private associateWireId(toolCall: TrackedToolCall, wireId: string): void {
+    let toolCallsWithId = this.toolCallsById.get(wireId);
+    if (toolCallsWithId == null) {
+      toolCallsWithId = new Set();
+      this.toolCallsById.set(wireId, toolCallsWithId);
+    }
+    toolCallsWithId.add(toolCall);
+  }
+
+  private associateIndex(toolCall: TrackedToolCall, index: number): void {
+    let toolCallsWithIndex = this.toolCallsByIndex.get(index);
+    if (toolCallsWithIndex == null) {
+      toolCallsWithIndex = new Set();
+      this.toolCallsByIndex.set(index, toolCallsWithIndex);
+    }
+    toolCallsWithIndex.add(toolCall);
+  }
+
+  private createToolCallId(wireId: string | undefined): string {
+    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;
+    }
+
+    // Resume after the last suffix checked for this generated value. This
+    // keeps deterministic generators bounded without repeatedly rescanning
+    // the same occupied suffixes.
+    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;
+      }
+    }
+
+    // The bounded search above is guaranteed to return by the pigeonhole
+    // principle. This guards against future changes invalidating that
+    // invariant without restoring an unbounded retry loop.
+    throw new Error('Failed to create a unique tool call ID.');
+  }
+
+  private getNonBlankString(
+    value: string | null | undefined,
+  ): string | undefined {
+    return value != null && value.trim().length > 0 ? value : undefined;
+  }
+
   private processExistingToolCall(
     toolCall: TrackedToolCall,
     toolCallDelta: DELTA,
@@ -219,6 +495,7 @@ export class StreamingToolCallTracker<
     }
 
     if (toolCallDelta.function?.arguments != null) {
+      toolCall.argumentState.append(toolCallDelta.function.arguments);
       toolCall.function.arguments += toolCallDelta.function.arguments;
 
       this.controller.enqueue({
@@ -241,7 +518,7 @@ export class StreamingToolCallTracker<
 
     this.controller.enqueue({
       type: 'tool-call',
-      toolCallId: toolCall.id ?? this._generateId(),
+      toolCallId: toolCall.id,
       toolName: toolCall.function.name,
       input: toolCall.function.arguments,
       ...(providerMetadata ? { providerMetadata } : {}),