ai 6.0.289 → 6.0.291

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/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';
@@ -2984,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
+  ];
+}

package/src/prompt/content-part.ts

@@ -201,6 +201,8 @@ export const toolApprovalRequestSchema: z.ZodType<ToolApprovalRequest> =
     type: z.literal('tool-approval-request'),
     approvalId: z.string(),
     toolCallId: z.string(),
+    signature: z.string().optional(),
+    inputSchemaInput: z.unknown().optional(),
   });
 
 /**

package/src/ui/chat.ts

@@ -259,6 +259,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   private onData?: ChatInit<UI_MESSAGE>['onData'];
   private sendAutomaticallyWhen?: ChatInit<UI_MESSAGE>['sendAutomaticallyWhen'];
 
+  private pendingApprovalMessageId: string | undefined;
   private activeResponse: ActiveResponse<UI_MESSAGE> | undefined = undefined;
   private activeResumeRequest: ActiveResumeRequest | undefined = undefined;
   private jobExecutor = new SerialJobExecutor();
@@ -361,9 +362,37 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     options?: ChatRequestOptions,
   ): Promise<void> => {
     if (message == null) {
-      await this.makeRequest({
-        trigger: 'submit-message',
-        messageId: this.lastMessage?.id,
+      let messageId = this.pendingApprovalMessageId;
+
+      if (messageId == null) {
+        messageId = this.lastMessage?.id;
+
+        // When hydrating a chat with an already-responded approval, continue
+        // the most recent matching assistant message so result chunks can
+        // resolve its tool invocation.
+        for (let i = this.state.messages.length - 1; i >= 0; i--) {
+          const candidate = this.state.messages[i];
+          if (
+            candidate.role === 'assistant' &&
+            candidate.parts.some(
+              part => isToolUIPart(part) && part.state === 'approval-responded',
+            )
+          ) {
+            messageId = candidate.id;
+            break;
+          }
+        }
+      }
+
+      const consumesPendingApproval =
+        messageId != null && messageId === this.pendingApprovalMessageId;
+      const pendingApprovalMessageIndex = consumesPendingApproval
+        ? this.state.messages.findIndex(message => message.id === messageId)
+        : -1;
+
+      await this.makeRequestForToolApproval({
+        messageId,
+        messageIndex: pendingApprovalMessageIndex,
         ...options,
       });
       return;
@@ -489,7 +518,6 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
   }) =>
     this.jobExecutor.run(async () => {
       const messages = this.state.messages;
-      const lastMessage = messages[messages.length - 1];
 
       const updatePart = (
         part: UIMessagePart<UIDataTypes, UITools>,
@@ -504,11 +532,25 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
             }
           : part;
 
-      // update the message to trigger an immediate UI update
-      this.state.replaceMessage(messages.length - 1, {
-        ...lastMessage,
-        parts: lastMessage.parts.map(updatePart),
-      });
+      const messageIndex = messages.findIndex(message =>
+        message.parts.some(
+          part =>
+            isToolUIPart(part) &&
+            part.state === 'approval-requested' &&
+            part.approval.id === id,
+        ),
+      );
+
+      if (messageIndex !== -1) {
+        const message = messages[messageIndex];
+
+        // update the message to trigger an immediate UI update
+        this.state.replaceMessage(messageIndex, {
+          ...message,
+          parts: message.parts.map(updatePart),
+        });
+        this.pendingApprovalMessageId = message.id;
+      }
 
       // update the active response if it exists
       if (this.activeResponse) {
@@ -525,9 +567,14 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         this.shouldSendAutomatically().then(shouldSend => {
           if (shouldSend) {
             // no await to avoid deadlocking
-            this.makeRequest({
-              trigger: 'submit-message',
-              messageId: this.lastMessage?.id,
+            const messageId =
+              messageIndex === -1
+                ? this.lastMessage?.id
+                : messages[messageIndex].id;
+
+            this.makeRequestForToolApproval({
+              messageId,
+              messageIndex,
               ...options,
             });
           }
@@ -610,6 +657,36 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     return result as boolean;
   }
 
+  private async makeRequestForToolApproval({
+    messageId,
+    messageIndex,
+    ...options
+  }: {
+    messageId?: string;
+    messageIndex: number;
+  } & ChatRequestOptions) {
+    const consumesPendingApproval =
+      messageId != null && messageId === this.pendingApprovalMessageId;
+    if (consumesPendingApproval) {
+      this.pendingApprovalMessageId = undefined;
+    }
+
+    await this.makeRequest({
+      trigger: 'submit-message',
+      messageId,
+      ...options,
+    });
+
+    if (
+      consumesPendingApproval &&
+      this.status === 'error' &&
+      this.pendingApprovalMessageId == null
+    ) {
+      this.pendingApprovalMessageId =
+        this.state.messages[messageIndex]?.id ?? messageId;
+    }
+  }
+
   private async makeRequest({
     trigger,
     metadata,
@@ -697,6 +774,18 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     this.setStatus({ status: 'submitted', error: undefined });
 
     const lastMessage = this.lastMessage;
+    const responseMessageIndex =
+      trigger === 'submit-message' && messageId != null
+        ? this.state.messages.findIndex(message => message.id === messageId)
+        : this.state.messages.length - 1;
+    const responseMessage =
+      responseMessageIndex === -1
+        ? lastMessage
+        : this.state.messages[responseMessageIndex];
+    const usesEarlierAssistantMessage =
+      responseMessageIndex !== -1 &&
+      responseMessageIndex < this.state.messages.length - 1 &&
+      responseMessage?.role === 'assistant';
 
     let isAbort = false;
     let isDisconnect = false;
@@ -709,7 +798,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
           lastMessage:
             trigger === 'resume-stream' || trigger === 'regenerate-message'
               ? undefined
-              : this.state.snapshot(lastMessage),
+              : this.state.snapshot(responseMessage),
           messageId: this.generateId(),
         }),
         abortController,
@@ -763,10 +852,12 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
                 this.setStatus({ status: 'streaming' });
               }
 
-              const replaceLastMessage =
-                response.state.message.id === this.lastMessage?.id;
-
-              if (replaceLastMessage) {
+              if (usesEarlierAssistantMessage) {
+                this.state.replaceMessage(
+                  responseMessageIndex,
+                  response.state.message,
+                );
+              } else if (response.state.message.id === this.lastMessage?.id) {
                 this.state.replaceMessage(
                   this.state.messages.length - 1,
                   response.state.message,

package/src/ui/convert-to-model-messages.ts

@@ -204,6 +204,14 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                       type: 'tool-approval-request' as const,
                       approvalId: part.approval.id,
                       toolCallId: part.toolCallId,
+                      ...(Object.prototype.hasOwnProperty.call(
+                        part.approval,
+                        'inputSchemaInput',
+                      )
+                        ? {
+                            inputSchemaInput: part.approval.inputSchemaInput,
+                          }
+                        : {}),
                       ...(part.approval.signature != null
                         ? { signature: part.approval.signature }
                         : {}),

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

@@ -721,6 +721,12 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
                 ...(chunk.approvalDescriptor != null
                   ? { descriptor: chunk.approvalDescriptor }
                   : {}),
+                ...(Object.prototype.hasOwnProperty.call(
+                  chunk,
+                  'inputSchemaInput',
+                )
+                  ? { inputSchemaInput: chunk.inputSchemaInput }
+                  : {}),
                 ...(chunk.signature != null
                   ? { signature: chunk.signature }
                   : {}),

package/src/ui/ui-messages.ts

@@ -263,6 +263,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
         descriptor?: unknown;
         reason?: never;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -277,6 +278,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -293,6 +295,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -309,6 +312,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -323,6 +327,7 @@ export type UIToolInvocation<TOOL extends UITool | Tool> = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
 );
@@ -381,6 +386,7 @@ export type DynamicToolUIPart = {
         descriptor?: unknown;
         reason?: never;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -395,6 +401,7 @@ export type DynamicToolUIPart = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -411,6 +418,7 @@ export type DynamicToolUIPart = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -426,6 +434,7 @@ export type DynamicToolUIPart = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
   | {
@@ -440,6 +449,7 @@ export type DynamicToolUIPart = {
         descriptor?: unknown;
         reason?: string;
         signature?: string;
+        inputSchemaInput?: unknown;
       };
     }
 );