maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime/node_modules/ai/dist/internal/index.js

@@ -0,0 +1,3690 @@
+// internal/index.ts
+import { convertAsyncIteratorToReadableStream } from "@ai-sdk/provider-utils";
+
+// src/util/async-iterable-stream.ts
+function createAsyncIterableStream(source) {
+  return asAsyncIterableStream(source.pipeThrough(new TransformStream()));
+}
+function asAsyncIterableStream(stream) {
+  stream[Symbol.asyncIterator] = function() {
+    const reader = this.getReader();
+    let finished = false;
+    async function cleanup(cancelStream) {
+      var _a12;
+      if (finished) return;
+      finished = true;
+      try {
+        if (cancelStream) {
+          await ((_a12 = reader.cancel) == null ? void 0 : _a12.call(reader));
+        }
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch (e) {
+        }
+      }
+    }
+    return {
+      /**
+       * Reads the next chunk from the stream.
+       * @returns A promise resolving to the next IteratorResult.
+       */
+      async next() {
+        if (finished) {
+          return { done: true, value: void 0 };
+        }
+        let result;
+        try {
+          result = await reader.read();
+        } catch (error) {
+          await cleanup(false);
+          throw error;
+        }
+        const { done, value } = result;
+        if (done) {
+          await cleanup(true);
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value };
+      },
+      /**
+       * May be called on early exit (e.g., break from for-await) or after completion.
+       * Ensures the stream is cancelled and resources are released.
+       * @returns A promise resolving to a completed IteratorResult.
+       */
+      async return() {
+        await cleanup(true);
+        return { done: true, value: void 0 };
+      },
+      /**
+       * Called on early exit with error.
+       * Ensures the stream is cancelled and resources are released, then rethrows the error.
+       * @param err The error to throw.
+       * @returns A promise that rejects with the provided error.
+       */
+      async throw(err) {
+        await cleanup(true);
+        throw err;
+      }
+    };
+  };
+  return stream;
+}
+
+// src/prompt/convert-to-language-model-prompt.ts
+import {
+  asArray,
+  detectMediaType,
+  isFullMediaType,
+  isUrlSupported
+} from "@ai-sdk/provider-utils";
+
+// src/util/download/download.ts
+import {
+  cancelResponseBody,
+  DownloadError,
+  readResponseWithSizeLimit,
+  DEFAULT_MAX_DOWNLOAD_SIZE,
+  fetchWithValidatedRedirects,
+  withUserAgentSuffix,
+  getRuntimeEnvironmentUserAgent
+} from "@ai-sdk/provider-utils";
+
+// src/version.ts
+var VERSION = true ? "7.0.99" : "0.0.0-test";
+
+// src/util/download/download.ts
+var download = async ({
+  url,
+  maxBytes,
+  abortSignal
+}) => {
+  var _a12;
+  const urlText = url.toString();
+  try {
+    const headers = withUserAgentSuffix(
+      {},
+      `ai-sdk/${VERSION}`,
+      getRuntimeEnvironmentUserAgent()
+    );
+    const response = await fetchWithValidatedRedirects({
+      url: urlText,
+      headers,
+      abortSignal
+    });
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data = await readResponseWithSizeLimit({
+      response,
+      url: urlText,
+      maxBytes: maxBytes != null ? maxBytes : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    return {
+      data,
+      mediaType: (_a12 = response.headers.get("content-type")) != null ? _a12 : void 0
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+};
+
+// src/util/download/download-function.ts
+var createDefaultDownloadFunction = (download2 = download) => (requestedDownloads) => Promise.all(
+  requestedDownloads.map(
+    async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : await download2(requestedDownload)
+  )
+);
+
+// src/util/merge-objects.ts
+function mergeObjects(base, overrides) {
+  if (base === void 0 && overrides === void 0) {
+    return void 0;
+  }
+  if (base === void 0) {
+    return overrides;
+  }
+  if (overrides === void 0) {
+    return base;
+  }
+  const result = { ...base };
+  for (const key in overrides) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
+      const overridesValue = overrides[key];
+      if (overridesValue === void 0) continue;
+      const baseValue = key in base ? base[key] : void 0;
+      const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
+      const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
+      if (isSourceObject && isTargetObject) {
+        result[key] = mergeObjects(
+          baseValue,
+          overridesValue
+        );
+      } else {
+        result[key] = overridesValue;
+      }
+    }
+  }
+  return result;
+}
+
+// src/prompt/file-part-data.ts
+import {
+  isBuffer,
+  isProviderReference
+} from "@ai-sdk/provider-utils";
+
+// src/prompt/invalid-data-content-error.ts
+import { AISDKError } from "@ai-sdk/provider";
+var name = "AI_InvalidDataContentError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a, _b;
+var InvalidDataContentError = class extends (_b = AISDKError, _a = symbol, _b) {
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  }) {
+    super({ name, message, cause });
+    this[_a] = true;
+    this.content = content;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker);
+  }
+};
+
+// src/prompt/split-data-url.ts
+function splitDataUrl(dataUrl) {
+  try {
+    const [header, base64Content] = dataUrl.split(",");
+    return {
+      mediaType: header.split(";")[0].split(":")[1],
+      base64Content
+    };
+  } catch (e) {
+    return {
+      mediaType: void 0,
+      base64Content: void 0
+    };
+  }
+}
+
+// src/prompt/file-part-data.ts
+function isTaggedFileData(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const type = value.type;
+  return type === "data" || type === "url" || type === "reference" || type === "text";
+}
+function convertUrlToFilePartData(url) {
+  if (url.protocol === "data:") {
+    const { mediaType, base64Content } = splitDataUrl(url.toString());
+    if (mediaType == null || base64Content == null) {
+      throw new InvalidDataContentError({
+        content: url,
+        message: `Invalid data URL format in content ${url.toString()}`
+      });
+    }
+    return { data: { type: "data", data: base64Content }, mediaType };
+  }
+  return { data: { type: "url", url }, mediaType: void 0 };
+}
+function convertInlineDataToFilePartData(content) {
+  if (content instanceof Uint8Array) {
+    return { data: { type: "data", data: content }, mediaType: void 0 };
+  }
+  if (content instanceof ArrayBuffer) {
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
+  }
+  if (isBuffer(content)) {
+    return {
+      data: { type: "data", data: new Uint8Array(content) },
+      mediaType: void 0
+    };
+  }
+  return {
+    data: { type: "data", data: content },
+    mediaType: void 0
+  };
+}
+function convertToLanguageModelV4FilePart(content) {
+  if (isTaggedFileData(content)) {
+    switch (content.type) {
+      case "data":
+        if (typeof content.data === "string" && content.data.startsWith("data:")) {
+          throw new InvalidDataContentError({
+            content: content.data,
+            message: 'Data URLs are not valid inline data. Pass them as { type: "url", url } instead.'
+          });
+        }
+        return convertInlineDataToFilePartData(content.data);
+      case "url":
+        return convertUrlToFilePartData(content.url);
+      case "reference":
+        return {
+          data: { type: "reference", reference: content.reference },
+          mediaType: void 0
+        };
+      case "text":
+        return {
+          data: { type: "text", text: content.text },
+          mediaType: void 0
+        };
+    }
+  }
+  if (content instanceof URL) {
+    return convertUrlToFilePartData(content);
+  }
+  if (typeof content === "string") {
+    try {
+      return convertUrlToFilePartData(new URL(content));
+    } catch (e) {
+      return convertInlineDataToFilePartData(content);
+    }
+  }
+  if (isProviderReference(content)) {
+    return {
+      data: { type: "reference", reference: content },
+      mediaType: void 0
+    };
+  }
+  return convertInlineDataToFilePartData(content);
+}
+
+// src/logger/log-warnings.ts
+function formatWarning({
+  warning,
+  provider,
+  model
+}) {
+  const scope = provider != null && model != null ? ` (${provider} / ${model})` : "";
+  const prefix = `AI SDK Warning${scope}:`;
+  switch (warning.type) {
+    case "unsupported": {
+      let message = `${prefix} The feature "${warning.feature}" is not supported.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+    case "compatibility": {
+      let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
+      if (warning.details) {
+        message += ` ${warning.details}`;
+      }
+      return message;
+    }
+    case "deprecated": {
+      return `${prefix} Deprecated: "${warning.setting}". ${warning.message}`;
+    }
+    case "other": {
+      return `${prefix} ${warning.message}`;
+    }
+    default: {
+      return `${prefix} ${JSON.stringify(warning, null, 2)}`;
+    }
+  }
+}
+var FIRST_WARNING_INFO_MESSAGE = "AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.";
+var hasLoggedBefore = false;
+function emitWarning({
+  message,
+  type
+}) {
+  if (typeof process !== "undefined" && typeof process.emitWarning === "function") {
+    process.emitWarning(message, { type });
+  } else {
+    console.warn(message);
+  }
+}
+var logWarnings = (options) => {
+  if (options.warnings.length === 0) {
+    return;
+  }
+  const logger = globalThis.AI_SDK_LOG_WARNINGS;
+  if (logger === false) {
+    return;
+  }
+  if (typeof logger === "function") {
+    logger(options);
+    return;
+  }
+  if (!hasLoggedBefore) {
+    hasLoggedBefore = true;
+    emitWarning({
+      message: FIRST_WARNING_INFO_MESSAGE,
+      type: "Warning"
+    });
+  }
+  for (const warning of options.warnings) {
+    const message = formatWarning({
+      warning,
+      provider: options.provider,
+      model: options.model
+    });
+    emitWarning({
+      message,
+      type: warning.type === "deprecated" ? "DeprecationWarning" : "Warning"
+    });
+  }
+};
+
+// src/prompt/invalid-message-role-error.ts
+import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
+var name2 = "AI_InvalidMessageRoleError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2, _b2;
+var InvalidMessageRoleError = class extends (_b2 = AISDKError2, _a2 = symbol2, _b2) {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name2, message });
+    this[_a2] = true;
+    this.role = role;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker2);
+  }
+};
+
+// src/error/missing-tool-result-error.ts
+import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
+var name3 = "AI_MissingToolResultsError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3, _b3;
+var MissingToolResultsError = class extends (_b3 = AISDKError3, _a3 = symbol3, _b3) {
+  constructor({ toolCallIds }) {
+    super({
+      name: name3,
+      message: `Tool result${toolCallIds.length > 1 ? "s are" : " is"} missing for tool call${toolCallIds.length > 1 ? "s" : ""} ${toolCallIds.join(
+        ", "
+      )}.`
+    });
+    this[_a3] = true;
+    this.toolCallIds = toolCallIds;
+  }
+  static isInstance(error) {
+    return AISDKError3.hasMarker(error, marker3);
+  }
+};
+
+// src/prompt/convert-to-language-model-prompt.ts
+async function convertToLanguageModelPrompt({
+  prompt,
+  supportedUrls,
+  download: download2 = createDefaultDownloadFunction(),
+  // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
+  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
+  provider
+}) {
+  const downloadedAssets = await downloadAssets(
+    prompt.messages,
+    download2,
+    supportedUrls
+  );
+  const approvalIdToToolCallId = /* @__PURE__ */ new Map();
+  for (const message of prompt.messages) {
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type === "tool-approval-request" && "approvalId" in part && "toolCallId" in part) {
+          approvalIdToToolCallId.set(
+            part.approvalId,
+            part.toolCallId
+          );
+        }
+      }
+    }
+  }
+  const approvedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of prompt.messages) {
+    if (message.role === "tool") {
+      for (const part of message.content) {
+        if (part.type === "tool-approval-response") {
+          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
+          if (toolCallId) {
+            approvedToolCallIds.add(toolCallId);
+          }
+        }
+      }
+    }
+  }
+  const messages = [
+    ...prompt.instructions != null ? typeof prompt.instructions === "string" ? [{ role: "system", content: prompt.instructions }] : asArray(prompt.instructions).map((message) => ({
+      role: "system",
+      content: message.content,
+      providerOptions: message.providerOptions
+    })) : [],
+    ...prompt.messages.map(
+      (message) => convertToLanguageModelMessage({ message, downloadedAssets, provider })
+    )
+  ];
+  const combinedMessages = [];
+  for (const message of messages) {
+    if (message.role !== "tool") {
+      combinedMessages.push(message);
+      continue;
+    }
+    const lastCombinedMessage = combinedMessages.at(-1);
+    if ((lastCombinedMessage == null ? void 0 : lastCombinedMessage.role) === "tool") {
+      const lastContentPart = lastCombinedMessage.content.at(-1);
+      if (lastContentPart != null && lastCombinedMessage.providerOptions != null) {
+        lastContentPart.providerOptions = mergeObjects(
+          lastCombinedMessage.providerOptions,
+          lastContentPart.providerOptions
+        );
+      }
+      lastCombinedMessage.content.push(...message.content);
+      lastCombinedMessage.providerOptions = message.providerOptions;
+    } else {
+      combinedMessages.push(message);
+    }
+  }
+  const toolCallIds = /* @__PURE__ */ new Set();
+  for (const message of combinedMessages) {
+    switch (message.role) {
+      case "assistant": {
+        for (const content of message.content) {
+          if (content.type === "tool-call" && !content.providerExecuted) {
+            toolCallIds.add(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const content of message.content) {
+          if (content.type === "tool-result") {
+            toolCallIds.delete(content.toolCallId);
+          }
+        }
+        break;
+      }
+      case "user":
+      case "system":
+        for (const id of approvedToolCallIds) {
+          toolCallIds.delete(id);
+        }
+        if (toolCallIds.size > 0) {
+          throw new MissingToolResultsError({
+            toolCallIds: Array.from(toolCallIds)
+          });
+        }
+        break;
+    }
+  }
+  for (const id of approvedToolCallIds) {
+    toolCallIds.delete(id);
+  }
+  if (toolCallIds.size > 0) {
+    throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
+  }
+  return combinedMessages.filter(
+    // Filter out empty tool messages (e.g. if they only contained
+    // tool-approval-response parts that were removed).
+    // This prevents sending invalid empty messages to the provider.
+    // Note: provider-executed tool-approval-response parts are preserved.
+    (message) => message.role !== "tool" || message.content.length > 0
+  );
+}
+function convertToLanguageModelMessage({
+  message,
+  downloadedAssets,
+  // `provider` is only needed here to convert legacy tool output types via `mapToolResultOutput`.
+  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
+  provider
+}) {
+  const warnings = [];
+  const role = message.role;
+  switch (role) {
+    case "system": {
+      return {
+        role: "system",
+        content: message.content,
+        providerOptions: message.providerOptions
+      };
+    }
+    case "user": {
+      if (typeof message.content === "string") {
+        return {
+          role: "user",
+          content: [{ type: "text", text: message.content }],
+          providerOptions: message.providerOptions
+        };
+      }
+      const converted = {
+        role: "user",
+        content: message.content.map((part) => {
+          if (part.type === "image") {
+            warnings.push({
+              type: "deprecated",
+              setting: '"image" content part',
+              message: `The "image" content part type is deprecated. Use a "file" part with mediaType: 'image' (or a more specific image/* subtype) instead.`
+            });
+          }
+          return convertImagePartToFilePart(part);
+        }).map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
+        providerOptions: message.providerOptions
+      };
+      if (warnings.length > 0) {
+        logWarnings({ warnings });
+      }
+      return converted;
+    }
+    case "assistant": {
+      if (typeof message.content === "string") {
+        return {
+          role: "assistant",
+          content: [{ type: "text", text: message.content }],
+          providerOptions: message.providerOptions
+        };
+      }
+      const converted = {
+        role: "assistant",
+        content: message.content.filter(
+          // remove empty text parts (no text, and no provider options):
+          (part) => part.type !== "text" || part.text !== "" || part.providerOptions != null
+        ).filter(
+          (part) => part.type !== "tool-approval-request"
+        ).map((part) => {
+          const providerOptions = part.providerOptions;
+          switch (part.type) {
+            case "custom": {
+              return {
+                type: "custom",
+                kind: part.kind,
+                providerOptions
+              };
+            }
+            case "file": {
+              const { data, mediaType } = convertToLanguageModelV4FilePart(
+                part.data
+              );
+              return {
+                type: "file",
+                data,
+                filename: part.filename,
+                mediaType: mediaType != null ? mediaType : part.mediaType,
+                providerOptions
+              };
+            }
+            case "reasoning": {
+              return {
+                type: "reasoning",
+                text: part.text,
+                providerOptions
+              };
+            }
+            case "reasoning-file": {
+              const { data, mediaType } = convertToLanguageModelV4FilePart(
+                part.data
+              );
+              if (data.type !== "data" && data.type !== "url") {
+                throw new Error(
+                  `Unsupported reasoning-file data type: ${data.type}`
+                );
+              }
+              return {
+                type: "reasoning-file",
+                data,
+                mediaType: mediaType != null ? mediaType : part.mediaType,
+                providerOptions
+              };
+            }
+            case "text": {
+              return {
+                type: "text",
+                text: part.text,
+                providerOptions
+              };
+            }
+            case "tool-call": {
+              return {
+                type: "tool-call",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+                providerExecuted: part.providerExecuted,
+                providerOptions
+              };
+            }
+            case "tool-result": {
+              return {
+                type: "tool-result",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                output: mapToolResultOutput({
+                  output: part.output,
+                  provider,
+                  warnings,
+                  downloadedAssets
+                }),
+                providerOptions
+              };
+            }
+          }
+        }),
+        providerOptions: message.providerOptions
+      };
+      if (warnings.length > 0) {
+        logWarnings({ warnings });
+      }
+      return converted;
+    }
+    case "tool": {
+      const converted = {
+        role: "tool",
+        content: message.content.filter(
+          // Only include tool-approval-response for provider-executed tools
+          (part) => part.type !== "tool-approval-response" || part.providerExecuted
+        ).map((part) => {
+          switch (part.type) {
+            case "tool-result": {
+              return {
+                type: "tool-result",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                output: mapToolResultOutput({
+                  output: part.output,
+                  provider,
+                  warnings,
+                  downloadedAssets
+                }),
+                providerOptions: part.providerOptions
+              };
+            }
+            case "tool-approval-response": {
+              return {
+                type: "tool-approval-response",
+                approvalId: part.approvalId,
+                approved: part.approved,
+                reason: part.reason
+              };
+            }
+          }
+        }),
+        providerOptions: message.providerOptions
+      };
+      if (warnings.length > 0) {
+        logWarnings({ warnings });
+      }
+      return converted;
+    }
+    default: {
+      const _exhaustiveCheck = role;
+      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
+    }
+  }
+}
+function convertImagePartToFilePart(part) {
+  var _a12;
+  if (part.type !== "image") {
+    return part;
+  }
+  return {
+    type: "file",
+    data: part.image,
+    mediaType: (_a12 = part.mediaType) != null ? _a12 : "image",
+    providerOptions: part.providerOptions
+  };
+}
+async function downloadAssets(messages, download2, supportedUrls) {
+  const downloadableFiles = [];
+  for (const message of messages) {
+    if (message.role === "user" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        const filePart = convertImagePartToFilePart(part);
+        if (filePart.type === "file") {
+          downloadableFiles.push(filePart);
+        }
+      }
+    }
+    if (message.role === "tool") {
+      for (const part of message.content) {
+        if (part.type !== "tool-result") {
+          continue;
+        }
+        if (part.output.type !== "content") {
+          continue;
+        }
+        for (const contentPart of part.output.value) {
+          if (contentPart.type === "file") {
+            downloadableFiles.push(contentPart);
+          }
+        }
+      }
+    }
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content) {
+        if (part.type !== "tool-result") {
+          continue;
+        }
+        if (part.output.type !== "content") {
+          continue;
+        }
+        for (const contentPart of part.output.value) {
+          if (contentPart.type === "file") {
+            downloadableFiles.push(contentPart);
+          }
+        }
+      }
+    }
+  }
+  const plannedDownloads = downloadableFiles.map((part) => {
+    const mediaType = part.mediaType;
+    const { data } = convertToLanguageModelV4FilePart(part.data);
+    return { mediaType, data };
+  }).filter((part) => part.data.type === "url").map((part) => ({
+    url: part.data.url,
+    isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
+      url: part.data.url.toString(),
+      mediaType: part.mediaType,
+      supportedUrls
+    })
+  }));
+  const downloadedFiles = await download2(plannedDownloads);
+  return Object.fromEntries(
+    downloadedFiles.map(
+      (file, index) => file == null ? null : [
+        plannedDownloads[index].url.toString(),
+        { data: file.data, mediaType: file.mediaType }
+      ]
+    ).filter((file) => file != null)
+  );
+}
+function convertPartToLanguageModelPart(part, downloadedAssets) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text,
+      providerOptions: part.providerOptions
+    };
+  }
+  const { data: normalizedData, mediaType: dataUrlMediaType } = convertToLanguageModelV4FilePart(part.data);
+  let mediaType = dataUrlMediaType != null ? dataUrlMediaType : part.mediaType;
+  let data = normalizedData;
+  if (data.type === "url") {
+    const downloadedFile = downloadedAssets[data.url.toString()];
+    if (downloadedFile) {
+      data = { type: "data", data: downloadedFile.data };
+      if (downloadedFile.mediaType != null && (mediaType == null || !isFullMediaType(mediaType))) {
+        mediaType = downloadedFile.mediaType;
+      }
+    }
+  }
+  if (data.type === "data" && (data.data instanceof Uint8Array || typeof data.data === "string")) {
+    const imageMediaType = detectMediaType({
+      data: data.data,
+      topLevelType: "image"
+    });
+    if (imageMediaType != null) {
+      mediaType = imageMediaType;
+    }
+  }
+  if (mediaType == null) {
+    throw new Error(`Media type is missing for file part`);
+  }
+  return {
+    type: "file",
+    mediaType,
+    filename: part.filename,
+    data,
+    providerOptions: part.providerOptions
+  };
+}
+function mapToolResultOutput({
+  output,
+  // `provider` is only needed here to convert legacy "file-id" and "image-file-id" types to provider references, in case they are using string ID values.
+  // TODO: remove in v8 when "file-id" and "image-file-id" types are removed
+  provider,
+  warnings = [],
+  downloadedAssets
+}) {
+  if (output.type !== "content") {
+    return output;
+  }
+  return {
+    type: "content",
+    value: output.value.map((item) => {
+      var _a12;
+      switch (item.type) {
+        case "file": {
+          const convertedPart = convertPartToLanguageModelPart(
+            item,
+            downloadedAssets
+          );
+          if (convertedPart.type !== "file") {
+            throw new Error(
+              "Expected tool result file content to convert to file."
+            );
+          }
+          return convertedPart;
+        }
+        case "file-data": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "file-data"',
+            message: `The "file-data" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'data', data } instead.`
+          });
+          return {
+            type: "file",
+            data: { type: "data", data: item.data },
+            filename: item.filename,
+            mediaType: item.mediaType,
+            providerOptions: item.providerOptions
+          };
+        }
+        case "file-url": {
+          const mediaType = (_a12 = item.mediaType) != null ? _a12 : getMediaTypeFromUrl(item.url);
+          let message = `The "file-url" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'url', url } instead.`;
+          if (!item.mediaType) {
+            const inferenceSuffix = mediaType === "application/octet-stream" ? `Unable to infer media type from URL. Defaulting to 'application/octet-stream'.` : `Inferred media type '${mediaType}' from URL.`;
+            message = `The "file-url" tool result content part with URL "${item.url}" is missing a "mediaType". ${inferenceSuffix} ${message}`;
+          }
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "file-url"',
+            message
+          });
+          return {
+            type: "file",
+            data: { type: "url", url: new URL(item.url) },
+            mediaType,
+            providerOptions: item.providerOptions
+          };
+        }
+        case "file-id": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "file-id"',
+            message: `The "file-id" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'reference', reference } instead.`
+          });
+          return {
+            type: "file",
+            data: {
+              type: "reference",
+              reference: convertFileIdToProviderReference({
+                fileId: item.fileId,
+                provider
+              })
+            },
+            mediaType: "application",
+            providerOptions: item.providerOptions
+          };
+        }
+        case "file-reference": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "file-reference"',
+            message: `The "file-reference" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'reference', reference } instead.`
+          });
+          return {
+            type: "file",
+            data: {
+              type: "reference",
+              reference: item.providerReference
+            },
+            mediaType: "application",
+            providerOptions: item.providerOptions
+          };
+        }
+        // The "image-*" types are legacy and deprecated.
+        // TODO: remove migration in v8 in combination with the removal of these types from the provider utils.
+        case "image-data": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "image-data"',
+            message: `The "image-data" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'data', data } instead.`
+          });
+          return {
+            type: "file",
+            data: { type: "data", data: item.data },
+            mediaType: item.mediaType,
+            providerOptions: item.providerOptions
+          };
+        }
+        case "image-url": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "image-url"',
+            message: `The "image-url" type for tool result content is deprecated. Use the "file" type with mediaType 'image' (or a specific image/* subtype) and { type: 'url', url } instead.`
+          });
+          return {
+            type: "file",
+            data: { type: "url", url: new URL(item.url) },
+            mediaType: "image",
+            providerOptions: item.providerOptions
+          };
+        }
+        case "image-file-id": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "image-file-id"',
+            message: `The "image-file-id" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'reference', reference } instead.`
+          });
+          return {
+            type: "file",
+            data: {
+              type: "reference",
+              reference: convertFileIdToProviderReference({
+                fileId: item.fileId,
+                provider
+              })
+            },
+            mediaType: "image",
+            providerOptions: item.providerOptions
+          };
+        }
+        case "image-file-reference": {
+          warnings.push({
+            type: "deprecated",
+            setting: '"tool-result" content of type "image-file-reference"',
+            message: `The "image-file-reference" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'reference', reference } instead.`
+          });
+          return {
+            type: "file",
+            data: {
+              type: "reference",
+              reference: item.providerReference
+            },
+            mediaType: "image",
+            providerOptions: item.providerOptions
+          };
+        }
+        default:
+          return item;
+      }
+    })
+  };
+}
+function convertFileIdToProviderReference({
+  fileId,
+  provider
+}) {
+  if (typeof fileId === "object") {
+    return fileId;
+  }
+  if (provider == null) {
+    throw new Error(
+      "Cannot convert string fileId to provider reference without a provider ID. Use a Record<string, string> fileId or switch to the file-reference type."
+    );
+  }
+  return { [provider]: fileId };
+}
+var URL_EXTENSION_TO_MEDIA_TYPE = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  avif: "image/avif",
+  heic: "image/heic",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg"
+};
+function getMediaTypeFromUrl(url, fallbackMediaType = "application/octet-stream") {
+  var _a12;
+  try {
+    const pathname = new URL(url).pathname;
+    const fileExtension = (_a12 = pathname.split(".").pop()) == null ? void 0 : _a12.toLowerCase();
+    if (fileExtension && Object.hasOwn(URL_EXTENSION_TO_MEDIA_TYPE, fileExtension)) {
+      return URL_EXTENSION_TO_MEDIA_TYPE[fileExtension];
+    }
+  } catch (e) {
+  }
+  return fallbackMediaType;
+}
+
+// src/prompt/create-tool-model-output.ts
+import { getErrorMessage } from "@ai-sdk/provider";
+async function createToolModelOutput({
+  toolCallId,
+  input,
+  output,
+  tool,
+  errorMode
+}) {
+  if (errorMode === "text") {
+    return { type: "error-text", value: getErrorMessage(output) };
+  } else if (errorMode === "json") {
+    return { type: "error-json", value: toJSONValue(output) };
+  }
+  if (tool == null ? void 0 : tool.toModelOutput) {
+    return await tool.toModelOutput({ toolCallId, input, output });
+  }
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
+}
+function toJSONValue(value) {
+  return value === void 0 ? null : value;
+}
+
+// src/prompt/prepare-tool-choice.ts
+function prepareToolChoice({
+  toolChoice
+}) {
+  return toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName };
+}
+
+// src/prompt/prepare-tools.ts
+import {
+  asSchema
+} from "@ai-sdk/provider-utils";
+
+// src/util/is-non-empty-object.ts
+function isNonEmptyObject(object2) {
+  return object2 != null && Object.keys(object2).length > 0;
+}
+
+// src/prompt/prepare-tools.ts
+async function prepareTools({
+  tools,
+  toolOrder,
+  toolsContext = {},
+  experimental_sandbox: sandbox
+}) {
+  if (!isNonEmptyObject(tools)) {
+    return void 0;
+  }
+  const languageModelTools = [];
+  for (const [name12, tool] of orderToolEntries({ tools, toolOrder })) {
+    const toolType = tool.type;
+    switch (toolType) {
+      case void 0:
+      case "dynamic":
+      case "function": {
+        const description = resolveToolDescription({
+          tool,
+          toolName: name12,
+          toolsContext,
+          experimental_sandbox: sandbox
+        });
+        const providerOptions = tool.providerOptions;
+        const inputExamples = tool.inputExamples;
+        const strict = tool.strict;
+        languageModelTools.push({
+          type: "function",
+          name: name12,
+          inputSchema: await asSchema(tool.inputSchema).jsonSchema,
+          ...description != null ? { description } : {},
+          ...inputExamples != null ? { inputExamples } : {},
+          ...providerOptions != null ? { providerOptions } : {},
+          ...strict != null ? { strict } : {}
+        });
+        break;
+      }
+      case "provider": {
+        languageModelTools.push({
+          type: "provider",
+          name: name12,
+          id: tool.id,
+          args: tool.args
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck = toolType;
+        throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+      }
+    }
+  }
+  return languageModelTools;
+}
+function orderToolEntries({
+  tools,
+  toolOrder
+}) {
+  if (toolOrder == null) {
+    return Object.entries(tools);
+  }
+  const toolEntries = Object.entries(tools);
+  const orderedTools = toolEntries.filter(([name12]) => toolOrder.includes(name12)).sort(
+    ([nameA], [nameB]) => toolOrder.indexOf(nameA) - toolOrder.indexOf(nameB)
+  );
+  const unorderedTools = toolEntries.filter(([name12]) => !toolOrder.includes(name12)).sort(([nameA], [nameB]) => nameA < nameB ? -1 : nameA > nameB ? 1 : 0);
+  return [...orderedTools, ...unorderedTools];
+}
+function resolveToolDescription({
+  tool,
+  toolName,
+  toolsContext,
+  experimental_sandbox: sandbox
+}) {
+  return tool.description === void 0 ? void 0 : typeof tool.description === "string" ? tool.description : tool.description({
+    context: toolsContext[toolName],
+    experimental_sandbox: sandbox
+  });
+}
+
+// src/prompt/standardize-prompt.ts
+import { InvalidPromptError } from "@ai-sdk/provider";
+import {
+  asArray as asArray2,
+  safeValidateTypes
+} from "@ai-sdk/provider-utils";
+
+// src/util/zod.ts
+import {
+  array,
+  boolean,
+  custom,
+  discriminatedUnion,
+  enum as enumType,
+  instanceof as instanceOf,
+  lazy,
+  literal,
+  looseObject,
+  never,
+  null as nullType,
+  number,
+  object,
+  record,
+  string,
+  union,
+  unknown
+} from "zod/v4";
+var z = {
+  array,
+  boolean,
+  custom,
+  discriminatedUnion,
+  enum: enumType,
+  instanceof: instanceOf,
+  lazy,
+  literal,
+  looseObject,
+  never,
+  null: nullType,
+  number,
+  object,
+  record,
+  string,
+  union,
+  unknown
+};
+
+// src/types/json-value.ts
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.record(z.string(), jsonValueSchema.optional()),
+    z.array(jsonValueSchema)
+  ])
+);
+
+// src/types/provider-metadata.ts
+var providerMetadataSchema = z.record(
+  z.string(),
+  z.record(z.string(), jsonValueSchema.optional())
+);
+
+// src/prompt/content-part.ts
+import {
+  isBuffer as isBuffer2
+} from "@ai-sdk/provider-utils";
+var fileInlineDataSchema = z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom(isBuffer2, { message: "Must be a Buffer" })
+]);
+var providerReferenceSchema = z.record(z.string(), z.string());
+var textPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var imagePartSchema = z.object({
+  type: z.literal("image"),
+  image: z.union([
+    fileInlineDataSchema,
+    z.instanceof(URL),
+    providerReferenceSchema
+  ]),
+  mediaType: z.string().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var taggedFileDataSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("data"), data: fileInlineDataSchema }),
+  z.object({ type: z.literal("url"), url: z.instanceof(URL) }),
+  z.object({
+    type: z.literal("reference"),
+    reference: providerReferenceSchema
+  }),
+  z.object({ type: z.literal("text"), text: z.string() })
+]);
+var taggedReasoningFileDataSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("data"), data: fileInlineDataSchema }),
+  z.object({ type: z.literal("url"), url: z.instanceof(URL) })
+]);
+var filePartSchema = z.object({
+  type: z.literal("file"),
+  data: z.union([
+    taggedFileDataSchema,
+    fileInlineDataSchema,
+    z.instanceof(URL),
+    providerReferenceSchema
+  ]),
+  filename: z.string().optional(),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningPartSchema = z.object({
+  type: z.literal("reasoning"),
+  text: z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var customPartSchema = z.object({
+  type: z.literal("custom"),
+  kind: z.string().transform((value) => value),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningFilePartSchema = z.object({
+  type: z.literal("reasoning-file"),
+  data: z.union([
+    taggedReasoningFileDataSchema,
+    fileInlineDataSchema,
+    z.instanceof(URL)
+  ]),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = z.object({
+  type: z.literal("tool-call"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: z.boolean().optional()
+});
+var outputSchema = z.discriminatedUnion(
+  "type",
+  [
+    z.object({
+      type: z.literal("text"),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z.object({
+      type: z.literal("json"),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z.object({
+      type: z.literal("execution-denied"),
+      reason: z.string().optional(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z.object({
+      type: z.literal("error-text"),
+      value: z.string(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z.object({
+      type: z.literal("error-json"),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z.object({
+      type: z.literal("content"),
+      value: z.array(
+        z.union([
+          z.object({
+            type: z.literal("text"),
+            text: z.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            type: z.literal("file"),
+            data: taggedFileDataSchema,
+            mediaType: z.string(),
+            filename: z.string().optional(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("file-data"),
+            data: z.string(),
+            mediaType: z.string(),
+            filename: z.string().optional(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("file-url"),
+            url: z.string(),
+            mediaType: z.string().optional(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("file-id"),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("file-reference"),
+            providerReference: z.record(z.string(), z.string()),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("image-data"),
+            data: z.string(),
+            mediaType: z.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("image-url"),
+            url: z.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("image-file-id"),
+            fileId: z.union([z.string(), z.record(z.string(), z.string())]),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            // Deprecated.
+            type: z.literal("image-file-reference"),
+            providerReference: z.record(z.string(), z.string()),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z.object({
+            type: z.literal("custom"),
+            providerOptions: providerMetadataSchema.optional()
+          })
+        ])
+      )
+    })
+  ]
+);
+var toolResultPartSchema = z.object({
+  type: z.literal("tool-result"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolApprovalRequestSchema = z.object(
+  {
+    type: z.literal("tool-approval-request"),
+    approvalId: z.string(),
+    toolCallId: z.string(),
+    reason: z.string().optional()
+  }
+);
+var toolApprovalResponseSchema = z.object({
+  type: z.literal("tool-approval-response"),
+  approvalId: z.string(),
+  approved: z.boolean(),
+  reason: z.string().optional()
+});
+
+// src/prompt/message.ts
+var systemModelMessageSchema = z.object({
+  role: z.literal("system"),
+  content: z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var userModelMessageSchema = z.object({
+  role: z.literal("user"),
+  content: z.union([
+    z.string(),
+    z.array(z.union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var assistantModelMessageSchema = z.object({
+  role: z.literal("assistant"),
+  content: z.union([
+    z.string(),
+    z.array(
+      z.union([
+        textPartSchema,
+        customPartSchema,
+        filePartSchema,
+        reasoningPartSchema,
+        reasoningFilePartSchema,
+        toolCallPartSchema,
+        toolResultPartSchema,
+        toolApprovalRequestSchema
+      ])
+    )
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolModelMessageSchema = z.object({
+  role: z.literal("tool"),
+  content: z.array(z.union([toolResultPartSchema, toolApprovalResponseSchema])),
+  providerOptions: providerMetadataSchema.optional()
+});
+var modelMessageSchema = z.union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema
+]);
+
+// src/prompt/standardize-prompt.ts
+async function standardizePrompt({
+  allowSystemInMessages = false,
+  system,
+  instructions = system,
+  prompt,
+  messages
+}) {
+  if (prompt == null && messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (prompt != null && messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  if (typeof instructions !== "string" && !asArray2(instructions).every((message) => message.role === "system")) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "instructions must be a string, SystemModelMessage, or array of SystemModelMessage"
+    });
+  }
+  if (prompt != null && typeof prompt === "string") {
+    messages = [{ role: "user", content: prompt }];
+  } else if (prompt != null && Array.isArray(prompt)) {
+    messages = prompt;
+  } else if (messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (messages.length === 0) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "messages must not be empty"
+    });
+  }
+  if (!allowSystemInMessages && messages.some((message) => message.role === "system")) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "System messages are not allowed in the prompt or messages fields. Use the instructions option instead."
+    });
+  }
+  const validationResult = await safeValidateTypes({
+    value: messages,
+    schema: z.array(modelMessageSchema)
+  });
+  if (!validationResult.success) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "The messages do not match the ModelMessage[] schema.",
+      cause: validationResult.error
+    });
+  }
+  return { messages, instructions };
+}
+
+// src/error/invalid-argument-error.ts
+import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
+var name4 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4, _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError4, _a4 = symbol4, _b4) {
+  constructor({
+    parameter,
+    value,
+    message
+  }) {
+    super({
+      name: name4,
+      message: `Invalid argument for parameter ${parameter}: ${message}`
+    });
+    this[_a4] = true;
+    this.parameter = parameter;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError4.hasMarker(error, marker4);
+  }
+};
+
+// src/prompt/prepare-language-model-call-options.ts
+function prepareLanguageModelCallOptions({
+  maxOutputTokens,
+  temperature,
+  topP,
+  topK,
+  presencePenalty,
+  frequencyPenalty,
+  seed,
+  stopSequences,
+  reasoning
+}) {
+  if (maxOutputTokens != null) {
+    if (!Number.isInteger(maxOutputTokens)) {
+      throw new InvalidArgumentError({
+        parameter: "maxOutputTokens",
+        value: maxOutputTokens,
+        message: "maxOutputTokens must be an integer"
+      });
+    }
+    if (maxOutputTokens < 1) {
+      throw new InvalidArgumentError({
+        parameter: "maxOutputTokens",
+        value: maxOutputTokens,
+        message: "maxOutputTokens must be >= 1"
+      });
+    }
+  }
+  if (temperature != null) {
+    if (typeof temperature !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "temperature",
+        value: temperature,
+        message: "temperature must be a number"
+      });
+    }
+  }
+  if (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topP",
+        value: topP,
+        message: "topP must be a number"
+      });
+    }
+  }
+  if (topK != null) {
+    if (typeof topK !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topK",
+        value: topK,
+        message: "topK must be a number"
+      });
+    }
+  }
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+  }
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+  }
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new InvalidArgumentError({
+        parameter: "seed",
+        value: seed,
+        message: "seed must be an integer"
+      });
+    }
+  }
+  return {
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    stopSequences,
+    seed,
+    reasoning
+  };
+}
+
+// src/util/retry-with-exponential-backoff.ts
+import { APICallError } from "@ai-sdk/provider";
+import { GatewayError } from "@ai-sdk/gateway";
+import {
+  retryWithExponentialBackoff
+} from "@ai-sdk/provider-utils";
+
+// src/util/retry-error.ts
+import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
+var name5 = "AI_RetryError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5, _b5;
+var RetryError = class extends (_b5 = AISDKError5, _a5 = symbol5, _b5) {
+  constructor({
+    message,
+    reason,
+    errors
+  }) {
+    super({ name: name5, message });
+    this[_a5] = true;
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
+  }
+  static isInstance(error) {
+    return AISDKError5.hasMarker(error, marker5);
+  }
+};
+
+// src/util/retry-with-exponential-backoff.ts
+function getRetryDelayInMs({
+  error,
+  exponentialBackoffDelay
+}) {
+  const headers = APICallError.isInstance(error) ? error.responseHeaders : APICallError.isInstance(error.cause) ? error.cause.responseHeaders : void 0;
+  if (!headers) return exponentialBackoffDelay;
+  let ms;
+  const retryAfterMs = headers["retry-after-ms"];
+  if (retryAfterMs) {
+    const timeoutMs = parseFloat(retryAfterMs);
+    if (!Number.isNaN(timeoutMs)) {
+      ms = timeoutMs;
+    }
+  }
+  const retryAfter = headers["retry-after"];
+  if (retryAfter && ms === void 0) {
+    const timeoutSeconds = parseFloat(retryAfter);
+    if (!Number.isNaN(timeoutSeconds)) {
+      ms = timeoutSeconds * 1e3;
+    } else {
+      ms = Date.parse(retryAfter) - Date.now();
+    }
+  }
+  if (ms != null && !Number.isNaN(ms) && 0 <= ms && (ms < 60 * 1e3 || ms < exponentialBackoffDelay)) {
+    return ms;
+  }
+  return exponentialBackoffDelay;
+}
+var retryWithExponentialBackoffRespectingRetryHeaders = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2,
+  abortSignal,
+  additionalRetryableError
+} = {}) => retryWithExponentialBackoff({
+  maxRetries,
+  initialDelayInMs,
+  backoffFactor,
+  abortSignal,
+  shouldRetry: async (error) => error instanceof Error && (APICallError.isInstance(error) && error.isRetryable === true || GatewayError.isInstance(error) && error.isRetryable === true) || additionalRetryableError != null && await additionalRetryableError(error),
+  getDelayInMs: ({ error, exponentialBackoffDelay }) => getRetryDelayInMs({
+    error,
+    exponentialBackoffDelay
+  }),
+  createRetryError: ({ message, reason, errors }) => new RetryError({ message, reason, errors })
+});
+
+// src/util/prepare-retries.ts
+function prepareRetries({
+  maxRetries,
+  abortSignal,
+  additionalRetryableError,
+  parameter = "maxRetries",
+  defaultMaxRetries = 2
+}) {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter,
+        value: maxRetries,
+        message: `${parameter} must be an integer`
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter,
+        value: maxRetries,
+        message: `${parameter} must be >= 0`
+      });
+    }
+  }
+  const maxRetriesResult = maxRetries != null ? maxRetries : defaultMaxRetries;
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoffRespectingRetryHeaders({
+      maxRetries: maxRetriesResult,
+      abortSignal,
+      additionalRetryableError
+    })
+  };
+}
+
+// src/types/usage.ts
+function asLanguageModelUsage(usage) {
+  return {
+    inputTokens: usage.inputTokens.total,
+    inputTokenDetails: {
+      noCacheTokens: usage.inputTokens.noCache,
+      cacheReadTokens: usage.inputTokens.cacheRead,
+      cacheWriteTokens: usage.inputTokens.cacheWrite
+    },
+    outputTokens: usage.outputTokens.total,
+    outputTokenDetails: {
+      textTokens: usage.outputTokens.text,
+      reasoningTokens: usage.outputTokens.reasoning
+    },
+    totalTokens: addTokenCounts(
+      usage.inputTokens.total,
+      usage.outputTokens.total
+    ),
+    raw: usage.raw
+  };
+}
+function createNullLanguageModelUsage() {
+  return {
+    inputTokens: void 0,
+    inputTokenDetails: {
+      noCacheTokens: void 0,
+      cacheReadTokens: void 0,
+      cacheWriteTokens: void 0
+    },
+    outputTokens: void 0,
+    outputTokenDetails: {
+      textTokens: void 0,
+      reasoningTokens: void 0
+    },
+    totalTokens: void 0,
+    raw: void 0
+  };
+}
+function addLanguageModelUsage(usage1, usage2) {
+  var _a12, _b12, _c, _d, _e, _f, _g, _h, _i, _j;
+  return {
+    inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
+    inputTokenDetails: {
+      noCacheTokens: addTokenCounts(
+        (_a12 = usage1.inputTokenDetails) == null ? void 0 : _a12.noCacheTokens,
+        (_b12 = usage2.inputTokenDetails) == null ? void 0 : _b12.noCacheTokens
+      ),
+      cacheReadTokens: addTokenCounts(
+        (_c = usage1.inputTokenDetails) == null ? void 0 : _c.cacheReadTokens,
+        (_d = usage2.inputTokenDetails) == null ? void 0 : _d.cacheReadTokens
+      ),
+      cacheWriteTokens: addTokenCounts(
+        (_e = usage1.inputTokenDetails) == null ? void 0 : _e.cacheWriteTokens,
+        (_f = usage2.inputTokenDetails) == null ? void 0 : _f.cacheWriteTokens
+      )
+    },
+    outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
+    outputTokenDetails: {
+      textTokens: addTokenCounts(
+        (_g = usage1.outputTokenDetails) == null ? void 0 : _g.textTokens,
+        (_h = usage2.outputTokenDetails) == null ? void 0 : _h.textTokens
+      ),
+      reasoningTokens: addTokenCounts(
+        (_i = usage1.outputTokenDetails) == null ? void 0 : _i.reasoningTokens,
+        (_j = usage2.outputTokenDetails) == null ? void 0 : _j.reasoningTokens
+      )
+    },
+    totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens)
+  };
+}
+function addTokenCounts(tokenCount1, tokenCount2) {
+  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
+}
+
+// src/model/resolve-model.ts
+import { gateway } from "@ai-sdk/gateway";
+
+// src/error/index.ts
+import {
+  AISDKError as AISDKError13,
+  APICallError as APICallError2,
+  EmptyResponseBodyError,
+  InvalidPromptError as InvalidPromptError2,
+  InvalidResponseDataError,
+  JSONParseError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  NoContentGeneratedError,
+  NoSuchModelError,
+  NoSuchProviderReferenceError,
+  TooManyEmbeddingValuesForCallError,
+  TypeValidationError,
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+
+// src/error/invalid-tool-approval-error.ts
+import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
+var name6 = "AI_InvalidToolApprovalError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6, _b6;
+var InvalidToolApprovalError = class extends (_b6 = AISDKError6, _a6 = symbol6, _b6) {
+  constructor({ approvalId }) {
+    super({
+      name: name6,
+      message: `Tool approval response references unknown approvalId: "${approvalId}". No matching tool-approval-request found in message history.`
+    });
+    this[_a6] = true;
+    this.approvalId = approvalId;
+  }
+  static isInstance(error) {
+    return AISDKError6.hasMarker(error, marker6);
+  }
+};
+
+// src/error/invalid-tool-approval-signature-error.ts
+import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
+var name7 = "AI_InvalidToolApprovalSignatureError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7, _b7;
+var InvalidToolApprovalSignatureError = class extends (_b7 = AISDKError7, _a7 = symbol7, _b7) {
+  constructor({
+    approvalId,
+    toolCallId,
+    reason
+  }) {
+    super({
+      name: name7,
+      message: `Tool approval signature verification failed for approval "${approvalId}" (tool call "${toolCallId}"): ${reason}`
+    });
+    this[_a7] = true;
+    this.approvalId = approvalId;
+    this.toolCallId = toolCallId;
+  }
+  static isInstance(error) {
+    return AISDKError7.hasMarker(error, marker7);
+  }
+};
+
+// src/error/invalid-tool-input-error.ts
+import { AISDKError as AISDKError8, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
+var name8 = "AI_InvalidToolInputError";
+var marker8 = `vercel.ai.error.${name8}`;
+var symbol8 = Symbol.for(marker8);
+var _a8, _b8;
+var InvalidToolInputError = class extends (_b8 = AISDKError8, _a8 = symbol8, _b8) {
+  constructor({
+    toolInput,
+    toolName,
+    cause,
+    message = `Invalid input for tool ${toolName}: ${getErrorMessage2(cause)}`
+  }) {
+    super({ name: name8, message, cause });
+    this[_a8] = true;
+    this.toolInput = toolInput;
+    this.toolName = toolName;
+  }
+  static isInstance(error) {
+    return AISDKError8.hasMarker(error, marker8);
+  }
+};
+
+// src/error/tool-call-not-found-for-approval-error.ts
+import { AISDKError as AISDKError9 } from "@ai-sdk/provider";
+var name9 = "AI_ToolCallNotFoundForApprovalError";
+var marker9 = `vercel.ai.error.${name9}`;
+var symbol9 = Symbol.for(marker9);
+var _a9, _b9;
+var ToolCallNotFoundForApprovalError = class extends (_b9 = AISDKError9, _a9 = symbol9, _b9) {
+  constructor({
+    toolCallId,
+    approvalId
+  }) {
+    super({
+      name: name9,
+      message: `Tool call "${toolCallId}" not found for approval request "${approvalId}".`
+    });
+    this[_a9] = true;
+    this.toolCallId = toolCallId;
+    this.approvalId = approvalId;
+  }
+  static isInstance(error) {
+    return AISDKError9.hasMarker(error, marker9);
+  }
+};
+
+// src/error/no-such-tool-error.ts
+import { AISDKError as AISDKError10 } from "@ai-sdk/provider";
+var name10 = "AI_NoSuchToolError";
+var marker10 = `vercel.ai.error.${name10}`;
+var symbol10 = Symbol.for(marker10);
+var _a10, _b10;
+var NoSuchToolError = class extends (_b10 = AISDKError10, _a10 = symbol10, _b10) {
+  constructor({
+    toolName,
+    availableTools = void 0,
+    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
+  }) {
+    super({ name: name10, message });
+    this[_a10] = true;
+    this.toolName = toolName;
+    this.availableTools = availableTools;
+  }
+  static isInstance(error) {
+    return AISDKError10.hasMarker(error, marker10);
+  }
+};
+
+// src/error/tool-call-repair-error.ts
+import { AISDKError as AISDKError11, getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
+var name11 = "AI_ToolCallRepairError";
+var marker11 = `vercel.ai.error.${name11}`;
+var symbol11 = Symbol.for(marker11);
+var _a11, _b11;
+var ToolCallRepairError = class extends (_b11 = AISDKError11, _a11 = symbol11, _b11) {
+  constructor({
+    cause,
+    originalError,
+    message = `Error repairing tool call: ${getErrorMessage3(cause)}`
+  }) {
+    super({ name: name11, message, cause });
+    this[_a11] = true;
+    this.originalError = originalError;
+  }
+  static isInstance(error) {
+    return AISDKError11.hasMarker(error, marker11);
+  }
+};
+
+// src/error/unsupported-model-version-error.ts
+import { AISDKError as AISDKError12 } from "@ai-sdk/provider";
+var UnsupportedModelVersionError = class extends AISDKError12 {
+  constructor(options) {
+    super({
+      name: "AI_UnsupportedModelVersionError",
+      message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
+    });
+    this.version = options.version;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+  }
+};
+
+// src/error/index.ts
+import { DownloadError as DownloadError2 } from "@ai-sdk/provider-utils";
+
+// src/util/log-v2-compatibility-warning.ts
+function logV2CompatibilityWarning({
+  provider,
+  modelId
+}) {
+  logWarnings({
+    warnings: [
+      {
+        type: "compatibility",
+        feature: "specificationVersion",
+        details: `Using v2 specification compatibility mode. Some features may not be available.`
+      }
+    ],
+    provider,
+    model: modelId
+  });
+}
+
+// src/model/as-embedding-model-v3.ts
+function asEmbeddingModelV3(model) {
+  if (model.specificationVersion === "v3") {
+    return model;
+  }
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId
+  });
+  return new Proxy(model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v3";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-embedding-model-v4.ts
+function asEmbeddingModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  const v3Model = model.specificationVersion === "v2" ? asEmbeddingModelV3(model) : model;
+  return new Proxy(v3Model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-image-model-v3.ts
+function asImageModelV3(model) {
+  if (model.specificationVersion === "v3") {
+    return model;
+  }
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId
+  });
+  return new Proxy(model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v3";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-image-model-v4.ts
+function asImageModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  const v3Model = model.specificationVersion === "v2" ? asImageModelV3(model) : model;
+  return new Proxy(v3Model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-language-model-v3.ts
+function asLanguageModelV3(model) {
+  if (model.specificationVersion === "v3") {
+    return model;
+  }
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId
+  });
+  return new Proxy(model, {
+    get(target, prop) {
+      switch (prop) {
+        case "specificationVersion":
+          return "v3";
+        case "doGenerate":
+          return async (...args) => {
+            const result = await target.doGenerate(...args);
+            return {
+              ...result,
+              finishReason: convertV2FinishReasonToV3(result.finishReason),
+              usage: convertV2UsageToV3(result.usage)
+            };
+          };
+        case "doStream":
+          return async (...args) => {
+            const result = await target.doStream(...args);
+            return {
+              ...result,
+              stream: convertV2StreamToV3(result.stream)
+            };
+          };
+        default:
+          return target[prop];
+      }
+    }
+  });
+}
+function convertV2StreamToV3(stream) {
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        switch (chunk.type) {
+          case "finish":
+            controller.enqueue({
+              ...chunk,
+              finishReason: convertV2FinishReasonToV3(chunk.finishReason),
+              usage: convertV2UsageToV3(chunk.usage)
+            });
+            break;
+          default:
+            controller.enqueue(chunk);
+            break;
+        }
+      }
+    })
+  );
+}
+function convertV2FinishReasonToV3(finishReason) {
+  return {
+    unified: finishReason === "unknown" ? "other" : finishReason,
+    raw: void 0
+  };
+}
+function convertV2UsageToV3(usage) {
+  return {
+    inputTokens: {
+      total: usage.inputTokens,
+      noCache: void 0,
+      cacheRead: usage.cachedInputTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: usage.outputTokens,
+      text: void 0,
+      reasoning: usage.reasoningTokens
+    }
+  };
+}
+
+// src/model/as-language-model-v4.ts
+function asLanguageModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  const v3Model = model.specificationVersion === "v2" ? asLanguageModelV3(model) : model;
+  return new Proxy(v3Model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-reranking-model-v4.ts
+function asRerankingModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  return new Proxy(model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-speech-model-v3.ts
+function asSpeechModelV3(model) {
+  if (model.specificationVersion === "v3") {
+    return model;
+  }
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId
+  });
+  return new Proxy(model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v3";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-speech-model-v4.ts
+function asSpeechModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  const v3Model = model.specificationVersion === "v2" ? asSpeechModelV3(model) : model;
+  return new Proxy(v3Model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-transcription-model-v3.ts
+function asTranscriptionModelV3(model) {
+  if (model.specificationVersion === "v3") {
+    return model;
+  }
+  logV2CompatibilityWarning({
+    provider: model.provider,
+    modelId: model.modelId
+  });
+  return new Proxy(model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v3";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-transcription-model-v4.ts
+function asTranscriptionModelV4(model) {
+  if (model.specificationVersion === "v4") {
+    return model;
+  }
+  const v3Model = model.specificationVersion === "v2" ? asTranscriptionModelV3(model) : model;
+  return new Proxy(v3Model, {
+    get(target, prop) {
+      if (prop === "specificationVersion") return "v4";
+      return target[prop];
+    }
+  });
+}
+
+// src/model/as-provider-v3.ts
+function asProviderV3(provider) {
+  if ("specificationVersion" in provider && provider.specificationVersion === "v3") {
+    return provider;
+  }
+  const v2Provider = provider;
+  return {
+    specificationVersion: "v3",
+    languageModel: (modelId) => asLanguageModelV3(v2Provider.languageModel(modelId)),
+    embeddingModel: (modelId) => asEmbeddingModelV3(v2Provider.textEmbeddingModel(modelId)),
+    imageModel: (modelId) => asImageModelV3(v2Provider.imageModel(modelId)),
+    transcriptionModel: v2Provider.transcriptionModel ? (modelId) => asTranscriptionModelV3(v2Provider.transcriptionModel(modelId)) : void 0,
+    speechModel: v2Provider.speechModel ? (modelId) => asSpeechModelV3(v2Provider.speechModel(modelId)) : void 0,
+    rerankingModel: void 0
+    // v2 providers don't have reranking models
+  };
+}
+
+// src/model/as-provider-v4.ts
+function asProviderV4(provider) {
+  if ("specificationVersion" in provider && provider.specificationVersion === "v4") {
+    return provider;
+  }
+  const v3Provider = !("specificationVersion" in provider) || provider.specificationVersion !== "v3" ? asProviderV3(provider) : provider;
+  return {
+    specificationVersion: "v4",
+    languageModel: (modelId) => asLanguageModelV4(v3Provider.languageModel(modelId)),
+    embeddingModel: (modelId) => asEmbeddingModelV4(v3Provider.embeddingModel(modelId)),
+    imageModel: (modelId) => asImageModelV4(v3Provider.imageModel(modelId)),
+    transcriptionModel: v3Provider.transcriptionModel ? (modelId) => asTranscriptionModelV4(v3Provider.transcriptionModel(modelId)) : void 0,
+    speechModel: v3Provider.speechModel ? (modelId) => asSpeechModelV4(v3Provider.speechModel(modelId)) : void 0,
+    rerankingModel: v3Provider.rerankingModel ? (modelId) => asRerankingModelV4(v3Provider.rerankingModel(modelId)) : void 0
+  };
+}
+
+// src/model/resolve-model.ts
+function resolveLanguageModel(model) {
+  if (typeof model === "string") {
+    return getGlobalProvider().languageModel(model);
+  }
+  if (!["v4", "v3", "v2"].includes(model.specificationVersion)) {
+    const unsupportedModel = model;
+    throw new UnsupportedModelVersionError({
+      version: unsupportedModel.specificationVersion,
+      provider: unsupportedModel.provider,
+      modelId: unsupportedModel.modelId
+    });
+  }
+  return asLanguageModelV4(model);
+}
+function getGlobalProvider() {
+  var _a12;
+  const provider = (_a12 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a12 : gateway;
+  return asProviderV4(provider);
+}
+
+// src/util/merge-abort-signals.ts
+import { filterNullable } from "@ai-sdk/provider-utils";
+function mergeAbortSignals(...signals) {
+  const validSignals = filterNullable(...signals).map(
+    (signal) => typeof signal === "number" ? AbortSignal.timeout(signal) : signal
+  );
+  return validSignals.length === 0 ? void 0 : validSignals.length === 1 ? validSignals[0] : AbortSignal.any(validSignals);
+}
+
+// src/util/merge-callbacks.ts
+function mergeCallbacks(...callbacks) {
+  return async (event) => {
+    await Promise.allSettled(
+      callbacks.map(async (callback) => {
+        await (callback == null ? void 0 : callback(event));
+      })
+    );
+  };
+}
+
+// src/telemetry/create-telemetry-dispatcher.ts
+import { asArray as asArray3 } from "@ai-sdk/provider-utils";
+
+// src/telemetry/tracing-channel.ts
+var AI_SDK_TELEMETRY_TRACING_CHANNEL = "ai:telemetry";
+
+// src/util/is-node-runtime.ts
+function isNodeRuntime() {
+  var _a12;
+  return typeof process !== "undefined" && ((_a12 = process.release) == null ? void 0 : _a12.name) === "node";
+}
+
+// src/telemetry/tracing-channel-publisher.ts
+var diagnosticsChannelPromise;
+async function loadDiagnosticsChannel() {
+  if (!isNodeRuntime()) {
+    return void 0;
+  }
+  if (diagnosticsChannelPromise == null) {
+    diagnosticsChannelPromise = Promise.resolve(
+      loadBuiltinModule("node:diagnostics_channel")
+    );
+  }
+  return diagnosticsChannelPromise;
+}
+function loadBuiltinModule(id) {
+  var _a12;
+  const processWithBuiltins = globalThis.process;
+  try {
+    return (_a12 = processWithBuiltins == null ? void 0 : processWithBuiltins.getBuiltinModule) == null ? void 0 : _a12.call(processWithBuiltins, id);
+  } catch (e) {
+    return void 0;
+  }
+}
+async function runWithTracingChannelSpan(message, execute) {
+  var _a12;
+  const diagnosticsChannel = await loadDiagnosticsChannel();
+  const tracingChannel = (_a12 = diagnosticsChannel == null ? void 0 : diagnosticsChannel.tracingChannel) == null ? void 0 : _a12.call(
+    diagnosticsChannel,
+    AI_SDK_TELEMETRY_TRACING_CHANNEL
+  );
+  if (tracingChannel == null || tracingChannel.hasSubscribers === false) {
+    return await execute();
+  }
+  let executePromise;
+  let executionResult;
+  let executionError;
+  let hasExecutionResult = false;
+  let hasExecutionError = false;
+  const tracedExecute = () => {
+    try {
+      executePromise = Promise.resolve(execute());
+    } catch (error) {
+      executePromise = Promise.reject(error);
+    }
+    executePromise = executePromise.then(
+      (result) => {
+        executionResult = result;
+        hasExecutionResult = true;
+        return result;
+      },
+      (error) => {
+        executionError = error;
+        hasExecutionError = true;
+        throw error;
+      }
+    );
+    return executePromise;
+  };
+  try {
+    return await tracingChannel.tracePromise(tracedExecute, message);
+  } catch (e) {
+    if (hasExecutionError) {
+      throw executionError;
+    }
+    if (hasExecutionResult) {
+      return executionResult;
+    }
+    if (executePromise != null) {
+      return await executePromise;
+    }
+    return await execute();
+  }
+}
+function openTelemetryChannelSpanContext({
+  message,
+  completion
+}) {
+  var _a12;
+  if (!isNodeRuntime()) {
+    return void 0;
+  }
+  const diagnosticsChannel = loadBuiltinModule(
+    "node:diagnostics_channel"
+  );
+  const asyncHooks = loadBuiltinModule("node:async_hooks");
+  const tracingChannel = (_a12 = diagnosticsChannel == null ? void 0 : diagnosticsChannel.tracingChannel) == null ? void 0 : _a12.call(
+    diagnosticsChannel,
+    AI_SDK_TELEMETRY_TRACING_CHANNEL
+  );
+  if (tracingChannel == null || tracingChannel.hasSubscribers === false || asyncHooks == null) {
+    Promise.resolve(completion).catch(() => {
+    });
+    return void 0;
+  }
+  const context = message;
+  let asyncResource;
+  let asyncEndPublished = false;
+  const safePublish = (publish) => {
+    try {
+      publish();
+    } catch (e) {
+    }
+  };
+  const publishAsyncEnd = ({
+    result,
+    error
+  }) => {
+    if (asyncEndPublished) {
+      return;
+    }
+    asyncEndPublished = true;
+    if (error !== void 0) {
+      context.error = error;
+      safePublish(() => tracingChannel.error.publish(context));
+    }
+    if (result !== void 0) {
+      context.result = result;
+    }
+    safePublish(() => tracingChannel.asyncEnd.publish(context));
+  };
+  safePublish(() => {
+    tracingChannel.start.runStores(context, () => {
+      asyncResource = new asyncHooks.AsyncResource("ai.telemetry");
+    });
+  });
+  safePublish(() => tracingChannel.end.publish(context));
+  void Promise.resolve(completion).then(
+    (result) => publishAsyncEnd({ result }),
+    (error) => publishAsyncEnd({ error })
+  );
+  return {
+    run: (execute) => asyncResource == null ? execute() : asyncResource.runInAsyncScope(execute)
+  };
+}
+
+// src/telemetry/telemetry-registry.ts
+function getGlobalTelemetryIntegrations() {
+  var _a12;
+  return (_a12 = globalThis.AI_SDK_TELEMETRY_INTEGRATIONS) != null ? _a12 : [];
+}
+
+// src/telemetry/create-telemetry-dispatcher.ts
+function augmentEvent(event, telemetry) {
+  return Object.assign(
+    Object.create(Object.getPrototypeOf(event)),
+    event,
+    telemetry
+  );
+}
+function createTelemetryDispatcher({
+  telemetry
+}) {
+  if ((telemetry == null ? void 0 : telemetry.isEnabled) === false) {
+    return {};
+  }
+  const localIntegrations = telemetry == null ? void 0 : telemetry.integrations;
+  const integrations = localIntegrations != null ? asArray3(localIntegrations) : getGlobalTelemetryIntegrations();
+  const telemetryMetadata = {
+    recordInputs: telemetry == null ? void 0 : telemetry.recordInputs,
+    recordOutputs: telemetry == null ? void 0 : telemetry.recordOutputs,
+    functionId: telemetry == null ? void 0 : telemetry.functionId
+  };
+  const mergeTelemetryCallback = (key) => {
+    const integrationCallbacks = integrations.map((integration) => {
+      var _a12;
+      return (_a12 = integration[key]) == null ? void 0 : _a12.bind(integration);
+    }).filter(Boolean).map(
+      (callback) => ((event) => callback(augmentEvent(event, telemetryMetadata)))
+    );
+    const mergedIntegrationCallback = mergeCallbacks(...integrationCallbacks);
+    return async (event) => {
+      await mergedIntegrationCallback(event);
+    };
+  };
+  const executeLanguageModelCallWrappers = integrations.map((integration) => {
+    var _a12;
+    return (_a12 = integration.executeLanguageModelCall) == null ? void 0 : _a12.bind(integration);
+  }).filter(Boolean);
+  const executeToolWrappers = integrations.map((integration) => {
+    var _a12;
+    return (_a12 = integration.executeTool) == null ? void 0 : _a12.bind(integration);
+  }).filter(Boolean);
+  return {
+    runInTracingChannelSpan: async ({ type, event, execute }) => await runWithTracingChannelSpan(
+      {
+        type,
+        event: augmentEvent(event, telemetryMetadata)
+      },
+      execute
+    ),
+    startTracingChannelContext: ({ type, event, completion }) => openTelemetryChannelSpanContext({
+      message: {
+        type,
+        event: augmentEvent(event, telemetryMetadata)
+      },
+      completion
+    }),
+    onStart: mergeTelemetryCallback("onStart"),
+    onStepStart: mergeTelemetryCallback("onStepStart"),
+    onLanguageModelCallStart: mergeTelemetryCallback(
+      "onLanguageModelCallStart"
+    ),
+    onLanguageModelCallEnd: mergeTelemetryCallback("onLanguageModelCallEnd"),
+    onToolExecutionStart: mergeTelemetryCallback("onToolExecutionStart"),
+    onToolExecutionEnd: mergeTelemetryCallback("onToolExecutionEnd"),
+    // Fan out step-end events to both the new `onStepEnd` callback and the
+    // deprecated `onStepFinish` callback so integrations that still implement
+    // only `onStepFinish` keep receiving step-end events during the deprecation
+    // window.
+    onStepEnd: mergeCallbacks(
+      mergeTelemetryCallback("onStepEnd"),
+      mergeTelemetryCallback("onStepFinish")
+    ),
+    onObjectStepStart: mergeTelemetryCallback("onObjectStepStart"),
+    onObjectStepEnd: mergeTelemetryCallback("onObjectStepEnd"),
+    onEmbedStart: mergeTelemetryCallback("onEmbedStart"),
+    onEmbedEnd: mergeTelemetryCallback("onEmbedEnd"),
+    onRerankStart: mergeTelemetryCallback("onRerankStart"),
+    onRerankEnd: mergeTelemetryCallback("onRerankEnd"),
+    onEnd: mergeTelemetryCallback("onEnd"),
+    onAbort: mergeTelemetryCallback("onAbort"),
+    onError: mergeTelemetryCallback("onError"),
+    /**
+     * Runs provider calls inside integration-specific context so
+     * auto-instrumented provider requests can be associated with model work.
+     */
+    executeLanguageModelCall: async ({ execute, ...event }) => {
+      const augmentedEvent = augmentEvent(event, telemetryMetadata);
+      let wrappedExecute = execute;
+      for (const executeWrapper of executeLanguageModelCallWrappers) {
+        const innerExecute = wrappedExecute;
+        wrappedExecute = () => executeWrapper({ ...augmentedEvent, execute: innerExecute });
+      }
+      return await runWithTracingChannelSpan(
+        { type: "languageModelCall", event: augmentedEvent },
+        wrappedExecute
+      );
+    },
+    /**
+     * Composes all `executeTool` wrappers around the original tool execution.
+     * Each wrapper receives an `execute` function that calls the next wrapper in
+     * the chain, so integrations can establish nested telemetry context before
+     * delegating to the underlying tool.
+     */
+    executeTool: async ({ execute, ...event }) => {
+      const augmentedEvent = augmentEvent(event, telemetryMetadata);
+      let wrappedExecute = execute;
+      for (const executeWrapper of executeToolWrappers) {
+        const innerExecute = wrappedExecute;
+        wrappedExecute = () => executeWrapper({ ...augmentedEvent, execute: innerExecute });
+      }
+      return await wrappedExecute();
+    }
+  };
+}
+
+// src/telemetry/filter-included-context.ts
+function filterIncludedContext({
+  context,
+  includeContext
+}) {
+  if (context == null) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(context).filter(
+      ([key]) => (includeContext == null ? void 0 : includeContext[key]) === true
+    )
+  );
+}
+
+// src/generate-text/reasoning.ts
+function asReasoningText(reasoningParts) {
+  const reasoningText = reasoningParts.map((part) => "text" in part ? part.text : "").join("");
+  return reasoningText.length > 0 ? reasoningText : void 0;
+}
+
+// src/generate-text/reasoning-output.ts
+function convertFromReasoningOutputs(parts) {
+  return parts.map((part) => {
+    if (part.type === "reasoning") {
+      return {
+        type: "reasoning",
+        text: part.text,
+        ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
+      };
+    }
+    return {
+      type: "reasoning-file",
+      data: part.file.base64,
+      mediaType: part.file.mediaType,
+      ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
+    };
+  });
+}
+
+// src/generate-text/step-result.ts
+var DefaultStepResult = class {
+  constructor({
+    callId,
+    stepNumber,
+    provider,
+    modelId,
+    runtimeContext,
+    toolsContext,
+    content,
+    finishReason,
+    rawFinishReason,
+    usage,
+    performance,
+    warnings,
+    request,
+    response,
+    providerMetadata
+  }) {
+    this.callId = callId;
+    this.stepNumber = stepNumber;
+    this.model = { provider, modelId };
+    this.runtimeContext = runtimeContext;
+    this.toolsContext = toolsContext;
+    this.content = content;
+    this.finishReason = finishReason;
+    this.rawFinishReason = rawFinishReason;
+    this.usage = usage;
+    this.performance = performance;
+    this.warnings = warnings;
+    this.request = request;
+    this.response = response;
+    this.providerMetadata = providerMetadata;
+  }
+  get text() {
+    return this.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+  }
+  get reasoning() {
+    return convertFromReasoningOutputs(
+      this.content.filter(
+        (part) => part.type === "reasoning" || part.type === "reasoning-file"
+      )
+    );
+  }
+  get reasoningText() {
+    return asReasoningText(this.reasoning);
+  }
+  get files() {
+    return this.content.filter((part) => part.type === "file").map((part) => part.file);
+  }
+  get sources() {
+    return this.content.filter((part) => part.type === "source");
+  }
+  get toolCalls() {
+    return this.content.filter((part) => part.type === "tool-call");
+  }
+  get staticToolCalls() {
+    return this.toolCalls.filter(
+      (toolCall) => toolCall.dynamic !== true
+    );
+  }
+  get dynamicToolCalls() {
+    return this.toolCalls.filter(
+      (toolCall) => toolCall.dynamic === true
+    );
+  }
+  get toolResults() {
+    return this.content.filter((part) => part.type === "tool-result");
+  }
+  get staticToolResults() {
+    return this.toolResults.filter(
+      (toolResult) => toolResult.dynamic !== true
+    );
+  }
+  get dynamicToolResults() {
+    return this.toolResults.filter(
+      (toolResult) => toolResult.dynamic === true
+    );
+  }
+};
+
+// src/generate-text/restricted-telemetry-dispatcher.ts
+function restrictStepResult({
+  step,
+  includeRuntimeContext,
+  includeToolsContext
+}) {
+  return new DefaultStepResult({
+    callId: step.callId,
+    stepNumber: step.stepNumber,
+    provider: step.model.provider,
+    modelId: step.model.modelId,
+    runtimeContext: filterIncludedContext({
+      context: step.runtimeContext,
+      includeContext: includeRuntimeContext
+    }),
+    toolsContext: filterToolsContext({
+      toolsContext: step.toolsContext,
+      includeToolsContext
+    }),
+    content: step.content,
+    finishReason: step.finishReason,
+    rawFinishReason: step.rawFinishReason,
+    usage: step.usage,
+    performance: step.performance,
+    warnings: step.warnings,
+    request: step.request,
+    response: step.response,
+    providerMetadata: step.providerMetadata
+  });
+}
+function filterToolsContext({
+  toolsContext,
+  includeToolsContext
+}) {
+  if (includeToolsContext == null) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(toolsContext).map(([toolName, toolContext]) => [
+      toolName,
+      filterToolContext({
+        toolName,
+        toolContext,
+        includeToolsContext
+      })
+    ])
+  );
+}
+function filterToolContext({
+  toolName,
+  toolContext,
+  includeToolsContext
+}) {
+  const includeToolContext = includeToolsContext == null ? void 0 : includeToolsContext[toolName];
+  return filterIncludedContext({
+    context: toolContext,
+    includeContext: includeToolContext
+  });
+}
+function createRestrictedTelemetryDispatcher({
+  telemetry,
+  includeRuntimeContext,
+  includeToolsContext
+}) {
+  const telemetryDispatcher = createTelemetryDispatcher({ telemetry });
+  return {
+    ...telemetryDispatcher,
+    onStart: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onStart) == null ? void 0 : _a12.call(telemetryDispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: includeRuntimeContext
+        }),
+        toolsContext: filterToolsContext({
+          toolsContext: event.toolsContext,
+          includeToolsContext
+        })
+      });
+    },
+    onStepStart: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onStepStart) == null ? void 0 : _a12.call(telemetryDispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: includeRuntimeContext
+        }),
+        steps: event.steps.map(
+          (step) => restrictStepResult({
+            step,
+            includeRuntimeContext,
+            includeToolsContext
+          })
+        ),
+        toolsContext: filterToolsContext({
+          toolsContext: event.toolsContext,
+          includeToolsContext
+        })
+      });
+    },
+    onStepEnd: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onStepEnd) == null ? void 0 : _a12.call(
+        telemetryDispatcher,
+        restrictStepResult({
+          step: event,
+          includeRuntimeContext,
+          includeToolsContext
+        })
+      );
+    },
+    onStepFinish: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onStepEnd) == null ? void 0 : _a12.call(
+        telemetryDispatcher,
+        restrictStepResult({
+          step: event,
+          includeRuntimeContext,
+          includeToolsContext
+        })
+      );
+    },
+    onEnd: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onEnd) == null ? void 0 : _a12.call(
+        telemetryDispatcher,
+        ((restrictedSteps) => {
+          return {
+            ...event,
+            runtimeContext: filterIncludedContext({
+              context: event.runtimeContext,
+              includeContext: includeRuntimeContext
+            }),
+            steps: restrictedSteps,
+            finalStep: restrictedSteps.at(-1),
+            toolsContext: filterToolsContext({
+              toolsContext: event.toolsContext,
+              includeToolsContext
+            })
+          };
+        })(
+          event.steps.map(
+            (step) => restrictStepResult({
+              step,
+              includeRuntimeContext,
+              includeToolsContext
+            })
+          )
+        )
+      );
+    },
+    onAbort: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onAbort) == null ? void 0 : _a12.call(telemetryDispatcher, {
+        ...event,
+        steps: event.steps.map(
+          (step) => restrictStepResult({
+            step,
+            includeRuntimeContext,
+            includeToolsContext
+          })
+        )
+      });
+    },
+    onToolExecutionStart: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onToolExecutionStart) == null ? void 0 : _a12.call(telemetryDispatcher, {
+        ...event,
+        toolContext: filterToolContext({
+          toolName: event.toolCall.toolName,
+          toolContext: event.toolContext,
+          includeToolsContext
+        })
+      });
+    },
+    onToolExecutionEnd: (event) => {
+      var _a12;
+      return (_a12 = telemetryDispatcher.onToolExecutionEnd) == null ? void 0 : _a12.call(telemetryDispatcher, {
+        ...event,
+        toolContext: filterToolContext({
+          toolName: event.toolCall.toolName,
+          toolContext: event.toolContext,
+          includeToolsContext
+        })
+      });
+    }
+  };
+}
+
+// src/generate-text/parse-tool-call.ts
+import {
+  asSchema as asSchema2,
+  safeParseJSON,
+  safeValidateTypes as safeValidateTypes2
+} from "@ai-sdk/provider-utils";
+
+// src/util/get-own.ts
+function getOwn(obj, key) {
+  return obj != null && Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+
+// src/generate-text/parse-tool-call.ts
+async function parseToolCall({
+  toolCall,
+  tools,
+  repairToolCall,
+  refineToolInput,
+  messages,
+  instructions
+}) {
+  try {
+    if (tools == null) {
+      if (toolCall.providerExecuted && toolCall.dynamic) {
+        return await refineParsedToolCallInput({
+          toolCall: await parseProviderExecutedDynamicToolCall(toolCall),
+          refineToolInput
+        });
+      }
+      throw new NoSuchToolError({ toolName: toolCall.toolName });
+    }
+    try {
+      return await refineParsedToolCallInput({
+        toolCall: await doParseToolCall({ toolCall, tools }),
+        refineToolInput
+      });
+    } catch (error) {
+      if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
+        throw error;
+      }
+      let repairedToolCall = null;
+      try {
+        repairedToolCall = await repairToolCall({
+          toolCall,
+          tools,
+          inputSchema: async ({ toolName }) => {
+            var _a12;
+            const inputSchema = (_a12 = getOwn(tools, toolName)) == null ? void 0 : _a12.inputSchema;
+            return await asSchema2(inputSchema).jsonSchema;
+          },
+          instructions,
+          system: instructions,
+          messages,
+          error
+        });
+      } catch (repairError) {
+        throw new ToolCallRepairError({
+          cause: repairError,
+          originalError: error
+        });
+      }
+      if (repairedToolCall == null) {
+        throw error;
+      }
+      return await refineParsedToolCallInput({
+        toolCall: await doParseToolCall({ toolCall: repairedToolCall, tools }),
+        refineToolInput
+      });
+    }
+  } catch (error) {
+    const parsedInput = await safeParseJSON({ text: toolCall.input });
+    const input = parsedInput.success ? parsedInput.value : toolCall.input;
+    const tool = getOwn(tools, toolCall.toolName);
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input,
+      dynamic: true,
+      invalid: true,
+      error,
+      title: tool == null ? void 0 : tool.title,
+      providerExecuted: toolCall.providerExecuted,
+      providerMetadata: toolCall.providerMetadata,
+      ...(tool == null ? void 0 : tool.metadata) != null ? { toolMetadata: tool.metadata } : {}
+    };
+  }
+}
+async function refineParsedToolCallInput({
+  toolCall,
+  refineToolInput
+}) {
+  const refine = getOwn(refineToolInput, toolCall.toolName);
+  if (refine == null) {
+    return toolCall;
+  }
+  return {
+    ...toolCall,
+    input: await refine(toolCall.input)
+  };
+}
+async function parseProviderExecutedDynamicToolCall(toolCall) {
+  const parseResult = toolCall.input.trim() === "" ? { success: true, value: {} } : await safeParseJSON({ text: toolCall.input });
+  if (parseResult.success === false) {
+    throw new InvalidToolInputError({
+      toolName: toolCall.toolName,
+      toolInput: toolCall.input,
+      cause: parseResult.error
+    });
+  }
+  return {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: parseResult.value,
+    providerExecuted: true,
+    dynamic: true,
+    providerMetadata: toolCall.providerMetadata
+  };
+}
+async function doParseToolCall({
+  toolCall,
+  tools
+}) {
+  const toolName = toolCall.toolName;
+  const tool = getOwn(tools, toolName);
+  if (tool == null) {
+    if (toolCall.providerExecuted && toolCall.dynamic) {
+      return await parseProviderExecutedDynamicToolCall(toolCall);
+    }
+    throw new NoSuchToolError({
+      toolName: toolCall.toolName,
+      availableTools: Object.keys(tools)
+    });
+  }
+  const schema = asSchema2(tool.inputSchema);
+  const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes2({ value: {}, schema }) : await safeParseJSON({ text: toolCall.input, schema });
+  if (parseResult.success === false) {
+    throw new InvalidToolInputError({
+      toolName,
+      toolInput: toolCall.input,
+      cause: parseResult.error
+    });
+  }
+  return tool.type === "dynamic" ? {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: parseResult.value,
+    providerExecuted: toolCall.providerExecuted,
+    providerMetadata: toolCall.providerMetadata,
+    ...tool.metadata != null ? { toolMetadata: tool.metadata } : {},
+    dynamic: true,
+    title: tool.title
+  } : {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName,
+    input: parseResult.value,
+    providerExecuted: toolCall.providerExecuted,
+    providerMetadata: toolCall.providerMetadata,
+    ...tool.metadata != null ? { toolMetadata: tool.metadata } : {},
+    title: tool.title
+  };
+}
+
+// src/generate-text/collect-tool-approvals.ts
+function collectToolApprovals({
+  messages
+}) {
+  const lastMessage = messages.at(-1);
+  if ((lastMessage == null ? void 0 : lastMessage.role) != "tool") {
+    return {
+      approvedToolApprovals: [],
+      deniedToolApprovals: []
+    };
+  }
+  const toolCallsByToolCallId = /* @__PURE__ */ Object.create(null);
+  for (const message of messages) {
+    if (message.role === "assistant" && typeof message.content !== "string") {
+      const content = message.content;
+      for (const part of content) {
+        if (part.type === "tool-call") {
+          toolCallsByToolCallId[part.toolCallId] = part;
+        }
+      }
+    }
+  }
+  const toolApprovalRequestsByApprovalId = /* @__PURE__ */ Object.create(null);
+  for (const message of messages) {
+    if (message.role === "assistant" && typeof message.content !== "string") {
+      const content = message.content;
+      for (const part of content) {
+        if (part.type === "tool-approval-request") {
+          toolApprovalRequestsByApprovalId[part.approvalId] = part;
+        }
+      }
+    }
+  }
+  const toolResults = /* @__PURE__ */ Object.create(null);
+  for (const part of lastMessage.content) {
+    if (part.type === "tool-result") {
+      toolResults[part.toolCallId] = part;
+    }
+  }
+  const approvedToolApprovals = [];
+  const deniedToolApprovals = [];
+  const approvalResponses = lastMessage.content.filter(
+    (part) => part.type === "tool-approval-response"
+  );
+  for (const approvalResponse of approvalResponses) {
+    const approvalRequest = toolApprovalRequestsByApprovalId[approvalResponse.approvalId];
+    if (approvalRequest == null) {
+      throw new InvalidToolApprovalError({
+        approvalId: approvalResponse.approvalId
+      });
+    }
+    const existingToolResult = toolResults[approvalRequest.toolCallId];
+    if (existingToolResult != null && (approvalResponse.approved || existingToolResult.output.type !== "execution-denied")) {
+      continue;
+    }
+    const toolCall = toolCallsByToolCallId[approvalRequest.toolCallId];
+    if (toolCall == null) {
+      throw new ToolCallNotFoundForApprovalError({
+        toolCallId: approvalRequest.toolCallId,
+        approvalId: approvalRequest.approvalId
+      });
+    }
+    const approval = {
+      approvalRequest,
+      approvalResponse,
+      toolCall,
+      ...existingToolResult != null ? { existingToolResult } : {}
+    };
+    if (approvalResponse.approved) {
+      approvedToolApprovals.push(approval);
+    } else {
+      deniedToolApprovals.push(approval);
+    }
+  }
+  return { approvedToolApprovals, deniedToolApprovals };
+}
+
+// src/generate-text/tool-approval-signature.ts
+import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
+
+// src/util/canonical-hash.ts
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+var encoder = new TextEncoder();
+function canonicalJSON(value) {
+  if (value === null || value === void 0) {
+    return JSON.stringify(value);
+  }
+  if (typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((element) => element === void 0 ? "null" : canonicalJSON(element)).join(",")}]`;
+  }
+  const keys = Object.keys(value).sort();
+  const entries = keys.map(
+    (k) => `${JSON.stringify(k)}:${canonicalJSON(value[k])}`
+  );
+  return `{${entries.join(",")}}`;
+}
+function toBase64url(bytes) {
+  return convertUint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function hashCanonical(value) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    encoder.encode(canonicalJSON(value))
+  );
+  return toBase64url(new Uint8Array(digest));
+}
+
+// src/generate-text/tool-approval-signature.ts
+var encoder2 = new TextEncoder();
+function fromBase64url(str) {
+  return convertBase64ToUint8Array(str);
+}
+async function importKey(secret) {
+  const keyData = typeof secret === "string" ? encoder2.encode(secret) : secret;
+  return crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign", "verify"]
+  );
+}
+function buildPayload(approvalId, toolCallId, toolName, inputDigest) {
+  return encoder2.encode(
+    JSON.stringify([
+      "ai-sdk-tool-approval-v1",
+      approvalId,
+      toolCallId,
+      toolName,
+      inputDigest
+    ])
+  );
+}
+function buildLegacyPayload(approvalId, toolCallId, toolName, inputDigest) {
+  return encoder2.encode(
+    `${approvalId}
+${toolCallId}
+${toolName}
+${inputDigest}`
+  );
+}
+async function signToolApproval({
+  secret,
+  approvalId,
+  toolCallId,
+  toolName,
+  input
+}) {
+  const key = await importKey(secret);
+  const inputDigest = await hashCanonical(input);
+  const payload = buildPayload(approvalId, toolCallId, toolName, inputDigest);
+  const sig = await crypto.subtle.sign("HMAC", key, payload);
+  return toBase64url(new Uint8Array(sig));
+}
+async function verifyToolApprovalSignature({
+  secret,
+  signature,
+  approvalId,
+  toolCallId,
+  toolName,
+  input
+}) {
+  const key = await importKey(secret);
+  const inputDigest = await hashCanonical(input);
+  const sigBytes = fromBase64url(signature);
+  const payload = buildPayload(approvalId, toolCallId, toolName, inputDigest);
+  if (await crypto.subtle.verify("HMAC", key, sigBytes, payload)) {
+    return true;
+  }
+  if (!approvalId.includes("\n") && !toolCallId.includes("\n") && !toolName.includes("\n")) {
+    const legacyPayload = buildLegacyPayload(
+      approvalId,
+      toolCallId,
+      toolName,
+      inputDigest
+    );
+    return crypto.subtle.verify("HMAC", key, sigBytes, legacyPayload);
+  }
+  return false;
+}
+
+// src/generate-text/validate-tool-approvals.ts
+import {
+  asSchema as asSchema3,
+  isExecutableTool,
+  safeValidateTypes as safeValidateTypes3
+} from "@ai-sdk/provider-utils";
+
+// src/generate-text/validate-tool-context.ts
+import { validateTypes } from "@ai-sdk/provider-utils";
+async function validateToolContext({
+  toolName,
+  context,
+  contextSchema
+}) {
+  if (contextSchema == null) {
+    return context;
+  }
+  return await validateTypes({
+    value: context,
+    schema: contextSchema,
+    context: {
+      field: "tool context",
+      entityName: toolName
+    }
+  });
+}
+
+// src/generate-text/resolve-tool-approval.ts
+async function resolveToolApproval({
+  tools,
+  toolCall,
+  toolApproval,
+  messages,
+  toolsContext,
+  runtimeContext
+}) {
+  if (toolApproval != null && typeof toolApproval === "function") {
+    return normalizeToolApprovalStatus(
+      await toolApproval({
+        toolCall,
+        tools,
+        toolsContext,
+        messages,
+        runtimeContext
+      })
+    );
+  }
+  const toolName = toolCall.toolName;
+  const tool = getOwn(tools, toolName);
+  const input = toolCall.input;
+  const userDefinedToolApprovalStatus = getOwn(toolApproval, toolName);
+  if (userDefinedToolApprovalStatus != null) {
+    const approvalStatus = typeof userDefinedToolApprovalStatus === "function" ? await userDefinedToolApprovalStatus(input, {
+      toolCallId: toolCall.toolCallId,
+      messages,
+      toolContext: await validateToolContext({
+        toolName,
+        context: getOwn(toolsContext, toolName),
+        contextSchema: tool == null ? void 0 : tool.contextSchema
+      }),
+      runtimeContext
+    }) : userDefinedToolApprovalStatus;
+    return normalizeToolApprovalStatus(approvalStatus);
+  }
+  if ((tool == null ? void 0 : tool.needsApproval) == null) {
+    return { type: "not-applicable" };
+  }
+  const needsApproval = typeof tool.needsApproval === "function" ? await tool.needsApproval(input, {
+    toolCallId: toolCall.toolCallId,
+    messages,
+    context: await validateToolContext({
+      toolName,
+      context: getOwn(toolsContext, toolName),
+      contextSchema: tool == null ? void 0 : tool.contextSchema
+    })
+  }) : tool.needsApproval;
+  return needsApproval ? { type: "user-approval" } : { type: "not-applicable" };
+}
+function normalizeToolApprovalStatus(status) {
+  return status === void 0 ? { type: "not-applicable" } : typeof status === "string" ? { type: status } : status;
+}
+
+// src/generate-text/validate-tool-approvals.ts
+async function validateApprovedToolApprovals({
+  approvedToolApprovals,
+  tools,
+  toolApproval,
+  messages,
+  toolsContext,
+  runtimeContext,
+  toolApprovalSecret
+}) {
+  var _a12;
+  const approved = [];
+  const denied = [];
+  const invalid = [];
+  for (const approval of approvedToolApprovals) {
+    const { toolCall, approvalRequest } = approval;
+    const tool = getOwn(tools, toolCall.toolName);
+    if (toolApprovalSecret != null) {
+      if (approvalRequest.signature == null) {
+        throw new InvalidToolApprovalSignatureError({
+          approvalId: approvalRequest.approvalId,
+          toolCallId: toolCall.toolCallId,
+          reason: "missing signature"
+        });
+      }
+      const valid = await verifyToolApprovalSignature({
+        secret: toolApprovalSecret,
+        signature: approvalRequest.signature,
+        approvalId: approvalRequest.approvalId,
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: toolCall.input
+      });
+      if (!valid) {
+        throw new InvalidToolApprovalSignatureError({
+          approvalId: approvalRequest.approvalId,
+          toolCallId: toolCall.toolCallId,
+          reason: "invalid signature"
+        });
+      }
+    }
+    if (isExecutableTool(tool) && tool.inputSchema != null) {
+      const validation = await safeValidateTypes3({
+        value: toolCall.input,
+        schema: asSchema3(tool.inputSchema)
+      });
+      if (!validation.success) {
+        invalid.push({
+          ...approval,
+          error: new InvalidToolInputError({
+            toolName: toolCall.toolName,
+            toolInput: JSON.stringify(toolCall.input),
+            cause: validation.error
+          })
+        });
+        continue;
+      }
+    }
+    const approvalStatus = await resolveToolApproval({
+      tools,
+      toolApproval,
+      toolCall,
+      messages,
+      toolsContext,
+      runtimeContext
+    });
+    if (approvalStatus.type === "denied") {
+      denied.push({
+        ...approval,
+        approvalResponse: {
+          ...approval.approvalResponse,
+          approved: false,
+          reason: (_a12 = approvalStatus.reason) != null ? _a12 : approval.approvalResponse.reason
+        }
+      });
+    } else {
+      approved.push(approval);
+    }
+  }
+  return {
+    approvedToolApprovals: approved,
+    deniedToolApprovals: denied,
+    invalidToolApprovals: invalid
+  };
+}
+
+// src/generate-text/to-response-messages.ts
+async function toResponseMessages({
+  content: inputContent,
+  tools
+}) {
+  const responseMessages = [];
+  const toolCallOrder = /* @__PURE__ */ new Map();
+  const content = [];
+  for (const part of inputContent) {
+    if (part.type === "source") {
+      continue;
+    }
+    if ((part.type === "tool-result" || part.type === "tool-error") && !part.providerExecuted) {
+      continue;
+    }
+    if (part.type === "text" && part.text.length === 0) {
+      continue;
+    }
+    switch (part.type) {
+      case "text":
+        content.push({
+          type: "text",
+          text: part.text,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "custom":
+        content.push({
+          type: "custom",
+          kind: part.kind,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "reasoning":
+        content.push({
+          type: "reasoning",
+          text: part.text,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "file":
+        content.push({
+          type: "file",
+          data: part.file.base64,
+          mediaType: part.file.mediaType,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "reasoning-file":
+        content.push({
+          type: "reasoning-file",
+          data: part.file.base64,
+          mediaType: part.file.mediaType,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "tool-call":
+        if (!toolCallOrder.has(part.toolCallId)) {
+          toolCallOrder.set(part.toolCallId, toolCallOrder.size);
+        }
+        content.push({
+          type: "tool-call",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.invalid && typeof part.input !== "object" ? {} : part.input,
+          providerExecuted: part.providerExecuted,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      case "tool-result": {
+        const output = await createToolModelOutput({
+          toolCallId: part.toolCallId,
+          input: part.input,
+          tool: getOwn(tools, part.toolName),
+          output: part.output,
+          errorMode: "none"
+        });
+        content.push({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          output,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      }
+      case "tool-error": {
+        const output = await createToolModelOutput({
+          toolCallId: part.toolCallId,
+          input: part.input,
+          tool: getOwn(tools, part.toolName),
+          output: part.error,
+          errorMode: "json"
+        });
+        content.push({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          output,
+          providerOptions: part.providerMetadata
+        });
+        break;
+      }
+      case "tool-approval-request":
+        content.push({
+          type: "tool-approval-request",
+          approvalId: part.approvalId,
+          toolCallId: part.toolCall.toolCallId,
+          ...part.reason != null ? { reason: part.reason } : {},
+          isAutomatic: part.isAutomatic,
+          ...part.signature != null ? { signature: part.signature } : {}
+        });
+        break;
+    }
+  }
+  if (content.length > 0) {
+    responseMessages.push({
+      role: "assistant",
+      content
+    });
+  }
+  const toolResultContent = [];
+  for (const part of inputContent) {
+    if (part.type !== "tool-approval-response" && part.type !== "tool-result" && part.type !== "tool-error") {
+      continue;
+    }
+    if (part.type === "tool-approval-response") {
+      toolResultContent.push({
+        type: "tool-approval-response",
+        approvalId: part.approvalId,
+        approved: part.approved,
+        reason: part.reason,
+        providerExecuted: part.providerExecuted
+      });
+      if (part.approved === false) {
+        toolResultContent.push({
+          type: "tool-result",
+          toolCallId: part.toolCall.toolCallId,
+          toolName: part.toolCall.toolName,
+          output: {
+            type: "execution-denied",
+            reason: part.reason
+          }
+        });
+      }
+      continue;
+    }
+    if (part.providerExecuted) {
+      continue;
+    }
+    const output = await createToolModelOutput({
+      toolCallId: part.toolCallId,
+      input: part.input,
+      tool: getOwn(tools, part.toolName),
+      output: part.type === "tool-result" ? part.output : part.error,
+      errorMode: part.type === "tool-error" ? "text" : "none"
+    });
+    toolResultContent.push({
+      type: "tool-result",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      output,
+      ...part.providerMetadata != null ? { providerOptions: part.providerMetadata } : {}
+    });
+  }
+  if (toolResultContent.length > 0) {
+    responseMessages.push({
+      role: "tool",
+      content: sortToolResultContentByToolCallOrder({
+        toolResultContent,
+        toolCallOrder
+      })
+    });
+  }
+  return responseMessages;
+}
+function sortToolResultContentByToolCallOrder({
+  toolResultContent,
+  toolCallOrder
+}) {
+  const sortedToolResults = toolResultContent.filter((part) => part.type === "tool-result").map((part, index) => ({ part, index })).sort((a, b) => {
+    const aOrder = toolCallOrder.get(a.part.toolCallId);
+    const bOrder = toolCallOrder.get(b.part.toolCallId);
+    if (aOrder == null && bOrder == null) {
+      return a.index - b.index;
+    }
+    if (aOrder == null) {
+      return 1;
+    }
+    if (bOrder == null) {
+      return -1;
+    }
+    return aOrder - bOrder || a.index - b.index;
+  }).map(({ part }) => part);
+  let toolResultIndex = 0;
+  return toolResultContent.map(
+    (part) => part.type === "tool-result" ? sortedToolResults[toolResultIndex++] : part
+  );
+}
+export {
+  DefaultStepResult,
+  addLanguageModelUsage,
+  asLanguageModelUsage,
+  collectToolApprovals,
+  convertAsyncIteratorToReadableStream,
+  convertToLanguageModelPrompt,
+  createAsyncIterableStream,
+  createDefaultDownloadFunction,
+  createNullLanguageModelUsage,
+  createRestrictedTelemetryDispatcher,
+  createTelemetryDispatcher,
+  createToolModelOutput,
+  downloadAssets,
+  mapToolResultOutput,
+  mergeAbortSignals,
+  mergeCallbacks,
+  parseToolCall,
+  prepareLanguageModelCallOptions as prepareCallSettings,
+  prepareLanguageModelCallOptions,
+  prepareRetries,
+  prepareToolChoice,
+  prepareTools,
+  resolveLanguageModel,
+  signToolApproval,
+  standardizePrompt,
+  toResponseMessages,
+  validateApprovedToolApprovals,
+  verifyToolApprovalSignature
+};
+//# sourceMappingURL=index.js.map