Migrate AI SDK 5.x to 6.0

Recommended Migration Process

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

AI SDK 6.0 Package Versions

You need to update the following packages to the latest versions in your package.json file(s):

ai package: ^6.0.0
@ai-sdk/provider package: ^3.0.0
@ai-sdk/provider-utils package: ^4.0.0
@ai-sdk/* packages: ^3.0.0

An example upgrade command would be:

pnpm install ai@latest @ai-sdk/react@latest @ai-sdk/openai@latest

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 v6 codemods (v5 → v6 migration) by running the following command from the root of your project:

npx @ai-sdk/codemod v6

Note

There is also an npx @ai-sdk/codemod upgrade command, but it runs all codemods from all versions (v4, v5, and v6). Use v6 when upgrading from v5.

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

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

For example, to run a specific v6 codemod:

npx @ai-sdk/codemod v6/rename-text-embedding-to-embedding src/

Note

Codemods are intended as a tool to help you with the upgrade process. They may not cover all of the changes you need to make. You may need to make additional changes manually.

Codemod Table

Codemod Name	Description
`rename-text-embedding-to-embedding`	Renames `textEmbeddingModel` to `embeddingModel` and `textEmbedding` to `embedding` on providers
`rename-mock-v2-to-v3`	Renames V2 mock classes from `ai/test` to V3 (e.g., `MockLanguageModelV2` → `MockLanguageModelV3`)
`rename-tool-call-options-to-tool-execution-options`	Renames the `ToolCallOptions` type to `ToolExecutionOptions`
`rename-core-message-to-model-message`	Renames the `CoreMessage` type to `ModelMessage`
`rename-converttocoremessages-to-converttomodelmessages`	Renames `convertToCoreMessages` function to `convertToModelMessages`
`rename-vertex-provider-metadata-key`	Renames `google` to `vertex` in `providerMetadata` and `providerOptions` for Google Vertex files
`wrap-tomodeloutput-parameter`	Wraps `toModelOutput` parameter in object destructuring (`output` → `{ output }`)
`add-await-converttomodelmessages`	Adds `await` to `convertToModelMessages` calls (now async in AI SDK 6)

AI SDK Core

`Experimental_Agent` to `ToolLoopAgent` Class

The Experimental_Agent class has been replaced with the ToolLoopAgent class. Two key changes:

The system parameter has been renamed to instructions
The default stopWhen has changed from isStepCount(1) to isStepCount(20)

import { Experimental_Agent as Agent, isStepCount } from 'ai';

const agent = new Agent({
  model: 'anthropic/claude-sonnet-5.5',
  system: 'You are a helpful assistant.',
  tools: {
    // your tools here
  },
  stopWhen: isStepCount(20), // Required for multi-step agent loops
});

const result = await agent.generate({
  prompt: 'What is the weather in San Francisco?',
});

import { ToolLoopAgent } from 'ai';

const agent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-5.5',
  instructions: 'You are a helpful assistant.',
  tools: {
    // your tools here
  },
  // stopWhen defaults to isStepCount(20)
});

const result = await agent.generate({
  prompt: 'What is the weather in San Francisco?',
});

Learn more about building agents.

`CoreMessage` Removal

The deprecated CoreMessage type and related functions have been removed (PR #10710). Replace convertToCoreMessages with convertToModelMessages.

import { convertToCoreMessages, type CoreMessage } from 'ai';

const coreMessages = convertToCoreMessages(messages); // CoreMessage[]

import { convertToModelMessages, type ModelMessage } from 'ai';

const modelMessages = await convertToModelMessages(messages); // ModelMessage[]

Note

Use the rename-core-message-to-model-message and rename-converttocoremessages-to-converttomodelmessages codemods to automatically update your codebase.

`generateObject` and `streamObject` Deprecation

generateObject and streamObject have been deprecated (PR #10754). They will be removed in a future version. Use generateText and streamText with an output setting instead.

import { generateObject } from 'ai';
import { z } from 'zod';

const { object } = await generateObject({
  model: 'anthropic/claude-sonnet-5.5',
  schema: z.object({
    recipe: z.object({
      name: z.string(),
      ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
      steps: z.array(z.string()),
    }),
  }),
  prompt: 'Generate a lasagna recipe.',
});

import { generateText, Output } from 'ai';
import { z } from 'zod';

const { output } = await generateText({
  model: 'anthropic/claude-sonnet-5.5',
  output: Output.object({
    schema: z.object({
      recipe: z.object({
        name: z.string(),
        ingredients: z.array(
          z.object({ name: z.string(), amount: z.string() }),
        ),
        steps: z.array(z.string()),
      }),
    }),
  }),
  prompt: 'Generate a lasagna recipe.',
});

For streaming structured data, replace streamObject with streamText:

import { streamObject } from 'ai';
import { z } from 'zod';

const { partialObjectStream } = streamObject({
  model: 'anthropic/claude-sonnet-5.5',
  schema: z.object({
    recipe: z.object({
      name: z.string(),
      ingredients: z.array(z.object({ name: z.string(), amount: z.string() })),
      steps: z.array(z.string()),
    }),
  }),
  prompt: 'Generate a lasagna recipe.',
});

for await (const partialObject of partialObjectStream) {
  console.log(partialObject);
}

import { streamText, Output } from 'ai';
import { z } from 'zod';

const { partialOutputStream } = streamText({
  model: 'anthropic/claude-sonnet-5.5',
  output: Output.object({
    schema: z.object({
      recipe: z.object({
        name: z.string(),
        ingredients: z.array(
          z.object({ name: z.string(), amount: z.string() }),
        ),
        steps: z.array(z.string()),
      }),
    }),
  }),
  prompt: 'Generate a lasagna recipe.',
});

for await (const partialObject of partialOutputStream) {
  console.log(partialObject);
}

Learn more about generating structured data.

async `convertToModelMessages`

convertToModelMessages() is async in AI SDK 6 to support async Tool.toModelOutput().

import { convertToModelMessages } from 'ai';

const modelMessages = convertToModelMessages(uiMessages);

import { convertToModelMessages } from 'ai';

const modelMessages = await convertToModelMessages(uiMessages);

Note

Use the add-await-converttomodelmessages codemod to automatically update your codebase.

`Tool.toModelOutput` changes

toModelOutput() receives a parameter object with an output property in AI SDK 6.

In AI SDK 5, the output was the arguments.

import { tool } from 'ai';

const someTool = tool({
  // ...
  toModelOutput: output => {
    // ...
  },
});

import { tool } from 'ai';

const someTool = tool({
  // ...
  toModelOutput: ({ output }) => {
    // ...
  },
});

Note

Use the wrap-tomodeloutput-parameter codemod to automatically update your codebase.

Remove `name` from Function Tool Definitions

Function tool names come from their keys in the tools object. In AI SDK 5, a name property could pass type checking because it was part of the provider-defined member of the Tool type, but it did not set the name of a function tool. The AI SDK 6 types no longer accept the property in a function tool definition.

Remove name from tool() and use the intended name as the key in the tools object:

import { tool } from 'ai';
import { z } from 'zod';

const tools = {
  getWeather: tool({
    name: 'getWeather',
    inputSchema: z.object({}),
    outputSchema: z.any(),
  }),
};

import { tool } from 'ai';
import { z } from 'zod';

const tools = {
  getWeather: tool({
    inputSchema: z.object({}),
    outputSchema: z.any(),
  }),
};

`cachedInputTokens` and `reasoningTokens` in `LanguageModelUsage` Deprecation

cachedInputTokens and reasoningTokens in LanguageModelUsage have been deprecated.

You can replace cachedInputTokens with inputTokenDetails.cacheReadTokens and reasoningTokens with outputTokenDetails.reasoningTokens.

`ToolCallOptions` to `ToolExecutionOptions` Rename

The ToolCallOptions type has been renamed to ToolExecutionOptions and is now deprecated.

Note

Use the rename-tool-call-options-to-tool-execution-options codemod to automatically update your codebase.

Per-Tool Strict Mode

Strict mode for tools is now controlled by setting strict on each tool (PR #10817). This enables fine-grained control over strict tool calls, which is important since strict mode depends on the specific tool input schema.

import { streamText, tool } from 'ai';
import { z } from 'zod';

// Tool strict mode was controlled by strictJsonSchema
const result = streamText({
  model: 'anthropic/claude-sonnet-5.5',
  tools: {
    calculator: tool({
      description: 'A simple calculator',
      inputSchema: z.object({
        expression: z.string(),
      }),
      execute: async ({ expression }) => {
        const result = eval(expression);
        return { result };
      },
    }),
  },
  providerOptions: {
    openai: {
      strictJsonSchema: true, // Applied to all tools
    },
  },
});

import { streamText, tool } from 'ai';
import { z } from 'zod';

const result = streamText({
  model: 'anthropic/claude-sonnet-5.5',
  tools: {
    calculator: tool({
      description: 'A simple calculator',
      inputSchema: z.object({
        expression: z.string(),
      }),
      execute: async ({ expression }) => {
        const result = eval(expression);
        return { result };
      },
      strict: true, // Control strict mode per tool
    }),
  },
});

Flexible Tool Content

AI SDK 6 introduces more flexible tool output and result content support (PR #9605), enabling richer tool interactions and better support for complex tool execution patterns.

`ToolCallRepairFunction` Signature

The system parameter in the ToolCallRepairFunction type now accepts SystemModelMessage in addition to string (PR #10635). This allows for more flexible system message configuration, including provider-specific options like caching.

import type { ToolCallRepairFunction } from 'ai';

const repairToolCall: ToolCallRepairFunction<MyTools> = async ({
  system, // type: string | undefined
  messages,
  toolCall,
  tools,
  inputSchema,
  error,
}) => {
  // ...
};

import type { ToolCallRepairFunction, SystemModelMessage } from 'ai';

const repairToolCall: ToolCallRepairFunction<MyTools> = async ({
  system, // type: string | SystemModelMessage | undefined
  messages,
  toolCall,
  tools,
  inputSchema,
  error,
}) => {
  // Handle both string and SystemModelMessage
  const systemText = typeof system === 'string' ? system : system?.content;
  // ...
};

Embedding Model Method Rename

The textEmbeddingModel and textEmbedding methods on providers have been renamed to embeddingModel and embedding respectively. Additionally, generics have been removed from EmbeddingModel, embed, and embedMany (PR #10592).

import { openai } from '@ai-sdk/openai';
import { embed } from 'ai';

// Using the full method name
const model = openai.textEmbeddingModel('text-embedding-3-small');

// Using the shorthand
const model = openai.textEmbedding('text-embedding-3-small');

const { embedding } = await embed({
  model: openai.textEmbedding('text-embedding-3-small'),
  value: 'sunny day at the beach',
});

import { openai } from '@ai-sdk/openai';
import { embed } from 'ai';

// Using the full method name
const model = openai.embeddingModel('text-embedding-3-small');

// Using the shorthand
const model = openai.embedding('text-embedding-3-small');

const { embedding } = await embed({
  model: openai.embedding('text-embedding-3-small'),
  value: 'sunny day at the beach',
});

Note

Use the rename-text-embedding-to-embedding codemod to automatically update your codebase.

Warning Logger

AI SDK 6 introduces a warning logger that outputs deprecation warnings and best practice recommendations (PR #8343).

To disable warning logging, set the AI_SDK_LOG_WARNINGS environment variable to false:

export AI_SDK_LOG_WARNINGS=false

Warning Type Unification

Separate warning types for each generation function have been consolidated into a single Warning type exported from the ai package (PR #10631).

// Separate warning types for each generation function
import type {
  CallWarning,
  ImageModelCallWarning,
  SpeechWarning,
  TranscriptionWarning,
} from 'ai';

// Single Warning type for all generation functions
import type { Warning } from 'ai';

Finish reason "unknown" merged into "other"

The unknown finish reason has been removed. It is now returned as other.

AI SDK UI

Tool UI Part Approval States

AI SDK 6 adds approval-requested, approval-responded, and output-denied to the tool UI part state union. Update exhaustive switch statements and other state handling to cover the three approval states.

switch (part.state) {
  case 'input-streaming':
    return 'Loading input';
  case 'input-available':
    return 'Input ready';
  case 'approval-requested':
    return 'Approval requested';
  case 'approval-responded':
    return 'Approval response received';
  case 'output-available':
    return 'Output ready';
  case 'output-error':
    return part.errorText;
  case 'output-denied':
    return 'Tool call denied';
}

See Tool execution approval for handling approval requests and responses in a chat UI.

Tool UI Part Helper Functions Rename

The tool UI part helper functions have been renamed to better reflect their purpose and to accommodate both static and dynamic tool parts (PR #XXXX).

`isToolUIPart` → `isStaticToolUIPart`

The isToolUIPart function has been renamed to isStaticToolUIPart to clarify that it checks for static tool parts only.

import { isToolUIPart } from 'ai';

// Check if a part is a tool UI part
if (isToolUIPart(part)) {
  console.log(part.toolName);
}

import { isStaticToolUIPart } from 'ai';

// Check if a part is a static tool UI part
if (isStaticToolUIPart(part)) {
  console.log(part.toolName);
}

`isToolOrDynamicToolUIPart` → `isToolUIPart`

The isToolOrDynamicToolUIPart function has been renamed to isToolUIPart. The old name is deprecated but still available.

import { isToolOrDynamicToolUIPart } from 'ai';

// Check if a part is either a static or dynamic tool UI part
if (isToolOrDynamicToolUIPart(part)) {
  console.log('Tool part found');
}

import { isToolUIPart } from 'ai';

// Check if a part is either a static or dynamic tool UI part
if (isToolUIPart(part)) {
  console.log('Tool part found');
}

`getToolName` → `getStaticToolName`

The getToolName function has been renamed to getStaticToolName to clarify that it returns the tool name from static tool parts only.

import { getToolName } from 'ai';

// Get the tool name from a tool part
const name = getToolName(toolPart);

import { getStaticToolName } from 'ai';

// Get the tool name from a static tool part
const name = getStaticToolName(toolPart);

`getToolOrDynamicToolName` → `getToolName`

The getToolOrDynamicToolName function has been renamed to getToolName. The old name is deprecated but still available.

import { getToolOrDynamicToolName } from 'ai';

// Get the tool name from either a static or dynamic tool part
const name = getToolOrDynamicToolName(toolPart);

import { getToolName } from 'ai';

// Get the tool name from either a static or dynamic tool part
const name = getToolName(toolPart);

Providers

OpenAI

`strictJsonSchema` Defaults to True

The strictJsonSchema setting for JSON outputs and tool calls is enabled by default (PR #10752). This improves stability and ensures valid JSON output that matches your schema.

However, strict mode is stricter about schema requirements. If you receive schema rejection errors, adjust your schema (for example, use null instead of undefined) or disable strict mode.

import { openai } from '@ai-sdk/openai';
import { generateObject } from 'ai';
import { z } from 'zod';

// strictJsonSchema was false by default
const result = await generateObject({
  model: openai('gpt-5.1'),
  schema: z.object({
    name: z.string(),
  }),
  prompt: 'Generate a person',
});

import { openai } from '@ai-sdk/openai';
import { generateObject } from 'ai';
import { z } from 'zod';

// strictJsonSchema is true by default
const result = await generateObject({
  model: openai('gpt-5.1'),
  schema: z.object({
    name: z.string(),
  }),
  prompt: 'Generate a person',
});

// Disable strict mode if needed
const resultNoStrict = await generateObject({
  model: openai('gpt-5.1'),
  schema: z.object({
    name: z.string(),
  }),
  prompt: 'Generate a person',
  providerOptions: {
    openai: {
      strictJsonSchema: false,
    } satisfies OpenAIResponsesProviderOptions,
  },
});

`structuredOutputs` Option Removed from Chat Model

The structuredOutputs provider option has been removed from chat models (PR #10752). Use strictJsonSchema instead.

Azure

Default Provider Uses Responses API

The @ai-sdk/azure provider now uses the Responses API by default when calling azure() (PR #9868). To use the previous Chat Completions API behavior, use azure.chat() instead.

import { azure } from '@ai-sdk/azure';

// Used Chat Completions API
const model = azure('gpt-4o');

import { azure } from '@ai-sdk/azure';

// Now uses Responses API by default
const model = azure('gpt-4o');

// Use azure.chat() for Chat Completions API
const chatModel = azure.chat('gpt-4o');

// Use azure.responses() explicitly for Responses API
const responsesModel = azure.responses('gpt-4o');

Note

The Responses and Chat Completions APIs have different behavior and defaults. If you depend on the Chat Completions API, switch your model instance to azure.chat() and audit your configuration.

Responses API `providerMetadata` and `providerOptions` Key

For the Responses API, the @ai-sdk/azure provider now uses azure as the key for providerMetadata and providerOptions instead of openai. The openai key is still supported for providerOptions input, but resulting providerMetadata output now uses azure.

import { azure } from '@ai-sdk/azure';
import { generateText } from 'ai';

const result = await generateText({
  model: azure.responses('gpt-5-mini'), // use your own deployment
  prompt: 'Hello',
  providerOptions: {
    openai: {
      // AI SDK 5: use `openai` key for Responses API options
      reasoningSummary: 'auto',
    },
  },
});

// Accessed metadata via 'openai' key
console.log(result.providerMetadata?.openai?.responseId);

import { azure } from '@ai-sdk/azure';
import { generateText } from 'ai';

const result = await generateText({
  // azure() now uses the Responses API by default
  model: azure('gpt-5-mini'), // use your own deployment
  prompt: 'Hello',
  providerOptions: {
    azure: {
      // AI SDK 6: use `azure` key for Responses API options
      reasoningSummary: 'auto',
    },
  },
});

// Access metadata via 'azure' key
console.log(result.providerMetadata?.azure?.responseId);

Anthropic

Structured Outputs Mode

Anthropic has introduced native structured outputs for Claude Sonnet 4.5 and later models . The @ai-sdk/anthropic provider now includes a structuredOutputMode option to control how structured outputs are generated (PR #10502).

The available modes are:

'outputFormat': Use Anthropic's native output_format parameter
'jsonTool': Use a special JSON tool to specify the structured output format
'auto' (default): Use 'outputFormat' when supported by the model, otherwise fall back to 'jsonTool'

import { anthropic } from '@ai-sdk/anthropic';
import { generateObject } from 'ai';
import { z } from 'zod';

const result = await generateObject({
  model: anthropic('claude-sonnet-4-5-20250929'),
  schema: z.object({
    name: z.string(),
    age: z.number(),
  }),
  prompt: 'Generate a person',
  providerOptions: {
    anthropic: {
      // Explicitly set the structured output mode (optional)
      structuredOutputMode: 'outputFormat',
    } satisfies AnthropicProviderOptions,
  },
});

Google Vertex

`providerMetadata` and `providerOptions` Key

The @ai-sdk/google-vertex provider now uses vertex as the key for providerMetadata and providerOptions instead of google. The google key is still supported for providerOptions input, but resulting providerMetadata output now uses vertex.

import { vertex } from '@ai-sdk/google-vertex';
import { generateText } from 'ai';

const result = await generateText({
  model: vertex('gemini-2.5-flash'),
  providerOptions: {
    google: {
      safetySettings: [
        /* ... */
      ],
    }, // Used 'google' key
  },
  prompt: 'Hello',
});

// Accessed metadata via 'google' key
console.log(result.providerMetadata?.google?.safetyRatings);

import { vertex } from '@ai-sdk/google-vertex';
import { generateText } from 'ai';

const result = await generateText({
  model: vertex('gemini-2.5-flash'),
  providerOptions: {
    vertex: {
      safetySettings: [
        /* ... */
      ],
    }, // Now uses 'vertex' key
  },
  prompt: 'Hello',
});

// Access metadata via 'vertex' key
console.log(result.providerMetadata?.vertex?.safetyRatings);

Note

Use the rename-vertex-provider-metadata-key codemod to automatically update your codebase.

`ai/test`

Mock Classes

V2 mock classes have been removed from the ai/test module. Use the new V3 mock classes instead for testing.

import {
  MockEmbeddingModelV2,
  MockImageModelV2,
  MockLanguageModelV2,
  MockProviderV2,
  MockSpeechModelV2,
  MockTranscriptionModelV2,
} from 'ai/test';

import {
  MockEmbeddingModelV3,
  MockImageModelV3,
  MockLanguageModelV3,
  MockProviderV3,
  MockSpeechModelV3,
  MockTranscriptionModelV3,
} from 'ai/test';

Note

Use the rename-mock-v2-to-v3 codemod to automatically update your codebase.

Recommended Migration Process

AI SDK 6.0 Package Versions

Codemods

Codemod Table

AI SDK Core

Experimental_Agent to ToolLoopAgent Class

CoreMessage Removal

generateObject and streamObject Deprecation

async convertToModelMessages

Tool.toModelOutput changes

Remove name from Function Tool Definitions

cachedInputTokens and reasoningTokens in LanguageModelUsage Deprecation

ToolCallOptions to ToolExecutionOptions Rename

Per-Tool Strict Mode

Flexible Tool Content

ToolCallRepairFunction Signature

Embedding Model Method Rename

Warning Logger

Warning Type Unification

Finish reason "unknown" merged into "other"

AI SDK UI

Tool UI Part Approval States

Tool UI Part Helper Functions Rename

isToolUIPart → isStaticToolUIPart

isToolOrDynamicToolUIPart → isToolUIPart

getToolName → getStaticToolName

getToolOrDynamicToolName → getToolName

Providers

OpenAI

strictJsonSchema Defaults to True

structuredOutputs Option Removed from Chat Model

Azure

Default Provider Uses Responses API

Responses API providerMetadata and providerOptions Key

Anthropic

Structured Outputs Mode

Google Vertex

providerMetadata and providerOptions Key

ai/test

Mock Classes

`Experimental_Agent` to `ToolLoopAgent` Class

`CoreMessage` Removal

`generateObject` and `streamObject` Deprecation

async `convertToModelMessages`

`Tool.toModelOutput` changes

Remove `name` from Function Tool Definitions

`cachedInputTokens` and `reasoningTokens` in `LanguageModelUsage` Deprecation

`ToolCallOptions` to `ToolExecutionOptions` Rename

`ToolCallRepairFunction` Signature

`isToolUIPart` → `isStaticToolUIPart`

`isToolOrDynamicToolUIPart` → `isToolUIPart`

`getToolName` → `getStaticToolName`

`getToolOrDynamicToolName` → `getToolName`

`strictJsonSchema` Defaults to True

`structuredOutputs` Option Removed from Chat Model

Responses API `providerMetadata` and `providerOptions` Key

`providerMetadata` and `providerOptions` Key

`ai/test`