ai 5.0.5 → 5.0.7

package/dist/index.js

@@ -20,31 +20,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AISDKError: () => import_provider18.AISDKError,
-  APICallError: () => import_provider18.APICallError,
+  AISDKError: () => import_provider16.AISDKError,
+  APICallError: () => import_provider16.APICallError,
   AbstractChat: () => AbstractChat,
   DefaultChatTransport: () => DefaultChatTransport,
   DownloadError: () => DownloadError,
-  EmptyResponseBodyError: () => import_provider18.EmptyResponseBodyError,
+  EmptyResponseBodyError: () => import_provider16.EmptyResponseBodyError,
   Experimental_Agent: () => Agent,
   HttpChatTransport: () => HttpChatTransport,
   InvalidArgumentError: () => InvalidArgumentError,
   InvalidDataContentError: () => InvalidDataContentError,
   InvalidMessageRoleError: () => InvalidMessageRoleError,
-  InvalidPromptError: () => import_provider18.InvalidPromptError,
-  InvalidResponseDataError: () => import_provider18.InvalidResponseDataError,
+  InvalidPromptError: () => import_provider16.InvalidPromptError,
+  InvalidResponseDataError: () => import_provider16.InvalidResponseDataError,
   InvalidStreamPartError: () => InvalidStreamPartError,
   InvalidToolInputError: () => InvalidToolInputError,
-  JSONParseError: () => import_provider18.JSONParseError,
+  JSONParseError: () => import_provider16.JSONParseError,
   JsonToSseTransformStream: () => JsonToSseTransformStream,
-  LoadAPIKeyError: () => import_provider18.LoadAPIKeyError,
+  LoadAPIKeyError: () => import_provider16.LoadAPIKeyError,
   MCPClientError: () => MCPClientError,
   MessageConversionError: () => MessageConversionError,
-  NoContentGeneratedError: () => import_provider18.NoContentGeneratedError,
+  NoContentGeneratedError: () => import_provider16.NoContentGeneratedError,
   NoImageGeneratedError: () => NoImageGeneratedError,
   NoObjectGeneratedError: () => NoObjectGeneratedError,
   NoOutputSpecifiedError: () => NoOutputSpecifiedError,
-  NoSuchModelError: () => import_provider18.NoSuchModelError,
+  NoSuchModelError: () => import_provider16.NoSuchModelError,
   NoSuchProviderError: () => NoSuchProviderError,
   NoSuchToolError: () => NoSuchToolError,
   Output: () => output_exports,
@@ -52,9 +52,9 @@ __export(src_exports, {
   SerialJobExecutor: () => SerialJobExecutor,
   TextStreamChatTransport: () => TextStreamChatTransport,
   ToolCallRepairError: () => ToolCallRepairError,
-  TypeValidationError: () => import_provider18.TypeValidationError,
+  TypeValidationError: () => import_provider16.TypeValidationError,
   UI_MESSAGE_STREAM_HEADERS: () => UI_MESSAGE_STREAM_HEADERS,
-  UnsupportedFunctionalityError: () => import_provider18.UnsupportedFunctionalityError,
+  UnsupportedFunctionalityError: () => import_provider16.UnsupportedFunctionalityError,
   UnsupportedModelVersionError: () => UnsupportedModelVersionError,
   asSchema: () => import_provider_utils28.asSchema,
   assistantModelMessageSchema: () => assistantModelMessageSchema,
@@ -139,10 +139,11 @@ var NoOutputSpecifiedError = class extends import_provider.AISDKError {
 };
 _a = symbol;
 
-// src/util/as-array.ts
-function asArray(value) {
-  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
-}
+// src/model/resolve-model.ts
+var import_gateway = require("@ai-sdk/gateway");
+
+// src/error/index.ts
+var import_provider16 = require("@ai-sdk/provider");
 
 // src/error/invalid-argument-error.ts
 var import_provider2 = require("@ai-sdk/provider");
@@ -170,27 +171,20 @@ var InvalidArgumentError = class extends import_provider2.AISDKError {
 };
 _a2 = symbol2;
 
-// src/util/retry-with-exponential-backoff.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-
-// src/util/retry-error.ts
+// src/error/invalid-stream-part-error.ts
 var import_provider3 = require("@ai-sdk/provider");
-var name3 = "AI_RetryError";
+var name3 = "AI_InvalidStreamPartError";
 var marker3 = `vercel.ai.error.${name3}`;
 var symbol3 = Symbol.for(marker3);
 var _a3;
-var RetryError = class extends import_provider3.AISDKError {
+var InvalidStreamPartError = class extends import_provider3.AISDKError {
   constructor({
-    message,
-    reason,
-    errors
+    chunk,
+    message
   }) {
     super({ name: name3, message });
     this[_a3] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
+    this.chunk = chunk;
   }
   static isInstance(error) {
     return import_provider3.AISDKError.hasMarker(error, marker3);
@@ -198,179 +192,354 @@ var RetryError = class extends import_provider3.AISDKError {
 };
 _a3 = symbol3;
 
-// src/util/retry-with-exponential-backoff.ts
-function getRetryDelayInMs({
-  error,
-  exponentialBackoffDelay
-}) {
-  const headers = error.responseHeaders;
-  if (!headers)
-    return exponentialBackoffDelay;
-  let ms;
-  const retryAfterMs = headers["retry-after-ms"];
-  if (retryAfterMs) {
-    const timeoutMs = parseFloat(retryAfterMs);
-    if (!Number.isNaN(timeoutMs)) {
-      ms = timeoutMs;
-    }
+// src/error/invalid-tool-input-error.ts
+var import_provider4 = require("@ai-sdk/provider");
+var name4 = "AI_InvalidToolInputError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidToolInputError = class extends import_provider4.AISDKError {
+  constructor({
+    toolInput,
+    toolName,
+    cause,
+    message = `Invalid input for tool ${toolName}: ${(0, import_provider4.getErrorMessage)(cause)}`
+  }) {
+    super({ name: name4, message, cause });
+    this[_a4] = true;
+    this.toolInput = toolInput;
+    this.toolName = toolName;
   }
-  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();
-    }
+  static isInstance(error) {
+    return import_provider4.AISDKError.hasMarker(error, marker4);
   }
-  if (ms != null && !Number.isNaN(ms) && 0 <= ms && (ms < 60 * 1e3 || ms < exponentialBackoffDelay)) {
-    return ms;
+};
+_a4 = symbol4;
+
+// src/error/mcp-client-error.ts
+var import_provider5 = require("@ai-sdk/provider");
+var name5 = "AI_MCPClientError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var MCPClientError = class extends import_provider5.AISDKError {
+  constructor({
+    name: name16 = "MCPClientError",
+    message,
+    cause
+  }) {
+    super({ name: name16, message, cause });
+    this[_a5] = true;
   }
-  return exponentialBackoffDelay;
-}
-var retryWithExponentialBackoffRespectingRetryHeaders = ({
-  maxRetries = 2,
-  initialDelayInMs = 2e3,
-  backoffFactor = 2,
-  abortSignal
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor,
-  abortSignal
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor,
-  abortSignal
-}, errors = []) {
-  try {
-    return await f();
-  } catch (error) {
-    if ((0, import_provider_utils.isAbortError)(error)) {
-      throw error;
-    }
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = (0, import_provider_utils.getErrorMessage)(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
-      });
-    }
-    if (error instanceof Error && import_provider4.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await (0, import_provider_utils.delay)(
-        getRetryDelayInMs({
-          error,
-          exponentialBackoffDelay: delayInMs
-        }),
-        { abortSignal }
-      );
-      return _retryWithExponentialBackoff(
-        f,
-        {
-          maxRetries,
-          delayInMs: backoffFactor * delayInMs,
-          backoffFactor,
-          abortSignal
-        },
-        newErrors
-      );
-    }
-    if (tryNumber === 1) {
-      throw error;
-    }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
+  static isInstance(error) {
+    return import_provider5.AISDKError.hasMarker(error, marker5);
   }
-}
+};
+_a5 = symbol5;
 
-// src/util/prepare-retries.ts
-function prepareRetries({
-  maxRetries,
-  abortSignal
-}) {
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
+// src/error/no-image-generated-error.ts
+var import_provider6 = require("@ai-sdk/provider");
+var name6 = "AI_NoImageGeneratedError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var NoImageGeneratedError = class extends import_provider6.AISDKError {
+  constructor({
+    message = "No image generated.",
+    cause,
+    responses
+  }) {
+    super({ name: name6, message, cause });
+    this[_a6] = true;
+    this.responses = responses;
   }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
-  return {
-    maxRetries: maxRetriesResult,
-    retry: retryWithExponentialBackoffRespectingRetryHeaders({
-      maxRetries: maxRetriesResult,
-      abortSignal
-    })
-  };
-}
+  static isInstance(error) {
+    return import_provider6.AISDKError.hasMarker(error, marker6);
+  }
+};
+_a6 = symbol6;
 
-// src/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+// src/error/no-object-generated-error.ts
+var import_provider7 = require("@ai-sdk/provider");
+var name7 = "AI_NoObjectGeneratedError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var NoObjectGeneratedError = class extends import_provider7.AISDKError {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage,
+    finishReason
+  }) {
+    super({ name: name7, message, cause });
+    this[_a7] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+  static isInstance(error) {
+    return import_provider7.AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
 
-// src/util/detect-media-type.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var imageMediaTypeSignatures = [
-  {
-    mediaType: "image/gif",
-    bytesPrefix: [71, 73, 70],
-    base64Prefix: "R0lG"
-  },
-  {
-    mediaType: "image/png",
-    bytesPrefix: [137, 80, 78, 71],
-    base64Prefix: "iVBORw"
-  },
-  {
-    mediaType: "image/jpeg",
-    bytesPrefix: [255, 216],
-    base64Prefix: "/9j/"
-  },
-  {
-    mediaType: "image/webp",
-    bytesPrefix: [82, 73, 70, 70],
-    base64Prefix: "UklGRg"
-  },
-  {
-    mediaType: "image/bmp",
-    bytesPrefix: [66, 77],
-    base64Prefix: "Qk"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0],
-    base64Prefix: "SUkqAA"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42],
-    base64Prefix: "TU0AKg"
-  },
-  {
-    mediaType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
+// src/error/no-such-tool-error.ts
+var import_provider8 = require("@ai-sdk/provider");
+var name8 = "AI_NoSuchToolError";
+var marker8 = `vercel.ai.error.${name8}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var NoSuchToolError = class extends import_provider8.AISDKError {
+  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: name8, message });
+    this[_a8] = true;
+    this.toolName = toolName;
+    this.availableTools = availableTools;
+  }
+  static isInstance(error) {
+    return import_provider8.AISDKError.hasMarker(error, marker8);
+  }
+};
+_a8 = symbol8;
+
+// src/error/tool-call-repair-error.ts
+var import_provider9 = require("@ai-sdk/provider");
+var name9 = "AI_ToolCallRepairError";
+var marker9 = `vercel.ai.error.${name9}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+var ToolCallRepairError = class extends import_provider9.AISDKError {
+  constructor({
+    cause,
+    originalError,
+    message = `Error repairing tool call: ${(0, import_provider9.getErrorMessage)(cause)}`
+  }) {
+    super({ name: name9, message, cause });
+    this[_a9] = true;
+    this.originalError = originalError;
+  }
+  static isInstance(error) {
+    return import_provider9.AISDKError.hasMarker(error, marker9);
+  }
+};
+_a9 = symbol9;
+
+// src/error/unsupported-model-version-error.ts
+var import_provider10 = require("@ai-sdk/provider");
+var UnsupportedModelVersionError = class extends import_provider10.AISDKError {
+  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/prompt/invalid-data-content-error.ts
+var import_provider11 = require("@ai-sdk/provider");
+var name10 = "AI_InvalidDataContentError";
+var marker10 = `vercel.ai.error.${name10}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+var InvalidDataContentError = class extends import_provider11.AISDKError {
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  }) {
+    super({ name: name10, message, cause });
+    this[_a10] = true;
+    this.content = content;
+  }
+  static isInstance(error) {
+    return import_provider11.AISDKError.hasMarker(error, marker10);
+  }
+};
+_a10 = symbol10;
+
+// src/prompt/invalid-message-role-error.ts
+var import_provider12 = require("@ai-sdk/provider");
+var name11 = "AI_InvalidMessageRoleError";
+var marker11 = `vercel.ai.error.${name11}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+var InvalidMessageRoleError = class extends import_provider12.AISDKError {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name11, message });
+    this[_a11] = true;
+    this.role = role;
+  }
+  static isInstance(error) {
+    return import_provider12.AISDKError.hasMarker(error, marker11);
+  }
+};
+_a11 = symbol11;
+
+// src/prompt/message-conversion-error.ts
+var import_provider13 = require("@ai-sdk/provider");
+var name12 = "AI_MessageConversionError";
+var marker12 = `vercel.ai.error.${name12}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+var MessageConversionError = class extends import_provider13.AISDKError {
+  constructor({
+    originalMessage,
+    message
+  }) {
+    super({ name: name12, message });
+    this[_a12] = true;
+    this.originalMessage = originalMessage;
+  }
+  static isInstance(error) {
+    return import_provider13.AISDKError.hasMarker(error, marker12);
+  }
+};
+_a12 = symbol12;
+
+// src/util/download-error.ts
+var import_provider14 = require("@ai-sdk/provider");
+var name13 = "AI_DownloadError";
+var marker13 = `vercel.ai.error.${name13}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var DownloadError = class extends import_provider14.AISDKError {
+  constructor({
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+  }) {
+    super({ name: name13, message, cause });
+    this[_a13] = true;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+  static isInstance(error) {
+    return import_provider14.AISDKError.hasMarker(error, marker13);
+  }
+};
+_a13 = symbol13;
+
+// src/util/retry-error.ts
+var import_provider15 = require("@ai-sdk/provider");
+var name14 = "AI_RetryError";
+var marker14 = `vercel.ai.error.${name14}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var RetryError = class extends import_provider15.AISDKError {
+  constructor({
+    message,
+    reason,
+    errors
+  }) {
+    super({ name: name14, message });
+    this[_a14] = true;
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
+  }
+  static isInstance(error) {
+    return import_provider15.AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
+
+// src/model/resolve-model.ts
+function resolveLanguageModel(model) {
+  if (typeof model !== "string") {
+    if (model.specificationVersion !== "v2") {
+      throw new UnsupportedModelVersionError({
+        version: model.specificationVersion,
+        provider: model.provider,
+        modelId: model.modelId
+      });
+    }
+    return model;
+  }
+  return getGlobalProvider().languageModel(model);
+}
+function resolveEmbeddingModel(model) {
+  if (typeof model !== "string") {
+    if (model.specificationVersion !== "v2") {
+      throw new UnsupportedModelVersionError({
+        version: model.specificationVersion,
+        provider: model.provider,
+        modelId: model.modelId
+      });
+    }
+    return model;
+  }
+  return getGlobalProvider().textEmbeddingModel(
+    model
+  );
+}
+function getGlobalProvider() {
+  var _a16;
+  return (_a16 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a16 : import_gateway.gateway;
+}
+
+// src/prompt/convert-to-language-model-prompt.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+
+// src/util/detect-media-type.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var imageMediaTypeSignatures = [
+  {
+    mediaType: "image/gif",
+    bytesPrefix: [71, 73, 70],
+    base64Prefix: "R0lG"
+  },
+  {
+    mediaType: "image/png",
+    bytesPrefix: [137, 80, 78, 71],
+    base64Prefix: "iVBORw"
+  },
+  {
+    mediaType: "image/jpeg",
+    bytesPrefix: [255, 216],
+    base64Prefix: "/9j/"
+  },
+  {
+    mediaType: "image/webp",
+    bytesPrefix: [82, 73, 70, 70],
+    base64Prefix: "UklGRg"
+  },
+  {
+    mediaType: "image/bmp",
+    bytesPrefix: [66, 77],
+    base64Prefix: "Qk"
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [73, 73, 42, 0],
+    base64Prefix: "SUkqAA"
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [77, 77, 0, 42],
+    base64Prefix: "TU0AKg"
+  },
+  {
+    mediaType: "image/avif",
+    bytesPrefix: [
+      0,
+      0,
       0,
       32,
       102,
@@ -441,7 +610,7 @@ var audioMediaTypeSignatures = [
   }
 ];
 var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? (0, import_provider_utils2.convertBase64ToUint8Array)(data) : data;
+  const bytes = typeof data === "string" ? (0, import_provider_utils.convertBase64ToUint8Array)(data) : data;
   const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
   return bytes.slice(id3Size + 10);
 };
@@ -466,32 +635,6 @@ function detectMediaType({
   return void 0;
 }
 
-// src/util/download-error.ts
-var import_provider5 = require("@ai-sdk/provider");
-var name4 = "AI_DownloadError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var DownloadError = class extends import_provider5.AISDKError {
-  constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
-  }) {
-    super({ name: name4, message, cause });
-    this[_a4] = true;
-    this.url = url;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-  }
-  static isInstance(error) {
-    return import_provider5.AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-
 // src/util/download.ts
 async function download({ url }) {
   var _a16;
@@ -518,32 +661,10 @@ async function download({ url }) {
 }
 
 // src/prompt/data-content.ts
-var import_provider7 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider17 = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_v4 = require("zod/v4");
 
-// src/prompt/invalid-data-content-error.ts
-var import_provider6 = require("@ai-sdk/provider");
-var name5 = "AI_InvalidDataContentError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var InvalidDataContentError = class extends import_provider6.AISDKError {
-  constructor({
-    content,
-    cause,
-    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
-  }) {
-    super({ name: name5, message, cause });
-    this[_a5] = true;
-    this.content = content;
-  }
-  static isInstance(error) {
-    return import_provider6.AISDKError.hasMarker(error, marker5);
-  }
-};
-_a5 = symbol5;
-
 // src/prompt/split-data-url.ts
 function splitDataUrl(dataUrl) {
   try {
@@ -592,7 +713,7 @@ function convertToLanguageModelV2DataContent(content) {
       content.toString()
     );
     if (dataUrlMediaType == null || base64Content == null) {
-      throw new import_provider7.AISDKError({
+      throw new import_provider17.AISDKError({
         name: "InvalidDataContentError",
         message: `Invalid data URL format in content ${content.toString()}`
       });
@@ -606,9 +727,9 @@ function convertDataContentToBase64String(content) {
     return content;
   }
   if (content instanceof ArrayBuffer) {
-    return (0, import_provider_utils3.convertUint8ArrayToBase64)(new Uint8Array(content));
+    return (0, import_provider_utils2.convertUint8ArrayToBase64)(new Uint8Array(content));
   }
-  return (0, import_provider_utils3.convertUint8ArrayToBase64)(content);
+  return (0, import_provider_utils2.convertUint8ArrayToBase64)(content);
 }
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
@@ -616,7 +737,7 @@ function convertDataContentToUint8Array(content) {
   }
   if (typeof content === "string") {
     try {
-      return (0, import_provider_utils3.convertBase64ToUint8Array)(content);
+      return (0, import_provider_utils2.convertBase64ToUint8Array)(content);
     } catch (error) {
       throw new InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
@@ -631,27 +752,6 @@ function convertDataContentToUint8Array(content) {
   throw new InvalidDataContentError({ content });
 }
 
-// src/prompt/invalid-message-role-error.ts
-var import_provider8 = require("@ai-sdk/provider");
-var name6 = "AI_InvalidMessageRoleError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var InvalidMessageRoleError = class extends import_provider8.AISDKError {
-  constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
-  }) {
-    super({ name: name6, message });
-    this[_a6] = true;
-    this.role = role;
-  }
-  static isInstance(error) {
-    return import_provider8.AISDKError.hasMarker(error, marker6);
-  }
-};
-_a6 = symbol6;
-
 // src/prompt/convert-to-language-model-prompt.ts
 async function convertToLanguageModelPrompt({
   prompt,
@@ -799,7 +899,7 @@ async function downloadAssets(messages, downloadImplementation, supportedUrls) {
     }
     return { mediaType, data };
   }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils4.isUrlSupported)({
+    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils3.isUrlSupported)({
       url: part.data.toString(),
       mediaType: part.mediaType,
       supportedUrls
@@ -911,338 +1011,120 @@ function prepareCallSettings({
       });
     }
   }
-  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
-  };
-}
-
-// src/prompt/prepare-tools-and-tool-choice.ts
-var import_provider_utils5 = require("@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-and-tool-choice.ts
-function prepareToolsAndToolChoice({
-  tools,
-  toolChoice,
-  activeTools
-}) {
-  if (!isNonEmptyObject(tools)) {
-    return {
-      tools: void 0,
-      toolChoice: void 0
-    };
-  }
-  const filteredTools = activeTools != null ? Object.entries(tools).filter(
-    ([name16]) => activeTools.includes(name16)
-  ) : Object.entries(tools);
-  return {
-    tools: filteredTools.map(([name16, tool3]) => {
-      const toolType = tool3.type;
-      switch (toolType) {
-        case void 0:
-        case "dynamic":
-        case "function":
-          return {
-            type: "function",
-            name: name16,
-            description: tool3.description,
-            inputSchema: (0, import_provider_utils5.asSchema)(tool3.inputSchema).jsonSchema,
-            providerOptions: tool3.providerOptions
-          };
-        case "provider-defined":
-          return {
-            type: "provider-defined",
-            name: name16,
-            id: tool3.id,
-            args: tool3.args
-          };
-        default: {
-          const exhaustiveCheck = toolType;
-          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
-        }
-      }
-    }),
-    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
-  };
-}
-
-// src/prompt/resolve-language-model.ts
-var import_gateway = require("@ai-sdk/gateway");
-
-// src/error/index.ts
-var import_provider18 = require("@ai-sdk/provider");
-
-// src/error/invalid-stream-part-error.ts
-var import_provider9 = require("@ai-sdk/provider");
-var name7 = "AI_InvalidStreamPartError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var InvalidStreamPartError = class extends import_provider9.AISDKError {
-  constructor({
-    chunk,
-    message
-  }) {
-    super({ name: name7, message });
-    this[_a7] = true;
-    this.chunk = chunk;
-  }
-  static isInstance(error) {
-    return import_provider9.AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-
-// src/error/invalid-tool-input-error.ts
-var import_provider10 = require("@ai-sdk/provider");
-var name8 = "AI_InvalidToolInputError";
-var marker8 = `vercel.ai.error.${name8}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-var InvalidToolInputError = class extends import_provider10.AISDKError {
-  constructor({
-    toolInput,
-    toolName,
-    cause,
-    message = `Invalid input for tool ${toolName}: ${(0, import_provider10.getErrorMessage)(cause)}`
-  }) {
-    super({ name: name8, message, cause });
-    this[_a8] = true;
-    this.toolInput = toolInput;
-    this.toolName = toolName;
-  }
-  static isInstance(error) {
-    return import_provider10.AISDKError.hasMarker(error, marker8);
-  }
-};
-_a8 = symbol8;
-
-// src/error/mcp-client-error.ts
-var import_provider11 = require("@ai-sdk/provider");
-var name9 = "AI_MCPClientError";
-var marker9 = `vercel.ai.error.${name9}`;
-var symbol9 = Symbol.for(marker9);
-var _a9;
-var MCPClientError = class extends import_provider11.AISDKError {
-  constructor({
-    name: name16 = "MCPClientError",
-    message,
-    cause
-  }) {
-    super({ name: name16, message, cause });
-    this[_a9] = true;
-  }
-  static isInstance(error) {
-    return import_provider11.AISDKError.hasMarker(error, marker9);
-  }
-};
-_a9 = symbol9;
-
-// src/error/no-image-generated-error.ts
-var import_provider12 = require("@ai-sdk/provider");
-var name10 = "AI_NoImageGeneratedError";
-var marker10 = `vercel.ai.error.${name10}`;
-var symbol10 = Symbol.for(marker10);
-var _a10;
-var NoImageGeneratedError = class extends import_provider12.AISDKError {
-  constructor({
-    message = "No image generated.",
-    cause,
-    responses
-  }) {
-    super({ name: name10, message, cause });
-    this[_a10] = true;
-    this.responses = responses;
-  }
-  static isInstance(error) {
-    return import_provider12.AISDKError.hasMarker(error, marker10);
-  }
-};
-_a10 = symbol10;
-
-// src/error/no-object-generated-error.ts
-var import_provider13 = require("@ai-sdk/provider");
-var name11 = "AI_NoObjectGeneratedError";
-var marker11 = `vercel.ai.error.${name11}`;
-var symbol11 = Symbol.for(marker11);
-var _a11;
-var NoObjectGeneratedError = class extends import_provider13.AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name11, message, cause });
-    this[_a11] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error) {
-    return import_provider13.AISDKError.hasMarker(error, marker11);
-  }
-};
-_a11 = symbol11;
-
-// src/error/no-such-tool-error.ts
-var import_provider14 = require("@ai-sdk/provider");
-var name12 = "AI_NoSuchToolError";
-var marker12 = `vercel.ai.error.${name12}`;
-var symbol12 = Symbol.for(marker12);
-var _a12;
-var NoSuchToolError = class extends import_provider14.AISDKError {
-  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: name12, message });
-    this[_a12] = true;
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-  static isInstance(error) {
-    return import_provider14.AISDKError.hasMarker(error, marker12);
-  }
-};
-_a12 = symbol12;
-
-// src/error/tool-call-repair-error.ts
-var import_provider15 = require("@ai-sdk/provider");
-var name13 = "AI_ToolCallRepairError";
-var marker13 = `vercel.ai.error.${name13}`;
-var symbol13 = Symbol.for(marker13);
-var _a13;
-var ToolCallRepairError = class extends import_provider15.AISDKError {
-  constructor({
-    cause,
-    originalError,
-    message = `Error repairing tool call: ${(0, import_provider15.getErrorMessage)(cause)}`
-  }) {
-    super({ name: name13, message, cause });
-    this[_a13] = true;
-    this.originalError = originalError;
-  }
-  static isInstance(error) {
-    return import_provider15.AISDKError.hasMarker(error, marker13);
-  }
-};
-_a13 = symbol13;
-
-// src/error/unsupported-model-version-error.ts
-var import_provider16 = require("@ai-sdk/provider");
-var UnsupportedModelVersionError = class extends import_provider16.AISDKError {
-  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/prompt/message-conversion-error.ts
-var import_provider17 = require("@ai-sdk/provider");
-var name14 = "AI_MessageConversionError";
-var marker14 = `vercel.ai.error.${name14}`;
-var symbol14 = Symbol.for(marker14);
-var _a14;
-var MessageConversionError = class extends import_provider17.AISDKError {
-  constructor({
-    originalMessage,
-    message
-  }) {
-    super({ name: name14, message });
-    this[_a14] = true;
-    this.originalMessage = originalMessage;
+  if (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topP",
+        value: topP,
+        message: "topP must be a number"
+      });
+    }
   }
-  static isInstance(error) {
-    return import_provider17.AISDKError.hasMarker(error, marker14);
+  if (topK != null) {
+    if (typeof topK !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topK",
+        value: topK,
+        message: "topK must be a number"
+      });
+    }
   }
-};
-_a14 = symbol14;
-
-// src/prompt/resolve-language-model.ts
-function resolveLanguageModel(model) {
-  if (typeof model !== "string") {
-    if (model.specificationVersion !== "v2") {
-      throw new UnsupportedModelVersionError({
-        version: model.specificationVersion,
-        provider: model.provider,
-        modelId: model.modelId
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: presencePenalty,
+        message: "presencePenalty must be a number"
       });
     }
-    return model;
   }
-  const globalProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
-  return (globalProvider != null ? globalProvider : import_gateway.gateway).languageModel(model);
+  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
+  };
+}
+
+// src/prompt/prepare-tools-and-tool-choice.ts
+var import_provider_utils4 = require("@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-and-tool-choice.ts
+function prepareToolsAndToolChoice({
+  tools,
+  toolChoice,
+  activeTools
+}) {
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: void 0,
+      toolChoice: void 0
+    };
+  }
+  const filteredTools = activeTools != null ? Object.entries(tools).filter(
+    ([name16]) => activeTools.includes(name16)
+  ) : Object.entries(tools);
+  return {
+    tools: filteredTools.map(([name16, tool3]) => {
+      const toolType = tool3.type;
+      switch (toolType) {
+        case void 0:
+        case "dynamic":
+        case "function":
+          return {
+            type: "function",
+            name: name16,
+            description: tool3.description,
+            inputSchema: (0, import_provider_utils4.asSchema)(tool3.inputSchema).jsonSchema,
+            providerOptions: tool3.providerOptions
+          };
+        case "provider-defined":
+          return {
+            type: "provider-defined",
+            name: name16,
+            id: tool3.id,
+            args: tool3.args
+          };
+        default: {
+          const exhaustiveCheck = toolType;
+          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+        }
+      }
+    }),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
 }
 
 // src/prompt/standardize-prompt.ts
-var import_provider19 = require("@ai-sdk/provider");
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_provider18 = require("@ai-sdk/provider");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 var import_v46 = require("zod/v4");
 
 // src/prompt/message.ts
@@ -1397,19 +1279,19 @@ var coreMessageSchema = modelMessageSchema;
 // src/prompt/standardize-prompt.ts
 async function standardizePrompt(prompt) {
   if (prompt.prompt == null && prompt.messages == null) {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
   if (prompt.prompt != null && prompt.messages != null) {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "prompt and messages cannot be defined at the same time"
     });
   }
   if (prompt.system != null && typeof prompt.system !== "string") {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "system must be a string"
     });
@@ -1422,23 +1304,23 @@ async function standardizePrompt(prompt) {
   } else if (prompt.messages != null) {
     messages = prompt.messages;
   } else {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
   if (messages.length === 0) {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "messages must not be empty"
     });
   }
-  const validationResult = await (0, import_provider_utils6.safeValidateTypes)({
+  const validationResult = await (0, import_provider_utils5.safeValidateTypes)({
     value: messages,
     schema: import_v46.z.array(modelMessageSchema)
   });
   if (!validationResult.success) {
-    throw new import_provider19.InvalidPromptError({
+    throw new import_provider18.InvalidPromptError({
       prompt,
       message: "The messages must be a ModelMessage[]. If you have passed a UIMessage[], you can use convertToModelMessages to convert them.",
       cause: validationResult.error
@@ -1452,10 +1334,10 @@ async function standardizePrompt(prompt) {
 
 // src/prompt/wrap-gateway-error.ts
 var import_gateway2 = require("@ai-sdk/gateway");
-var import_provider20 = require("@ai-sdk/provider");
+var import_provider19 = require("@ai-sdk/provider");
 function wrapGatewayError(error) {
   if (import_gateway2.GatewayAuthenticationError.isInstance(error) || import_gateway2.GatewayModelNotFoundError.isInstance(error)) {
-    return new import_provider20.AISDKError({
+    return new import_provider19.AISDKError({
       name: "GatewayError",
       message: "Vercel AI Gateway access failed. If you want to use AI SDK providers directly, use the providers, e.g. @ai-sdk/openai, or register a different global default provider.",
       cause: error
@@ -1691,9 +1573,143 @@ function addLanguageModelUsage(usage1, usage2) {
     )
   };
 }
-function addTokenCounts(tokenCount1, tokenCount2) {
-  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
-}
+function addTokenCounts(tokenCount1, tokenCount2) {
+  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
+}
+
+// src/util/as-array.ts
+function asArray(value) {
+  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
+
+// src/util/retry-with-exponential-backoff.ts
+var import_provider20 = require("@ai-sdk/provider");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+function getRetryDelayInMs({
+  error,
+  exponentialBackoffDelay
+}) {
+  const headers = error.responseHeaders;
+  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
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor,
+  abortSignal
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor,
+  abortSignal
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error) {
+    if ((0, import_provider_utils6.isAbortError)(error)) {
+      throw error;
+    }
+    if (maxRetries === 0) {
+      throw error;
+    }
+    const errorMessage = (0, import_provider_utils6.getErrorMessage)(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error && import_provider20.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await (0, import_provider_utils6.delay)(
+        getRetryDelayInMs({
+          error,
+          exponentialBackoffDelay: delayInMs
+        }),
+        { abortSignal }
+      );
+      return _retryWithExponentialBackoff(
+        f,
+        {
+          maxRetries,
+          delayInMs: backoffFactor * delayInMs,
+          backoffFactor,
+          abortSignal
+        },
+        newErrors
+      );
+    }
+    if (tryNumber === 1) {
+      throw error;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
+}
+
+// src/util/prepare-retries.ts
+function prepareRetries({
+  maxRetries,
+  abortSignal
+}) {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoffRespectingRetryHeaders({
+      maxRetries: maxRetriesResult,
+      abortSignal
+    })
+  };
+}
 
 // src/generate-text/extract-content-text.ts
 function extractContentText(content) {
@@ -1749,38 +1765,50 @@ async function parseToolCall({
   system,
   messages
 }) {
-  if (tools == null) {
-    throw new NoSuchToolError({ toolName: toolCall.toolName });
-  }
   try {
-    return await doParseToolCall({ toolCall, tools });
-  } catch (error) {
-    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
-      throw error;
+    if (tools == null) {
+      throw new NoSuchToolError({ toolName: toolCall.toolName });
     }
-    let repairedToolCall = null;
     try {
-      repairedToolCall = await repairToolCall({
-        toolCall,
-        tools,
-        inputSchema: ({ toolName }) => {
-          const { inputSchema } = tools[toolName];
-          return (0, import_provider_utils8.asSchema)(inputSchema).jsonSchema;
-        },
-        system,
-        messages,
-        error
-      });
-    } catch (repairError) {
-      throw new ToolCallRepairError({
-        cause: repairError,
-        originalError: error
-      });
-    }
-    if (repairedToolCall == null) {
-      throw error;
+      return await doParseToolCall({ toolCall, tools });
+    } catch (error) {
+      if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
+        throw error;
+      }
+      let repairedToolCall = null;
+      try {
+        repairedToolCall = await repairToolCall({
+          toolCall,
+          tools,
+          inputSchema: ({ toolName }) => {
+            const { inputSchema } = tools[toolName];
+            return (0, import_provider_utils8.asSchema)(inputSchema).jsonSchema;
+          },
+          system,
+          messages,
+          error
+        });
+      } catch (repairError) {
+        throw new ToolCallRepairError({
+          cause: repairError,
+          originalError: error
+        });
+      }
+      if (repairedToolCall == null) {
+        throw error;
+      }
+      return await doParseToolCall({ toolCall: repairedToolCall, tools });
     }
-    return await doParseToolCall({ toolCall: repairedToolCall, tools });
+  } catch (error) {
+    return {
+      type: "tool-call",
+      toolCallId: toolCall.toolCallId,
+      toolName: toolCall.toolName,
+      input: toolCall.input,
+      dynamic: true,
+      invalid: true,
+      error
+    };
   }
 }
 async function doParseToolCall({
@@ -2230,6 +2258,9 @@ async function generateText({
             )
           );
           for (const toolCall of stepToolCalls) {
+            if (toolCall.invalid) {
+              continue;
+            }
             const tool3 = tools[toolCall.toolName];
             if ((tool3 == null ? void 0 : tool3.onInputAvailable) != null) {
               await tool3.onInputAvailable({
@@ -2241,18 +2272,38 @@ async function generateText({
               });
             }
           }
+          const invalidToolCalls = stepToolCalls.filter(
+            (toolCall) => toolCall.invalid && toolCall.dynamic
+          );
+          clientToolOutputs = [];
+          for (const toolCall of invalidToolCalls) {
+            clientToolOutputs.push({
+              type: "tool-error",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input,
+              error: (0, import_provider_utils9.getErrorMessage)(toolCall.error),
+              dynamic: true
+            });
+          }
           clientToolCalls = stepToolCalls.filter(
-            (toolCall) => toolCall.providerExecuted !== true
+            (toolCall) => !toolCall.providerExecuted
           );
-          clientToolOutputs = tools == null ? [] : await executeTools({
-            toolCalls: clientToolCalls,
-            tools,
-            tracer,
-            telemetry,
-            messages: stepInputMessages,
-            abortSignal,
-            experimental_context
-          });
+          if (tools != null) {
+            clientToolOutputs.push(
+              ...await executeTools({
+                toolCalls: clientToolCalls.filter(
+                  (toolCall) => !toolCall.invalid
+                ),
+                tools,
+                tracer,
+                telemetry,
+                messages: stepInputMessages,
+                abortSignal,
+                experimental_context
+              })
+            );
+          }
           const stepContent = asContent({
             content: currentModelResponse.content,
             toolCalls: stepToolCalls,
@@ -2744,6 +2795,16 @@ var uiMessageChunkSchema = import_v47.z.union([
     providerMetadata: providerMetadataSchema.optional(),
     dynamic: import_v47.z.boolean().optional()
   }),
+  import_v47.z.strictObject({
+    type: import_v47.z.literal("tool-input-error"),
+    toolCallId: import_v47.z.string(),
+    toolName: import_v47.z.string(),
+    input: import_v47.z.unknown(),
+    providerExecuted: import_v47.z.boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: import_v47.z.boolean().optional(),
+    errorText: import_v47.z.string()
+  }),
   import_v47.z.strictObject({
     type: import_v47.z.literal("tool-output-available"),
     toolCallId: import_v47.z.string(),
@@ -3283,6 +3344,7 @@ function processUIMessageStream({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
+              anyPart.rawInput = anyOptions.rawInput;
               anyPart.providerExecuted = (_a17 = anyOptions.providerExecuted) != null ? _a17 : part.providerExecuted;
               if (anyOptions.providerMetadata != null && part.state === "input-available") {
                 part.callProviderMetadata = anyOptions.providerMetadata;
@@ -3294,6 +3356,7 @@ function processUIMessageStream({
                 state: options.state,
                 input: anyOptions.input,
                 output: anyOptions.output,
+                rawInput: anyOptions.rawInput,
                 errorText: anyOptions.errorText,
                 providerExecuted: anyOptions.providerExecuted,
                 ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
@@ -3301,6 +3364,7 @@ function processUIMessageStream({
             }
           }
           function updateDynamicToolPart(options) {
+            var _a17;
             const part = state.message.parts.find(
               (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
             );
@@ -3312,6 +3376,7 @@ function processUIMessageStream({
               anyPart.input = anyOptions.input;
               anyPart.output = anyOptions.output;
               anyPart.errorText = anyOptions.errorText;
+              anyPart.rawInput = (_a17 = anyOptions.rawInput) != null ? _a17 : anyPart.rawInput;
               if (anyOptions.providerMetadata != null && part.state === "input-available") {
                 part.callProviderMetadata = anyOptions.providerMetadata;
               }
@@ -3505,6 +3570,31 @@ function processUIMessageStream({
               }
               break;
             }
+            case "tool-input-error": {
+              if (chunk.dynamic) {
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "output-error",
+                  input: chunk.input,
+                  errorText: chunk.errorText,
+                  providerMetadata: chunk.providerMetadata
+                });
+              } else {
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "output-error",
+                  input: void 0,
+                  rawInput: chunk.input,
+                  errorText: chunk.errorText,
+                  providerExecuted: chunk.providerExecuted,
+                  providerMetadata: chunk.providerMetadata
+                });
+              }
+              write();
+              break;
+            }
             case "tool-output-available": {
               if (chunk.dynamic) {
                 const toolInvocation = getDynamicToolInvocation(
@@ -3550,6 +3640,7 @@ function processUIMessageStream({
                   toolName: getToolName(toolInvocation),
                   state: "output-error",
                   input: toolInvocation.input,
+                  rawInput: toolInvocation.rawInput,
                   errorText: chunk.errorText
                 });
               }
@@ -3888,12 +3979,6 @@ var DelayedPromise = class {
   }
 };
 
-// src/util/now.ts
-function now() {
-  var _a16, _b;
-  return (_b = (_a16 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a16.now()) != null ? _b : Date.now();
-}
-
 // src/util/filter-stream-errors.ts
 function filterStreamErrors(readable, onError) {
   return new ReadableStream({
@@ -3918,6 +4003,12 @@ function filterStreamErrors(readable, onError) {
   });
 }
 
+// src/util/now.ts
+function now() {
+  var _a16, _b;
+  return (_b = (_a16 = globalThis == null ? void 0 : globalThis.performance) == null ? void 0 : _a16.now()) != null ? _b : Date.now();
+}
+
 // src/generate-text/run-tools-transformation.ts
 var import_provider_utils12 = require("@ai-sdk/provider-utils");
 function runToolsTransformation({
@@ -3999,6 +4090,17 @@ function runToolsTransformation({
               messages
             });
             controller.enqueue(toolCall);
+            if (toolCall.invalid) {
+              toolResultsStreamController.enqueue({
+                type: "tool-error",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input,
+                error: (0, import_provider_utils12.getErrorMessage)(toolCall.error),
+                dynamic: true
+              });
+              break;
+            }
             const tool3 = tools[toolCall.toolName];
             toolInputs.set(toolCall.toolCallId, toolCall.input);
             if (tool3.onInputAvailable != null) {
@@ -4311,6 +4413,7 @@ var DefaultStreamTextResult = class {
     this._steps = new DelayedPromise();
     this.output = output;
     this.includeRawChunks = includeRawChunks;
+    this.tools = tools;
     let stepFinish;
     let recordedContent = [];
     const recordedResponseMessages = [];
@@ -5119,6 +5222,13 @@ var DefaultStreamTextResult = class {
       originalMessages,
       responseMessageId: generateMessageId
     }) : void 0;
+    const toolNamesByCallId = {};
+    const isDynamic = (toolCallId) => {
+      var _a16, _b;
+      const toolName = toolNamesByCallId[toolCallId];
+      const dynamic = ((_b = (_a16 = this.tools) == null ? void 0 : _a16[toolName]) == null ? void 0 : _b.type) === "dynamic";
+      return dynamic ? true : void 0;
+    };
     const baseStream = this.fullStream.pipeThrough(
       new TransformStream({
         transform: async (part, controller) => {
@@ -5208,12 +5318,14 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "tool-input-start": {
+              toolNamesByCallId[part.id] = part.toolName;
+              const dynamic = isDynamic(part.id);
               controller.enqueue({
                 type: "tool-input-start",
                 toolCallId: part.id,
                 toolName: part.toolName,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
@@ -5226,34 +5338,51 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "tool-call": {
-              controller.enqueue({
-                type: "tool-input-available",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                input: part.input,
-                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
-              });
+              toolNamesByCallId[part.toolCallId] = part.toolName;
+              const dynamic = isDynamic(part.toolCallId);
+              if (part.invalid) {
+                controller.enqueue({
+                  type: "tool-input-error",
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  input: part.input,
+                  ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                  ...dynamic != null ? { dynamic } : {},
+                  errorText: onError(part.error)
+                });
+              } else {
+                controller.enqueue({
+                  type: "tool-input-available",
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  input: part.input,
+                  ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                  ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                  ...dynamic != null ? { dynamic } : {}
+                });
+              }
               break;
             }
             case "tool-result": {
+              const dynamic = isDynamic(part.toolCallId);
               controller.enqueue({
                 type: "tool-output-available",
                 toolCallId: part.toolCallId,
                 output: part.output,
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
             case "tool-error": {
+              const dynamic = isDynamic(part.toolCallId);
               controller.enqueue({
                 type: "tool-output-error",
                 toolCallId: part.toolCallId,
                 errorText: onError(part.error),
                 ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
-                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
+                ...dynamic != null ? { dynamic } : {}
               });
               break;
             }
@@ -5410,7 +5539,7 @@ var Agent = class {
 
 // src/embed/embed.ts
 async function embed({
-  model,
+  model: modelArg,
   value,
   providerOptions,
   maxRetries: maxRetriesArg,
@@ -5418,13 +5547,7 @@ async function embed({
   headers,
   experimental_telemetry: telemetry
 }) {
-  if (model.specificationVersion !== "v2") {
-    throw new UnsupportedModelVersionError({
-      version: model.specificationVersion,
-      provider: model.provider,
-      modelId: model.modelId
-    });
-  }
+  const model = resolveEmbeddingModel(modelArg);
   const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal
@@ -5542,7 +5665,7 @@ function splitArray(array, chunkSize) {
 
 // src/embed/embed-many.ts
 async function embedMany({
-  model,
+  model: modelArg,
   values,
   maxParallelCalls = Infinity,
   maxRetries: maxRetriesArg,
@@ -5551,13 +5674,7 @@ async function embedMany({
   providerOptions,
   experimental_telemetry: telemetry
 }) {
-  if (model.specificationVersion !== "v2") {
-    throw new UnsupportedModelVersionError({
-      version: model.specificationVersion,
-      provider: model.provider,
-      modelId: model.modelId
-    });
-  }
+  const model = resolveEmbeddingModel(modelArg);
   const { maxRetries, retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal
@@ -6149,6 +6266,63 @@ function getOutputStrategy({
   }
 }
 
+// src/generate-object/parse-and-validate-object-result.ts
+var import_provider24 = require("@ai-sdk/provider");
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
+async function parseAndValidateObjectResult(result, outputStrategy, context) {
+  const parseResult = await (0, import_provider_utils15.safeParseJSON)({ text: result });
+  if (!parseResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: could not parse the response.",
+      cause: parseResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  const validationResult = await outputStrategy.validateFinalResult(
+    parseResult.value,
+    {
+      text: result,
+      response: context.response,
+      usage: context.usage
+    }
+  );
+  if (!validationResult.success) {
+    throw new NoObjectGeneratedError({
+      message: "No object generated: response did not match schema.",
+      cause: validationResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason
+    });
+  }
+  return validationResult.value;
+}
+async function parseAndValidateObjectResultWithRepair(result, outputStrategy, repairText, context) {
+  try {
+    return await parseAndValidateObjectResult(result, outputStrategy, context);
+  } catch (error) {
+    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider24.JSONParseError.isInstance(error.cause) || import_provider24.TypeValidationError.isInstance(error.cause))) {
+      const repairedText = await repairText({
+        text: result,
+        error: error.cause
+      });
+      if (repairedText === null) {
+        throw error;
+      }
+      return await parseAndValidateObjectResult(
+        repairedText,
+        outputStrategy,
+        context
+      );
+    }
+    throw error;
+  }
+}
+
 // src/generate-object/validate-object-generation-input.ts
 function validateObjectGenerationInput({
   output,
@@ -6267,63 +6441,6 @@ function validateObjectGenerationInput({
   }
 }
 
-// src/generate-object/parse-and-validate-object-result.ts
-var import_provider24 = require("@ai-sdk/provider");
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-async function parseAndValidateObjectResult(result, outputStrategy, context) {
-  const parseResult = await (0, import_provider_utils15.safeParseJSON)({ text: result });
-  if (!parseResult.success) {
-    throw new NoObjectGeneratedError({
-      message: "No object generated: could not parse the response.",
-      cause: parseResult.error,
-      text: result,
-      response: context.response,
-      usage: context.usage,
-      finishReason: context.finishReason
-    });
-  }
-  const validationResult = await outputStrategy.validateFinalResult(
-    parseResult.value,
-    {
-      text: result,
-      response: context.response,
-      usage: context.usage
-    }
-  );
-  if (!validationResult.success) {
-    throw new NoObjectGeneratedError({
-      message: "No object generated: response did not match schema.",
-      cause: validationResult.error,
-      text: result,
-      response: context.response,
-      usage: context.usage,
-      finishReason: context.finishReason
-    });
-  }
-  return validationResult.value;
-}
-async function parseAndValidateObjectResultWithRepair(result, outputStrategy, repairText, context) {
-  try {
-    return await parseAndValidateObjectResult(result, outputStrategy, context);
-  } catch (error) {
-    if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider24.JSONParseError.isInstance(error.cause) || import_provider24.TypeValidationError.isInstance(error.cause))) {
-      const repairedText = await repairText({
-        text: result,
-        error: error.cause
-      });
-      if (repairedText === null) {
-        throw error;
-      }
-      return await parseAndValidateObjectResult(
-        repairedText,
-        outputStrategy,
-        context
-      );
-    }
-    throw error;
-  }
-}
-
 // src/generate-object/generate-object.ts
 var originalGenerateId3 = (0, import_provider_utils16.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
@@ -9288,7 +9405,7 @@ function convertToModelMessages(messages, options) {
       case "assistant": {
         if (message.parts != null) {
           let processBlock2 = function() {
-            var _a16;
+            var _a16, _b;
             if (block.length === 0) {
               return;
             }
@@ -9340,7 +9457,7 @@ function convertToModelMessages(messages, options) {
                     type: "tool-call",
                     toolCallId: part.toolCallId,
                     toolName,
-                    input: part.input,
+                    input: part.state === "output-error" ? (_a16 = part.input) != null ? _a16 : part.rawInput : part.input,
                     providerExecuted: part.providerExecuted,
                     ...part.callProviderMetadata != null ? { providerOptions: part.callProviderMetadata } : {}
                   });
@@ -9351,7 +9468,7 @@ function convertToModelMessages(messages, options) {
                       toolName,
                       output: createToolModelOutput({
                         output: part.state === "output-error" ? part.errorText : part.output,
-                        tool: (_a16 = options == null ? void 0 : options.tools) == null ? void 0 : _a16[toolName],
+                        tool: (_b = options == null ? void 0 : options.tools) == null ? void 0 : _b[toolName],
                         errorMode: part.state === "output-error" ? "json" : "none"
                       })
                     });