ai 7.0.54 → 7.0.55

package/dist/internal/index.js

@@ -92,7 +92,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.54" : "0.0.0-test";
+var VERSION = true ? "7.0.55" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.54",
+  "version": "7.0.55",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.42",
-    "@ai-sdk/provider": "4.0.5",
-    "@ai-sdk/provider-utils": "5.0.22"
+    "@ai-sdk/gateway": "4.0.43",
+    "@ai-sdk/provider": "4.0.6",
+    "@ai-sdk/provider-utils": "5.0.23"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/batch/batch-types.ts

@@ -0,0 +1,134 @@
+import type {
+  Experimental_BatchV4Error as BatchV4Error,
+  Experimental_BatchV4StartResult as BatchV4StartResult,
+  Experimental_BatchV4Status as BatchV4Status,
+  Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+} from '@ai-sdk/provider';
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
+import type { LanguageModelCallOptions } from '../prompt/language-model-call-options';
+import type { Prompt } from '../prompt/prompt';
+import type {
+  FinishReason,
+  GlobalProviderModelId,
+} from '../types/language-model';
+import type { ProviderMetadata } from '../types/provider-metadata';
+import type { LanguageModelUsage } from '../types/usage';
+
+/**
+ * Language model input that can be used for durable batch processing.
+ *
+ * String model IDs are resolved through the global provider and checked for
+ * batch support at runtime.
+ */
+export type BatchLanguageModel = GlobalProviderModelId | BatchLanguageModelV4;
+
+/**
+ * The persisted reference for a text batch.
+ */
+export type TextBatchReference = {
+  readonly version: 1;
+  readonly type: 'text';
+  readonly id: string;
+  readonly provider: string;
+  readonly modelId: string;
+};
+
+/**
+ * Persisted reference for any supported batch type.
+ *
+ * Additional modality-specific references can be added to this union.
+ */
+export type BatchReference = TextBatchReference;
+
+/**
+ * Serializable error information for a batch or batch item.
+ */
+export type BatchError = BatchV4Error;
+
+/**
+ * The latest normalized lifecycle status for a batch.
+ */
+export type BatchStatus = BatchV4Status;
+
+/**
+ * A text batch and its latest normalized lifecycle status.
+ */
+export type TextBatch = TextBatchReference & BatchStatus;
+
+/**
+ * One text generation request within a batch.
+ */
+export type TextBatchRequest = Prompt &
+  LanguageModelCallOptions & {
+    id: string;
+    providerOptions?: ProviderOptions;
+  };
+
+type BatchRequestOptions = {
+  abortSignal?: AbortSignal;
+  headers?: Record<string, string | undefined>;
+  timeout?: number | { totalMs?: number };
+};
+
+/**
+ * Options for starting a text batch.
+ */
+export type StartTextBatchOptions = {
+  model: BatchLanguageModel;
+  requests: ReadonlyArray<TextBatchRequest>;
+  providerOptions?: ProviderOptions;
+} & BatchRequestOptions;
+
+/**
+ * The acknowledged text batch and warnings produced while starting it.
+ */
+export type StartTextBatchResult = TextBatch & {
+  readonly warnings: BatchV4StartResult['warnings'];
+};
+
+/**
+ * Options shared by batch status and result retrieval operations.
+ */
+export type BatchOperationOptions = {
+  model: BatchLanguageModel;
+  batch: BatchReference;
+  providerOptions?: ProviderOptions;
+  maxRetries?: number;
+} & BatchRequestOptions;
+
+/**
+ * A normalized result for a successful text batch item.
+ */
+export type TextBatchGenerationResult = {
+  readonly text: string;
+  readonly finishReason: FinishReason;
+  readonly rawFinishReason?: string;
+  readonly usage: LanguageModelUsage;
+  readonly response?: {
+    readonly id?: string;
+    readonly timestamp?: string;
+    readonly modelId?: string;
+  };
+  readonly providerMetadata?: ProviderMetadata;
+};
+
+/**
+ * A complete terminal result for one request in a text batch.
+ */
+export type TextBatchItemResult =
+  | (TextBatchGenerationResult & {
+      readonly id: string;
+      readonly status: 'succeeded';
+    })
+  | {
+      readonly id: string;
+      readonly status: 'failed';
+      readonly error: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    }
+  | {
+      readonly id: string;
+      readonly status: 'cancelled' | 'expired';
+      readonly error?: BatchError;
+      readonly providerMetadata?: ProviderMetadata;
+    };

package/src/batch/batch.ts

@@ -0,0 +1,336 @@
+import {
+  UnsupportedFunctionalityError,
+  type Experimental_BatchLanguageModelV4 as BatchLanguageModelV4,
+  type Experimental_BatchV4ItemResult as BatchV4ItemResult,
+  type LanguageModelV4,
+  type LanguageModelV4GenerateResult,
+} from '@ai-sdk/provider';
+import { withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+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';
+import { standardizePrompt } from '../prompt/standardize-prompt';
+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 { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+import type {
+  BatchOperationOptions,
+  BatchReference,
+  BatchStatus,
+  StartTextBatchOptions,
+  StartTextBatchResult,
+  TextBatchGenerationResult,
+  TextBatchItemResult,
+  TextBatchRequest,
+} from './batch-types';
+
+/**
+ * Starts a durable text-generation batch.
+ */
+export async function startTextBatch({
+  model: modelArg,
+  requests,
+  providerOptions,
+  abortSignal,
+  headers,
+  timeout,
+}: StartTextBatchOptions): Promise<StartTextBatchResult> {
+  validateRequests(requests);
+
+  const model = resolveBatchLanguageModel(modelArg);
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+  );
+  const supportedUrls = await model.supportedUrls;
+  operationAbortSignal?.throwIfAborted();
+  const normalizedRequests = [];
+
+  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],
+        }),
+        providerOptions: request.providerOptions,
+      },
+    });
+    operationAbortSignal?.throwIfAborted();
+  }
+
+  const headersWithUserAgent = withUserAgentSuffix(
+    headers ?? {},
+    `ai/${VERSION}`,
+  );
+  try {
+    const result = await model.experimental_doStartBatch({
+      requests: normalizedRequests,
+      providerOptions,
+      abortSignal: operationAbortSignal,
+      headers: headersWithUserAgent,
+    });
+    const { batchId, warnings, ...status } = result;
+
+    logWarnings({
+      warnings: warnings.map(({ warning }) => warning),
+      provider: model.provider,
+      model: model.modelId,
+    });
+
+    return {
+      version: 1,
+      type: 'text',
+      id: batchId,
+      provider: model.provider,
+      modelId: model.modelId,
+      ...status,
+      warnings,
+    };
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
+}
+
+/**
+ * Retrieves the latest normalized status for a durable batch.
+ */
+export async function getBatchStatus({
+  model: modelArg,
+  batch,
+  providerOptions,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout,
+}: BatchOperationOptions): Promise<BatchStatus> {
+  const model = resolveBatchLanguageModel(modelArg);
+  validateBatchReference({ model, batch });
+
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+  );
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal,
+  });
+
+  try {
+    const status = await retry(() =>
+      model.experimental_doGetBatchStatus({
+        batchId: batch.id,
+        providerOptions,
+        abortSignal: operationAbortSignal,
+        headers: withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+      }),
+    );
+
+    return status;
+  } catch (error) {
+    throw wrapGatewayError(error);
+  }
+}
+
+/**
+ * Streams complete terminal results for the requests in a durable batch.
+ */
+export function getBatchResults({
+  model: modelArg,
+  batch,
+  providerOptions,
+  maxRetries,
+  abortSignal,
+  headers,
+  timeout,
+}: BatchOperationOptions) {
+  const model = resolveBatchLanguageModel(modelArg);
+  validateBatchReference({ model, batch });
+
+  const streamAbortController = new AbortController();
+  const operationAbortSignal = mergeAbortSignals(
+    abortSignal,
+    getTotalTimeoutMs(timeout),
+    streamAbortController.signal,
+  );
+  const { retry } = prepareRetries({
+    maxRetries,
+    abortSignal: operationAbortSignal,
+  });
+  const transformer: Transformer<
+    BatchV4ItemResult<LanguageModelV4GenerateResult>,
+    TextBatchItemResult
+  > & { cancel?: (reason?: unknown) => void } = {
+    transform(item, controller) {
+      controller.enqueue(convertBatchItemResult(item));
+    },
+
+    cancel(reason) {
+      streamAbortController.abort(
+        reason ?? new Error('Batch results stream was cancelled.'),
+      );
+    },
+  };
+  const transform = new TransformStream<
+    BatchV4ItemResult<LanguageModelV4GenerateResult>,
+    TextBatchItemResult
+  >(transformer);
+
+  void (async () => {
+    try {
+      const stream = await retry(() =>
+        model.experimental_doGetBatchResults({
+          batchId: batch.id,
+          providerOptions,
+          abortSignal: operationAbortSignal,
+          headers: withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+        }),
+      );
+
+      await stream.pipeTo(transform.writable, {
+        signal: operationAbortSignal,
+      });
+    } catch (error) {
+      await transform.writable.abort(wrapGatewayError(error)).catch(() => {});
+    }
+  })();
+
+  return asAsyncIterableStream(transform.readable);
+}
+
+function resolveBatchLanguageModel(
+  modelArg: StartTextBatchOptions['model'],
+): BatchLanguageModelV4 {
+  const model = resolveLanguageModel(modelArg);
+
+  if (!isBatchLanguageModel(model)) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'batch processing',
+      message: `The ${model.provider} model "${model.modelId}" does not support batch processing.`,
+    });
+  }
+
+  return model;
+}
+
+function isBatchLanguageModel(
+  model: LanguageModelV4,
+): model is BatchLanguageModelV4 {
+  const candidate = model as Partial<BatchLanguageModelV4>;
+  return (
+    typeof candidate.experimental_doStartBatch === 'function' &&
+    typeof candidate.experimental_doGetBatchStatus === 'function' &&
+    typeof candidate.experimental_doGetBatchResults === 'function'
+  );
+}
+
+function validateRequests(requests: ReadonlyArray<TextBatchRequest>) {
+  if (requests.length === 0) {
+    throw new InvalidArgumentError({
+      parameter: 'requests',
+      value: requests,
+      message: 'requests must not be empty',
+    });
+  }
+
+  const ids = new Set<string>();
+
+  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);
+  }
+}
+
+function validateBatchReference({
+  model,
+  batch,
+}: {
+  model: BatchLanguageModelV4;
+  batch: BatchReference;
+}) {
+  if (batch.version !== 1 || batch.type !== 'text') {
+    throw new InvalidArgumentError({
+      parameter: 'batch',
+      value: batch,
+      message: 'batch must be a supported text batch reference',
+    });
+  }
+
+  if (batch.provider !== model.provider || batch.modelId !== model.modelId) {
+    throw new InvalidArgumentError({
+      parameter: 'model',
+      value: model,
+      message:
+        `model ${model.provider}:${model.modelId} is not compatible with ` +
+        `batch ${batch.provider}:${batch.modelId}`,
+    });
+  }
+}
+
+function convertBatchItemResult(
+  item: BatchV4ItemResult<LanguageModelV4GenerateResult>,
+): TextBatchItemResult {
+  if (item.status !== 'succeeded') {
+    return item;
+  }
+
+  return {
+    id: item.id,
+    status: 'succeeded',
+    ...convertGenerateResult(item.result),
+  };
+}
+
+function convertGenerateResult(
+  result: LanguageModelV4GenerateResult,
+): TextBatchGenerationResult {
+  return {
+    text: result.content
+      .filter(
+        (part): part is Extract<typeof part, { type: 'text' }> =>
+          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: result.response.timestamp?.toISOString(),
+            modelId: result.response.modelId,
+          },
+        }
+      : {}),
+    providerMetadata: result.providerMetadata,
+  };
+}

package/src/batch/index.ts

@@ -0,0 +1,19 @@
+export {
+  startTextBatch as experimental_startTextBatch,
+  getBatchResults as experimental_getBatchResults,
+  getBatchStatus as experimental_getBatchStatus,
+} from './batch';
+export type {
+  BatchError as Experimental_BatchError,
+  BatchLanguageModel as Experimental_BatchLanguageModel,
+  BatchOperationOptions as Experimental_BatchOperationOptions,
+  BatchReference as Experimental_BatchReference,
+  BatchStatus as Experimental_BatchStatus,
+  StartTextBatchOptions as Experimental_StartTextBatchOptions,
+  StartTextBatchResult as Experimental_StartTextBatchResult,
+  TextBatch as Experimental_TextBatch,
+  TextBatchGenerationResult as Experimental_TextBatchGenerationResult,
+  TextBatchItemResult as Experimental_TextBatchItemResult,
+  TextBatchReference as Experimental_TextBatchReference,
+  TextBatchRequest as Experimental_TextBatchRequest,
+} from './batch-types';

package/src/index.ts

@@ -32,6 +32,7 @@ export {
 
 // directory exports
 export * from './agent';
+export * from './batch';
 export * from './embed';
 export * from './error';
 export * from './generate-image';