Agent 的三种模式：Reactive、Deliberative 与 Hybrid

START → call_model → 条件判断 → call_tool → call_model → ... → END

Step 1:
  Thought: 用户想了解北京天气，我需要调用天气查询工具
  Action: get_weather("北京")

Step 2:
  Observation: 晴，25°C，PM2.5: 35
  Thought: 天气晴朗，温度适宜，空气质量良好，很适合户外跑步

Step 3:
  无需更多工具，最终回答："北京今天晴，25°C，空气质量良好，非常适合跑步"

# agent-playground/app/core/state.py
from typing import Annotated, TypedDict
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages


class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]

# agent-playground/app/core/llm.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()


def create_llm(tools=None):
    llm = ChatOpenAI(
        model=os.getenv("DEEPSEEK_MODEL", "deepseek-chat"),
        base_url=os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1"),
        api_key=os.getenv("DEEPSEEK_API_KEY", ""),
        temperature=0,
    )
    if tools:
        llm = llm.bind_tools(tools)
    return llm

# agent-playground/app/core/graph.py
from langgraph.constants import END
from langgraph.graph import START, StateGraph
from langgraph.prebuilt import ToolNode
from .state import AgentState


def build_reactive_graph(llm, tools, max_steps=10):
    def call_model(state: AgentState) -> dict:
        response = llm.invoke(state["messages"])
        step = state.get("step_count", 0) + 1
        print(f"\n--- Step {step} ---")
        if hasattr(response, "tool_calls") and response.tool_calls:
            for tc in response.tool_calls:
                print(f"  Action: {tc['name']}({tc['args']})")
        else:
            print(f"  Response: {response.content[:100]}...")
        return {"messages": [response], "step_count": step}

    def should_continue(state: AgentState) -> str:
        last_message = state["messages"][-1]
        if state.get("step_count", 0) >= max_steps:
            return END
        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
            return "call_tool"
        return END

    def observe_result(state: AgentState) -> dict:
        last_message = state["messages"][-1]
        print(f"  Observation: {last_message.content[:100]}")
        return {}

    workflow = StateGraph(AgentState)
    workflow.add_node("call_model", call_model)
    workflow.add_node("call_tool", ToolNode(tools))
    workflow.add_node("observe", observe_result)

    workflow.add_edge(START, "call_model")
    workflow.add_conditional_edges("call_model", should_continue, {
        "call_tool": "call_tool",
        END: END,
    })
    workflow.add_edge("call_tool", "observe")
    workflow.add_edge("observe", "call_model")

    return workflow.compile()

# agent-playground/app/core/agent.py
from langchain_core.messages import HumanMessage
from .llm import create_llm
from .graph import build_reactive_graph
from .tools import get_tools


def create_reactive_agent():
    tools = get_tools()
    llm = create_llm(tools)
    return build_reactive_graph(llm, tools)


def run_agent(agent, user_input: str):
    result = agent.invoke({"messages": [HumanMessage(content=user_input)]})
    return result["messages"][-1].content

# agent-playground/main.py
from app.core.agent import create_reactive_agent, run_agent


agent = create_reactive_agent()
answer = run_agent(agent, "北京今天天气怎么样？")
print(f"\n最终回答: {answer}")

--- Step 1 ---
  Action: search_tool({'query': '北京今天天气'})
--- Step 2 ---
  Observation: 北京今天晴，气温22°C ~ 32°C，空气质量良
--- Step 3 ---
  Response: 北京今天晴，气温在22°C到32°C之间...

User → Planner → [Step1, Step2, Step3, ...]
                    ↓
              Executor（逐步执行）
                    ↓
              Replanner → 结果 OK？→ 结束
                    ↓ 结果不行
              调整计划，重新执行

# agent-playground/app/core/state.py
from typing import Annotated, TypedDict
from langchain_core.messages import BaseMessage
from langgraph.graph.message import add_messages


class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]
    step_count: int


class DeliberativeState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]
    plan: list[str]
    current_step: int
    step_results: dict[int, str]
    original_question: str
    tool_rounds: int

# agent-playground/app/core/graph.py（追加到文件末尾）

import json

from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
from langgraph.constants import END
from langgraph.graph import START, StateGraph
from langgraph.prebuilt import ToolNode
from .state import DeliberativeState

PLANNER_PROMPT = SystemMessage(content="""你是一个任务分解专家。请将用户的请求分解为可执行的步骤列表。

规则：
1. 每个步骤应该是一个独立、可执行的操作
2. 步骤之间应该有明确的先后顺序
3. 返回格式为 JSON 数组，每个元素是一个步骤描述字符串
4. 如果任务简单，可能只有 1-2 个步骤

示例：
用户："调研 Django 和 Flask 的性能差异"
输出：["搜索 Django 性能数据", "搜索 Flask 性能数据", "对比两者的性能差异并输出结论"]
""")

EXECUTOR_PROMPT = SystemMessage(content="""你正在执行一个任务计划中的某一个步骤。
当前步骤是你唯一需要关注的任务，请使用可用的工具完成它。
完成后，简洁地输出执行结果。""")

REPLANNER_PROMPT = SystemMessage(content="""你是一个任务审核专家。请检查以下已完成步骤的结果，判断是否需要调整后续计划。

已完成的步骤及其结果：
{step_results}

剩余步骤：
{remaining_steps}

如果需要调整计划（比如某步骤的结果表明后续方向需要改变），请返回更新后的剩余步骤 JSON 数组。
如果不需要调整，请返回原来的剩余步骤。""")


def build_deliberative_graph(plan_llm, execute_llm, tools, max_tool_rounds_per_step=2):
    llm_with_tools = execute_llm.bind_tools(tools)

    def parse_plan(content: str) -> list[str]:
        if "```" in content:
            content = content.split("```")[1]
            if content.startswith("json"):
                content = content[4:]
        try:
            plan = json.loads(content)
            if isinstance(plan, list):
                return [str(step).strip() for step in plan if str(step).strip()]
        except json.JSONDecodeError:
            pass
        return [
            line.strip("- ").strip()
            for line in content.strip().split("\n")
            if line.strip()
        ]

    def current_tool_exchange(messages):
        for idx in range(len(messages) - 1, -1, -1):
            message = messages[idx]
            if hasattr(message, "tool_calls") and message.tool_calls:
                return messages[idx:]
        return []

    def current_tool_observations(messages) -> list[str]:
        return [
            message.content
            for message in current_tool_exchange(messages)
            if isinstance(message, ToolMessage)
        ]

    def planner(state: DeliberativeState) -> dict:
        user_msg = state["messages"][-1]
        response = plan_llm.invoke([PLANNER_PROMPT, user_msg])
        plan = parse_plan(response.content)
        if not plan:
            plan = [user_msg.content]
        print(f"\n[Plan] {' → '.join(plan)}")
        return {
            "plan": plan,
            "current_step": 0,
            "step_results": {},
            "original_question": user_msg.content,
            "tool_rounds": 0,
        }

    def executor(state: DeliberativeState) -> dict:
        step_idx = state["current_step"]
        step_desc = state["plan"][step_idx]
        print(f"\n[Execute] Step {step_idx + 1}/{len(state['plan'])}: {step_desc}")

        previous_results = "\n".join(
            f"{state['plan'][idx]}: {result}"
            for idx, result in sorted(state["step_results"].items())
        ) or "暂无"
        task_msg = HumanMessage(content=f"请完成以下任务步骤：{step_desc}")
        context_msg = HumanMessage(content=(
            f"用户原始问题：{state.get('original_question', '')}\n\n"
            f"已完成步骤结果：\n{previous_results}"
        ))
        messages = [EXECUTOR_PROMPT, context_msg, task_msg]
        if isinstance(state["messages"][-1], ToolMessage):
            messages.extend(current_tool_exchange(state["messages"]))

        response = llm_with_tools.invoke(messages)
        if hasattr(response, "tool_calls") and response.tool_calls:
            for tool_call in response.tool_calls:
                print(f"  Action: {tool_call['name']}({tool_call['args']})")
        else:
            print(f"  Result: {response.content[:100]}")
        return {"messages": [response]}

    def observe_tool_result(state: DeliberativeState) -> dict:
        tool_messages = [
            message for message in state["messages"]
            if isinstance(message, ToolMessage)
        ]
        if tool_messages:
            observations = [message.content for message in tool_messages[-2:]]
            print(f"  Observation: {' | '.join(observations)[:160]}")
        return {"tool_rounds": state.get("tool_rounds", 0) + 1}

    def record_step_result(state: DeliberativeState) -> dict:
        step_idx = state["current_step"]
        response = state["messages"][-1]
        new_results = dict(state["step_results"])
        if isinstance(response, ToolMessage):
            observations = current_tool_observations(state["messages"])
            content = "\n".join(observations) or response.content
            print(f"  Result: {content[:100]}")
        else:
            content = response.content
        new_results[step_idx] = content
        return {
            "step_results": new_results,
            "current_step": step_idx + 1,
            "tool_rounds": 0,
        }

    def replanner(state: DeliberativeState) -> dict:
        if state["current_step"] >= len(state["plan"]):
            return {}  # 全部完成，不需要重规划

        remaining = state["plan"][state["current_step"]:]
        results_str = "\n".join(
            f"Step {k+1}: {v}" for k, v in state["step_results"].items()
        )
        prompt = HumanMessage(content=REPLANNER_PROMPT.content.format(
            step_results=results_str,
            remaining_steps="\n".join(remaining),
        ))
        response = plan_llm.invoke([prompt])
        new_plan = parse_plan(response.content)
        if new_plan and new_plan != remaining:
            print(f"\n[Replan] 调整计划: {' → '.join(new_plan)}")
            updated_plan = (
                state["plan"][:state["current_step"]] + new_plan
            )
            return {"plan": updated_plan}
        return {}

    def should_continue_after_planning(state: DeliberativeState) -> str:
        if state["current_step"] >= len(state["plan"]):
            return "summarize"
        return "executor"

    def should_continue_after_executor(state: DeliberativeState) -> str:
        last_message = state["messages"][-1]
        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
            return "call_tool"
        return "record_step_result"

    def should_continue_after_observation(state: DeliberativeState) -> str:
        if state.get("tool_rounds", 0) >= max_tool_rounds_per_step:
            print("  Tool limit reached for this step; using current observations.")
            return "record_step_result"
        return "executor"

    def should_continue_after_step(state: DeliberativeState) -> str:
        if state["current_step"] >= len(state["plan"]):
            return "summarize"
        if state["current_step"] > 0 and state["current_step"] % 3 == 0:
            return "replanner"
        return "executor"

    def summarize(state: DeliberativeState) -> dict:
        results_str = "\n".join(
            f"{state['plan'][k]}: {v}"
            for k, v in sorted(state["step_results"].items())
        )
        summary_prompt = HumanMessage(content=(
            "请根据以下执行结果，生成最终回答：\n\n" + results_str
        ))
        response = plan_llm.invoke([summary_prompt])
        print(f"\n[Final] {response.content[:100]}")
        return {"messages": [response]}

    workflow = StateGraph(DeliberativeState)
    workflow.add_node("planner", planner)
    workflow.add_node("executor", executor)
    workflow.add_node("call_tool", ToolNode(tools))
    workflow.add_node("observe_tool_result", observe_tool_result)
    workflow.add_node("record_step_result", record_step_result)
    workflow.add_node("replanner", replanner)
    workflow.add_node("summarize", summarize)

    workflow.add_edge(START, "planner")
    workflow.add_conditional_edges("planner", should_continue_after_planning, {
        "executor": "executor",
        "summarize": "summarize",
    })
    workflow.add_conditional_edges("executor", should_continue_after_executor, {
        "call_tool": "call_tool",
        "record_step_result": "record_step_result",
    })
    workflow.add_edge("call_tool", "observe_tool_result")
    workflow.add_conditional_edges("observe_tool_result", should_continue_after_observation, {
        "executor": "executor",
        "record_step_result": "record_step_result",
    })
    workflow.add_conditional_edges("record_step_result", should_continue_after_step, {
        "executor": "executor",
        "replanner": "replanner",
        "summarize": "summarize",
    })
    workflow.add_edge("replanner", "executor")
    workflow.add_edge("summarize", END)

    return workflow.compile()

# agent-playground/app/core/agent.py（追加）
from .graph import build_deliberative_graph


def create_deliberative_agent():
    tools = get_tools()
    plan_llm = create_llm()     # 负责规划，不需要工具
    execute_llm = create_llm()  # 负责执行，工具在 graph 内部绑定
    return build_deliberative_graph(plan_llm, execute_llm, tools)

# agent-playground/main.py
from app.core.agent import create_deliberative_agent, run_agent


agent = create_deliberative_agent()
answer = run_agent(agent, "调研 Django 和 Flask 的性能差异")
print(f"\n最终回答: {answer}")

# agent-playground/app/core/graph.py（追加，Hybrid 模式）

from langgraph.constants import END
from langgraph.graph import START, StateGraph
from langgraph.prebuilt import ToolNode
from .state import HybridState


def build_hybrid_graph(
    plan_llm,
    execute_llm,
    tools,
    max_steps=10,
    max_tool_rounds_per_step=2,
):
    reactive_llm_with_tools = execute_llm.bind_tools(tools)
    deliberative_nodes = _create_deliberative_nodes(
        plan_llm,
        execute_llm.bind_tools(tools),
        max_tool_rounds_per_step,
    )

    def router(state: HybridState) -> dict:
        user_msg = state["messages"][-1]
        content = user_msg.content.lower()
        complex_markers = [
            "调研", "研究", "分析", "比较", "对比", "规划", "计划",
            "总结", "多步", "步骤", "方案", "benchmark", "performance",
            "compare", "research", "analyze",
        ]
        is_complex = len(user_msg.content) > 40 or any(
            marker in content for marker in complex_markers
        )
        mode = "deliberative" if is_complex else "reactive"
        print(f"\n[Hybrid] Route: {mode}")
        return {"mode": mode, "original_question": user_msg.content}

    def choose_mode(state: HybridState) -> str:
        return state.get("mode", "reactive")

    def reactive_call_model(state: HybridState) -> dict:
        response = reactive_llm_with_tools.invoke(
            [SYSTEM_PROMPT] + state["messages"]
        )
        step = state.get("step_count", 0) + 1
        print(f"\n[Reactive] Step {step}")
        if hasattr(response, "tool_calls") and response.tool_calls:
            for tool_call in response.tool_calls:
                print(f"  Action: {tool_call['name']}({tool_call['args']})")
        else:
            print(f"  Response: {response.content[:100]}...")
        return {"messages": [response], "step_count": step}

    def reactive_observe(state: HybridState) -> dict:
        last_message = state["messages"][-1]
        print(f"  Observation: {last_message.content[:100]}")
        return {}

    def should_continue_reactive(state: HybridState) -> str:
        last_message = state["messages"][-1]
        if state.get("step_count", 0) >= max_steps:
            return END
        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
            return "reactive_call_tool"
        return END

    workflow = StateGraph(HybridState)
    workflow.add_node("router", router)
    workflow.add_node("reactive_call_model", reactive_call_model)
    workflow.add_node("reactive_call_tool", ToolNode(tools))
    workflow.add_node("reactive_observe", reactive_observe)
    _add_deliberative_nodes(workflow, deliberative_nodes, tools)

    workflow.add_edge(START, "router")
    workflow.add_conditional_edges("router", choose_mode, {
        "reactive": "reactive_call_model",
        "deliberative": "planner",
    })
    workflow.add_conditional_edges("reactive_call_model", should_continue_reactive, {
        "reactive_call_tool": "reactive_call_tool",
        END: END,
    })
    workflow.add_edge("reactive_call_tool", "reactive_observe")
    workflow.add_edge("reactive_observe", "reactive_call_model")
    _add_deliberative_edges(workflow, deliberative_nodes)

    return workflow.compile()