Atopos

1
问题 → 拆解 → 研究 → 综合 → 答案
2
   (固定)  (固定)  (固定)

1
[START]
2
   ↓
3
 planner  ← 制定计划（分解成 N 个步骤）
4
   ↓
5
executor ← 执行当前步骤
6
   ↓
7
replanner ← 评估：完成了吗？需要补充吗？
8
   ↓   ↘
9
   ↓    (完成) → [END]
10
   ↓
11
(继续执行) → executor ← 回到执行节点，循环

1
// src/server/handlers/deep-langgraph.ts:57
2
const PlanExecuteState = Annotation.Root({
3
  // 原始任务（只读，不会变）
4
  task: Annotation<string>(),
5

6
  // 当前计划（数组 reducer：新值覆盖旧值）
7
  plan: Annotation<string[]>({
8
    reducer: (_prev, next) => next,
9
    default: () => [],
10
  }),
11

12
  // 已完成的步骤结果（追加 reducer：新值追加到旧值）
13
  completed: Annotation<string[]>({
14
    reducer: (prev, next) => [...prev, ...next],
15
    default: () => [],
16
  }),
17

18
  // 当前执行到第几步（覆盖）
19
  currentStepIndex: Annotation<number>({
20
    reducer: (_prev, next) => next,
21
    default: () => 0,
22
  }),
23

24
  // 最终结果（有值就代表任务完成）
25
  result: Annotation<string>({
26
    reducer: (_prev, next) => next,
27
    default: () => "",
28
  }),
29
});

1
// src/server/handlers/deep-langgraph.ts:256
2
function shouldContinue(
3
  state: typeof PlanExecuteState.State,
4
): "executor" | "replanner" | typeof END {
5
  if (state.result) return END;           // 有结果了 → 结束
6
  if (state.currentStepIndex < state.plan.length)
7
    return "executor";                     // 还有步骤没执行 → 去执行
8
  return "replanner";                      // 执行完了 → 去评估
9
}
10

11
function afterReplan(
12
  state: typeof PlanExecuteState.State,
13
): "executor" | typeof END {
14
  if (state.result) return END;           // 评估完说可以结束 → 结束
15
  return "executor";                       // 评估完说还要继续 → 回去执行
16
}

1
// src/server/handlers/deep-langgraph.ts:278
2
function createGraph(ws: WebSocket) {
3
  return new StateGraph(PlanExecuteState)
4
    .addNode("planner", (s) => planNode(s, ws))
5
    .addNode("executor", (s) => executeNode(s, ws))
6
    .addNode("replanner", (s) => replanNode(s, ws))
7
    .addEdge(START, "planner")                    // 起点 → 规划
8
    .addConditionalEdges("planner", shouldContinue) // 规划后 → 决定去哪
9
    .addConditionalEdges("executor", () => "replanner") // 执行完 → 去评估
10
    .addConditionalEdges("replanner", afterReplan) // 评估后 → 决定继续还是结束
11
    .compile();
12
}

1
用户问：北京有什么美食推荐？
2
  │
3
  ▼
4
[START]
5
  │
6
  ▼
7
planner: 🧠 正在分析任务并制定计划...
8
         📝 已制定计划：
9
           1. 搜索北京著名美食
10
           2. 了解烤鸭的历史背景
11
           3. 整理推荐清单
12
  │
13
  ▼
14
executor: 🔄 正在执行步骤 [1/3]：搜索北京著名美食
15
            ✅ 步骤完成
16
  │
17
  ▼
18
replanner: 📋 正在评估执行进度...
19
           📋 继续执行剩余计划...
20
  │
21
  ▼
22
executor: 🔄 正在执行步骤 [2/3]：了解烤鸭的历史背景
23
            ✅ 步骤完成
24
  │
25
  ▼
26
replanner: 📋 正在评估执行进度...
27
           📋 继续执行剩余计划...
28
  │
29
  ▼
30
executor: 🔄 正在执行步骤 [3/3]：整理推荐清单
31
            ✅ 步骤完成
32
  │
33
  ▼
34
replanner: 📋 所有步骤执行完毕，正在生成总结...
35
           🎉 任务完成！
36
  │
37
  ▼
38
[END]

1
// src/server/handlers/deep-langgraph.ts:299
2
export async function handleDeepLangGraph(
3
  ws: WebSocket,
4
  session: Session,
5
  content: string,
6
): Promise<void> {
7
  if (!content.trim()) {
8
    ws.send(JSON.stringify({ type: "error", content: "消息不能为空" }));
9
    return;
10
  }
11

12
  addUserMessage(session, content);
13

14
  try {
15
    const start = Date.now();
16
    sendStatus(ws, `🚀 启动 LangGraph 深度思考模式...`);
17

18
    // 创建图并执行
19
    const graph = createGraph(ws);
20
    const result = await graph.invoke({ task: content });
21

22
    const elapsed = Date.now() - start;
23
    addAIMessage(session, result.result);
24

25
    // 返回给前端：最终答案 + 耗时 + 每步的详细信息
26
    ws.send(
27
      JSON.stringify({
28
        type: "done",
29
        mode: "deep-langgraph",
30
        content: result.result,
31
        elapsed,
32
        summary: {
33
          totalSteps: result.completed.length,
34
          completed: result.completed,
35
        },
36
      }),
37
    );
38

39
    logger.info(
40
      `[${session.id}] 🧠 deep-langgraph 完成 (${elapsed}ms, ${result.completed.length} 步)`,
41
    );
42
  } catch (error: any) {
43
    logger.error(`[${session.id}] deep-langgraph 调用失败`, error.message);
44
    ws.send(JSON.stringify({ type: "error", content: `请求失败: ${error.message}` }));
45
  }
46
}

1
function sendStatus(ws: WebSocket, content: string) {
2
  try {
3
    if (ws.readyState === WebSocket.OPEN) {
4
      ws.send(JSON.stringify({ type: "status", content }));
5
    }
6
  } catch (err: any) {
7
    logger.error(`❌ 发送状态消息失败: ${err.message}`);
8
  }
9
}

1
🚀 启动 LangGraph 深度思考模式...
2
🧠 正在分析任务并制定计划...
3
📝 已制定计划：
4
  1. 搜索北京著名美食
5
  2. 了解烤鸭的历史背景
6
  3. 整理推荐清单
7
🔄 正在执行步骤 [1/3]：搜索北京著名美食
8
  ✅ 步骤完成
9
📋 正在评估执行进度...
10
...
11
🎉 任务完成！

1
// Planner 的容错
2
let steps: string[];
3
try {
4
  const jsonMatch = result.match(/\{[\s\S]*\}/);
5
  steps = jsonMatch ? JSON.parse(jsonMatch[0]).steps : [state.task];
6
} catch {
7
  steps = [state.task];  // 解析失败？兜底：直接把整个任务当一步
8
}
9

10
// Replanner 的容错
11
let decision: { status: string; result?: string };
12
try {
13
  const jsonMatch = response.match(/\{[\s\S]*\}/);
14
  decision = jsonMatch
15
    ? JSON.parse(jsonMatch[0])
16
    : { status: "continue" };
17
} catch {
18
  decision = { status: "continue" };  // 解析失败？默认继续
19
}

1
// ✅ 好的做法：每次 invoke 时把 ws 注入节点
2
function createGraph(ws: WebSocket) {
3
  return new StateGraph(PlanExecuteState)
4
    .addNode("planner", (s) => planNode(s, ws))
5
    .addNode("executor", (s) => executeNode(s, ws))
6
    .addNode("replanner", (s) => replanNode(s, ws))
7
    // ...
8
    .compile();
9
}
10

11
// handler 里调用
12
const graph = createGraph(ws);
13
const result = await graph.invoke({ task: content });

1
// 给 Executor 加上工具选择能力
2
async function executeNodeWithTools(state, ws) {
3
  // 1. LLM 决定：用哪个工具？还是直接回答？
4
  // 2. 如果选工具 → 调用工具
5
  // 3. 如果不选工具 → 直接回答
6
  // 4. 把结果存入 State
7
}

1
planner → tool_selector → tool_executor → replanner