ai 7.0.93 → 7.0.94

package/dist/index.js

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 // src/index.ts
 import {
   createGateway,
-  gateway as gateway2
+  gateway as gateway3
 } from "@ai-sdk/gateway";
 import {
   asSchema as asSchema8,
@@ -1178,7 +1178,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.93" : "0.0.0-test";
+var VERSION = true ? "7.0.94" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -2813,13 +2813,14 @@ var retryWithExponentialBackoffRespectingRetryHeaders = ({
   maxRetries = 2,
   initialDelayInMs = 2e3,
   backoffFactor = 2,
-  abortSignal
+  abortSignal,
+  additionalRetryableError
 } = {}) => retryWithExponentialBackoff({
   maxRetries,
   initialDelayInMs,
   backoffFactor,
   abortSignal,
-  shouldRetry: (error) => error instanceof Error && (APICallError2.isInstance(error) && error.isRetryable === true || GatewayError.isInstance(error) && error.isRetryable === true),
+  shouldRetry: async (error) => error instanceof Error && (APICallError2.isInstance(error) && error.isRetryable === true || GatewayError.isInstance(error) && error.isRetryable === true) || additionalRetryableError != null && await additionalRetryableError(error),
   getDelayInMs: ({ error, exponentialBackoffDelay }) => getRetryDelayInMs({
     error,
     exponentialBackoffDelay
@@ -2831,6 +2832,7 @@ var retryWithExponentialBackoffRespectingRetryHeaders = ({
 function prepareRetries({
   maxRetries,
   abortSignal,
+  additionalRetryableError,
   parameter = "maxRetries",
   defaultMaxRetries = 2
 }) {
@@ -2855,7 +2857,8 @@ function prepareRetries({
     maxRetries: maxRetriesResult,
     retry: retryWithExponentialBackoffRespectingRetryHeaders({
       maxRetries: maxRetriesResult,
-      abortSignal
+      abortSignal,
+      additionalRetryableError
     })
   };
 }
@@ -8792,6 +8795,7 @@ async function streamLanguageModelCall({
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
+      toolChoice: stepToolChoice,
       generateId: generateId4,
       now: now2,
       callStartTimestampMs,
@@ -8813,6 +8817,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
   callId,
   provider,
   modelId,
+  toolChoice,
   generateId: generateId4,
   now: now2,
   callStartTimestampMs,
@@ -8820,8 +8825,11 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
 }) {
   const toolCallsByToolCallId = /* @__PURE__ */ new Map();
   const modelCallContent = [];
+  const rawModelCallContent = [];
   const textPartIndexes = /* @__PURE__ */ new Map();
   const reasoningPartIndexes = /* @__PURE__ */ new Map();
+  const rawTextPartIndexes = /* @__PURE__ */ new Map();
+  const rawReasoningPartIndexes = /* @__PURE__ */ new Map();
   let responseId = generateId4();
   let responseModelId = modelId;
   let timeToFirstOutputMs;
@@ -8851,7 +8859,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "text-start":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: "text",
             providerMetadata: chunk.providerMetadata
@@ -8861,7 +8871,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "text-delta":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: "text",
             textDelta: chunk.delta,
@@ -8877,18 +8889,23 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "text-end":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: "text",
             providerMetadata: chunk.providerMetadata
           });
           textPartIndexes.delete(chunk.id);
+          rawTextPartIndexes.delete(chunk.id);
           controller.enqueue(chunk);
           break;
         case "reasoning-start":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: "reasoning",
             providerMetadata: chunk.providerMetadata
@@ -8898,7 +8915,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "reasoning-delta":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: "reasoning",
             textDelta: chunk.delta,
@@ -8914,12 +8933,15 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         case "reasoning-end":
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: "reasoning",
             providerMetadata: chunk.providerMetadata
           });
           reasoningPartIndexes.delete(chunk.id);
+          rawReasoningPartIndexes.delete(chunk.id);
           controller.enqueue(chunk);
           break;
         case "file":
@@ -8933,6 +8955,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             file,
             ...chunk.providerMetadata != null ? { providerMetadata: chunk.providerMetadata } : {}
           });
+          rawModelCallContent.push(chunk);
           controller.enqueue({
             type: chunk.type,
             file,
@@ -8986,9 +9009,26 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
             providerMetadata: chunk.providerMetadata,
             performance
           });
+          const enforcedToolChoice = toolChoice.type === "required" || toolChoice.type === "tool" ? toolChoice : void 0;
+          if (enforcedToolChoice != null && ![...toolCallsByToolCallId.values()].some(
+            (toolCall) => enforcedToolChoice.type === "required" || toolCall.toolName === enforcedToolChoice.toolName
+          )) {
+            controller.enqueue({
+              type: "error",
+              error: new ToolChoiceViolationError({
+                toolChoice: enforcedToolChoice,
+                finishReason: chunk.finishReason.unified,
+                provider,
+                modelId,
+                content: rawModelCallContent
+              })
+            });
+            break;
+          }
           break;
         }
         case "tool-call": {
+          rawModelCallContent.push(chunk);
           try {
             const toolCall = await parseToolCall({
               toolCall: chunk,
@@ -9022,6 +9062,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
           break;
         }
         case "tool-approval-request": {
+          rawModelCallContent.push(chunk);
           const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
           if (toolCall == null) {
             controller.enqueue({
@@ -9043,6 +9084,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
           break;
         }
         case "tool-result": {
+          rawModelCallContent.push(chunk);
           const toolName = chunk.toolName;
           const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
           const toolResultPart = chunk.isError ? {
@@ -9101,6 +9143,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform({
         default:
           if (chunk.type === "custom" || chunk.type === "source") {
             modelCallContent.push(chunk);
+            rawModelCallContent.push(chunk);
           }
           controller.enqueue(chunk);
           break;
@@ -9128,7 +9171,9 @@ function calculateNearestRankPercentile(sortedValues, percentile) {
 }
 function upsertTextContentPart({
   content,
+  rawContent,
   partIndexes,
+  rawPartIndexes,
   id,
   type,
   textDelta,
@@ -9143,12 +9188,24 @@ function upsertTextContentPart({
     }) - 1;
     partIndexes.set(id, partIndex);
   }
+  let rawPartIndex = rawPartIndexes.get(id);
+  if (rawPartIndex == null) {
+    rawPartIndex = rawContent.push({
+      type,
+      text: "",
+      ...providerMetadata != null ? { providerMetadata } : {}
+    }) - 1;
+    rawPartIndexes.set(id, rawPartIndex);
+  }
   const part = content[partIndex];
+  const rawPart = rawContent[rawPartIndex];
   if (textDelta != null) {
     part.text += textDelta;
+    rawPart.text += textDelta;
   }
   if (providerMetadata != null) {
     part.providerMetadata = providerMetadata;
+    rawPart.providerMetadata = providerMetadata;
   }
 }
 
@@ -10492,14 +10549,15 @@ var DefaultStreamTextResult = class {
                   callbacks: onChunk
                 });
                 const error = wrapGatewayError(value.error);
+                const isToolChoiceViolation = ToolChoiceViolationError.isInstance(error);
                 let onErrorResult;
                 try {
                   onErrorResult = await onError({ error });
                 } catch (e) {
                 }
                 const callbackRequestedRetry = canRetryStreamViaOnError && typeof onErrorResult === "object" && onErrorResult != null && "retry" in onErrorResult && onErrorResult.retry === true;
-                const automaticRetry = automaticStreamRetryCount < streamRetries;
-                const callbackRetry = !automaticRetry && callbackRequestedRetry && callbackStreamRetryCount < 1;
+                const automaticRetry = !isToolChoiceViolation && automaticStreamRetryCount < streamRetries;
+                const callbackRetry = !isToolChoiceViolation && !automaticRetry && callbackRequestedRetry && callbackStreamRetryCount < 1;
                 if (!automaticRetry && !callbackRetry) {
                   flushBufferedAttemptParts();
                   errorsHandledForStreamRetry.add(value.error);
@@ -12522,14 +12580,40 @@ async function pipeAgentUIStreamToResponse({
 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";
-async function startTextBatch({
-  model: modelArg,
+
+// 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/batch/batch.ts
+async function startBatch({
+  provider,
   requests,
-  tools,
-  toolChoice,
-  toolOrder,
-  toolsContext,
   providerOptions,
   webhookUrl,
   abortSignal,
@@ -12537,37 +12621,49 @@ async function startTextBatch({
   timeout
 }) {
   validateRequests(requests);
-  const model = resolveBatchLanguageModel(modelArg);
+  const batchApi = resolveBatchApi(provider);
   const operationAbortSignal = mergeAbortSignals(
     abortSignal,
     getTotalTimeoutMs(timeout)
   );
-  const supportedUrls = await model.supportedUrls;
-  const preparedTools = await prepareTools({
-    tools,
-    toolOrder,
-    toolsContext
-  });
-  const preparedToolChoice = prepareToolChoice({ toolChoice });
+  const supportedUrls = await batchApi.supportedUrls;
   operationAbortSignal == null ? void 0 : operationAbortSignal.throwIfAborted();
   const normalizedRequests = [];
+  const toolsByName = /* @__PURE__ */ new Map();
   for (const request of requests) {
-    const standardizedPrompt = await standardizePrompt(request);
-    normalizedRequests.push({
-      id: request.id,
-      options: {
-        ...prepareLanguageModelCallOptions(request),
-        prompt: await convertToLanguageModelPrompt({
-          prompt: standardizedPrompt,
-          supportedUrls,
-          download: void 0,
-          provider: model.provider.split(".")[0]
-        }),
-        tools: preparedTools,
-        toolChoice: preparedToolChoice,
-        providerOptions: request.providerOptions
+    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();
   }
   const headersWithUserAgent = withUserAgentSuffix4(
@@ -12575,7 +12671,7 @@ async function startTextBatch({
     `ai/${VERSION}`
   );
   try {
-    const result = await model.experimental_doStartBatch({
+    const result = await batchApi.doStartBatch({
       requests: normalizedRequests,
       providerOptions,
       abortSignal: operationAbortSignal,
@@ -12583,17 +12679,20 @@ async function startTextBatch({
       ...webhookUrl != null && { webhookUrl }
     });
     const { batchId, warnings, ...status } = result;
-    logWarnings({
-      warnings: warnings.map(({ warning }) => warning),
-      provider: model.provider,
-      model: model.modelId
-    });
+    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: 1,
-      type: "text",
+      version: 2,
       id: batchId,
-      provider: model.provider,
-      modelId: model.modelId,
+      provider: batchApi.provider,
       ...status,
       warnings
     };
@@ -12601,8 +12700,25 @@ async function startTextBatch({
     throw wrapGatewayError(error);
   }
 }
+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);
+  }
+}
 async function getBatchStatus({
-  model: modelArg,
+  provider,
   batch,
   providerOptions,
   maxRetries,
@@ -12610,8 +12726,8 @@ async function getBatchStatus({
   headers,
   timeout
 }) {
-  const model = resolveBatchLanguageModel(modelArg);
-  validateBatchReference({ model, batch });
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
   const operationAbortSignal = mergeAbortSignals(
     abortSignal,
     getTotalTimeoutMs(timeout)
@@ -12622,7 +12738,7 @@ async function getBatchStatus({
   });
   try {
     const status = await retry(
-      () => model.experimental_doGetBatchStatus({
+      () => batchApi.doGetBatchStatus({
         batchId: batch.id,
         providerOptions,
         abortSignal: operationAbortSignal,
@@ -12635,7 +12751,7 @@ async function getBatchStatus({
   }
 }
 function getBatchResults({
-  model: modelArg,
+  provider,
   batch,
   tools,
   providerOptions,
@@ -12644,8 +12760,8 @@ function getBatchResults({
   headers,
   timeout
 }) {
-  const model = resolveBatchLanguageModel(modelArg);
-  validateBatchReference({ model, batch });
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
   const streamAbortController = new AbortController();
   const operationAbortSignal = mergeAbortSignals(
     abortSignal,
@@ -12670,7 +12786,7 @@ function getBatchResults({
   void (async () => {
     try {
       const stream = await retry(
-        () => model.experimental_doGetBatchResults({
+        () => batchApi.doGetBatchResults({
           batchId: batch.id,
           providerOptions,
           abortSignal: operationAbortSignal,
@@ -12687,19 +12803,26 @@ function getBatchResults({
   })();
   return asAsyncIterableStream(transform.readable);
 }
-function resolveBatchLanguageModel(modelArg) {
-  const model = resolveLanguageModel(modelArg);
-  if (!isBatchLanguageModel(model)) {
+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 ${model.provider} model "${model.modelId}" does not support batch processing.`
+      message: "The provider does not support batch processing. Make sure it exposes an experimental_batch() method."
     });
   }
-  return model;
+  return provider.experimental_batch();
 }
-function isBatchLanguageModel(model) {
-  const candidate = model;
-  return typeof candidate.experimental_doStartBatch === "function" && typeof candidate.experimental_doGetBatchStatus === "function" && typeof candidate.experimental_doGetBatchResults === "function";
+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";
 }
 function validateRequests(requests) {
   if (requests.length === 0) {
@@ -12729,21 +12852,21 @@ function validateRequests(requests) {
   }
 }
 function validateBatchReference({
-  model,
+  batchApi,
   batch
 }) {
-  if (batch.version !== 1 || batch.type !== "text") {
+  if (batch.version !== 2) {
     throw new InvalidArgumentError({
       parameter: "batch",
       value: batch,
-      message: "batch must be a supported text batch reference"
+      message: "batch must be a supported batch reference"
     });
   }
-  if (batch.provider !== model.provider || batch.modelId !== model.modelId) {
+  if (batch.provider !== batchApi.provider) {
     throw new InvalidArgumentError({
-      parameter: "model",
-      value: model,
-      message: `model ${model.provider}:${model.modelId} is not compatible with batch ${batch.provider}:${batch.modelId}`
+      parameter: "provider",
+      value: batchApi,
+      message: `provider ${batchApi.provider} is not compatible with batch provider ${batch.provider}`
     });
   }
 }
@@ -12751,14 +12874,32 @@ async function convertBatchItemResult({
   item,
   tools
 }) {
-  if (item.status !== "succeeded") {
-    return item;
+  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
+          };
+      }
   }
-  return {
-    id: item.id,
-    status: "succeeded",
-    ...await convertGenerateResult({ result: item.result, tools })
-  };
 }
 async function convertGenerateResult({
   result,
@@ -13355,6 +13496,12 @@ var gatewayCostMetadataKeys = [
   "outputInferenceCost",
   "surchargeCost"
 ];
+var RetryableNoImageResultError = class extends Error {
+  constructor() {
+    super("No image generated.");
+    this.name = "RetryableNoImageResultError";
+  }
+};
 async function generateImage({
   model: modelArg,
   prompt: promptArg,
@@ -13376,7 +13523,8 @@ async function generateImage({
   );
   const { retry } = prepareRetries({
     maxRetries: maxRetriesArg,
-    abortSignal
+    abortSignal,
+    additionalRetryableError: (error) => error instanceof RetryableNoImageResultError
   });
   const maxImagesPerCallWithDefault = (_a25 = maxImagesPerCall != null ? maxImagesPerCall : await invokeModelMaxImagesPerCall(model)) != null ? _a25 : 1;
   const callCount = Math.ceil(n / maxImagesPerCallWithDefault);
@@ -13387,25 +13535,41 @@ async function generateImage({
     const remainder = n % maxImagesPerCallWithDefault;
     return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
   });
-  const results = await Promise.all(
-    callImageCounts.map(
-      async (callImageCount) => await retry(() => {
-        const { prompt, files, mask } = normalizePrompt(promptArg);
-        return model.doGenerate({
-          prompt,
-          files,
-          mask,
-          n: callImageCount,
-          abortSignal,
-          headers: headersWithUserAgent,
-          size,
-          aspectRatio,
-          seed,
-          providerOptions: providerOptions != null ? providerOptions : {}
+  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 = [];
@@ -14362,33 +14526,6 @@ function getTextFromDataUrl(dataUrl) {
   }
 }
 
-// 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/util/serial-job-executor.ts
 var SerialJobExecutor = class {
   constructor() {
@@ -19639,7 +19776,7 @@ export {
   getRealtimeToolDefinitions as experimental_getRealtimeToolDefinitions,
   experimental_getVideoStatus,
   resampleAudio as experimental_resampleAudio,
-  startTextBatch as experimental_startTextBatch,
+  startBatch as experimental_startBatch,
   experimental_startVideo,
   streamLanguageModelCall as experimental_streamLanguageModelCall,
   streamTranscribe as experimental_streamTranscribe,
@@ -19649,7 +19786,7 @@ export {
   extractJsonMiddleware,
   extractReasoningMiddleware,
   fingerprintTools,
-  gateway2 as gateway,
+  gateway3 as gateway,
   generateId3 as generateId,
   generateImage,
   generateObject,