ai 6.0.288 → 6.0.289

package/docs/03-ai-sdk-core/40-middleware.mdx

@@ -282,6 +282,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/release-v6.0/packages/provider/src/language-model/v3/language-model-v3.ts).
    You can modify the parameters, call the language model, and modify the result.
 
+Every `LanguageModelV3Middleware` object must set
+`specificationVersion: 'v3'`.
+
 Here are some examples of how to implement language model middleware:
 
 ## Examples
@@ -302,6 +305,8 @@ import type {
 } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('doGenerate called');
     console.log(`params: ${JSON.stringify(params, null, 2)}`);
@@ -379,6 +384,8 @@ import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 const cache = new Map<string, any>();
 
 export const yourCacheMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     const cacheKey = JSON.stringify(params);
 
@@ -411,6 +418,8 @@ This example shows how to use RAG as middleware.
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export const yourRagMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   transformParams: async ({ params }) => {
     const lastUserMessageText = getLastUserMessageText({
       prompt: params.prompt,
@@ -437,28 +446,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 { LanguageModelV3Middleware } from '@ai-sdk/provider';
+import type {
+  LanguageModelV3Middleware,
+  LanguageModelV3StreamPart,
+} from '@ai-sdk/provider';
+
+const redactText = (text: string) => text.replace(/badword/g, '<REDACTED>');
 
 export const yourGuardrailMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   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<
+      LanguageModelV3StreamPart,
+      LanguageModelV3StreamPart
+    >({
+      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.
@@ -469,6 +552,8 @@ __PROVIDER_IMPORT__;
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV3Middleware = {
+  specificationVersion: 'v3',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('METADATA', params?.providerMetadata?.yourLogMiddleware);
     const result = await doGenerate();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.288",
+  "version": "6.0.289",
   "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",
   "sideEffects": false,
@@ -45,9 +45,9 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@ai-sdk/gateway": "3.0.198",
-    "@ai-sdk/provider": "3.0.16",
-    "@ai-sdk/provider-utils": "4.0.52"
+    "@ai-sdk/gateway": "3.0.199",
+    "@ai-sdk/provider": "3.0.17",
+    "@ai-sdk/provider-utils": "4.0.53"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/generate-text/run-tools-transformation.ts

@@ -261,6 +261,10 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
       });
   }
 
+  // Keep input callbacks in the same transform so input availability cannot
+  // overtake pending start or delta callbacks in a downstream stream.
+  const activeToolCallToolNames = new Map<string, string>();
+
   // forward stream
   const forwardStream = new TransformStream<
     LanguageModelV3StreamPart,
@@ -283,9 +287,6 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
         case 'reasoning-start':
         case 'reasoning-delta':
         case 'reasoning-end':
-        case 'tool-input-start':
-        case 'tool-input-delta':
-        case 'tool-input-end':
         case 'source':
         case 'response-metadata':
         case 'error':
@@ -294,6 +295,39 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
           break;
         }
 
+        case 'tool-input-start': {
+          activeToolCallToolNames.set(chunk.id, chunk.toolName);
+          await tools?.[chunk.toolName]?.onInputStart?.({
+            toolCallId: chunk.id,
+            messages,
+            abortSignal,
+            experimental_context,
+          });
+          controller.enqueue(chunk);
+          break;
+        }
+
+        case 'tool-input-delta': {
+          const toolName = activeToolCallToolNames.get(chunk.id);
+          if (toolName != null) {
+            await tools?.[toolName]?.onInputDelta?.({
+              inputTextDelta: chunk.delta,
+              toolCallId: chunk.id,
+              messages,
+              abortSignal,
+              experimental_context,
+            });
+          }
+          controller.enqueue(chunk);
+          break;
+        }
+
+        case 'tool-input-end': {
+          activeToolCallToolNames.delete(chunk.id);
+          controller.enqueue(chunk);
+          break;
+        }
+
         case 'file': {
           controller.enqueue({
             type: 'file',

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

@@ -1965,8 +1965,6 @@ class DefaultStreamTextResult<
             const stepToolOutputs: ToolOutput<TOOLS>[] = [];
             let warnings: SharedV3Warning[] | undefined;
 
-            const activeToolCallToolNames: Record<string, string> = {};
-
             let stepFinishReason: FinishReason = 'other';
             let stepRawFinishReason: string | undefined = undefined;
 
@@ -2168,18 +2166,7 @@ class DefaultStreamTextResult<
                       }
 
                       case 'tool-input-start': {
-                        activeToolCallToolNames[chunk.id] = chunk.toolName;
-
                         const tool = stepToolSet?.[chunk.toolName];
-                        if (tool?.onInputStart != null) {
-                          await tool.onInputStart({
-                            toolCallId: chunk.id,
-                            messages: stepInputMessages,
-                            abortSignal,
-                            experimental_context,
-                          });
-                        }
-
                         controller.enqueue({
                           ...chunk,
                           dynamic: chunk.dynamic ?? tool?.type === 'dynamic',
@@ -2189,25 +2176,11 @@ class DefaultStreamTextResult<
                       }
 
                       case 'tool-input-end': {
-                        delete activeToolCallToolNames[chunk.id];
                         controller.enqueue(chunk);
                         break;
                       }
 
                       case 'tool-input-delta': {
-                        const toolName = activeToolCallToolNames[chunk.id];
-                        const tool = stepToolSet?.[toolName];
-
-                        if (tool?.onInputDelta != null) {
-                          await tool.onInputDelta({
-                            inputTextDelta: chunk.delta,
-                            toolCallId: chunk.id,
-                            messages: stepInputMessages,
-                            abortSignal,
-                            experimental_context,
-                          });
-                        }
-
                         controller.enqueue(chunk);
                         break;
                       }

package/src/prompt/convert-to-language-model-prompt.ts

@@ -492,8 +492,11 @@ function convertPartToLanguageModelPart(
       throw new Error(`Unsupported part type: ${type}`);
   }
 
-  const { data: convertedData, mediaType: convertedMediaType } =
-    convertToLanguageModelV3DataContent(originalData);
+  const {
+    data: convertedData,
+    mediaType: convertedMediaType,
+    originalUrl,
+  } = convertToLanguageModelV3DataContent(originalData);
 
   let mediaType: string | undefined = convertedMediaType ?? part.mediaType;
   let data: Uint8Array | string | URL = convertedData; // binary | base64 | url
@@ -525,6 +528,7 @@ function convertPartToLanguageModelPart(
         mediaType: mediaType ?? 'image/*', // any image
         filename: undefined,
         data,
+        ...(data instanceof URL && originalUrl != null ? { originalUrl } : {}),
         providerOptions: part.providerOptions,
       };
     }
@@ -540,6 +544,7 @@ function convertPartToLanguageModelPart(
         mediaType,
         filename: part.filename,
         data,
+        ...(data instanceof URL && originalUrl != null ? { originalUrl } : {}),
         providerOptions: part.providerOptions,
       };
     }

package/src/prompt/data-content.ts

@@ -28,7 +28,10 @@ export function convertToLanguageModelV3DataContent(
 ): {
   data: LanguageModelV3DataContent;
   mediaType: string | undefined;
+  originalUrl?: string;
 } {
+  let originalUrl: string | undefined;
+
   // Buffer & Uint8Array:
   if (content instanceof Uint8Array) {
     return { data: content, mediaType: undefined };
@@ -43,7 +46,9 @@ export function convertToLanguageModelV3DataContent(
   // is not a URL and likely some other sort of data.
   if (typeof content === 'string') {
     try {
-      content = new URL(content);
+      const url = new URL(content);
+      originalUrl = url.toString() !== content ? content : undefined;
+      content = url;
     } catch (error) {
       // ignored
     }
@@ -65,7 +70,11 @@ export function convertToLanguageModelV3DataContent(
     return { data: base64Content, mediaType: dataUrlMediaType };
   }
 
-  return { data: content, mediaType: undefined };
+  return {
+    data: content,
+    mediaType: undefined,
+    ...(originalUrl != null ? { originalUrl } : {}),
+  };
 }
 
 /**

package/src/ui/http-chat-transport.ts

@@ -191,7 +191,7 @@ export abstract class HttpChatTransport<
     const response = await fetch(api, {
       method: 'POST',
       headers: {
-        'Content-Type': 'application/json',
+        'content-type': 'application/json',
         ...headers,
       },
       body: JSON.stringify(body),

package/src/ui/last-assistant-message-is-complete-with-approval-responses.ts

@@ -35,7 +35,7 @@ export function lastAssistantMessageIsCompleteWithApprovalResponses({
     // all tool approvals must have a response
     lastStepToolInvocations.every(
       part =>
-        part.state === 'output-available' ||
+        (part.state === 'output-available' && part.preliminary !== true) ||
         part.state === 'output-error' ||
         part.state === 'output-denied' ||
         part.state === 'approval-responded',

package/src/ui/last-assistant-message-is-complete-with-tool-calls.ts

@@ -33,7 +33,8 @@ export function lastAssistantMessageIsCompleteWithToolCalls({
     lastStepToolInvocations.length > 0 &&
     lastStepToolInvocations.every(
       part =>
-        part.state === 'output-available' || part.state === 'output-error',
+        (part.state === 'output-available' && part.preliminary !== true) ||
+        part.state === 'output-error',
     )
   );
 }