@ai-sdk/provider-utils 5.0.19 → 5.0.21

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ai-sdk/provider-utils
 
+## 5.0.21
+
+### Patch Changes
+
+- 1bec07d: Fix streamed tool calls with non-zero, non-contiguous, reused, or missing indexes.
+
+## 5.0.20
+
+### Patch Changes
+
+- 160ccdb: Reduce bundle size by removing the runtime Zod 3 dependency.
+
 ## 5.0.19
 
 ### Patch Changes

package/dist/index.d.ts

@@ -2303,6 +2303,9 @@ type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<
  */
 declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
     private toolCalls;
+    private toolCallsById;
+    private toolCallsByIndex;
+    private latestToolCall;
     private readonly controller;
     private readonly _generateId;
     private readonly typeValidation;

package/dist/index.js

@@ -1325,7 +1325,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.19" : "0.0.0-test";
+var VERSION = true ? "5.0.21" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -1783,22 +1783,18 @@ var getDefaultOptions = (options) => typeof options === "string" ? {
   ...options
 };
 
-// src/to-json-schema/zod3-to-json-schema/select-parser.ts
-import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
-
 // src/to-json-schema/zod3-to-json-schema/parsers/any.ts
 function parseAnyDef() {
   return {};
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/array.ts
-import { ZodFirstPartyTypeKind } from "zod/v3";
 function parseArrayDef(def, refs) {
   var _a3, _b3, _c;
   const res = {
     type: "array"
   };
-  if (((_a3 = def.type) == null ? void 0 : _a3._def) && ((_c = (_b3 = def.type) == null ? void 0 : _b3._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
+  if (((_a3 = def.type) == null ? void 0 : _a3._def) && ((_c = (_b3 = def.type) == null ? void 0 : _b3._def) == null ? void 0 : _c.typeName) !== "ZodAny") {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -1972,11 +1968,6 @@ function parseLiteralDef(def) {
   };
 }
 
-// src/to-json-schema/zod3-to-json-schema/parsers/record.ts
-import {
-  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
-} from "zod/v3";
-
 // src/to-json-schema/zod3-to-json-schema/parsers/string.ts
 var emojiRegex = void 0;
 var zodPatterns = {
@@ -2323,20 +2314,20 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     })) != null ? _a3 : refs.allowedAdditionalProperties
   };
-  if (((_b3 = def.keyType) == null ? void 0 : _b3._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+  if (((_b3 = def.keyType) == null ? void 0 : _b3._def.typeName) === "ZodString" && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
     const { type: _type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === "ZodEnum") {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === "ZodBranded" && def.keyType._def.type._def.typeName === "ZodString" && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
     const { type: _type, ...keyType } = parseBrandedDef(
       def.keyType._def,
       refs
@@ -2712,73 +2703,73 @@ var parseReadonlyDef = (def, refs) => {
 // src/to-json-schema/zod3-to-json-schema/select-parser.ts
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case ZodFirstPartyTypeKind3.ZodString:
+    case "ZodString":
       return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNumber:
+    case "ZodNumber":
       return parseNumberDef(def);
-    case ZodFirstPartyTypeKind3.ZodObject:
+    case "ZodObject":
       return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBigInt:
+    case "ZodBigInt":
       return parseBigintDef(def);
-    case ZodFirstPartyTypeKind3.ZodBoolean:
+    case "ZodBoolean":
       return parseBooleanDef();
-    case ZodFirstPartyTypeKind3.ZodDate:
+    case "ZodDate":
       return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUndefined:
+    case "ZodUndefined":
       return parseUndefinedDef();
-    case ZodFirstPartyTypeKind3.ZodNull:
+    case "ZodNull":
       return parseNullDef();
-    case ZodFirstPartyTypeKind3.ZodArray:
+    case "ZodArray":
       return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUnion:
-    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion":
       return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodIntersection:
+    case "ZodIntersection":
       return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodTuple:
+    case "ZodTuple":
       return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodRecord:
+    case "ZodRecord":
       return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLiteral:
+    case "ZodLiteral":
       return parseLiteralDef(def);
-    case ZodFirstPartyTypeKind3.ZodEnum:
+    case "ZodEnum":
       return parseEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNativeEnum:
+    case "ZodNativeEnum":
       return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNullable:
+    case "ZodNullable":
       return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodOptional:
+    case "ZodOptional":
       return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodMap:
+    case "ZodMap":
       return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodSet:
+    case "ZodSet":
       return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLazy:
+    case "ZodLazy":
       return () => def.getter()._def;
-    case ZodFirstPartyTypeKind3.ZodPromise:
+    case "ZodPromise":
       return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNaN:
-    case ZodFirstPartyTypeKind3.ZodNever:
+    case "ZodNaN":
+    case "ZodNever":
       return parseNeverDef();
-    case ZodFirstPartyTypeKind3.ZodEffects:
+    case "ZodEffects":
       return parseEffectsDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodAny:
+    case "ZodAny":
       return parseAnyDef();
-    case ZodFirstPartyTypeKind3.ZodUnknown:
+    case "ZodUnknown":
       return parseUnknownDef();
-    case ZodFirstPartyTypeKind3.ZodDefault:
+    case "ZodDefault":
       return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBranded:
+    case "ZodBranded":
       return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodReadonly:
+    case "ZodReadonly":
       return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodCatch:
+    case "ZodCatch":
       return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodPipeline:
+    case "ZodPipeline":
       return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodFunction:
-    case ZodFirstPartyTypeKind3.ZodVoid:
-    case ZodFirstPartyTypeKind3.ZodSymbol:
+    case "ZodFunction":
+    case "ZodVoid":
+    case "ZodSymbol":
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -3739,7 +3730,9 @@ import {
 } from "@ai-sdk/provider";
 var StreamingToolCallTracker = class {
   constructor(controller, options = {}) {
-    this.toolCalls = [];
+    this.toolCalls = /* @__PURE__ */ new Set();
+    this.toolCallsById = /* @__PURE__ */ new Map();
+    this.toolCallsByIndex = /* @__PURE__ */ new Map();
     var _a3, _b3;
     this.controller = controller;
     this._generateId = (_a3 = options.generateId) != null ? _a3 : generateId;
@@ -3753,13 +3746,17 @@ var StreamingToolCallTracker = class {
    * events as appropriate.
    */
   processDelta(toolCallDelta) {
-    var _a3;
-    const index = (_a3 = toolCallDelta.index) != null ? _a3 : 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;
   }
   /**
    * Finalize any unfinished tool calls. Should be called during the stream's
@@ -3772,7 +3769,7 @@ var StreamingToolCallTracker = class {
       }
     }
   }
-  processNewToolCall(index, toolCallDelta) {
+  processNewToolCall(toolCallDelta) {
     var _a3, _b3, _c;
     if (this.typeValidation === "required") {
       if (toolCallDelta.type !== "function") {
@@ -3807,7 +3804,7 @@ var StreamingToolCallTracker = class {
       toolName: toolCallDelta.function.name
     });
     const metadata = (_b3 = this.extractMetadata) == null ? void 0 : _b3.call(this, toolCallDelta);
-    this.toolCalls[index] = {
+    const toolCall = {
       id: toolCallDelta.id,
       type: "function",
       function: {
@@ -3817,7 +3814,10 @@ var StreamingToolCallTracker = class {
       hasFinished: false,
       metadata
     };
-    const toolCall = this.toolCalls[index];
+    this.toolCalls.add(toolCall);
+    if (toolCall.id.length > 0) {
+      this.toolCallsById.set(toolCall.id, toolCall);
+    }
     if (toolCall.function.arguments.length > 0) {
       this.controller.enqueue({
         type: "tool-input-delta",
@@ -3825,10 +3825,10 @@ var StreamingToolCallTracker = class {
         delta: toolCall.function.arguments
       });
     }
+    return toolCall;
   }
-  processExistingToolCall(index, toolCallDelta) {
+  processExistingToolCall(toolCall, toolCallDelta) {
     var _a3;
-    const toolCall = this.toolCalls[index];
     if (toolCall.hasFinished) {
       return;
     }