ai 7.0.111 → 7.0.112

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/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.112",
   "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.90",
+    "@ai-sdk/provider": "4.0.18",
+    "@ai-sdk/provider-utils": "5.0.46"
   },
   "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.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/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.5",
+    "@ai-sdk/xai": "5.0.6",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

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/prompt/convert-to-language-model-prompt.ts

@@ -661,6 +661,7 @@ export function mapToolResultOutput({
         }
         case 'file-url': {
           const mediaType = item.mediaType ?? getMediaTypeFromUrl(item.url);
+          const url = new URL(item.url);
           let message = `The "file-url" type for tool result content is deprecated. Use the "file" type with mediaType and { type: 'url', url } instead.`;
           if (!item.mediaType) {
             const inferenceSuffix =
@@ -676,7 +677,11 @@ export function mapToolResultOutput({
           });
           return {
             type: 'file' as const,
-            data: { type: 'url' as const, url: new URL(item.url) },
+            data: {
+              type: 'url' as const,
+              url,
+              ...(url.toString() !== item.url ? { originalUrl: item.url } : {}),
+            },
             mediaType,
             providerOptions: item.providerOptions,
           };
@@ -732,6 +737,7 @@ export function mapToolResultOutput({
           };
         }
         case 'image-url': {
+          const url = new URL(item.url);
           warnings.push({
             type: 'deprecated',
             setting: '"tool-result" content of type "image-url"',
@@ -739,7 +745,11 @@ export function mapToolResultOutput({
           });
           return {
             type: 'file' as const,
-            data: { type: 'url' as const, url: new URL(item.url) },
+            data: {
+              type: 'url' as const,
+              url,
+              ...(url.toString() !== item.url ? { originalUrl: item.url } : {}),
+            },
             mediaType: 'image',
             providerOptions: item.providerOptions,
           };

package/src/prompt/file-part-data.ts

@@ -41,6 +41,16 @@ function convertUrlToFilePartData(url: URL): ConvertResult {
   return { data: { type: 'url', url }, mediaType: undefined };
 }
 
+function convertUrlStringToFilePartData(content: string): ConvertResult {
+  const result = convertUrlToFilePartData(new URL(content));
+
+  if (result.data.type === 'url' && result.data.url.toString() !== content) {
+    result.data.originalUrl = content;
+  }
+
+  return result;
+}
+
 function convertInlineDataToFilePartData(content: DataContent): ConvertResult {
   if (content instanceof Uint8Array) {
     return { data: { type: 'data', data: content }, mediaType: undefined };
@@ -108,7 +118,7 @@ export function convertToLanguageModelV4FilePart(
 
   if (typeof content === 'string') {
     try {
-      return convertUrlToFilePartData(new URL(content));
+      return convertUrlStringToFilePartData(content);
     } catch {
       return convertInlineDataToFilePartData(content);
     }

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

@@ -489,7 +489,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 +527,7 @@ async function safeValidateUIMessagesInternal<UI_MESSAGE extends UIMessage>(
               };
             }
 
-            await validateTypes({
+            dataPart.data = await validateTypes({
               value: dataPart.data,
               schema: dataSchema,
               context: {

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/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' }