ai 7.0.112 → 7.0.113

package/src/ui/validate-ui-messages.ts

@@ -5,11 +5,13 @@ import {
   validateTypes,
   zodSchema,
   type FlexibleSchema,
+  type MaybePromiseLike,
   type Tool,
 } from '@ai-sdk/provider-utils';
 import { InvalidArgumentError } from '../error';
 import { jsonValueSchema } from '../types/json-value';
 import { getOwn } from '../util/get-own';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import { providerMetadataSchema } from '../types/provider-metadata';
 import { z, type ZodType } from '../util/zod';
 import type {
@@ -48,8 +50,38 @@ function asDynamicToolPart(toolPart: ToolUIPart): DynamicToolUIPart {
   } as DynamicToolUIPart;
 }
 
-const uiMessagesSchema = lazySchema(() =>
-  zodSchema(
+function getToolPartInputSchemaInput(
+  toolPart: ToolUIPart,
+): { value: unknown } | undefined {
+  return toolPart.approval != null &&
+    Object.prototype.hasOwnProperty.call(toolPart.approval, 'inputSchemaInput')
+    ? { value: toolPart.approval.inputSchemaInput }
+    : undefined;
+}
+
+const uiMessagesSchema = lazySchema(() => {
+  const approvalRequestedSchema = z.object({
+    id: z.string(),
+    approved: z.never().optional(),
+    descriptor: z.unknown().optional(),
+    requestReason: z.string().optional(),
+    reason: z.never().optional(),
+    isAutomatic: z.boolean().optional(),
+    signature: z.string().optional(),
+    inputSchemaInput: z.unknown().optional(),
+  });
+  const approvalRespondedSchema = approvalRequestedSchema.extend({
+    approved: z.boolean(),
+    reason: z.string().optional(),
+  });
+  const approvalGrantedSchema = approvalRespondedSchema.extend({
+    approved: z.literal(true),
+  });
+  const approvalDeniedSchema = approvalRespondedSchema.extend({
+    approved: z.literal(false),
+  });
+
+  return zodSchema(
     z
       .array(
         z
@@ -154,15 +186,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.never().optional(),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.never().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalRequestedSchema,
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
@@ -176,15 +200,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.boolean(),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.string().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalRespondedSchema,
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
@@ -200,17 +216,7 @@ const uiMessagesSchema = lazySchema(() =>
                   callProviderMetadata: providerMetadataSchema.optional(),
                   resultProviderMetadata: providerMetadataSchema.optional(),
                   preliminary: z.boolean().optional(),
-                  approval: z
-                    .object({
-                      id: z.string(),
-                      approved: z.literal(true),
-                      descriptor: z.unknown().optional(),
-                      requestReason: z.string().optional(),
-                      reason: z.string().optional(),
-                      isAutomatic: z.boolean().optional(),
-                      signature: z.string().optional(),
-                    })
-                    .optional(),
+                  approval: approvalGrantedSchema.optional(),
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
@@ -226,17 +232,7 @@ const uiMessagesSchema = lazySchema(() =>
                   errorText: z.string(),
                   callProviderMetadata: providerMetadataSchema.optional(),
                   resultProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z
-                    .object({
-                      id: z.string(),
-                      approved: z.literal(true),
-                      descriptor: z.unknown().optional(),
-                      requestReason: z.string().optional(),
-                      reason: z.string().optional(),
-                      isAutomatic: z.boolean().optional(),
-                      signature: z.string().optional(),
-                    })
-                    .optional(),
+                  approval: approvalGrantedSchema.optional(),
                 }),
                 z.object({
                   type: z.literal('dynamic-tool'),
@@ -250,15 +246,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.literal(false),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.string().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalDeniedSchema,
                 }),
                 z.object({
                   type: z.string().startsWith('tool-'),
@@ -297,15 +285,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.never().optional(),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.never().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalRequestedSchema,
                 }),
                 z.object({
                   type: z.string().startsWith('tool-'),
@@ -318,15 +298,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.boolean(),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.string().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalRespondedSchema,
                 }),
                 z.object({
                   type: z.string().startsWith('tool-'),
@@ -341,17 +313,7 @@ const uiMessagesSchema = lazySchema(() =>
                   callProviderMetadata: providerMetadataSchema.optional(),
                   resultProviderMetadata: providerMetadataSchema.optional(),
                   preliminary: z.boolean().optional(),
-                  approval: z
-                    .object({
-                      id: z.string(),
-                      approved: z.literal(true),
-                      descriptor: z.unknown().optional(),
-                      requestReason: z.string().optional(),
-                      reason: z.string().optional(),
-                      isAutomatic: z.boolean().optional(),
-                      signature: z.string().optional(),
-                    })
-                    .optional(),
+                  approval: approvalGrantedSchema.optional(),
                 }),
                 z.object({
                   type: z.string().startsWith('tool-'),
@@ -366,17 +328,7 @@ const uiMessagesSchema = lazySchema(() =>
                   errorText: z.string(),
                   callProviderMetadata: providerMetadataSchema.optional(),
                   resultProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z
-                    .object({
-                      id: z.string(),
-                      approved: z.literal(true),
-                      descriptor: z.unknown().optional(),
-                      requestReason: z.string().optional(),
-                      reason: z.string().optional(),
-                      isAutomatic: z.boolean().optional(),
-                      signature: z.string().optional(),
-                    })
-                    .optional(),
+                  approval: approvalGrantedSchema.optional(),
                 }),
                 z.object({
                   type: z.string().startsWith('tool-'),
@@ -389,15 +341,7 @@ const uiMessagesSchema = lazySchema(() =>
                   output: z.never().optional(),
                   errorText: z.never().optional(),
                   callProviderMetadata: providerMetadataSchema.optional(),
-                  approval: z.object({
-                    id: z.string(),
-                    approved: z.literal(false),
-                    descriptor: z.unknown().optional(),
-                    requestReason: z.string().optional(),
-                    reason: z.string().optional(),
-                    isAutomatic: z.boolean().optional(),
-                    signature: z.string().optional(),
-                  }),
+                  approval: approvalDeniedSchema,
                 }),
               ]),
             ),
@@ -417,8 +361,8 @@ const uiMessagesSchema = lazySchema(() =>
           }),
       )
       .nonempty('Messages array must not be empty'),
-  ),
-);
+  );
+});
 
 export type SafeValidateUIMessagesResult<UI_MESSAGE extends UIMessage> =
   | {
@@ -453,6 +397,11 @@ type ValidateUIMessagesOptions<UI_MESSAGE extends UIMessage> = {
           >;
         };
   };
+  experimental_refineToolInput?: {
+    [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: (
+      input: InferUIMessageTools<UI_MESSAGE>[NAME]['input'],
+    ) => MaybePromiseLike<InferUIMessageTools<UI_MESSAGE>[NAME]['input']>;
+  };
 };
 
 async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
@@ -461,6 +410,7 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
     metadataSchema,
     dataSchemas,
     tools,
+    experimental_refineToolInput,
   }: ValidateUIMessagesOptions<UI_MESSAGE>,
   {
     convertMissingTerminalToolsToDynamic,
@@ -583,49 +533,65 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
               entityName: toolName,
               entityId: toolPart.toolCallId,
             };
+            const inputSchemaInput = getToolPartInputSchemaInput(toolPart);
+            const inputToValidate =
+              inputSchemaInput == null
+                ? toolPart.input
+                : inputSchemaInput.value;
             let convertToDynamic = false;
 
             // Tool input validation
-            if (toolPart.state === 'output-error') {
-              // Failed calls can retain invalid input. Keep them loadable, but
-              // expose incompatible input as unknown instead of the current
-              // static tool input type.
-              if (toolPart.input !== undefined) {
-                const result = await safeValidateTypes({
-                  value: toolPart.input,
-                  schema: tool.inputSchema,
-                  context: inputValidationContext,
-                });
-                convertToDynamic = !result.success;
-              }
-            } else if (toolPart.state === 'output-available') {
+            if (
+              toolPart.state !== 'input-streaming' &&
+              (toolPart.state !== 'output-error' ||
+                inputSchemaInput != null ||
+                toolPart.input !== undefined)
+            ) {
               const result = await safeValidateTypes({
-                value: toolPart.input,
+                value: inputToValidate,
                 schema: tool.inputSchema,
                 context: inputValidationContext,
               });
 
+              let inputError: TypeValidationError | undefined;
               if (!result.success) {
-                // Empty terminal input can represent aborted or incomplete
-                // history whose input was never streamed. Preserve it without
-                // claiming that it matches the current static input type.
-                if (isEmptyObject(toolPart.input)) {
+                inputError = result.error;
+              } else if (inputSchemaInput != null) {
+                try {
+                  const refine = getOwn(experimental_refineToolInput, toolName);
+                  const reconstructedInput =
+                    refine == null ? result.value : await refine(result.value);
+
+                  if (!isDeepEqualData(reconstructedInput, toolPart.input)) {
+                    inputError = new TypeValidationError({
+                      value: toolPart.input,
+                      cause:
+                        'Tool input does not match the output reconstructed from inputSchemaInput.',
+                      context: inputValidationContext,
+                    });
+                  }
+                } catch (error) {
+                  inputError = new TypeValidationError({
+                    value: inputToValidate,
+                    cause: error,
+                    context: inputValidationContext,
+                  });
+                }
+              }
+
+              if (inputError != null) {
+                // Failed calls and empty terminal inputs must remain loadable,
+                // but must not claim to match the current static input type.
+                if (
+                  toolPart.state === 'output-error' ||
+                  (toolPart.state === 'output-available' &&
+                    isEmptyObject(toolPart.input))
+                ) {
                   convertToDynamic = true;
                 } else {
-                  throw result.error;
+                  throw inputError;
                 }
               }
-            } else if (
-              toolPart.state === 'input-available' ||
-              toolPart.state === 'approval-requested' ||
-              toolPart.state === 'approval-responded' ||
-              toolPart.state === 'output-denied'
-            ) {
-              await validateTypes({
-                value: toolPart.input,
-                schema: tool.inputSchema,
-                context: inputValidationContext,
-              });
             }
 
             // Tool output validation

package/src/ui-message-stream/to-ui-message-chunk.ts

@@ -1,10 +1,12 @@
 import type { ToolSet } from '@ai-sdk/provider-utils';
 import type { TextStreamPart } from '../generate-text/stream-text-result';
+import { getToolCallInputSchemaInput } from '../generate-text/tool-call';
 import type {
   InferUIMessageData,
   InferUIMessageMetadata,
   UIMessage,
 } from '../ui/ui-messages';
+import { isDeepEqualData } from '../util/is-deep-equal-data';
 import type { InferUIMessageChunk, UIMessageChunk } from './ui-message-chunks';
 
 export type ToUIMessageChunkOptions<
@@ -250,10 +252,15 @@ export function toUIMessageChunk<
     }
 
     case 'tool-approval-request': {
+      const inputSchemaInput = getToolCallInputSchemaInput(part.toolCall);
       return {
         type: 'tool-approval-request',
         approvalId: part.approvalId,
         toolCallId: part.toolCall.toolCallId,
+        ...(inputSchemaInput != null &&
+        !isDeepEqualData(inputSchemaInput.value, part.toolCall.input)
+          ? { inputSchemaInput: inputSchemaInput.value }
+          : {}),
         ...(part.reason != null ? { reason: part.reason } : {}),
         ...(part.isAutomatic != null ? { isAutomatic: part.isAutomatic } : {}),
         ...(part.signature != null ? { signature: part.signature } : {}),

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

@@ -86,6 +86,7 @@ export const uiMessageChunkSchema = lazySchema(() =>
         approvalId: z.string(),
         toolCallId: z.string(),
         approvalDescriptor: z.unknown().optional(),
+        inputSchemaInput: z.unknown().optional(),
         reason: z.string().optional(),
         isAutomatic: z.boolean().optional(),
         signature: z.string().optional(),
@@ -301,6 +302,7 @@ export type UIMessageChunk<
       approvalId: string;
       toolCallId: string;
       approvalDescriptor?: unknown;
+      inputSchemaInput?: unknown;
       reason?: string;
       isAutomatic?: boolean;
       signature?: string;

package/src/util/write-to-server-response.ts

@@ -51,8 +51,6 @@ export function writeToServerResponse({
           });
         }
       }
-    } catch (error) {
-      throw error;
     } finally {
       response.end();
     }