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)       // record what tool the model wants
11
                messages.append(toolResult)     // record what tool returned
12
        else:
13
            return response.text   // no more tool calls, final answer
14

15
    return "Max steps reached, stop"

1
You are a [role].
2

3
## Capabilities
4
You can use the following tools:
5
- getWeather: query weather. Use when user asks weather-related questions.
6
- calculate: math calculation. Use for precise calculations, do not do mental math.
7
- searchKnowledge: search knowledge base. Use when facts are uncertain.
8

9
## Behavior rules
10
1. Think first whether tools are needed; do not call blindly.
11
2. If one tool result is insufficient, call additional tools.
12
3. After collecting required information, provide a complete Chinese answer.
13
4. If a tool returns error or empty result, tell the user instead of fabricating.
14

15
## Constraints
16
- Do not invent capabilities for tools.
17
- Do not call tools more than 5 times in one response.

1
## Response workflow
2
Before deciding tool calls, think in <thinking> tags:
3
1. What does user want?
4
2. What do I already know?
5
3. What is missing? Which tool should I call?
6
4. If info is sufficient, answer directly.

1
tool({
2
  description: "Database operations",  // too vague
3
  inputSchema: z.object({
4
    sql: z.string(),  // asking model to write SQL directly? risky
5
  }),
6
})

1
tool({
2
  description: "Get user profile by user ID; returns name, email, and signup time",
3
  inputSchema: z.object({
4
    userId: z.string().describe("Unique user identifier, format like 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()  // model may output "tomorrow", "Jan 1", etc.
2
✅ year: z.number(), month: z.number(), day: z.number()  // structured, robust

1
// Bad: model can misinterpret unit
2
❌ return { temp: 5 }
3

4
// Good: self-contained return
5
✅ return { temp: 5, unit: "°C", city: "Beijing", condition: "Sunny" }

1
User: Which city is warmer, Beijing or Tokyo?
2

3
Thought: I need both temperatures. Check Beijing first.
4
Action: getWeather(city="Beijing")
5
Observation: {temp: 5, condition: "Sunny"}
6

7
Thought: Beijing is 5°C. Now check Tokyo.
8
Action: getWeather(city="Tokyo")
9
Observation: {temp: 8, condition: "Light rain"}
10

11
Thought: 8°C > 5°C. I have enough information.
12
Answer: Tokyo (8°C) is warmer than Beijing (5°C), difference is 3°C.

1
User: Compare React vs Vue and write a report.
2

3
Plan:
4
  1. Search core features of React
5
  2. Search core features of Vue
6
  3. Search performance comparison data
7
  4. Search ecosystem comparison
8
  5. Synthesize and write final report
9

10
Execute:
11
  Step 1: search("React core features 2024") → ...
12
  Step 2: search("Vue core features 2024") → ...
13
  ...

1
Attempt 1:
2
  Action: search("Python sorting") → irrelevant results
3
  Reflection: query is too broad; should specify algorithm
4

5
Attempt 2:
6
  Action: search("Python quicksort implementation") → useful results

1
System Prompt:         ~500 tokens
2
Tool definitions (3):  ~800 tokens
3
User message:          ~100 tokens
4
Each tool roundtrip:   ~300-1000 tokens
5
──────────────────────────
6
After 10 rounds:       ~5000-10000 tokens

1
// Compress history with another LLM call when messages grow too long
2
async function compressHistory(messages: Message[]): Promise<Message[]> {
3
  const summary = await generateText({
4
    model: deepseek("deepseek-chat"),
5
    prompt: `Summarize key facts and decisions from the conversation:
6
    ${JSON.stringify(messages)}`,
7
  });
8

9
  return [
10
    messages[0],  // keep system prompt
11
    { role: "system", content: `Conversation summary: ${summary.text}` },
12
    ...messages.slice(-4),  // keep most recent 4 messages
13
  ];
14
}

1
User question → vector search → insert relevant chunks into context → LLM answer
2
// Conceptual example
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: `Answer based on references below:\n${context}`,
9
  prompt: userQuery,
10
});

1
Planner Agent → Executor Agent → Reviewer Agent
2
     plan            execute          verify
3
// Conceptual example
4
const plan = await plannerAgent.generateText({
5
  prompt: "User wants a Todo API, produce an implementation plan",
6
});
7

8
const code = await executorAgent.generateText({
9
  prompt: `Implement code based on this plan: ${plan.text}`,
10
});
11

12
const review = await reviewerAgent.generateText({
13
  prompt: `Review code against plan:\nPlan: ${plan.text}\nCode: ${code.text}`,
14
});

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

1
const managerTools = {
2
  delegateToSearchAgent: tool({
3
    description: "Delegate search tasks to search specialist",
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: "Delegate coding tasks to code specialist",
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 (optimistic) ──┐
2
Agent B (skeptical) ───┤→ Synthesizer Agent → final conclusion
3
Agent C (technical) ───┘

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

1
// Tool execution 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("Tool execution timeout")), 10000)
12
      ),
13
    ]);
14
    return JSON.stringify(result);
15
  } catch (error) {
16
    // Never let tool errors crash the whole agent
17
    // Return structured error to model so it can react
18
    return JSON.stringify({
19
      error: true,
20
      message: `Tool ${toolName} execution failed: ${error}`,
21
    });
22
  }
23
}

1
// Validate model final output with Zod
2
import { z } from "zod/v4";
3
import { generateObject } from "ai";
4

5
// generateObject forces schema-constrained structured outputs
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 is guaranteed to follow schema

1
interface TestCase {
2
  input: string;
3
  expectedToolCalls?: string[];    // expected tool names
4
  expectedOutputContains?: string[]; // expected output keywords
5
  maxStepsAllowed?: number;          // expected max steps
6
}
7

8
const testCases: TestCase[] = [
9
  {
10
    input: "How is Beijing weather",
11
    expectedToolCalls: ["getWeather"],
12
    expectedOutputContains: ["Beijing", "°C"],
13
    maxStepsAllowed: 2,
14
  },
15
  {
16
    input: "Temperature difference between Beijing and Tokyo",
17
    expectedToolCalls: ["getWeather", "getWeather", "calculate"],
18
    expectedOutputContains: ["difference", "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(`   Tools: expected ${tc.expectedToolCalls}, got ${toolsCalled}`);
45
      if (!outputMatch) console.log(`   Output missing expected keywords`);
46
      if (!stepsOk) console.log(`   Steps: ${steps.length} > ${tc.maxStepsAllowed}`);
47
    }
48
  }
49
  console.log(`\nResult: ${passed}/${testCases.length} passed`);
50
}

1
const judgment = await generateText({
2
  model: deepseek("deepseek-chat"),
3
  prompt: `You are a judge. Evaluate this assistant response.
4

5
User question: ${userQuestion}
6
Assistant answer: ${agentAnswer}
7

8
Scoring rubric (1-5):
9
1. Accuracy: Is answer grounded in tool-returned data?
10
2. Completeness: Does it answer all user asks?
11
3. Conciseness: Is there unnecessary filler?
12

13
Provide scores and rationale.`,
14
});

1
readFile(path) → read file
2
writeFile(path, content) → write file
3
runCommand(cmd) → run command (requires confirmation)
4
listFiles(dir) → list directory

1
Planner → [Searcher, Searcher, Searcher] (parallel) → Synthesizer → Writer