ai 6.0.219 → 6.0.221

package/dist/internal/index.js

@@ -152,7 +152,7 @@ function detectMediaType({
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.219" : "0.0.0-test";
+var VERSION = true ? "6.0.221" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -132,7 +132,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.219" : "0.0.0-test";
+var VERSION = true ? "6.0.221" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/02-foundations/02-providers-and-models.mdx

@@ -82,7 +82,7 @@ The open-source community has created the following providers:
 - [Browser AI Provider](/providers/community-providers/browser-ai) (`browser-ai`)
 - [Gemini CLI Provider](/providers/community-providers/gemini-cli) (`ai-sdk-provider-gemini-cli`)
 - [A2A Provider](/providers/community-providers/a2a) (`a2a-ai-provider`)
-- [SAP-AI Provider](/providers/community-providers/sap-ai) (`@mymediset/sap-ai-provider`)
+- [SAP AI Core Provider](/providers/community-providers/sap-ai) (`@jerome-benoit/sap-ai-provider`)
 - [AI/ML API Provider](/providers/community-providers/aimlapi) (`@ai-ml.api/aimlapi-vercel-ai`)
 - [MCP Sampling Provider](/providers/community-providers/mcp-sampling) (`@mcpc-tech/mcp-sampling-ai-provider`)
 - [ACP Provider](/providers/community-providers/acp) (`@mcpc-tech/acp-ai-provider`)

package/docs/03-agents/06-memory.mdx

@@ -207,6 +207,55 @@ The `bankId` identifies the memory store and is typically a user ID. In multi-us
 
 See the [Hindsight provider documentation](/providers/community-providers/hindsight) for full setup and configuration.
 
+### MongoDB
+
+[`@mongodb-developer/vercel-ai-memory`](https://www.npmjs.com/package/@mongodb-developer/vercel-ai-memory) provides MongoDB Atlas-backed persistent memory with five structured tiers: **Session**, **Semantic**, **Procedural**, **Episodic**, and **Scratchpad**. Retrieval is powered by Atlas Vector Search using any AI SDK embedding model, with automatic index creation and per-type retention policies.
+
+```bash
+pnpm add @mongodb-developer/vercel-ai-memory
+```
+
+This integration targets AI SDK v6 because it relies on v6 APIs such as `ModelMessage`, `ToolLoopAgent`, and `isLoopFinished()`:
+
+```json
+{
+  "peerDependencies": {
+    "ai": "^6.0.0",
+    "mongodb": "^6.0.0",
+    "zod": "^3.0.0"
+  }
+}
+```
+
+```ts
+import { createMongoDBMemory } from '@mongodb-developer/vercel-ai-memory';
+import { openai } from '@ai-sdk/openai';
+import { ToolLoopAgent, isLoopFinished } from 'ai';
+
+// Create the memory instance once at module/server level
+const mongodbMemory = createMongoDBMemory({
+  uri: process.env.MONGODB_URI!,
+  embedder: openai.embedding('text-embedding-3-small'),
+});
+
+// Scope to a user and session per request
+const agent = new ToolLoopAgent({
+  model: openai('gpt-4.1'),
+  tools: mongodbMemory({ userId: 'alice', sessionId: 'sess-001' }),
+  stopWhen: isLoopFinished(),
+});
+
+const result = await agent.generate({
+  prompt: 'My name is Alice and I love hiking. Remember that.',
+});
+```
+
+`isLoopFinished()` lets the agent keep running until the tool loop naturally finishes, which is useful when memory tools need to read and write before the final response.
+
+Session memory supports two modes: **tool-driven** (the LLM decides when to read/write — good for prototypes) and **hook-driven** (the runtime persists every turn via `prepareCall` + `onFinish` hooks — recommended for production). The other memory tiers (semantic, procedural, episodic, scratchpad) are always LLM-controlled and selective by design.
+
+MongoDB memory works with any AI SDK model and embedding provider, with no vendor lock-in beyond MongoDB Atlas.
+
 **When to use memory providers**: these providers are a good fit when you want memory without building any storage infrastructure. The tradeoff is that the provider controls memory behavior, so you have less visibility into what gets stored and how it is retrieved. You also take on a dependency on an external service.
 
 ## Custom Tool

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

@@ -307,9 +307,13 @@ export const yourLogMiddleware: LanguageModelV3Middleware = {
     console.log(`params: ${JSON.stringify(params, null, 2)}`);
 
     const result = await doGenerate();
+    const generatedText = result.content
+      .filter(part => part.type === 'text')
+      .map(part => part.text)
+      .join('');
 
     console.log('doGenerate finished');
-    console.log(`generated text: ${result.text}`);
+    console.log(`generated text: ${generatedText}`);
 
     return result;
   },
@@ -437,12 +441,16 @@ import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
 export const yourGuardrailMiddleware: LanguageModelV3Middleware = {
   wrapGenerate: async ({ doGenerate }) => {
-    const { text, ...rest } = await doGenerate();
+    const result = await doGenerate();
 
     // filtering approach, e.g. for PII or other sensitive information:
-    const cleanedText = text?.replace(/badword/g, '<REDACTED>');
+    const content = result.content.map(part =>
+      part.type === 'text'
+        ? { ...part, text: part.text.replace(/badword/g, '<REDACTED>') }
+        : part,
+    );
 
-    return { text: cleanedText, ...rest };
+    return { ...result, content };
   },
 
   // here you would implement the guardrail logic for streaming

package/docs/04-ai-sdk-ui/03-chatbot-message-persistence.mdx

@@ -345,11 +345,20 @@ By default, message IDs are generated client-side:
 - AI response message IDs are generated by `streamText` on the server
 
 For applications without persistence, client-side ID generation works perfectly.
-However, **for persistence, you need server-side generated IDs** to ensure consistency across sessions and prevent ID conflicts when messages are stored and retrieved.
+However, **for persistence, you should use IDs that are stable before messages
+are stored** to ensure consistency across sessions and prevent ID conflicts when
+messages are restored.
+
+The server-side options below control IDs for generated assistant response
+messages. User message IDs are created by `useChat` before the request is sent
+to your API route, so keep those client-generated IDs when saving incoming
+request messages, or generate and persist your own user message IDs before
+sending/storing them.
 
 ### Setting Up Server-side ID Generation
 
-When implementing persistence, you have two options for generating server-side IDs:
+When implementing persistence, you have two options for generating server-side
+IDs for assistant response messages:
 
 1. **Using `generateMessageId` in `toUIMessageStreamResponse`**
 2. **Setting IDs in your start message part with `createUIMessageStream`**

package/docs/06-advanced/10-vercel-deployment-guide.mdx

@@ -40,7 +40,7 @@ You can create a GitHub repository from within your terminal, or on [github.com]
 
 To create your GitHub repository:
 
-1. Navigate to [github.com](http://github.com/)
+1. Navigate to [github.com](https://github.com/)
 2. In the top right corner, click the "plus" icon and select "New repository"
 3. Pick a name for your repository (this can be anything)
 4. Click "Create repository"

package/docs/07-reference/01-ai-sdk-core/20-tool.mdx

@@ -139,7 +139,7 @@ export const weatherTool = tool({
               isOptional: true,
               type: '({toolCallId: string; input: INPUT; output: OUTPUT}) => ToolResultOutput | PromiseLike<ToolResultOutput>',
               description:
-                'Optional conversion function that maps the tool result to an output that can be used by the language model. If not provided, the tool result will be sent as a JSON object.',
+                'Optional conversion function that maps the tool result to an output that can be used by the language model. If not provided, the tool result will be sent as a JSON object. This function is invoked on the server by "convertToModelMessages", so ensure that you pass the same "tools" (ToolSet) to both "convertToModelMessages" and "streamText" (or other generation APIs).',
             },
             {
               name: 'onInputStart',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.219",
+  "version": "6.0.221",
   "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.143",
+    "@ai-sdk/gateway": "3.0.145",
     "@ai-sdk/provider": "3.0.13",
-    "@ai-sdk/provider-utils": "4.0.35"
+    "@ai-sdk/provider-utils": "4.0.37"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/agent/tool-loop-agent-settings.ts

@@ -151,6 +151,16 @@ export type ToolLoopAgentSettings<
    * Prepare the parameters for the generateText or streamText call.
    *
    * You can use this to have templates based on call options.
+   *
+   * The design requires you to pass call parameters as follows to
+   * allow for the removal of parameters from the original settings
+   * by setting them to `undefined`:
+   *
+   * ```
+   *   prepareCall: ({ options, ...rest }) => ({
+   *     ...rest,
+   *   }),
+   * ```
    */
   prepareCall?: (
     options: Omit<

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

@@ -52,6 +52,7 @@ import { asArray } from '../util/as-array';
 import type { DownloadFunction } from '../util/download/download-function';
 import { mergeObjects } from '../util/merge-objects';
 import { prepareRetries } from '../util/prepare-retries';
+import { setAbortTimeout } from '../util/set-abort-timeout';
 import { VERSION } from '../version';
 import type {
   OnFinishEvent,
@@ -684,10 +685,11 @@ export async function generateText<
 
         do {
           // Set up step timeout if configured
-          const stepTimeoutId =
-            stepTimeoutMs != null
-              ? setTimeout(() => stepAbortController!.abort(), stepTimeoutMs)
-              : undefined;
+          const stepTimeoutId = setAbortTimeout({
+            abortController: stepAbortController,
+            label: 'Step',
+            timeoutMs: stepTimeoutMs,
+          });
 
           try {
             const stepInputMessages = [...initialMessages, ...responseMessages];

package/src/generate-text/output.ts

@@ -278,6 +278,7 @@ export const array = <ELEMENT>({
         });
       }
 
+      const validatedElements: Array<ELEMENT> = [];
       for (const element of outerValue.elements) {
         const validationResult = await safeValidateTypes({
           value: element,
@@ -294,9 +295,11 @@ export const array = <ELEMENT>({
             finishReason: context.finishReason,
           });
         }
+
+        validatedElements.push(validationResult.value);
       }
 
-      return outerValue.elements as Array<ELEMENT>;
+      return validatedElements;
     },
 
     async parsePartialOutput({ text }: { text: string }) {

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

@@ -171,10 +171,8 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
   // keep track of outstanding tool results for stream closing:
   const outstandingToolResults = new Set<string>();
 
-  // keep track of tool inputs for provider-side tool results
-  const toolInputs = new Map<string, unknown>();
-
   // keep track of parsed tool calls so provider-emitted approval requests can reference them
+  // keep track of tool inputs for provider-side tool results
   const toolCallsByToolCallId = new Map<string, TypedToolCall<TOOLS>>();
 
   let canClose = false;
@@ -349,8 +347,6 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
               break;
             }
 
-            toolInputs.set(toolCall.toolCallId, toolCall.input);
-
             // Only execute tools that are not provider-executed:
             if (tool.execute != null && toolCall.providerExecuted !== true) {
               const toolExecutionId = generateId(); // use our own id to guarantee uniqueness
@@ -405,7 +401,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
               type: 'tool-error',
               toolCallId: chunk.toolCallId,
               toolName,
-              input: toolInputs.get(chunk.toolCallId),
+              input: toolCall?.input,
               providerExecuted: true,
               error: chunk.result,
               dynamic: chunk.dynamic,
@@ -421,7 +417,7 @@ export function runToolsTransformation<TOOLS extends ToolSet>({
               type: 'tool-result',
               toolCallId: chunk.toolCallId,
               toolName,
-              input: toolInputs.get(chunk.toolCallId),
+              input: toolCall?.input,
               output: chunk.result,
               providerExecuted: true,
               dynamic: chunk.dynamic,

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

@@ -82,6 +82,7 @@ import { mergeAbortSignals } from '../util/merge-abort-signals';
 import { mergeObjects } from '../util/merge-objects';
 import { now as originalNow } from '../util/now';
 import { prepareRetries } from '../util/prepare-retries';
+import { setAbortTimeout } from '../util/set-abort-timeout';
 import { collectToolApprovals } from './collect-tool-approvals';
 import { validateApprovedToolApprovals } from './validate-tool-approvals';
 import type {
@@ -1567,25 +1568,25 @@ class DefaultStreamTextResult<
           const includeRawChunks = self.includeRawChunks;
 
           // Set up step timeout if configured
-          const stepTimeoutId =
-            stepTimeoutMs != null
-              ? setTimeout(() => stepAbortController!.abort(), stepTimeoutMs)
-              : undefined;
+          const stepTimeoutId = setAbortTimeout({
+            abortController: stepAbortController,
+            label: 'Step',
+            timeoutMs: stepTimeoutMs,
+          });
 
           // Set up chunk timeout tracking (will be reset on each chunk)
           let chunkTimeoutId: ReturnType<typeof setTimeout> | undefined =
             undefined;
 
           function resetChunkTimeout() {
-            if (chunkTimeoutMs != null) {
-              if (chunkTimeoutId != null) {
-                clearTimeout(chunkTimeoutId);
-              }
-              chunkTimeoutId = setTimeout(
-                () => chunkAbortController!.abort(),
-                chunkTimeoutMs,
-              );
+            if (chunkTimeoutId != null) {
+              clearTimeout(chunkTimeoutId);
             }
+            chunkTimeoutId = setAbortTimeout({
+              abortController: chunkAbortController,
+              label: 'Chunk',
+              timeoutMs: chunkTimeoutMs,
+            });
           }
 
           function clearChunkTimeout() {
@@ -1601,6 +1602,13 @@ class DefaultStreamTextResult<
             }
           }
 
+          // The step's stream is registered lazily and consumed long after this
+          // function returns, so the step timer must stay armed past setup. When
+          // the merged abort signal fires (any step/chunk/total timeout or caller
+          // abort), drop both step-scoped timers so neither outlives the step.
+          abortSignal?.addEventListener('abort', clearStepTimeout);
+          abortSignal?.addEventListener('abort', clearChunkTimeout);
+
           try {
             stepFinish = new DelayedPromise<void>();
 
@@ -2244,9 +2252,12 @@ class DefaultStreamTextResult<
                 }),
               ),
             );
-          } finally {
+          } catch (error) {
+            // Setup failed before the stream was registered, so neither the
+            // stream's flush nor an abort will clear the timers — clear them here.
             clearStepTimeout();
             clearChunkTimeout();
+            throw error;
           }
         }
 

package/src/generate-text/to-response-messages.ts

@@ -19,6 +19,7 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
   tools: TOOLS | undefined;
 }): Promise<Array<AssistantModelMessage | ToolModelMessage>> {
   const responseMessages: Array<AssistantModelMessage | ToolModelMessage> = [];
+  const toolCallOrder = new Map<string, number>();
 
   const content: AssistantContent = [];
   for (const part of inputContent) {
@@ -64,6 +65,9 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
         });
         break;
       case 'tool-call':
+        if (!toolCallOrder.has(part.toolCallId)) {
+          toolCallOrder.set(part.toolCallId, toolCallOrder.size);
+        }
         content.push({
           type: 'tool-call',
           toolCallId: part.toolCallId,
@@ -157,9 +161,49 @@ export async function toResponseMessages<TOOLS extends ToolSet>({
   if (toolResultContent.length > 0) {
     responseMessages.push({
       role: 'tool',
-      content: toolResultContent,
+      content: sortToolResultContentByToolCallOrder({
+        toolResultContent,
+        toolCallOrder,
+      }),
     });
   }
 
   return responseMessages;
 }
+
+function sortToolResultContentByToolCallOrder({
+  toolResultContent,
+  toolCallOrder,
+}: {
+  toolResultContent: ToolContent;
+  toolCallOrder: Map<string, number>;
+}): ToolContent {
+  const sortedToolResults = toolResultContent
+    .filter(part => part.type === 'tool-result')
+    .map((part, index) => ({ part, index }))
+    .sort((a, b) => {
+      const aOrder = toolCallOrder.get(a.part.toolCallId);
+      const bOrder = toolCallOrder.get(b.part.toolCallId);
+
+      if (aOrder == null && bOrder == null) {
+        return a.index - b.index;
+      }
+
+      if (aOrder == null) {
+        return 1;
+      }
+
+      if (bOrder == null) {
+        return -1;
+      }
+
+      return aOrder - bOrder || a.index - b.index;
+    })
+    .map(({ part }) => part);
+
+  let toolResultIndex = 0;
+
+  return toolResultContent.map(part =>
+    part.type === 'tool-result' ? sortedToolResults[toolResultIndex++] : part,
+  );
+}

package/src/middleware/extract-json-middleware.ts

@@ -15,6 +15,10 @@ function defaultTransform(text: string): string {
     .trim();
 }
 
+function stripMarkdownCodeFenceSuffix(text: string): string {
+  return text.replace(/\n?```\s*$/, '').trimEnd();
+}
+
 /**
  * Middleware that extracts JSON from text content by stripping
  * markdown code fences and other formatting.
@@ -169,10 +173,15 @@ export function extractJsonMiddleware(options?: {
                     remaining = transform(remaining);
                   } else if (block.prefixStripped) {
                     // strip suffix since prefix already handled
-                    remaining = remaining.replace(/\n?```\s*$/, '').trimEnd();
-                  } else {
-                    // Apply full transform (handles both prefix and suffix)
+                    remaining = stripMarkdownCodeFenceSuffix(remaining);
+                  } else if (block.phase === 'prefix') {
+                    // No text has streamed yet, so the full transform is safe.
                     remaining = transform(remaining);
+                  } else {
+                    // Only strip the suffix. Since earlier text may already have
+                    // streamed, trimming the remaining suffix would remove valid
+                    // leading whitespace at the stream boundary.
+                    remaining = stripMarkdownCodeFenceSuffix(remaining);
                   }
 
                   if (remaining.length > 0) {

package/src/ui/chat.ts

@@ -494,7 +494,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
           ? {
               ...part,
               state: 'approval-responded',
-              approval: { id, approved, reason },
+              approval: { ...part.approval, id, approved, reason },
             }
           : part;
 

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

@@ -246,10 +246,12 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
               }
             }
 
-            modelMessages.push({
-              role: 'assistant',
-              content,
-            });
+            if (content.length > 0) {
+              modelMessages.push({
+                role: 'assistant',
+                content,
+              });
+            }
 
             // check if there are tool invocations with results in the block
             // Include non-provider-executed tools, OR provider-executed tools with approval responses
@@ -297,7 +299,7 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                           type: 'error-text' as const,
                           value:
                             toolPart.approval?.reason ??
-                            'Tool execution denied.',
+                            'Tool call execution denied.',
                         },
                         ...(toolPart.callProviderMetadata != null
                           ? { providerOptions: toolPart.callProviderMetadata }

package/src/ui/index.ts

@@ -37,6 +37,7 @@ export {
   getToolName,
   getToolOrDynamicToolName,
   isDataUIPart,
+  isDynamicToolUIPart,
   isFileUIPart,
   isReasoningUIPart,
   isStaticToolUIPart,

package/src/util/set-abort-timeout.ts

@@ -0,0 +1,37 @@
+/**
+ * Schedules a timeout that aborts the given controller with a `TimeoutError`
+ * `DOMException`, matching the reason produced by `AbortSignal.timeout(ms)`.
+ *
+ * @param abortController - The controller to abort when the timeout elapses.
+ * If undefined, no timeout is scheduled.
+ * @param label - Human-readable label included in the error message
+ * (e.g. "Step", "Chunk").
+ * @param timeoutMs - Duration in milliseconds before the controller is aborted.
+ * If undefined, no timeout is scheduled.
+ * @returns The timeout id (suitable for passing to `clearTimeout`), or
+ * `undefined` if no timeout was scheduled.
+ */
+export function setAbortTimeout({
+  abortController,
+  label,
+  timeoutMs,
+}: {
+  abortController: AbortController | undefined;
+  label: string;
+  timeoutMs: number | undefined;
+}): ReturnType<typeof setTimeout> | undefined {
+  if (abortController == null || timeoutMs == null) {
+    return undefined;
+  }
+
+  return setTimeout(
+    () =>
+      abortController.abort(
+        new DOMException(
+          `${label} timeout of ${timeoutMs}ms exceeded`,
+          'TimeoutError',
+        ),
+      ),
+    timeoutMs,
+  );
+}