@ai-sdk/provider-utils 4.0.54 → 4.0.56

package/dist/index.mjs

@@ -822,7 +822,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "4.0.54" : "0.0.0-test";
+var VERSION = true ? "4.0.56" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -958,7 +958,9 @@ function isUrlSupported({
   return Object.entries(supportedUrls).map(([key, value]) => {
     const mediaType2 = key.toLowerCase();
     return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
-  }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
+  }).filter(
+    ({ mediaTypePrefix }) => mediaTypePrefix === "" || mediaTypePrefix.endsWith("/") ? mediaType.startsWith(mediaTypePrefix) : mediaType === mediaTypePrefix
+  ).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
 }
 
 // src/load-api-key.ts
@@ -3076,6 +3078,367 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/streaming-tool-call-tracker.ts
+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[nextStructure.stack.length - 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 = [];
+    this.toolCallsById = /* @__PURE__ */ new Map();
+    this.toolCallsByIndex = /* @__PURE__ */ new Map();
+    this.usedToolCallIds = /* @__PURE__ */ new Set();
+    this.nextGeneratedIdSuffixes = /* @__PURE__ */ new Map();
+    var _a2, _b2;
+    this.controller = controller;
+    this._generateId = (_a2 = options.generateId) != null ? _a2 : generateId;
+    this.typeValidation = (_b2 = options.typeValidation) != null ? _b2 : "none";
+    this.extractMetadata = options.extractMetadata;
+    this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
+  }
+  processDelta(toolCallDelta) {
+    var _a2, _b2;
+    const wireName = (_a2 = toolCallDelta.function) == null ? void 0 : _a2.name;
+    const hasBlankName = typeof wireName === "string" && wireName.trim().length === 0;
+    const wireId = this.getNonBlankString(toolCallDelta.id);
+    const name2 = this.getNonBlankString(wireName);
+    const { index } = toolCallDelta;
+    const resolution = this.resolveToolCall({
+      wireId,
+      index,
+      name: name2,
+      hasExplicitCallStart: name2 != null && startsWithStructuredValue((_b2 = toolCallDelta.function) == null ? void 0 : _b2.arguments)
+    });
+    if (resolution.kind === "ambiguous") {
+      return;
+    }
+    let toolCall;
+    if (resolution.kind === "new") {
+      if (hasBlankName) {
+        return;
+      }
+      toolCall = this.processNewToolCall(toolCallDelta, {
+        wireId,
+        index,
+        name: name2
+      });
+    } else {
+      toolCall = resolution.toolCall;
+      if (wireId != null) {
+        this.associateWireId(toolCall, wireId);
+      }
+      this.processExistingToolCall(toolCall, toolCallDelta);
+    }
+    if (index != null) {
+      this.associateIndex(toolCall, index);
+    }
+  }
+  flush() {
+    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);
+      }
+    }
+  }
+  resolveToolCall({
+    wireId,
+    index,
+    name: name2,
+    hasExplicitCallStart
+  }) {
+    const indexedToolCalls = index != null ? this.toolCallsByIndex.get(index) : void 0;
+    const matchingIndexedToolCalls = this.filterToolCallsByName(
+      indexedToolCalls,
+      name2
+    );
+    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 (name2 != null) {
+            return { kind: "new" };
+          }
+          if (indexedToolCalls != null) {
+            return { kind: "ambiguous" };
+          }
+          return this.resolveMatchingToolCall([...toolCallsWithId], false);
+        }
+        if (name2 != null) {
+          const matchingToolCalls = [...toolCallsWithId].filter(
+            (toolCall) => toolCall.function.name === name2
+          );
+          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 (name2 != 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, name2) {
+    if (toolCalls == null) {
+      return [];
+    }
+    return [...toolCalls].filter(
+      (toolCall) => name2 == null || toolCall.function.name === name2
+    );
+  }
+  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: name2
+  }) {
+    var _a2, _b2, _c, _d, _e;
+    if (this.typeValidation === "required") {
+      if (toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    } else if (this.typeValidation === "if-present") {
+      if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    }
+    if (name2 == 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,
+      toolName: name2
+    });
+    const toolCall = {
+      id,
+      index: index != null ? index : void 0,
+      sequence: this.toolCalls.length,
+      type: "function",
+      function: {
+        name: name2,
+        arguments: (_b2 = (_a2 = toolCallDelta.function) == null ? void 0 : _a2.arguments) != null ? _b2 : ""
+      },
+      argumentState: new StreamingToolCallArgumentState(
+        (_d = (_c = toolCallDelta.function) == null ? void 0 : _c.arguments) != null ? _d : ""
+      ),
+      hasFinished: false,
+      metadata: (_e = this.extractMetadata) == null ? void 0 : _e.call(this, toolCallDelta)
+    };
+    this.toolCalls.push(toolCall);
+    if (wireId != null) {
+      this.associateWireId(toolCall, wireId);
+    }
+    if (toolCall.function.arguments.length > 0) {
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCall.function.arguments
+      });
+    }
+    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) {
+    var _a2, _b2;
+    if (wireId != null && !this.usedToolCallIds.has(wireId)) {
+      this.usedToolCallIds.add(wireId);
+      return wireId;
+    }
+    const generatedId = (_a2 = this.getNonBlankString(this._generateId())) != null ? _a2 : "tool-call";
+    if (!this.usedToolCallIds.has(generatedId)) {
+      this.usedToolCallIds.add(generatedId);
+      return generatedId;
+    }
+    const initialSuffix = (_b2 = this.nextGeneratedIdSuffixes.get(generatedId)) != null ? _b2 : 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) {
+    var _a2;
+    if (!toolCall.hasFinished && ((_a2 = toolCallDelta.function) == null ? void 0 : _a2.arguments) != null) {
+      toolCall.argumentState.append(toolCallDelta.function.arguments);
+      toolCall.function.arguments += toolCallDelta.function.arguments;
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCallDelta.function.arguments
+      });
+    }
+  }
+  finishToolCall(toolCall) {
+    var _a2;
+    this.controller.enqueue({
+      type: "tool-input-end",
+      id: toolCall.id
+    });
+    const providerMetadata = (_a2 = this.buildToolCallProviderMetadata) == null ? void 0 : _a2.call(
+      this,
+      toolCall.metadata
+    );
+    this.controller.enqueue({
+      type: "tool-call",
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      input: toolCall.function.arguments,
+      ...providerMetadata ? { providerMetadata } : {}
+    });
+    toolCall.hasFinished = true;
+  }
+};
+
 // src/strip-file-extension.ts
 function stripFileExtension(filename) {
   const firstDotIndex = filename.indexOf(".");
@@ -3122,6 +3485,7 @@ export {
   EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
   EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER as EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
   EventSourceParserStream2 as EventSourceParserStream,
+  StreamingToolCallTracker,
   VERSION,
   asSchema,
   cancelResponseBody,