import openai
from typing import Dict, List, Any, Optional
from abc import ABC, abstractmethod
class Tool(ABC):
    """工具基类定义"""
    @abstractmethod
    def execute(self, input_text: str) -> str:
        pass
    
    @property
    @abstractmethod
    def name(self) -> str:
        pass
    
    @property
    @abstractmethod
    def description(self) -> str:
        pass
class SearchTool(Tool):
    """搜索工具实现"""
    def execute(self, query: str) -> str:
        # 模拟搜索API调用
        return f"搜索结果: {query}的相关信息..."
    
    @property
    def name(self) -> str:
        return "search"
    
    @property
    def description(self) -> str:
        return "搜索工具，用于查找相关信息"
class CalculatorTool(Tool):
    """计算器工具实现"""
    def execute(self, expression: str) -> str:
        try:
            result = eval(expression)  # 注意：生产环境需要安全的数学表达式解析
            return f"计算结果: {result}"
        except Exception as e:
            return f"计算错误: {str(e)}"
    
    @property
    def name(self) -> str:
        return "calculator"
    
    @property
    def description(self) -> str:
        return "计算器工具，用于数学计算"
class ReActAgent:
    """ReAct智能体实现"""
    
    def __init__(self, model_name: str = "gpt-4", max_iterations: int = 10):
        self.model_name = model_name
        self.max_iterations = max_iterations
        self.tools: Dict[str, Tool] = {}
        self.conversation_history: List[Dict[str, str]] = []
    
    def add_tool(self, tool: Tool) -> None:
        """添加工具到智能体"""
        self.tools[tool.name] = tool
    
    def _generate_prompt(self, task: str, iteration: int) -> str:
        """生成ReAct格式的提示词"""
        tools_desc = "\n".join([
            f"- {tool.name}: {tool.description}" 
            for tool in self.tools.values()
        ])
        
        conversation = "\n".join([
            f"{msg['role']}: {msg['content']}" 
            for msg in self.conversation_history
        ])
        
        prompt = f"""你是一个ReAct智能体，需要通过思考-行动-观察的循环来完成任务。
可用工具:
{tools_desc}
任务: {task}
历史对话:
{conversation}
请按照以下格式回复：
思考: [你的推理过程]
行动: [tool_name(参数)]
或者
思考: [你的推理过程]
答案: [最终答案]
当前轮次: {iteration}/{self.max_iterations}
"""
        return prompt
    
    def _parse_response(self, response: str) -> tuple[str, Optional[str], Optional[str]]:
        """解析模型响应"""
        lines = response.strip().split('\n')
        thought = ""
        action = None
        answer = None
        
        for line in lines:
            if line.startswith("思考:"):
                thought = line[3:].strip()
            elif line.startswith("行动:"):
                action = line[3:].strip()
            elif line.startswith("答案:"):
                answer = line[3:].strip()
        
        return thought, action, answer
    
    def _execute_action(self, action: str) -> str:
        """执行动作并返回观察结果"""
        # 解析动作格式: tool_name(参数)
        if '(' in action and action.endswith(')'):
            tool_name = action.split('(')[0].strip()
            params = action[action.find('(')+1:-1].strip()
            
            if tool_name in self.tools:
                try:
                    result = self.tools[tool_name].execute(params)
                    return f"观察: {result}"
                except Exception as e:
                    return f"观察: 工具执行错误 - {str(e)}"
            else:
                return f"观察: 未找到工具 '{tool_name}'"
        else:
            return f"观察: 动作格式错误 - {action}"
    
    def run(self, task: str) -> str:
        """运行ReAct智能体"""
        self.conversation_history = []
        
        for iteration in range(1, self.max_iterations + 1):
            # 生成提示词
            prompt = self._generate_prompt(task, iteration)
            
            # 调用语言模型
            try:
                response = openai.ChatCompletion.create(
                    model=self.model_name,
                    messages=[{"role": "user", "content": prompt}],
                    temperature=0.1
                )
                model_response = response.choices[0].message.content
            except Exception as e:
                return f"模型调用错误: {str(e)}"
            
            # 解析响应
            thought, action, answer = self._parse_response(model_response)
            
            # 记录思考过程
            self.conversation_history.append({
                "role": "assistant",
                "content": f"思考: {thought}"
            })
            
            # 如果得到最终答案，返回结果
            if answer:
                return answer
            
            # 执行动作并获取观察结果
            if action:
                observation = self._execute_action(action)
                self.conversation_history.append({
                    "role": "user",
                    "content": observation
                })
            else:
                self.conversation_history.append({
                    "role": "user",
                    "content": "观察: 未指定有效动作"
                })
        
        return "达到最大迭代次数，任务未完成"
# 使用示例
if __name__ == "__main__":
    # 创建ReAct智能体
    agent = ReActAgent()
    
    # 添加工具
    agent.add_tool(SearchTool())
    agent.add_tool(CalculatorTool())
    
    # 执行任务
    task = "计算2023年中国GDP增长率，并搜索相关的经济政策信息"
    result = agent.run(task)
    print(f"任务结果: {result}")

from typing import List, Dict, Any, Optional
from dataclasses import dataclass
from enum import Enum
import json
class TaskStatus(Enum):
    """任务状态枚举"""
    PENDING = "pending"
    RUNNING = "running"
    COMPLETED = "completed"
    FAILED = "failed"
@dataclass
class SubTask:
    """子任务数据结构"""
    id: str
    description: str
    dependencies: List[str]
    estimated_time: int
    status: TaskStatus = TaskStatus.PENDING
    result: Optional[str] = None
    error_message: Optional[str] = None
class TaskPlanner:
    """任务规划器"""
    
    def __init__(self, model_name: str = "gpt-4"):
        self.model_name = model_name
    
    def generate_plan(self, main_task: str, context: Dict[str, Any] = None) -> List[SubTask]:
        """生成任务执行计划"""
        planning_prompt = f"""
作为一个专业的任务规划专家，请将以下复杂任务分解为具体的子任务序列。
主任务: {main_task}
上下文: {json.dumps(context or {}, ensure_ascii=False, indent=2)}
请按照以下JSON格式输出子任务列表：
{{
  "subtasks": [
    {{
      "id": "task_1",
      "description": "具体的子任务描述",
      "dependencies": [],
      "estimated_time": 300
    }}
  ]
}}
要求：
1. 子任务应该具体、可执行
2. 合理设置依赖关系
3. 估算执行时间（秒）
4. 确保任务完整覆盖主目标
"""
        
        try:
            # 调用LLM生成规划（此处简化实现）
            response = self._call_llm(planning_prompt)
            plan_data = json.loads(response)
            
            subtasks = []
            for task_info in plan_data.get("subtasks", []):
                subtask = SubTask(
                    id=task_info["id"],
                    description=task_info["description"],
                    dependencies=task_info.get("dependencies", []),
                    estimated_time=task_info.get("estimated_time", 300)
                )
                subtasks.append(subtask)
            
            return subtasks
            
        except Exception as e:
            # 生成默认规划
            return [SubTask(
                id="fallback_task",
                description=f"执行任务: {main_task}",
                dependencies=[],
                estimated_time=600
            )]
    
    def replan(self, failed_task: SubTask, remaining_tasks: List[SubTask], 
               error_context: str) -> List[SubTask]:
        """重新规划失败任务"""
        replan_prompt = f"""
任务执行失败，需要重新规划：
失败任务: {failed_task.description}
错误信息: {failed_task.error_message}
剩余任务: {[t.description for t in remaining_tasks]}
错误上下文: {error_context}
请提供修正后的子任务序列，格式同上。
"""
        
        try:
            response = self._call_llm(replan_prompt)
            plan_data = json.loads(response)
            
            new_subtasks = []
            for task_info in plan_data.get("subtasks", []):
                subtask = SubTask(
                    id=f"replan_{task_info['id']}",
                    description=task_info["description"],
                    dependencies=task_info.get("dependencies", []),
                    estimated_time=task_info.get("estimated_time", 300)
                )
                new_subtasks.append(subtask)
            
            return new_subtasks
            
        except Exception:
            # 简单重试策略
            failed_task.status = TaskStatus.PENDING
            failed_task.error_message = None
            return [failed_task] + remaining_tasks
    
    def _call_llm(self, prompt: str) -> str:
        """调用语言模型（简化实现）"""
        # 实际实现中应该调用真实的LLM API
        return '{"subtasks": [{"id": "example", "description": "示例任务", "dependencies": [], "estimated_time": 300}]}'
class TaskExecutor:
    """任务执行器"""
    
    def __init__(self, tools: Dict[str, Any] = None):
        self.tools = tools or {}
        self.execution_context = {}
    
    def execute_task(self, task: SubTask) -> bool:
        """执行单个子任务"""
        try:
            task.status = TaskStatus.RUNNING
            
            # 根据任务描述选择执行策略
            if "搜索" in task.description:
                result = self._execute_search_task(task)
            elif "计算" in task.description:
                result = self._execute_calculation_task(task)
            elif "生成" in task.description:
                result = self._execute_generation_task(task)
            else:
                result = self._execute_general_task(task)
            
            task.result = result
            task.status = TaskStatus.COMPLETED
            
            # 更新执行上下文
            self.execution_context[task.id] = {
                "result": result,
                "timestamp": "2024-01-01T00:00:00Z"  # 简化时间戳
            }
            
            return True
            
        except Exception as e:
            task.status = TaskStatus.FAILED
            task.error_message = str(e)
            return False
    
    def _execute_search_task(self, task: SubTask) -> str:
        """执行搜索类任务"""
        # 模拟搜索执行
        return f"搜索完成: {task.description}"
    
    def _execute_calculation_task(self, task: SubTask) -> str:
        """执行计算类任务"""
        # 模拟计算执行
        return f"计算完成: {task.description}"
    
    def _execute_generation_task(self, task: SubTask) -> str:
        """执行生成类任务"""
        # 模拟内容生成
        return f"生成完成: {task.description}"
    
    def _execute_general_task(self, task: SubTask) -> str:
        """执行通用任务"""
        # 模拟通用任务执行
        return f"任务完成: {task.description}"
class PlanAndExecuteAgent:
    """Plan-and-Execute智能体"""
    
    def __init__(self, max_replans: int = 3):
        self.planner = TaskPlanner()
        self.executor = TaskExecutor()
        self.max_replans = max_replans
        self.execution_log: List[Dict[str, Any]] = []
    
    def run(self, main_task: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
        """执行主任务"""
        print(f"开始执行任务: {main_task}")
        
        # 生成初始计划
        subtasks = self.planner.generate_plan(main_task, context)
        replan_count = 0
        
        while subtasks and replan_count <= self.max_replans:
            # 获取可执行的任务（依赖已满足）
            executable_tasks = self._get_executable_tasks(subtasks)
            
            if not executable_tasks:
                break
            
            # 执行任务
            current_task = executable_tasks[0]
            print(f"执行子任务: {current_task.description}")
            
            success = self.executor.execute_task(current_task)
            
            # 记录执行日志
            self.execution_log.append({
                "task_id": current_task.id,
                "description": current_task.description,
                "status": current_task.status.value,
                "result": current_task.result,
                "error": current_task.error_message
            })
            
            if success:
                # 移除已完成的任务
                subtasks = [t for t in subtasks if t.id != current_task.id]
            else:
                # 重新规划
                print(f"任务失败，重新规划: {current_task.error_message}")
                remaining_tasks = [t for t in subtasks if t.id != current_task.id]
                subtasks = self.planner.replan(
                    current_task, 
                    remaining_tasks, 
                    current_task.error_message or ""
                )
                replan_count += 1
        
        # 生成执行报告
        completed_tasks = [log for log in self.execution_log if log["status"] == "completed"]
        failed_tasks = [log for log in self.execution_log if log["status"] == "failed"]
        
        return {
            "main_task": main_task,
            "total_subtasks": len(self.execution_log),
            "completed_count": len(completed_tasks),
            "failed_count": len(failed_tasks),
            "success_rate": len(completed_tasks) / len(self.execution_log) if self.execution_log else 0,
            "execution_log": self.execution_log,
            "final_result": "任务完成" if not subtasks else f"部分完成，剩余{len(subtasks)}个子任务"
        }
    
    def _get_executable_tasks(self, subtasks: List[SubTask]) -> List[SubTask]:
        """获取可执行的任务（依赖已满足）"""
        completed_task_ids = {
            log["task_id"] for log in self.execution_log 
            if log["status"] == "completed"
        }
        
        executable = []
        for task in subtasks:
            if task.status == TaskStatus.PENDING:
                # 检查依赖是否都已完成
                if all(dep_id in completed_task_ids for dep_id in task.dependencies):
                    executable.append(task)
        
        return executable
# 使用示例
if __name__ == "__main__":
    agent = PlanAndExecuteAgent()
    
    task = "制作一份关于人工智能发展趋势的研究报告"
    context = {
        "report_length": "5000字",
        "focus_areas": ["机器学习", "深度学习", "大语言模型"],
        "deadline": "2024-01-15"
    }
    
    result = agent.run(task, context)
    print(f"执行结果: {json.dumps(result, ensure_ascii=False, indent=2)}")

import numpy as np
from typing import Dict, List, Any
import time
from dataclasses import dataclass
@dataclass
class EvaluationMetrics:
    """评估指标数据结构"""
    reasoning_accuracy: float  # 推理准确率
    execution_efficiency: float  # 执行效率
    adaptability_score: float  # 适应性评分
    robustness_index: float  # 鲁棒性指数
    computational_cost: float  # 计算成本
    response_time: float  # 响应时间
class AgentEvaluator:
    """智能体评估器"""
    
    def __init__(self):
        self.test_cases = []
        self.baseline_performance = {}
    
    def evaluate_reasoning_accuracy(self, agent, test_cases: List[Dict]) -> float:
        """评估推理准确率"""
        correct_count = 0
        total_count = len(test_cases)
        
        for case in test_cases:
            start_time = time.time()
            result = agent.run(case['input'])
            end_time = time.time()
            
            # 评估结果正确性
            if self._check_correctness(result, case['expected_output']):
                correct_count += 1
            
            # 记录响应时间
            case['response_time'] = end_time - start_time
        
        return correct_count / total_count if total_count > 0 else 0.0
    
    def evaluate_adaptability(self, agent, dynamic_scenarios: List[Dict]) -> float:
        """评估适应性"""
        adaptation_scores = []
        
        for scenario in dynamic_scenarios:
            # 初始性能
            initial_performance = self._measure_performance(agent, scenario['initial_tasks'])
            
            # 环境变化后的性能
            agent.adapt_to_environment(scenario['environment_changes'])
            adapted_performance = self._measure_performance(agent, scenario['adapted_tasks'])
            
            # 计算适应性评分
            adaptation_score = adapted_performance / initial_performance if initial_performance > 0 else 0
            adaptation_scores.append(min(adaptation_score, 2.0))  # 限制最大值
        
        return np.mean(adaptation_scores)
    
    def _check_correctness(self, actual_result: str, expected_result: str) -> bool:
        """检查结果正确性"""
        # 简化的正确性检查逻辑
        return actual_result.strip().lower() == expected_result.strip().lower()
    
    def _measure_performance(self, agent, tasks: List[Dict]) -> float:
        """测量性能指标"""
        success_count = 0
        for task in tasks:
            try:
                result = agent.run(task['input'])
                if self._check_correctness(result, task['expected_output']):
                    success_count += 1
            except Exception:
                pass
        
        return success_count / len(tasks) if tasks else 0.0
# 基准测试套件
def run_comprehensive_benchmark():
    """运行综合基准测试"""
    test_cases = [
        {
            'input': '计算2^10的值',
            'expected_output': '1024',
            'category': 'mathematical_reasoning'
        },
        {
            'input': '搜索最新的AI发展趋势',
            'expected_output': '人工智能相关信息',
            'category': 'information_retrieval'
        }
        # 更多测试用例...
    ]
    
    evaluator = AgentEvaluator()
    
    # 创建不同类型的智能体进行对比
    agents = {
        'ReAct': ReActAgent(),
        'PlanExecute': PlanAndExecuteAgent(),
        # 'Adaptive': AdaptiveAgent()  # 需要实现
    }
    
    results = {}
    for agent_name, agent in agents.items():
        print(f"评估智能体: {agent_name}")
        
        accuracy = evaluator.evaluate_reasoning_accuracy(agent, test_cases)
        # adaptability = evaluator.evaluate_adaptability(agent, dynamic_scenarios)
        
        results[agent_name] = {
            'reasoning_accuracy': accuracy,
            # 'adaptability_score': adaptability,
            'avg_response_time': np.mean([case.get('response_time', 0) for case in test_cases])
        }
    
    return results