ai 7.0.93 → 7.0.94

package/src/batch/batch.ts

@@ -1,11 +1,12 @@
 import {
   UnsupportedFunctionalityError,
-  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+  type Experimental_BatchV4 as BatchV4,
   type Experimental_BatchV4ItemResult as BatchV4ItemResult,
-  type LanguageModelV4,
   type LanguageModelV4GenerateResult,
   type LanguageModelV4ToolCall,
+  type ProviderV4,
 } from '@ai-sdk/provider';
+import { gateway } from '@ai-sdk/gateway';
 import { type ToolSet, withUserAgentSuffix } from '@ai-sdk/provider-utils';
 import { InvalidArgumentError } from '../error/invalid-argument-error';
 import { convertLanguageModelContent } from '../generate-text/convert-language-model-content';
@@ -13,7 +14,6 @@ import { parseToolCall } from '../generate-text/parse-tool-call';
 import { prepareToolChoice } from '../prompt/prepare-tool-choice';
 import { prepareTools } from '../prompt/prepare-tools';
 import { logWarnings } from '../logger/log-warnings';
-import { resolveLanguageModel } from '../model/resolve-model';
 import { convertToLanguageModelPrompt } from '../prompt/convert-to-language-model-prompt';
 import { prepareLanguageModelCallOptions } from '../prompt/prepare-language-model-call-options';
 import { getTotalTimeoutMs } from '../prompt/request-options';
@@ -22,70 +22,85 @@ import { wrapGatewayError } from '../prompt/wrap-gateway-error';
 import { asLanguageModelUsage } from '../types/usage';
 import { asAsyncIterableStream } from '../util/async-iterable-stream';
 import { mergeAbortSignals } from '../util/merge-abort-signals';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import { prepareRetries } from '../util/prepare-retries';
 import { VERSION } from '../version';
+import { asProviderV4 } from '../model/as-provider-v4';
 import type {
-  BatchOperationOptions,
+  BatchItemResult,
+  BatchProvider,
   BatchReference,
   BatchStatus,
-  StartTextBatchOptions,
-  StartTextBatchResult,
+  GetBatchResultsOptions,
+  GetBatchStatusOptions,
+  StartBatchOptions,
+  StartBatchResult,
   TextBatchGenerationResult,
   TextBatchItemResult,
-  TextBatchRequest,
 } from './batch-types';
 
 /**
- * Starts a durable text-generation batch.
+ * Starts a batch.
  */
-export async function startTextBatch<TOOLS extends ToolSet>({
-  model: modelArg,
+export async function startBatch<
+  TOOLS extends ToolSet,
+  PROVIDER extends BatchProvider,
+>({
+  provider,
   requests,
-  tools,
-  toolChoice,
-  toolOrder,
-  toolsContext,
   providerOptions,
   webhookUrl,
   abortSignal,
   headers,
   timeout,
-}: StartTextBatchOptions<TOOLS>): Promise<StartTextBatchResult> {
+}: StartBatchOptions<TOOLS, PROVIDER>): Promise<StartBatchResult> {
   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?.throwIfAborted();
   const normalizedRequests = [];
+  const toolsByName = new Map<string, unknown>();
 
   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: undefined,
-          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: undefined,
+              provider: batchApi.provider.split('.')[0],
+            }),
+            tools: preparedTools,
+            toolChoice: prepareToolChoice({ toolChoice: request.toolChoice }),
+            providerOptions: request.providerOptions,
+          },
+        });
+        break;
+      }
+    }
     operationAbortSignal?.throwIfAborted();
   }
 
@@ -94,7 +109,7 @@ export async function startTextBatch<TOOLS extends ToolSet>({
     `ai/${VERSION}`,
   );
   try {
-    const result = await model.experimental_doStartBatch({
+    const result = await batchApi.doStartBatch({
       requests: normalizedRequests,
       providerOptions,
       abortSignal: operationAbortSignal,
@@ -103,18 +118,21 @@ export async function startTextBatch<TOOLS extends ToolSet>({
     });
     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 ? undefined : modelByRequestId.get(requestId),
+      });
+    }
 
     return {
-      version: 1,
-      type: 'text',
+      version: 2,
       id: batchId,
-      provider: model.provider,
-      modelId: model.modelId,
+      provider: batchApi.provider,
       ...status,
       warnings,
     };
@@ -123,20 +141,44 @@ export async function startTextBatch<TOOLS extends ToolSet>({
   }
 }
 
+function validateCompatibleTools({
+  requestId,
+  tools,
+  toolsByName,
+}: {
+  requestId: string;
+  tools: ReadonlyArray<{ name: string }> | undefined;
+  toolsByName: Map<string, unknown>;
+}) {
+  for (const tool of tools ?? []) {
+    const previousTool = toolsByName.get(tool.name);
+
+    if (previousTool != null && !isDeepEqualData(previousTool, tool)) {
+      throw new InvalidArgumentError({
+        parameter: 'requests',
+        value: requestId,
+        message: `tool "${tool.name}" must have the same definition in every batch request`,
+      });
+    }
+
+    toolsByName.set(tool.name, tool);
+  }
+}
+
 /**
- * Retrieves the latest normalized status for a durable batch.
+ * Retrieves the latest normalized status for a batch.
  */
 export async function getBatchStatus({
-  model: modelArg,
+  provider,
   batch,
   providerOptions,
   maxRetries,
   abortSignal,
   headers,
   timeout,
-}: Omit<BatchOperationOptions, 'tools'>): Promise<BatchStatus> {
-  const model = resolveBatchLanguageModel(modelArg);
-  validateBatchReference({ model, batch });
+}: GetBatchStatusOptions): Promise<BatchStatus> {
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
 
   const operationAbortSignal = mergeAbortSignals(
     abortSignal,
@@ -149,7 +191,7 @@ export async function getBatchStatus({
 
   try {
     const status = await retry(() =>
-      model.experimental_doGetBatchStatus({
+      batchApi.doGetBatchStatus({
         batchId: batch.id,
         providerOptions,
         abortSignal: operationAbortSignal,
@@ -164,10 +206,10 @@ export async function getBatchStatus({
 }
 
 /**
- * Streams complete terminal results for the requests in a durable batch.
+ * Streams complete terminal results for the requests in a batch.
  */
 export function getBatchResults<TOOLS extends ToolSet>({
-  model: modelArg,
+  provider,
   batch,
   tools,
   providerOptions,
@@ -175,9 +217,9 @@ export function getBatchResults<TOOLS extends ToolSet>({
   abortSignal,
   headers,
   timeout,
-}: BatchOperationOptions<TOOLS>) {
-  const model = resolveBatchLanguageModel(modelArg);
-  validateBatchReference({ model, batch });
+}: GetBatchResultsOptions<TOOLS>) {
+  const batchApi = resolveBatchApi(provider);
+  validateBatchReference({ batchApi, batch });
 
   const streamAbortController = new AbortController();
   const operationAbortSignal = mergeAbortSignals(
@@ -189,10 +231,9 @@ export function getBatchResults<TOOLS extends ToolSet>({
     maxRetries,
     abortSignal: operationAbortSignal,
   });
-  const transformer: Transformer<
-    BatchV4ItemResult<LanguageModelV4GenerateResult>,
-    TextBatchItemResult<TOOLS>
-  > & { cancel?: (reason?: unknown) => void } = {
+  const transformer: Transformer<BatchV4ItemResult, BatchItemResult<TOOLS>> & {
+    cancel?: (reason?: unknown) => void;
+  } = {
     async transform(item, controller) {
       controller.enqueue(await convertBatchItemResult({ item, tools }));
     },
@@ -204,14 +245,14 @@ export function getBatchResults<TOOLS extends ToolSet>({
     },
   };
   const transform = new TransformStream<
-    BatchV4ItemResult<LanguageModelV4GenerateResult>,
-    TextBatchItemResult<TOOLS>
+    BatchV4ItemResult,
+    BatchItemResult<TOOLS>
   >(transformer);
 
   void (async () => {
     try {
       const stream = await retry(() =>
-        model.experimental_doGetBatchResults({
+        batchApi.doGetBatchResults({
           batchId: batch.id,
           providerOptions,
           abortSignal: operationAbortSignal,
@@ -230,33 +271,43 @@ export function getBatchResults<TOOLS extends ToolSet>({
   return asAsyncIterableStream(transform.readable);
 }
 
-function resolveBatchLanguageModel(
-  modelArg: StartTextBatchOptions['model'],
-): BatchLanguageModelV4 {
-  const model = resolveLanguageModel(modelArg);
+function resolveBatchApi(provider?: BatchProvider): BatchV4 {
+  provider ??= asProviderV4(globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway);
+
+  if (isBatchApi(provider)) {
+    return provider;
+  }
 
-  if (!isBatchLanguageModel(model)) {
+  if (!hasBatchFactory(provider)) {
     throw new UnsupportedFunctionalityError({
       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 hasBatchFactory(
+  provider: ProviderV4,
+): provider is ProviderV4 & { experimental_batch(): BatchV4 } {
+  return (
+    typeof (provider as { experimental_batch?: unknown }).experimental_batch ===
+    'function'
+  );
 }
 
-function isBatchLanguageModel(
-  model: LanguageModelV4,
-): model is BatchLanguageModelV4 {
-  const candidate = model as Partial<BatchLanguageModelV4>;
+function isBatchApi(provider: BatchProvider): provider is BatchV4 {
+  const candidate = provider as Partial<BatchV4>;
   return (
-    typeof candidate.experimental_doStartBatch === 'function' &&
-    typeof candidate.experimental_doGetBatchStatus === 'function' &&
-    typeof candidate.experimental_doGetBatchResults === 'function'
+    typeof candidate.doStartBatch === 'function' &&
+    typeof candidate.doGetBatchStatus === 'function' &&
+    typeof candidate.doGetBatchResults === 'function'
   );
 }
 
-function validateRequests(requests: ReadonlyArray<TextBatchRequest>) {
+function validateRequests(requests: ReadonlyArray<{ readonly id: string }>) {
   if (requests.length === 0) {
     throw new InvalidArgumentError({
       parameter: 'requests',
@@ -289,27 +340,27 @@ function validateRequests(requests: ReadonlyArray<TextBatchRequest>) {
 }
 
 function validateBatchReference({
-  model,
+  batchApi,
   batch,
 }: {
-  model: BatchLanguageModelV4;
+  batchApi: BatchV4;
   batch: BatchReference;
 }) {
-  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,
+      parameter: 'provider',
+      value: batchApi,
       message:
-        `model ${model.provider}:${model.modelId} is not compatible with ` +
-        `batch ${batch.provider}:${batch.modelId}`,
+        `provider ${batchApi.provider} is not compatible with ` +
+        `batch provider ${batch.provider}`,
     });
   }
 }
@@ -318,18 +369,35 @@ async function convertBatchItemResult<TOOLS extends ToolSet>({
   item,
   tools,
 }: {
-  item: BatchV4ItemResult<LanguageModelV4GenerateResult>;
+  item: BatchV4ItemResult;
   tools: TOOLS | undefined;
 }): Promise<TextBatchItemResult<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<TOOLS extends ToolSet>({

package/src/batch/index.ts

@@ -1,19 +1,21 @@
 export {
-  startTextBatch as experimental_startTextBatch,
+  startBatch as experimental_startBatch,
   getBatchResults as experimental_getBatchResults,
   getBatchStatus as experimental_getBatchStatus,
 } from './batch';
 export type {
   BatchError as Experimental_BatchError,
-  BatchLanguageModel as Experimental_BatchLanguageModel,
-  BatchOperationOptions as Experimental_BatchOperationOptions,
+  BatchProvider as Experimental_BatchProvider,
   BatchReference as Experimental_BatchReference,
   BatchStatus as Experimental_BatchStatus,
-  StartTextBatchOptions as Experimental_StartTextBatchOptions,
-  StartTextBatchResult as Experimental_StartTextBatchResult,
-  TextBatch as Experimental_TextBatch,
+  GetBatchResultsOptions as Experimental_GetBatchResultsOptions,
+  GetBatchStatusOptions as Experimental_GetBatchStatusOptions,
+  StartBatchOptions as Experimental_StartBatchOptions,
+  StartBatchResult as Experimental_StartBatchResult,
+  Batch as Experimental_Batch,
+  BatchItemResult as Experimental_BatchItemResult,
+  BatchRequest as Experimental_BatchRequest,
   TextBatchGenerationResult as Experimental_TextBatchGenerationResult,
   TextBatchItemResult as Experimental_TextBatchItemResult,
-  TextBatchReference as Experimental_TextBatchReference,
   TextBatchRequest as Experimental_TextBatchRequest,
 } from './batch-types';

package/src/generate-image/generate-image.ts

@@ -4,6 +4,7 @@ import {
   type ImageModelV4CallOptions,
   type ImageModelV4File,
   type ImageModelV4ProviderMetadata,
+  type ImageModelV4Result,
   type JSONObject,
 } from '@ai-sdk/provider';
 import {
@@ -25,6 +26,7 @@ import type { ImageModelResponseMetadata } from '../types/image-model-response-m
 import { addImageModelUsage, type ImageModelUsage } from '../types/usage';
 import type { Warning } from '../types/warning';
 import { prepareRetries } from '../util/prepare-retries';
+import { RetryError } from '../util/retry-error';
 import { VERSION } from '../version';
 import type {
   GenerateImageCall,
@@ -47,6 +49,13 @@ type GatewayCostMetadata = {
   [key in (typeof gatewayCostMetadataKeys)[number]]?: unknown;
 };
 
+class RetryableNoImageResultError extends Error {
+  constructor() {
+    super('No image generated.');
+    this.name = 'RetryableNoImageResultError';
+  }
+}
+
 export type GenerateImagePrompt =
   | string
   | {
@@ -67,7 +76,7 @@ export type GenerateImagePrompt =
  * @param seed - Seed for the image generation.
  * @param providerOptions - Additional provider-specific options that are passed through to the provider
  * as body parameters.
- * @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+ * @param maxRetries - Maximum number of retries per image model call, including retries after unclassified empty responses. Empty responses marked as not retryable by the provider are not retried. Set to 0 to disable retries. Default: 2.
  * @param abortSignal - An optional abort signal that can be used to cancel the call.
  * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
  *
@@ -138,7 +147,9 @@ export async function generateImage({
   providerOptions?: ProviderOptions;
 
   /**
-   * Maximum number of retries per image model call. Set to 0 to disable retries.
+   * Maximum number of retries per image model call, including retries after
+   * unclassified empty responses. Empty responses marked as not retryable by
+   * the provider are not retried. Set to 0 to disable retries.
    *
    * @default 2
    */
@@ -165,6 +176,8 @@ export async function generateImage({
   const { retry } = prepareRetries({
     maxRetries: maxRetriesArg,
     abortSignal,
+    additionalRetryableError: error =>
+      error instanceof RetryableNoImageResultError,
   });
 
   // default to 1 if the model has not specified limits on
@@ -183,13 +196,15 @@ export async function generateImage({
     return remainder === 0 ? maxImagesPerCallWithDefault : remainder;
   });
 
-  const results = await Promise.all(
-    callImageCounts.map(
-      async callImageCount =>
-        await retry(() => {
+  const resultGroups = await Promise.all(
+    callImageCounts.map(async callImageCount => {
+      const callResults: Array<ImageModelV4Result> = [];
+
+      try {
+        await retry(async () => {
           const { prompt, files, mask } = normalizePrompt(promptArg);
 
-          return model.doGenerate({
+          const result = await model.doGenerate({
             prompt,
             files,
             mask,
@@ -201,9 +216,35 @@ export async function generateImage({
             seed,
             providerOptions: 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
+              : undefined;
+
+        if (noImageResultError != null) {
+          return callResults;
+        }
+
+        throw error;
+      }
+    }),
   );
+  const results = resultGroups.flat();
 
   // collect result images, warnings, and response metadata
   const images: Array<GeneratedFile> = [];