ai 7.0.54 → 7.0.56

package/dist/internal/index.d.ts

@@ -1399,6 +1399,8 @@ type LanguageModelCallEndEvent<TOOLS extends ToolSet = ToolSet> = ModelInfo & {
     readonly content: ReadonlyArray<ContentPart<TOOLS>>;
     /** The provider-returned response id for this model call. */
     readonly responseId: string;
+    /** Optional provider-specific metadata for this model call. */
+    readonly providerMetadata?: ProviderMetadata;
     /** Performance metrics for the model call. */
     readonly performance: {
         /** Time spent waiting for the language model response in milliseconds. */

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.56" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-ai-sdk-core/05-generating-text.mdx

@@ -187,7 +187,7 @@ The available lifecycle callbacks are:
 - **`onStart`**: Called once when the `generateText` operation begins, before any LLM calls. Receives model info, messages, settings, and `runtimeContext`.
 - **`onStepStart`**: Called before each step (LLM call). Receives the step number, model, messages being sent, tools, and prior steps.
 - **`onLanguageModelCallStart`**: Called immediately before the provider model call begins. Useful when you want to observe the model invocation separately from later tool execution.
-- **`onLanguageModelCallEnd`**: Called after the model response has been normalized and parsed, but before any client-side tool execution begins. Receives the model-call content parts, usage, and finish reason.
+- **`onLanguageModelCallEnd`**: Called after the model response has been normalized and parsed, but before any client-side tool execution begins. Receives the model-call content parts, usage, finish reason, and provider metadata.
 - **`onToolExecutionStart`**: Called right before a tool's `execute` function runs. Receives the tool call object, messages, and `toolContext`.
 - **`onToolExecutionEnd`**: Called right after a tool's `execute` function completes or errors. Receives the tool call object, `toolExecutionMs`, and a `toolOutput` discriminated union (`type: 'tool-result'` with `output`, or `type: 'tool-error'` with `error`).
 - **`onStepEnd`**: Called after each step finishes. Includes `stepNumber` (zero-based index of the completed step).
@@ -417,7 +417,7 @@ The available lifecycle callbacks are:
 - **`onStart`**: Called once when the `streamText` operation begins, before any LLM calls. Receives model info, messages, settings, and `runtimeContext`.
 - **`onStepStart`**: Called before each step (LLM call). Receives the step number, model, messages being sent, tools, and prior steps.
 - **`onLanguageModelCallStart`**: Called immediately before the provider model call begins. Useful when you want to observe the model invocation separately from later tool execution.
-- **`onLanguageModelCallEnd`**: Called after the model response has been normalized and parsed, but before any client-side tool execution begins. Receives the model-call content parts, usage, and finish reason.
+- **`onLanguageModelCallEnd`**: Called after the model response has been normalized and parsed, but before any client-side tool execution begins. Receives the model-call content parts, usage, finish reason, and provider metadata.
 - **`onToolExecutionStart`**: Called right before a tool's `execute` function runs. Receives the tool call object, messages, and `toolContext`.
 - **`onToolExecutionEnd`**: Called right after a tool's `execute` function completes or errors. Receives the tool call object, `toolExecutionMs`, and a `toolOutput` discriminated union (`type: 'tool-result'` with `output`, or `type: 'tool-error'` with `error`).
 - **`onStepEnd`**: Called after each step finishes. Receives the finish reason, usage, and other step details.

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

@@ -356,7 +356,7 @@ export function myIntegration(): Telemetry {
       name: 'onLanguageModelCallEnd',
       type: '(event: LanguageModelCallEndEvent) => void | PromiseLike<void>',
       description:
-        'Called after the model response has been normalized and parsed, but before any client-side tool execution begins.',
+        'Called after the model response has been normalized and parsed, but before any client-side tool execution begins. Includes provider-specific metadata when available.',
     },
     {
       name: 'onToolExecutionStart',
@@ -628,7 +628,7 @@ registerTelemetry(
 The available options are:
 
 - `usage`: detailed usage attributes that are not covered by GenAI usage attributes, such as uncached input tokens and output text/reasoning token details.
-- `providerMetadata`: `ai.response.providerMetadata`.
+- `providerMetadata`: `ai.response.providerMetadata` on operation, step, and model-call spans.
 - `embedding`: embedding inputs and outputs.
 - `reranking`: rerank input documents and ranking output.
 - `runtimeContext`: `ai.settings.context.*`.

package/docs/03-ai-sdk-core/65-lifecycle-callbacks.mdx

@@ -97,7 +97,13 @@ const result = streamText({
   model: __MODEL__,
   prompt: 'Explain partial prerendering in two paragraphs.',
 
-  onLanguageModelCallEnd({ callId, modelId, usage, performance }) {
+  onLanguageModelCallEnd({
+    callId,
+    modelId,
+    usage,
+    performance,
+    providerMetadata,
+  }) {
     metrics.histogram('ai.model.response_time_ms', performance.responseTimeMs, {
       callId,
       modelId,
@@ -108,6 +114,11 @@ const result = streamText({
       total: performance.effectiveTotalTokensPerSecond,
       tokens: usage.totalTokens,
     });
+
+    logger.info('ai.model.provider_metadata', {
+      callId,
+      providerMetadata,
+    });
   },
 });
 
@@ -675,6 +686,12 @@ Called after the provider response has been normalized and parsed, before local
       type: 'string',
       description: 'Provider-returned response ID for this model call.',
     },
+    {
+      name: 'providerMetadata',
+      type: 'ProviderMetadata | undefined',
+      description:
+        'Provider-specific metadata for this model call, when returned by the provider.',
+    },
     {
       name: 'performance',
       type: 'LanguageModelCallPerformance',

package/docs/07-reference/01-ai-sdk-core/01-generate-text.mdx

@@ -1438,6 +1438,12 @@ To see `generateText` in action, check out [these examples](#examples).
               description:
                 'The provider-returned response ID for this model call.',
             },
+            {
+              name: 'providerMetadata',
+              type: 'ProviderMetadata | undefined',
+              description:
+                'Provider-specific metadata for this model call, when returned by the provider.',
+            },
             {
               name: 'performance',
               type: '{ responseTimeMs: number; effectiveOutputTokensPerSecond: number; outputTokensPerSecond: number | undefined; inputTokensPerSecond: number | undefined; effectiveTotalTokensPerSecond: number; timeToFirstOutputMs: number | undefined; timeBetweenOutputChunksMs?: OutputChunkTimingStats }',

package/docs/07-reference/01-ai-sdk-core/02-stream-text.mdx

@@ -2422,6 +2422,12 @@ To see `streamText` in action, check out [these examples](#examples).
               description:
                 'The provider-returned response ID for this model call.',
             },
+            {
+              name: 'providerMetadata',
+              type: 'ProviderMetadata | undefined',
+              description:
+                'Provider-specific metadata for this model call, when returned by the provider.',
+            },
             {
               name: 'performance',
               type: '{ responseTimeMs: number; effectiveOutputTokensPerSecond: number; outputTokensPerSecond: number | undefined; inputTokensPerSecond: number | undefined; effectiveTotalTokensPerSecond: number; timeToFirstOutputMs: number | undefined; timeBetweenOutputChunksMs?: OutputChunkTimingStats }',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.54",
+  "version": "7.0.56",
   "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.44",
+    "@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/generate-text/generate-text.ts

@@ -1085,6 +1085,11 @@ export async function generateText<
                   usage: stepUsage,
                   content: modelCallContent,
                   responseId: currentModelResponse.response.id,
+                  ...(currentModelResponse.providerMetadata != null
+                    ? {
+                        providerMetadata: currentModelResponse.providerMetadata,
+                      }
+                    : {}),
                   performance: {
                     responseTimeMs,
                     effectiveOutputTokensPerSecond: calculateTokensPerSecond({

package/src/generate-text/language-model-events.ts

@@ -1,6 +1,7 @@
 import type { ToolSet } from '@ai-sdk/provider-utils';
 import type { Callback } from '../util/callback';
 import type { FinishReason } from '../types/language-model';
+import type { ProviderMetadata } from '../types/provider-metadata';
 import type { LanguageModelUsage } from '../types/usage';
 import type { ContentPart } from './content-part';
 import type { StandardizedPrompt } from '../prompt/standardize-prompt';
@@ -55,6 +56,9 @@ export type LanguageModelCallEndEvent<TOOLS extends ToolSet = ToolSet> =
     /** The provider-returned response id for this model call. */
     readonly responseId: string;
 
+    /** Optional provider-specific metadata for this model call. */
+    readonly providerMetadata?: ProviderMetadata;
+
     /** Performance metrics for the model call. */
     readonly performance: {
       /** Time spent waiting for the language model response in milliseconds. */

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

@@ -596,6 +596,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
               usage,
               content: modelCallContent,
               responseId,
+              ...(chunk.providerMetadata != null
+                ? { providerMetadata: chunk.providerMetadata }
+                : {}),
               performance,
             },
             callbacks: onLanguageModelCallEnd,