ai 7.0.97 → 7.0.99

package/dist/index.js

@@ -1178,7 +1178,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.97" : "0.0.0-test";
+var VERSION = true ? "7.0.99" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -4387,6 +4387,21 @@ function normalizeToolApprovalStatus(status) {
   return status === void 0 ? { type: "not-applicable" } : typeof status === "string" ? { type: status } : status;
 }
 
+// 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/telemetry/create-telemetry-dispatcher.ts
 import { asArray as asArray4 } from "@ai-sdk/provider-utils";
 
@@ -4759,19 +4774,6 @@ var DefaultStepResult = class {
 };
 
 // src/generate-text/restricted-telemetry-dispatcher.ts
-function filterIncludedContext({
-  context,
-  includeContext
-}) {
-  if (context == null) {
-    return {};
-  }
-  return Object.fromEntries(
-    Object.entries(context).filter(
-      ([key]) => (includeContext == null ? void 0 : includeContext[key]) === true
-    )
-  );
-}
 function restrictStepResult({
   step,
   includeRuntimeContext,
@@ -6950,6 +6952,9 @@ function isDynamicToolUIPart(part) {
 function isToolUIPart(part) {
   return isStaticToolUIPart(part) || isDynamicToolUIPart(part);
 }
+function isToolOutputErrorUIPart(part) {
+  return isToolUIPart(part) && part.state === "output-error";
+}
 function getStaticToolName(part) {
   return part.type.split("-").slice(1).join("-");
 }
@@ -12581,1264 +12586,1394 @@ import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { withUserAgentSuffix as withUserAgentSuffix4 } from "@ai-sdk/provider-utils";
+import {
+  detectMediaType as detectMediaType3,
+  withUserAgentSuffix as withUserAgentSuffix5
+} from "@ai-sdk/provider-utils";
 
-// src/util/is-deep-equal-data.ts
-function isDeepEqualData(obj1, obj2) {
-  if (obj1 === obj2) return true;
-  if (obj1 == null || obj2 == null) return false;
-  if (typeof obj1 !== "object" && typeof obj2 !== "object")
-    return obj1 === obj2;
-  if (obj1.constructor !== obj2.constructor) return false;
-  if (obj1 instanceof Date && obj2 instanceof Date) {
-    return obj1.getTime() === obj2.getTime();
-  }
-  if (Array.isArray(obj1)) {
-    if (obj1.length !== obj2.length) return false;
-    for (let i = 0; i < obj1.length; i++) {
-      if (!isDeepEqualData(obj1[i], obj2[i])) return false;
-    }
-    return true;
-  }
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length) return false;
-  for (const key of keys1) {
-    if (!keys2.includes(key)) return false;
-    if (!isDeepEqualData(obj1[key], obj2[key])) return false;
-  }
-  return true;
-}
+// src/generate-image/generate-image.ts
+import {
+  isJSONObject
+} from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array4,
+  detectMediaType as detectMediaType2,
+  withUserAgentSuffix as withUserAgentSuffix4
+} from "@ai-sdk/provider-utils";
 
-// src/batch/batch.ts
-async function cancelBatch({
-  provider,
-  batch,
-  providerOptions,
-  abortSignal,
-  headers,
-  timeout
-}) {
-  const batchApi = resolveBatchApi(provider);
-  validateBatchReference({ batchApi, batch });
-  if (batchApi.doCancelBatch == null) {
-    throw new UnsupportedFunctionalityError3({
-      functionality: "batch cancellation",
-      message: "The provider does not support batch cancellation."
-    });
+// src/prompt/data-content.ts
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array3,
+  convertUint8ArrayToBase64 as convertUint8ArrayToBase643
+} from "@ai-sdk/provider-utils";
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
   }
-  const operationAbortSignal = mergeAbortSignals(
-    abortSignal,
-    getTotalTimeoutMs(timeout)
-  );
-  try {
-    return await batchApi.doCancelBatch({
-      batchId: batch.id,
-      providerOptions,
-      abortSignal: operationAbortSignal,
-      headers: withUserAgentSuffix4(headers != null ? headers : {}, `ai/${VERSION}`)
-    });
-  } catch (error) {
-    throw wrapGatewayError(error);
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase643(new Uint8Array(content));
   }
+  return convertUint8ArrayToBase643(content);
 }
-async function listBatches({
-  provider,
-  providerOptions,
-  limit,
-  cursor,
-  maxRetries,
-  abortSignal,
-  headers,
-  timeout
-} = {}) {
-  var _a25;
-  const batchApi = resolveBatchApi(provider);
-  const doListBatches = (_a25 = batchApi.doListBatches) == null ? void 0 : _a25.bind(batchApi);
-  if (doListBatches == null) {
-    throw new UnsupportedFunctionalityError3({
-      functionality: "batch listing",
-      message: "The provider does not support listing batches."
-    });
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
   }
-  const operationAbortSignal = mergeAbortSignals(
-    abortSignal,
-    getTotalTimeoutMs(timeout)
-  );
-  const { retry } = prepareRetries({
-    maxRetries,
-    abortSignal: operationAbortSignal
-  });
-  try {
-    const { batches, nextCursor, providerMetadata } = await retry(
-      () => doListBatches({
-        providerOptions,
-        abortSignal: operationAbortSignal,
-        headers: withUserAgentSuffix4(headers != null ? headers : {}, `ai/${VERSION}`),
-        ...limit != null && { limit },
-        ...cursor != null && { cursor }
-      })
-    );
-    return {
-      batches: batches.map(({ batchId, ...status }) => ({
-        version: 2,
-        id: batchId,
-        provider: batchApi.provider,
-        ...status
-      })),
-      ...nextCursor != null && { nextCursor },
-      ...providerMetadata != null && { providerMetadata }
-    };
-  } catch (error) {
-    throw wrapGatewayError(error);
+  if (typeof content === "string") {
+    try {
+      return convertBase64ToUint8Array3(content);
+    } catch (error) {
+      throw new InvalidDataContentError({
+        message: "Invalid data content. Content string is not a base64-encoded media.",
+        content,
+        cause: error
+      });
+    }
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
   }
+  throw new InvalidDataContentError({ content });
 }
-async function startBatch({
-  provider,
-  requests,
+
+// src/generate-image/generate-image.ts
+var gatewayCostMetadataKeys = [
+  "cost",
+  "gatewayCost",
+  "inferenceCost",
+  "inputInferenceCost",
+  "marketCost",
+  "outputInferenceCost",
+  "surchargeCost"
+];
+var RetryableNoImageResultError = class extends Error {
+  constructor() {
+    super("No image generated.");
+    this.name = "RetryableNoImageResultError";
+  }
+};
+async function generateImage({
+  model: modelArg,
+  prompt: promptArg,
+  n = 1,
+  maxImagesPerCall,
+  size,
+  aspectRatio,
+  seed,
   providerOptions,
-  webhookUrl,
+  maxRetries: maxRetriesArg,
   abortSignal,
-  headers,
-  timeout
+  headers
 }) {
-  validateRequests(requests);
-  const batchApi = resolveBatchApi(provider);
-  const operationAbortSignal = mergeAbortSignals(
-    abortSignal,
-    getTotalTimeoutMs(timeout)
-  );
-  const supportedUrls = await batchApi.supportedUrls;
-  operationAbortSignal == null ? void 0 : operationAbortSignal.throwIfAborted();
-  const normalizedRequests = [];
-  const toolsByName = /* @__PURE__ */ new Map();
-  for (const request of requests) {
-    switch (request.type) {
-      case "text": {
-        const standardizedPrompt = await standardizePrompt(request);
-        const preparedTools = await prepareTools({
-          tools: request.tools,
-          toolOrder: request.toolOrder,
-          toolsContext: request.toolsContext
-        });
-        validateCompatibleTools({
-          requestId: request.id,
-          tools: preparedTools,
-          toolsByName
-        });
-        normalizedRequests.push({
-          id: request.id,
-          type: request.type,
-          modelId: request.model,
-          options: {
-            ...prepareLanguageModelCallOptions(request),
-            prompt: await convertToLanguageModelPrompt({
-              prompt: standardizedPrompt,
-              supportedUrls,
-              download: void 0,
-              provider: batchApi.provider.split(".")[0]
-            }),
-            tools: preparedTools,
-            toolChoice: prepareToolChoice({ toolChoice: request.toolChoice }),
-            providerOptions: request.providerOptions
-          }
-        });
-        break;
-      }
-    }
-    operationAbortSignal == null ? void 0 : operationAbortSignal.throwIfAborted();
-  }
+  var _a25, _b25;
+  const model = resolveImageModel(modelArg);
   const headersWithUserAgent = withUserAgentSuffix4(
     headers != null ? headers : {},
     `ai/${VERSION}`
   );
-  try {
-    const result = await batchApi.doStartBatch({
-      requests: normalizedRequests,
-      providerOptions,
-      abortSignal: operationAbortSignal,
-      headers: headersWithUserAgent,
-      ...webhookUrl != null && { webhookUrl }
-    });
-    const { batchId, warnings, ...status } = result;
-    const modelByRequestId = new Map(
-      normalizedRequests.map((request) => [request.id, request.modelId])
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+    additionalRetryableError: (error) => error instanceof RetryableNoImageResultError
+  });
+  const maxImagesPerCallWithDefault = (_a25 = maxImagesPerCall != null ? maxImagesPerCall : await invokeModelMaxImagesPerCall(model)) != null ? _a25 : 1;
+  const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
+  const callImageCounts = Array.from({ length: callCount }, (_, i) => {
+    if (i < callCount - 1) {
+      return maxImagesPerCallWithDefault;
+    }
+    const remainder = n % maxImagesPerCallWithDefault;
+    return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
+  });
+  const resultGroups = await Promise.all(
+    callImageCounts.map(async (callImageCount) => {
+      const callResults = [];
+      try {
+        await retry(async () => {
+          const { prompt, files, mask } = normalizePrompt(promptArg);
+          const result = await model.doGenerate({
+            prompt,
+            files,
+            mask,
+            n: callImageCount,
+            abortSignal,
+            headers: headersWithUserAgent,
+            size,
+            aspectRatio,
+            seed,
+            providerOptions: providerOptions != null ? providerOptions : {}
+          });
+          callResults.push(result);
+          if (result.images.length === 0 && result.isRetryable !== false) {
+            throw new RetryableNoImageResultError();
+          }
+          return result;
+        });
+        return callResults;
+      } catch (error) {
+        const noImageResultError = error instanceof RetryableNoImageResultError ? error : RetryError.isInstance(error) && error.lastError instanceof RetryableNoImageResultError ? error.lastError : void 0;
+        if (noImageResultError != null) {
+          return callResults;
+        }
+        throw error;
+      }
+    })
+  );
+  const results = resultGroups.flat();
+  const images = [];
+  const calls = [];
+  const warnings = [];
+  const responses = [];
+  const providerMetadata = {};
+  let totalUsage = {
+    inputTokens: void 0,
+    outputTokens: void 0,
+    totalTokens: void 0
+  };
+  for (const result of results) {
+    const callImages = result.images.map(
+      (image, index) => {
+        var _a26;
+        return new DefaultGeneratedFile({
+          data: image,
+          mediaType: (_a26 = detectMediaType2({
+            data: image,
+            topLevelType: "image"
+          })) != null ? _a26 : "image/png",
+          providerMetadata: getImageProviderMetadata(
+            result.providerMetadata,
+            index
+          )
+        });
+      }
     );
-    for (const { requestId, warning } of warnings) {
-      logWarnings({
-        warnings: [warning],
-        provider: batchApi.provider,
-        model: requestId == null ? void 0 : modelByRequestId.get(requestId)
-      });
+    images.push(...callImages);
+    calls.push({
+      images: callImages,
+      providerMetadata: result.providerMetadata,
+      response: result.response,
+      warnings: result.warnings,
+      usage: result.usage
+    });
+    warnings.push(...result.warnings);
+    if (result.usage != null) {
+      totalUsage = addImageModelUsage(totalUsage, result.usage);
     }
-    return {
-      version: 2,
-      id: batchId,
-      provider: batchApi.provider,
-      ...status,
-      warnings
-    };
-  } catch (error) {
-    throw wrapGatewayError(error);
+    if (result.providerMetadata) {
+      for (const [providerName, metadata] of Object.entries(
+        result.providerMetadata
+      )) {
+        if (providerName === "gateway") {
+          const currentEntry = providerMetadata[providerName];
+          if (currentEntry != null && typeof currentEntry === "object") {
+            const currentGatewayMetadata = currentEntry;
+            const newGatewayMetadata = metadata;
+            providerMetadata[providerName] = {
+              ...currentEntry,
+              ...metadata,
+              ...Object.fromEntries(
+                gatewayCostMetadataKeys.flatMap((key) => {
+                  const total = addDecimalStrings(
+                    currentGatewayMetadata[key],
+                    newGatewayMetadata[key]
+                  );
+                  return total == null ? [] : [[key, total]];
+                })
+              )
+            };
+          } else {
+            providerMetadata[providerName] = {
+              ...metadata
+            };
+          }
+          const imagesValue = providerMetadata[providerName].images;
+          if (Array.isArray(imagesValue) && imagesValue.length === 0) {
+            delete providerMetadata[providerName].images;
+          }
+        } else {
+          (_b25 = providerMetadata[providerName]) != null ? _b25 : providerMetadata[providerName] = { images: [] };
+          providerMetadata[providerName].images.push(...metadata.images);
+        }
+      }
+    }
+    responses.push(result.response);
+  }
+  logWarnings({ warnings, provider: model.provider, model: model.modelId });
+  if (!images.length) {
+    throw new NoImageGeneratedError({ calls, responses });
   }
+  return new DefaultGenerateImageResult({
+    images,
+    calls,
+    warnings,
+    responses,
+    providerMetadata,
+    usage: totalUsage
+  });
 }
-function validateCompatibleTools({
-  requestId,
-  tools,
-  toolsByName
-}) {
-  for (const tool2 of tools != null ? tools : []) {
-    const previousTool = toolsByName.get(tool2.name);
-    if (previousTool != null && !isDeepEqualData(previousTool, tool2)) {
-      throw new InvalidArgumentError({
-        parameter: "requests",
-        value: requestId,
-        message: `tool "${tool2.name}" must have the same definition in every batch request`
-      });
+var DefaultGenerateImageResult = class {
+  constructor(options) {
+    this.images = options.images;
+    this.calls = options.calls;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = options.providerMetadata;
+    this.usage = options.usage;
+  }
+  get image() {
+    return this.images[0];
+  }
+};
+function getImageProviderMetadata(providerMetadata, imageIndex) {
+  var _a25;
+  if (providerMetadata == null) {
+    return void 0;
+  }
+  let imageMetadata;
+  for (const [providerName, metadata] of Object.entries(providerMetadata)) {
+    const value = (_a25 = metadata.images) == null ? void 0 : _a25[imageIndex];
+    if (isJSONObject(value) && !Array.isArray(value)) {
+      (imageMetadata != null ? imageMetadata : imageMetadata = {})[providerName] = value;
     }
-    toolsByName.set(tool2.name, tool2);
   }
+  return imageMetadata;
 }
-async function getBatchStatus({
-  provider,
-  batch,
-  providerOptions,
-  maxRetries,
-  abortSignal,
-  headers,
-  timeout
-}) {
-  const batchApi = resolveBatchApi(provider);
-  validateBatchReference({ batchApi, batch });
-  const operationAbortSignal = mergeAbortSignals(
-    abortSignal,
-    getTotalTimeoutMs(timeout)
-  );
-  const { retry } = prepareRetries({
-    maxRetries,
-    abortSignal: operationAbortSignal
+async function invokeModelMaxImagesPerCall(model) {
+  const isFunction = model.maxImagesPerCall instanceof Function;
+  if (!isFunction) {
+    return model.maxImagesPerCall;
+  }
+  return model.maxImagesPerCall({
+    modelId: model.modelId
   });
-  try {
-    const status = await retry(
-      () => batchApi.doGetBatchStatus({
-        batchId: batch.id,
-        providerOptions,
-        abortSignal: operationAbortSignal,
-        headers: withUserAgentSuffix4(headers != null ? headers : {}, `ai/${VERSION}`)
-      })
-    );
-    return status;
-  } catch (error) {
-    throw wrapGatewayError(error);
+}
+function addDecimalStrings(value1, value2) {
+  if (typeof value1 !== "string" || typeof value2 !== "string" || !/^\d+(?:\.\d+)?$/.test(value1) || !/^\d+(?:\.\d+)?$/.test(value2)) {
+    return void 0;
   }
+  const [integer1, fraction1 = ""] = value1.split(".");
+  const [integer2, fraction2 = ""] = value2.split(".");
+  const precision = Math.max(fraction1.length, fraction2.length);
+  const sum = BigInt(integer1 + fraction1.padEnd(precision, "0")) + BigInt(integer2 + fraction2.padEnd(precision, "0"));
+  const sumString = sum.toString().padStart(precision + 1, "0");
+  return precision === 0 ? sumString : `${sumString.slice(0, -precision)}.${sumString.slice(
+    -precision
+  )}`.replace(/\.?0+$/, "");
 }
-function getBatchResults({
-  provider,
-  batch,
-  tools,
-  providerOptions,
-  maxRetries,
-  abortSignal,
-  headers,
-  timeout
-}) {
-  const batchApi = resolveBatchApi(provider);
-  validateBatchReference({ batchApi, batch });
-  const streamAbortController = new AbortController();
-  const operationAbortSignal = mergeAbortSignals(
-    abortSignal,
-    getTotalTimeoutMs(timeout),
-    streamAbortController.signal
-  );
-  const { retry } = prepareRetries({
-    maxRetries,
-    abortSignal: operationAbortSignal
-  });
-  const transformer = {
-    async transform(item, controller) {
-      controller.enqueue(await convertBatchItemResult({ item, tools }));
-    },
-    cancel(reason) {
-      streamAbortController.abort(
-        reason != null ? reason : new Error("Batch results stream was cancelled.")
-      );
-    }
+function normalizePrompt(prompt) {
+  if (typeof prompt === "string") {
+    return { prompt, files: void 0, mask: void 0 };
+  }
+  return {
+    prompt: prompt.text,
+    files: prompt.images.map(toImageModelV4File),
+    mask: prompt.mask ? toImageModelV4File(prompt.mask) : void 0
   };
-  const transform = new TransformStream(transformer);
-  void (async () => {
-    try {
-      const stream = await retry(
-        () => batchApi.doGetBatchResults({
-          batchId: batch.id,
-          providerOptions,
-          abortSignal: operationAbortSignal,
-          headers: withUserAgentSuffix4(headers != null ? headers : {}, `ai/${VERSION}`)
-        })
-      );
-      await stream.pipeTo(transform.writable, {
-        signal: operationAbortSignal
-      });
-    } catch (error) {
-      await transform.writable.abort(wrapGatewayError(error)).catch(() => {
-      });
-    }
-  })();
-  return asAsyncIterableStream(transform.readable);
 }
-function resolveBatchApi(provider) {
-  var _a25;
-  provider != null ? provider : provider = asProviderV4((_a25 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a25 : gateway2);
-  if (isBatchApi(provider)) {
-    return provider;
+function toImageModelV4File(dataContent) {
+  if (typeof dataContent === "string" && dataContent.startsWith("http")) {
+    return {
+      type: "url",
+      url: dataContent
+    };
   }
-  if (!hasBatchFactory(provider)) {
-    throw new UnsupportedFunctionalityError3({
-      functionality: "batch processing",
-      message: "The provider does not support batch processing. Make sure it exposes an experimental_batch() method."
-    });
+  if (typeof dataContent === "string" && dataContent.startsWith("data:")) {
+    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(dataContent);
+    if (base64Content != null) {
+      const uint8Data2 = convertBase64ToUint8Array4(base64Content);
+      return {
+        type: "file",
+        data: uint8Data2,
+        mediaType: dataUrlMediaType || detectMediaType2({
+          data: uint8Data2,
+          topLevelType: "image"
+        }) || "image/png"
+      };
+    }
   }
-  return provider.experimental_batch();
-}
-function hasBatchFactory(provider) {
-  return typeof provider.experimental_batch === "function";
-}
-function isBatchApi(provider) {
-  const candidate = provider;
-  return typeof candidate.doStartBatch === "function" && typeof candidate.doGetBatchStatus === "function" && typeof candidate.doGetBatchResults === "function";
+  const uint8Data = convertDataContentToUint8Array(dataContent);
+  return {
+    type: "file",
+    data: uint8Data,
+    mediaType: detectMediaType2({
+      data: uint8Data,
+      topLevelType: "image"
+    }) || "image/png"
+  };
 }
-function validateRequests(requests) {
-  if (requests.length === 0) {
-    throw new InvalidArgumentError({
-      parameter: "requests",
-      value: requests,
-      message: "requests must not be empty"
-    });
+
+// src/util/is-deep-equal-data.ts
+function isDeepEqualData(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (obj1 == null || obj2 == null) return false;
+  if (typeof obj1 !== "object" && typeof obj2 !== "object")
+    return obj1 === obj2;
+  if (obj1.constructor !== obj2.constructor) return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
   }
-  const ids = /* @__PURE__ */ new Set();
-  for (const request of requests) {
-    if (request.id.trim().length === 0) {
-      throw new InvalidArgumentError({
-        parameter: "requests",
-        value: requests,
-        message: "request IDs must not be empty"
-      });
-    }
-    if (ids.has(request.id)) {
-      throw new InvalidArgumentError({
-        parameter: "requests",
-        value: requests,
-        message: `request IDs must be unique; duplicate ID "${request.id}"`
-      });
+  if (Array.isArray(obj1)) {
+    if (obj1.length !== obj2.length) return false;
+    for (let i = 0; i < obj1.length; i++) {
+      if (!isDeepEqualData(obj1[i], obj2[i])) return false;
     }
-    ids.add(request.id);
+    return true;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key)) return false;
+    if (!isDeepEqualData(obj1[key], obj2[key])) return false;
   }
+  return true;
 }
-function validateBatchReference({
-  batchApi,
-  batch
+
+// src/batch/batch.ts
+async function cancelBatch({
+  provider,
+  batch,
+  providerOptions,
+  abortSignal,
+  headers,
+  timeout
 }) {
-  if (batch.version !== 2) {
-    throw new InvalidArgumentError({
-      parameter: "batch",
-      value: batch,
-      message: "batch must be a supported batch reference"
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
+  if (batchApi.doCancelBatch == null) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: "batch cancellation",
+      message: "The provider does not support batch cancellation."
     });
   }
-  if (batch.provider !== batchApi.provider) {
-    throw new InvalidArgumentError({
-      parameter: "provider",
-      value: batchApi,
-      message: `provider ${batchApi.provider} is not compatible with batch provider ${batch.provider}`
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout)
+  );
+  try {
+    return await batchApi.doCancelBatch({
+      batchId: batch.id,
+      providerOptions,
+      abortSignal: operationAbortSignal,
+      headers: withUserAgentSuffix5(headers != null ? headers : {}, `ai/${VERSION}`)
     });
+  } catch (error) {
+    throw wrapGatewayError(error);
   }
 }
-async function convertBatchItemResult({
-  item,
-  tools
-}) {
-  switch (item.type) {
-    case "text":
-      switch (item.status) {
-        case "succeeded":
-          return {
-            id: item.id,
-            status: item.status,
-            ...await convertGenerateResult({ result: item.result, tools })
-          };
-        case "failed":
-          return {
-            id: item.id,
-            status: item.status,
-            error: item.error,
-            providerMetadata: item.providerMetadata
-          };
-        case "cancelled":
-        case "expired":
-          return {
-            id: item.id,
-            status: item.status,
-            error: item.error,
-            providerMetadata: item.providerMetadata
-          };
-      }
-  }
-}
-async function convertGenerateResult({
-  result,
-  tools
-}) {
+async function listBatches({
+  provider,
+  providerOptions,
+  limit,
+  cursor,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout
+} = {}) {
   var _a25;
-  const toolCalls = await Promise.all(
-    result.content.filter(
-      (part) => part.type === "tool-call"
-    ).map(
-      (toolCall) => parseToolCall({
-        toolCall,
-        tools,
-        repairToolCall: void 0,
-        refineToolInput: void 0,
-        instructions: void 0,
-        messages: []
-      })
-    )
+  const batchApi = resolveBatchApi(provider);
+  const doListBatches = (_a25 = batchApi.doListBatches) == null ? void 0 : _a25.bind(batchApi);
+  if (doListBatches == null) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: "batch listing",
+      message: "The provider does not support listing batches."
+    });
+  }
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout)
   );
-  const content = convertLanguageModelContent({
-    content: result.content,
-    toolCalls,
-    toolOutputs: [],
-    toolApprovalRequests: [],
-    toolApprovalResponses: [],
-    tools
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal
   });
-  return {
-    content,
-    text: result.content.filter(
-      (part) => part.type === "text"
-    ).map((part) => part.text).join(""),
-    finishReason: result.finishReason.unified,
-    rawFinishReason: result.finishReason.raw,
-    usage: asLanguageModelUsage(result.usage),
-    ...result.response != null ? {
-      response: {
-        id: result.response.id,
-        timestamp: (_a25 = result.response.timestamp) == null ? void 0 : _a25.toISOString(),
-        modelId: result.response.modelId
-      }
-    } : {},
-    providerMetadata: result.providerMetadata
-  };
+  try {
+    const { batches, nextCursor, providerMetadata } = await retry(
+      () => doListBatches({
+        providerOptions,
+        abortSignal: operationAbortSignal,
+        headers: withUserAgentSuffix5(headers != null ? headers : {}, `ai/${VERSION}`),
+        ...limit != null && { limit },
+        ...cursor != null && { cursor }
+      })
+    );
+    return {
+      batches: batches.map(({ batchId, ...status }) => ({
+        version: 2,
+        id: batchId,
+        provider: batchApi.provider,
+        ...status
+      })),
+      ...nextCursor != null && { nextCursor },
+      ...providerMetadata != null && { providerMetadata }
+    };
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
 }
-
-// src/embed/embed.ts
-import {
-  createIdGenerator as createIdGenerator4,
-  withUserAgentSuffix as withUserAgentSuffix5
-} from "@ai-sdk/provider-utils";
-var originalGenerateCallId4 = createIdGenerator4({
-  prefix: "call",
-  size: 24
-});
-async function embed({
-  model: modelArg,
-  value,
+async function startBatch({
+  provider,
+  requests,
   providerOptions,
-  maxRetries: maxRetriesArg,
+  webhookUrl,
   abortSignal,
   headers,
-  experimental_telemetry,
-  telemetry = experimental_telemetry,
-  onStart,
-  experimental_onStart,
-  onEnd,
-  experimental_onEnd,
-  _internal: { generateCallId = originalGenerateCallId4 } = {}
+  timeout
 }) {
-  var _a25;
-  const model = resolveEmbeddingModel(modelArg);
-  const { maxRetries, retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal
-  });
-  const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
-  const resolvedOnEnd = onEnd != null ? onEnd : experimental_onEnd;
-  const headersWithUserAgent = withUserAgentSuffix5(
-    headers != null ? headers : {},
-    `ai/${VERSION}`
+  var _a25, _b25;
+  validateRequests(requests);
+  const batchApi = resolveBatchApi(provider);
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout)
   );
-  const callId = generateCallId();
-  const telemetryDispatcher = createTelemetryDispatcher({
-    telemetry
-  });
-  const runInTracingChannelSpan = (_a25 = telemetryDispatcher.runInTracingChannelSpan) != null ? _a25 : (async ({ execute }) => await execute());
-  const startEvent = {
-    callId,
-    operationId: "ai.embed",
-    provider: model.provider,
-    modelId: model.modelId,
-    value,
-    maxRetries,
-    headers: headersWithUserAgent,
-    providerOptions
-  };
-  return await runInTracingChannelSpan({
-    type: "embed",
-    event: startEvent,
-    execute: async () => {
-      var _a26;
-      await notify({
-        event: startEvent,
-        callbacks: [resolvedOnStart, telemetryDispatcher.onStart]
-      });
-      try {
-        const { embedding, usage, warnings, response, providerMetadata } = await retry(async () => {
-          var _a27, _b25;
-          const embedCallId = generateCallId();
-          await notify({
-            event: {
-              callId,
-              embedCallId,
-              operationId: "ai.embed.doEmbed",
-              provider: model.provider,
-              modelId: model.modelId,
-              values: [value]
-            },
-            callbacks: [telemetryDispatcher.onEmbedStart]
-          });
-          const modelResponse = await model.doEmbed({
-            values: [value],
-            abortSignal,
-            headers: headersWithUserAgent,
-            providerOptions
-          });
-          const embedding2 = modelResponse.embeddings[0];
-          const usage2 = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
-          await notify({
-            event: {
-              callId,
-              embedCallId,
-              operationId: "ai.embed.doEmbed",
-              provider: model.provider,
-              modelId: model.modelId,
-              values: [value],
-              embeddings: modelResponse.embeddings,
-              usage: usage2
-            },
-            callbacks: [telemetryDispatcher.onEmbedEnd]
-          });
-          if (embedding2 == null) {
-            throw new InvalidResponseDataError({
-              data: modelResponse.embeddings,
-              message: "No embedding generated."
-            });
-          }
-          return {
-            embedding: embedding2,
-            usage: usage2,
-            warnings: (_b25 = modelResponse.warnings) != null ? _b25 : [],
-            providerMetadata: modelResponse.providerMetadata,
-            response: modelResponse.response
-          };
+  const supportedUrls = await batchApi.supportedUrls;
+  operationAbortSignal == null ? void 0 : operationAbortSignal.throwIfAborted();
+  const normalizedRequests = [];
+  const toolsByName = /* @__PURE__ */ new Map();
+  for (const request of requests) {
+    const requestType = request.type;
+    switch (requestType) {
+      case "text": {
+        const standardizedPrompt = await standardizePrompt(request);
+        const preparedTools = await prepareTools({
+          tools: request.tools,
+          toolOrder: request.toolOrder,
+          toolsContext: request.toolsContext
         });
-        logWarnings({
-          warnings,
-          provider: model.provider,
-          model: model.modelId
+        validateCompatibleTools({
+          requestId: request.id,
+          tools: preparedTools,
+          toolsByName
         });
-        await notify({
-          event: {
-            callId,
-            operationId: "ai.embed",
-            provider: model.provider,
-            modelId: model.modelId,
-            value,
-            embedding,
-            usage,
-            warnings,
-            providerMetadata,
-            response
-          },
-          callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
+        normalizedRequests.push({
+          id: request.id,
+          type: request.type,
+          modelId: request.model,
+          options: {
+            ...prepareLanguageModelCallOptions(request),
+            prompt: await convertToLanguageModelPrompt({
+              prompt: standardizedPrompt,
+              supportedUrls,
+              download: void 0,
+              provider: batchApi.provider.split(".")[0]
+            }),
+            tools: preparedTools,
+            toolChoice: prepareToolChoice({ toolChoice: request.toolChoice }),
+            providerOptions: request.providerOptions
+          }
         });
-        return new DefaultEmbedResult({
-          value,
-          embedding,
-          usage,
-          warnings,
-          providerMetadata,
-          response
+        break;
+      }
+      case "image": {
+        const { prompt, files, mask } = normalizePrompt(request.prompt);
+        normalizedRequests.push({
+          id: request.id,
+          type: request.type,
+          modelId: request.model,
+          options: {
+            prompt,
+            n: (_a25 = request.n) != null ? _a25 : 1,
+            size: request.size,
+            aspectRatio: request.aspectRatio,
+            seed: request.seed,
+            files,
+            mask,
+            providerOptions: (_b25 = request.providerOptions) != null ? _b25 : {}
+          }
+        });
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = requestType;
+        throw new InvalidArgumentError({
+          parameter: "requests",
+          value: _exhaustiveCheck,
+          message: `Unsupported batch request type "${_exhaustiveCheck}".`
         });
-      } catch (error) {
-        await ((_a26 = telemetryDispatcher.onError) == null ? void 0 : _a26.call(telemetryDispatcher, { callId, error }));
-        throw error;
       }
     }
-  });
-}
-var DefaultEmbedResult = class {
-  constructor(options) {
-    this.value = options.value;
-    this.embedding = options.embedding;
-    this.usage = options.usage;
-    this.warnings = options.warnings;
-    this.providerMetadata = options.providerMetadata;
-    this.response = options.response;
+    operationAbortSignal == null ? void 0 : operationAbortSignal.throwIfAborted();
   }
-};
-
-// src/embed/embed-many.ts
-import { InvalidResponseDataError as InvalidResponseDataError2 } from "@ai-sdk/provider";
-import {
-  createIdGenerator as createIdGenerator5,
-  withUserAgentSuffix as withUserAgentSuffix6
-} from "@ai-sdk/provider-utils";
-
-// src/model/get-embedding-model-max-input-bytes-per-call.ts
-import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from "@ai-sdk/provider-utils";
-function getEmbeddingModelMaxInputBytesPerCall(model) {
-  return model[EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL];
-}
-
-// src/util/split-array.ts
-function splitArray(array3, chunkSize) {
-  if (chunkSize <= 0) {
-    throw new Error("chunkSize must be greater than 0");
+  const headersWithUserAgent = withUserAgentSuffix5(
+    headers != null ? headers : {},
+    `ai/${VERSION}`
+  );
+  try {
+    const result = await batchApi.doStartBatch({
+      requests: normalizedRequests,
+      providerOptions,
+      abortSignal: operationAbortSignal,
+      headers: headersWithUserAgent,
+      ...webhookUrl != null && { webhookUrl }
+    });
+    const { batchId, warnings, ...status } = result;
+    const modelByRequestId = new Map(
+      normalizedRequests.map((request) => [request.id, request.modelId])
+    );
+    for (const { requestId, warning } of warnings) {
+      logWarnings({
+        warnings: [warning],
+        provider: batchApi.provider,
+        model: requestId == null ? void 0 : modelByRequestId.get(requestId)
+      });
+    }
+    return {
+      version: 2,
+      id: batchId,
+      provider: batchApi.provider,
+      ...status,
+      warnings
+    };
+  } catch (error) {
+    throw wrapGatewayError(error);
   }
-  const result = [];
-  for (let i = 0; i < array3.length; i += chunkSize) {
-    result.push(array3.slice(i, i + chunkSize));
+}
+function validateCompatibleTools({
+  requestId,
+  tools,
+  toolsByName
+}) {
+  for (const tool2 of tools != null ? tools : []) {
+    const previousTool = toolsByName.get(tool2.name);
+    if (previousTool != null && !isDeepEqualData(previousTool, tool2)) {
+      throw new InvalidArgumentError({
+        parameter: "requests",
+        value: requestId,
+        message: `tool "${tool2.name}" must have the same definition in every batch request`
+      });
+    }
+    toolsByName.set(tool2.name, tool2);
   }
-  return result;
 }
-
-// src/embed/embed-many.ts
-var originalGenerateCallId5 = createIdGenerator5({
-  prefix: "call",
-  size: 24
-});
-async function embedMany({
-  model: modelArg,
-  values,
-  maxParallelCalls = Infinity,
-  maxRetries: maxRetriesArg,
+async function getBatchStatus({
+  provider,
+  batch,
+  providerOptions,
+  maxRetries,
   abortSignal,
   headers,
-  providerOptions,
-  experimental_telemetry,
-  telemetry = experimental_telemetry,
-  onStart,
-  experimental_onStart,
-  onEnd,
-  experimental_onEnd,
-  _internal: { generateCallId = originalGenerateCallId5 } = {}
+  timeout
 }) {
-  var _a25;
-  const model = resolveEmbeddingModel(modelArg);
-  const { maxRetries, retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal
-  });
-  const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
-  const resolvedOnEnd = onEnd != null ? onEnd : experimental_onEnd;
-  const headersWithUserAgent = withUserAgentSuffix6(
-    headers != null ? headers : {},
-    `ai/${VERSION}`
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout)
   );
-  const callId = generateCallId();
-  const telemetryDispatcher = createTelemetryDispatcher({
-    telemetry
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal
   });
-  const runInTracingChannelSpan = (_a25 = telemetryDispatcher.runInTracingChannelSpan) != null ? _a25 : (async ({ execute }) => await execute());
-  const startEvent = {
-    callId,
-    operationId: "ai.embedMany",
-    provider: model.provider,
-    modelId: model.modelId,
-    value: values,
+  try {
+    const status = await retry(
+      () => batchApi.doGetBatchStatus({
+        batchId: batch.id,
+        providerOptions,
+        abortSignal: operationAbortSignal,
+        headers: withUserAgentSuffix5(headers != null ? headers : {}, `ai/${VERSION}`)
+      })
+    );
+    return status;
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
+}
+function getBatchResults({
+  provider,
+  batch,
+  tools,
+  providerOptions,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout
+}) {
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
+  const streamAbortController = new AbortController();
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+    streamAbortController.signal
+  );
+  const { retry } = prepareRetries({
     maxRetries,
-    headers: headersWithUserAgent,
-    providerOptions
+    abortSignal: operationAbortSignal
+  });
+  const transformer = {
+    async transform(item, controller) {
+      controller.enqueue(await convertBatchItemResult({ item, tools }));
+    },
+    cancel(reason) {
+      streamAbortController.abort(
+        reason != null ? reason : new Error("Batch results stream was cancelled.")
+      );
+    }
   };
-  return await runInTracingChannelSpan({
-    type: "embedMany",
-    event: startEvent,
-    execute: async () => {
-      var _a26, _b25;
-      await notify({
-        event: startEvent,
-        callbacks: [resolvedOnStart, telemetryDispatcher.onStart]
+  const transform = new TransformStream(transformer);
+  void (async () => {
+    try {
+      const stream = await retry(
+        () => batchApi.doGetBatchResults({
+          batchId: batch.id,
+          providerOptions,
+          abortSignal: operationAbortSignal,
+          headers: withUserAgentSuffix5(headers != null ? headers : {}, `ai/${VERSION}`)
+        })
+      );
+      await stream.pipeTo(transform.writable, {
+        signal: operationAbortSignal
+      });
+    } catch (error) {
+      await transform.writable.abort(wrapGatewayError(error)).catch(() => {
       });
-      try {
-        const [
-          maxEmbeddingsPerCall,
-          maxInputBytesPerCall,
-          supportsParallelCalls
-        ] = await Promise.all([
-          model.maxEmbeddingsPerCall,
-          getEmbeddingModelMaxInputBytesPerCall(model),
-          model.supportsParallelCalls
-        ]);
-        const hasEmbeddingLimit = maxEmbeddingsPerCall != null && maxEmbeddingsPerCall !== Infinity;
-        const hasInputByteLimit = maxInputBytesPerCall != null && maxInputBytesPerCall !== Infinity;
-        if (!hasEmbeddingLimit && !hasInputByteLimit) {
-          const { embeddings: embeddings2, usage, warnings: warnings2, response, providerMetadata: providerMetadata2 } = await retry(async () => {
-            var _a27, _b26;
-            const embedCallId = generateCallId();
-            await notify({
-              event: {
-                callId,
-                embedCallId,
-                operationId: "ai.embedMany.doEmbed",
-                provider: model.provider,
-                modelId: model.modelId,
-                values
-              },
-              callbacks: [telemetryDispatcher.onEmbedStart]
-            });
-            const modelResponse = await model.doEmbed({
-              values,
-              abortSignal,
-              headers: headersWithUserAgent,
-              providerOptions
-            });
-            const embeddings3 = modelResponse.embeddings;
-            const usage2 = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
-            await notify({
-              event: {
-                callId,
-                embedCallId,
-                operationId: "ai.embedMany.doEmbed",
-                provider: model.provider,
-                modelId: model.modelId,
-                values,
-                embeddings: embeddings3,
-                usage: usage2
-              },
-              callbacks: [telemetryDispatcher.onEmbedEnd]
-            });
-            return {
-              embeddings: embeddings3,
-              usage: usage2,
-              warnings: (_b26 = modelResponse.warnings) != null ? _b26 : [],
-              providerMetadata: modelResponse.providerMetadata,
-              response: modelResponse.response
-            };
-          });
-          validateEmbeddingCount({ embeddings: embeddings2, values });
-          logWarnings({
-            warnings: warnings2,
-            provider: model.provider,
-            model: model.modelId
-          });
-          await notify({
-            event: {
-              callId,
-              operationId: "ai.embedMany",
-              provider: model.provider,
-              modelId: model.modelId,
-              value: values,
-              embedding: embeddings2,
-              usage,
-              warnings: warnings2,
-              providerMetadata: providerMetadata2,
-              response: [response]
-            },
-            callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
-          });
-          return new DefaultEmbedManyResult({
-            values,
-            embeddings: embeddings2,
-            usage,
-            warnings: warnings2,
-            providerMetadata: providerMetadata2,
-            responses: [response]
-          });
-        }
-        const valueChunks = splitByEmbeddingLimits({
-          values,
-          maxEmbeddingsPerCall: hasEmbeddingLimit ? maxEmbeddingsPerCall : Infinity,
-          maxInputBytesPerCall: hasInputByteLimit ? maxInputBytesPerCall : Infinity
-        });
-        const embeddings = [];
-        const warnings = [];
-        const responses = [];
-        let tokens = 0;
-        let providerMetadata;
-        const parallelChunks = splitArray(
-          valueChunks,
-          supportsParallelCalls ? maxParallelCalls : 1
-        );
-        for (const parallelChunk of parallelChunks) {
-          const results = await Promise.all(
-            parallelChunk.map(async (chunk) => {
-              const result = await retry(async () => {
-                var _a27, _b26;
-                const embedCallId = generateCallId();
-                await notify({
-                  event: {
-                    callId,
-                    embedCallId,
-                    operationId: "ai.embedMany.doEmbed",
-                    provider: model.provider,
-                    modelId: model.modelId,
-                    values: chunk
-                  },
-                  callbacks: [telemetryDispatcher.onEmbedStart]
-                });
-                const modelResponse = await model.doEmbed({
-                  values: chunk,
-                  abortSignal,
-                  headers: headersWithUserAgent,
-                  providerOptions
-                });
-                const chunkEmbeddings = modelResponse.embeddings;
-                const usage = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
-                await notify({
-                  event: {
-                    callId,
-                    embedCallId,
-                    operationId: "ai.embedMany.doEmbed",
-                    provider: model.provider,
-                    modelId: model.modelId,
-                    values: chunk,
-                    embeddings: chunkEmbeddings,
-                    usage
-                  },
-                  callbacks: [telemetryDispatcher.onEmbedEnd]
-                });
-                return {
-                  embeddings: chunkEmbeddings,
-                  usage,
-                  warnings: (_b26 = modelResponse.warnings) != null ? _b26 : [],
-                  providerMetadata: modelResponse.providerMetadata,
-                  response: modelResponse.response
-                };
-              });
-              validateEmbeddingCount({
-                embeddings: result.embeddings,
-                values: chunk
-              });
-              return result;
-            })
-          );
-          for (const result of results) {
-            embeddings.push(...result.embeddings);
-            warnings.push(...result.warnings);
-            responses.push(result.response);
-            tokens += result.usage.tokens;
-            if (result.providerMetadata) {
-              if (!providerMetadata) {
-                providerMetadata = { ...result.providerMetadata };
-              } else {
-                for (const [providerName, metadata] of Object.entries(
-                  result.providerMetadata
-                )) {
-                  providerMetadata[providerName] = {
-                    ...(_a26 = providerMetadata[providerName]) != null ? _a26 : {},
-                    ...metadata
-                  };
-                }
-              }
-            }
-          }
-        }
-        logWarnings({
-          warnings,
-          provider: model.provider,
-          model: model.modelId
-        });
-        await notify({
-          event: {
-            callId,
-            operationId: "ai.embedMany",
-            provider: model.provider,
-            modelId: model.modelId,
-            value: values,
-            embedding: embeddings,
-            usage: { tokens },
-            warnings,
-            providerMetadata,
-            response: responses
-          },
-          callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
-        });
-        return new DefaultEmbedManyResult({
-          values,
-          embeddings,
-          usage: { tokens },
-          warnings,
-          providerMetadata,
-          responses
-        });
-      } catch (error) {
-        await ((_b25 = telemetryDispatcher.onError) == null ? void 0 : _b25.call(telemetryDispatcher, { callId, error }));
-        throw error;
-      }
     }
-  });
+  })();
+  return asAsyncIterableStream(transform.readable);
 }
-function validateEmbeddingCount({
-  embeddings,
-  values
-}) {
-  if (embeddings.length !== values.length) {
-    throw new InvalidResponseDataError2({
-      data: embeddings,
-      message: `Expected ${values.length} embeddings, but received ${embeddings.length}.`
+function resolveBatchApi(provider) {
+  var _a25;
+  provider != null ? provider : provider = asProviderV4((_a25 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a25 : gateway2);
+  if (isBatchApi(provider)) {
+    return provider;
+  }
+  if (!hasBatchFactory(provider)) {
+    throw new UnsupportedFunctionalityError3({
+      functionality: "batch processing",
+      message: "The provider does not support batch processing. Make sure it exposes an experimental_batch() method."
     });
   }
+  return provider.experimental_batch();
 }
-var textEncoder = new TextEncoder();
-function splitByEmbeddingLimits({
-  values,
-  maxEmbeddingsPerCall,
-  maxInputBytesPerCall
-}) {
-  if (maxEmbeddingsPerCall <= 0) {
-    throw new Error("maxEmbeddingsPerCall must be greater than 0");
-  }
-  if (maxInputBytesPerCall <= 0) {
-    throw new Error("maxInputBytesPerCall must be greater than 0");
-  }
-  if (values.length === 0) {
-    return [];
-  }
-  const chunks = [];
-  let currentChunk = [];
-  let currentInputBytes = 0;
-  for (const value of values) {
-    const inputBytes = textEncoder.encode(value).length;
-    if (currentChunk.length > 0 && (currentChunk.length >= maxEmbeddingsPerCall || currentInputBytes + inputBytes > maxInputBytesPerCall)) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentInputBytes = 0;
-    }
-    currentChunk.push(value);
-    currentInputBytes += inputBytes;
-  }
-  chunks.push(currentChunk);
-  return chunks;
+function hasBatchFactory(provider) {
+  return typeof provider.experimental_batch === "function";
 }
-var DefaultEmbedManyResult = class {
-  constructor(options) {
-    this.values = options.values;
-    this.embeddings = options.embeddings;
-    this.usage = options.usage;
-    this.warnings = options.warnings;
-    this.providerMetadata = options.providerMetadata;
-    this.responses = options.responses;
-  }
-};
-
-// src/generate-image/generate-image.ts
-import {
-  isJSONObject
-} from "@ai-sdk/provider";
-import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array4,
-  detectMediaType as detectMediaType2,
-  withUserAgentSuffix as withUserAgentSuffix7
-} from "@ai-sdk/provider-utils";
-
-// src/prompt/data-content.ts
-import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  convertUint8ArrayToBase64 as convertUint8ArrayToBase643
-} from "@ai-sdk/provider-utils";
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase643(new Uint8Array(content));
-  }
-  return convertUint8ArrayToBase643(content);
+function isBatchApi(provider) {
+  const candidate = provider;
+  return typeof candidate.doStartBatch === "function" && typeof candidate.doGetBatchStatus === "function" && typeof candidate.doGetBatchResults === "function";
 }
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
+function validateRequests(requests) {
+  if (requests.length === 0) {
+    throw new InvalidArgumentError({
+      parameter: "requests",
+      value: requests,
+      message: "requests must not be empty"
+    });
   }
-  if (typeof content === "string") {
-    try {
-      return convertBase64ToUint8Array3(content);
-    } catch (error) {
-      throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded media.",
-        content,
-        cause: error
+  const ids = /* @__PURE__ */ new Set();
+  for (const request of requests) {
+    if (request.id.trim().length === 0) {
+      throw new InvalidArgumentError({
+        parameter: "requests",
+        value: requests,
+        message: "request IDs must not be empty"
       });
     }
+    if (ids.has(request.id)) {
+      throw new InvalidArgumentError({
+        parameter: "requests",
+        value: requests,
+        message: `request IDs must be unique; duplicate ID "${request.id}"`
+      });
+    }
+    ids.add(request.id);
   }
-  if (content instanceof ArrayBuffer) {
-    return new Uint8Array(content);
-  }
-  throw new InvalidDataContentError({ content });
 }
-
-// src/generate-image/generate-image.ts
-var gatewayCostMetadataKeys = [
-  "cost",
-  "gatewayCost",
-  "inferenceCost",
-  "inputInferenceCost",
-  "marketCost",
-  "outputInferenceCost",
-  "surchargeCost"
-];
-var RetryableNoImageResultError = class extends Error {
-  constructor() {
-    super("No image generated.");
-    this.name = "RetryableNoImageResultError";
+function validateBatchReference({
+  batchApi,
+  batch
+}) {
+  if (batch.version !== 2) {
+    throw new InvalidArgumentError({
+      parameter: "batch",
+      value: batch,
+      message: "batch must be a supported batch reference"
+    });
   }
-};
-async function generateImage({
-  model: modelArg,
-  prompt: promptArg,
-  n = 1,
-  maxImagesPerCall,
-  size,
-  aspectRatio,
-  seed,
-  providerOptions,
-  maxRetries: maxRetriesArg,
-  abortSignal,
-  headers
+  if (batch.provider !== batchApi.provider) {
+    throw new InvalidArgumentError({
+      parameter: "provider",
+      value: batchApi,
+      message: `provider ${batchApi.provider} is not compatible with batch provider ${batch.provider}`
+    });
+  }
+}
+async function convertBatchItemResult({
+  item,
+  tools
 }) {
-  var _a25, _b25;
-  const model = resolveImageModel(modelArg);
-  const headersWithUserAgent = withUserAgentSuffix7(
-    headers != null ? headers : {},
-    `ai/${VERSION}`
-  );
-  const { retry } = prepareRetries({
-    maxRetries: maxRetriesArg,
-    abortSignal,
-    additionalRetryableError: (error) => error instanceof RetryableNoImageResultError
-  });
-  const maxImagesPerCallWithDefault = (_a25 = maxImagesPerCall != null ? maxImagesPerCall : await invokeModelMaxImagesPerCall(model)) != null ? _a25 : 1;
-  const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
-  const callImageCounts = Array.from({ length: callCount }, (_, i) => {
-    if (i < callCount - 1) {
-      return maxImagesPerCallWithDefault;
-    }
-    const remainder = n % maxImagesPerCallWithDefault;
-    return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
-  });
-  const resultGroups = await Promise.all(
-    callImageCounts.map(async (callImageCount) => {
-      const callResults = [];
-      try {
-        await retry(async () => {
-          const { prompt, files, mask } = normalizePrompt(promptArg);
-          const result = await model.doGenerate({
-            prompt,
-            files,
-            mask,
-            n: callImageCount,
-            abortSignal,
-            headers: headersWithUserAgent,
-            size,
-            aspectRatio,
-            seed,
-            providerOptions: providerOptions != null ? providerOptions : {}
-          });
-          callResults.push(result);
-          if (result.images.length === 0 && result.isRetryable !== false) {
-            throw new RetryableNoImageResultError();
-          }
-          return result;
-        });
-        return callResults;
-      } catch (error) {
-        const noImageResultError = error instanceof RetryableNoImageResultError ? error : RetryError.isInstance(error) && error.lastError instanceof RetryableNoImageResultError ? error.lastError : void 0;
-        if (noImageResultError != null) {
-          return callResults;
-        }
-        throw error;
+  switch (item.type) {
+    case "text":
+      switch (item.status) {
+        case "succeeded":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            ...await convertGenerateResult({ result: item.result, tools })
+          };
+        case "failed":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            error: item.error,
+            providerMetadata: item.providerMetadata
+          };
+        case "cancelled":
+        case "expired":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            error: item.error,
+            providerMetadata: item.providerMetadata
+          };
       }
-    })
-  );
-  const results = resultGroups.flat();
-  const images = [];
-  const calls = [];
-  const warnings = [];
-  const responses = [];
-  const providerMetadata = {};
-  let totalUsage = {
-    inputTokens: void 0,
-    outputTokens: void 0,
-    totalTokens: void 0
-  };
-  for (const result of results) {
-    const callImages = result.images.map(
+    case "image":
+      switch (item.status) {
+        case "succeeded":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            ...convertImageResult(item.result)
+          };
+        case "failed":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            error: item.error,
+            providerMetadata: item.providerMetadata
+          };
+        case "cancelled":
+        case "expired":
+          return {
+            type: item.type,
+            id: item.id,
+            status: item.status,
+            error: item.error,
+            providerMetadata: item.providerMetadata
+          };
+      }
+  }
+}
+function convertImageResult(result) {
+  return {
+    images: result.images.map(
       (image, index) => {
-        var _a26;
+        var _a25;
         return new DefaultGeneratedFile({
           data: image,
-          mediaType: (_a26 = detectMediaType2({
-            data: image,
-            topLevelType: "image"
-          })) != null ? _a26 : "image/png",
+          mediaType: (_a25 = detectMediaType3({ data: image, topLevelType: "image" })) != null ? _a25 : "image/png",
           providerMetadata: getImageProviderMetadata(
             result.providerMetadata,
             index
           )
         });
       }
-    );
-    images.push(...callImages);
-    calls.push({
-      images: callImages,
-      providerMetadata: result.providerMetadata,
-      response: result.response,
-      warnings: result.warnings,
-      usage: result.usage
-    });
-    warnings.push(...result.warnings);
-    if (result.usage != null) {
-      totalUsage = addImageModelUsage(totalUsage, result.usage);
+    ),
+    warnings: result.warnings,
+    response: {
+      timestamp: result.response.timestamp,
+      modelId: result.response.modelId,
+      headers: result.response.headers
+    },
+    providerMetadata: result.providerMetadata,
+    usage: result.usage
+  };
+}
+async function convertGenerateResult({
+  result,
+  tools
+}) {
+  var _a25;
+  const toolCalls = await Promise.all(
+    result.content.filter(
+      (part) => part.type === "tool-call"
+    ).map(
+      (toolCall) => parseToolCall({
+        toolCall,
+        tools,
+        repairToolCall: void 0,
+        refineToolInput: void 0,
+        instructions: void 0,
+        messages: []
+      })
+    )
+  );
+  const content = convertLanguageModelContent({
+    content: result.content,
+    toolCalls,
+    toolOutputs: [],
+    toolApprovalRequests: [],
+    toolApprovalResponses: [],
+    tools
+  });
+  return {
+    content,
+    text: result.content.filter(
+      (part) => part.type === "text"
+    ).map((part) => part.text).join(""),
+    finishReason: result.finishReason.unified,
+    rawFinishReason: result.finishReason.raw,
+    usage: asLanguageModelUsage(result.usage),
+    ...result.response != null ? {
+      response: {
+        id: result.response.id,
+        timestamp: (_a25 = result.response.timestamp) == null ? void 0 : _a25.toISOString(),
+        modelId: result.response.modelId
+      }
+    } : {},
+    providerMetadata: result.providerMetadata
+  };
+}
+
+// src/embed/embed.ts
+import {
+  createIdGenerator as createIdGenerator4,
+  withUserAgentSuffix as withUserAgentSuffix6
+} from "@ai-sdk/provider-utils";
+
+// src/embed/restricted-telemetry-dispatcher.ts
+function createRestrictedTelemetryDispatcher2({
+  telemetry
+}) {
+  const dispatcher = createTelemetryDispatcher({ telemetry });
+  return {
+    ...dispatcher,
+    onStart: (event) => {
+      var _a25;
+      return (_a25 = dispatcher.onStart) == null ? void 0 : _a25.call(dispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext
+        })
+      });
+    },
+    onEnd: (event) => {
+      var _a25;
+      return (_a25 = dispatcher.onEnd) == null ? void 0 : _a25.call(dispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext
+        })
+      });
     }
-    if (result.providerMetadata) {
-      for (const [providerName, metadata] of Object.entries(
-        result.providerMetadata
-      )) {
-        if (providerName === "gateway") {
-          const currentEntry = providerMetadata[providerName];
-          if (currentEntry != null && typeof currentEntry === "object") {
-            const currentGatewayMetadata = currentEntry;
-            const newGatewayMetadata = metadata;
-            providerMetadata[providerName] = {
-              ...currentEntry,
-              ...metadata,
-              ...Object.fromEntries(
-                gatewayCostMetadataKeys.flatMap((key) => {
-                  const total = addDecimalStrings(
-                    currentGatewayMetadata[key],
-                    newGatewayMetadata[key]
-                  );
-                  return total == null ? [] : [[key, total]];
-                })
-              )
-            };
-          } else {
-            providerMetadata[providerName] = {
-              ...metadata
-            };
+  };
+}
+
+// src/embed/embed.ts
+var originalGenerateCallId4 = createIdGenerator4({
+  prefix: "call",
+  size: 24
+});
+async function embed({
+  model: modelArg,
+  value,
+  providerOptions,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  experimental_telemetry,
+  telemetry = experimental_telemetry,
+  runtimeContext = {},
+  onStart,
+  experimental_onStart,
+  onEnd,
+  experimental_onEnd,
+  _internal: { generateCallId = originalGenerateCallId4 } = {}
+}) {
+  var _a25;
+  const model = resolveEmbeddingModel(modelArg);
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
+  const resolvedOnEnd = onEnd != null ? onEnd : experimental_onEnd;
+  const headersWithUserAgent = withUserAgentSuffix6(
+    headers != null ? headers : {},
+    `ai/${VERSION}`
+  );
+  const callId = generateCallId();
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher2({
+    telemetry
+  });
+  const runInTracingChannelSpan = (_a25 = telemetryDispatcher.runInTracingChannelSpan) != null ? _a25 : (async ({ execute }) => await execute());
+  const startEvent = {
+    callId,
+    operationId: "ai.embed",
+    runtimeContext,
+    provider: model.provider,
+    modelId: model.modelId,
+    value,
+    maxRetries,
+    headers: headersWithUserAgent,
+    providerOptions
+  };
+  return await runInTracingChannelSpan({
+    type: "embed",
+    event: startEvent,
+    execute: async () => {
+      var _a26;
+      await notify({
+        event: startEvent,
+        callbacks: [resolvedOnStart, telemetryDispatcher.onStart]
+      });
+      try {
+        const { embedding, usage, warnings, response, providerMetadata } = await retry(async () => {
+          var _a27, _b25;
+          const embedCallId = generateCallId();
+          await notify({
+            event: {
+              callId,
+              embedCallId,
+              operationId: "ai.embed.doEmbed",
+              provider: model.provider,
+              modelId: model.modelId,
+              values: [value]
+            },
+            callbacks: [telemetryDispatcher.onEmbedStart]
+          });
+          const modelResponse = await model.doEmbed({
+            values: [value],
+            abortSignal,
+            headers: headersWithUserAgent,
+            providerOptions
+          });
+          const embedding2 = modelResponse.embeddings[0];
+          const usage2 = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
+          await notify({
+            event: {
+              callId,
+              embedCallId,
+              operationId: "ai.embed.doEmbed",
+              provider: model.provider,
+              modelId: model.modelId,
+              values: [value],
+              embeddings: modelResponse.embeddings,
+              usage: usage2
+            },
+            callbacks: [telemetryDispatcher.onEmbedEnd]
+          });
+          if (embedding2 == null) {
+            throw new InvalidResponseDataError({
+              data: modelResponse.embeddings,
+              message: "No embedding generated."
+            });
           }
-          const imagesValue = providerMetadata[providerName].images;
-          if (Array.isArray(imagesValue) && imagesValue.length === 0) {
-            delete providerMetadata[providerName].images;
+          return {
+            embedding: embedding2,
+            usage: usage2,
+            warnings: (_b25 = modelResponse.warnings) != null ? _b25 : [],
+            providerMetadata: modelResponse.providerMetadata,
+            response: modelResponse.response
+          };
+        });
+        logWarnings({
+          warnings,
+          provider: model.provider,
+          model: model.modelId
+        });
+        await notify({
+          event: {
+            callId,
+            operationId: "ai.embed",
+            runtimeContext,
+            provider: model.provider,
+            modelId: model.modelId,
+            value,
+            embedding,
+            usage,
+            warnings,
+            providerMetadata,
+            response
+          },
+          callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
+        });
+        return new DefaultEmbedResult({
+          value,
+          embedding,
+          usage,
+          warnings,
+          providerMetadata,
+          response
+        });
+      } catch (error) {
+        await ((_a26 = telemetryDispatcher.onError) == null ? void 0 : _a26.call(telemetryDispatcher, { callId, error }));
+        throw error;
+      }
+    }
+  });
+}
+var DefaultEmbedResult = class {
+  constructor(options) {
+    this.value = options.value;
+    this.embedding = options.embedding;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.providerMetadata = options.providerMetadata;
+    this.response = options.response;
+  }
+};
+
+// src/embed/embed-many.ts
+import { InvalidResponseDataError as InvalidResponseDataError2 } from "@ai-sdk/provider";
+import {
+  createIdGenerator as createIdGenerator5,
+  withUserAgentSuffix as withUserAgentSuffix7
+} from "@ai-sdk/provider-utils";
+
+// src/model/get-embedding-model-max-input-bytes-per-call.ts
+import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from "@ai-sdk/provider-utils";
+function getEmbeddingModelMaxInputBytesPerCall(model) {
+  return model[EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL];
+}
+
+// src/util/split-array.ts
+function splitArray(array3, chunkSize) {
+  if (chunkSize <= 0) {
+    throw new InvalidArgumentError({
+      parameter: "chunkSize",
+      value: chunkSize,
+      message: "chunkSize must be greater than 0"
+    });
+  }
+  const result = [];
+  for (let i = 0; i < array3.length; i += chunkSize) {
+    result.push(array3.slice(i, i + chunkSize));
+  }
+  return result;
+}
+
+// src/embed/embed-many.ts
+var originalGenerateCallId5 = createIdGenerator5({
+  prefix: "call",
+  size: 24
+});
+async function embedMany({
+  model: modelArg,
+  values,
+  maxParallelCalls = Infinity,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  providerOptions,
+  experimental_telemetry,
+  telemetry = experimental_telemetry,
+  runtimeContext = {},
+  onStart,
+  experimental_onStart,
+  onEnd,
+  experimental_onEnd,
+  _internal: { generateCallId = originalGenerateCallId5 } = {}
+}) {
+  var _a25;
+  const model = resolveEmbeddingModel(modelArg);
+  const { maxRetries, retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal
+  });
+  const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
+  const resolvedOnEnd = onEnd != null ? onEnd : experimental_onEnd;
+  const headersWithUserAgent = withUserAgentSuffix7(
+    headers != null ? headers : {},
+    `ai/${VERSION}`
+  );
+  const callId = generateCallId();
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher2({
+    telemetry
+  });
+  const runInTracingChannelSpan = (_a25 = telemetryDispatcher.runInTracingChannelSpan) != null ? _a25 : (async ({ execute }) => await execute());
+  const startEvent = {
+    callId,
+    operationId: "ai.embedMany",
+    runtimeContext,
+    provider: model.provider,
+    modelId: model.modelId,
+    value: values,
+    maxRetries,
+    headers: headersWithUserAgent,
+    providerOptions
+  };
+  return await runInTracingChannelSpan({
+    type: "embedMany",
+    event: startEvent,
+    execute: async () => {
+      var _a26, _b25;
+      await notify({
+        event: startEvent,
+        callbacks: [resolvedOnStart, telemetryDispatcher.onStart]
+      });
+      try {
+        const [
+          maxEmbeddingsPerCall,
+          maxInputBytesPerCall,
+          supportsParallelCalls
+        ] = await Promise.all([
+          model.maxEmbeddingsPerCall,
+          getEmbeddingModelMaxInputBytesPerCall(model),
+          model.supportsParallelCalls
+        ]);
+        const hasEmbeddingLimit = maxEmbeddingsPerCall != null && maxEmbeddingsPerCall !== Infinity;
+        const hasInputByteLimit = maxInputBytesPerCall != null && maxInputBytesPerCall !== Infinity;
+        if (!hasEmbeddingLimit && !hasInputByteLimit) {
+          const { embeddings: embeddings2, usage, warnings: warnings2, response, providerMetadata: providerMetadata2 } = await retry(async () => {
+            var _a27, _b26;
+            const embedCallId = generateCallId();
+            await notify({
+              event: {
+                callId,
+                embedCallId,
+                operationId: "ai.embedMany.doEmbed",
+                provider: model.provider,
+                modelId: model.modelId,
+                values
+              },
+              callbacks: [telemetryDispatcher.onEmbedStart]
+            });
+            const modelResponse = await model.doEmbed({
+              values,
+              abortSignal,
+              headers: headersWithUserAgent,
+              providerOptions
+            });
+            const embeddings3 = modelResponse.embeddings;
+            const usage2 = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
+            await notify({
+              event: {
+                callId,
+                embedCallId,
+                operationId: "ai.embedMany.doEmbed",
+                provider: model.provider,
+                modelId: model.modelId,
+                values,
+                embeddings: embeddings3,
+                usage: usage2
+              },
+              callbacks: [telemetryDispatcher.onEmbedEnd]
+            });
+            return {
+              embeddings: embeddings3,
+              usage: usage2,
+              warnings: (_b26 = modelResponse.warnings) != null ? _b26 : [],
+              providerMetadata: modelResponse.providerMetadata,
+              response: modelResponse.response
+            };
+          });
+          validateEmbeddingCount({ embeddings: embeddings2, values });
+          logWarnings({
+            warnings: warnings2,
+            provider: model.provider,
+            model: model.modelId
+          });
+          await notify({
+            event: {
+              callId,
+              operationId: "ai.embedMany",
+              runtimeContext,
+              provider: model.provider,
+              modelId: model.modelId,
+              value: values,
+              embedding: embeddings2,
+              usage,
+              warnings: warnings2,
+              providerMetadata: providerMetadata2,
+              response: [response]
+            },
+            callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
+          });
+          return new DefaultEmbedManyResult({
+            values,
+            embeddings: embeddings2,
+            usage,
+            warnings: warnings2,
+            providerMetadata: providerMetadata2,
+            responses: [response]
+          });
+        }
+        const valueChunks = splitByEmbeddingLimits({
+          values,
+          maxEmbeddingsPerCall: hasEmbeddingLimit ? maxEmbeddingsPerCall : Infinity,
+          maxInputBytesPerCall: hasInputByteLimit ? maxInputBytesPerCall : Infinity
+        });
+        const embeddings = [];
+        const warnings = [];
+        const responses = [];
+        let tokens = 0;
+        let providerMetadata;
+        const parallelChunks = splitArray(
+          valueChunks,
+          supportsParallelCalls ? maxParallelCalls : 1
+        );
+        for (const parallelChunk of parallelChunks) {
+          const results = await Promise.all(
+            parallelChunk.map(async (chunk) => {
+              const result = await retry(async () => {
+                var _a27, _b26;
+                const embedCallId = generateCallId();
+                await notify({
+                  event: {
+                    callId,
+                    embedCallId,
+                    operationId: "ai.embedMany.doEmbed",
+                    provider: model.provider,
+                    modelId: model.modelId,
+                    values: chunk
+                  },
+                  callbacks: [telemetryDispatcher.onEmbedStart]
+                });
+                const modelResponse = await model.doEmbed({
+                  values: chunk,
+                  abortSignal,
+                  headers: headersWithUserAgent,
+                  providerOptions
+                });
+                const chunkEmbeddings = modelResponse.embeddings;
+                const usage = (_a27 = modelResponse.usage) != null ? _a27 : { tokens: NaN };
+                await notify({
+                  event: {
+                    callId,
+                    embedCallId,
+                    operationId: "ai.embedMany.doEmbed",
+                    provider: model.provider,
+                    modelId: model.modelId,
+                    values: chunk,
+                    embeddings: chunkEmbeddings,
+                    usage
+                  },
+                  callbacks: [telemetryDispatcher.onEmbedEnd]
+                });
+                return {
+                  embeddings: chunkEmbeddings,
+                  usage,
+                  warnings: (_b26 = modelResponse.warnings) != null ? _b26 : [],
+                  providerMetadata: modelResponse.providerMetadata,
+                  response: modelResponse.response
+                };
+              });
+              validateEmbeddingCount({
+                embeddings: result.embeddings,
+                values: chunk
+              });
+              return result;
+            })
+          );
+          for (const result of results) {
+            embeddings.push(...result.embeddings);
+            warnings.push(...result.warnings);
+            responses.push(result.response);
+            tokens += result.usage.tokens;
+            if (result.providerMetadata) {
+              if (!providerMetadata) {
+                providerMetadata = { ...result.providerMetadata };
+              } else {
+                for (const [providerName, metadata] of Object.entries(
+                  result.providerMetadata
+                )) {
+                  providerMetadata[providerName] = {
+                    ...(_a26 = providerMetadata[providerName]) != null ? _a26 : {},
+                    ...metadata
+                  };
+                }
+              }
+            }
           }
-        } else {
-          (_b25 = providerMetadata[providerName]) != null ? _b25 : providerMetadata[providerName] = { images: [] };
-          providerMetadata[providerName].images.push(...metadata.images);
         }
+        logWarnings({
+          warnings,
+          provider: model.provider,
+          model: model.modelId
+        });
+        await notify({
+          event: {
+            callId,
+            operationId: "ai.embedMany",
+            runtimeContext,
+            provider: model.provider,
+            modelId: model.modelId,
+            value: values,
+            embedding: embeddings,
+            usage: { tokens },
+            warnings,
+            providerMetadata,
+            response: responses
+          },
+          callbacks: [resolvedOnEnd, telemetryDispatcher.onEnd]
+        });
+        return new DefaultEmbedManyResult({
+          values,
+          embeddings,
+          usage: { tokens },
+          warnings,
+          providerMetadata,
+          responses
+        });
+      } catch (error) {
+        await ((_b25 = telemetryDispatcher.onError) == null ? void 0 : _b25.call(telemetryDispatcher, { callId, error }));
+        throw error;
       }
     }
-    responses.push(result.response);
-  }
-  logWarnings({ warnings, provider: model.provider, model: model.modelId });
-  if (!images.length) {
-    throw new NoImageGeneratedError({ calls, responses });
-  }
-  return new DefaultGenerateImageResult({
-    images,
-    calls,
-    warnings,
-    responses,
-    providerMetadata,
-    usage: totalUsage
   });
 }
-var DefaultGenerateImageResult = class {
-  constructor(options) {
-    this.images = options.images;
-    this.calls = options.calls;
-    this.warnings = options.warnings;
-    this.responses = options.responses;
-    this.providerMetadata = options.providerMetadata;
-    this.usage = options.usage;
-  }
-  get image() {
-    return this.images[0];
-  }
-};
-function getImageProviderMetadata(providerMetadata, imageIndex) {
-  var _a25;
-  if (providerMetadata == null) {
-    return void 0;
-  }
-  let imageMetadata;
-  for (const [providerName, metadata] of Object.entries(providerMetadata)) {
-    const value = (_a25 = metadata.images) == null ? void 0 : _a25[imageIndex];
-    if (isJSONObject(value) && !Array.isArray(value)) {
-      (imageMetadata != null ? imageMetadata : imageMetadata = {})[providerName] = value;
-    }
-  }
-  return imageMetadata;
-}
-async function invokeModelMaxImagesPerCall(model) {
-  const isFunction = model.maxImagesPerCall instanceof Function;
-  if (!isFunction) {
-    return model.maxImagesPerCall;
+function validateEmbeddingCount({
+  embeddings,
+  values
+}) {
+  if (embeddings.length !== values.length) {
+    throw new InvalidResponseDataError2({
+      data: embeddings,
+      message: `Expected ${values.length} embeddings, but received ${embeddings.length}.`
+    });
   }
-  return model.maxImagesPerCall({
-    modelId: model.modelId
-  });
 }
-function addDecimalStrings(value1, value2) {
-  if (typeof value1 !== "string" || typeof value2 !== "string" || !/^\d+(?:\.\d+)?$/.test(value1) || !/^\d+(?:\.\d+)?$/.test(value2)) {
-    return void 0;
+var textEncoder = new TextEncoder();
+function splitByEmbeddingLimits({
+  values,
+  maxEmbeddingsPerCall,
+  maxInputBytesPerCall
+}) {
+  if (maxEmbeddingsPerCall <= 0) {
+    throw new Error("maxEmbeddingsPerCall must be greater than 0");
   }
-  const [integer1, fraction1 = ""] = value1.split(".");
-  const [integer2, fraction2 = ""] = value2.split(".");
-  const precision = Math.max(fraction1.length, fraction2.length);
-  const sum = BigInt(integer1 + fraction1.padEnd(precision, "0")) + BigInt(integer2 + fraction2.padEnd(precision, "0"));
-  const sumString = sum.toString().padStart(precision + 1, "0");
-  return precision === 0 ? sumString : `${sumString.slice(0, -precision)}.${sumString.slice(
-    -precision
-  )}`.replace(/\.?0+$/, "");
-}
-function normalizePrompt(prompt) {
-  if (typeof prompt === "string") {
-    return { prompt, files: void 0, mask: void 0 };
+  if (maxInputBytesPerCall <= 0) {
+    throw new Error("maxInputBytesPerCall must be greater than 0");
   }
-  return {
-    prompt: prompt.text,
-    files: prompt.images.map(toImageModelV4File),
-    mask: prompt.mask ? toImageModelV4File(prompt.mask) : void 0
-  };
-}
-function toImageModelV4File(dataContent) {
-  if (typeof dataContent === "string" && dataContent.startsWith("http")) {
-    return {
-      type: "url",
-      url: dataContent
-    };
+  if (values.length === 0) {
+    return [];
   }
-  if (typeof dataContent === "string" && dataContent.startsWith("data:")) {
-    const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(dataContent);
-    if (base64Content != null) {
-      const uint8Data2 = convertBase64ToUint8Array4(base64Content);
-      return {
-        type: "file",
-        data: uint8Data2,
-        mediaType: dataUrlMediaType || detectMediaType2({
-          data: uint8Data2,
-          topLevelType: "image"
-        }) || "image/png"
-      };
+  const chunks = [];
+  let currentChunk = [];
+  let currentInputBytes = 0;
+  for (const value of values) {
+    const inputBytes = textEncoder.encode(value).length;
+    if (currentChunk.length > 0 && (currentChunk.length >= maxEmbeddingsPerCall || currentInputBytes + inputBytes > maxInputBytesPerCall)) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentInputBytes = 0;
     }
+    currentChunk.push(value);
+    currentInputBytes += inputBytes;
   }
-  const uint8Data = convertDataContentToUint8Array(dataContent);
-  return {
-    type: "file",
-    data: uint8Data,
-    mediaType: detectMediaType2({
-      data: uint8Data,
-      topLevelType: "image"
-    }) || "image/png"
-  };
+  chunks.push(currentChunk);
+  return chunks;
 }
+var DefaultEmbedManyResult = class {
+  constructor(options) {
+    this.values = options.values;
+    this.embeddings = options.embeddings;
+    this.usage = options.usage;
+    this.warnings = options.warnings;
+    this.providerMetadata = options.providerMetadata;
+    this.responses = options.responses;
+  }
+};
 
 // src/generate-object/generate-object.ts
 import {
@@ -14606,12 +14741,20 @@ function getTextFromDataUrl(dataUrl) {
   const [header, base64Content] = dataUrl.split(",");
   const mediaType = header.split(";")[0].split(":")[1];
   if (mediaType == null || base64Content == null) {
-    throw new Error("Invalid data URL format");
+    throw new InvalidArgumentError({
+      parameter: "dataUrl",
+      value: dataUrl,
+      message: "Invalid data URL format"
+    });
   }
   try {
     return atob2(base64Content);
   } catch (e) {
-    throw new Error(`Error decoding data URL`);
+    throw new InvalidArgumentError({
+      parameter: "dataUrl",
+      value: dataUrl,
+      message: "Error decoding data URL"
+    });
   }
 }
 
@@ -15230,7 +15373,7 @@ var DefaultStreamObjectResult = class {
 
 // src/generate-speech/generate-speech.ts
 import {
-  detectMediaType as detectMediaType3,
+  detectMediaType as detectMediaType4,
   withUserAgentSuffix as withUserAgentSuffix9
 } from "@ai-sdk/provider-utils";
 
@@ -15310,7 +15453,7 @@ async function generateSpeech({
   return new DefaultSpeechResult({
     audio: new DefaultGeneratedAudioFile({
       data: result.audio,
-      mediaType: (_a25 = detectMediaType3({
+      mediaType: (_a25 = detectMediaType4({
         data: result.audio,
         topLevelType: "audio"
       })) != null ? _a25 : "audio/mp3"
@@ -15589,7 +15732,7 @@ import {
   delay as defaultDelay,
   generateId,
   withUserAgentSuffix as withUserAgentSuffix10,
-  detectMediaType as detectMediaType4
+  detectMediaType as detectMediaType5
 } from "@ai-sdk/provider-utils";
 var defaultDownload = createDownload();
 async function experimental_generateVideo({
@@ -15697,7 +15840,7 @@ async function experimental_generateVideo({
             abortSignal
           });
           const isUsableMediaType = (type) => !!type && type !== "application/octet-stream";
-          const mediaType = isUsableMediaType(videoData.mediaType) && videoData.mediaType || isUsableMediaType(downloadedMediaType) && downloadedMediaType || detectMediaType4({
+          const mediaType = isUsableMediaType(videoData.mediaType) && videoData.mediaType || isUsableMediaType(downloadedMediaType) && downloadedMediaType || detectMediaType5({
             data,
             topLevelType: "video"
           }) || "video/mp4";
@@ -15719,7 +15862,7 @@ async function experimental_generateVideo({
           break;
         }
         case "binary": {
-          const mediaType = videoData.mediaType || detectMediaType4({
+          const mediaType = videoData.mediaType || detectMediaType5({
             data: videoData.data,
             topLevelType: "video"
           }) || "video/mp4";
@@ -15957,7 +16100,7 @@ function normalizeVideoCallInputs({
   };
 }
 function detectFileMediaType(data, restrictToImages) {
-  const detected = restrictToImages ? detectMediaType4({ data, topLevelType: "image" }) : detectMediaType4({ data });
+  const detected = restrictToImages ? detectMediaType5({ data, topLevelType: "image" }) : detectMediaType5({ data });
   return detected != null ? detected : "image/png";
 }
 function normalizeImageData(dataContent, { restrictToImages = true } = {}) {
@@ -18059,9 +18202,44 @@ var DefaultProviderRegistry = class {
 };
 
 // src/rerank/rerank.ts
+import {
+  InvalidResponseDataError as InvalidResponseDataError3
+} from "@ai-sdk/provider";
 import {
   createIdGenerator as createIdGenerator8
 } from "@ai-sdk/provider-utils";
+
+// src/rerank/restricted-telemetry-dispatcher.ts
+function createRestrictedTelemetryDispatcher3({
+  telemetry
+}) {
+  const dispatcher = createTelemetryDispatcher({ telemetry });
+  return {
+    ...dispatcher,
+    onStart: (event) => {
+      var _a25;
+      return (_a25 = dispatcher.onStart) == null ? void 0 : _a25.call(dispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext
+        })
+      });
+    },
+    onEnd: (event) => {
+      var _a25;
+      return (_a25 = dispatcher.onEnd) == null ? void 0 : _a25.call(dispatcher, {
+        ...event,
+        runtimeContext: filterIncludedContext({
+          context: event.runtimeContext,
+          includeContext: telemetry == null ? void 0 : telemetry.includeRuntimeContext
+        })
+      });
+    }
+  };
+}
+
+// src/rerank/rerank.ts
 var originalGenerateCallId6 = createIdGenerator8({
   prefix: "call",
   size: 24
@@ -18077,6 +18255,7 @@ async function rerank({
   providerOptions,
   experimental_telemetry,
   telemetry = experimental_telemetry,
+  runtimeContext = {},
   onStart,
   experimental_onStart,
   onEnd,
@@ -18088,7 +18267,7 @@ async function rerank({
   const callId = generateCallId();
   const resolvedOnStart = onStart != null ? onStart : experimental_onStart;
   const resolvedOnEnd = onEnd != null ? onEnd : experimental_onEnd;
-  const telemetryDispatcher = createTelemetryDispatcher({
+  const telemetryDispatcher = createRestrictedTelemetryDispatcher3({
     telemetry
   });
   const runInTracingChannelSpan = (_a25 = telemetryDispatcher.runInTracingChannelSpan) != null ? _a25 : (async ({ execute }) => await execute());
@@ -18097,6 +18276,7 @@ async function rerank({
       event: {
         callId,
         operationId: "ai.rerank",
+        runtimeContext,
         provider: model.provider,
         modelId: model.modelId,
         documents,
@@ -18112,6 +18292,7 @@ async function rerank({
       event: {
         callId,
         operationId: "ai.rerank",
+        runtimeContext,
         provider: model.provider,
         modelId: model.modelId,
         documents,
@@ -18144,6 +18325,7 @@ async function rerank({
   const startEvent = {
     callId,
     operationId: "ai.rerank",
+    runtimeContext,
     provider: model.provider,
     modelId: model.modelId,
     documents,
@@ -18206,6 +18388,7 @@ async function rerank({
             };
           }
         );
+        validateRankingIndices({ ranking, documents });
         logWarnings({
           warnings: warnings != null ? warnings : [],
           provider: model.provider,
@@ -18215,14 +18398,15 @@ async function rerank({
           event: {
             callId,
             operationId: "ai.rerank",
+            runtimeContext,
             provider: model.provider,
             modelId: model.modelId,
             documents,
             query,
-            ranking: ranking.map((r) => ({
-              originalIndex: r.index,
-              score: r.relevanceScore,
-              document: documents[r.index]
+            ranking: ranking.map((ranking2) => ({
+              originalIndex: ranking2.index,
+              score: ranking2.relevanceScore,
+              document: documents[ranking2.index]
             })),
             warnings: warnings != null ? warnings : [],
             providerMetadata,
@@ -18259,6 +18443,19 @@ async function rerank({
     }
   });
 }
+function validateRankingIndices({
+  ranking,
+  documents
+}) {
+  for (const { index } of ranking) {
+    if (!Number.isInteger(index) || index < 0 || index >= documents.length) {
+      throw new InvalidResponseDataError3({
+        data: ranking,
+        message: `Invalid ranking index ${index}. Expected an integer between 0 and ${documents.length - 1}.`
+      });
+    }
+  }
+}
 var DefaultRerankResult = class {
   constructor(options) {
     this.originalDocuments = options.originalDocuments;
@@ -18273,7 +18470,7 @@ var DefaultRerankResult = class {
 
 // src/transcribe/transcribe.ts
 import {
-  detectMediaType as detectMediaType5,
+  detectMediaType as detectMediaType6,
   withUserAgentSuffix as withUserAgentSuffix13
 } from "@ai-sdk/provider-utils";
 var defaultDownload2 = createDownload();
@@ -18307,7 +18504,7 @@ async function transcribe({
         abortSignal,
         headers: headersWithUserAgent,
         providerOptions,
-        mediaType: (_a25 = detectMediaType5({
+        mediaType: (_a25 = detectMediaType6({
           data: audioData,
           topLevelType: "audio"
         })) != null ? _a25 : "audio/wav"
@@ -19676,7 +19873,7 @@ var TextStreamChatTransport = class extends HttpChatTransport {
 // src/upload-file/upload-file.ts
 import {
   convertBase64ToUint8Array as convertBase64ToUint8Array6,
-  detectMediaType as detectMediaType6
+  detectMediaType as detectMediaType7
 } from "@ai-sdk/provider-utils";
 async function uploadFile({
   api,
@@ -19689,7 +19886,7 @@ async function uploadFile({
 }) {
   var _a25;
   const data = dataArg instanceof Uint8Array || typeof dataArg === "string" ? { type: "data", data: dataArg } : dataArg;
-  const mediaType = mediaTypeArg != null ? mediaTypeArg : data.type === "text" ? "text/plain" : data.type === "stream" ? "application/octet-stream" : (_a25 = detectMediaType6({ data: data.data })) != null ? _a25 : isLikelyText(data.data) ? "text/plain" : "application/octet-stream";
+  const mediaType = mediaTypeArg != null ? mediaTypeArg : data.type === "text" ? "text/plain" : data.type === "stream" ? "application/octet-stream" : (_a25 = detectMediaType7({ data: data.data })) != null ? _a25 : isLikelyText(data.data) ? "text/plain" : "application/octet-stream";
   let result;
   try {
     const filesApi = "uploadFile" in api ? api : typeof api.files === "function" ? api.files() : (() => {
@@ -19906,6 +20103,7 @@ export {
   isStaticToolUIPart,
   isStepCount,
   isTextUIPart,
+  isToolOutputErrorUIPart,
   isToolUIPart,
   jsonSchema,
   lastAssistantMessageIsCompleteWithApprovalResponses,