@ai-sdk/provider-utils 4.0.55 → 4.0.57

package/dist/index.mjs

@@ -248,6 +248,15 @@ function isBrowserRuntime(globalThisAny = globalThis) {
   return globalThisAny.window != null;
 }
 
+// src/is-same-origin.ts
+function isSameOrigin(url, baseUrl) {
+  try {
+    return new URL(url).origin === new URL(baseUrl).origin;
+  } catch (e) {
+    return false;
+  }
+}
+
 // src/validate-download-url.ts
 function validateDownloadUrl(url) {
   let parsed;
@@ -433,34 +442,24 @@ function createSafeLookup(lookup) {
   });
 }
 var safeNodeFetchPromise;
-var initialGlobalFetch = globalThis.fetch;
-var initialGlobalFetchIsNodeDefault = isNodeDefaultFetch(initialGlobalFetch);
 function isNodeRuntime() {
-  var _a2, _b2;
+  var _a2, _b2, _c;
   const runtimeProcess = globalThis.process;
-  return ((_a2 = runtimeProcess == null ? void 0 : runtimeProcess.release) == null ? void 0 : _a2.name) === "node" && ((_b2 = runtimeProcess.versions) == null ? void 0 : _b2.bun) == null;
+  return ((_a2 = runtimeProcess == null ? void 0 : runtimeProcess.release) == null ? void 0 : _a2.name) === "node" && ((_b2 = runtimeProcess.versions) == null ? void 0 : _b2.bun) == null && ((_c = runtimeProcess.versions) == null ? void 0 : _c.deno) == null && runtimeProcess.title !== "workerd" && globalThis.EdgeRuntime == null;
 }
 async function getDefaultDownloadFetch() {
-  if (!isNodeRuntime() || !initialGlobalFetchIsNodeDefault || globalThis.fetch !== initialGlobalFetch) {
+  if (!isNodeRuntime()) {
     return globalThis.fetch;
   }
   return safeNodeFetchPromise != null ? safeNodeFetchPromise : safeNodeFetchPromise = createSafeNodeFetch();
 }
-function isNodeDefaultFetch(fetch) {
-  if (typeof fetch !== "function") {
-    return false;
-  }
-  const source = Function.prototype.toString.call(fetch);
-  return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
-}
 async function createSafeNodeFetch() {
-  const [{ createRequire }, { lookup }] = await Promise.all([
+  const [module, { lookup }] = await Promise.all([
     loadNodeModule("node:module"),
     loadNodeModule("node:dns")
   ]);
-  const { Agent, fetch } = createRequire(getCurrentModulePath())(
-    "undici"
-  );
+  const nodeRequire = module.createRequire(getCurrentModulePath());
+  const { Agent, fetch } = nodeRequire("undici");
   const dispatcher = new Agent({
     connect: {
       lookup: createSafeLookup(lookup)
@@ -502,20 +501,47 @@ function getCurrentModulePath() {
 
 // src/fetch-with-validated-redirects.ts
 var MAX_DOWNLOAD_REDIRECTS = 10;
+async function getValidatedFetch(customFetch) {
+  return customFetch == null || customFetch === globalThis.fetch ? await getDefaultDownloadFetch() : customFetch;
+}
+async function fetchWithValidatedEndpoint({
+  url,
+  init,
+  fetch: customFetch,
+  trustedOrigin,
+  redirect = "error"
+}) {
+  const urlText = url.toString();
+  const isTrusted = trustedOrigin !== void 0 && isSameOrigin(urlText, trustedOrigin);
+  if (!isTrusted) {
+    validateDownloadUrl(urlText);
+  }
+  const fetch = isTrusted && customFetch != null ? customFetch : isTrusted ? globalThis.fetch : await getValidatedFetch(customFetch);
+  return await fetch(url, {
+    ...init,
+    redirect
+  });
+}
 async function fetchWithValidatedRedirects({
   url,
   headers,
   abortSignal,
-  maxRedirects = MAX_DOWNLOAD_REDIRECTS
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS,
+  fetch: customFetch,
+  trustedOrigin
 }) {
+  var _a2;
   const baseInit = { signal: abortSignal };
   if (headers !== void 0) {
     baseInit.headers = headers;
   }
   let currentUrl = url;
   for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
-    validateDownloadUrl(currentUrl);
-    const fetch = await getDefaultDownloadFetch();
+    const isTrustedHop = trustedOrigin !== void 0 && isSameOrigin(currentUrl, trustedOrigin);
+    if (!isTrustedHop) {
+      validateDownloadUrl(currentUrl);
+    }
+    const fetch = isTrustedHop && customFetch != null ? customFetch : isTrustedHop ? globalThis.fetch : await getValidatedFetch(customFetch);
     const response = await fetch(currentUrl, {
       ...baseInit,
       redirect: "manual"
@@ -529,7 +555,7 @@ async function fetchWithValidatedRedirects({
       }
       return await fetch(currentUrl, { ...baseInit, redirect: "follow" });
     }
-    const location = response.headers.get("location");
+    const location = (_a2 = response.headers) == null ? void 0 : _a2.get("location");
     if (response.status >= 300 && response.status < 400 && location) {
       await cancelResponseBody(response);
       currentUrl = new URL(location, currentUrl).toString();
@@ -822,7 +848,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "4.0.55" : "0.0.0-test";
+var VERSION = true ? "4.0.57" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -938,15 +964,6 @@ function isNonNullable(value) {
   return value != null;
 }
 
-// src/is-same-origin.ts
-function isSameOrigin(url, baseUrl) {
-  try {
-    return new URL(url).origin === new URL(baseUrl).origin;
-  } catch (e) {
-    return false;
-  }
-}
-
 // src/is-url-supported.ts
 function isUrlSupported({
   mediaType,
@@ -3078,6 +3095,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(".");
@@ -3124,6 +3502,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,
@@ -3148,6 +3527,7 @@ export {
   dynamicTool,
   executeTool,
   extractResponseHeaders,
+  fetchWithValidatedEndpoint,
   fetchWithValidatedRedirects,
   generateId,
   getErrorMessage,