@ai-sdk/provider-utils 5.0.19 → 5.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.19",
+  "version": "5.0.21",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

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

@@ -77,7 +77,10 @@ type StreamingToolCallTrackerController = Pick<
 export class StreamingToolCallTracker<
   DELTA extends StreamingToolCallDelta = StreamingToolCallDelta,
 > {
-  private toolCalls: TrackedToolCall[] = [];
+  private toolCalls = new Set<TrackedToolCall>();
+  private toolCallsById = new Map<string, TrackedToolCall>();
+  private toolCallsByIndex = new Map<number, TrackedToolCall>();
+  private latestToolCall: TrackedToolCall | undefined;
   private readonly controller: StreamingToolCallTrackerController;
   private readonly _generateId: () => string;
   private readonly typeValidation: 'none' | 'if-present' | 'required';
@@ -105,13 +108,24 @@ export class StreamingToolCallTracker<
    * events as appropriate.
    */
   processDelta(toolCallDelta: DELTA): void {
-    const index = toolCallDelta.index ?? this.toolCalls.length;
-
-    if (this.toolCalls[index] == null) {
-      this.processNewToolCall(index, 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);
     } else {
-      this.processExistingToolCall(index, toolCallDelta);
+      this.processExistingToolCall(toolCall, toolCallDelta);
+    }
+
+    if (index != null) {
+      this.toolCallsByIndex.set(index, toolCall);
     }
+    this.latestToolCall = toolCall;
   }
 
   /**
@@ -126,7 +140,7 @@ export class StreamingToolCallTracker<
     }
   }
 
-  private processNewToolCall(index: number, toolCallDelta: DELTA): void {
+  private processNewToolCall(toolCallDelta: DELTA): TrackedToolCall {
     if (this.typeValidation === 'required') {
       if (toolCallDelta.type !== 'function') {
         throw new InvalidResponseDataError({
@@ -165,7 +179,7 @@ export class StreamingToolCallTracker<
 
     const metadata = this.extractMetadata?.(toolCallDelta);
 
-    this.toolCalls[index] = {
+    const toolCall: TrackedToolCall = {
       id: toolCallDelta.id,
       type: 'function',
       function: {
@@ -175,8 +189,10 @@ export class StreamingToolCallTracker<
       hasFinished: false,
       metadata,
     };
-
-    const toolCall = this.toolCalls[index];
+    this.toolCalls.add(toolCall);
+    if (toolCall.id.length > 0) {
+      this.toolCallsById.set(toolCall.id, toolCall);
+    }
 
     // Emit initial delta if arguments already present
     if (toolCall.function.arguments.length > 0) {
@@ -191,11 +207,13 @@ export class StreamingToolCallTracker<
     // argument buffer can still be the prefix of a longer argument string,
     // so acting on it early would use truncated inputs (see #13137).
     // Finalization happens in flush().
+    return toolCall;
   }
 
-  private processExistingToolCall(index: number, toolCallDelta: DELTA): void {
-    const toolCall = this.toolCalls[index];
-
+  private processExistingToolCall(
+    toolCall: TrackedToolCall,
+    toolCallDelta: DELTA,
+  ): void {
     if (toolCall.hasFinished) {
       return;
     }

package/src/to-json-schema/zod3-to-json-schema/parsers/array.ts

@@ -1,4 +1,4 @@
-import { ZodFirstPartyTypeKind, type ZodArrayDef } from 'zod/v3';
+import type { ZodArrayDef } from 'zod/v3';
 import { parseDef } from '../parse-def';
 import type { JsonSchema7Type } from '../parse-types';
 import type { Refs } from '../refs';
@@ -14,10 +14,7 @@ export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
   const res: JsonSchema7ArrayType = {
     type: 'array',
   };
-  if (
-    def.type?._def &&
-    def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny
-  ) {
+  if (def.type?._def && def.type?._def?.typeName !== 'ZodAny') {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, 'items'],

package/src/to-json-schema/zod3-to-json-schema/parsers/record.ts

@@ -1,9 +1,4 @@
-import {
-  ZodFirstPartyTypeKind,
-  type ZodMapDef,
-  type ZodRecordDef,
-  type ZodTypeAny,
-} from 'zod/v3';
+import type { ZodMapDef, ZodRecordDef, ZodTypeAny } from 'zod/v3';
 import { parseDef } from '../parse-def';
 import type { JsonSchema7Type } from '../parse-types';
 import type { Refs } from '../refs';
@@ -34,7 +29,7 @@ export function parseRecordDef(
   };
 
   if (
-    def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString &&
+    def.keyType?._def.typeName === 'ZodString' &&
     def.keyType._def.checks?.length
   ) {
     const { type: _type, ...keyType } = parseStringDef(def.keyType._def, refs);
@@ -43,7 +38,7 @@ export function parseRecordDef(
       ...schema,
       propertyNames: keyType,
     };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === 'ZodEnum') {
     return {
       ...schema,
       propertyNames: {
@@ -51,8 +46,8 @@ export function parseRecordDef(
       },
     };
   } else if (
-    def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded &&
-    def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString &&
+    def.keyType?._def.typeName === 'ZodBranded' &&
+    def.keyType._def.type._def.typeName === 'ZodString' &&
     def.keyType._def.type._def.checks?.length
   ) {
     const { type: _type, ...keyType } = parseBrandedDef(

package/src/to-json-schema/zod3-to-json-schema/select-parser.ts

@@ -1,4 +1,4 @@
-import { ZodFirstPartyTypeKind } from 'zod/v3';
+import type { ZodFirstPartyTypeKind } from 'zod/v3';
 import { parseAnyDef } from './parsers/any';
 import { parseArrayDef } from './parsers/array';
 import { parseBigintDef } from './parsers/bigint';
@@ -34,79 +34,81 @@ import type { JsonSchema7Type } from './parse-types';
 
 export type InnerDefGetter = () => any;
 
+type Zod3TypeName = `${ZodFirstPartyTypeKind}`;
+
 export const selectParser = (
   def: any,
-  typeName: ZodFirstPartyTypeKind,
+  typeName: Zod3TypeName,
   refs: Refs,
 ): JsonSchema7Type | undefined | InnerDefGetter => {
   switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
+    case 'ZodString':
       return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
+    case 'ZodNumber':
       return parseNumberDef(def);
-    case ZodFirstPartyTypeKind.ZodObject:
+    case 'ZodObject':
       return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
+    case 'ZodBigInt':
       return parseBigintDef(def);
-    case ZodFirstPartyTypeKind.ZodBoolean:
+    case 'ZodBoolean':
       return parseBooleanDef();
-    case ZodFirstPartyTypeKind.ZodDate:
+    case 'ZodDate':
       return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
+    case 'ZodUndefined':
       return parseUndefinedDef();
-    case ZodFirstPartyTypeKind.ZodNull:
+    case 'ZodNull':
       return parseNullDef();
-    case ZodFirstPartyTypeKind.ZodArray:
+    case 'ZodArray':
       return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case 'ZodUnion':
+    case 'ZodDiscriminatedUnion':
       return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
+    case 'ZodIntersection':
       return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
+    case 'ZodTuple':
       return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
+    case 'ZodRecord':
       return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
+    case 'ZodLiteral':
       return parseLiteralDef(def);
-    case ZodFirstPartyTypeKind.ZodEnum:
+    case 'ZodEnum':
       return parseEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
+    case 'ZodNativeEnum':
       return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
+    case 'ZodNullable':
       return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodOptional:
+    case 'ZodOptional':
       return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodMap:
+    case 'ZodMap':
       return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
+    case 'ZodSet':
       return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
+    case 'ZodLazy':
       return () => (def as any).getter()._def;
-    case ZodFirstPartyTypeKind.ZodPromise:
+    case 'ZodPromise':
       return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
+    case 'ZodNaN':
+    case 'ZodNever':
       return parseNeverDef();
-    case ZodFirstPartyTypeKind.ZodEffects:
+    case 'ZodEffects':
       return parseEffectsDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodAny:
+    case 'ZodAny':
       return parseAnyDef();
-    case ZodFirstPartyTypeKind.ZodUnknown:
+    case 'ZodUnknown':
       return parseUnknownDef();
-    case ZodFirstPartyTypeKind.ZodDefault:
+    case 'ZodDefault':
       return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBranded:
+    case 'ZodBranded':
       return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodReadonly:
+    case 'ZodReadonly':
       return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodCatch:
+    case 'ZodCatch':
       return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodPipeline:
+    case 'ZodPipeline':
       return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodFunction:
-    case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
+    case 'ZodFunction':
+    case 'ZodVoid':
+    case 'ZodSymbol':
       return undefined;
     default:
       /* c8 ignore next */