ai 7.0.74 → 7.0.76

package/dist/internal/index.js

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

package/docs/03-ai-sdk-core/60-telemetry.mdx

@@ -491,10 +491,9 @@ For `embed` and `embedMany`, the integration records spans with `CLIENT` kind:
   - `gen_ai.provider.name`: the provider
   - `gen_ai.request.model`: the requested model ID
 
-  Attributes set on finish:
-  - `gen_ai.usage.input_tokens`: the number of tokens used
-
-- **`embeddings {modelId}`** (inner span, `embedMany` only): one span per provider batch call, nested under the root span.
+- **`embeddings {modelId}`** (inner span): one span per provider request,
+  nested under the root span. `embed` creates one inner span. `embedMany`
+  creates one inner span per provider batch call.
 
   Initial attributes:
   - `gen_ai.operation.name`: `"embeddings"`
@@ -504,6 +503,9 @@ For `embed` and `embedMany`, the integration records spans with `CLIENT` kind:
   Attributes set on finish:
   - `gen_ai.usage.input_tokens`: the number of tokens used
 
+Usage is recorded only on inner provider-request spans. For `embedMany`, sum
+the usage from the inner spans to get the total usage for the operation.
+
 #### rerank
 
 For `rerank`, the integration records spans with `CLIENT` kind:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.74",
+  "version": "7.0.76",
   "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,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.60",
+    "@ai-sdk/gateway": "4.0.61",
     "@ai-sdk/provider": "4.0.7",
     "@ai-sdk/provider-utils": "5.0.28"
   },

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

@@ -1160,6 +1160,35 @@ class DefaultStreamTextResult<
     let stepMessagesForNextStep: Array<ModelMessage> | undefined;
     let currentStepMessages: Array<ModelMessage> = [];
 
+    // provider-assigned text/reasoning part IDs are only unique within a
+    // single model call (e.g. Anthropic uses the content block index, which
+    // restarts at 0 for every call), so colliding IDs are remapped to keep
+    // them unique across the whole multi-step stream:
+    const createPartIdReserver = () => {
+      const usedIds = new Set<string>();
+
+      return (id: string) => {
+        if (!usedIds.has(id)) {
+          usedIds.add(id);
+          return id;
+        }
+
+        const generatedId = generateId();
+        let uniqueId = generatedId;
+        let suffix = 0;
+
+        while (usedIds.has(uniqueId)) {
+          uniqueId = `${generatedId}-${++suffix}`;
+        }
+
+        usedIds.add(uniqueId);
+        return uniqueId;
+      };
+    };
+
+    const reserveTextPartId = createPartIdReserver();
+    const reserveReasoningPartId = createPartIdReserver();
+
     // Track provider-executed tool calls that support deferred results
     // (e.g., code_execution in programmatic tool calling scenarios).
     // These tools may not return their results in the same turn as their call.
@@ -2189,6 +2218,11 @@ class DefaultStreamTextResult<
             modelId: model.modelId,
           };
 
+          // maps provider-assigned IDs to stream-unique IDs for the text and
+          // reasoning parts that are active in this step
+          const textPartIds = new Map<string, string>();
+          const reasoningPartIds = new Map<string, string>();
+
           self.addStream(
             streamWithToolResults.pipeThrough(
               new TransformStream<
@@ -2228,11 +2262,6 @@ class DefaultStreamTextResult<
                     case 'file':
                     case 'custom':
                     case 'source':
-                    case 'text-start':
-                    case 'text-end':
-                    case 'reasoning-start':
-                    case 'reasoning-end':
-                    case 'reasoning-delta':
                     case 'reasoning-file':
                     case 'tool-input-start':
                     case 'tool-input-end':
@@ -2242,16 +2271,59 @@ class DefaultStreamTextResult<
                       break;
                     }
 
+                    case 'text-start': {
+                      const id = reserveTextPartId(chunk.id);
+                      textPartIds.set(chunk.id, id);
+                      controller.enqueue({ ...chunk, id });
+                      break;
+                    }
+
                     case 'text-delta': {
                       if (
                         chunk.text.length > 0 ||
                         chunk.providerMetadata != null
                       ) {
-                        controller.enqueue(chunk);
+                        controller.enqueue({
+                          ...chunk,
+                          id: textPartIds.get(chunk.id) ?? chunk.id,
+                        });
                       }
                       break;
                     }
 
+                    case 'text-end': {
+                      controller.enqueue({
+                        ...chunk,
+                        id: textPartIds.get(chunk.id) ?? chunk.id,
+                      });
+                      textPartIds.delete(chunk.id);
+                      break;
+                    }
+
+                    case 'reasoning-start': {
+                      const id = reserveReasoningPartId(chunk.id);
+                      reasoningPartIds.set(chunk.id, id);
+                      controller.enqueue({ ...chunk, id });
+                      break;
+                    }
+
+                    case 'reasoning-delta': {
+                      controller.enqueue({
+                        ...chunk,
+                        id: reasoningPartIds.get(chunk.id) ?? chunk.id,
+                      });
+                      break;
+                    }
+
+                    case 'reasoning-end': {
+                      controller.enqueue({
+                        ...chunk,
+                        id: reasoningPartIds.get(chunk.id) ?? chunk.id,
+                      });
+                      reasoningPartIds.delete(chunk.id);
+                      break;
+                    }
+
                     case 'tool-call': {
                       controller.enqueue(chunk);
                       // store tool calls for onEnd callback and toolCalls promise:

package/src/generate-video/generate-video.ts

@@ -292,59 +292,13 @@ export async function experimental_generateVideo({
     abortSignal,
   });
 
-  const { prompt, image } = normalizePrompt(promptArg);
-
-  const normalizedFrameImages:
-    | Array<Experimental_VideoModelV4FrameImage>
-    | undefined = frameImages?.flatMap(frame => {
-    const normalizedImage = normalizeImageData(frame.image);
-    return normalizedImage != null
-      ? [{ image: normalizedImage, frameType: frame.frameType }]
-      : [];
-  });
-
-  const normalizedInputReferences:
-    | Array<Experimental_VideoModelV4File>
-    | undefined = inputReferences?.flatMap(reference => {
-    const normalized = normalizeReferenceData(reference);
-    return normalized != null ? [normalized] : [];
-  });
-
-  const effectiveInputReferences =
-    normalizedFrameImages != null && normalizedFrameImages.length > 0
-      ? undefined
-      : normalizedInputReferences;
-
-  const warnings: Array<Warning> = [];
-
-  if (
-    normalizedFrameImages != null &&
-    normalizedFrameImages.length > 0 &&
-    normalizedInputReferences != null &&
-    normalizedInputReferences.length > 0
-  ) {
-    warnings.push({
-      type: 'other',
-      message:
-        'inputReferences were ignored because frameImages were provided; ' +
-        'frameImages and inputReferences cannot be combined.',
-    });
-  }
-
-  const firstFrameImage = normalizedFrameImages?.find(
-    frame => frame.frameType === 'first_frame',
-  )?.image;
-
-  if (image != null && firstFrameImage != null) {
-    warnings.push({
-      type: 'other',
-      message:
-        'prompt.image was ignored because a first_frame frameImage was provided; ' +
-        'the first_frame frameImage takes precedence as the start image.',
-    });
-  }
-
-  const resolvedImage = firstFrameImage ?? image;
+  const {
+    prompt,
+    resolvedImage,
+    normalizedFrameImages,
+    effectiveInputReferences,
+    warnings,
+  } = normalizeVideoCallInputs({ promptArg, frameImages, inputReferences });
 
   const maxVideosPerCallWithDefault =
     maxVideosPerCall ?? (await invokeModelMaxVideosPerCall(model)) ?? 1;
@@ -737,6 +691,94 @@ function normalizePrompt(promptArg: GenerateVideoPrompt): {
   };
 }
 
+/**
+ * Shared input normalization for `experimental_generateVideo` and
+ * `experimental_startVideo`: prompt/image plus the frameImages /
+ * inputReferences precedence rules and their warnings.
+ */
+export function normalizeVideoCallInputs({
+  promptArg,
+  frameImages,
+  inputReferences,
+}: {
+  promptArg: GenerateVideoPrompt;
+  frameImages?: Array<{
+    image: DataContent;
+    frameType: Experimental_VideoModelV4FrameType;
+  }>;
+  inputReferences?: Array<
+    DataContent | { data: DataContent; mediaType?: string }
+  >;
+}): {
+  prompt: string | undefined;
+  resolvedImage: Experimental_VideoModelV4File | undefined;
+  normalizedFrameImages: Array<Experimental_VideoModelV4FrameImage> | undefined;
+  effectiveInputReferences: Array<Experimental_VideoModelV4File> | undefined;
+  warnings: Array<Warning>;
+} {
+  const { prompt, image } = normalizePrompt(promptArg);
+
+  const normalizedFrameImages:
+    | Array<Experimental_VideoModelV4FrameImage>
+    | undefined = frameImages?.flatMap(frame => {
+    const normalizedImage = normalizeImageData(frame.image);
+    return normalizedImage != null
+      ? [{ image: normalizedImage, frameType: frame.frameType }]
+      : [];
+  });
+
+  const normalizedInputReferences:
+    | Array<Experimental_VideoModelV4File>
+    | undefined = inputReferences?.flatMap(reference => {
+    const normalized = normalizeReferenceData(reference);
+    return normalized != null ? [normalized] : [];
+  });
+
+  const effectiveInputReferences =
+    normalizedFrameImages != null && normalizedFrameImages.length > 0
+      ? undefined
+      : normalizedInputReferences;
+
+  const warnings: Array<Warning> = [];
+
+  if (
+    normalizedFrameImages != null &&
+    normalizedFrameImages.length > 0 &&
+    normalizedInputReferences != null &&
+    normalizedInputReferences.length > 0
+  ) {
+    warnings.push({
+      type: 'other',
+      message:
+        'inputReferences were ignored because frameImages were provided; ' +
+        'frameImages and inputReferences cannot be combined.',
+    });
+  }
+
+  const firstFrameImage = normalizedFrameImages?.find(
+    frame => frame.frameType === 'first_frame',
+  )?.image;
+
+  if (image != null && firstFrameImage != null) {
+    warnings.push({
+      type: 'other',
+      message:
+        'prompt.image was ignored because a first_frame frameImage was provided; ' +
+        'the first_frame frameImage takes precedence as the start image.',
+    });
+  }
+
+  const resolvedImage = firstFrameImage ?? image;
+
+  return {
+    prompt,
+    resolvedImage,
+    normalizedFrameImages,
+    effectiveInputReferences,
+    warnings,
+  };
+}
+
 function detectFileMediaType(
   data: Uint8Array,
   restrictToImages: boolean,

package/src/generate-video/get-video-status.ts

@@ -0,0 +1,66 @@
+import type {
+  Experimental_VideoModelV4OperationStatusResult,
+  JSONValue,
+} from '@ai-sdk/provider';
+import { withUserAgentSuffix } from '@ai-sdk/provider-utils';
+import { resolveVideoModel } from '../model/resolve-model';
+import type { VideoModel } from '../types/video-model';
+import { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+
+/**
+ * The result of an `experimental_getVideoStatus` call: the spec-level status
+ * payload, discriminated by `status` (`pending` | `completed` | `error`).
+ */
+export type GetVideoStatusResult =
+  Experimental_VideoModelV4OperationStatusResult;
+
+/**
+ * Checks the status of an asynchronous video generation started with
+ * `experimental_startVideo`.
+ *
+ * A single check — no polling loop. Poll by calling this on your own
+ * schedule, or skip polling entirely when the start used `webhookUrl` and
+ * your receiver fetches the result after the terminal notification arrives.
+ *
+ * @param model - The video model the operation was started on.
+ * @param operation - The opaque reference returned by `experimental_startVideo`.
+ * @param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+ * @param abortSignal - An optional abort signal that can be used to cancel the call.
+ * @param maxRetries - Maximum number of retries for the status call. Set to 0 to disable retries. Default: 2.
+ */
+export async function experimental_getVideoStatus(
+  modelArg: VideoModel,
+  {
+    operation,
+    headers,
+    abortSignal,
+    maxRetries: maxRetriesArg,
+  }: {
+    operation: JSONValue;
+    headers?: Record<string, string>;
+    abortSignal?: AbortSignal;
+    maxRetries?: number;
+  },
+): Promise<GetVideoStatusResult> {
+  const model = resolveVideoModel(modelArg);
+
+  if (model.doStatus == null) {
+    throw new Error(
+      `Video model ${model.modelId} does not implement doStatus.`,
+    );
+  }
+
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  return retry(() =>
+    model.doStatus!({
+      operation,
+      headers: withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+      abortSignal,
+    }),
+  );
+}

package/src/generate-video/index.ts

@@ -1,3 +1,7 @@
 export type { GenerateVideoPrompt } from './generate-video';
 export { experimental_generateVideo } from './generate-video';
 export type { GenerateVideoResult } from './generate-video-result';
+export { experimental_startVideo } from './start-video';
+export type { StartVideoResult } from './start-video';
+export { experimental_getVideoStatus } from './get-video-status';
+export type { GetVideoStatusResult } from './get-video-status';

package/src/generate-video/start-video.ts

@@ -0,0 +1,214 @@
+import type {
+  Experimental_VideoModelV4CallOptions,
+  Experimental_VideoModelV4FrameType,
+  JSONValue,
+} from '@ai-sdk/provider';
+import {
+  generateId,
+  withUserAgentSuffix,
+  type DataContent,
+  type ProviderOptions,
+} from '@ai-sdk/provider-utils';
+import { resolveVideoModel } from '../model/resolve-model';
+import type {
+  VideoModel,
+  VideoModelProviderMetadata,
+} from '../types/video-model';
+import type { VideoModelResponseMetadata } from '../types/video-model-response-metadata';
+import type { Warning } from '../types/warning';
+import { prepareRetries } from '../util/prepare-retries';
+import { VERSION } from '../version';
+import {
+  normalizeVideoCallInputs,
+  type GenerateVideoPrompt,
+} from './generate-video';
+
+/**
+ * The result of an `experimental_startVideo` call.
+ */
+export interface StartVideoResult {
+  /**
+   * JSON-serializable opaque reference to the started generation.
+   * Persist it and pass it to `experimental_getVideoStatus` to retrieve the
+   * status and result later — from any process.
+   */
+  readonly operation: JSONValue;
+
+  /**
+   * Warnings for the call, e.g. unsupported settings.
+   */
+  readonly warnings: Array<Warning>;
+
+  /**
+   * Provider-specific metadata passed through from the provider.
+   * Carries the provider's own job identifiers (e.g. the AI Gateway's
+   * `providerMetadata.gateway.asyncJob.jobId` and, when `webhookUrl` was
+   * given, its `webhookSigningSecret`).
+   */
+  readonly providerMetadata?: VideoModelProviderMetadata;
+
+  /**
+   * Response metadata from the provider.
+   */
+  readonly response: VideoModelResponseMetadata;
+}
+
+/**
+ * Starts an asynchronous video generation and returns immediately with an
+ * opaque `operation` reference — without waiting for the video to finish.
+ *
+ * This is the fire-and-forget counterpart to `experimental_generateVideo`:
+ * use it to fan out many jobs, to submit from a process that will not stay
+ * alive, or together with `webhookUrl` so the provider notifies your endpoint
+ * at the terminal state. Check the outcome with `experimental_getVideoStatus`,
+ * or let your webhook receiver fetch the result.
+ *
+ * @param model - The video model to use. Must implement `doStart`.
+ * @param prompt - The prompt that should be used to generate the video.
+ * @param n - Number of videos to generate. Default: 1. Must not exceed the
+ * model's `maxVideosPerCall` — fan out with multiple `startVideo` calls.
+ * @param aspectRatio - Aspect ratio of the videos to generate. Must have the format `{width}:{height}`, or `'adaptive'`.
+ * @param resolution - Resolution of the videos to generate. Must have the format `{width}x${height}`.
+ * @param duration - Duration of the video in seconds.
+ * @param fps - Frames per second for the video.
+ * @param seed - Seed for the video generation.
+ * @param frameImages - Role-tagged image inputs for image-to-video and first-last-frame generation.
+ * @param inputReferences - Reference image or video inputs for reference-to-video generation.
+ * @param generateAudio - Whether the model should generate audio alongside the video.
+ * @param providerOptions - Additional provider-specific options that are passed through to the provider
+ * as body parameters.
+ * @param maxRetries - Maximum number of retries for the start call. 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.
+ * @param webhookUrl - A URL the provider should notify when the generation
+ * reaches a terminal state.
+ *
+ * @returns A result object that contains the opaque `operation` reference,
+ * warnings, provider metadata (including the provider's job id), and response
+ * metadata.
+ */
+export async function experimental_startVideo({
+  model: modelArg,
+  prompt: promptArg,
+  n = 1,
+  maxVideosPerCall,
+  aspectRatio,
+  resolution,
+  duration,
+  fps,
+  seed,
+  frameImages,
+  inputReferences,
+  generateAudio,
+  providerOptions,
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers,
+  webhookUrl,
+}: {
+  model: VideoModel;
+  prompt: GenerateVideoPrompt;
+  n?: number;
+  maxVideosPerCall?: number;
+  aspectRatio?: `${number}:${number}` | 'adaptive';
+  resolution?: `${number}x${number}`;
+  duration?: number;
+  fps?: number;
+  seed?: number;
+  frameImages?: Array<{
+    image: DataContent;
+    frameType: Experimental_VideoModelV4FrameType;
+  }>;
+  inputReferences?: Array<
+    DataContent | { data: DataContent; mediaType?: string }
+  >;
+  generateAudio?: boolean;
+  providerOptions?: ProviderOptions;
+  maxRetries?: number;
+  abortSignal?: AbortSignal;
+  headers?: Record<string, string>;
+  webhookUrl?: string;
+}): Promise<StartVideoResult> {
+  const model = resolveVideoModel(modelArg);
+
+  if (model.doStart == null) {
+    throw new Error(
+      `Video model ${model.modelId} does not implement doStart. ` +
+        'Use generateVideo for models without an asynchronous start/status flow.',
+    );
+  }
+
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(
+      `Invalid n: expected a positive integer, received ${JSON.stringify(n)}.`,
+    );
+  }
+
+  // A start yields one operation covering all n videos: refuse to silently
+  // exceed a known per-call limit instead of splitting into several starts.
+  const knownMaxVideosPerCall =
+    maxVideosPerCall ??
+    (typeof model.maxVideosPerCall === 'function'
+      ? await model.maxVideosPerCall({ modelId: model.modelId })
+      : model.maxVideosPerCall);
+  if (knownMaxVideosPerCall != null && n > knownMaxVideosPerCall) {
+    throw new Error(
+      `Video model ${model.modelId} supports at most ${knownMaxVideosPerCall} video(s) per call, ` +
+        `but ${n} were requested. Split the batch across multiple startVideo calls.`,
+    );
+  }
+
+  const {
+    prompt,
+    resolvedImage,
+    normalizedFrameImages,
+    effectiveInputReferences,
+    warnings,
+  } = normalizeVideoCallInputs({ promptArg, frameImages, inputReferences });
+
+  const { retry } = prepareRetries({
+    maxRetries: maxRetriesArg,
+    abortSignal,
+  });
+
+  // `doStart` is billable: mint one idempotency token per logical start,
+  // outside the retry closure; a caller-supplied key wins.
+  const callerIdempotencyKey = Object.entries(headers ?? {}).find(
+    ([key, value]) =>
+      key.toLowerCase() === 'idempotency-key' && value !== undefined,
+  );
+
+  const callOptions: Experimental_VideoModelV4CallOptions & {
+    webhookUrl?: string;
+  } = {
+    prompt,
+    n,
+    aspectRatio,
+    resolution,
+    duration,
+    fps,
+    seed,
+    image: resolvedImage,
+    frameImages: normalizedFrameImages,
+    inputReferences: effectiveInputReferences,
+    generateAudio,
+    providerOptions: providerOptions ?? {},
+    headers: {
+      ...withUserAgentSuffix(headers ?? {}, `ai/${VERSION}`),
+      ...(callerIdempotencyKey
+        ? {}
+        : { 'idempotency-key': `aisdk_vid_${generateId()}` }),
+    },
+    abortSignal,
+    webhookUrl,
+  };
+
+  const startResult = await retry(() => model.doStart!(callOptions));
+
+  return {
+    operation: startResult.operation,
+    warnings: [...warnings, ...startResult.warnings],
+    providerMetadata: startResult.providerMetadata,
+    response: startResult.response,
+  };
+}

package/src/ui/chat.ts

@@ -191,7 +191,7 @@ export interface ChatInit<UI_MESSAGE extends UIMessage> {
    */
   id?: string;
 
-  messageMetadataSchema?: FlexibleSchema<InferUIMessageMetadata<UI_MESSAGE>>;
+  messageMetadataSchema?: FlexibleSchema<UI_MESSAGE['metadata']>;
   dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
 
   messages?: UI_MESSAGE[];
@@ -246,7 +246,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   protected state: ChatState<UI_MESSAGE>;
 
   private messageMetadataSchema:
-    | FlexibleSchema<InferUIMessageMetadata<UI_MESSAGE>>
+    | FlexibleSchema<UI_MESSAGE['metadata']>
     | undefined;
   private dataPartSchemas:
     | UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>

package/src/ui/process-ui-message-stream.ts

@@ -90,7 +90,7 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
 }: {
   // input stream is not fully typed yet:
   stream: ReadableStream<UIMessageChunk>;
-  messageMetadataSchema?: FlexibleSchema<InferUIMessageMetadata<UI_MESSAGE>>;
+  messageMetadataSchema?: FlexibleSchema<UI_MESSAGE['metadata']>;
   dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
   onToolCall?: (options: {
     toolCall: InferUIMessageToolCall<UI_MESSAGE>;