Migrate AI SDK 6.x to 7.0

Use the command below to add the migration skill:

1
npx skills add vercel/ai --skill migrate-ai-sdk-v6-to-v7

Then ask your agent:

1
Use the migrate-ai-sdk-v6-to-v7 skill and migrate my app from AI SDK v6 to v7.

Recommended Migration Process

1. Backup your project. If you use a versioning control system, make sure all previous versions are committed.
2. Upgrade to AI SDK 7.0.
3. Follow the breaking changes guide below.
4. Verify your project is working as expected.
5. Commit your changes.

An example upgrade command would be:

1
pnpm install ai @ai-sdk/react @ai-sdk/openai @ai-sdk/otel

Codemods

The AI SDK provides Codemod transformations to help upgrade your codebase when a feature is deprecated, removed, or otherwise changed.

Codemods are transformations that run on your codebase automatically. They allow you to easily apply many changes without having to manually go through every file.

You can run all v7 codemods (v6 -> v7 migration) by running the following command from the root of your project:

1
npx @ai-sdk/codemod v7

Individual codemods can be run by specifying the name of the codemod:

1
npx @ai-sdk/codemod <codemod-name> <path>

For example, to run a specific v7 codemod:

1
npx @ai-sdk/codemod v7/rename-system-to-instructions src/

Codemod Table

All Packages

Minimum Node.js Version

AI SDK 7.0 requires Node.js 22 or later. The SDK is tested on Node.js 22, 24, and 26.

Node.js 18 and 20 are no longer supported. Node.js 22 reached end-of-maintenance on April 30, 2026; for production workloads, prefer Node.js 24 (LTS) or Node.js 26. See the Node.js release schedule for current status and support timelines.

Update the engines field in your package.json if you enforce a minimum Node.js version:

1
{
2
  "engines": {
3
    "node": ">=22"
4
  }
5
}

ESM Only — CommonJS Support Removed

All AI SDK packages are now ESM-only. The require() function is no longer supported.

If your project uses CommonJS (require()), switch to ESM import syntax:

1
const { generateText } = require('ai');
2
const { openai } = require('@ai-sdk/openai');

1
import { generateText } from 'ai';
2
import { openai } from '@ai-sdk/openai';

If your package.json does not already include "type": "module", add it or rename your files to use the .mjs extension.

AI SDK Core

Core API Renames and Removals

Provider Management: Remove Deprecated experimental_customProvider

The deprecated experimental_customProvider export has been removed in AI SDK 7. Replace it with customProvider.

1
import { experimental_customProvider } from 'ai';
2

3
export const myProvider = experimental_customProvider({
4
  languageModels: {
5
    // ...
6
  },
7
});

1
import { customProvider } from 'ai';
2

3
export const myProvider = customProvider({
4
  languageModels: {
5
    // ...
6
  },
7
});

This is only an import and symbol rename. The customProvider options and behavior are unchanged.

Remove Deprecated experimental_generateImage Export

The deprecated experimental_generateImage export has been removed in AI SDK 7. Replace it with generateImage.

The deprecated Experimental_GenerateImageResult type export has also been removed. Replace it with GenerateImageResult.

1
import {
2
  experimental_generateImage,
3
  type Experimental_GenerateImageResult,
4
} from 'ai';
5

6
const result: Experimental_GenerateImageResult =
7
  await experimental_generateImage({
8
    model: yourImageModel,
9
    prompt: 'A red panda eating bamboo',
10
  });

1
import { generateImage, type GenerateImageResult } from 'ai';
2

3
const result: GenerateImageResult = await generateImage({
4
  model: yourImageModel,
5
  prompt: 'A red panda eating bamboo',
6
});

experimental_transcribe Renamed to transcribe

The transcription API has graduated out of experimental status and has been renamed to transcribe. The Experimental_TranscriptionResult type has also been renamed to TranscriptionResult.

1
import {
2
  experimental_transcribe as transcribe,
3
  type Experimental_TranscriptionResult,
4
} from 'ai';
5

6
const result: Experimental_TranscriptionResult = await transcribe({
7
  model: yourTranscriptionModel,
8
  audio,
9
});

1
import { transcribe, type TranscriptionResult } from 'ai';
2

3
const result: TranscriptionResult = await transcribe({
4
  model: yourTranscriptionModel,
5
  audio,
6
});

The old names continue to work as deprecated aliases in AI SDK 7 and will be removed in a future major release.

experimental_generateSpeech Renamed to generateSpeech

The speech generation function has graduated out of experimental status and has been renamed to generateSpeech. The Experimental_SpeechResult type has also been renamed to SpeechResult.

1
import { experimental_generateSpeech as generateSpeech } from 'ai';
2

3
const result = await generateSpeech({
4
  model: yourSpeechModel,
5
  text: 'Hello',
6
});

1
import { generateSpeech } from 'ai';
2

3
const result = await generateSpeech({
4
  model: yourSpeechModel,
5
  text: 'Hello',
6
});

The old experimental_generateSpeech and Experimental_SpeechResult exports continue to work as deprecated aliases in AI SDK 7 and will be removed in a future major release.

Structured Outputs: Remove Deprecated experimental_output Option and Result

The deprecated experimental_output option has been removed in AI SDK 7. Replace all remaining usages with output.

The deprecated generateText() result property experimental_output has also been removed. Read result.output instead.

This name was deprecated in AI SDK 6, so if you already migrated to output, no changes are needed. Otherwise, update both the call options and any result access:

1
const result = await generateText({
2
  model: yourModel,
3
  experimental_output: Output.object({
4
    schema: recipeSchema,
5
  }),
6
  prompt: 'Generate a recipe.',
7
});
8

9
console.log(result.experimental_output);

1
const result = await generateText({
2
  model: yourModel,
3
  output: Output.object({
4
    schema: recipeSchema,
5
  }),
6
  prompt: 'Generate a recipe.',
7
});
8

9
console.log(result.output);

CallSettings Renamed to LanguageModelCallOptions and RequestOptions

CallSettings has been split into LanguageModelCallOptions (model-facing options) and RequestOptions (transport options). Replace usages in custom wrappers or helpers:

• CallSettings → LanguageModelCallOptions & Omit<RequestOptions, 'timeout'> (note: CallSettings never included timeout)

The deprecated CallSettings type remains available in AI SDK 7.

Stop Condition Helper Rename: stepCountIs -> isStepCount

Rename imports and usage in tool-loop stop conditions:

1
import { stepCountIs } from 'ai';
2

3
stopWhen: stepCountIs(3);

1
import { isStepCount } from 'ai';
2

3
stopWhen: isStepCount(3);

Prompts and Step Preparation

system Renamed to instructions

The top-level prompt option for system instructions has been renamed from system to instructions.

1
const result = await generateText({
2
  model: yourModel,
3
  system: 'You are a helpful assistant.',
4
  prompt: 'Hello!',
5
});

1
const result = await generateText({
2
  model: yourModel,
3
  instructions: 'You are a helpful assistant.',
4
  prompt: 'Hello!',
5
});

This applies to AI SDK functions that accept prompt or messages, including generateText, streamText, generateObject, streamObject, and streamUI.

The same rename applies to prepareStep results for generateText and streamText, and to the options passed into experimental_repairToolCall:

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  prepareStep: () => ({
5
    system: 'Use concise answers for this step.',
6
  }),
7
});

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  prepareStep: () => ({
5
    instructions: 'Use concise answers for this step.',
6
  }),
7
});

The system option is still accepted as a deprecated fallback. When both instructions and system are provided, instructions takes precedence.

prepareStep Instructions Carry Forward

In AI SDK 7, instructions returned from prepareStep are used in future steps until prepareStep returns another instructions or system override. This matches how messages returned from prepareStep carry forward.

In AI SDK 6, prepareStep instruction overrides only applied to the current step. Later steps fell back to the top-level system instructions unless they returned their own override.

If your prepareStep logic depends on one-step-only instruction overrides, return the desired instructions for each step explicitly:

1
const result = streamText({
2
  model: yourModel,
3
  instructions: 'Use the default behavior.',
4
  prompt: 'Hello!',
5
  prepareStep: ({ stepNumber, initialInstructions }) => ({
6
    instructions:
7
      stepNumber === 0
8
        ? 'Use special instructions for the first step.'
9
        : initialInstructions,
10
  }),
11
});

The prepareStep callback receives both instructions, which is the current instruction state for the step, and initialInstructions, which is the top-level instruction value from the original call.

If your tool call repair function forwards the current system instructions to another model call, read and pass instructions instead of system:

1
const result = await generateText({
2
  model: yourModel,
3
  tools,
4
  prompt: 'Hello!',
5
  experimental_repairToolCall: async ({ system, messages }) => {
6
    return repairWithModel({ system, messages });
7
  },
8
});

1
const result = await generateText({
2
  model: yourModel,
3
  tools,
4
  prompt: 'Hello!',
5
  experimental_repairToolCall: async ({ instructions, messages }) => {
6
    return repairWithModel({ instructions, messages });
7
  },
8
});

Lifecycle callback events for generateText, streamText, and agents also use instructions instead of system:

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  experimental_onStart: ({ system }) => {
5
    console.log(system);
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onStart: ({ instructions }) => {
5
    console.log(instructions);
6
  },
7
});

Prompt Messages: System Messages in prompt or messages Are Rejected by Default

AI SDK 7 rejects system messages in the prompt or messages fields by default. System instructions should usually be passed with the top-level instructions option.

This can break older persisted chats or custom prompt arrays that include { role: 'system' } messages:

1
const result = await generateText({
2
  model: yourModel,
3
  messages: [
4
    { role: 'system', content: 'You are a helpful assistant.' },
5
    { role: 'user', content: 'Hello!' },
6
  ],
7
});

Move system instructions to the instructions option when possible:

1
const result = await generateText({
2
  model: yourModel,
3
  instructions: 'You are a helpful assistant.',
4
  messages: [{ role: 'user', content: 'Hello!' }],
5
});

If you need to keep existing chat histories that already contain system messages, opt in to the previous behavior with allowSystemInMessages: true:

1
const result = await generateText({
2
  model: yourModel,
3
  allowSystemInMessages: true,
4
  messages: persistedMessages,
5
});

This applies to AI SDK functions that accept prompt or messages, including generateText, streamText, generateObject, streamObject, and streamUI.

Remove Deprecated experimental_prepareStep Option

The deprecated experimental_prepareStep option has been removed in AI SDK 7. Replace all remaining usages with prepareStep.

This option was deprecated in AI SDK 5, so if you already migrated to prepareStep, no changes are needed. Otherwise, update generateText calls:

1
const result = await generateText({
2
  model: yourModel,
3
  tools: { weather },
4
  experimental_prepareStep: ({ stepNumber }) => {
5
    console.log('Preparing step', stepNumber);
6
    return {
7
      activeTools: ['weather'],
8
    };
9
  },
10
});

1
const result = await generateText({
2
  model: yourModel,
3
  tools: { weather },
4
  prepareStep: ({ stepNumber }) => {
5
    console.log('Preparing step', stepNumber);
6
    return {
7
      activeTools: ['weather'],
8
    };
9
  },
10
});

prepareStep Message Overrides Carry Forward

When prepareStep returns messages, those messages are now used as the base for subsequent steps. The next step receives those messages plus the response messages from the previous step.

In AI SDK 6, a messages override only applied to the current step. To keep that behavior, rebuild the current step's messages from initialMessages and responseMessages inside prepareStep:

1
const result = await generateText({
2
  model: yourModel,
3
  tools: { weather },
4
  prepareStep: ({ initialMessages, responseMessages }) => {
5
    return {
6
      messages: [
7
        ...initialMessages,
8
        ...responseMessages,
9
        // add any one-step-only message changes here
10
      ],
11
    };
12
  },
13
});

Lifecycle Events

experimental_onStart Renamed to onStart

The generation start callback for generateText, streamText, and agents has been renamed from experimental_onStart to onStart.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  experimental_onStart: () => {
5
    console.log('Generation started');
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onStart: () => {
5
    console.log('Generation started');
6
  },
7
});

experimental_onStepStart Renamed to onStepStart

The per-step start callback for generateText, streamText, and agents has been renamed from experimental_onStepStart to onStepStart.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  experimental_onStepStart: ({ stepNumber }) => {
5
    console.log(`Step ${stepNumber} started`);
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onStepStart: ({ stepNumber }) => {
5
    console.log(`Step ${stepNumber} started`);
6
  },
7
});

onFinish Renamed to onEnd

The final lifecycle callback for generateText, streamText, and agents has been renamed from onFinish to onEnd.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onFinish: ({ text }) => {
5
    console.log(text);
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onEnd: ({ text }) => {
5
    console.log(text);
6
  },
7
});

The same rename applies to streamText, Agent.generate(), Agent.stream(), and ToolLoopAgent settings. The onFinish option is still accepted as a deprecated alias. When both onEnd and onFinish are provided, onEnd takes precedence.

onStepFinish Renamed to onStepEnd

The per-step lifecycle callback has been renamed from onStepFinish to onStepEnd.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onStepFinish: ({ stepNumber, usage }) => {
5
    console.log(`Step ${stepNumber} used ${usage.totalTokens} tokens`);
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
  onStepEnd: ({ stepNumber, usage }) => {
5
    console.log(`Step ${stepNumber} used ${usage.totalTokens} tokens`);
6
  },
7
});

This applies to generateText, streamText, generateObject, streamObject, agents, workflow agents, and UI message stream helpers. Telemetry integrations should implement onStepEnd.

The onStepFinish option is still accepted as a deprecated alias for user-facing callbacks. When both onStepEnd and onStepFinish are provided, onStepEnd takes precedence.

Embed Callbacks

The per-call callback option for completed embed and embedMany operations has been renamed from experimental_onFinish to onEnd.

1
const result = await embed({
2
  model: yourEmbeddingModel,
3
  value,
4
  experimental_onFinish(event) {
5
    console.log('Embedding finished:', event.usage.tokens);
6
  },
7
});

1
const result = await embed({
2
  model: yourEmbeddingModel,
3
  value,
4
  onEnd(event) {
5
    console.log('Embedding ended:', event.usage.tokens);
6
  },
7
});

Rerank Callback

The per-call callback option for completed rerank operations has been renamed from experimental_onFinish to onEnd.

1
const result = await rerank({
2
  model: yourRerankingModel,
3
  documents,
4
  query,
5
  experimental_onFinish(event) {
6
    console.log('Rerank finished:', event.ranking.length);
7
  },
8
});

1
const result = await rerank({
2
  model: yourRerankingModel,
3
  documents,
4
  query,
5
  onEnd(event) {
6
    console.log('Rerank ended:', event.ranking.length);
7
  },
8
});

Usage and Result Shape Changes

cachedInputTokens and reasoningTokens Removed from LanguageModelUsage

The deprecated top-level cachedInputTokens and reasoningTokens fields have been removed from LanguageModelUsage.

Use inputTokenDetails.cacheReadTokens and outputTokenDetails.reasoningTokens instead:

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
});
5

6
console.log(result.usage.cachedInputTokens);
7
console.log(result.usage.reasoningTokens);

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
});
5

6
console.log(result.usage.inputTokenDetails.cacheReadTokens);
7
console.log(result.usage.outputTokenDetails.reasoningTokens);

Telemetry

OpenTelemetry Moved to @ai-sdk/otel

OpenTelemetry span collection is no longer built into the ai package. To continue receiving OpenTelemetry traces, you must install the new @ai-sdk/otel package and register the OpenTelemetry instance globally.

1
pnpm install @ai-sdk/otel

Previously, OpenTelemetry spans were emitted automatically when experimental_telemetry was enabled:

1
import { generateText } from 'ai';
2

3
const result = await generateText({
4
  model: yourModel,
5
  prompt: 'Hello',
6
  experimental_telemetry: { isEnabled: true },
7
});

Now, you must install @ai-sdk/otel and register the OpenTelemetry instance once at application startup. For Next.js, place this in your instrumentation.ts file alongside your OpenTelemetry provider setup:

1
import { registerTelemetry } from 'ai';
2
import { OpenTelemetry } from '@ai-sdk/otel';
3

4
registerTelemetry(new OpenTelemetry());
5

6
// ... your OpenTelemetry provider setup (e.g. registerOTel, NodeTracerProvider)

For Node.js applications (without Next.js), register the integration at the top level of your entry file.

This applies to all AI SDK functions that accept experimental_telemetry, including generateText, streamText, ToolLoopAgent, embed, embedMany, and rerank.

Enabled by Default When an Integration Is Registered

In AI SDK 6, telemetry was opt-in — you had to set experimental_telemetry: { isEnabled: true } on every call to emit events. In AI SDK 7, telemetry is opt-out: once you register a telemetry integration (for example OpenTelemetry or DevToolsTelemetry), all AI SDK calls emit telemetry events by default.

1
import { generateText } from 'ai';
2

3
const result = await generateText({
4
  model: yourModel,
5
  prompt: 'Hello',
6
  experimental_telemetry: { isEnabled: true },
7
});

1
import { generateText } from 'ai';
2
import { registerTelemetry } from 'ai';
3
import { OpenTelemetry } from '@ai-sdk/otel';
4

5
registerTelemetry(new OpenTelemetry());
6

7
const result = await generateText({
8
  model: yourModel,
9
  prompt: 'Hello',
10
});

You can safely remove experimental_telemetry: { isEnabled: true } from all of your calls. If you are already passing other fields like functionId or integrations, keep them — only isEnabled: true is redundant:

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  experimental_telemetry: {
5
    isEnabled: true,
6
    functionId: 'my-awesome-function',
7
  },
8
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  experimental_telemetry: {
5
    functionId: 'my-awesome-function',
6
  },
7
});

To opt out of telemetry for a specific call, set isEnabled: false:

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  experimental_telemetry: { isEnabled: false },
5
});

To disable telemetry globally, do not register any telemetry integrations.

This applies to all AI SDK functions that accept experimental_telemetry, including generateText, streamText, ToolLoopAgent, embed, embedMany, and rerank.

tracer Property Removed from experimental_telemetry

The tracer property on experimental_telemetry has been removed. If you were passing a custom OpenTelemetry Tracer, pass it to the OpenTelemetry constructor instead:

1
import { generateText } from 'ai';
2
import { trace } from '@opentelemetry/api';
3

4
const result = await generateText({
5
  model: yourModel,
6
  prompt: 'Hello',
7
  experimental_telemetry: {
8
    isEnabled: true,
9
    tracer: trace.getTracer('my-app'),
10
  },
11
});

1
import { registerTelemetry } from 'ai';
2
import { OpenTelemetry } from '@ai-sdk/otel';
3
import { trace } from '@opentelemetry/api';
4

5
registerTelemetry(
6
  new OpenTelemetry({
7
    tracer: trace.getTracer('my-app'),
8
  }),
9
);

This applies to all AI SDK functions that accept experimental_telemetry, including streamText, generateObject, streamObject, embed, and embedMany.

If you were not passing a custom tracer (relying on the default global tracer), no changes are needed — the OpenTelemetry is registered globally by default and uses trace.getTracer('ai') when no custom tracer is provided.

experimental_telemetry Renamed to telemetry

The telemetry option has graduated out of experimental status and has been renamed to telemetry. The old name experimental_telemetry continues to work as a deprecated alias in AI SDK 7 and will be removed in a future major release.

1
import { generateText } from 'ai';
2

3
const result = await generateText({
4
  model: yourModel,
5
  prompt: 'Hello',
6
  experimental_telemetry: {
7
    functionId: 'story-agent',
8
  },
9
});

1
import { generateText } from 'ai';
2

3
const result = await generateText({
4
  model: yourModel,
5
  prompt: 'Hello',
6
  telemetry: {
7
    functionId: 'story-agent',
8
  },
9
});

This applies to all AI SDK functions and agents that accept telemetry configuration, including generateText, streamText, generateObject, streamObject, embed, embedMany, rerank, ToolLoopAgent, and WorkflowAgent.

No behavior changes beyond the rename. You can migrate incrementally — mixed usage of telemetry and experimental_telemetry in the same codebase is supported during the deprecation window.

onRerankFinish Renamed to onRerankEnd

The telemetry integration callback for individual reranking model calls has been renamed from onRerankFinish to onRerankEnd.

This also applies to the type field emitted on AI_SDK_TELEMETRY_TRACING_CHANNEL: tracing-channel subscribers now receive onRerankEnd instead of onRerankFinish.

Update telemetry integrations and tracing-channel subscribers to use onRerankEnd.

1
import type { Telemetry } from 'ai';
2

3
const telemetry: Telemetry = {
4
  onRerankFinish(event) {
5
    console.log('Rerank finished:', event.ranking.length);
6
  },
7
};

1
import type { Telemetry } from 'ai';
2

3
const telemetry: Telemetry = {
4
  onRerankEnd(event) {
5
    console.log('Rerank ended:', event.ranking.length);
6
  },
7
};

onEmbedFinish Renamed to onEmbedEnd

The telemetry integration callback for individual embedding model calls has been renamed from onEmbedFinish to onEmbedEnd.

This also applies to the type field emitted on AI_SDK_TELEMETRY_TRACING_CHANNEL: tracing-channel subscribers now receive onEmbedEnd instead of onEmbedFinish.

Update telemetry integrations and tracing-channel subscribers to use onEmbedEnd.

1
import type { Telemetry } from 'ai';
2

3
const telemetry: Telemetry = {
4
  onEmbedFinish(event) {
5
    console.log('Embedding finished:', event.embeddings.length);
6
  },
7
};

1
import type { Telemetry } from 'ai';
2

3
const telemetry: Telemetry = {
4
  onEmbedEnd(event) {
5
    console.log('Embedding ended:', event.embeddings.length);
6
  },
7
};

Streaming and Include Options

StreamTextResult.fullStream Renamed to stream

The full event stream returned by streamText has been renamed from fullStream to stream.

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
});
5

6
for await (const part of result.fullStream) {
7
  console.log(part);
8
}

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello!',
4
});
5

6
for await (const part of result.stream) {
7
  console.log(part);
8
}

The fullStream property is still available as a deprecated alias for stream.

streamText onChunk Receives All Stream Parts

In AI SDK 7, streamText calls onChunk for every TextStreamPart emitted by the stream. In AI SDK 6, onChunk only received a subset of stream parts such as text deltas, reasoning deltas, sources, tool calls, tool input deltas, tool results, custom parts, and raw chunks.

Update handlers that assume the old subset to guard the chunk types they process:

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  onChunk({ chunk }) {
5
    if (chunk.type === 'text-delta') {
6
      console.log(chunk.text);
7
    }
8
  },
9
});

onChunk can now also receive lifecycle, boundary, and terminal parts such as start, start-step, text-start, text-end, reasoning-start, reasoning-end, tool-input-end, finish-step, finish, abort, and error.

Move includeRawChunks to include.rawChunks

The top-level includeRawChunks option on streamText is deprecated in AI SDK 7. Move it into the include options object as rawChunks.

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  includeRawChunks: true,
5
});

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  include: {
5
    rawChunks: true,
6
  },
7
});

The deprecated top-level option continues to work in AI SDK 7, so you can migrate incrementally.

Rename experimental_include to include

The experimental_include option for generateText, streamText, and ToolLoopAgent is now stable and has been renamed to include.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  experimental_include: {
5
    requestBody: false,
6
  },
7
});

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  include: {
5
    requestBody: false,
6
  },
7
});

The deprecated experimental_include name continues to work for backwards compatibility. If both include and experimental_include are provided, include takes precedence.

Request and Response Bodies Are Excluded by Default

In AI SDK 7, generateText and streamText no longer include request bodies in step results by default. generateText also no longer includes response bodies by default. This reduces memory usage, especially when prompts or provider responses contain large payloads such as images or files.

If your application reads result.request.body, step.request.body, result.response.body, or step.response.body, opt in with include.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  include: {
5
    requestBody: true,
6
    responseBody: true,
7
  },
8
});

For streamText, only requestBody is available:

1
const result = streamText({
2
  model: yourModel,
3
  prompt: 'Hello',
4
  include: {
5
    requestBody: true,
6
  },
7
});

Result Message Changes

Step Response Messages Are No Longer Accumulated

In AI SDK 7, step.response.messages on each StepResult only contains the response messages produced by that particular step.

In AI SDK 6, step.response.messages accumulated response messages from all previous steps. If your application reads step.response.messages from an intermediate or final step and expects the full assistant/tool message history, use the top-level result.responseMessages instead.

1
const result = await generateText({
2
  model: yourModel,
3
  prompt: 'Use tools if needed',
4
  tools,
5
  stopWhen: isStepCount(5),
6
});
7

8
// Accumulated response messages from all steps:
9
const responseMessages = result.responseMessages;
10

11
// Response messages produced by each individual step:
12
const stepMessages = result.steps.map(step => step.response.messages);

If you specifically need to reconstruct response messages from step results, flatten the per-step messages:

1
const responseMessages = result.steps.flatMap(step => step.response.messages);

Prefer result.responseMessages when you want the full response message history. It also includes response messages produced before the first model step, such as tool results from approved tool calls in the input messages.

Tools and Tool Execution

Tool Execution Callbacks

The tool execution callback options for generateText and streamText have been renamed:

• experimental_onToolCallStart is now onToolExecutionStart
• experimental_onToolCallFinish is now onToolExecutionEnd

The old names continue to work as deprecated aliases in AI SDK 7 and will be removed in a future major release. They are only used as fallbacks when the new callback names are not provided.

1
const result = await generateText({
2
  model: yourModel,
3
  tools,
4
  prompt: 'Hello',
5
  experimental_onToolCallStart(event) {
6
    console.log('Tool starting:', event.toolCall.toolName);
7
  },
8
  experimental_onToolCallFinish(event) {
9
    console.log('Tool finished:', event.toolCall.toolName);
10
  },
11
});

1
const result = await generateText({
2
  model: yourModel,
3
  tools,
4
  prompt: 'Hello',
5
  onToolExecutionStart(event) {
6
    console.log('Tool starting:', event.toolCall.toolName);
7
  },
8
  onToolExecutionEnd(event) {
9
    console.log('Tool finished:', event.toolCall.toolName);
10
  },
11
});

Context: experimental_context Became Tool context, and Shared Runtime Data Moved to runtimeContext

In AI SDK 7, the tool callback option previously exposed as experimental_context has been renamed to context and is now stable.

The bigger behavioral change is that AI SDK now separates:

• tool-specific context, which is passed to tool callbacks from toolsContext
• shared generation/agent runtime data, which flows through runtimeContext

In AI SDK 6, tools often read from one generic runtime context object. In AI SDK 7, each tool gets its own scoped context, and you provide those values through toolsContext, keyed by tool name.

tool() infers the type of a tool's context from its contextSchema, so each tool only sees the fields declared for that specific tool.

In AI SDK 6, tool code often accessed experimental_context and had to cast it manually:

1
const weather = tool({
2
  inputSchema: z.object({
3
    location: z.string(),
4
  }),
5
  execute: async ({ location }, { experimental_context }) => {
6
    const { weatherApiKey } = experimental_context as {
7
      weatherApiKey: string;
8
    };
9

10
    return getWeather(location, weatherApiKey);
11
  },
12
});

In AI SDK 7, rename experimental_context to context, declare the tool-specific context with contextSchema, and pass the per-tool values through toolsContext. The execute callback, approval callback, and tool input lifecycle hooks then receive a typed context automatically:

1
const weather = tool({
2
  inputSchema: z.object({
3
    location: z.string(),
4
  }),
5
  contextSchema: z.object({
6
    apiKey: z.string(),
7
  }),
8
  execute: async ({ location }, { context: { apiKey } }) => {
9
    return getWeather(location, apiKey);
10
  },
11
});
12

13
const result = await generateText({
14
  model: yourModel,
15
  tools: { weather },
16
  runtimeContext: {
17
    requestId: 'req-123',
18
  },
19
  toolsContext: {
20
    weather: {
21
      apiKey: process.env.WEATHER_API_KEY!,
22
    },
23
  },
24
  prepareStep: async ({ runtimeContext, toolsContext }) => {
25
    console.log(runtimeContext.requestId);
26
    console.log(toolsContext.weather.apiKey);
27

28
    return {};
29
  },
30
});