ai 7.0.2 → 7.0.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # ai
 
+## 7.0.3
+
+### Patch Changes
+
+- Updated dependencies [728eaa0]
+  - @ai-sdk/gateway@4.0.3
+
 ## 7.0.2
 
 ### Patch Changes

package/dist/index.js

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

package/dist/internal/index.js

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

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

@@ -252,7 +252,7 @@ const result = await agent.generate({
 
 `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.
+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` + `onEnd` 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.
 

package/docs/03-ai-sdk-core/16-mcp-tools.mdx

@@ -49,6 +49,53 @@ const mcpClient = await createMCPClient({
 });
 ```
 
+If the MCP server uses Streamable HTTP sessions, you can reattach to a saved
+session by restoring both the previous session id and initialize result:
+
+```typescript
+import { createMCPClient } from '@ai-sdk/mcp';
+
+const savedSession = await loadMcpSession();
+let currentSessionId = savedSession?.sessionId;
+
+const mcpClient = await createMCPClient({
+  transport: {
+    type: 'http',
+    url: 'https://your-server.com/mcp',
+    initialSessionId: savedSession?.sessionId,
+    initialProtocolVersion: savedSession?.initializeResult.protocolVersion,
+    terminateSessionOnClose: false,
+
+    onSessionIdChange: sessionId => {
+      currentSessionId = sessionId;
+    },
+
+    onSessionExpired: sessionId => {
+      if (currentSessionId === sessionId) {
+        currentSessionId = undefined;
+        void clearMcpSession();
+      }
+    },
+  },
+  initialInitializeResult: savedSession?.initializeResult,
+});
+
+if (currentSessionId) {
+  await saveMcpSession({
+    sessionId: currentSessionId,
+    initializeResult: mcpClient.initializeResult,
+  });
+}
+```
+
+When `initialInitializeResult` is provided, `createMCPClient` reuses the cached
+initialize metadata and does not send another `initialize` request. When
+`onSessionExpired` is called, the transport has already cleared the session id
+and the request still fails with the underlying HTTP error. Retry by creating a
+fresh client without `initialSessionId` or `initialInitializeResult`.
+Set `terminateSessionOnClose` to `false` when closing only the local client but
+keeping the MCP session available for a later reattach.
+
 Alternatively, you can use `StreamableHTTPClientTransport` from MCP's official TypeScript SDK:
 
 ```typescript
@@ -116,8 +163,8 @@ You can also bring your own transport by implementing the `MCPTransport` interfa
 <Note>
   The client returned by the `createMCPClient` function is a
   lightweight client intended for use in tool conversion. It currently does not
-  support all features of the full MCP client, such as: session
-  management, resumable streams, and receiving notifications.
+  support all features of the full MCP client, such as automatic session
+  persistence, resumable streams, and receiving notifications.
 
 Authorization via OAuth is supported when using the AI SDK MCP HTTP or SSE
 transports by providing an `authProvider`.

package/docs/03-ai-sdk-core/35-image-generation.mdx

@@ -288,7 +288,7 @@ for (const file of result.files) {
 | Provider                                                                        | Model                                                        | Support sizes (`width x height`) or aspect ratios (`width : height`)                                                                                                |
 | ------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [xAI Grok](/providers/ai-sdk-providers/xai#image-models)                        | `grok-imagine-image`                                         | `1:1`, `16:9`, `9:16`, `4:3`, `3:4`, `3:2`, `2:3`, `2:1`, `1:2`, `19.5:9`, `9:19.5`, `20:9`, `9:20`, `auto`                                                         |
-| [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `gpt-image-1`                                                | 1024x1024, 1536x1024, 1024x1536                                                                                                                                     |
+| [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `gpt-image-2`                                                | 1024x1024, 1536x1024, 1024x1536                                                                                                                                     |
 | [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `dall-e-3`                                                   | 1024x1024, 1792x1024, 1024x1792                                                                                                                                     |
 | [OpenAI](/providers/ai-sdk-providers/openai#image-models)                       | `dall-e-2`                                                   | 256x256, 512x512, 1024x1024                                                                                                                                         |
 | [Amazon Bedrock](/providers/ai-sdk-providers/amazon-bedrock#image-models)       | `amazon.nova-canvas-v1:0`                                    | 320-4096 (multiples of 16), 1:4 to 4:1, max 4.2M pixels                                                                                                             |

package/docs/03-ai-sdk-harnesses/02-harness-agent.mdx

@@ -261,6 +261,81 @@ default working directory and is used as the session working directory. When
 omitted, regular sessions use the default `<harnessId>-<sessionId>` directory,
 while `onBootstrap` receives the sandbox's default working directory.
 
+## Prepare Reusable Sandboxes
+
+Use `prepareHarnessSandboxTemplate()` when you want the sandbox provider to
+create or refresh its reusable template for one harness ahead of time:
+
+```ts
+import { prepareHarnessSandboxTemplate } from '@ai-sdk/harness/agent';
+
+await prepareHarnessSandboxTemplate({
+  harness: claudeCode,
+  sandboxProvider: createVercelSandbox({
+    runtime: 'node24',
+    ports: [4000],
+  }),
+  sandboxConfig: {
+    bootstrapHash: 'ripgrep-v1',
+    onBootstrap: async ({ session, abortSignal }) => {
+      await session.run({
+        command:
+          'command -v rg >/dev/null || (apt-get update && apt-get install -y ripgrep)',
+        abortSignal,
+      });
+    },
+  },
+});
+```
+
+Use `prepareSandboxForHarness()` when you own the native sandbox lifecycle and
+want to snapshot the prepared sandbox yourself. It applies the selected harness
+bootstrap recipes and `sandboxConfig.onBootstrap`, then returns preparation
+metadata. It does not stop or snapshot the sandbox.
+
+```ts
+import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
+import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { Sandbox } from '@vercel/sandbox';
+
+const nativeSandbox = await Sandbox.create({
+  runtime: 'node24',
+  ports: [4000],
+});
+const sandboxProvider = createVercelSandbox({ sandbox: nativeSandbox });
+const session = await sandboxProvider.createSession();
+
+const preparation = await prepareSandboxForHarness({
+  session: session.restricted(),
+  harnesses: [claudeCode, codex],
+  sandboxConfig,
+});
+
+const { snapshot } = await nativeSandbox.stop();
+if (snapshot == null) {
+  throw new Error('Prepared sandbox did not create a snapshot.');
+}
+
+const sandboxFromSnapshot = await Sandbox.create({
+  source: {
+    type: 'snapshot',
+    snapshotId: snapshot.id,
+  },
+  ports: [4000],
+});
+
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  sandbox: createVercelSandbox({
+    sandbox: sandboxFromSnapshot,
+    bridgePorts: [4000],
+  }),
+  sandboxConfig,
+});
+
+console.log(preparation.identity);
+```
+
 ## Settings
 
 `HarnessAgent` accepts these main settings:

package/docs/04-ai-sdk-ui/20-streaming-data.mdx

@@ -92,7 +92,7 @@ export async function POST(req: Request) {
       const result = streamText({
         model: __MODEL__,
         messages: await convertToModelMessages(messages),
-        onFinish() {
+        onEnd() {
           // 4. Update the same data part (reconciliation)
           writer.write({
             type: 'data-weather',

package/docs/05-ai-sdk-rsc/10-migrating-to-ui.mdx

@@ -489,7 +489,7 @@ export const AI = createAI({
 
 #### After: Save chats using callback function of `streamText`
 
-With AI SDK UI, you will save chats using the `onFinish` callback function of `streamText` in your route handler.
+With AI SDK UI, you will save chats using the `onEnd` callback function of `streamText` in your route handler.
 
 ```ts filename="@/app/api/chat/route.ts"
 import { openai } from '@ai-sdk/openai';
@@ -510,7 +510,7 @@ export async function POST(request) {
     model: __MODEL__,
     instructions: 'you are a friendly assistant!',
     messages: coreMessages,
-    onFinish: async ({ responseMessages }) => {
+    onEnd: async ({ responseMessages }) => {
       try {
         await saveChat({
           id,

package/docs/06-advanced/02-stopping-streams.mdx

@@ -82,7 +82,7 @@ export default function Chat() {
 
 When streams are aborted, you may need to perform cleanup operations such as persisting partial results or cleaning up resources. The `onAbort` callback provides a way to handle these scenarios on the server side.
 
-Unlike `onFinish`, which is called when a stream completes normally, `onAbort` is specifically called when a stream is aborted via `AbortSignal`. This distinction allows you to handle normal completion and aborted streams differently.
+Unlike `onEnd`, which is called when a stream completes normally, `onAbort` is specifically called when a stream is aborted via `AbortSignal`. This distinction allows you to handle normal completion and aborted streams differently.
 
 <Note>
   For UI message streams (`toUIMessageStreamResponse`), the `onEnd` callback
@@ -104,7 +104,7 @@ const result = streamText({
     await savePartialResults(steps);
     await logAbortEvent(steps.length);
   },
-  onFinish: ({ steps, totalUsage }) => {
+  onEnd: ({ steps, totalUsage }) => {
     // Called when stream completes normally
     await saveFinalResults(steps, totalUsage);
   },

package/docs/06-advanced/04-caching.mdx

@@ -118,7 +118,7 @@ You can see a full example of caching with Redis in a Next.js application in our
 
 ## Using Lifecycle Callbacks
 
-Alternatively, each AI SDK Core function has special lifecycle callbacks you can use. The one of interest is likely `onFinish`, which is called when the generation is complete. This is where you can cache the full response.
+Alternatively, each AI SDK Core function has special lifecycle callbacks you can use. The one of interest is likely `onEnd`, which is called when the generation is complete. This is where you can cache the full response.
 
 Here's an example of how you can implement caching using Vercel KV and Next.js to cache the OpenAI response for 1 hour:
 
@@ -162,7 +162,7 @@ export async function POST(req: Request) {
   const result = streamText({
     model: __MODEL__,
     messages: await convertToModelMessages(messages),
-    async onFinish({ text }) {
+    async onEnd({ text }) {
       // Cache the response text:
       await redis.set(key, text);
       await redis.expire(key, 60 * 60);

package/docs/07-reference/01-ai-sdk-core/23-create-mcp-client.mdx

@@ -86,7 +86,7 @@ It currently does not support accepting notifications from an MCP server, and cu
                   parameters: [
                     {
                       name: 'type',
-                      type: "'sse' | 'http",
+                      type: "'sse' | 'http'",
                       description: 'Use Server-Sent Events for communication',
                     },
                     {
@@ -115,6 +115,48 @@ It currently does not support accepting notifications from an MCP server, and cu
                       description:
                         "Controls how HTTP redirects are handled for transport requests. Set to 'follow' to allow redirect responses. Defaults to 'error' to reject any redirect response, preventing servers from redirecting requests to unintended hosts.",
                     },
+                    {
+                      name: 'initialSessionId',
+                      type: 'string',
+                      isOptional: true,
+                      description:
+                        'Initial MCP session id to send with resumed Streamable HTTP requests after initialization. Pair with initialInitializeResult when using createMCPClient. Only used by the HTTP transport.',
+                    },
+                    {
+                      name: 'initialProtocolVersion',
+                      type: 'string',
+                      isOptional: true,
+                      description:
+                        'Initial MCP protocol version to send before initialize negotiates one. Only used by the HTTP transport.',
+                    },
+                    {
+                      name: 'onSessionIdChange',
+                      type: '(sessionId: string | undefined) => void',
+                      isOptional: true,
+                      description:
+                        'Callback invoked when the Streamable HTTP server creates, changes, or clears the MCP session id. Only used by the HTTP transport.',
+                    },
+                    {
+                      name: 'onSessionExpired',
+                      type: '(sessionId: string) => void',
+                      isOptional: true,
+                      description:
+                        'Callback invoked when a Streamable HTTP request returns 404 for an existing MCP session id. The transport clears the session id before reporting the underlying HTTP error. Only used by the HTTP transport.',
+                    },
+                    {
+                      name: 'terminateSessionOnClose',
+                      type: 'boolean',
+                      isOptional: true,
+                      description:
+                        'Whether close() should send DELETE for the current MCP session id. Set to false when the application intends to reattach to the session later. Defaults to true. Only used by the HTTP transport.',
+                    },
+                    {
+                      name: 'fetch',
+                      type: 'FetchFunction',
+                      isOptional: true,
+                      description:
+                        'Optional custom fetch implementation to use for HTTP requests. Useful for runtimes that need a request-local fetch.',
+                    },
                   ],
                 },
               ],
@@ -144,6 +186,13 @@ It currently does not support accepting notifications from an MCP server, and cu
               isOptional: true,
               description: 'Handler for uncaught errors',
             },
+            {
+              name: 'initialInitializeResult',
+              type: 'InitializeResult',
+              isOptional: true,
+              description:
+                'Initialize result from a previous MCP session. When provided, the client starts the transport and reuses this metadata without sending a new initialize request.',
+            },
             {
               name: 'capabilities',
               type: 'ClientCapabilities',
@@ -164,6 +213,12 @@ Returns a Promise that resolves to an `MCPClient` with the following properties
 
 <PropertiesTable
   content={[
+    {
+      name: 'initializeResult',
+      type: 'InitializeResult',
+      description:
+        'The full initialize result used by this client, either from the server during initialization or from initialInitializeResult.',
+    },
     {
       name: 'serverInfo',
       type: 'Configuration',

package/docs/07-reference/01-ai-sdk-core/61-wrap-image-model.mdx

@@ -13,7 +13,7 @@ import { generateImage, wrapImageModel } from 'ai';
 import { openai } from '@ai-sdk/openai';
 
 const model = wrapImageModel({
-  model: openai.image('gpt-image-1'),
+  model: openai.image('gpt-image-2'),
   middleware: yourImageModelMiddleware,
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "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,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.2",
+    "@ai-sdk/gateway": "4.0.3",
     "@ai-sdk/provider": "4.0.0",
     "@ai-sdk/provider-utils": "5.0.0"
   },