from typing import Annotated, TypedDict, Literal
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI

# 定义状态类型
class AgentState(TypedDict):
    """ReAct智能体状态定义"""
    messages: Annotated[list, "消息历史，包含所有对话和工具调用记录"]
    iteration: int  # 当前迭代次数

def create_react_agent(tools: list, max_iterations: int = 10):
    """
    创建ReAct模式智能体
    
    Args:
        tools: 可用工具列表
        max_iterations: 最大迭代次数，防止无限循环
    
    Returns:
        编译后的LangGraph工作流
    """
    
    # 初始化LLM并绑定工具，使模型能够调用工具
    llm = ChatOpenAI(model="gpt-4").bind_tools(tools)
    # 创建工具节点，用于执行工具调用
    tool_node = ToolNode(tools)
    
    def reasoning_node(state: AgentState) -> AgentState:
        """
        Thought阶段：推理并决定下一步行动
        
        模型分析当前消息历史，决定是否需要调用工具或直接回答
        """
        messages = state["messages"]
        response = llm.invoke(messages)
        return {
            "messages": messages + [response],
            "iteration": state["iteration"] + 1
        }
    
    def should_continue(state: AgentState) -> Literal["tools", "end"]:
        """
        路由函数：决定是否继续执行或结束
        
        Returns:
            "tools": 需要执行工具调用
            "end": 任务完成或达到最大迭代次数
        """
        last_message = state["messages"][-1]
        
        # 安全检查：防止无限循环
        if state["iteration"] >= max_iterations:
            return "end"
        
        # 检查是否有工具调用请求
        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
            return "tools"
        
        return "end"
    
    # ===== 构建状态图 =====
    workflow = StateGraph(AgentState)
    
    # 添加节点
    workflow.add_node("reasoning", reasoning_node)  # Thought: 推理节点
    workflow.add_node("tools", tool_node)           # Action + Observation: 工具执行节点
    
    # 设置入口点
    workflow.set_entry_point("reasoning")
    
    # 添加条件边：根据推理结果决定下一步
    workflow.add_conditional_edges(
        "reasoning",
        should_continue,
        {"tools": "tools", "end": END}
    )
    
    # 工具执行后返回推理节点，形成循环
    workflow.add_edge("tools", "reasoning")
    
    return workflow.compile()

# 使用示例
def run_react_agent(task: str):
    from langchain_core.tools import tool
    
    @tool
    def search(query: str) -> str:
        """搜索信息"""
        return f"搜索结果: 关于'{query}'的相关信息..."
    
    @tool
    def calculate(expression: str) -> str:
        """执行数学计算"""
        return str(eval(expression))
    
    agent = create_react_agent(tools=[search, calculate])
    
    result = agent.invoke({
        "messages": [HumanMessage(content=task)],
        "iteration": 0
    })
    
    return result["messages"][-1].content

from typing import TypedDict, List, Optional, Literal
from dataclasses import dataclass
from enum import Enum
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import json

class StepStatus(Enum):
    """计划步骤状态枚举"""
    PENDING = "pending"         # 待执行
    IN_PROGRESS = "in_progress" # 执行中
    COMPLETED = "completed"     # 已完成
    FAILED = "failed"           # 执行失败

@dataclass
class PlanStep:
    """计划步骤数据类"""
    id: int                      # 步骤ID
    description: str             # 步骤描述
    tools: List[str]             # 所需工具
    dependencies: List[int]      # 依赖的步骤ID
    status: StepStatus = StepStatus.PENDING
    result: Optional[str] = None

# 定义状态类型
class PlanExecuteState(TypedDict):
    """Plan-and-Execute智能体状态定义"""
    task: str                    # 原始任务
    plan: List[dict]             # 执行计划（步骤列表）
    current_step: int            # 当前执行到的步骤索引
    results: List[str]           # 各步骤执行结果
    final_result: Optional[str]  # 最终综合结果

def create_plan_execute_agent(tools: list):
    """
    创建Plan-and-Execute模式智能体
    
    该模式采用"先规划，后执行"的策略：
    1. Planner: 分析任务，生成执行计划
    2. Executor: 按计划逐步执行
    3. Re-planner: 根据执行情况动态调整计划
    4. Synthesizer: 综合所有结果生成最终答案
    
    Args:
        tools: 可用工具列表
    
    Returns:
        编译后的LangGraph工作流
    """
    
    # 规划器使用低温度确保稳定的计划生成
    planner_llm = ChatOpenAI(model="gpt-4", temperature=0)
    # 执行器绑定工具
    executor_llm = ChatOpenAI(model="gpt-4").bind_tools(tools)
    
    def planning_node(state: PlanExecuteState) -> PlanExecuteState:
        """
        规划阶段：创建执行计划
        
        将复杂任务分解为有序的子任务序列
        """
        task = state["task"]
        
        plan_prompt = f"""
        请为以下任务创建详细的执行计划：
        
        任务：{task}
        
        要求：
        1. 将任务分解为3-8个具体步骤
        2. 每个步骤应该是可执行的原子操作
        3. 明确步骤之间的依赖关系
        
        请以JSON数组格式输出，每个步骤包含: id, description, dependencies
        """
        
        response = planner_llm.invoke([HumanMessage(content=plan_prompt)])
        plan = json.loads(response.content)
        
        return {**state, "plan": plan, "current_step": 0, "results": []}
    
    def execution_node(state: PlanExecuteState) -> PlanExecuteState:
        """
        执行阶段：执行当前步骤
        
        根据计划执行具体操作，并收集执行结果
        """
        plan = state["plan"]
        current_step = state["current_step"]
        results = state["results"]
        
        # 边界检查
        if current_step >= len(plan):
            return state
        
        step = plan[current_step]
        
        # 构建执行上下文，包含之前的结果
        exec_prompt = f"""
        请执行以下步骤：
        步骤描述：{step['description']}
        
        之前的执行结果：
        {chr(10).join([f"步骤{i+1}: {r}" for i, r in enumerate(results)])}
        """
        
        response = executor_llm.invoke([HumanMessage(content=exec_prompt)])
        new_results = results + [response.content]
        
        return {**state, "results": new_results, "current_step": current_step + 1}
    
    def replan_node(state: PlanExecuteState) -> PlanExecuteState:
        """
        重规划阶段：根据执行结果调整计划
        
        当执行过程中发现问题或新信息时，动态调整剩余计划
        """
        task = state["task"]
        results = state["results"]
        
        replan_prompt = f"""
        原始任务：{task}
        已完成的步骤结果：{results}
        
        请根据当前进度，评估是否需要调整剩余计划。
        如需调整，请输出新的计划步骤（JSON格式）。
        如不需要调整，输出 "NO_REPLAN"。
        """
        
        response = planner_llm.invoke([HumanMessage(content=replan_prompt)])
        
        if "NO_REPLAN" not in response.content:
            new_plan = json.loads(response.content)
            return {**state, "plan": new_plan, "current_step": 0}
        
        return state
    
    def synthesize_node(state: PlanExecuteState) -> PlanExecuteState:
        """
        综合阶段：整合所有结果
        
        将各步骤的执行结果综合为最终答案
        """
        task = state["task"]
        results = state["results"]
        
        synth_prompt = f"""
        任务：{task}
        
        执行结果：
        {chr(10).join([f"步骤{i+1}: {r}" for i, r in enumerate(results)])}
        
        请综合以上结果，给出最终答案。
        """
        
        response = planner_llm.invoke([HumanMessage(content=synth_prompt)])
        
        return {**state, "final_result": response.content}
    
    def should_continue(state: PlanExecuteState) -> Literal["execute", "replan", "synthesize"]:
        """
        路由函数：决定下一步操作
        
        Returns:
            "execute": 继续执行下一步
            "replan": 触发重规划
            "synthesize": 所有步骤完成，进入综合阶段
        """
        current_step = state["current_step"]
        plan = state["plan"]
        
        # 所有步骤执行完毕
        if current_step >= len(plan):
            return "synthesize"
        
        # 每执行两步检查一次是否需要重规划（可配置）
        if current_step > 0 and current_step % 2 == 0:
            return "replan"
        
        return "execute"
    
    # ===== 构建状态图 =====
    workflow = StateGraph(PlanExecuteState)
    
    # 添加节点
    workflow.add_node("plan", planning_node)       # 规划器
    workflow.add_node("execute", execution_node)   # 执行器
    workflow.add_node("replan", replan_node)       # 重规划器
    workflow.add_node("synthesize", synthesize_node) # 综合器
    
    # 设置入口点
    workflow.set_entry_point("plan")
    
    # 定义执行流程
    workflow.add_edge("plan", "execute")  # 规划完成后开始执行
    workflow.add_conditional_edges(
        "execute",
        should_continue,
        {"execute": "execute", "replan": "replan", "synthesize": "synthesize"}
    )
    workflow.add_edge("replan", "execute")  # 重规划后继续执行
    workflow.add_edge("synthesize", END)    # 综合后结束
    
    return workflow.compile()

# 使用示例
def run_plan_execute_agent(task: str):
    from langchain_core.tools import tool
    
    @tool
    def search(query: str) -> str:
        """搜索信息"""
        return f"搜索结果: {query}"
    
    @tool
    def write_file(content: str) -> str:
        """写入文件"""
        return f"已写入: {content[:50]}..."
    
    agent = create_plan_execute_agent(tools=[search, write_file])
    
    result = agent.invoke({
        "task": task,
        "plan": [],
        "current_step": 0,
        "results": [],
        "final_result": None
    })
    
    return result["final_result"]

from typing import TypedDict, List, Optional, Literal
from datetime import datetime
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import json

# 定义状态类型
class RalphState(TypedDict):
    """Ralph Loop智能体状态定义"""
    task: str                              # 原始任务
    episode_count: int                     # 当前回合数
    max_episodes: int                      # 最大回合数
    reasoning_result: Optional[dict]       # 推理阶段结果
    action_result: Optional[dict]          # 行动阶段结果
    learning_result: Optional[dict]        # 学习阶段结果
    planning_result: Optional[dict]        # 规划阶段结果
    task_completed: bool                   # 任务是否完成
    final_answer: Optional[str]            # 最终答案
    knowledge_base: List[dict]             # 知识库（持久化存储）
    experience_memory: List[dict]          # 经验记忆（情景记忆）

def create_ralph_agent(tools: list, max_episodes: int = 10):
    """
    创建Ralph Loop模式智能体
    
    Ralph = Reasoning + Acting + Learning + Planning
    这是一个具有学习能力的高级智能体模式
    
    Args:
        tools: 可用工具列表（本示例中未使用，可扩展）
        max_episodes: 最大学习回合数
    
    Returns:
        编译后的LangGraph工作流
    """
    
    llm = ChatOpenAI(model="gpt-4", temperature=0)
    
    def reasoning_node(state: RalphState) -> RalphState:
        """
        Phase 1: 推理阶段 (Reasoning)
        
        职责：
        - 评估当前状态
        - 分析问题核心
        - 生成解决假设
        - 推荐行动策略
        """
        task = state["task"]
        kb = state["knowledge_base"]
        memory = state["experience_memory"]
        
        # 检索相关知识和历史经验（简化版，实际可用向量检索）
        relevant_knowledge = kb[-5:] if kb else []
        similar_experiences = memory[-3:] if memory else []
        
        prompt = f"""
        任务: {task}
        
        相关知识: {json.dumps(relevant_knowledge, ensure_ascii=False)}
        类似经验: {json.dumps(similar_experiences, ensure_ascii=False)}
        
        请进行推理分析，输出JSON格式：
        {{
            "state_assessment": "当前状态评估",
            "problem_analysis": "问题核心分析",
            "hypotheses": ["假设1", "假设2"],
            "recommended_action": "推荐的行动策略"
        }}
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        reasoning = json.loads(response.content)
        
        return {**state, "reasoning_result": reasoning}
    
    def acting_node(state: RalphState) -> RalphState:
        """
        Phase 2: 行动阶段 (Acting)
        
        职责：
        - 根据推理结果选择动作
        - 执行动作并收集反馈
        - 记录执行上下文
        """
        task = state["task"]
        reasoning = state["reasoning_result"]
        
        prompt = f"""
        任务: {task}
        推理结果: {json.dumps(reasoning, ensure_ascii=False)}
        
        请执行推荐的行动，输出JSON格式：
        {{
            "action_taken": "执行的动作",
            "parameters": {{}},
            "outcome": "执行结果",
            "success": true,
            "context": "执行上下文"
        }}
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        action_result = json.loads(response.content)
        
        return {**state, "action_result": action_result}
    
    def learning_node(state: RalphState) -> RalphState:
        """
        Phase 3: 学习阶段 (Learning)
        
        职责：
        - 从执行结果中提取经验
        - 识别行为模式
        - 更新知识库
        - 优化执行策略
        """
        action_result = state["action_result"]
        kb = state["knowledge_base"].copy()
        memory = state["experience_memory"].copy()
        
        # 构建经验记录
        experience = {
            "context": action_result.get("context", ""),
            "action": action_result.get("action_taken", ""),
            "outcome": action_result.get("outcome", ""),
            "success": action_result.get("success", False),
            "timestamp": datetime.now().isoformat()
        }
        memory.append(experience)
        
        # 请求LLM识别模式并提取知识
        prompt = f"""
        根据以下经验，提取可学习的知识模式：
        {json.dumps(experience, ensure_ascii=False)}
        
        输出JSON格式：
        {{
            "patterns": ["识别的模式"],
            "new_knowledge": {{"key": "value"}},
            "strategy_updates": ["策略更新建议"]
        }}
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        learning = json.loads(response.content)
        
        # 将新知识添加到知识库
        if learning.get("new_knowledge"):
            kb.append(learning["new_knowledge"])
        
        return {
            **state,
            "learning_result": learning,
            "knowledge_base": kb,
            "experience_memory": memory
        }
    
    def planning_node(state: RalphState) -> RalphState:
        """
        Phase 4: 规划阶段 (Planning)
        
        职责：
        - 根据学习结果设定下一步目标
        - 制定新的执行策略
        - 评估任务是否完成
        """
        task = state["task"]
        learning = state["learning_result"]
        
        prompt = f"""
        任务: {task}
        学习结果: {json.dumps(learning, ensure_ascii=False)}
        
        基于学习到的内容，制定下一轮的计划：
        {{
            "goal": "下一步目标",
            "strategy": "采用的策略",
            "expected_outcome": "预期结果",
            "task_completed": false
        }}
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        planning = json.loads(response.content)
        
        return {
            **state,
            "planning_result": planning,
            "task_completed": planning.get("task_completed", False)
        }
    
    def finalize_node(state: RalphState) -> RalphState:
        """生成最终答案，综合所有学习经验"""
        task = state["task"]
        memory = state["experience_memory"]
        
        prompt = f"""
        任务: {task}
        完整执行历史: {json.dumps(memory, ensure_ascii=False)}
        
        请综合所有经验，生成最终答案。
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        
        return {**state, "final_answer": response.content}
    
    def should_continue(state: RalphState) -> Literal["reasoning", "finalize"]:
        """路由函数：决定是否继续Ralph循环"""
        if state["task_completed"]:
            return "finalize"
        if state["episode_count"] >= state["max_episodes"]:
            return "finalize"
        return "reasoning"
    
    def increment_episode(state: RalphState) -> RalphState:
        """回合计数器，用于跟踪学习进度"""
        return {**state, "episode_count": state["episode_count"] + 1}
    
    # ===== 构建状态图 =====
    workflow = StateGraph(RalphState)
    
    # 添加Ralph四阶段节点
    workflow.add_node("reasoning", reasoning_node)    # R - 推理
    workflow.add_node("acting", acting_node)          # A - 行动
    workflow.add_node("learning", learning_node)      # L - 学习
    workflow.add_node("planning", planning_node)      # P - 规划
    workflow.add_node("increment", increment_episode) # 回合计数
    workflow.add_node("finalize", finalize_node)      # 最终输出
    
    # 设置入口点
    workflow.set_entry_point("reasoning")
    
    # 定义Ralph循环边: R -> A -> L -> P -> increment
    workflow.add_edge("reasoning", "acting")
    workflow.add_edge("acting", "learning")
    workflow.add_edge("learning", "planning")
    workflow.add_edge("planning", "increment")
    
    # 条件边：继续循环或结束
    workflow.add_conditional_edges(
        "increment",
        should_continue,
        {"reasoning": "reasoning", "finalize": "finalize"}
    )
    workflow.add_edge("finalize", END)
    
    return workflow.compile()

# 使用示例
def run_ralph_agent(task: str):
    agent = create_ralph_agent(tools=[], max_episodes=5)
    
    result = agent.invoke({
        "task": task,
        "episode_count": 0,
        "max_episodes": 5,
        "reasoning_result": None,
        "action_result": None,
        "learning_result": None,
        "planning_result": None,
        "task_completed": False,
        "final_answer": None,
        "knowledge_base": [],
        "experience_memory": []
    })
    
    return result["final_answer"]

from typing import TypedDict, List, Literal
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# 定义状态类型
class CoTState(TypedDict):
    """Chain-of-Thought智能体状态定义"""
    problem: str           # 待解决的问题
    steps: List[str]       # 推理步骤列表
    current_step: int      # 当前推理步骤索引
    final_answer: str      # 最终答案

def create_cot_agent(max_steps: int = 5):
    """
    创建Chain-of-Thought模式智能体
    
    通过引导模型逐步展示推理过程来提高复杂问题的解决能力
    每一步都会基于之前的推理结果进行下一步分析
    
    Args:
        max_steps: 最大推理步骤数
    
    Returns:
        编译后的LangGraph工作流
    """
    
    llm = ChatOpenAI(model="gpt-4", temperature=0)
    
    # 预定义的推理步骤引导
    STEP_PROMPTS = [
        "分析问题的关键信息和约束条件",
        "确定解决问题的方法和策略",
        "执行具体的计算或推理过程",
        "验证结果的合理性和完整性",
        "总结并给出最终答案"
    ]
    
    def analyze_step(state: CoTState) -> CoTState:
        """
        执行单步推理
        
        每次调用生成一个推理步骤，并将结果添加到推理链中
        """
        problem = state["problem"]
        steps = state["steps"]
        current = state["current_step"]
        
        # 获取当前步骤的引导提示
        current_prompt = STEP_PROMPTS[current] if current < len(STEP_PROMPTS) else "继续推理"
        
        # 构建包含历史推理的提示
        prompt = f"""
        问题: {problem}
        
        之前的推理步骤:
        {chr(10).join([f"步骤{i+1}: {s}" for i, s in enumerate(steps)])}
        
        当前任务: {current_prompt}
        
        请给出这一步的详细推理过程：
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        new_steps = steps + [response.content]
        
        return {
            **state,
            "steps": new_steps,
            "current_step": current + 1
        }
    
    def finalize_answer(state: CoTState) -> CoTState:
        """
        生成最终答案
        
        综合所有推理步骤，给出简洁明确的最终结论
        """
        problem = state["problem"]
        steps = state["steps"]
        
        prompt = f"""
        问题: {problem}
        
        完整推理过程:
        {chr(10).join([f"步骤{i+1}: {s}" for i, s in enumerate(steps)])}
        
        请基于以上推理，给出简洁明确的最终答案：
        """
        
        response = llm.invoke([HumanMessage(content=prompt)])
        
        return {**state, "final_answer": response.content}
    
    def should_continue(state: CoTState) -> Literal["analyze", "finalize"]:
        """路由函数：决定是否继续推理"""
        if state["current_step"] >= max_steps:
            return "finalize"
        return "analyze"
    
    # ===== 构建状态图 =====
    workflow = StateGraph(CoTState)
    
    # 添加节点
    workflow.add_node("analyze", analyze_step)      # 推理节点
    workflow.add_node("finalize", finalize_answer)  # 总结节点
    
    # 设置入口点
    workflow.set_entry_point("analyze")
    
    # 添加条件边：推理完成后决定继续还是总结
    workflow.add_conditional_edges(
        "analyze",
        should_continue,
        {"analyze": "analyze", "finalize": "finalize"}
    )
    workflow.add_edge("finalize", END)
    
    return workflow.compile()

# 使用示例
def solve_with_cot(problem: str):
    agent = create_cot_agent(max_steps=4)
    
    result = agent.invoke({
        "problem": problem,
        "steps": [],
        "current_step": 0,
        "final_answer": ""
    })
    
    # 输出完整推理链
    for i, step in enumerate(result["steps"]):
        print(f"步骤{i+1}: {step}")
    print(f"\n最终答案: {result['final_answer']}")
    
    return result["final_answer"]

from typing import TypedDict, Literal, Optional
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import json

# 定义状态类型
class MultiAgentState(TypedDict):
    """Multi-Agent协作系统状态定义"""
    task: str                         # 原始任务
    research_result: Optional[str]    # 研究智能体输出
    analysis_result: Optional[str]    # 分析智能体输出
    draft: Optional[str]              # 写作智能体输出（草稿）
    review_result: Optional[dict]     # 审核智能体输出
    final_result: Optional[str]       # 最终结果
    revision_count: int               # 修改次数

def create_multi_agent_system():
    """
    创建Multi-Agent协作系统
    
    系统包含四个专业智能体：
    - Research Agent: 负责收集和整理相关信息
    - Analysis Agent: 负责深度分析研究结果
    - Writing Agent: 负责撰写内容
    - Review Agent: 负责审核并提供反馈
    
    Returns:
        编译后的LangGraph工作流
    """
    
    # 各专业智能体使用不同的配置
    research_llm = ChatOpenAI(model="gpt-4", temperature=0.7)   # 较高创造性
    analysis_llm = ChatOpenAI(model="gpt-4", temperature=0)     # 精确分析
    writing_llm = ChatOpenAI(model="gpt-4", temperature=0.5)    # 平衡创造性
    review_llm = ChatOpenAI(model="gpt-4", temperature=0)       # 严格审核
    
    def coordinator_node(state: MultiAgentState) -> MultiAgentState:
        """
        协调者节点：初始化任务分配
        
        在实际场景中可以进行任务分解和智能体选择
        """
        return state
    
    def research_agent(state: MultiAgentState) -> MultiAgentState:
        """
        研究智能体：收集和整理相关信息
        
        职责：背景调研、资料收集、关键信息提取
        """
        task = state["task"]
        
        prompt = f"""
        你是一个专业的研究员。请针对以下任务进行深入研究：
        
        任务：{task}
        
        请提供：
        1. 相关背景信息
        2. 关键概念解释
        3. 重要数据和事实
        4. 参考资源列表
        """
        
        response = research_llm.invoke([HumanMessage(content=prompt)])
        return {**state, "research_result": response.content}
    
    def analysis_agent(state: MultiAgentState) -> MultiAgentState:
        """
        分析智能体：深度分析研究结果
        
        职责：逻辑分析、观点提炼、优劣势评估
        """
        task = state["task"]
        research = state.get("research_result", "")
        
        prompt = f"""
        你是一个专业的分析师。请基于以下信息进行深度分析：
        
        任务：{task}
        研究资料：{research}
        
        请提供：
        1. 核心观点总结
        2. 逻辑关系分析
        3. 优劣势评估
        4. 建议和结论
        """
        
        response = analysis_llm.invoke([HumanMessage(content=prompt)])
        return {**state, "analysis_result": response.content}
    
    def writing_agent(state: MultiAgentState) -> MultiAgentState:
        """
        写作智能体：撰写内容
        
        职责：整合信息、撰写文章、响应修改意见
        """
        task = state["task"]
        research = state.get("research_result", "")
        analysis = state.get("analysis_result", "")
        review = state.get("review_result")
        
        if review and not review.get("approved"):
            # 根据审核意见进行修改
            prompt = f"""
            请根据以下审核意见修改文章：
            
            原文：{state.get('draft', '')}
            审核意见：{review.get('feedback', '')}
            
            请输出修改后的完整文章。
            """
        else:
            # 首次撰写
            prompt = f"""
            你是一个专业的写作者。请基于以下材料撰写高质量内容：
            
            任务：{task}
            研究资料：{research}
            分析结果：{analysis}
            
            请撰写一篇结构清晰、内容丰富的文章。
            """
        
        response = writing_llm.invoke([HumanMessage(content=prompt)])
        return {**state, "draft": response.content}
    
    def review_agent(state: MultiAgentState) -> MultiAgentState:
        """
        审核智能体：审核并提供反馈
        
        职责：质量评估、问题识别、改进建议
        """
        task = state["task"]
        draft = state.get("draft", "")
        
        prompt = f"""
        你是一个严格的审核专家。请审核以下内容：
        
        原始任务：{task}
        待审核内容：{draft}
        
        请以JSON格式输出审核结果：
        {{
            "approved": true,
            "score": 8,
            "feedback": "具体的修改建议或通过理由"
        }}
        """
        
        response = review_llm.invoke([HumanMessage(content=prompt)])
        review_result = json.loads(response.content)
        
        return {
            **state,
            "review_result": review_result,
            "revision_count": state["revision_count"] + 1
        }
    
    def finalize_node(state: MultiAgentState) -> MultiAgentState:
        """最终确认输出"""
        return {**state, "final_result": state.get("draft", "")}
    
    def should_revise(state: MultiAgentState) -> Literal["writing", "finalize"]:
        """
        路由函数：决定是否需要修改
        
        Returns:
            "writing": 需要修改
            "finalize": 审核通过或达到最大修改次数
        """
        review = state.get("review_result", {})
        revision_count = state.get("revision_count", 0)
        
        # 防止无限修改循环
        if revision_count >= 3:
            return "finalize"
        
        if review.get("approved", False):
            return "finalize"
        
        return "writing"
    
    # ===== 构建状态图 =====
    workflow = StateGraph(MultiAgentState)
    
    # 添加智能体节点
    workflow.add_node("coordinator", coordinator_node)  # 协调者
    workflow.add_node("research", research_agent)       # 研究智能体
    workflow.add_node("analysis", analysis_agent)       # 分析智能体
    workflow.add_node("writing", writing_agent)         # 写作智能体
    workflow.add_node("review", review_agent)           # 审核智能体
    workflow.add_node("finalize", finalize_node)        # 最终输出
    
    # 设置入口点
    workflow.set_entry_point("coordinator")
    
    # 定义协作流程（串行展示，实际可并行优化）
    workflow.add_edge("coordinator", "research")
    workflow.add_edge("research", "analysis")
    workflow.add_edge("analysis", "writing")
    workflow.add_edge("writing", "review")
    
    # 审核后决定是修改还是完成
    workflow.add_conditional_edges(
        "review",
        should_revise,
        {"writing": "writing", "finalize": "finalize"}
    )
    workflow.add_edge("finalize", END)
    
    return workflow.compile()

# 使用示例
def run_multi_agent(task: str):
    system = create_multi_agent_system()
    
    result = system.invoke({
        "task": task,
        "research_result": None,
        "analysis_result": None,
        "draft": None,
        "review_result": None,
        "final_result": None,
        "revision_count": 0
    })
    
    return result["final_result"]

from typing import TypedDict, List, Optional, Dict
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import json

# 定义状态类型
class HierarchicalState(TypedDict):
    """Hierarchical Agent层次化智能体状态定义"""
    task: str                              # 原始任务
    subtasks: Dict[str, List[str]]         # supervisor_name -> [子任务列表]
    worker_results: Dict[str, str]         # worker_id -> 执行结果
    supervisor_summaries: Dict[str, str]   # supervisor_name -> 汇总报告
    final_result: Optional[str]            # 最终结果

def create_hierarchical_agent():
    """
    创建Hierarchical Agent层次化智能体系统
    
    三层架构：
    - Master Agent (主控层): 任务分解和最终汇总
    - Supervisor Agents (管理层): 管理各自领域的Worker
    - Worker Agents (执行层): 具体任务执行
    
    Returns:
        编译后的LangGraph工作流
    """
    
    # 不同层级使用不同的模型配置
    master_llm = ChatOpenAI(model="gpt-4", temperature=0)        # 主控：精确决策
    supervisor_llm = ChatOpenAI(model="gpt-4", temperature=0)    # 管理：汇总分析
    worker_llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)  # 执行：高效完成
    
    def master_node(state: HierarchicalState) -> HierarchicalState:
        """
        主控智能体：任务分解
        
        将复杂任务分解给三个管理者：
        - task_supervisor: 任务执行管理
        - resource_supervisor: 资源管理
        - quality_supervisor: 质量保证
        """
        task = state["task"]
        
        prompt = f"""
        你是主控智能体。请将以下任务分解给三个管理者：
        - task_supervisor: 负责任务执行相关的子任务
        - resource_supervisor: 负责资源管理相关的子任务  
        - quality_supervisor: 负责质量保证相关的子任务
        
        任务：{task}
        
        请以JSON格式输出任务分配：
        {{
            "task_supervisor": ["子任务1", "子任务2"],
            "resource_supervisor": ["子任务1", "子任务2"],
            "quality_supervisor": ["子任务1", "子任务2"]
        }}
        """
        
        response = master_llm.invoke([HumanMessage(content=prompt)])
        subtasks = json.loads(response.content)
        
        return {**state, "subtasks": subtasks}
    
    def create_supervisor_node(supervisor_name: str):
        """
        创建Supervisor节点的工厂函数
        
        每个Supervisor负责：
        1. 分发子任务给Worker
        2. 收集Worker执行结果
        3. 汇总并生成报告
        
        Args:
            supervisor_name: 管理者名称
        
        Returns:
            supervisor节点函数
        """
        def supervisor_node(state: HierarchicalState) -> HierarchicalState:
            subtasks = state["subtasks"].get(supervisor_name, [])
            worker_results = state["worker_results"].copy()
            
            # Worker层：执行各子任务
            for i, subtask in enumerate(subtasks):
                worker_prompt = f"""
                你是一个执行者。请完成以下子任务：
                {subtask}
                
                请直接输出执行结果。
                """
                response = worker_llm.invoke([HumanMessage(content=worker_prompt)])
                worker_results[f"{supervisor_name}_worker_{i}"] = response.content
            
            # Supervisor层：汇总Worker结果
            relevant_results = {k: v for k, v in worker_results.items() 
                               if k.startswith(supervisor_name)}
            
            summary_prompt = f"""
            你是{supervisor_name}管理者。请汇总以下Worker的执行结果：
            
            {json.dumps(relevant_results, ensure_ascii=False)}
            
            请输出汇总报告。
            """
            
            summary = supervisor_llm.invoke([HumanMessage(content=summary_prompt)])
            
            supervisor_summaries = state["supervisor_summaries"].copy()
            supervisor_summaries[supervisor_name] = summary.content
            
            return {
                **state,
                "worker_results": worker_results,
                "supervisor_summaries": supervisor_summaries
            }
        
        return supervisor_node
    
    def aggregation_node(state: HierarchicalState) -> HierarchicalState:
        """
        聚合节点：综合所有Supervisor的结果
        
        Master Agent汇总各管理者的报告，生成最终结果
        """
        task = state["task"]
        summaries = state["supervisor_summaries"]
        
        prompt = f"""
        你是主控智能体。请综合以下各管理者的汇报，生成最终结果：
        
        原始任务：{task}
        
        任务管理报告：{summaries.get('task_supervisor', '')}
        资源管理报告：{summaries.get('resource_supervisor', '')}
        质量管理报告：{summaries.get('quality_supervisor', '')}
        
        请输出最终的综合报告。
        """
        
        response = master_llm.invoke([HumanMessage(content=prompt)])
        
        return {**state, "final_result": response.content}
    
    # ===== 构建状态图 =====
    workflow = StateGraph(HierarchicalState)
    
    # 添加节点
    workflow.add_node("master", master_node)  # 主控层
    workflow.add_node("task_supervisor", create_supervisor_node("task_supervisor"))
    workflow.add_node("resource_supervisor", create_supervisor_node("resource_supervisor"))
    workflow.add_node("quality_supervisor", create_supervisor_node("quality_supervisor"))
    workflow.add_node("aggregation", aggregation_node)  # 聚合层
    
    # 设置入口点
    workflow.set_entry_point("master")
    
    # 定义层次化执行流程（串行展示，实际可并行优化）
    workflow.add_edge("master", "task_supervisor")
    workflow.add_edge("task_supervisor", "resource_supervisor")
    workflow.add_edge("resource_supervisor", "quality_supervisor")
    workflow.add_edge("quality_supervisor", "aggregation")
    workflow.add_edge("aggregation", END)
    
    return workflow.compile()

# 使用示例
def run_hierarchical_agent(task: str):
    agent = create_hierarchical_agent()
    
    result = agent.invoke({
        "task": task,
        "subtasks": {},
        "worker_results": {},
        "supervisor_summaries": {},
        "final_result": None
    })
    
    return result["final_result"]

from typing import TypedDict, List, Literal, Optional
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import json

# 定义状态类型
class ReflectionState(TypedDict):
    """Reflection反思模式智能体状态定义"""
    task: str                       # 原始任务
    current_solution: Optional[str] # 当前解决方案
    reflection: Optional[dict]      # 反思评估结果
    improvements: List[str]         # 改进建议列表
    iteration: int                  # 当前迭代次数
    max_iterations: int             # 最大迭代次数
    final_result: Optional[str]     # 最终结果
    quality_score: float            # 质量评分（0-10）

def create_reflection_agent(max_iterations: int = 3, quality_threshold: float = 8.0):
    """
    创建Reflection反思模式智能体
    
    该模式通过持续的自我反思和改进来优化输出质量：
    1. Action: 执行任务或应用改进
    2. Reflect: 评估当前方案的质量
    3. Improve: 制定改进策略
    4. Plan: 决定是否继续迭代
    
    Args:
        max_iterations: 最大反思迭代次数
        quality_threshold: 质量阈值，达到后停止迭代
    
    Returns:
        编译后的LangGraph工作流
    """
    
    # Actor负责执行，Reflector负责评估
    actor_llm = ChatOpenAI(model="gpt-4", temperature=0.7)    # 较高创造性
    reflector_llm = ChatOpenAI(model="gpt-4", temperature=0)  # 精确评估
    
    def action_node(state: ReflectionState) -> ReflectionState:
        """
        行动阶段 (Action)
        
        执行任务或根据改进建议优化现有方案
        """
        task = state["task"]
        improvements = state["improvements"]
        current = state.get("current_solution", "")
        
        if current and improvements:
            # 应用改进建议
            prompt = f"""
            请根据以下改进建议，优化现有解决方案：
            
            原始任务：{task}
            当前方案：{current}
            改进建议：{chr(10).join(improvements)}
            
            请输出改进后的完整方案。
            """
        else:
            # 首次执行
            prompt = f"""
            请完成以下任务：
            
            {task}
            
            请输出完整的解决方案。
            """
        
        response = actor_llm.invoke([HumanMessage(content=prompt)])
        
        return {**state, "current_solution": response.content}
    
    def reflect_node(state: ReflectionState) -> ReflectionState:
        """
        反思阶段 (Reflect)
        
        从多个维度评估当前方案：
        - 效果评估 (effectiveness)
        - 方法分析 (methodology)
        - 目标对齐 (goal_alignment)
        """
        task = state["task"]
        solution = state["current_solution"]
        
        prompt = f"""
        你是一个严格的质量评估专家。请对以下解决方案进行全面反思评估：
        
        原始任务：{task}
        当前方案：{solution}
        
        请从以下维度进行评估，输出JSON格式：
        {{
            "effectiveness": {{
                "score": 8,
                "analysis": "效果评估分析"
            }},
            "methodology": {{
                "score": 7,
                "analysis": "方法分析"
            }},
            "goal_alignment": {{
                "score": 9,
                "analysis": "目标对齐度分析"
            }},
            "overall_score": 8,
            "strengths": ["优点1", "优点2"],
            "weaknesses": ["不足1", "不足2"]
        }}
        """
        
        response = reflector_llm.invoke([HumanMessage(content=prompt)])
        reflection = json.loads(response.content)
        
        return {
            **state,
            "reflection": reflection,
            "quality_score": reflection.get("overall_score", 0)
        }
    
    def improve_node(state: ReflectionState) -> ReflectionState:
        """
        改进阶段 (Improve)
        
        根据反思结果制定具体的改进策略
        """
        reflection = state["reflection"]
        
        prompt = f"""
        基于以下反思评估，制定具体的改进策略：
        
        评估结果：{json.dumps(reflection, ensure_ascii=False)}
        
        请列出3-5条具体可执行的改进建议：
        """
        
        response = reflector_llm.invoke([HumanMessage(content=prompt)])
        
        # 解析改进建议（提取数字开头的行）
        improvements = [line.strip() for line in response.content.split('\n') 
                       if line.strip() and line.strip()[0].isdigit()]
        
        return {**state, "improvements": improvements}
    
    def plan_node(state: ReflectionState) -> ReflectionState:
        """
        规划阶段 (Plan)
        
        更新迭代计数，为下一轮做准备
        """
        return {**state, "iteration": state["iteration"] + 1}
    
    def finalize_node(state: ReflectionState) -> ReflectionState:
        """最终输出"""
        return {**state, "final_result": state["current_solution"]}
    
    def should_continue(state: ReflectionState) -> Literal["action", "finalize"]:
        """
        路由函数：决定是否继续迭代
        
        停止条件：
        1. 质量评分达到阈值
        2. 达到最大迭代次数
        """
        if state["quality_score"] >= quality_threshold:
            return "finalize"
        
        if state["iteration"] >= state["max_iterations"]:
            return "finalize"
        
        return "action"
    
    # ===== 构建状态图 =====
    workflow = StateGraph(ReflectionState)
    
    # 添加节点 (A-R-I-P 循环)
    workflow.add_node("action", action_node)      # A - 行动
    workflow.add_node("reflect", reflect_node)    # R - 反思
    workflow.add_node("improve", improve_node)    # I - 改进
    workflow.add_node("plan", plan_node)          # P - 规划
    workflow.add_node("finalize", finalize_node)  # 最终输出
    
    # 设置入口点
    workflow.set_entry_point("action")
    
    # 定义反思循环: A -> R -> I -> P
    workflow.add_edge("action", "reflect")
    workflow.add_edge("reflect", "improve")
    workflow.add_edge("improve", "plan")
    
    # 条件边：继续循环或结束
    workflow.add_conditional_edges(
        "plan",
        should_continue,
        {"action": "action", "finalize": "finalize"}
    )
    workflow.add_edge("finalize", END)
    
    return workflow.compile()

# 使用示例
def run_reflection_agent(task: str):
    agent = create_reflection_agent(max_iterations=3, quality_threshold=8.0)
    
    result = agent.invoke({
        "task": task,
        "current_solution": None,
        "reflection": None,
        "improvements": [],
        "iteration": 0,
        "max_iterations": 3,
        "final_result": None,
        "quality_score": 0.0
    })
    
    print(f"迭代次数: {result['iteration']}")
    print(f"质量得分: {result['quality_score']}")
    
    return result["final_result"]