ai 7.0.111 → 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,
@@ -489,7 +439,7 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
 
     if (metadataSchema) {
       for (const [msgIdx, message] of validatedMessages.entries()) {
-        await validateTypes({
+        message.metadata = await validateTypes({
           value: message.metadata,
           schema: metadataSchema,
           context: {
@@ -527,7 +477,7 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
               };
             }
 
-            await validateTypes({
+            dataPart.data = await validateTypes({
               value: dataPart.data,
               schema: dataSchema,
               context: {
@@ -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/handle-ui-message-stream-finish.ts

@@ -147,7 +147,7 @@ export function handleUIMessageStreamFinish<UI_MESSAGE extends UIMessage>({
 
   let finishCalled = false;
 
-  const callOnEnd = async () => {
+  const callOnEnd = async ({ isCancelled }: { isCancelled: boolean }) => {
     if (finishCalled || !resolvedOnEnd) {
       return;
     }
@@ -160,9 +160,11 @@ export function handleUIMessageStreamFinish<UI_MESSAGE extends UIMessage>({
       : declaredOutcome.status === 'unknown' && isAborted
         ? { status: 'aborted' }
         : declaredOutcome;
+    const isConsumerCancellation = isCancelled && outcome.status === 'unknown';
 
     await resolvedOnEnd({
       isAborted: isAborted || outcome.status === 'aborted',
+      ...(isConsumerCancellation ? { isCancelled: true as const } : {}),
       isContinuation,
       outcome,
       responseMessage: state.message as UI_MESSAGE,
@@ -215,11 +217,11 @@ export function handleUIMessageStreamFinish<UI_MESSAGE extends UIMessage>({
       },
       // @ts-expect-error cancel is still new and missing from types https://developer.mozilla.org/en-US/docs/Web/API/TransformStream#browser_compatibility
       async cancel() {
-        await callOnEnd();
+        await callOnEnd({ isCancelled: true });
       },
 
       async flush() {
-        await callOnEnd();
+        await callOnEnd({ isCancelled: false });
       },
     }),
   );

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/ui-message-stream/ui-message-stream-on-end-callback.ts

@@ -20,6 +20,14 @@ export type UIMessageStreamOnEndCallback<UI_MESSAGE extends UIMessage> =
      */
     isAborted: boolean;
 
+    /**
+     * Indicates that the consumer cancelled the stream before an outcome was
+     * declared, for example because the client disconnected.
+     *
+     * This property is only present when it is `true`.
+     */
+    isCancelled?: true;
+
     /**
      * The operation-level outcome of the stream. Fatal stream-processing
      * failures override outcomes declared by the stream owner.

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

@@ -4,6 +4,10 @@
  * This is separate from model finish reasons and individual stream chunks.
  * Fatal stream-processing failures override outcomes declared by the stream
  * owner.
+ *
+ * Consumer cancellation before an outcome is declared keeps the `unknown`
+ * status and is reported separately through the end callback's `isCancelled`
+ * property.
  */
 export type UIMessageStreamOutcome =
   | { status: 'completed' }

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

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