ai 7.0.57 → 7.0.59

package/docs/03-ai-sdk-core/38-video-generation.mdx

@@ -48,6 +48,22 @@ const { video } = await generateVideo({
 });
 ```
 
+Some models also accept `'adaptive'`, which lets the provider derive the output
+ratio from the input media instead of a fixed value. This is typically required
+for image-to-video, video editing, and video extension, where the output
+inherits the ratio of the input and an explicit ratio is rejected.
+
+```tsx highlight={"7"}
+import { experimental_generateVideo as generateVideo } from 'ai';
+__PROVIDER_IMPORT__;
+
+const { video } = await generateVideo({
+  model: __VIDEO_MODEL__,
+  prompt: { image: firstFrame, text: 'A cat walking on a treadmill' },
+  aspectRatio: 'adaptive',
+});
+```
+
 ### Resolution
 
 The resolution is specified as a string in the format `{width}x{height}`.

package/docs/03-ai-sdk-harnesses/03-tools.mdx

@@ -5,11 +5,13 @@ description: Use tools with AI SDK harnesses.
 
 # Harness Tools
 
-Harnesses have two tool surfaces:
+Harnesses have three tool surfaces:
 
 - Built-in tools exposed by the underlying harness runtime, such as file reads,
   edits, shell commands, and web search.
 - AI SDK tools that you pass to `HarnessAgent` with the `tools` setting.
+- External MCP tools configured through the harness adapter's `mcpServers`
+  setting.
 
 This page covers harness-specific behavior. For general AI SDK tool concepts,
 schemas, tool results, and `tool()` usage, see [Tools](/docs/foundations/tools).

package/docs/03-ai-sdk-harnesses/05-harness-adapters.mdx

@@ -17,6 +17,7 @@ The AI SDK includes the following harness adapters:
 - [Claude Code](/providers/ai-sdk-harnesses/claude-code) (`@ai-sdk/harness-claude-code`)
 - [Codex](/providers/ai-sdk-harnesses/codex) (`@ai-sdk/harness-codex`)
 - [Deep Agents](/providers/ai-sdk-harnesses/deepagents) (`@ai-sdk/harness-deepagents`)
+- [Grok Build](/providers/ai-sdk-harnesses/grok-build) (`@ai-sdk/harness-grok-build`)
 - [OpenCode](/providers/ai-sdk-harnesses/opencode) (`@ai-sdk/harness-opencode`)
 - [Pi](/providers/ai-sdk-harnesses/pi) (`@ai-sdk/harness-pi`)
 
@@ -33,5 +34,6 @@ The AI SDK includes the following harness adapters:
 | [Claude Code](/providers/ai-sdk-harnesses/claude-code) | Sandbox bridge   | <Check />    | <Check />     | <Check />              | <Check />                    |
 | [Codex](/providers/ai-sdk-harnesses/codex)             | Sandbox bridge   | <Check />    | <Check />     | <Cross />              | <Cross />                    |
 | [Deep Agents](/providers/ai-sdk-harnesses/deepagents)  | Sandbox bridge   | <Check />    | <Check />     | <Check />              | <Check /> via auto-rejection |
+| [Grok Build](/providers/ai-sdk-harnesses/grok-build)   | Sandbox via ACP  | <Check />    | <Check />     | <Check />              | <Cross />                    |
 | [OpenCode](/providers/ai-sdk-harnesses/opencode)       | Sandbox bridge   | <Check />    | <Check />     | <Check />              | <Check /> via auto-rejection |
 | [Pi](/providers/ai-sdk-harnesses/pi)                   | Host process     | <Check />    | <Check />     | <Check />              | <Check />                    |

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

@@ -44,7 +44,7 @@ export async function POST(req: Request) {
 ## AI SDK UI
 
 The hooks, e.g. `useChat` or `useCompletion`, provide a `stop` helper function that can be used to cancel a stream.
-This will cancel the stream from the client side to the server.
+This aborts the HTTP request from the client. To also stop the model request on the server, your server runtime must propagate the client disconnect to the request's `AbortSignal`, and your route must forward that signal to the AI SDK Core call as shown above.
 
 <Note type="warning">
   Stream abort functionality is not compatible with stream resumption. If you're
@@ -78,6 +78,27 @@ export default function Chat() {
 }
 ```
 
+### Vercel
+
+On Vercel, [request cancellation](https://vercel.com/docs/functions/functions-api-reference#cancel-requests) is only supported in the Node.js runtime and must be enabled for each function that needs it. Add `supportsCancellation` to the function's configuration in `vercel.json`:
+
+```json filename="vercel.json"
+{
+  "functions": {
+    "app/api/chat/route.ts": {
+      "supportsCancellation": true
+    }
+  }
+}
+```
+
+With cancellation enabled, calling `stop()` aborts the client request, Vercel aborts `req.signal`, and forwarding `req.signal` as `abortSignal` cancels the model request.
+
+<Note type="warning">
+  Without `supportsCancellation`, `stop()` still stops the client-side stream
+  but the server-side generation may continue.
+</Note>
+
 ## Handling stream abort cleanup
 
 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.

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

@@ -120,9 +120,7 @@ You can see a full example of caching with Redis in a Next.js application in our
 
 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:
-
-This example uses [Upstash Redis](https://upstash.com/docs/redis/overall/getstarted) and Next.js to cache the response for 1 hour.
+Here's an example of how you can use [Upstash Redis](https://upstash.com/redis) and Next.js to cache the OpenAI response for 1 hour:
 
 ```tsx filename="app/api/chat/route.ts"
 import {

package/docs/06-advanced/06-rate-limiting.mdx

@@ -11,13 +11,11 @@ specified timeframe. This simple technique acts as a gatekeeper,
 preventing excessive usage that can degrade service performance and incur
 unnecessary costs.
 
-## Rate Limiting with Vercel KV and Upstash Ratelimit
+## Rate Limiting with Upstash Redis and Upstash Ratelimit
 
-In this example, you will protect an API endpoint using [Vercel KV](https://vercel.com/storage/kv)
-and [Upstash Ratelimit](https://github.com/upstash/ratelimit).
+In this example, you will protect an API endpoint using [Upstash Redis](https://upstash.com/redis) and [Upstash Ratelimit](https://github.com/upstash/ratelimit).
 
 ```tsx filename='app/api/generate/route.ts'
-import kv from '@vercel/kv';
 import {
   createUIMessageStreamResponse,
   streamText,
@@ -25,6 +23,7 @@ import {
 } from 'ai';
 __PROVIDER_IMPORT__;
 import { Ratelimit } from '@upstash/ratelimit';
+import { Redis } from '@upstash/redis';
 import { NextRequest } from 'next/server';
 
 // Allow streaming responses up to 30 seconds
@@ -32,7 +31,7 @@ export const maxDuration = 30;
 
 // Create Rate limit
 const ratelimit = new Ratelimit({
-  redis: kv,
+  redis: Redis.fromEnv(),
   limiter: Ratelimit.fixedWindow(5, '30s'),
 });
 
@@ -61,6 +60,6 @@ export async function POST(req: NextRequest) {
 
 ## Simplify API Protection
 
-With Vercel KV and Upstash Ratelimit, it is possible to protect your APIs
+With Upstash Redis and Upstash Ratelimit, it is possible to protect your APIs
 from such attacks with ease. To learn more about how Ratelimit works and
 how it can be configured to your needs, see [Ratelimit Documentation](https://upstash.com/docs/oss/sdks/ts/ratelimit/overview).

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

@@ -95,6 +95,47 @@ export const maxDuration = 30;
 
 You can increase the max duration to 60 seconds on the Hobby Tier. For other tiers, [see the documentation](https://vercel.com/docs/functions/runtimes#max-duration) for limits.
 
+### Request Cancellation
+
+AI SDK UI helpers such as `useChat` and `useCompletion` abort the client request when you call `stop()`. To propagate that cancellation to a Vercel Function and its model request, you must:
+
+1. Use the Node.js runtime, which is the default for Next.js route handlers.
+2. Enable [`supportsCancellation`](https://vercel.com/docs/functions/functions-api-reference#cancel-requests) for the route in `vercel.json`.
+3. Forward the route's `req.signal` to `streamText` or `generateText` as `abortSignal`.
+
+For example, enable cancellation for your chat route:
+
+```json filename="vercel.json"
+{
+  "functions": {
+    "app/api/chat/route.ts": {
+      "supportsCancellation": true
+    }
+  }
+}
+```
+
+Then forward the request signal to the AI SDK:
+
+```ts filename="app/api/chat/route.ts" highlight="10"
+import { convertToModelMessages, streamText, type UIMessage } from 'ai';
+__PROVIDER_IMPORT__;
+
+export async function POST(req: Request) {
+  const { messages }: { messages: UIMessage[] } = await req.json();
+
+  const result = streamText({
+    model: __MODEL__,
+    messages: convertToModelMessages(messages),
+    abortSignal: req.signal,
+  });
+
+  return result.toUIMessageStreamResponse();
+}
+```
+
+Without `supportsCancellation`, calling `stop()` closes the client-side stream but does not cancel the Vercel Function or model request. See [Stopping Streams](/docs/advanced/stopping-streams) for the complete client and server setup.
+
 ## Security Considerations
 
 Given the high cost of calling an LLM, it's important to have measures in place that can protect your application from abuse.

package/docs/07-reference/01-ai-sdk-core/13-generate-video.mdx

@@ -83,7 +83,7 @@ console.log(videos);
       type: 'string',
       isOptional: true,
       description:
-        'Aspect ratio of the videos to generate. Format: `{width}:{height}`.',
+        "Aspect ratio of the videos to generate. Format: `{width}:{height}`, or `'adaptive'` to inherit the ratio from the input media (e.g. a first-frame image or a source video). Support for `'adaptive'` is provider-specific.",
     },
     {
       name: 'resolution',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.57",
+  "version": "7.0.59",
   "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,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.45",
-    "@ai-sdk/provider": "4.0.6",
-    "@ai-sdk/provider-utils": "5.0.24"
+    "@ai-sdk/gateway": "4.0.47",
+    "@ai-sdk/provider": "4.0.7",
+    "@ai-sdk/provider-utils": "5.0.26"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

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

@@ -219,7 +219,7 @@ export class ToolLoopAgent<
     });
     const callbackArgs = {
       abortSignal,
-      timeout,
+      timeout: timeout ?? preparedCall.timeout,
       experimental_sandbox: sandbox,
       onStart: mergeCallbacks(
         this.settings.onStart ?? this.settings.experimental_onStart,
@@ -284,7 +284,7 @@ export class ToolLoopAgent<
     });
     const callbackArgs = {
       abortSignal,
-      timeout,
+      timeout: timeout ?? preparedCall.timeout,
       experimental_sandbox: sandbox,
       experimental_transform,
       onStart: mergeCallbacks(

package/src/generate-video/generate-video.ts

@@ -93,7 +93,7 @@ export type GenerateVideoWebhookFactory = () => PromiseLike<{
  * @param model - The video model to use.
  * @param prompt - The prompt that should be used to generate the video.
  * @param n - Number of videos to generate. Default: 1.
- * @param aspectRatio - Aspect ratio of the videos to generate. Must have the format `{width}:{height}`.
+ * @param aspectRatio - Aspect ratio of the videos to generate. Must have the format `{width}:{height}`, or `'adaptive'`.
  * @param resolution - Resolution of the videos to generate. Must have the format `{width}x{height}`.
  * @param duration - Duration of the video in seconds.
  * @param fps - Frames per second for the video.
@@ -155,9 +155,10 @@ export async function experimental_generateVideo({
   maxVideosPerCall?: number;
 
   /**
-   * Aspect ratio of the videos to generate. Must have the format `{width}:{height}`.
+   * Aspect ratio of the videos to generate. Must have the format
+   * `{width}:{height}`, or `'adaptive'` to inherit the ratio from the input media.
    */
-  aspectRatio?: `${number}:${number}`;
+  aspectRatio?: `${number}:${number}` | 'adaptive';
 
   /**
    * Resolution of the videos to generate. Must have the format `{width}x${height}`.

package/src/prompt/content-part.ts

@@ -13,11 +13,11 @@ import {
   type ToolResultOutput,
   type ToolResultPart,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
 import { jsonValueSchema } from '../types/json-value';
 import { providerMetadataSchema } from '../types/provider-metadata';
+import { z, type ZodType } from '../util/zod';
 
-const fileInlineDataSchema: z.ZodType<DataContent> = z.union([
+const fileInlineDataSchema: ZodType<DataContent> = z.union([
   z.string(),
   z.instanceof(Uint8Array),
   z.instanceof(ArrayBuffer),
@@ -29,7 +29,7 @@ const providerReferenceSchema = z.record(z.string(), z.string());
 /**
  * @internal
  */
-export const textPartSchema: z.ZodType<TextPart> = z.object({
+export const textPartSchema: ZodType<TextPart> = z.object({
   type: z.literal('text'),
   text: z.string(),
   providerOptions: providerMetadataSchema.optional(),
@@ -40,7 +40,7 @@ export const textPartSchema: z.ZodType<TextPart> = z.object({
  * @deprecated Use `filePartSchema` with `mediaType: 'image'` instead:
  * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
  */
-export const imagePartSchema: z.ZodType<ImagePart> = z.object({
+export const imagePartSchema: ZodType<ImagePart> = z.object({
   type: z.literal('image'),
   image: z.union([
     fileInlineDataSchema,
@@ -69,7 +69,7 @@ const taggedReasoningFileDataSchema = z.discriminatedUnion('type', [
 /**
  * @internal
  */
-export const filePartSchema: z.ZodType<FilePart> = z.object({
+export const filePartSchema: ZodType<FilePart> = z.object({
   type: z.literal('file'),
   data: z.union([
     taggedFileDataSchema,
@@ -85,7 +85,7 @@ export const filePartSchema: z.ZodType<FilePart> = z.object({
 /**
  * @internal
  */
-export const reasoningPartSchema: z.ZodType<ReasoningPart> = z.object({
+export const reasoningPartSchema: ZodType<ReasoningPart> = z.object({
   type: z.literal('reasoning'),
   text: z.string(),
   providerOptions: providerMetadataSchema.optional(),
@@ -94,7 +94,7 @@ export const reasoningPartSchema: z.ZodType<ReasoningPart> = z.object({
 /**
  * @internal
  */
-export const customPartSchema: z.ZodType<CustomPart> = z.object({
+export const customPartSchema: ZodType<CustomPart> = z.object({
   type: z.literal('custom'),
   kind: z.string().transform(value => value as `${string}.${string}`),
   providerOptions: providerMetadataSchema.optional(),
@@ -103,7 +103,7 @@ export const customPartSchema: z.ZodType<CustomPart> = z.object({
 /**
  * @internal
  */
-export const reasoningFilePartSchema: z.ZodType<ReasoningFilePart> = z.object({
+export const reasoningFilePartSchema: ZodType<ReasoningFilePart> = z.object({
   type: z.literal('reasoning-file'),
   data: z.union([
     taggedReasoningFileDataSchema,
@@ -146,19 +146,19 @@ export interface ToolCallPart {
 /**
  * @internal
  */
-export const toolCallPartSchema: z.ZodType<ToolCallPart> = z.object({
+export const toolCallPartSchema: ZodType<ToolCallPart> = z.object({
   type: z.literal('tool-call'),
   toolCallId: z.string(),
   toolName: z.string(),
   input: z.unknown(),
   providerOptions: providerMetadataSchema.optional(),
   providerExecuted: z.boolean().optional(),
-}) as z.ZodType<ToolCallPart>; // necessary bc input is optional on Zod type
+}) as ZodType<ToolCallPart>; // necessary bc input is optional on Zod type
 
 /**
  * @internal
  */
-export const outputSchema: z.ZodType<ToolResultOutput> = z.discriminatedUnion(
+export const outputSchema: ZodType<ToolResultOutput> = z.discriminatedUnion(
   'type',
   [
     z.object({
@@ -267,28 +267,29 @@ export const outputSchema: z.ZodType<ToolResultOutput> = z.discriminatedUnion(
 /**
  * @internal
  */
-export const toolResultPartSchema: z.ZodType<ToolResultPart> = z.object({
+export const toolResultPartSchema: ZodType<ToolResultPart> = z.object({
   type: z.literal('tool-result'),
   toolCallId: z.string(),
   toolName: z.string(),
   output: outputSchema,
   providerOptions: providerMetadataSchema.optional(),
-}) as z.ZodType<ToolResultPart>; // necessary bc result is optional on Zod type
+}) as ZodType<ToolResultPart>; // necessary bc result is optional on Zod type
 
 /**
  * @internal
  */
-export const toolApprovalRequestSchema: z.ZodType<ToolApprovalRequest> =
-  z.object({
+export const toolApprovalRequestSchema: ZodType<ToolApprovalRequest> = z.object(
+  {
     type: z.literal('tool-approval-request'),
     approvalId: z.string(),
     toolCallId: z.string(),
-  });
+  },
+);
 
 /**
  * @internal
  */
-export const toolApprovalResponseSchema: z.ZodType<ToolApprovalResponse> =
+export const toolApprovalResponseSchema: ZodType<ToolApprovalResponse> =
   z.object({
     type: z.literal('tool-approval-response'),
     approvalId: z.string(),

package/src/prompt/message.ts

@@ -5,8 +5,8 @@ import type {
   ToolModelMessage,
   UserModelMessage,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
 import { providerMetadataSchema } from '../types/provider-metadata';
+import { z, type ZodType } from '../util/zod';
 import {
   customPartSchema,
   filePartSchema,
@@ -20,15 +20,13 @@ import {
   toolResultPartSchema,
 } from './content-part';
 
-export const systemModelMessageSchema: z.ZodType<SystemModelMessage> = z.object(
-  {
-    role: z.literal('system'),
-    content: z.string(),
-    providerOptions: providerMetadataSchema.optional(),
-  },
-);
+export const systemModelMessageSchema: ZodType<SystemModelMessage> = z.object({
+  role: z.literal('system'),
+  content: z.string(),
+  providerOptions: providerMetadataSchema.optional(),
+});
 
-export const userModelMessageSchema: z.ZodType<UserModelMessage> = z.object({
+export const userModelMessageSchema: ZodType<UserModelMessage> = z.object({
   role: z.literal('user'),
   content: z.union([
     z.string(),
@@ -37,7 +35,7 @@ export const userModelMessageSchema: z.ZodType<UserModelMessage> = z.object({
   providerOptions: providerMetadataSchema.optional(),
 });
 
-export const assistantModelMessageSchema: z.ZodType<AssistantModelMessage> =
+export const assistantModelMessageSchema: ZodType<AssistantModelMessage> =
   z.object({
     role: z.literal('assistant'),
     content: z.union([
@@ -58,13 +56,13 @@ export const assistantModelMessageSchema: z.ZodType<AssistantModelMessage> =
     providerOptions: providerMetadataSchema.optional(),
   });
 
-export const toolModelMessageSchema: z.ZodType<ToolModelMessage> = z.object({
+export const toolModelMessageSchema: ZodType<ToolModelMessage> = z.object({
   role: z.literal('tool'),
   content: z.array(z.union([toolResultPartSchema, toolApprovalResponseSchema])),
   providerOptions: providerMetadataSchema.optional(),
 });
 
-export const modelMessageSchema: z.ZodType<ModelMessage> = z.union([
+export const modelMessageSchema: ZodType<ModelMessage> = z.union([
   systemModelMessageSchema,
   userModelMessageSchema,
   assistantModelMessageSchema,

package/src/prompt/standardize-prompt.ts

@@ -4,7 +4,7 @@ import {
   safeValidateTypes,
   type ModelMessage,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
+import { z } from '../util/zod';
 import { modelMessageSchema } from './message';
 import type { Instructions, Prompt } from './prompt';
 

package/src/types/json-value.ts

@@ -1,7 +1,7 @@
 import type { JSONValue as OriginalJSONValue } from '@ai-sdk/provider';
-import { z } from 'zod/v4';
+import { z, type ZodType } from '../util/zod';
 
-export const jsonValueSchema: z.ZodType<JSONValue> = z.lazy(() =>
+export const jsonValueSchema: ZodType<JSONValue> = z.lazy(() =>
   z.union([
     z.null(),
     z.string(),

package/src/types/provider-metadata.ts

@@ -1,5 +1,5 @@
 import type { SharedV4ProviderMetadata } from '@ai-sdk/provider';
-import { z } from 'zod/v4';
+import { z, type ZodType } from '../util/zod';
 import { jsonValueSchema } from './json-value';
 
 /**
@@ -10,7 +10,7 @@ import { jsonValueSchema } from './json-value';
  */
 export type ProviderMetadata = SharedV4ProviderMetadata;
 
-export const providerMetadataSchema: z.ZodType<ProviderMetadata> = z.record(
+export const providerMetadataSchema: ZodType<ProviderMetadata> = z.record(
   z.string(),
   z.record(z.string(), jsonValueSchema.optional()),
 );

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

@@ -6,11 +6,11 @@ import {
   type FlexibleSchema,
   type Tool,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
 import { InvalidArgumentError } from '../error';
 import { jsonValueSchema } from '../types/json-value';
 import { getOwn } from '../util/get-own';
 import { providerMetadataSchema } from '../types/provider-metadata';
+import { z, type ZodType } from '../util/zod';
 import type {
   DataUIPart,
   InferUIMessageData,
@@ -19,7 +19,7 @@ import type {
   UIMessage,
 } from './ui-messages';
 
-const toolMetadataSchema: z.ZodType<JSONObject> = z.record(
+const toolMetadataSchema: ZodType<JSONObject> = z.record(
   z.string(),
   jsonValueSchema.optional(),
 );

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

@@ -1,5 +1,4 @@
 import type { JSONObject } from '@ai-sdk/provider';
-import { z } from 'zod/v4';
 import {
   providerMetadataSchema,
   type ProviderMetadata,
@@ -13,9 +12,10 @@ import type {
   UIMessage,
 } from '../ui/ui-messages';
 import type { ValueOf } from '../util/value-of';
+import { z, type ZodType } from '../util/zod';
 import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 
-const toolMetadataSchema: z.ZodType<JSONObject> = z.record(
+const toolMetadataSchema: ZodType<JSONObject> = z.record(
   z.string(),
   jsonValueSchema.optional(),
 );

package/src/util/zod.ts

@@ -0,0 +1,43 @@
+import {
+  array,
+  boolean,
+  custom,
+  discriminatedUnion,
+  enum as enumType,
+  instanceof as instanceOf,
+  lazy,
+  literal,
+  looseObject,
+  never,
+  null as nullType,
+  number,
+  object,
+  record,
+  string,
+  union,
+  unknown,
+} from 'zod/v4';
+
+// Import individual Zod factories so bundlers can tree-shake the full `z`
+// namespace, which also re-exports every locale.
+export const z = {
+  array,
+  boolean,
+  custom,
+  discriminatedUnion,
+  enum: enumType,
+  instanceof: instanceOf,
+  lazy,
+  literal,
+  looseObject,
+  never,
+  null: nullType,
+  number,
+  object,
+  record,
+  string,
+  union,
+  unknown,
+};
+
+export type { ZodType } from 'zod/v4';