手把手带你理解OpenManus

BaseAgent (抽象基类)
  └─ ReActAgent (抽象基类)
      └─ ToolCallAgent
          ├─ PlanningAgent
          ├─ SWEAgent
          └─ Manus

async run(request):
  if state != IDLE:
    raise RuntimeError


  if request:
    update_memory(USER, request)


  async with state_context(RUNNING):
    while current_step < max_steps and state != FINISHED:
      current_step += 1
      step_result = await step()  # 调用子类的 step() 方法
      if is_stuck():
         handle_stuck_state()


      results.append(step_result)


    if current_step >= max_steps:
      state = IDLE
      results.append("Terminated: Reached max steps")


  return "\n".join(results)

async step():
  should_act = await think()  # 调用子类的 think()
  if should_act:
    return await act()  # 调用子类的 act()
  else:
    return "Thinking complete - no action needed"

async think():
  # ... (准备消息和工具信息) ...
  response = await llm.ask_tool(...) # 让LLM决定是否调用工具，以及调用哪个工具
  if response.tool_calls:
     self.tool_calls = response.tool_calls
     return True # 需要执行工具
  else:
     return False


async act():
   if self.tool_calls:
      tool_call = self.tool_calls.pop(0) # 取出第一个工具调用
      result = await execute_tool(tool_call)
      await _handle_special_tool(tool_call.function.name,result) # 如果是特殊工具，则处理。
      update_memory(TOOL, result, tool_call_id=tool_call.id)
      return result
   else:
       return "No tool to execute"

async run(request):
  if request:
     await create_initial_plan(request)
  return await super().run()  # 调用 ToolCallAgent.run() -> ReActAgent.run() -> BaseAgent.run()




async create_initial_plan(request):
  # 1. 构造消息，让 LLM 创建计划
  messages = [...]
  response = await llm.ask_tool(..., tool_choice=ToolChoice.AUTO)


  # 2. 处理 LLM 的响应，提取工具调用（应该是 planning 工具的调用）
  for tool_call in response.tool_calls:
    if tool_call.function.name == "planning":
      result = await execute_tool(tool_call) # 执行 planning 工具
      # 3. 将工具执行结果（计划）存入内存
      update_memory(TOOL, result, tool_call_id=tool_call.id)




async think():
    prompt = f"CURRENT PLAN STATUS:\n{await self.get_plan()}\n\n{self.next_step_prompt}"
    self.messages.append(Message.user_message(prompt))
    self.current_step_index = await self._get_current_step_index()
    result = await super().think() # 调用 ToolCallAgent 的 think()


    if result and self.tool_calls:
       # 记录工具和步骤的关联
       latest_tool_call = self.tool_calls[0]
       if latest_tool_call 不是 planning tool 且 不是 special tool:
           self.step_execution_tracker[latest_tool_call.id] = {
               "step_index": self.current_step_index,
               "tool_name": latest_tool_call.function.name,
                "status": "pending"
           }
    return result


async act():
   result = await super().act() # 调用 ToolCallAgent 的 act()
   if self.tool_calls:
       latest_tool_call = self.tool_calls[0]
       if latest_tool_call.id in self.step_execution_tracker:
          self.step_execution_tracker[latest_tool_call.id]["status"] = "completed"
          self.step_execution_tracker[latest_tool_call.id]["result"] = result


          if latest_tool_call 不是 planning tool 且 不是 special tool:
              await self.update_plan_status(latest_tool_call.id)
   return result




async update_plan_status(tool_call_id):
  # 1. 检查 tool_call_id 是否在 tracker 中，以及状态是否为 completed
  # 2. 调用 planning 工具的 mark_step 命令，将对应步骤标记为 completed


async _get_current_step_index():
   # 1. 获取当前计划 (文本)
   # 2. 解析计划文本，找到第一个 [ ] 或 [→] 的步骤
   # 3. 调用 planning 工具的 mark_step 命令，将当前步骤设置为 in_progress
   # 4. 返回步骤索引

async think():
  self.working_dir = await self.bash.execute("pwd")  # 获取当前工作目录
  self.next_step_prompt = self.next_step_prompt.format(current_dir=self.working_dir) # 更新提示
  return await super().think()  # 调用 ToolCallAgent 的 think()