ai 7.0.112 → 7.0.113

package/docs/03-agents/06-tool-approvals.mdx

@@ -272,6 +272,22 @@ When a manual approval status includes a reason, it is available as
 `part.approval.requestReason`. A reason supplied with
 `addToolApprovalResponse` is stored separately as `part.approval.reason`.
 
+### Schema transforms and persisted approvals
+
+Approval requests preserve the original schema input in `inputSchemaInput` when
+it differs from the input presented for approval. Keep this field when persisting
+`responseMessages` or UI messages; the UI message conversion functions preserve it
+automatically.
+
+On continuation, the SDK reconstructs the transformed input and checks that it
+matches the approved input. It never replaces the approved input with a different
+value. Older or projected histories that omit the original input are rejected as
+invalid tool input if revalidation fails or would change the approved value.
+
+The original input is included in persisted messages and UI approval streams,
+including fields removed by schema transforms. A transform that removes a field
+does not redact it from approval metadata.
+
 ## Security Considerations
 
 ### Trust model

package/docs/03-ai-sdk-core/37-speech.mdx

@@ -147,6 +147,8 @@ try {
 | [Google](/providers/ai-sdk-providers/google#speech-models)               | `gemini-2.5-flash-preview-tts`      |
 | [Google](/providers/ai-sdk-providers/google#speech-models)               | `gemini-2.5-pro-preview-tts`        |
 | [Google](/providers/ai-sdk-providers/google#speech-models)               | `gemini-3.1-flash-tts-preview`      |
+| [Google](/providers/ai-sdk-providers/google#speech-models)               | `gemini-3.8-flash-tts`              |
+| [Google](/providers/ai-sdk-providers/google#speech-models)               | `gemini-3.8-flash-lite-tts`         |
 | [Google Vertex](/providers/ai-sdk-providers/google-vertex#speech-models) | `gemini-2.5-flash-tts`              |
 | [Google Vertex](/providers/ai-sdk-providers/google-vertex#speech-models) | `gemini-2.5-pro-tts`                |
 | [Google Vertex](/providers/ai-sdk-providers/google-vertex#speech-models) | `gemini-2.5-flash-lite-preview-tts` |

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

@@ -79,7 +79,7 @@ const { audio } = await generateSpeech({
       type: 'string',
       isOptional: true,
       description:
-        'The output format to use for the speech e.g. "mp3", "wav", etc.',
+        'The output format to use for the speech, such as "mp3", "wav", or headerless "audio/l16", "audio/mulaw", and "audio/alaw". Supported formats and defaults vary by provider and model.',
     },
     {
       name: 'instructions',

package/docs/07-reference/01-ai-sdk-core/32-validate-ui-messages.mdx

@@ -100,6 +100,24 @@ const validatedMessages = await validateUIMessages({
 });
 ```
 
+When validating approval messages produced with
+`experimental_refineToolInput`, pass the same refinement functions so
+`validateUIMessages` can reconstruct and verify the approved input:
+
+```typescript
+const experimental_refineToolInput = {
+  weather: (input: { location: string }) => ({
+    location: input.location.trim(),
+  }),
+};
+
+const validatedMessages = await validateUIMessages({
+  messages,
+  tools,
+  experimental_refineToolInput,
+});
+```
+
 ## Deprecated `rawInput` field
 
 For backward compatibility, validation still accepts `rawInput` on tool parts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.112",
+  "version": "7.0.113",
   "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,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.90",
+    "@ai-sdk/gateway": "4.0.91",
     "@ai-sdk/provider": "4.0.18",
-    "@ai-sdk/provider-utils": "5.0.46"
+    "@ai-sdk/provider-utils": "5.0.47"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.92",
-    "@ai-sdk/deepseek": "3.0.51",
-    "@ai-sdk/google": "4.0.78",
-    "@ai-sdk/groq": "4.0.47",
-    "@ai-sdk/huggingface": "2.0.54",
-    "@ai-sdk/moonshotai": "3.0.55",
-    "@ai-sdk/openai": "4.0.73",
+    "@ai-sdk/amazon-bedrock": "5.0.93",
+    "@ai-sdk/deepseek": "3.0.52",
+    "@ai-sdk/google": "4.0.79",
+    "@ai-sdk/groq": "4.0.48",
+    "@ai-sdk/huggingface": "2.0.55",
+    "@ai-sdk/moonshotai": "3.0.56",
+    "@ai-sdk/openai": "4.0.74",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.6",
+    "@ai-sdk/xai": "5.0.7",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/embed/embed-many.ts

@@ -7,6 +7,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 { createRestrictedTelemetryDispatcher } from './restricted-telemetry-dispatcher';
 import type { TelemetryOptions } from '../telemetry/telemetry-options';
@@ -321,6 +322,8 @@ export async function embedMany<RUNTIME_CONTEXT extends Context = Context>({
             ? maxInputBytesPerCall
             : Infinity,
         });
+        const providerOptionsTransformer =
+          getEmbeddingModelProviderOptionsTransformer(model);
 
         const embeddings: Array<Embedding> = [];
         const warnings: Array<Warning> = [];
@@ -339,9 +342,22 @@ export async function embedMany<RUNTIME_CONTEXT extends Context = Context>({
           supportsParallelCalls ? maxParallelCalls : 1,
         );
 
+        let nextChunkStartIndex = 0;
         for (const parallelChunk of parallelChunks) {
           const results = await Promise.all(
             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;
+
               const result = await retry(async () => {
                 const embedCallId = generateCallId();
 
@@ -361,7 +377,7 @@ export async function embedMany<RUNTIME_CONTEXT extends Context = Context>({
                   values: chunk,
                   abortSignal,
                   headers: headersWithUserAgent,
-                  providerOptions,
+                  providerOptions: chunkProviderOptions,
                 });
 
                 const chunkEmbeddings = modelResponse.embeddings;
@@ -412,7 +428,7 @@ export async function embedMany<RUNTIME_CONTEXT extends Context = Context>({
                   result.providerMetadata,
                 )) {
                   providerMetadata[providerName] = {
-                    ...(providerMetadata[providerName] ?? {}),
+                    ...providerMetadata[providerName],
                     ...metadata,
                   };
                 }

package/src/generate-speech/generate-speech.ts

@@ -204,10 +204,21 @@ function getOutputFormatMediaType(outputFormat: string | undefined) {
 
   const normalizedOutputFormat = outputFormat.trim().toLowerCase();
 
-  return normalizedOutputFormat === 'pcm' ||
-    normalizedOutputFormat === 'audio/pcm'
-    ? 'audio/pcm'
-    : undefined;
+  switch (normalizedOutputFormat) {
+    case 'pcm':
+    case 'audio/pcm':
+      return 'audio/pcm';
+    case 'audio/l16':
+      return 'audio/l16';
+    case 'mulaw':
+    case 'audio/mulaw':
+      return 'audio/mulaw';
+    case 'alaw':
+    case 'audio/alaw':
+      return 'audio/alaw';
+    default:
+      return undefined;
+  }
 }
 
 class DefaultSpeechResult implements SpeechResult {

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

@@ -53,12 +53,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/execute-tools-from-stream.ts

@@ -265,8 +265,6 @@ export function executeToolsFromStream<
                 }
               }),
             );
-
-            return;
           }
         }
       },

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

@@ -726,6 +726,7 @@ export async function generateText<
         toolsContext,
         runtimeContext,
         toolApprovalSecret: experimental_toolApprovalSecret,
+        refineToolInput,
       });
 
       const deniedToolApprovals = [

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

@@ -78,12 +78,4 @@ export class DefaultGeneratedFile implements GeneratedFile {
 
 export class DefaultGeneratedFileWithType extends DefaultGeneratedFile {
   readonly type = 'file';
-
-  constructor(options: {
-    data: string | Uint8Array;
-    mediaType: string;
-    providerMetadata?: Record<string, JSONObject>;
-  }) {
-    super(options);
-  }
 }

package/src/generate-text/invoke-tool-callbacks-from-stream.ts

@@ -35,7 +35,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
     string,
     {
       toolName: string;
-      validatedContext: Promise<unknown> | undefined;
+      validatedContexts: Record<string, Promise<unknown> | undefined>;
     }
   > = createIdMap();
 
@@ -48,22 +48,23 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
   }): Promise<unknown> => {
     const ongoingToolCall = ongoingToolCalls[toolCallId];
 
-    if (ongoingToolCall?.validatedContext != null) {
-      return ongoingToolCall.validatedContext;
+    const validatedContext = ongoingToolCall?.validatedContexts[toolName];
+    if (validatedContext != null) {
+      return validatedContext;
     }
 
     const tool = getOwn(tools, toolName);
-    const validatedContext = validateToolContext({
+    const newValidatedContext = validateToolContext({
       toolName,
       context: getOwn(toolsContext, toolName),
       contextSchema: tool?.contextSchema,
     });
 
     if (ongoingToolCall != null) {
-      ongoingToolCall.validatedContext = validatedContext;
+      ongoingToolCall.validatedContexts[toolName] = newValidatedContext;
     }
 
-    return validatedContext;
+    return newValidatedContext;
   };
 
   return stream.pipeThrough(
@@ -80,7 +81,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
           case 'tool-input-start': {
             ongoingToolCalls[chunk.id] = {
               toolName: chunk.toolName,
-              validatedContext: undefined,
+              validatedContexts: createIdMap(),
             };
 
             const tool = getOwn(tools, chunk.toolName);
@@ -120,7 +121,7 @@ export function invokeToolCallbacksFromStream<TOOLS extends ToolSet>({
           }
 
           case 'tool-call': {
-            const toolName = ongoingToolCalls[chunk.toolCallId]?.toolName;
+            const toolName = chunk.toolName;
             const tool = getOwn(tools, toolName);
 
             if (!chunk.invalid && tool?.onInputAvailable != null) {

package/src/generate-text/output.ts

@@ -487,8 +487,6 @@ function getArrayLengthValidationError({
       cause: `elements array must contain at most ${maxItems} items`,
     });
   }
-
-  return undefined;
 }
 
 /**

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

@@ -12,7 +12,12 @@ import { NoSuchToolError } from '../error/no-such-tool-error';
 import { ToolCallRepairError } from '../error/tool-call-repair-error';
 import type { Instructions } from '../prompt';
 import { getOwn } from '../util/get-own';
-import type { DynamicToolCall, TypedToolCall } from './tool-call';
+import {
+  getToolCallInputSchemaInput,
+  setToolCallInputSchemaInput,
+  type DynamicToolCall,
+  type TypedToolCall,
+} from './tool-call';
 import type { ToolCallRepairFunction } from './tool-call-repair-function';
 import type { ToolInputRefinement } from './tool-input-refinement';
 
@@ -167,7 +172,7 @@ async function waitForPromiseWithAbortSignal<T>({
   });
 }
 
-async function refineParsedToolCallInput<TOOLS extends ToolSet>({
+export async function refineParsedToolCallInput<TOOLS extends ToolSet>({
   toolCall,
   refineToolInput,
 }: {
@@ -180,10 +185,15 @@ async function refineParsedToolCallInput<TOOLS extends ToolSet>({
     return toolCall;
   }
 
-  return {
+  const refinedToolCall = {
     ...toolCall,
     input: await refine(toolCall.input as InferToolInput<TOOLS[keyof TOOLS]>),
   } as TypedToolCall<TOOLS>;
+
+  const inputSchemaInput = getToolCallInputSchemaInput(toolCall);
+  return inputSchemaInput == null
+    ? refinedToolCall
+    : setToolCallInputSchemaInput(refinedToolCall, inputSchemaInput.value);
 }
 
 async function parseProviderExecutedDynamicToolCall(
@@ -253,26 +263,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/stream-text.ts

@@ -2046,6 +2046,7 @@ class DefaultStreamTextResult<
           toolsContext,
           runtimeContext,
           toolApprovalSecret: experimental_toolApprovalSecret,
+          refineToolInput,
         });
 
         const localDeniedToolApprovals = [

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

@@ -6,8 +6,10 @@ import type {
 } from '../prompt';
 import { createToolModelOutput } from '../prompt/create-tool-model-output';
 import { getOwn } from '../util/get-own';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { ContentPart } from './content-part';
 import type { ToolSet } from '@ai-sdk/provider-utils';
+import { getToolCallInputSchemaInput } from './tool-call';
 
 /**
  * Converts the result of a `generateText` or `streamText` call to a list of response messages.
@@ -129,6 +131,7 @@ 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,
@@ -136,6 +139,10 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
           ...(part.reason != null ? { reason: part.reason } : {}),
           isAutomatic: part.isAutomatic,
           ...(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

@@ -3,6 +3,8 @@ import type { InferToolInput, ToolSet } from '@ai-sdk/provider-utils';
 import type { ProviderMetadata } from '../types';
 import type { ValueOf } from '../util/value-of';
 
+const inputSchemaInputSymbol = Symbol('ai-sdk-tool-call-input-schema-input');
+
 type BaseToolCall = {
   type: 'tool-call';
   toolCallId: string;
@@ -58,3 +60,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

@@ -10,10 +10,13 @@ import {
 import { InvalidToolApprovalSignatureError } from '../error/invalid-tool-approval-signature-error';
 import { InvalidToolInputError } from '../error/invalid-tool-input-error';
 import { getOwn } from '../util/get-own';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { CollectedToolApprovals } from './collect-tool-approvals';
+import { refineParsedToolCallInput } from './parse-tool-call';
 import { resolveToolApproval } from './resolve-tool-approval';
 import { verifyToolApprovalSignature } from './tool-approval-signature';
 import type { ToolApprovalConfiguration } from './tool-approval-configuration';
+import type { ToolInputRefinement } from './tool-input-refinement';
 
 /**
  * Re-validates approved tool approvals reconstructed from client-supplied
@@ -31,6 +34,7 @@ export async function validateApprovedToolApprovals<
   toolsContext,
   runtimeContext,
   toolApprovalSecret,
+  refineToolInput,
 }: {
   approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
   tools: TOOLS | undefined;
@@ -39,6 +43,7 @@ export async function validateApprovedToolApprovals<
   toolsContext: InferToolSetContext<TOOLS>;
   runtimeContext: RUNTIME_CONTEXT;
   toolApprovalSecret?: string | Uint8Array;
+  refineToolInput?: ToolInputRefinement<TOOLS>;
 }): Promise<{
   approvedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
   deniedToolApprovals: Array<CollectedToolApprovals<TOOLS>>;
@@ -53,7 +58,7 @@ export async function validateApprovedToolApprovals<
   > = [];
 
   for (const approval of approvedToolApprovals) {
-    const { toolCall, approvalRequest } = approval;
+    const { approvalRequest, toolCall } = approval;
     // Look up the tool by own property only: `toolName` comes from
     // client-supplied history, so a name matching an inherited object property
     // (e.g. `constructor`, `toString`) must resolve to "no such tool" rather
@@ -88,18 +93,49 @@ export async function validateApprovedToolApprovals<
     }
 
     if (isExecutableTool(tool) && 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 {
+        try {
+          const revalidatedToolCall = await refineParsedToolCallInput({
+            toolCall: {
+              ...toolCall,
+              input: validation.value,
+            },
+            refineToolInput,
+          });
+
+          // Revalidation must never change the operation that was approved,
+          // including when older or projected history omits the schema input.
+          if (!isDeepEqualData(revalidatedToolCall.input, toolCall.input)) {
+            validationError = new Error(
+              'Approved tool input does not match the validated schema output.',
+            );
+          }
+        } catch (error) {
+          validationError = error;
+        }
+      }
+
+      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/generate-video/generate-video.ts

@@ -890,8 +890,6 @@ function normalizeImageData(
       data: bytes,
     };
   }
-
-  return undefined;
 }
 
 /**

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: 'v4',

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

@@ -7,12 +7,17 @@ import type {
 import {
   asArray,
   EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
 } from '@ai-sdk/provider-utils';
 import { asEmbeddingModelV4 } from '../model/as-embedding-model-v4';
 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';
 
 /**
@@ -63,7 +68,8 @@ const doWrap = ({
   middleware: EmbeddingModelMiddleware;
   modelId?: string;
   providerId?: string;
-}): EmbeddingModelWithMaxInputBytesPerCall => {
+}): EmbeddingModelWithMaxInputBytesPerCall &
+  EmbeddingModelWithProviderOptionsTransformer => {
   async function doTransform({
     params,
   }: {
@@ -80,6 +86,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 { EmbeddingModelV4 } from '@ai-sdk/provider';
+import {
+  EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER,
+  type EmbeddingModelProviderOptionsTransformer,
+} from '@ai-sdk/provider-utils';
+
+export type EmbeddingModelWithProviderOptionsTransformer = EmbeddingModelV4 & {
+  readonly [EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER]?: EmbeddingModelProviderOptionsTransformer;
+};
+
+export function getEmbeddingModelProviderOptionsTransformer(
+  model: EmbeddingModelV4,
+) {
+  return (model as EmbeddingModelWithProviderOptionsTransformer)[
+    EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER
+  ];
+}

package/src/prompt/content-part.ts

@@ -284,6 +284,9 @@ export const toolApprovalRequestSchema: ZodType<ToolApprovalRequest> = z.object(
     approvalId: z.string(),
     toolCallId: z.string(),
     reason: z.string().optional(),
+    isAutomatic: z.boolean().optional(),
+    signature: z.string().optional(),
+    inputSchemaInput: z.unknown().optional(),
   },
 );