ai 7.0.111 → 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/03-ai-sdk-core/40-middleware.mdx

@@ -310,6 +310,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/main/packages/provider/src/language-model/v4/language-model-v4.ts).
    You can modify the parameters, call the language model, and modify the result.
 
+Every `LanguageModelV4Middleware` object must set
+`specificationVersion: 'v4'`.
+
 Here are some examples of how to implement language model middleware:
 
 ## Examples
@@ -330,6 +333,8 @@ import type {
 } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('doGenerate called');
     console.log(`params: ${JSON.stringify(params, null, 2)}`);
@@ -407,6 +412,8 @@ import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 const cache = new Map<string, any>();
 
 export const yourCacheMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     const cacheKey = JSON.stringify(params);
 
@@ -439,6 +446,8 @@ This example shows how to use RAG as middleware.
 import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 
 export const yourRagMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   transformParams: async ({ params }) => {
     const lastUserMessageText = getLastUserMessageText({
       prompt: params.prompt,
@@ -465,28 +474,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 { LanguageModelV4Middleware } from '@ai-sdk/provider';
+import type {
+  LanguageModelV4Middleware,
+  LanguageModelV4StreamPart,
+} from '@ai-sdk/provider';
+
+const redactText = (text: string) => text.replace(/badword/g, '<REDACTED>');
 
 export const yourGuardrailMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   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<
+      LanguageModelV4StreamPart,
+      LanguageModelV4StreamPart
+    >({
+      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.
@@ -497,6 +580,8 @@ __PROVIDER_IMPORT__;
 import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('METADATA', params?.providerMetadata?.yourLogMiddleware);
     const result = await doGenerate();

package/docs/06-advanced/02-stopping-streams.mdx

@@ -205,6 +205,14 @@ export async function POST(req: Request) {
 
 The `consumeStream` function is necessary for proper abort handling in UI message streams. It ensures that the stream is properly consumed even when aborted, preventing potential memory leaks or hanging connections.
 
+The `onEnd` callback distinguishes consumer cancellation from an observed
+abort. When the consumer cancels the UI message stream before an outcome is
+declared, such as during a client disconnect, `isCancelled` is `true`,
+`outcome.status` remains `'unknown'`, and `isAborted` remains `false`. When the
+stream observes an `abort` part first, `outcome.status` is `'aborted'`,
+`isAborted` is `true`, and `isCancelled` is absent. Check both flags when the
+same cleanup should run for either case.
+
 ## AI SDK RSC
 
 <Note type="warning">

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

@@ -4082,13 +4082,13 @@ To see `streamText` in action, check out [these examples](#examples).
             },
             {
               name: 'onEnd',
-              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
+              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
               isOptional: true,
-              description: 'Callback function called when the stream ends. Provides the updated messages, continuation and abort state, model finish reason, and operation-level outcome.',
+              description: 'Callback function called when the stream ends. Provides the updated messages, continuation, abort and consumer-cancellation state, model finish reason, and operation-level outcome.',
             },
             {
               name: 'onFinish',
-              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
+              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
               isOptional: true,
               description: 'Deprecated alias for `onEnd`.',
             },

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/docs/07-reference/02-ai-sdk-ui/40-create-ui-message-stream.mdx

@@ -134,7 +134,7 @@ outcomes and call `setOutcome` once.
     },
     {
       name: 'onEnd',
-      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
+      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
       description: 'A callback function that is called when the stream ends.',
       properties: [
         {
@@ -156,11 +156,17 @@ outcomes and call `setOutcome` once.
               type: 'boolean',
               description: 'Indicates whether the stream was aborted.',
             },
+            {
+              name: 'isCancelled',
+              type: 'true | undefined',
+              description:
+                'Present and true when the consumer cancelled the stream before an outcome was declared, for example because the client disconnected.',
+            },
             {
               name: 'outcome',
               type: "UIMessageStreamOutcome = { status: 'completed' } | { status: 'failed'; error?: unknown } | { status: 'aborted' } | { status: 'unknown' }",
               description:
-                'The operation-level outcome of the stream. It reflects the stream owner declaration unless a fatal stream-processing failure occurs, and is separate from model finish reasons and individual error chunks.',
+                "The operation-level outcome of the stream. It reflects the stream owner declaration unless a fatal stream-processing failure occurs, and is separate from model finish reasons and individual error chunks. It remains 'unknown' when the consumer cancels before an outcome is declared; check isCancelled to distinguish that case from normal closure without a declared outcome.",
             },
             {
               name: 'responseMessage',
@@ -180,7 +186,7 @@ outcomes and call `setOutcome` once.
     },
     {
       name: 'onFinish',
-      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
+      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
       description: 'Deprecated alias for `onEnd`.',
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.111",
+  "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.89",
-    "@ai-sdk/provider": "4.0.17",
-    "@ai-sdk/provider-utils": "5.0.45"
+    "@ai-sdk/gateway": "4.0.91",
+    "@ai-sdk/provider": "4.0.18",
+    "@ai-sdk/provider-utils": "5.0.47"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.91",
-    "@ai-sdk/deepseek": "3.0.50",
-    "@ai-sdk/google": "4.0.77",
-    "@ai-sdk/groq": "4.0.46",
-    "@ai-sdk/huggingface": "2.0.53",
-    "@ai-sdk/moonshotai": "3.0.54",
-    "@ai-sdk/openai": "4.0.72",
+    "@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.5",
+    "@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/prune-messages.ts

@@ -47,7 +47,9 @@ export function pruneMessages({
 
       return {
         ...message,
-        content: message.content.filter(part => part.type !== 'reasoning'),
+        content: message.content.filter(
+          part => part.type !== 'reasoning' && part.type !== 'reasoning-file',
+        ),
       };
     });
   }

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

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