AI SDK Core：Vercel AI SDK v5/v6 后端AI开发工具包 - 支持OpenAI、Anthropic、Google模型

ai-sdk-core by jezweb/claude-skills

479 周安装量

666 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/jezweb/claude-skills --skill ai-sdk-core

AI/机器学习 Node.js API

🇨🇳中文介绍

AI SDK Core

使用 Vercel AI SDK v5 和 v6 的后端 AI。

安装：

npm install ai @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google zod

AI SDK 6 (稳定版 - 2026年1月)

状态： 稳定 最新版本： ai@6.0.26 (2026年1月)

重大变更：Output API 替代 generateObject/streamObject

⚠️ 重要提示：generateObject() 和 streamObject() 已弃用，并将在未来版本中移除。请使用新的 Output API。

之前 (v5 - 已弃用)：

// ❌ 已弃用 - 将被移除
import { generateObject } from 'ai';

const result = await generateObject({
  model: openai('gpt-5'),
  schema: z.object({ name: z.string(), age: z.number() }),
  prompt: 'Generate a person',
});

之后 (v6 - 请使用此方式)：

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

使用 Output API 进行流式处理

import { streamText, Output } from 'ai';

const result = streamText({
  model: openai('gpt-5'),
  output: Output.object({ schema: personSchema }),
  prompt: 'Generate a person',
});

// 流式传输部分对象
for await (const partialObject of result.objectStream) {
  console.log(partialObject); // { name: "Ali..." } -> { name: "Alice", age: ... }
}

// 获取最终对象
const finalObject = await result.object;

1. 智能体抽象 使用 ToolLoopAgent 类构建智能体的统一接口：

完全控制执行流程、工具循环和状态管理
替代手动工具调用编排

2. 工具执行审批 (人在回路)

使用选择性审批以获得更好的用户体验。并非每次工具调用都需要审批。

tools: {
  payment: tool({
    // 基于输入的动态审批
    needsApproval: async ({ amount }) => amount > 1000,
    inputSchema: z.object({ amount: z.number() }),
    execute: async ({ amount }) => { /* process payment */ },
  }),

  readFile: tool({
    needsApproval: false, // 安全操作不需要审批
    inputSchema: z.object({ path: z.string() }),
    execute: async ({ path }) => fs.readFile(path),
  }),

  deleteFile: tool({
    needsApproval: true, // 破坏性操作始终需要审批
    inputSchema: z.object({ path: z.string() }),
    execute: async ({ path }) => fs.unlink(path),
  }),
}

对于风险取决于参数的操作（例如，支付金额）使用动态审批
对于破坏性操作（删除、修改、购买）始终要求审批
对于安全的读取操作不需要审批
添加系统指令："当工具执行未获批准时，不要重试"
为审批请求实现超时，以防止状态卡住
存储用户对重复操作的偏好

3. RAG 重排序

import { rerank } from 'ai';

const result = await rerank({
  model: cohere.reranker('rerank-v3.5'),
  query: '用户问题',
  documents: searchResults,
  topK: 5,
});

4. MCP 工具 (模型上下文协议)

⚠️ 安全警告：MCP 工具在生产环境中有重大风险。请参阅下面的安全部分。

import { experimental_createMCPClient } from 'ai';

const mcpClient = await experimental_createMCPClient({
  transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem'] },
});

const tools = await mcpClient.tools();

const result = await generateText({
  model: openai('gpt-5'),
  tools,
  prompt: '列出当前目录中的文件',
});

已知问题：MCP 工具可能在流模式下无法执行 (Vercel 社区讨论)。对于 MCP 工具，请使用 generateText() 而不是 streamText()。

MCP 安全注意事项

⚠️ 重要提示：生产环境中的动态 MCP 工具存在安全风险：

工具定义成为你智能体提示的一部分
可能在没有警告的情况下意外更改
被入侵的 MCP 服务器可以注入恶意提示
新工具可以提升用户权限（例如，为只读服务器添加删除功能）

解决方案 - 使用静态工具生成：

// ❌ 有风险：动态工具在你控制之外变化
const mcpClient = await experimental_createMCPClient({ /* ... */ });
const tools = await mcpClient.tools(); // 随时可能改变！

// ✅ 安全：生成静态的、版本化的工具定义
// 步骤 1: 安装 mcp-to-ai-sdk
npm install -g mcp-to-ai-sdk

// 步骤 2: 生成静态工具 (一次性，版本控制)
npx mcp-to-ai-sdk generate stdio 'npx -y @modelcontextprotocol/server-filesystem'

// 步骤 3: 导入静态工具
import { tools } from './generated-mcp-tools';

const result = await generateText({
  model: openai('gpt-5'),
  tools, // 静态的、经过审查的、版本化的
  prompt: '使用工具',
});

最佳实践：生成静态工具，审查它们，提交到版本控制，并且只在有意时更新。

5. 语言模型中间件

import { wrapLanguageModel, extractReasoningMiddleware } from 'ai';

const wrappedModel = wrapLanguageModel({
  model: anthropic('claude-sonnet-4-5-20250929'),
  middleware: extractReasoningMiddleware({ tagName: 'think' }),
});

// 自动从 <think>...</think> 标签中提取推理过程

6. 遥测 (OpenTelemetry)

const result = await generateText({
  model: openai('gpt-5'),
  prompt: 'Hello',
  experimental_telemetry: {
    isEnabled: true,
    functionId: 'my-chat-function',
    metadata: { userId: '123' },
    recordInputs: true,
    recordOutputs: true,
  },
});

官方文档： https://ai-sdk.dev/docs

方法	输出格式	使用场景
`toTextStreamResponse()`	纯文本块	简单的文本流式处理
`toUIMessageStreamResponse()`	带有 JSON 事件的 SSE	聊天 UI (text-start, text-delta, text-end, finish)

workers-ai-provider 版本兼容性

重要提示： workers-ai-provider@2.x 需要 AI SDK v5，而不是 v4。

# ✅ 正确 - AI SDK v5 与 workers-ai-provider v2
npm install ai@^5.0.0 workers-ai-provider@^2.0.0 zod@^3.25.0

# ❌ 错误 - AI SDK v4 会导致错误
npm install ai@^4.0.0 workers-ai-provider@^2.0.0
# 错误："AI SDK 4 only supports models that implement specification version v1"

Zod 版本： AI SDK v5 需要 zod@^3.25.0 或更高版本以支持 zod/v3 和 zod/v4 导出。旧版本 (3.22.x) 会导致构建错误："Could not resolve zod/v4"。

Cloudflare Workers 启动修复

问题： AI SDK v5 + Zod 导致 >270ms 的启动时间 (超过 Workers 400ms 限制)。

// ❌ 不好：顶层导入导致启动开销
import { createWorkersAI } from 'workers-ai-provider';
const workersai = createWorkersAI({ binding: env.AI });

// ✅ 好：在处理器内部延迟初始化
app.post('/chat', async (c) => {
  const { createWorkersAI } = await import('workers-ai-provider');
  const workersai = createWorkersAI({ binding: c.env.AI });
  // ...
});

最小化顶层 Zod 模式
将复杂模式移到路由处理器中
使用 Wrangler 监控启动时间

v5 工具调用变更

parameters → inputSchema (Zod 模式)
工具属性：args → input, result → output
ToolExecutionError 已移除 (现在是 tool-error 内容部分)
maxSteps 参数已移除 → 使用 stopWhen(stepCountIs(n))

v5 新增功能：

动态工具 (根据上下文在运行时添加工具)
智能体类 (带有工具的多步执行)

关键的 v4→v5 迁移

AI SDK v5 引入了广泛的重大变更。如果从 v4 迁移，请遵循本指南。

参数重命名
- maxTokens → maxOutputTokens
- providerMetadata → providerOptions
工具定义
- parameters → inputSchema
- 工具属性：args → input, result → output
消息类型
- CoreMessage → ModelMessage
- Message → UIMessage
- convertToCoreMessages → convertToModelMessages
工具错误处理
- ToolExecutionError 类已移除
- 现在是 tool-error 内容部分
- 支持自动重试
多步执行
- maxSteps → stopWhen
- 使用 stepCountIs() 或 hasToolCall()
消息结构
- 简单的 content 字符串 → parts 数组
- 部分：text, file, reasoning, tool-call, tool-result
流式架构
- 单个块 → start/delta/end 生命周期
- 并发流的唯一 ID
工具流式处理
- 默认启用
- toolCallStreaming 选项已移除
包重组
- ai/rsc → @ai-sdk/rsc
- ai/react → @ai-sdk/react
- LangChainAdapter → @ai-sdk/langchain

import { generateText } from 'ai';

const result = await generateText({
  model: openai.chat('gpt-4-turbo'),
  maxTokens: 500,
  providerMetadata: { openai: { user: 'user-123' } },
  tools: {
    weather: {
      description: '获取天气',
      parameters: z.object({ location: z.string() }),
      execute: async (args) => { /* args.location */ },
    },
  },
  maxSteps: 5,
});

import { generateText, tool, stopWhen, stepCountIs } from 'ai';

const result = await generateText({
  model: openai('gpt-4-turbo'),
  maxOutputTokens: 500,
  providerOptions: { openai: { user: 'user-123' } },
  tools: {
    weather: tool({
      description: '获取天气',
      inputSchema: z.object({ location: z.string() }),
      execute: async ({ location }) => { /* input.location */ },
    }),
  },
  stopWhen: stepCountIs(5),
});

将所有 maxTokens 更新为 maxOutputTokens
将 providerMetadata 更新为 providerOptions
将工具 parameters 转换为 inputSchema
更新工具执行函数：args → input
将 maxSteps 替换为 stopWhen(stepCountIs(n))
更新消息类型：CoreMessage → ModelMessage
移除 ToolExecutionError 处理
更新包导入 (ai/rsc → @ai-sdk/rsc)
测试流式行为 (架构已更改)
更新 TypeScript 类型

AI SDK 提供了迁移工具：

这将自动更新大多数重大变更。请仔细审查更改。

前 15 个错误及解决方案

原因： API 请求失败 (网络、认证、速率限制)。

import { AI_APICallError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_APICallError) {
    console.error('API 调用失败：', error.message);
    console.error('状态码：', error.statusCode);
    console.error('响应：', error.responseBody);

    // 检查常见原因
    if (error.statusCode === 401) {
      // 无效的 API 密钥
    } else if (error.statusCode === 429) {
      // 速率限制 - 实现退避
    } else if (error.statusCode >= 500) {
      // 提供商问题 - 重试
    }
  }
}

在启动时验证 API 密钥
实现带有指数退避的重试逻辑
监控速率限制
优雅地处理网络错误

2. AI_NoObjectGeneratedError

原因： 模型没有生成与模式匹配的有效对象。

import { AI_NoObjectGeneratedError } from 'ai';

try {
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: z.object({ /* 复杂模式 */ }),
    prompt: '生成数据',
  });
} catch (error) {
  if (error instanceof AI_NoObjectGeneratedError) {
    console.error('未生成有效对象');

    // 解决方案：
    // 1. 简化模式
    // 2. 在提示中添加更多上下文
    // 3. 在提示中提供示例
    // 4. 尝试不同的模型 (对于复杂对象，尝试 gpt-5 或 claude-sonnet-4-5)
  }
}

从简单模式开始，逐步增加复杂性
在提示中包含示例："生成一个人，例如：{ name: 'Alice', age: 30 }"
对于复杂的结构化输出使用 GPT-4
首先用样本数据测试模式

3. Worker 启动限制 (270ms+)

原因： Cloudflare Workers 中的 AI SDK v5 + Zod 初始化开销超过启动限制。

// 不好：顶层导入导致启动开销
import { createWorkersAI } from 'workers-ai-provider';
import { complexSchema } from './schemas';

const workersai = createWorkersAI({ binding: env.AI });

// 好：在处理器内部延迟初始化
export default {
  async fetch(request, env) {
    const { createWorkersAI } = await import('workers-ai-provider');
    const workersai = createWorkersAI({ binding: env.AI });

    // 在这里使用 workersai
  }
}

将 AI SDK 导入移到路由处理器内部
最小化顶层 Zod 模式
监控 Worker 启动时间 (必须 <400ms)
使用 Wrangler 的启动时间报告

GitHub 问题： 在 Vercel AI SDK 问题中搜索 "Workers startup limit"

4. streamText 静默失败

原因： 流错误可能被 createDataStreamResponse 吞掉。

状态： ✅ 已解决 - 在 ai@4.1.22 (2025年2月) 中修复

解决方案 (推荐)：

// 使用 onError 回调 (在 v4.1.22 中添加)
const stream = streamText({
  model: openai('gpt-4-turbo'),
  prompt: 'Hello',
  onError({ error }) {
    console.error('流错误：', error);
    // 自定义错误日志记录和处理
  },
});

// 安全地流式处理
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}

替代方案 (手动 try-catch)：

// 如果不使用 onError 回调的回退方案
try {
  const stream = streamText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });

  for await (const chunk of stream.textStream) {
    process.stdout.write(chunk);
  }
} catch (error) {
  console.error('流错误：', error);
}

使用 onError 回调 进行适当的错误捕获 (推荐)
实现服务器端错误监控
显式测试流错误处理
在生产环境中始终在服务器端记录日志

GitHub 问题： #4726 (已解决)

5. AI_LoadAPIKeyError

原因： 缺少或无效的 API 密钥。

import { AI_LoadAPIKeyError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_LoadAPIKeyError) {
    console.error('API 密钥错误：', error.message);

    // 检查：
    // 1. .env 文件存在且已加载
    // 2. 正确的环境变量名称 (OPENAI_API_KEY)
    // 3. 密钥格式有效 (以 sk- 开头)
  }
}

在应用程序启动时验证 API 密钥
使用环境变量验证 (例如，zod)
在开发中提供清晰的错误消息
记录所需的环境变量

6. AI_InvalidArgumentError

原因： 传递给函数的参数无效。

import { AI_InvalidArgumentError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    maxOutputTokens: -1,  // 无效！
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_InvalidArgumentError) {
    console.error('无效参数：', error.message);
    // 检查参数类型和值
  }
}

使用 TypeScript 进行类型检查
在调用 AI SDK 函数之前验证输入
仔细阅读函数签名
检查官方文档以了解参数约束

7. AI_NoContentGeneratedError

原因： 模型没有生成任何内容 (安全过滤器等)。

import { AI_NoContentGeneratedError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: '某些提示',
  });
} catch (error) {
  if (error instanceof AI_NoContentGeneratedError) {
    console.error('未生成任何内容');

    // 可能的原因：
    // 1. 安全过滤器阻止了输出
    // 2. 提示触发了内容策略
    // 3. 模型配置问题

    // 优雅地处理：
    return { text: '无法生成响应。请尝试不同的输入。' };
  }
}

清理用户输入
避免可能触发安全过滤器的提示
有备用消息
记录发生情况以供分析

8. AI_TypeValidationError

原因： 对生成的输出进行 Zod 模式验证失败。

import { AI_TypeValidationError } from 'ai';

try {
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: z.object({
      age: z.number().min(0).max(120),  // 严格验证
    }),
    prompt: '生成人员',
  });
} catch (error) {
  if (error instanceof AI_TypeValidationError) {
    console.error('验证失败：', error.message);

    // 解决方案：
    // 1. 放宽模式约束
    // 2. 在提示中添加更多指导
    // 3. 对于不可靠的字段使用 .optional()
  }
}

从宽松的模式开始，逐渐收紧
对于可能不总是存在的字段使用 .optional()
在字段描述中添加验证提示
用各种提示进行测试

原因： 所有重试尝试都失败了。

import { AI_RetryError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
    maxRetries: 3,  // 默认为 2
  });
} catch (error) {
  if (error instanceof AI_RetryError) {
    console.error('所有重试都失败了');
    console.error('最后错误：', error.lastError);

    // 检查根本原因：
    // - 持续的网络问题
    // - 提供商中断
    // - 无效的配置
  }
}

调查失败的根本原因
如果需要，调整重试配置
为提供商中断实现断路器模式
有备用提供商

10. 速率限制错误

原因： 超过提供商速率限制 (RPM/TPM)。

// 实现指数退避
async function generateWithBackoff(prompt: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await generateText({
        model: openai('gpt-4-turbo'),
        prompt,
      });
    } catch (error) {
      if (error instanceof AI_APICallError && error.statusCode === 429) {
        const delay = Math.pow(2, i) * 1000;  // 指数退避
        console.log(`速率受限，等待 ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
  throw new Error('速率限制重试已用尽');
}

监控速率限制头
对请求进行排队以保持在限制内
如果需要，升级提供商层级
实现请求节流

11. TypeScript 与 Zod 的性能问题

原因： 复杂的 Zod 模式会减慢 TypeScript 类型检查速度。

// 不要在顶层使用深度嵌套的模式：
// const complexSchema = z.object({ /* 100+ 字段 */ });

// 在函数内部定义或使用类型断言：
function generateData() {
  const schema = z.object({ /* 复杂模式 */ });
  return generateObject({ model: openai('gpt-4-turbo'), schema, prompt: '...' });
}

// 或者对于递归模式使用 z.lazy()：
type Category = { name: string; subcategories?: Category[] };
const CategorySchema: z.ZodType<Category> = z.lazy(() =>
  z.object({
    name: z.string(),
    subcategories: z.array(CategorySchema).optional(),
  })
);

避免顶层复杂模式
对于递归类型使用 z.lazy()
将大型模式拆分为较小的模式
在适当的地方使用类型断言

12. 无效的 JSON 响应 (提供商特定)

原因： 某些模型偶尔返回无效的 JSON。

// 使用内置的重试和模式选择
const result = await generateObject({
  model: openai('gpt-4-turbo'),
  schema: mySchema,
  prompt: '生成数据',
  mode: 'json',  // 强制 JSON 模式 (GPT-4 支持)
  maxRetries: 3,  // 在无效 JSON 时重试
});

// 或者手动捕获并重试：
try {
  const result = await generateObject({
    model: openai('gpt-4-turbo

🇺🇸English

AI SDK Core

Backend AI with Vercel AI SDK v5 and v6.

Installation:

npm install ai @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google zod

AI SDK 6 (Stable - January 2026)

Status: Stable Latest: ai@6.0.26 (Jan 2026)

BREAKING: Output API Replaces generateObject/streamObject

⚠️ CRITICAL : generateObject() and streamObject() are DEPRECATED and will be removed in a future version. Use the new Output API instead.

Before (v5 - DEPRECATED):

// ❌ DEPRECATED - will be removed
import { generateObject } from 'ai';

const result = await generateObject({
  model: openai('gpt-5'),
  schema: z.object({ name: z.string(), age: z.number() }),
  prompt: 'Generate a person',
});

After (v6 - USE THIS):

// ✅ NEW OUTPUT API
import { generateText, Output } from 'ai';

const result = await generateText({
  model: openai('gpt-5'),
  output: Output.object({ schema: z.object({ name: z.string(), age: z.number() }) }),
  prompt: 'Generate a person',
});

// Access the typed object
console.log(result.object); // { name: "Alice", age: 30 }

Output Types

import { generateText, Output } from 'ai';

// Object with Zod schema
output: Output.object({ schema: myZodSchema })

// Array of typed objects
output: Output.array({ schema: personSchema })

// Enum/choice from options
output: Output.choice({ choices: ['positive', 'negative', 'neutral'] })

// Plain text (explicit)
output: Output.text()

// Unstructured JSON (no schema validation)
output: Output.json()

Streaming with Output API

import { streamText, Output } from 'ai';

const result = streamText({
  model: openai('gpt-5'),
  output: Output.object({ schema: personSchema }),
  prompt: 'Generate a person',
});

// Stream partial objects
for await (const partialObject of result.objectStream) {
  console.log(partialObject); // { name: "Ali..." } -> { name: "Alice", age: ... }
}

// Get final object
const finalObject = await result.object;

v6 New Features

1. Agent Abstraction Unified interface for building agents with ToolLoopAgent class:

Full control over execution flow, tool loops, and state management
Replaces manual tool calling orchestration

2. Tool Execution Approval (Human-in-the-Loop)

Use selective approval for better UX. Not every tool call needs approval.

tools: {
  payment: tool({
    // Dynamic approval based on input
    needsApproval: async ({ amount }) => amount > 1000,
    inputSchema: z.object({ amount: z.number() }),
    execute: async ({ amount }) => { /* process payment */ },
  }),

  readFile: tool({
    needsApproval: false, // Safe operations don't need approval
    inputSchema: z.object({ path: z.string() }),
    execute: async ({ path }) => fs.readFile(path),
  }),

  deleteFile: tool({
    needsApproval: true, // Destructive operations always need approval
    inputSchema: z.object({ path: z.string() }),
    execute: async ({ path }) => fs.unlink(path),
  }),
}

Best Practices :

Use dynamic approval for operations where risk depends on parameters (e.g., payment amount)
Always require approval for destructive operations (delete, modify, purchase)
Don't require approval for safe read operations
Add system instruction: "When a tool execution is not approved, do not retry it"
Implement timeout for approval requests to prevent stuck states
Store user preferences for repeat actions

Sources :

3. Reranking for RAG

import { rerank } from 'ai';

const result = await rerank({
  model: cohere.reranker('rerank-v3.5'),
  query: 'user question',
  documents: searchResults,
  topK: 5,
});

4. MCP Tools (Model Context Protocol)

⚠️ SECURITY WARNING : MCP tools have significant production risks. See security section below.

import { experimental_createMCPClient } from 'ai';

const mcpClient = await experimental_createMCPClient({
  transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem'] },
});

const tools = await mcpClient.tools();

const result = await generateText({
  model: openai('gpt-5'),
  tools,
  prompt: 'List files in the current directory',
});

Known Issue : MCP tools may not execute in streaming mode (Vercel Community Discussion). Use generateText() instead of streamText() for MCP tools.

MCP Security Considerations

⚠️ CRITICAL : Dynamic MCP tools in production have security risks:

Risks :

Tool definitions become part of your agent's prompt
Can change unexpectedly without warning
Compromised MCP server can inject malicious prompts
New tools can escalate user privileges (e.g., adding delete to read-only server)

Solution - Use Static Tool Generation :

// ❌ RISKY: Dynamic tools change without your control
const mcpClient = await experimental_createMCPClient({ /* ... */ });
const tools = await mcpClient.tools(); // Can change anytime!

// ✅ SAFE: Generate static, versioned tool definitions
// Step 1: Install mcp-to-ai-sdk
npm install -g mcp-to-ai-sdk

// Step 2: Generate static tools (one-time, version controlled)
npx mcp-to-ai-sdk generate stdio 'npx -y @modelcontextprotocol/server-filesystem'

// Step 3: Import static tools
import { tools } from './generated-mcp-tools';

const result = await generateText({
  model: openai('gpt-5'),
  tools, // Static, reviewed, versioned
  prompt: 'Use tools',
});

Best Practice : Generate static tools, review them, commit to version control, and only update intentionally.

Source : Vercel Blog: MCP Security

5. Language Model Middleware

import { wrapLanguageModel, extractReasoningMiddleware } from 'ai';

const wrappedModel = wrapLanguageModel({
  model: anthropic('claude-sonnet-4-5-20250929'),
  middleware: extractReasoningMiddleware({ tagName: 'think' }),
});

// Reasoning extracted automatically from <think>...</think> tags

6. Telemetry (OpenTelemetry)

const result = await generateText({
  model: openai('gpt-5'),
  prompt: 'Hello',
  experimental_telemetry: {
    isEnabled: true,
    functionId: 'my-chat-function',
    metadata: { userId: '123' },
    recordInputs: true,
    recordOutputs: true,
  },
});

Official Docs: https://ai-sdk.dev/docs

Latest AI Models (2025-2026)

OpenAI

GPT-5.2 (Dec 2025):

400k context window, 128k output tokens
Enhanced reasoning capabilities
Available in API platform

GPT-5.1 (Nov 2025):

Improved speed and efficiency over GPT-5
"Warmer" and more intelligent responses

GPT-5 (Aug 2025):

45% less hallucination than GPT-4o
State-of-the-art in math, coding, visual perception

o3 Reasoning Models (Dec 2025):

o3, o3-pro, o3-mini - Advanced reasoning
o4-mini - Fast reasoning

import { openai } from '@ai-sdk/openai'; const gpt52 = openai('gpt-5.2'); const gpt51 = openai('gpt-5.1'); const gpt5 = openai('gpt-5'); const o3 = openai('o3'); const o3mini = openai('o3-mini');

Anthropic

Claude 4 Family (May-Oct 2025):

Opus 4 (May 22): Best for complex reasoning, $15/$75 per million tokens
Sonnet 4 (May 22): Balanced performance, $3/$15 per million tokens
Opus 4.1 (Aug 5): Enhanced agentic tasks, real-world coding
Sonnet 4.5 (Sept 29): Most capable for coding, agents, computer use
Haiku 4.5 (Oct 15): Small, fast, low-latency model

import { anthropic } from '@ai-sdk/anthropic'; const sonnet45 = anthropic('claude-sonnet-4-5-20250929'); // Latest const opus41 = anthropic('claude-opus-4-1-20250805'); const haiku45 = anthropic('claude-haiku-4-5-20251015');

Google

Gemini 2.5 Family (Mar-Sept 2025):

Pro (March 2025): Most intelligent, #1 on LMArena at launch
Pro Deep Think (May 2025): Enhanced reasoning mode
Flash (May 2025): Fast, cost-effective
Flash-Lite (Sept 2025): Updated efficiency

import { google } from '@ai-sdk/google'; const pro = google('gemini-2.5-pro'); const flash = google('gemini-2.5-flash'); const lite = google('gemini-2.5-flash-lite');

Core Functions

Text Generation

generateText() - Text completion with tools streamText() - Real-time streaming

Structured Output (v6 Output API)

Output.object() - Typed objects with Zod schema (replaces generateObject) Output.array() - Typed arrays Output.choice() - Enum selection Output.json() - Unstructured JSON

See "AI SDK 6" section above for usage examples.

Multi-Modal Capabilities

Speech Synthesis (Text-to-Speech)

import { experimental_generateSpeech as generateSpeech } from 'ai';
import { openai } from '@ai-sdk/openai';

const result = await generateSpeech({
  model: openai.speech('tts-1-hd'),
  voice: 'alloy',
  text: 'Hello, how can I help you today?',
});

// result.audio is an ArrayBuffer containing the audio
const audioBuffer = result.audio;

Supported Providers:

OpenAI: tts-1, tts-1-hd, gpt-4o-mini-tts
ElevenLabs: eleven_multilingual_v2, eleven_turbo_v2
LMNT, Hume

Transcription (Speech-to-Text)

import { experimental_transcribe as transcribe } from 'ai';
import { openai } from '@ai-sdk/openai';

const result = await transcribe({
  model: openai.transcription('whisper-1'),
  audio: audioFile, // File, Blob, ArrayBuffer, or URL
});

console.log(result.text); // Transcribed text
console.log(result.segments); // Timestamped segments

Supported Providers:

OpenAI: whisper-1
ElevenLabs, Deepgram, AssemblyAI, Groq, Rev.ai

Image Generation

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

const result = await generateImage({
  model: openai.image('dall-e-3'),
  prompt: 'A futuristic city at sunset',
  size: '1024x1024',
  n: 1,
});

// result.images is an array of generated images
const imageUrl = result.images[0].url;
const imageBase64 = result.images[0].base64;

Supported Providers:

OpenAI: dall-e-2, dall-e-3
Google: imagen-3.0
Fal AI, Black Forest Labs (Flux), Luma AI, Replicate

Embeddings

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

// Single embedding
const result = await embed({
  model: openai.embedding('text-embedding-3-small'),
  value: 'Hello world',
});
console.log(result.embedding); // number[]

// Multiple embeddings (parallel processing)
const results = await embedMany({
  model: openai.embedding('text-embedding-3-small'),
  values: ['Hello', 'World', 'AI'],
  maxParallelCalls: 5, // Parallel processing
});

// Compare similarity
const similarity = cosineSimilarity(
  results.embeddings[0],
  results.embeddings[1]
);
console.log(`Similarity: ${similarity}`); // 0.0 to 1.0

Supported Providers:

OpenAI: text-embedding-3-small, text-embedding-3-large
Google: text-embedding-004
Cohere, Voyage AI, Mistral, Amazon Bedrock

Multi-Modal Prompts (Files, Images, PDFs)

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

const result = await generateText({
  model: google('gemini-2.5-pro'),
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'Summarize this document' },
      { type: 'file', data: pdfBuffer, mimeType: 'application/pdf' },
    ],
  }],
});

// Or with images
const result = await generateText({
  model: openai('gpt-5'),
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'What is in this image?' },
      { type: 'image', image: imageBuffer },
    ],
  }],
});

See official docs for full API: https://ai-sdk.dev/docs/ai-sdk-core

v5 Stream Response Methods

When returning streaming responses from an API, use the correct method:

Method	Output Format	Use Case
`toTextStreamResponse()`	Plain text chunks	Simple text streaming
`toUIMessageStreamResponse()`	SSE with JSON events	Chat UIs (text-start, text-delta, text-end, finish)

For chat widgets and UIs, always usetoUIMessageStreamResponse():

const result = streamText({
  model: workersai('@cf/qwen/qwen3-30b-a3b-fp8'),
  messages,
  system: 'You are helpful.',
});

// ✅ For chat UIs - returns SSE with JSON events
return result.toUIMessageStreamResponse({
  headers: { 'Access-Control-Allow-Origin': '*' },
});

// ❌ For simple text - returns plain text chunks only
return result.toTextStreamResponse();

Note: toDataStreamResponse() does NOT exist in AI SDK v5 (common misconception).

workers-ai-provider Version Compatibility

IMPORTANT: workers-ai-provider@2.x requires AI SDK v5, NOT v4.

# ✅ Correct - AI SDK v5 with workers-ai-provider v2
npm install ai@^5.0.0 workers-ai-provider@^2.0.0 zod@^3.25.0

# ❌ Wrong - AI SDK v4 causes error
npm install ai@^4.0.0 workers-ai-provider@^2.0.0
# Error: "AI SDK 4 only supports models that implement specification version v1"

Zod Version: AI SDK v5 requires zod@^3.25.0 or later for zod/v3 and zod/v4 exports. Older versions (3.22.x) cause build errors: "Could not resolve zod/v4".

Cloudflare Workers Startup Fix

Problem: AI SDK v5 + Zod causes >270ms startup time (exceeds Workers 400ms limit).

Solution:

// ❌ BAD: Top-level imports cause startup overhead
import { createWorkersAI } from 'workers-ai-provider';
const workersai = createWorkersAI({ binding: env.AI });

// ✅ GOOD: Lazy initialization inside handler
app.post('/chat', async (c) => {
  const { createWorkersAI } = await import('workers-ai-provider');
  const workersai = createWorkersAI({ binding: c.env.AI });
  // ...
});

Additional:

Minimize top-level Zod schemas
Move complex schemas into route handlers
Monitor startup time with Wrangler

v5 Tool Calling Changes

Breaking Changes:

parameters → inputSchema (Zod schema)
Tool properties: args → input, result → output
ToolExecutionError removed (now tool-error content parts)
maxSteps parameter removed → Use stopWhen(stepCountIs(n))

New in v5:

Dynamic tools (add tools at runtime based on context)
Agent class (multi-step execution with tools)

Critical v4→v5 Migration

AI SDK v5 introduced extensive breaking changes. If migrating from v4, follow this guide.

Breaking Changes Overview

Parameter Renames
- maxTokens → maxOutputTokens
- providerMetadata → providerOptions
Tool Definitions
- parameters → inputSchema
- Tool properties: args → input, result →

Migration Examples

Before (v4):

import { generateText } from 'ai';

const result = await generateText({
  model: openai.chat('gpt-4-turbo'),
  maxTokens: 500,
  providerMetadata: { openai: { user: 'user-123' } },
  tools: {
    weather: {
      description: 'Get weather',
      parameters: z.object({ location: z.string() }),
      execute: async (args) => { /* args.location */ },
    },
  },
  maxSteps: 5,
});

After (v5):

import { generateText, tool, stopWhen, stepCountIs } from 'ai';

const result = await generateText({
  model: openai('gpt-4-turbo'),
  maxOutputTokens: 500,
  providerOptions: { openai: { user: 'user-123' } },
  tools: {
    weather: tool({
      description: 'Get weather',
      inputSchema: z.object({ location: z.string() }),
      execute: async ({ location }) => { /* input.location */ },
    }),
  },
  stopWhen: stepCountIs(5),
});

Migration Checklist

Update all maxTokens to maxOutputTokens
Update providerMetadata to providerOptions
Convert tool parameters to inputSchema
Update tool execute functions: args → input
Replace maxSteps with stopWhen(stepCountIs(n))
Update message types: CoreMessage →

Automated Migration

AI SDK provides a migration tool:

npx ai migrate

This will update most breaking changes automatically. Review changes carefully.

Official Migration Guide: https://ai-sdk.dev/docs/migration-guides/migration-guide-5-0

Top 15 Errors & Solutions

1. AI_APICallError

Cause: API request failed (network, auth, rate limit).

Solution:

import { AI_APICallError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_APICallError) {
    console.error('API call failed:', error.message);
    console.error('Status code:', error.statusCode);
    console.error('Response:', error.responseBody);

    // Check common causes
    if (error.statusCode === 401) {
      // Invalid API key
    } else if (error.statusCode === 429) {
      // Rate limit - implement backoff
    } else if (error.statusCode >= 500) {
      // Provider issue - retry
    }
  }
}

Prevention:

Validate API keys at startup
Implement retry logic with exponential backoff
Monitor rate limits
Handle network errors gracefully

2. AI_NoObjectGeneratedError

Cause: Model didn't generate valid object matching schema.

Solution:

import { AI_NoObjectGeneratedError } from 'ai';

try {
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: z.object({ /* complex schema */ }),
    prompt: 'Generate data',
  });
} catch (error) {
  if (error instanceof AI_NoObjectGeneratedError) {
    console.error('No valid object generated');

    // Solutions:
    // 1. Simplify schema
    // 2. Add more context to prompt
    // 3. Provide examples in prompt
    // 4. Try different model (gpt-5 or claude-sonnet-4-5 for complex objects)
  }
}

Prevention:

Start with simple schemas, add complexity incrementally
Include examples in prompt: "Generate a person like: { name: 'Alice', age: 30 }"
Use GPT-4 for complex structured output
Test schemas with sample data first

3. Worker Startup Limit (270ms+)

Cause: AI SDK v5 + Zod initialization overhead in Cloudflare Workers exceeds startup limits.

Solution:

// BAD: Top-level imports cause startup overhead
import { createWorkersAI } from 'workers-ai-provider';
import { complexSchema } from './schemas';

const workersai = createWorkersAI({ binding: env.AI });

// GOOD: Lazy initialization inside handler
export default {
  async fetch(request, env) {
    const { createWorkersAI } = await import('workers-ai-provider');
    const workersai = createWorkersAI({ binding: env.AI });

    // Use workersai here
  }
}

Prevention:

Move AI SDK imports inside route handlers
Minimize top-level Zod schemas
Monitor Worker startup time (must be <400ms)
Use Wrangler's startup time reporting

GitHub Issue: Search for "Workers startup limit" in Vercel AI SDK issues

4. streamText Fails Silently

Cause: Stream errors can be swallowed by createDataStreamResponse.

Status: ✅ RESOLVED - Fixed in ai@4.1.22 (February 2025)

Solution (Recommended):

// Use the onError callback (added in v4.1.22)
const stream = streamText({
  model: openai('gpt-4-turbo'),
  prompt: 'Hello',
  onError({ error }) {
    console.error('Stream error:', error);
    // Custom error logging and handling
  },
});

// Stream safely
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}

Alternative (Manual try-catch):

// Fallback if not using onError callback
try {
  const stream = streamText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });

  for await (const chunk of stream.textStream) {
    process.stdout.write(chunk);
  }
} catch (error) {
  console.error('Stream error:', error);
}

Prevention:

UseonError callback for proper error capture (recommended)
Implement server-side error monitoring
Test stream error handling explicitly
Always log on server side in production

GitHub Issue: #4726 (RESOLVED)

5. AI_LoadAPIKeyError

Cause: Missing or invalid API key.

Solution:

import { AI_LoadAPIKeyError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_LoadAPIKeyError) {
    console.error('API key error:', error.message);

    // Check:
    // 1. .env file exists and loaded
    // 2. Correct env variable name (OPENAI_API_KEY)
    // 3. Key format is valid (starts with sk-)
  }
}

Prevention:

Validate API keys at application startup
Use environment variable validation (e.g., zod)
Provide clear error messages in development
Document required environment variables

6. AI_InvalidArgumentError

Cause: Invalid parameters passed to function.

Solution:

import { AI_InvalidArgumentError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    maxOutputTokens: -1,  // Invalid!
    prompt: 'Hello',
  });
} catch (error) {
  if (error instanceof AI_InvalidArgumentError) {
    console.error('Invalid argument:', error.message);
    // Check parameter types and values
  }
}

Prevention:

Use TypeScript for type checking
Validate inputs before calling AI SDK functions
Read function signatures carefully
Check official docs for parameter constraints

7. AI_NoContentGeneratedError

Cause: Model generated no content (safety filters, etc.).

Solution:

import { AI_NoContentGeneratedError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Some prompt',
  });
} catch (error) {
  if (error instanceof AI_NoContentGeneratedError) {
    console.error('No content generated');

    // Possible causes:
    // 1. Safety filters blocked output
    // 2. Prompt triggered content policy
    // 3. Model configuration issue

    // Handle gracefully:
    return { text: 'Unable to generate response. Please try different input.' };
  }
}

Prevention:

Sanitize user inputs
Avoid prompts that may trigger safety filters
Have fallback messaging
Log occurrences for analysis

8. AI_TypeValidationError

Cause: Zod schema validation failed on generated output.

Solution:

import { AI_TypeValidationError } from 'ai';

try {
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: z.object({
      age: z.number().min(0).max(120),  // Strict validation
    }),
    prompt: 'Generate person',
  });
} catch (error) {
  if (error instanceof AI_TypeValidationError) {
    console.error('Validation failed:', error.message);

    // Solutions:
    // 1. Relax schema constraints
    // 2. Add more guidance in prompt
    // 3. Use .optional() for unreliable fields
  }
}

Prevention:

Start with lenient schemas, tighten gradually
Use .optional() for fields that may not always be present
Add validation hints in field descriptions
Test with various prompts

9. AI_RetryError

Cause: All retry attempts failed.

Solution:

import { AI_RetryError } from 'ai';

try {
  const result = await generateText({
    model: openai('gpt-4-turbo'),
    prompt: 'Hello',
    maxRetries: 3,  // Default is 2
  });
} catch (error) {
  if (error instanceof AI_RetryError) {
    console.error('All retries failed');
    console.error('Last error:', error.lastError);

    // Check root cause:
    // - Persistent network issue
    // - Provider outage
    // - Invalid configuration
  }
}

Prevention:

Investigate root cause of failures
Adjust retry configuration if needed
Implement circuit breaker pattern for provider outages
Have fallback providers

10. Rate Limiting Errors

Cause: Exceeded provider rate limits (RPM/TPM).

Solution:

// Implement exponential backoff
async function generateWithBackoff(prompt: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await generateText({
        model: openai('gpt-4-turbo'),
        prompt,
      });
    } catch (error) {
      if (error instanceof AI_APICallError && error.statusCode === 429) {
        const delay = Math.pow(2, i) * 1000;  // Exponential backoff
        console.log(`Rate limited, waiting ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
  throw new Error('Rate limit retries exhausted');
}

Prevention:

Monitor rate limit headers
Queue requests to stay under limits
Upgrade provider tier if needed
Implement request throttling

11. TypeScript Performance with Zod

Cause: Complex Zod schemas slow down TypeScript type checking.

Solution:

// Instead of deeply nested schemas at top level:
// const complexSchema = z.object({ /* 100+ fields */ });

// Define inside functions or use type assertions:
function generateData() {
  const schema = z.object({ /* complex schema */ });
  return generateObject({ model: openai('gpt-4-turbo'), schema, prompt: '...' });
}

// Or use z.lazy() for recursive schemas:
type Category = { name: string; subcategories?: Category[] };
const CategorySchema: z.ZodType<Category> = z.lazy(() =>
  z.object({
    name: z.string(),
    subcategories: z.array(CategorySchema).optional(),
  })
);

Prevention:

Avoid top-level complex schemas
Use z.lazy() for recursive types
Split large schemas into smaller ones
Use type assertions where appropriate

Official Docs: https://ai-sdk.dev/docs/troubleshooting/common-issues/slow-type-checking

12. Invalid JSON Response (Provider-Specific)

Cause: Some models occasionally return invalid JSON.

Solution:

// Use built-in retry and mode selection
const result = await generateObject({
  model: openai('gpt-4-turbo'),
  schema: mySchema,
  prompt: 'Generate data',
  mode: 'json',  // Force JSON mode (supported by GPT-4)
  maxRetries: 3,  // Retry on invalid JSON
});

// Or catch and retry manually:
try {
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: mySchema,
    prompt: 'Generate data',
  });
} catch (error) {
  // Retry with different model
  const result = await generateObject({
    model: openai('gpt-4-turbo'),
    schema: mySchema,
    prompt: 'Generate data',
  });
}

Prevention:

Use mode: 'json' when available
Prefer GPT-4 for structured output
Implement retry logic
Validate responses

GitHub Issue: #4302 (Imagen 3.0 Invalid JSON)

13. Gemini Implicit Caching Fails with Tools

Error : No error, but higher API costs due to disabled caching Cause : Google Gemini 3 Flash's cost-saving implicit caching doesn't work when any tools are defined, even if never used. Source : GitHub Issue #11513

Why It Happens : Gemini API disables caching when tools are present in the request, regardless of whether they're invoked.

Prevention :

// Conditionally add tools only when needed
const needsTools = await analyzePrompt(userInput);

const result = await generateText({
  model: google('gemini-3-flash'),
  tools: needsTools ? { weather: weatherTool } : undefined,
  prompt: userInput,
});

Impact : High - Can significantly increase API costs for repeated context

14. Anthropic Tool Error Results Cause JSON Parse Crash

Error : SyntaxError: "[object Object]" is not valid JSON Cause : Anthropic provider built-in tools (web_fetch, etc.) return error objects that SDK tries to JSON.parse Source : GitHub Issue #11856

Why It Happens : When Anthropic built-in tools fail (e.g., url_not_allowed), they return error objects. AI SDK incorrectly tries to parse these as JSON strings.

Prevention :

try {
  const result = await generateText({
    model: anthropic('claude-sonnet-4-5-20250929'),
    tools: { web_fetch: { type: 'anthropic_defined', name: 'web_fetch' } },
    prompt: userPrompt,
  });
} catch (error) {
  if (error.message.includes('is not valid JSON')) {
    // Tool returned error result, handle gracefully
    console.error('Tool execution failed - likely blocked URL or permission issue');
    // Retry without tool or use custom tool
  }
  throw error;
}

Impact : High - Production crashes when using Anthropic built-in tools

15. Tool-Result in Assistant Message (Anthropic)

Error : Anthropic API error - tool-result in assistant message not allowed Cause : Server-executed tools incorrectly place tool-result parts in assistant messages Source : GitHub Issue #11855

Why It Happens : When using server-executed tools (tools where execute runs on server, not sent to model), the AI SDK incorrectly includes tool-result parts in the assistant message. Anthropic expects tool-result only in user messages.

Prevention :

// Workaround: Filter messages before sending
const filteredMessages = messages.map(msg => {
  if (msg.role === 'assistant') {
    return {
      ...msg,
      content: msg.content.filter(part => part.type !== 'tool-result'),
    };
  }
  return msg;
});

const result = await generateText({
  model: anthropic('claude-sonnet-4-5-20250929'),
  tools: { database: databaseTool },
  messages: filteredMessages,
  prompt: 'Get user data',
});

Impact : High - Breaks server-executed tool pattern with Anthropic provider

Status : Known issue, PR #11854 submitted

More Errors: https://ai-sdk.dev/docs/reference/ai-sdk-errors (31 total)

Known Issues & Limitations

useChat Stale Closures with Memoized Options

Issue : When using useChat with memoized options (common for performance), the onData and onFinish callbacks have stale closures and don't see updated state variables.

Source : GitHub Issue #11686

Reproduction :

const [count, setCount] = useState(0);

const chatOptions = useMemo(() => ({
  onFinish: (message) => {
    console.log('Count:', count); // ALWAYS 0, never updates!
  },
}), []); // Empty deps = stale closure

const { messages, append } = useChat(chatOptions);

Workaround 1 - Don't Memoize Callbacks :

const { messages, append } = useChat({
  onFinish: (message) => {
    console.log('Count:', count); // Now sees current count
  },
});

Workaround 2 - Use useRef :

const countRef = useRef(count);
useEffect(() => { countRef.current = count; }, [count]);

const chatOptions = useMemo(() => ({
  onFinish: (message) => {
    console.log('Count:', countRef.current); // Always current
  },
}), []);

Full Repro : https://github.com/alechoey/ai-sdk-stale-ondata-repro

Stream Resumption Fails on Tab Switch

Issue : When users switch browser tabs or background the app during an AI stream, the stream does not resume when they return. The connection is lost and does not automatically reconnect.

Source : GitHub Issue #11865

Impact : High - Major UX issue for long-running streams

Workaround 1 - Implement onError Handler :

const { messages, append, reload } = useChat({
  api: '/api/chat',
  onError: (error) => {
    if (error.message.includes('stream') || error.message.includes('aborted')) {
      // Attempt to reload last message
      reload();
    }
  },
});

Workaround 2 - Detect Visibility Change :

useEffect(() => {
  const handleVisibilityChange = () => {
    if (document.visibilityState === 'visible') {
      // Check if stream was interrupted
      const lastMessage = messages[messages.length - 1];
      if (lastMessage?.role === 'assistant' && !lastMessage.content) {
        reload();
      }
    }
  };

  document.addEventListener('visibilitychange', handleVisibilityChange);
  return () => document.removeEventListener('visibilitychange', handleVisibilityChange);
}, [messages, reload]);

Status : Known limitation, no auto-reconnection built-in

When to Use This Skill

Use ai-sdk-core when:

Building backend AI features (server-side text generation)
Implementing server-side text generation (Node.js, Workers, Next.js)
Creating structured AI outputs (JSON, forms, data extraction)
Building AI agents with tools (multi-step workflows)
Integrating multiple AI providers (OpenAI, Anthropic, Google, Cloudflare)
Migrating from AI SDK v4 to v5
Encountering AI SDK errors (AI_APICallError, AI_NoObjectGeneratedError, etc.)
Using AI in Cloudflare Workers (with workers-ai-provider)
Using AI in Next.js Server Components/Actions
Need consistent API across different LLM providers

Don't use this skill when:

Building React chat UIs (use ai-sdk-ui skill instead)
Need frontend hooks like useChat (use ai-sdk-ui skill instead)
Need advanced topics like embeddings or image generation (check official docs)
Building native Cloudflare Workers AI apps without multi-provider (use cloudflare-workers-ai skill instead)
Need Generative UI / RSC (see https://ai-sdk.dev/docs/ai-sdk-rsc)

Versions

AI SDK:

Stable: ai@6.0.26 (Jan 2026)
⚠️ Skip v6.0.40 - Breaking streaming change (reverted in v6.0.41)
Legacy v5: ai@5.0.117 (ai-v5 tag)
Zod 3.x/4.x both supported

Latest Models (2026):

OpenAI: GPT-5.2, GPT-5.1, GPT-5, o3, o3-mini, o4-mini
Anthropic: Claude Sonnet 4.5, Opus 4.1, Haiku 4.5
Google: Gemini 2.5 Pro/Flash/Lite

Check Latest:

npm view ai version
npm view ai dist-tags

Official Docs

Core:

AI SDK v6: https://ai-sdk.dev/docs
AI SDK Core: https://ai-sdk.dev/docs/ai-sdk-core/overview
Output API: https://ai-sdk.dev/docs/ai-sdk-core/generating-structured-data
v4→v5 Migration: https://ai-sdk.dev/docs/migration-guides/migration-guide-5-0
All Errors (31): https://ai-sdk.dev/docs/reference/ai-sdk-errors
Providers (69+): https://ai-sdk.dev/providers/overview

Multi-Modal:

Speech: https://ai-sdk.dev/docs/ai-sdk-core/speech
Transcription: https://ai-sdk.dev/docs/ai-sdk-core/transcription
Image Generation: https://ai-sdk.dev/docs/ai-sdk-core/image-generation
Embeddings: https://ai-sdk.dev/docs/ai-sdk-core/embeddings

GitHub:

Repository: https://github.com/vercel/ai
Issues: https://github.com/vercel/ai/issues

Last Updated: 2026-01-20 Skill Version: 2.1.0 Changes: Added 3 new errors (Gemini caching, Anthropic tool errors, tool-result placement), MCP security guidance, tool approval best practices, React hooks edge cases, stream resumption workarounds AI SDK: 6.0.26 stable (avoid v6.0.40)

Weekly Installs

479

Repository

jezweb/claude-skills

GitHub Stars

652

First Seen

Jan 20, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

claude-code377

opencode319

gemini-cli313

cursor295

codex276

antigravity265

AI 代码实施计划编写技能 | 自动化开发任务分解与 TDD 流程规划工具

42,300 周安装

Message Types

CoreMessage → ModelMessage
Message → UIMessage
convertToCoreMessages → convertToModelMessages

Tool Error Handling

ToolExecutionError class removed
Now tool-error content parts
Enables automated retry

Multi-Step Execution

maxSteps → stopWhen
Use stepCountIs() or hasToolCall()

Message Structure

Simple content string → parts array
Parts: text, file, reasoning, tool-call, tool-result

Streaming Architecture

Single chunk → start/delta/end lifecycle
Unique IDs for concurrent streams

Tool Streaming

Enabled by default
toolCallStreaming option removed

Package Reorganization

ai/rsc → @ai-sdk/rsc
ai/react → @ai-sdk/react
LangChainAdapter → @ai-sdk/langchain

Remove ToolExecutionError handling

Update package imports (ai/rsc → @ai-sdk/rsc)

Test streaming behavior (architecture changed)

Update TypeScript types

AI SDK Core：Vercel AI SDK v5/v6 后端AI开发工具包 - 支持OpenAI、Anthropic、Google模型

🇨🇳中文介绍

AI SDK Core

AI SDK 6 (稳定版 - 2026年1月)

重大变更：Output API 替代 generateObject/streamObject

相关 Skills

输出类型

使用 Output API 进行流式处理

v6 新功能

最新 AI 模型 (2025-2026)

OpenAI

Anthropic

Google

核心功能

文本生成

结构化输出 (v6 Output API)

多模态能力

语音合成 (文本转语音)

转录 (语音转文本)

图像生成

嵌入

多模态提示 (文件、图像、PDF)

v5 流响应方法

workers-ai-provider 版本兼容性

Cloudflare Workers 启动修复

v5 工具调用变更

关键的 v4→v5 迁移

重大变更概述

迁移示例

迁移清单

自动化迁移

前 15 个错误及解决方案

1. AI_APICallError

2. AI_NoObjectGeneratedError

3. Worker 启动限制 (270ms+)

4. streamText 静默失败

5. AI_LoadAPIKeyError

6. AI_InvalidArgumentError

7. AI_NoContentGeneratedError

8. AI_TypeValidationError

9. AI_RetryError

10. 速率限制错误

11. TypeScript 与 Zod 的性能问题

12. 无效的 JSON 响应 (提供商特定)

🇺🇸English

AI SDK Core

AI SDK 6 (Stable - January 2026)

BREAKING: Output API Replaces generateObject/streamObject

Output Types

Streaming with Output API

v6 New Features

Latest AI Models (2025-2026)

OpenAI

Anthropic

Google

Core Functions

Text Generation

Structured Output (v6 Output API)

Multi-Modal Capabilities

Speech Synthesis (Text-to-Speech)

Transcription (Speech-to-Text)

Image Generation

Embeddings

Multi-Modal Prompts (Files, Images, PDFs)

v5 Stream Response Methods

workers-ai-provider Version Compatibility

Cloudflare Workers Startup Fix

v5 Tool Calling Changes

Critical v4→v5 Migration

Breaking Changes Overview

Migration Examples

Migration Checklist

Automated Migration

Top 15 Errors & Solutions

1. AI_APICallError

2. AI_NoObjectGeneratedError

3. Worker Startup Limit (270ms+)

4. streamText Fails Silently

5. AI_LoadAPIKeyError

6. AI_InvalidArgumentError