Atopos

1
const plannerPrompt = PromptTemplate.fromTemplate(`
2
你是一个任务规划专家。请分析用户的请求，制定执行计划。
3

4
可用工具：
5
{tools}
6

7
请输出 JSON 格式的计划：
8
{{"steps": ["步骤1的描述", "步骤2的描述", ...]}}
9

10
注意：
11
- 如果需要外部信息，安排搜索步骤
12
- 如果需要计算，安排计算步骤
13
- 步骤不超过 5 个
14

15
用户请求：{task}
16
`);
17

18
async function planNode(state: typeof AgentState.State, ws: WebSocket) {
19
  sendStatus(ws, "🧠 正在分析任务并制定计划...");
20

21
  const chain = plannerPrompt.pipe(llm).pipe(parser);
22
  const result = await chain.invoke({
23
    tools: allTools.map(t => `${t.name}: ${t.description}`).join("\n"),
24
    task: state.task,
25
  });
26

27
  let steps: string[];
28
  try {
29
    const jsonMatch = result.match(/\{[\s\S]*\}/);
30
    steps = jsonMatch ? JSON.parse(jsonMatch[0]).steps : [state.task];
31
  } catch {
32
    steps = [state.task];
33
  }
34

35
  const planText = steps.map((s, i) => `  ${i + 1}. ${s}`).join("\n");
36
  sendStatus(ws, `📝 已制定计划：\n${planText}`);
37

38
  return { plan: steps, currentStepIndex: 0 };
39
}

1
const toolSelectorPrompt = PromptTemplate.fromTemplate(`
2
你是一个工具选择专家。请根据当前步骤，选择最合适的工具并生成参数。
3

4
当前任务步骤：
5
{currentStep}
6

7
可用工具列表：
8
{toolsList}
9

10
请输出 JSON 格式，选择一个工具：
11
{{
12
  "thought": "你选择这个工具的原因（1句话）",
13
  "toolName": "工具名称",
14
  "parameters": {{
15
    "参数名1": "参数值1",
16
    "参数名2": "参数值2"
17
  }}
18
}}
19

20
注意：
21
1. 必须从上面的工具列表中选择，不能自己发明工具
22
2. 参数必须符合工具的参数定义
23
3. 如果不需要工具（直接回答即可），toolName 设为 "direct_answer"
24
`);
25

26
async function toolSelectorNode(state: typeof AgentState.State, ws: WebSocket) {
27
  const currentStep = state.plan[state.currentStepIndex];
28

29
  sendStatus(
30
    ws,
31
    `🔧 正在为步骤 [${state.currentStepIndex + 1}/${state.plan.length}] 选择工具：${currentStep}`,
32
  );
33

34
  // 把工具列表格式化，告诉 LLM 每个工具的参数要求
35
  const toolsList = allTools.map(tool => {
36
    const paramsDesc = Object.entries(tool.parameters.properties)
37
      .map(([name, prop]) => `  - ${name}: ${prop.description} (${prop.type})`)
38
      .join("\n");
39
    return `${tool.name}: ${tool.description}\n参数：\n${paramsDesc}`;
40
  }).join("\n\n");
41

42
  const chain = toolSelectorPrompt.pipe(llm).pipe(parser);
43
  const result = await chain.invoke({
44
    currentStep,
45
    toolsList,
46
  });
47

48
  let decision: {
49
    thought: string;
50
    toolName: string;
51
    parameters: Record<string, any>;
52
  };
53

54
  try {
55
    const jsonMatch = result.match(/\{[\s\S]*\}/);
56
    decision = jsonMatch ? JSON.parse(jsonMatch[0]) : {
57
      thought: "无法解析，直接回答",
58
      toolName: "direct_answer",
59
      parameters: {},
60
    };
61
  } catch {
62
    decision = {
63
      thought: "解析失败，直接回答",
64
      toolName: "direct_answer",
65
      parameters: {},
66
    };
67
  }
68

69
  sendStatus(ws, `  💭 思考：${decision.thought}`);
70
  sendStatus(ws, `  🎯 选择工具：${decision.toolName}`);
71
  if (Object.keys(decision.parameters).length > 0) {
72
    sendStatus(ws, `  📋 参数：${JSON.stringify(decision.parameters)}`);
73
  }
74

75
  return {
76
    thoughts: [decision.thought],
77
    toolCalls: [{
78
      toolName: decision.toolName,
79
      parameters: decision.parameters,
80
      result: "",  // 留空，等 executor 执行后填充
81
    }],
82
  };
83
}

1
async function toolExecutorNode(state: typeof AgentState.State, ws: WebSocket) {
2
  const lastCall = state.toolCalls[state.toolCalls.length - 1];
3
  if (!lastCall || lastCall.result) {
4
    return {};
5
  }
6

7
  // 直接回答，不需要调用工具
8
  if (lastCall.toolName === "direct_answer") {
9
    sendStatus(ws, "  ✅ 不需要调用工具，直接回答");
10
    return {
11
      toolCalls: [{
12
        ...lastCall,
13
        result: "直接基于已有信息回答",
14
      }],
15
    };
16
  }
17

18
  // 找到对应的工具
19
  const tool = allTools.find(t => t.name === lastCall.toolName);
20
  if (!tool) {
21
    const error = `工具不存在：${lastCall.toolName}`;
22
    sendStatus(ws, `  ❌ ${error}`);
23
    return {
24
      toolCalls: [{ ...lastCall, result: error }],
25
    };
26
  }
27

28
  sendStatus(ws, `  ⚡ 正在执行 ${tool.name}...`);
29

30
  try {
31
    // 执行工具
32
    const result = await tool.execute(lastCall.parameters);
33
    sendStatus(ws, `  ✅ 工具执行完成`);
34
    sendStatus(ws, `  📄 结果：${result.slice(0, 100)}${result.length > 100 ? "..." : ""}`);
35

36
    return {
37
      toolCalls: [{ ...lastCall, result }],
38
    };
39
  } catch (error: any) {
40
    const errorMsg = `工具执行失败：${error.message}`;
41
    sendStatus(ws, `  ❌ ${errorMsg}`);
42
    return {
43
      toolCalls: [{ ...lastCall, result: errorMsg }],
44
    };
45
  }
46
}

1
const replannerPrompt = PromptTemplate.fromTemplate(`
2
你是一个任务评估专家。请判断当前任务是否已经完成。
3

4
原始任务：{task}
5

6
已完成的工具调用和结果：
7
{toolResults}
8

9
请输出 JSON 格式的决策：
10
{{
11
  "status": "complete" 或 "continue",
12
  "reason": "你的判断理由（1句话）",
13
  "result": "如果 complete，这里是最终的总结回答；如果 continue，可以为空"
14
}}
15

16
注意：
17
- 只有当已有信息足够完整回答用户问题时，才选 complete
18
- 如果信息不足，选 continue，下一步会继续调用工具
19
`);
20

21
async function replanNode(state: typeof AgentState.State, ws: WebSocket) {
22
  sendStatus(ws, "📋 正在评估执行结果...");
23

24
  // 格式化工具调用历史
25
  const toolResults = state.toolCalls
26
    .map((call, i) => {
27
      return `调用 ${i + 1}：${call.toolName}\n参数：${JSON.stringify(call.parameters)}\n结果：${call.result}`;
28
    })
29
    .join("\n\n");
30

31
  const chain = replannerPrompt.pipe(llm).pipe(parser);
32
  const response = await chain.invoke({
33
    task: state.task,
34
    toolResults,
35
  });
36

37
  let decision: { status: string; reason: string; result?: string };
38
  try {
39
    const jsonMatch = response.match(/\{[\s\S]*\}/);
40
    decision = jsonMatch ? JSON.parse(jsonMatch[0]) : {
41
      status: "complete",
42
      reason: "解析失败，默认完成",
43
      result: "任务已完成",
44
    };
45
  } catch {
46
    decision = {
47
      status: "complete",
48
      reason: "解析失败，默认完成",
49
      result: "任务已完成",
50
    };
51
  }
52

53
  sendStatus(ws, `  💭 评估：${decision.reason}`);
54

55
  if (decision.status === "complete") {
56
    sendStatus(ws, "🎉 任务完成！");
57
    return {
58
      result: decision.result || "任务已完成",
59
      thoughts: [decision.reason],
60
    };
61
  }
62

63
  // 继续执行下一个步骤
64
  sendStatus(ws, "🔄 继续执行下一步...");
65
  return {
66
    currentStepIndex: state.currentStepIndex + 1,
67
    thoughts: [decision.reason],
68
  };
69
}