1
function agent(userMessage, tools, maxSteps):
2
    messages = [systemPrompt, userMessage]
3

4
    for step in 1..maxSteps:
5
        response = LLM(messages, tools)
6

7
        if response.hasToolCalls:
8
            for toolCall in response.toolCalls:
9
                result = execute(toolCall.name, toolCall.input)
10
                messages.append(toolCall)       // 记录模型想调什么
11
                messages.append(toolResult)     // 记录工具返回了什么
12
        else:
13
            return response.text   // 模型不再调工具，输出最终回答
14

15
    return "达到最大步数，停止"

1
你是一个 [角色描述]。
2

3
## 能力
4
你可以使用以下工具：
5
- getWeather：查询天气。当用户问到天气相关问题时使用。
6
- calculate：数学计算。当需要精确计算时使用，不要自己心算。
7
- searchKnowledge：搜索知识库。当用户问到你不确定的事实时使用。
8

9
## 行为准则
10
1. 先思考是否需要使用工具，不要盲目调用
11
2. 如果一个工具的返回结果不够，可以再调用其他工具补充
12
3. 得到所有需要的信息后，给出完整的中文回答
13
4. 如果工具返回了错误或空结果，告诉用户而不是编造答案
14

15
## 限制
16
- 不要编造工具不存在的功能
17
- 不要在一次回答中调用超过 5 次工具

1
## 回答流程
2
在每次决定是否调用工具前，先用 <thinking> 标签思考：
3
1. 用户想知道什么？
4
2. 我目前已经知道哪些信息？
5
3. 还缺少什么信息？需要调用哪个工具？
6
4. 如果信息足够了，直接回答。

1
tool({
2
  description: "数据库操作",  // 太模糊，模型不知道什么时候该用
3
  inputSchema: z.object({
4
    sql: z.string(),  // 让模型写 SQL？灾难
5
  }),
6
})

1
tool({
2
  description: "根据用户ID查询用户信息，返回姓名、邮箱、注册时间",
3
  inputSchema: z.object({
4
    userId: z.string().describe("用户的唯一标识符，格式如 user_123"),
5
  }),
6
})

1
❌ processData(action: "create" | "read" | "update" | "delete", ...)
2
✅ createUser(name, email)
3
✅ getUser(userId)
4
✅ updateUser(userId, fields)
5
✅ deleteUser(userId)

1
❌ date: z.string()  // 模型可能给出 "明天"、"2024-01-01"、"Jan 1" 等各种格式
2
✅ year: z.number(), month: z.number(), day: z.number()  // 结构化，不容易出错

1
// 差：模型不知道单位，可能误解
2
❌ return { temp: 5 }
3

4
// 好：自包含，模型能正确理解和转述
5
✅ return { temp: 5, unit: "°C", city: "北京", condition: "晴" }

1
用户：北京和东京哪个更热？
2

3
Thought: 我需要知道两个城市的温度才能比较。先查北京。
4
Action: getWeather(city="北京")
5
Observation: {temp: 5, condition: "晴"}
6

7
Thought: 北京是 5°C。现在查东京。
8
Action: getWeather(city="东京")
9
Observation: {temp: 8, condition: "小雨"}
10

11
Thought: 北京 5°C，东京 8°C，东京更热。我有足够信息了。
12
Answer: 东京（8°C）比北京（5°C）更热，温差 3°C。

1
用户：帮我调研 React 和 Vue 的区别，写一份对比报告
2

3
Plan:
4
  1. 搜索 React 的核心特点
5
  2. 搜索 Vue 的核心特点
6
  3. 搜索两者的性能对比数据
7
  4. 搜索社区生态对比
8
  5. 综合以上信息撰写报告
9

10
Execute:
11
  Step 1: search("React 核心特点 2024") → ...
12
  Step 2: search("Vue 核心特点 2024") → ...
13
  ...

1
Attempt 1:
2
  Action: search("Python 排序") → 结果不相关
3
  Reflection: 搜索太宽泛，应该具体到算法名称
4

5
Attempt 2:
6
  Action: search("Python quicksort 实现") → 得到有效结果

1
System Prompt:        ~500 tokens
2
工具定义 (3 个工具):    ~800 tokens
3
用户消息:              ~100 tokens
4
每轮工具调用+结果:      ~300-1000 tokens
5
─────────────────────────
6
10 轮交互后:           ~5000-10000 tokens

1
// 当 messages 太长时，用另一个 LLM 调用来压缩历史
2
async function compressHistory(messages: Message[]): Promise<Message[]> {
3
  const summary = await generateText({
4
    model: deepseek("deepseek-chat"),
5
    prompt: `总结以下对话的关键信息，保留所有重要的事实和决策：
6
    ${JSON.stringify(messages)}`,
7
  });
8

9
  return [
10
    messages[0],  // 保留 system prompt
11
    { role: "system", content: `之前的对话摘要：${summary.text}` },
12
    ...messages.slice(-4),  // 保留最近 4 条消息
13
  ];
14
}

1
用户提问 → 向量搜索相关文档 → 把相关片段塞进 context → LLM 生成回答
2
// 概念示意
3
const relevantDocs = await vectorDB.search(userQuery, { topK: 5 });
4
const context = relevantDocs.map((d) => d.content).join("\n");
5

6
const response = await generateText({
7
  model: deepseek("deepseek-chat"),
8
  system: `基于以下参考资料回答问题：\n${context}`,
9
  prompt: userQuery,
10
});

1
Planner Agent → Executor Agent → Reviewer Agent
2
     规划            执行            检验
3
// 概念示意
4
const plan = await plannerAgent.generateText({
5
  prompt: "用户想要一个 Todo API，请制定实现计划",
6
});
7

8
const code = await executorAgent.generateText({
9
  prompt: `按照以下计划实现代码：${plan.text}`,
10
});
11

12
const review = await reviewerAgent.generateText({
13
  prompt: `审查以下代码是否符合计划：\n计划：${plan.text}\n代码：${code.text}`,
14
});

1
Manager Agent
2
        /      |      \
3
  Search Agent  Code Agent  Test Agent

1
const managerTools = {
2
  delegateToSearchAgent: tool({
3
    description: "将搜索任务委托给搜索专家",
4
    inputSchema: z.object({ query: z.string() }),
5
    execute: async ({ query }) => {
6
      const result = await searchAgent.generateText({ prompt: query });
7
      return result.text;
8
    },
9
  }),
10
  delegateToCodeAgent: tool({
11
    description: "将编码任务委托给编码专家",
12
    inputSchema: z.object({ task: z.string() }),
13
    execute: async ({ task }) => {
14
      const result = await codeAgent.generateText({ prompt: task });
15
      return result.text;
16
    },
17
  }),
18
};

1
Agent A (乐观视角) ──┐
2
  Agent B (悲观视角) ──┤→ Synthesizer Agent → 最终结论
3
  Agent C (技术视角) ──┘

1
Task Pool: [task1, task2, task3, task4, task5]
2
                    ↑
3
  Agent A (领 task1) | Agent B (领 task2) | Agent C (领 task3)

1
// 工具执行的 wrapper
2
async function safeExecute(
3
  toolName: string,
4
  args: unknown,
5
  impl: Function
6
): Promise<string> {
7
  try {
8
    const result = await Promise.race([
9
      impl(args),
10
      new Promise((_, reject) =>
11
        setTimeout(() => reject(new Error("工具执行超时")), 10000)
12
      ),
13
    ]);
14
    return JSON.stringify(result);
15
  } catch (error) {
16
    // 不要让工具错误崩掉整个 agent
17
    // 而是把错误信息返回给模型，让它决定怎么办
18
    return JSON.stringify({
19
      error: true,
20
      message: `工具 ${toolName} 执行失败: ${error}`,
21
    });
22
  }
23
}

1
// 用 Zod 校验模型的最终输出
2
import { z } from "zod/v4";
3
import { generateObject } from "ai";
4

5
// generateObject 强制模型输出符合 schema 的结构化数据
6
const { object } = await generateObject({
7
  model: deepseek("deepseek-chat"),
8
  schema: z.object({
9
    answer: z.string(),
10
    confidence: z.number().min(0).max(1),
11
    sources: z.array(z.string()),
12
  }),
13
  prompt: "...",
14
});
15
// object 一定是 { answer: string, confidence: number, sources: string[] }
16
// 不符合 schema 的输出会被拒绝并重试

1
interface TestCase {
2
  input: string;
3
  expectedToolCalls?: string[];    // 期望调用的工具名列表
4
  expectedOutputContains?: string[]; // 期望输出包含的关键词
5
  maxStepsAllowed?: number;          // 期望的最大步骤数
6
}
7

8
const testCases: TestCase[] = [
9
  {
10
    input: "北京天气怎么样",
11
    expectedToolCalls: ["getWeather"],
12
    expectedOutputContains: ["北京", "°C"],
13
    maxStepsAllowed: 2,
14
  },
15
  {
16
    input: "北京和东京的温差",
17
    expectedToolCalls: ["getWeather", "getWeather", "calculate"],
18
    expectedOutputContains: ["温差", "3"],
19
    maxStepsAllowed: 5,
20
  },
21
];
22

23
async function runEval(testCases: TestCase[]) {
24
  let passed = 0;
25
  for (const tc of testCases) {
26
    const { text, steps } = await runAgent(tc.input);
27
    const toolsCalled = steps.flatMap((s) => s.toolCalls.map((c) => c.toolName));
28

29
    const toolsMatch = tc.expectedToolCalls
30
      ? JSON.stringify(toolsCalled) === JSON.stringify(tc.expectedToolCalls)
31
      : true;
32
    const outputMatch = tc.expectedOutputContains
33
      ? tc.expectedOutputContains.every((kw) => text.includes(kw))
34
      : true;
35
    const stepsOk = tc.maxStepsAllowed
36
      ? steps.length <= tc.maxStepsAllowed
37
      : true;
38

39
    if (toolsMatch && outputMatch && stepsOk) {
40
      passed++;
41
      console.log(`✅ PASS: "${tc.input}"`);
42
    } else {
43
      console.log(`❌ FAIL: "${tc.input}"`);
44
      if (!toolsMatch) console.log(`   工具: 期望 ${tc.expectedToolCalls}, 实际 ${toolsCalled}`);
45
      if (!outputMatch) console.log(`   输出缺少关键词`);
46
      if (!stepsOk) console.log(`   步骤数: ${steps.length} > ${tc.maxStepsAllowed}`);
47
    }
48
  }
49
  console.log(`\n结果: ${passed}/${testCases.length} 通过`);
50
}

1
const judgment = await generateText({
2
  model: deepseek("deepseek-chat"),
3
  prompt: `你是一个评判者。请评估以下 AI 助手的回答质量。
4

5
用户问题：${userQuestion}
6
助手回答：${agentAnswer}
7

8
评分标准（1-5 分）：
9
1. 准确性：回答是否基于工具返回的真实数据？
10
2. 完整性：是否回答了用户的所有问题？
11
3. 简洁性：是否有多余的废话？
12

13
请给出评分和理由。`,
14
});

1
readFile(path) → 读文件
2
writeFile(path, content) → 写文件
3
runCommand(cmd) → 执行命令（需要确认）
4
listFiles(dir) → 列目录

1
Planner → [Searcher, Searcher, Searcher] (并行) → Synthesizer → Writer