Migrate AI SDK 5.x to 6.0 Beta

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

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

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

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

1
import { openai } from '@ai-sdk/openai';
2
import { generateObject } from 'ai';
3
import { z } from 'zod';
4

5
// strictJsonSchema was false by default
6
const result = await generateObject({
7
  model: openai('gpt-4o'),
8
  schema: z.object({
9
    name: z.string(),
10
  }),
11
  prompt: 'Generate a person',
12
});

1
import { openai } from '@ai-sdk/openai';
2
import { generateObject } from 'ai';
3
import { z } from 'zod';
4

5
// strictJsonSchema is true by default
6
const result = await generateObject({
7
  model: openai('gpt-4o'),
8
  schema: z.object({
9
    name: z.string(),
10
  }),
11
  prompt: 'Generate a person',
12
});
13

14
// Disable strict mode if needed
15
const resultNoStrict = await generateObject({
16
  model: openai('gpt-4o'),
17
  schema: z.object({
18
    name: z.string(),
19
  }),
20
  prompt: 'Generate a person',
21
  providerOptions: {
22
    openai: {
23
      strictJsonSchema: false,
24
    } satisfies OpenAIResponsesProviderOptions,
25
  },
26
});

1
import { openai } from '@ai-sdk/openai';
2
import { streamText, tool } from 'ai';
3
import { z } from 'zod';
4

5
// Tool strict mode was controlled by strictJsonSchema
6
const result = streamText({
7
  model: openai('gpt-4o'),
8
  tools: {
9
    calculator: tool({
10
      description: 'A simple calculator',
11
      inputSchema: z.object({
12
        expression: z.string(),
13
      }),
14
      execute: async ({ expression }) => {
15
        const result = eval(expression);
16
        return { result };
17
      },
18
    }),
19
  },
20
  providerOptions: {
21
    openai: {
22
      strictJsonSchema: true, // Applied to all tools
23
    },
24
  },
25
});

1
import { openai } from '@ai-sdk/openai';
2
import { streamText, tool } from 'ai';
3
import { z } from 'zod';
4

5
const result = streamText({
6
  model: openai('gpt-4o'),
7
  tools: {
8
    calculator: tool({
9
      description: 'A simple calculator',
10
      inputSchema: z.object({
11
        expression: z.string(),
12
      }),
13
      execute: async ({ expression }) => {
14
        const result = eval(expression);
15
        return { result };
16
      },
17
      strict: true, // Control strict mode per tool
18
    }),
19
  },
20
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1
import { anthropic } from '@ai-sdk/anthropic';
2
import { generateObject } from 'ai';
3
import { z } from 'zod';
4

5
const result = await generateObject({
6
  model: anthropic('claude-sonnet-4-5-20250929'),
7
  schema: z.object({
8
    name: z.string(),
9
    age: z.number(),
10
  }),
11
  prompt: 'Generate a person',
12
  providerOptions: {
13
    anthropic: {
14
      // Explicitly set the structured output mode (optional)
15
      structuredOutputMode: 'outputFormat',
16
    } satisfies AnthropicProviderOptions,
17
  },
18
});

1
import {
2
  MockEmbeddingModelV2,
3
  MockImageModelV2,
4
  MockLanguageModelV2,
5
  MockProviderV2,
6
  MockSpeechModelV2,
7
  MockTranscriptionModelV2,
8
} from 'ai/test';

1
import {
2
  MockEmbeddingModelV3,
3
  MockImageModelV3,
4
  MockLanguageModelV3,
5
  MockProviderV3,
6
  MockSpeechModelV3,
7
  MockTranscriptionModelV3,
8
} from 'ai/test';

1
// Separate warning types for each generation function
2
import type {
3
  CallWarning,
4
  ImageModelCallWarning,
5
  SpeechWarning,
6
  TranscriptionWarning,
7
} from 'ai';

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

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

3
const repairToolCall: ToolCallRepairFunction<MyTools> = async ({
4
  system, // type: string | undefined
5
  messages,
6
  toolCall,
7
  tools,
8
  inputSchema,
9
  error,
10
}) => {
11
  // ...
12
};

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

3
const repairToolCall: ToolCallRepairFunction<MyTools> = async ({
4
  system, // type: string | SystemModelMessage | undefined
5
  messages,
6
  toolCall,
7
  tools,
8
  inputSchema,
9
  error,
10
}) => {
11
  // Handle both string and SystemModelMessage
12
  const systemText = typeof system === 'string' ? system : system?.content;
13
  // ...
14
};