ai 7.0.78 → 7.0.82

package/docs/07-reference/04-ai-sdk-workflow/03-generate-video.mdx

@@ -0,0 +1,157 @@
+---
+title: generateVideo
+description: API Reference for durable video generation in workflows.
+---
+
+# `generateVideo()`
+
+Generates videos durably inside a workflow. The helper starts an asynchronous
+video generation job with a Workflow webhook URL, suspends the workflow until
+the provider sends a terminal notification, and then retrieves the completed
+result with one status request.
+
+Unlike [`experimental_generateVideo`](/docs/reference/ai-sdk-core/generate-video)
+from `ai`, this helper does not download provider-hosted videos. URL results
+remain URLs so your workflow can decide whether to persist, copy, or process
+them in another step without serializing the video bytes through workflow step
+boundaries.
+
+```ts
+import { experimental_generateVideo as generateVideo } from '@ai-sdk/workflow/video';
+
+export async function videoWorkflow(prompt: string) {
+  'use workflow';
+
+  // The workflow suspends while the video renders, consuming no compute.
+  const result = await generateVideo({
+    model: 'klingai/kling-v3.0-t2v',
+    prompt,
+  });
+
+  return result.videos;
+}
+```
+
+The selected model must support asynchronous start and status operations and
+provider webhooks. The helper must be called from a Workflow SDK workflow.
+
+## Import
+
+<Snippet
+  text={`import { experimental_generateVideo as generateVideo } from "@ai-sdk/workflow/video"`}
+  prompt={false}
+/>
+
+## Parameters
+
+The helper accepts the same parameters as `experimental_startVideo` from `ai`,
+except `webhookUrl` and `abortSignal`. It creates and manages the webhook URL.
+
+<PropertiesTable
+  content={[
+    {
+      name: 'model',
+      type: 'VideoModel',
+      isRequired: true,
+      description:
+        'The asynchronous video model to use. A string compatible with Vercel AI Gateway or a serializable provider model.',
+    },
+    {
+      name: 'prompt',
+      type: 'string | GenerateVideoPrompt',
+      isRequired: true,
+      description: 'The prompt or image prompt used to generate the video.',
+    },
+    {
+      name: 'n',
+      type: 'number',
+      isOptional: true,
+      description: 'Number of videos to generate. Default: 1.',
+    },
+    {
+      name: 'aspectRatio',
+      type: '`${number}:${number}` | "adaptive"',
+      isOptional: true,
+      description: 'Aspect ratio of the generated videos.',
+    },
+    {
+      name: 'resolution',
+      type: '`${number}x${number}`',
+      isOptional: true,
+      description: 'Resolution of the generated videos.',
+    },
+    {
+      name: 'duration',
+      type: 'number',
+      isOptional: true,
+      description: 'Duration of each generated video in seconds.',
+    },
+    {
+      name: 'maxVideosPerCall',
+      type: 'number',
+      isOptional: true,
+      description: 'Maximum number of videos that may be started in one call.',
+    },
+    {
+      name: 'fps',
+      type: 'number',
+      isOptional: true,
+      description: 'Frames per second for the generated videos.',
+    },
+    {
+      name: 'seed',
+      type: 'number',
+      isOptional: true,
+      description: 'Seed used for deterministic generation when supported.',
+    },
+    {
+      name: 'frameImages',
+      type: 'Array<{ image: DataContent; frameType: VideoModelV4FrameType }>',
+      isOptional: true,
+      description: 'Role-tagged first and last frame images.',
+    },
+    {
+      name: 'inputReferences',
+      type: 'Array<DataContent | { data: DataContent; mediaType?: string }>',
+      isOptional: true,
+      description: 'Reference images or videos for the generation.',
+    },
+    {
+      name: 'generateAudio',
+      type: 'boolean',
+      isOptional: true,
+      description: 'Whether to generate audio with the video.',
+    },
+    {
+      name: 'providerOptions',
+      type: 'ProviderOptions',
+      isOptional: true,
+      description: 'Additional provider-specific options.',
+    },
+    {
+      name: 'headers',
+      type: 'Record<string, string>',
+      isOptional: true,
+      description: 'Additional HTTP headers for start and status requests.',
+    },
+    {
+      name: 'maxRetries',
+      type: 'number',
+      isOptional: true,
+      description:
+        'Maximum number of AI SDK retries for each start and status request. Default: 2.',
+    },
+  ]}
+/>
+
+## Returns
+
+Returns the completed status result from the provider. `videos` contains raw
+provider video data discriminated by `type`:
+
+- `url`: A provider-hosted URL and media type
+- `base64`: Base64-encoded video data and media type
+- `binary`: A `Uint8Array` and media type
+
+Hosted URLs can expire. Handle any video you need to retain in a separate
+workflow step.

package/docs/07-reference/04-ai-sdk-workflow/index.mdx

@@ -22,5 +22,11 @@ collapsed: true
         'Chat transport with automatic stream reconnection for workflow-based apps.',
       href: '/docs/reference/ai-sdk-workflow/workflow-chat-transport',
     },
+    {
+      title: 'generateVideo',
+      description:
+        'Generate videos durably with provider webhooks and no implicit downloads.',
+      href: '/docs/reference/ai-sdk-workflow/generate-video',
+    },
   ]}
 />

package/docs/07-reference/05-ai-sdk-errors/ai-stream-provider-error.mdx

@@ -0,0 +1,52 @@
+---
+title: AI_StreamProviderError
+description: Learn how to handle AI_StreamProviderError
+---
+
+# AI_StreamProviderError
+
+This error represents a well-formed error event reported by a provider after a
+model response stream has started. The AI SDK exposes it in streaming error
+parts and callbacks such as the `streamText` `onError` callback.
+
+## Properties
+
+- `message`: The provider error message
+- `type`: The provider-defined error type (optional)
+- `code`: The provider-defined error code as a string or number (optional)
+- `statusCode`: The HTTP-equivalent status code when supplied by or inferable from provider metadata (optional)
+- `isRetryable`: Whether retrying the model call may succeed
+- `data`: The original provider error payload (optional)
+- `cause`: The underlying error that caused the failure (optional)
+
+`isRetryable` is a retry classification, not an automatic retry. A stream may
+already contain partial output, so applications should decide whether to
+discard, replace, or preserve that output before starting another model call.
+
+## Checking for this Error
+
+Use `StreamProviderError.isInstance` so identification also works when multiple
+AI SDK versions are present:
+
+```typescript
+import { StreamProviderError, streamText } from 'ai';
+
+const result = streamText({
+  model: __MODEL__,
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+  onError: ({ error }) => {
+    if (StreamProviderError.isInstance(error) && error.isRetryable) {
+      // Schedule an application-managed retry.
+    }
+  },
+});
+```
+
+Providers may not include enough metadata to determine a status code. In that
+case, `statusCode` is `undefined`, and retryability is classified
+conservatively. Provider-specific status and retry mappings are supplied by the
+provider adapter rather than inferred from arbitrary provider error type or code
+substrings. Provider `type` and `code` values are preserved independently, even
+when a numeric code is also used to determine `statusCode`. Errors that are
+already `Error` instances and malformed or unknown provider values are
+preserved unchanged.

package/docs/07-reference/05-ai-sdk-errors/index.mdx

@@ -33,6 +33,7 @@ collapsed: true
 - [AI_NoSuchProviderReferenceError](/docs/reference/ai-sdk-errors/ai-no-such-provider-reference-error)
 - [AI_NoSuchToolError](/docs/reference/ai-sdk-errors/ai-no-such-tool-error)
 - [AI_RetryError](/docs/reference/ai-sdk-errors/ai-retry-error)
+- [AI_StreamProviderError](/docs/reference/ai-sdk-errors/ai-stream-provider-error)
 - [AI_ToolCallNotFoundForApprovalError](/docs/reference/ai-sdk-errors/ai-tool-call-not-found-for-approval-error)
 - [AI_ToolCallRepairError](/docs/reference/ai-sdk-errors/ai-tool-call-repair-error)
 - [AI_TooManyEmbeddingValuesForCallError](/docs/reference/ai-sdk-errors/ai-too-many-embedding-values-for-call-error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.78",
+  "version": "7.0.82",
   "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,21 +42,32 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.63",
-    "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.29"
+    "@ai-sdk/gateway": "4.0.67",
+    "@ai-sdk/provider": "4.0.8",
+    "@ai-sdk/provider-utils": "5.0.32"
   },
   "devDependencies": {
+    "@ai-sdk/amazon-bedrock": "5.0.65",
+    "@ai-sdk/deepseek": "3.0.34",
+    "@ai-sdk/google": "4.0.53",
+    "@ai-sdk/groq": "4.0.33",
+    "@ai-sdk/huggingface": "2.0.39",
+    "@ai-sdk/moonshotai": "3.0.41",
+    "@ai-sdk/open-responses": "2.0.34",
+    "@ai-sdk/openai": "4.0.49",
+    "@ai-sdk/test-server": "2.0.1",
+    "@ai-sdk/xai": "4.0.47",
     "@edge-runtime/vm": "^5.0.0",
+    "@smithy/eventstream-codec": "^4.3.3",
+    "@smithy/util-utf8": "^4.3.3",
     "@types/json-schema": "7.0.15",
     "@types/node": "22.19.19",
+    "@vercel/ai-tsconfig": "0.0.0",
     "esbuild": "^0.28.1",
     "tsup": "^7.2.0",
     "tsx": "4.23.12",
     "typescript": "5.8.3",
-    "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.1",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "zod": "3.25.76"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/batch/batch-types.ts

@@ -77,6 +77,13 @@ export type StartTextBatchOptions = {
   model: BatchLanguageModel;
   requests: ReadonlyArray<TextBatchRequest>;
   providerOptions?: ProviderOptions;
+
+  /**
+   * URL that the provider should notify when the batch reaches a terminal
+   * state. Providers that do not support completion webhooks return an
+   * unsupported warning.
+   */
+  webhookUrl?: string;
 } & BatchRequestOptions;
 
 /**

package/src/batch/batch.ts

@@ -37,6 +37,7 @@ export async function startTextBatch({
   model: modelArg,
   requests,
   providerOptions,
+  webhookUrl,
   abortSignal,
   headers,
   timeout,
@@ -81,6 +82,7 @@ export async function startTextBatch({
       providerOptions,
       abortSignal: operationAbortSignal,
       headers: headersWithUserAgent,
+      ...(webhookUrl != null && { webhookUrl }),
     });
     const { batchId, warnings, ...status } = result;
 

package/src/embed/embed-many.ts

@@ -4,6 +4,7 @@ import {
   type ProviderOptions,
 } from '@ai-sdk/provider-utils';
 import { logWarnings } from '../logger/log-warnings';
+import { getEmbeddingModelMaxInputBytesPerCall } from '../model/get-embedding-model-max-input-bytes-per-call';
 import { resolveEmbeddingModel } from '../model/resolve-model';
 import { createTelemetryDispatcher } from '../telemetry/create-telemetry-dispatcher';
 import type { TelemetryOptions } from '../telemetry/telemetry-options';
@@ -26,8 +27,9 @@ const originalGenerateCallId = createIdGenerator({
  * Embed several values using an embedding model. The type of the value is defined
  * by the embedding model.
  *
- * `embedMany` automatically splits large requests into smaller chunks if the model
- * has a limit on how many embeddings can be generated in a single call.
+ * `embedMany` automatically splits large requests into smaller chunks when the
+ * model has a limit on either the number of embeddings or the UTF-8 input bytes
+ * that can be processed in a single call.
  *
  * @param model - The embedding model to use.
  * @param values - The values that should be embedded.
@@ -197,11 +199,22 @@ export async function embedMany({
       });
 
       try {
-        const [maxEmbeddingsPerCall, supportsParallelCalls] = await Promise.all(
-          [model.maxEmbeddingsPerCall, model.supportsParallelCalls],
-        );
-
-        if (maxEmbeddingsPerCall == null || maxEmbeddingsPerCall === Infinity) {
+        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, usage, warnings, response, providerMetadata } =
             await retry(async () => {
               const embedCallId = generateCallId();
@@ -283,7 +296,15 @@ export async function embedMany({
           });
         }
 
-        const valueChunks = splitArray(values, maxEmbeddingsPerCall);
+        const valueChunks = splitByEmbeddingLimits({
+          values,
+          maxEmbeddingsPerCall: hasEmbeddingLimit
+            ? maxEmbeddingsPerCall
+            : Infinity,
+          maxInputBytesPerCall: hasInputByteLimit
+            ? maxInputBytesPerCall
+            : Infinity,
+        });
 
         const embeddings: Array<Embedding> = [];
         const warnings: Array<Warning> = [];
@@ -415,6 +436,55 @@ export async function embedMany({
   });
 }
 
+const textEncoder = new TextEncoder();
+
+function splitByEmbeddingLimits({
+  values,
+  maxEmbeddingsPerCall,
+  maxInputBytesPerCall,
+}: {
+  values: Array<string>;
+  maxEmbeddingsPerCall: number;
+  maxInputBytesPerCall: number;
+}): Array<Array<string>> {
+  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: Array<Array<string>> = [];
+  let currentChunk: Array<string> = [];
+  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;
+}
+
 class DefaultEmbedManyResult implements EmbedManyResult {
   readonly values: EmbedManyResult['values'];
   readonly embeddings: EmbedManyResult['embeddings'];

package/src/error/index.ts

@@ -30,6 +30,7 @@ export { NoTranscriptGeneratedError } from './no-transcript-generated-error';
 export { NoTranslationGeneratedError } from './no-translation-generated-error';
 export { NoVideoGeneratedError } from './no-video-generated-error';
 export { NoSuchToolError } from './no-such-tool-error';
+export { StreamProviderError } from './stream-provider-error';
 export { ToolCallRepairError } from './tool-call-repair-error';
 export { UnsupportedModelVersionError } from './unsupported-model-version-error';
 export { UIMessageStreamError } from './ui-message-stream-error';

package/src/error/stream-provider-error.ts

@@ -0,0 +1,78 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_StreamProviderError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+/**
+ * Error reported by a provider after a model response stream has started.
+ */
+export class StreamProviderError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  /**
+   * Provider-defined error type, when supplied by the provider.
+   */
+  readonly type?: string;
+
+  /**
+   * Provider-defined error code, when supplied by the provider.
+   */
+  readonly code?: string | number;
+
+  /**
+   * HTTP-equivalent status code, when supplied by or inferable from the
+   * provider error metadata.
+   */
+  readonly statusCode?: number;
+
+  /**
+   * Whether retrying the model call may succeed.
+   */
+  readonly isRetryable: boolean;
+
+  /**
+   * Original provider error payload.
+   */
+  readonly data?: unknown;
+
+  constructor({
+    message,
+    type,
+    code,
+    statusCode,
+    isRetryable = isRetryableStatusCode(statusCode),
+    data,
+    cause,
+  }: {
+    message: string;
+    type?: string;
+    code?: string | number;
+    statusCode?: number;
+    isRetryable?: boolean;
+    data?: unknown;
+    cause?: unknown;
+  }) {
+    super({ name, message, cause });
+
+    this.type = type;
+    this.code = code;
+    this.statusCode = statusCode;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+
+  static isInstance(error: unknown): error is StreamProviderError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}
+
+function isRetryableStatusCode(statusCode: number | undefined): boolean {
+  return (
+    statusCode != null &&
+    (statusCode === 408 ||
+      statusCode === 409 ||
+      statusCode === 429 ||
+      statusCode >= 500)
+  );
+}

package/src/generate-text/execute-tools-from-stream.ts

@@ -141,6 +141,9 @@ export function executeToolsFromStream<
                   type: 'tool-approval-request',
                   approvalId,
                   toolCall: chunk,
+                  ...(toolApprovalStatus.reason != null
+                    ? { reason: toolApprovalStatus.reason }
+                    : {}),
                   ...(signature != null ? { signature } : {}),
                 });
 

package/src/generate-text/generate-text-result.ts

@@ -175,7 +175,8 @@ export interface GenerateTextResult<
    * The generated output according to the `output` specification.
    *
    * @throws {NoOutputGeneratedError} When no output is available, for example
-   * when the final step does not finish with a `stop` reason.
+   * when the final step finishes with a `tool-calls` reason, or when it
+   * contains no text and does not finish with a `stop` reason.
    */
   readonly output: InferCompleteOutput<OUTPUT>;
 }

package/src/generate-text/generate-text.ts

@@ -1201,6 +1201,9 @@ export async function generateText<
                       type: 'tool-approval-request',
                       approvalId,
                       toolCall,
+                      ...(toolApprovalStatus.reason != null
+                        ? { reason: toolApprovalStatus.reason }
+                        : {}),
                       ...(signature != null ? { signature } : {}),
                     };
                     blockedToolCallIds.add(toolCall.toolCallId);
@@ -1538,9 +1541,13 @@ export async function generateText<
         callbacks: [onEnd, telemetryDispatcher.onEnd],
       });
 
-      // parse output only if the last step was finished with "stop":
+      // parse output for stop responses and non-empty responses that are not
+      // tool calls:
       let resolvedOutput;
-      if (lastStep.finishReason === 'stop') {
+      if (
+        lastStep.finishReason === 'stop' ||
+        (lastStep.finishReason !== 'tool-calls' && lastStep.text.length > 0)
+      ) {
         const outputSpecification = output ?? text();
         resolvedOutput = await outputSpecification.parseCompleteOutput(
           { text: lastStep.text },

package/src/generate-text/stream-language-model-call.ts

@@ -20,6 +20,7 @@ import { getOwn } from '../util/get-own';
 import type { Instructions, Prompt } from '../prompt';
 import { convertToLanguageModelPrompt } from '../prompt/convert-to-language-model-prompt';
 import type { LanguageModelCallOptions } from '../prompt/language-model-call-options';
+import { normalizeStreamProviderError } from '../prompt/normalize-stream-provider-error';
 import { prepareToolChoice } from '../prompt/prepare-tool-choice';
 import { prepareTools } from '../prompt/prepare-tools';
 import { standardizePrompt } from '../prompt/standardize-prompt';
@@ -447,6 +448,13 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
       }
 
       switch (chunk.type) {
+        case 'error':
+          controller.enqueue({
+            type: 'error',
+            error: normalizeStreamProviderError(chunk.error),
+          });
+          break;
+
         case 'text-start':
           upsertTextContentPart({
             content: modelCallContent,

package/src/generate-text/to-response-messages.ts

@@ -133,6 +133,7 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
           type: 'tool-approval-request',
           approvalId: part.approvalId,
           toolCallId: part.toolCall.toolCallId,
+          ...(part.reason != null ? { reason: part.reason } : {}),
           isAutomatic: part.isAutomatic,
           ...(part.signature != null ? { signature: part.signature } : {}),
         });

package/src/generate-text/tool-approval-configuration.ts

@@ -19,6 +19,8 @@ import type { TypedToolCall } from './tool-call';
  * - 'user-approval': The tool requires user approval.
  *
  * In addition to the string statuses, you can also use object statuses with a reason property.
+ * For approved and denied statuses, the reason is emitted on the approval response.
+ * For user-approval statuses, the reason is emitted on the approval request so it can be shown to the approver.
  *
  * `undefined` is treated as the `not-applicable` status.
  */
@@ -31,7 +33,7 @@ export type ToolApprovalStatus =
   | { type: 'not-applicable'; reason?: never }
   | { type: 'approved'; reason?: string }
   | { type: 'denied'; reason?: string }
-  | { type: 'user-approval'; reason?: never };
+  | { type: 'user-approval'; reason?: string };
 
 /**
  * Function that is called to determine if the tool needs approval before it can be executed.
@@ -107,6 +109,8 @@ export type GenericToolApprovalFunction<
  * - 'user-approval': The tool requires user approval.
  *
  * In addition to the string statuses, you can also use object statuses with a reason property.
+ * For approved and denied statuses, the reason is emitted on the approval response.
+ * For user-approval statuses, the reason is emitted on the approval request so it can be shown to the approver.
  */
 export type ToolApprovalConfiguration<
   TOOLS extends ToolSet,

package/src/generate-text/tool-approval-request-output.ts

@@ -19,6 +19,11 @@ export type ToolApprovalRequestOutput<TOOLS extends ToolSet> = {
    */
   toolCall: TypedToolCall<TOOLS>;
 
+  /**
+   * Reason why the tool call requires approval.
+   */
+  reason?: string;
+
   /**
    * Flag indicating whether the tool was automatically approved or denied.
    *

package/src/index.ts

@@ -2,7 +2,13 @@
 import './global';
 
 // re-exports:
-export { createGateway, gateway, type GatewayModelId } from '@ai-sdk/gateway';
+export {
+  createGateway,
+  gateway,
+  type GatewayAsyncJobMetadata,
+  type GatewayModelId,
+  type GatewayProviderMetadata,
+} from '@ai-sdk/gateway';
 export {
   asSchema,
   createIdGenerator,