ai 6.0.288 → 6.0.290

package/docs/03-ai-sdk-core/40-middleware.mdx

@@ -282,6 +282,9 @@ You can implement any of the following three function to modify the behavior of
 3. `wrapStream`: Wraps the `doStream` method of the [language model](https://github.com/vercel/ai/blob/release-v6.0/packages/provider/src/language-model/v3/language-model-v3.ts).
    You can modify the parameters, call the language model, and modify the result.
 
+Every `LanguageModelV3Middleware` object must set
+`specificationVersion: 'v3'`.
+
 Here are some examples of how to implement language model middleware:
 
 ## Examples
@@ -302,6 +305,8 @@ import type {
 } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('doGenerate called');
     console.log(`params: ${JSON.stringify(params, null, 2)}`);
@@ -379,6 +384,8 @@ import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 const cache = new Map<string, any>();
 
 export const yourCacheMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     const cacheKey = JSON.stringify(params);
 
@@ -411,6 +418,8 @@ This example shows how to use RAG as middleware.
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export const yourRagMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   transformParams: async ({ params }) => {
     const lastUserMessageText = getLastUserMessageText({
       prompt: params.prompt,
@@ -437,28 +446,102 @@ Guard rails are a way to ensure that the generated text of a language model call
 is safe and appropriate. This example shows how to use guardrails as middleware.
 
 ```ts
-import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
+import type {
+  LanguageModelV3Middleware,
+  LanguageModelV3StreamPart,
+} from '@ai-sdk/provider';
+
+const redactText = (text: string) => text.replace(/badword/g, '<REDACTED>');
 
 export const yourGuardrailMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate }) => {
     const result = await doGenerate();
 
     // filtering approach, e.g. for PII or other sensitive information:
     const content = result.content.map(part =>
-      part.type === 'text'
-        ? { ...part, text: part.text.replace(/badword/g, '<REDACTED>') }
-        : part,
+      part.type === 'text' ? { ...part, text: redactText(part.text) } : part,
     );
 
     return { ...result, content };
   },
 
-  // here you would implement the guardrail logic for streaming
-  // Note: streaming guardrails are difficult to implement, because
-  // you do not know the full content of the stream until it's finished.
+  wrapStream: async ({ doStream }) => {
+    const { stream, ...rest } = await doStream();
+
+    // Keep a separate buffer for each text block in the stream.
+    const buffers = new Map<string, string>();
+
+    const transformStream = new TransformStream<
+      LanguageModelV3StreamPart,
+      LanguageModelV3StreamPart
+    >({
+      transform(chunk, controller) {
+        if (chunk.type === 'text-start') {
+          buffers.set(chunk.id, '');
+          controller.enqueue(chunk);
+          return;
+        }
+
+        if (chunk.type === 'text-delta') {
+          buffers.set(chunk.id, (buffers.get(chunk.id) ?? '') + chunk.delta);
+          return;
+        }
+
+        if (chunk.type === 'text-end') {
+          const bufferedText = buffers.get(chunk.id);
+
+          if (bufferedText != null) {
+            const redactedText = redactText(bufferedText);
+
+            if (redactedText) {
+              controller.enqueue({
+                type: 'text-delta',
+                id: chunk.id,
+                delta: redactedText,
+              });
+            }
+
+            buffers.delete(chunk.id);
+          }
+        }
+
+        controller.enqueue(chunk);
+      },
+
+      flush(controller) {
+        for (const [id, bufferedText] of buffers) {
+          const redactedText = redactText(bufferedText);
+
+          if (redactedText) {
+            controller.enqueue({
+              type: 'text-delta',
+              id,
+              delta: redactedText,
+            });
+          }
+        }
+      },
+    });
+
+    return {
+      stream: stream.pipeThrough(transformStream),
+      ...rest,
+    };
+  },
 };
 ```
 
+<Note>
+  The streaming example buffers each text block until `text-end` so matches
+  split across `text-delta` chunks cannot leak through. This delays output and
+  uses memory proportional to the text block size. Do not redact each delta
+  independently. An incremental implementation must retain every possible
+  incomplete match, and a fixed-size buffer alone is not safe for unbounded
+  variable-length patterns.
+</Note>
+
 ## Configuring Per Request Custom Metadata
 
 To send and access custom metadata in Middleware, you can use `providerOptions`. This is useful when building logging middleware where you want to pass additional context like user IDs, timestamps, or other contextual data that can help with tracking and debugging.
@@ -469,6 +552,8 @@ __PROVIDER_IMPORT__;
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('METADATA', params?.providerMetadata?.yourLogMiddleware);
     const result = await doGenerate();

package/docs/04-ai-sdk-ui/03-chatbot-tool-usage.mdx

@@ -487,6 +487,13 @@ the `approval-responded` state after `addToolApprovalResponse` is called. This
 lets clients render or persist server-computed approval metadata without using
 it to determine whether the tool was approved.
 
+When a tool input schema transforms its input, approval requests also preserve
+the original value as `part.approval.inputSchemaInput`. Keep this field when
+persisting UI messages or model response messages so the SDK can reconstruct
+and verify the approved input before execution. The original value can include
+fields removed by the transform, so approval metadata should not be treated as
+redacted input.
+
 ### Auto-Submit After Approval
 
 <Note>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.288",
+  "version": "6.0.290",
   "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",
   "sideEffects": false,
@@ -45,9 +45,9 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@ai-sdk/gateway": "3.0.198",
-    "@ai-sdk/provider": "3.0.16",
-    "@ai-sdk/provider-utils": "4.0.52"
+    "@ai-sdk/gateway": "3.0.200",
+    "@ai-sdk/provider": "3.0.17",
+    "@ai-sdk/provider-utils": "4.0.54"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",
@@ -58,6 +58,7 @@
     "tsx": "^4.19.2",
     "typescript": "5.8.3",
     "zod": "3.25.76",
+    "@ai-sdk/google": "3.0.127",
     "@ai-sdk/test-server": "1.0.6",
     "@vercel/ai-tsconfig": "0.0.0"
   },

package/src/embed/embed-many.ts

@@ -4,6 +4,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { logWarnings } from '../logger/log-warnings';
 import { getEmbeddingModelMaxInputBytesPerCall } from '../model/get-embedding-model-max-input-bytes-per-call';
+import { getEmbeddingModelProviderOptionsTransformer } from '../model/get-embedding-model-provider-options-transformer';
 import { resolveEmbeddingModel } from '../model/resolve-model';
 import { assembleOperationName } from '../telemetry/assemble-operation-name';
 import { getBaseTelemetryAttributes } from '../telemetry/get-base-telemetry-attributes';
@@ -250,6 +251,8 @@ export async function embedMany({
           ? maxInputBytesPerCall
           : Infinity,
       });
+      const providerOptionsTransformer =
+        getEmbeddingModelProviderOptionsTransformer(model);
 
       // serially embed the chunks:
       const embeddings: Array<Embedding> = [];
@@ -269,9 +272,22 @@ export async function embedMany({
         supportsParallelCalls ? maxParallelCalls : 1,
       );
 
+      let nextChunkStartIndex = 0;
       for (const parallelChunk of parallelChunks) {
         const results = await Promise.all(
-          parallelChunk.map(chunk => {
+          parallelChunk.map(async chunk => {
+            // Capture the range before awaiting transformations or retrying.
+            const startIndex = nextChunkStartIndex;
+            nextChunkStartIndex += chunk.length;
+            const chunkProviderOptions = providerOptionsTransformer
+              ? await providerOptionsTransformer({
+                  providerOptions,
+                  values,
+                  startIndex,
+                  endIndex: startIndex + chunk.length,
+                })
+              : providerOptions;
+
             return retry(() => {
               // nested spans to align with the embedMany telemetry data:
               return recordSpan({
@@ -296,7 +312,7 @@ export async function embedMany({
                     values: chunk,
                     abortSignal,
                     headers: headersWithUserAgent,
-                    providerOptions,
+                    providerOptions: chunkProviderOptions,
                   });
 
                   const embeddings = modelResponse.embeddings;
@@ -343,7 +359,7 @@ export async function embedMany({
                 result.providerMetadata,
               )) {
                 providerMetadata[providerName] = {
-                  ...(providerMetadata[providerName] ?? {}),
+                  ...providerMetadata[providerName],
                   ...metadata,
                 };
               }

package/src/generate-speech/generated-audio-file.ts

@@ -54,12 +54,4 @@ export class DefaultGeneratedAudioFile
 
 export class DefaultGeneratedAudioFileWithType extends DefaultGeneratedAudioFile {
   readonly type = 'audio';
-
-  constructor(options: {
-    data: string | Uint8Array;
-    mediaType: string;
-    format: string;
-  }) {
-    super(options);
-  }
 }

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

@@ -63,8 +63,4 @@ export class DefaultGeneratedFile implements GeneratedFile {
 
 export class DefaultGeneratedFileWithType extends DefaultGeneratedFile {
   readonly type = 'file';
-
-  constructor(options: { data: string | Uint8Array; mediaType: string }) {
-    super(options);
-  }
 }

package/src/generate-text/parse-tool-call.ts

@@ -9,7 +9,11 @@ import {
 import { InvalidToolInputError } from '../error/invalid-tool-input-error';
 import { NoSuchToolError } from '../error/no-such-tool-error';
 import { ToolCallRepairError } from '../error/tool-call-repair-error';
-import type { DynamicToolCall, TypedToolCall } from './tool-call';
+import {
+  setToolCallInputSchemaInput,
+  type DynamicToolCall,
+  type TypedToolCall,
+} from './tool-call';
 import type { ToolCallRepairFunction } from './tool-call-repair-function';
 import type { ToolSet } from './tool-set';
 
@@ -167,26 +171,29 @@ async function doParseToolCall<TOOLS extends ToolSet>({
     });
   }
 
-  return tool.type === 'dynamic'
-    ? {
-        type: 'tool-call',
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        input: parseResult.value,
-        providerExecuted: toolCall.providerExecuted,
-        providerMetadata: toolCall.providerMetadata,
-        ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
-        dynamic: true,
-        title: tool.title,
-      }
-    : {
-        type: 'tool-call',
-        toolCallId: toolCall.toolCallId,
-        toolName,
-        input: parseResult.value,
-        providerExecuted: toolCall.providerExecuted,
-        providerMetadata: toolCall.providerMetadata,
-        ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
-        title: tool.title,
-      };
+  return setToolCallInputSchemaInput(
+    tool.type === 'dynamic'
+      ? {
+          type: 'tool-call',
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: parseResult.value,
+          providerExecuted: toolCall.providerExecuted,
+          providerMetadata: toolCall.providerMetadata,
+          ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
+          dynamic: true,
+          title: tool.title,
+        }
+      : {
+          type: 'tool-call',
+          toolCallId: toolCall.toolCallId,
+          toolName,
+          input: parseResult.value,
+          providerExecuted: toolCall.providerExecuted,
+          providerMetadata: toolCall.providerMetadata,
+          ...(tool.metadata != null ? { toolMetadata: tool.metadata } : {}),
+          title: tool.title,
+        },
+    parseResult.rawValue,
+  );
 }

package/src/generate-text/run-tools-transformation.ts

@@ -261,6 +261,10 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
       });
   }
 
+  // Keep input callbacks in the same transform so input availability cannot
+  // overtake pending start or delta callbacks in a downstream stream.
+  const activeToolCallToolNames = new Map<string, string>();
+
   // forward stream
   const forwardStream = new TransformStream<
     LanguageModelV3StreamPart,
@@ -283,9 +287,6 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
         case 'reasoning-start':
         case 'reasoning-delta':
         case 'reasoning-end':
-        case 'tool-input-start':
-        case 'tool-input-delta':
-        case 'tool-input-end':
         case 'source':
         case 'response-metadata':
         case 'error':
@@ -294,6 +295,39 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
           break;
         }
 
+        case 'tool-input-start': {
+          activeToolCallToolNames.set(chunk.id, chunk.toolName);
+          await tools?.[chunk.toolName]?.onInputStart?.({
+            toolCallId: chunk.id,
+            messages,
+            abortSignal,
+            experimental_context,
+          });
+          controller.enqueue(chunk);
+          break;
+        }
+
+        case 'tool-input-delta': {
+          const toolName = activeToolCallToolNames.get(chunk.id);
+          if (toolName != null) {
+            await tools?.[toolName]?.onInputDelta?.({
+              inputTextDelta: chunk.delta,
+              toolCallId: chunk.id,
+              messages,
+              abortSignal,
+              experimental_context,
+            });
+          }
+          controller.enqueue(chunk);
+          break;
+        }
+
+        case 'tool-input-end': {
+          activeToolCallToolNames.delete(chunk.id);
+          controller.enqueue(chunk);
+          break;
+        }
+
         case 'file': {
           controller.enqueue({
             type: 'file',

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

@@ -79,6 +79,7 @@ import { consumeStream } from '../util/consume-stream';
 import { createIdMap } from '../util/create-id-map';
 import { createStitchableStream } from '../util/create-stitchable-stream';
 import type { DownloadFunction } from '../util/download/download-function';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import { mergeAbortSignals } from '../util/merge-abort-signals';
 import { mergeObjects } from '../util/merge-objects';
 import { now as originalNow } from '../util/now';
@@ -123,7 +124,7 @@ import type {
   UIMessageStreamOptions,
 } from './stream-text-result';
 import { toResponseMessages } from './to-response-messages';
-import type { TypedToolCall } from './tool-call';
+import { getToolCallInputSchemaInput, type TypedToolCall } from './tool-call';
 import type { ToolCallRepairFunction } from './tool-call-repair-function';
 import type { ToolOutput } from './tool-output';
 import type { StaticToolOutputDenied } from './tool-output-denied';
@@ -1965,8 +1966,6 @@ class DefaultStreamTextResult<
             const stepToolOutputs: ToolOutput<TOOLS>[] = [];
             let warnings: SharedV3Warning[] | undefined;
 
-            const activeToolCallToolNames: Record<string, string> = {};
-
             let stepFinishReason: FinishReason = 'other';
             let stepRawFinishReason: string | undefined = undefined;
 
@@ -2168,18 +2167,7 @@ class DefaultStreamTextResult<
                       }
 
                       case 'tool-input-start': {
-                        activeToolCallToolNames[chunk.id] = chunk.toolName;
-
                         const tool = stepToolSet?.[chunk.toolName];
-                        if (tool?.onInputStart != null) {
-                          await tool.onInputStart({
-                            toolCallId: chunk.id,
-                            messages: stepInputMessages,
-                            abortSignal,
-                            experimental_context,
-                          });
-                        }
-
                         controller.enqueue({
                           ...chunk,
                           dynamic: chunk.dynamic ?? tool?.type === 'dynamic',
@@ -2189,25 +2177,11 @@ class DefaultStreamTextResult<
                       }
 
                       case 'tool-input-end': {
-                        delete activeToolCallToolNames[chunk.id];
                         controller.enqueue(chunk);
                         break;
                       }
 
                       case 'tool-input-delta': {
-                        const toolName = activeToolCallToolNames[chunk.id];
-                        const tool = stepToolSet?.[toolName];
-
-                        if (tool?.onInputDelta != null) {
-                          await tool.onInputDelta({
-                            inputTextDelta: chunk.delta,
-                            toolCallId: chunk.id,
-                            messages: stepInputMessages,
-                            abortSignal,
-                            experimental_context,
-                          });
-                        }
-
                         controller.enqueue(chunk);
                         break;
                       }
@@ -3011,10 +2985,17 @@ class DefaultStreamTextResult<
             }
 
             case 'tool-approval-request': {
+              const inputSchemaInput = getToolCallInputSchemaInput(
+                part.toolCall,
+              );
               controller.enqueue({
                 type: 'tool-approval-request',
                 approvalId: part.approvalId,
                 toolCallId: part.toolCall.toolCallId,
+                ...(inputSchemaInput != null &&
+                !isDeepEqualData(inputSchemaInput.value, part.toolCall.input)
+                  ? { inputSchemaInput: inputSchemaInput.value }
+                  : {}),
                 ...(part.signature != null
                   ? { signature: part.signature }
                   : {}),

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

@@ -5,8 +5,10 @@ import type {
   ToolModelMessage,
 } from '../prompt';
 import { createToolModelOutput } from '../prompt/create-tool-model-output';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { ContentPart } from './content-part';
 import type { ToolSet } from './tool-set';
+import { getToolCallInputSchemaInput } from './tool-call';
 
 /**
  * Converts the result of a `generateText` or `streamText` call to a list of response messages.
@@ -113,11 +115,16 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
         break;
       }
       case 'tool-approval-request':
+        const inputSchemaInput = getToolCallInputSchemaInput(part.toolCall);
         content.push({
           type: 'tool-approval-request',
           approvalId: part.approvalId,
           toolCallId: part.toolCall.toolCallId,
           ...(part.signature != null ? { signature: part.signature } : {}),
+          ...(inputSchemaInput != null &&
+          !isDeepEqualData(inputSchemaInput.value, part.toolCall.input)
+            ? { inputSchemaInput: inputSchemaInput.value }
+            : {}),
         });
         break;
     }

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

@@ -4,6 +4,8 @@ import type { ProviderMetadata } from '../types';
 import type { ValueOf } from '../util/value-of';
 import type { ToolSet } from './tool-set';
 
+const inputSchemaInputSymbol = Symbol('ai-sdk-tool-call-input-schema-input');
+
 type BaseToolCall = {
   type: 'tool-call';
   toolCallId: string;
@@ -47,3 +49,27 @@ export type DynamicToolCall = BaseToolCall & {
 export type TypedToolCall<TOOLS extends ToolSet> =
   | StaticToolCall<TOOLS>
   | DynamicToolCall;
+
+export function setToolCallInputSchemaInput<TOOLS extends ToolSet>(
+  toolCall: TypedToolCall<TOOLS>,
+  inputSchemaInput: unknown,
+): TypedToolCall<TOOLS> {
+  Object.defineProperty(toolCall, inputSchemaInputSymbol, {
+    value: inputSchemaInput,
+  });
+  return toolCall;
+}
+
+export function getToolCallInputSchemaInput<TOOLS extends ToolSet>(
+  toolCall: TypedToolCall<TOOLS>,
+): { value: unknown } | undefined {
+  return inputSchemaInputSymbol in toolCall
+    ? {
+        value: (
+          toolCall as TypedToolCall<TOOLS> & {
+            [inputSchemaInputSymbol]: unknown;
+          }
+        )[inputSchemaInputSymbol],
+      }
+    : undefined;
+}

package/src/generate-text/validate-tool-approvals.ts

@@ -5,6 +5,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { InvalidToolApprovalSignatureError } from '../error/invalid-tool-approval-signature-error';
 import { InvalidToolInputError } from '../error/invalid-tool-input-error';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { CollectedToolApprovals } from './collect-tool-approvals';
 import { isApprovalNeeded } from './is-approval-needed';
 import { verifyToolApprovalSignature } from './tool-approval-signature';
@@ -86,18 +87,35 @@ export async function validateApprovedToolApprovals<TOOLS extends ToolSet>({
       typeof tool.execute === 'function' &&
       tool.inputSchema != null
     ) {
+      const hasInputSchemaInput = Object.prototype.hasOwnProperty.call(
+        approvalRequest,
+        'inputSchemaInput',
+      );
       const validation = await safeValidateTypes({
-        value: toolCall.input,
+        value: hasInputSchemaInput
+          ? approvalRequest.inputSchemaInput
+          : toolCall.input,
         schema: asSchema(tool.inputSchema),
       });
 
+      let validationError: unknown;
       if (!validation.success) {
+        validationError = validation.error;
+      } else if (!isDeepEqualData(validation.value, toolCall.input)) {
+        // Revalidation must never change the operation that was approved,
+        // including when older or projected history omits the schema input.
+        validationError = new Error(
+          'Approved tool input does not match the validated schema output.',
+        );
+      }
+
+      if (validationError != null) {
         invalid.push({
           ...approval,
           error: new InvalidToolInputError({
             toolName: toolCall.toolName,
             toolInput: JSON.stringify(toolCall.input),
-            cause: validation.error,
+            cause: validationError,
           }),
         });
         continue;

package/src/middleware/extract-reasoning-middleware.ts

@@ -24,7 +24,7 @@ export function extractReasoningMiddleware({
   startWithReasoning?: boolean;
 }): LanguageModelMiddleware {
   const openingTag = `<${tagName}>`;
-  const closingTag = `<\/${tagName}>`;
+  const closingTag = `</${tagName}>`;
 
   return {
     specificationVersion: 'v3',

package/src/middleware/wrap-embedding-model.ts

@@ -2,11 +2,18 @@ import type {
   EmbeddingModelV3,
   EmbeddingModelV3CallOptions,
 } from '@ai-sdk/provider';
-import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from '@ai-sdk/provider-utils';
+import {
+  EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
+} from '@ai-sdk/provider-utils';
 import {
   getEmbeddingModelMaxInputBytesPerCall,
   type EmbeddingModelWithMaxInputBytesPerCall,
 } from '../model/get-embedding-model-max-input-bytes-per-call';
+import {
+  getEmbeddingModelProviderOptionsTransformer,
+  type EmbeddingModelWithProviderOptionsTransformer,
+} from '../model/get-embedding-model-provider-options-transformer';
 import type { EmbeddingModelMiddleware } from '../types';
 import { asArray } from '../util/as-array';
 
@@ -57,7 +64,8 @@ const doWrap = ({
   middleware: EmbeddingModelMiddleware;
   modelId?: string;
   providerId?: string;
-}): EmbeddingModelWithMaxInputBytesPerCall => {
+}): EmbeddingModelWithMaxInputBytesPerCall &
+  EmbeddingModelWithProviderOptionsTransformer => {
   async function doTransform({
     params,
   }: {
@@ -74,6 +82,8 @@ const doWrap = ({
       overrideMaxEmbeddingsPerCall?.({ model }) ?? model.maxEmbeddingsPerCall,
     [EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL]:
       getEmbeddingModelMaxInputBytesPerCall(model),
+    [EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER]:
+      getEmbeddingModelProviderOptionsTransformer(model),
     supportsParallelCalls:
       overrideSupportsParallelCalls?.({ model }) ?? model.supportsParallelCalls,
     async doEmbed(

package/src/model/get-embedding-model-provider-options-transformer.ts

@@ -0,0 +1,17 @@
+import type { EmbeddingModelV3 } from '@ai-sdk/provider';
+import {
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
+  type EmbeddingModelProviderOptionsTransformer,
+} from '@ai-sdk/provider-utils';
+
+export type EmbeddingModelWithProviderOptionsTransformer = EmbeddingModelV3 & {
+  readonly [EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER]?: EmbeddingModelProviderOptionsTransformer;
+};
+
+export function getEmbeddingModelProviderOptionsTransformer(
+  model: EmbeddingModelV3,
+) {
+  return (model as EmbeddingModelWithProviderOptionsTransformer)[
+    EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER
+  ];
+}