class Agent:
    def __init__(self, ai_name, memory, full_message_history, next_action_count):
        """
        AutoGPT核心代理类
        - ai_name: AI代理名称
        - memory: 记忆系统实例
        - full_message_history: 完整消息历史
        - next_action_count: 下一步动作计数
        """
        self.ai_name = ai_name
        self.memory = memory
        self.full_message_history = full_message_history
        self.next_action_count = next_action_count
        
    def start_interaction_loop(self):
        """
        启动主要的交互循环
        这是AutoGPT的核心执行机制
        """
        while True:
            # 1. 构建助手回复
            assistant_reply = chat.chat_with_ai(
                self.full_message_history,
                self.ai_name,
                self.memory
            )
            
            # 2. 解析助手回复获取动作
            try:
                action_name, arguments = json_parser.parse_json(assistant_reply)
            except json.decoder.JSONDecodeError:
                logger.error("解析JSON失败，重试...")
                continue
                
            # 3. 执行动作
            result = self.execute_command(action_name, arguments)
            
            # 4. 将结果添加到记忆系统
            self.memory.add(f"动作: {action_name}, 参数: {arguments}, 结果: {result}")
            
            # 5. 更新消息历史
            self.full_message_history.append({
                "role": "assistant", 
                "content": assistant_reply
            })
            self.full_message_history.append({
                "role": "user", 
                "content": f"系统: {result}"
            })
            
    def execute_command(self, command_name, arguments):
        """
        执行具体命令
        支持文件操作、网络搜索、代码执行等多种工具
        """
        try:
            if command_name == "write_to_file":
                return file_operations.write_to_file(arguments["filename"], arguments["text"])
            elif command_name == "web_search":
                return web_search.google_search(arguments["query"])
            elif command_name == "execute_python_code":
                return code_executor.execute_python_code(arguments["code"])
            # ...更多工具调用
        except Exception as e:
            return f"命令执行失败: {str(e)}"

import openai
import pinecone
from collections import deque
class BabyAGI:
    def __init__(self, objective, initial_task):
        """
        BabyAGI核心类
        - objective: 总体目标
        - initial_task: 初始任务
        """
        self.objective = objective
        self.task_list = deque([{"task_id": 1, "task_name": initial_task}])
        self.task_id_counter = 1
        
        # 初始化向量数据库
        self.index = pinecone.Index("babyagi-tasks")
        
    def main_loop(self):
        """
        BabyAGI主循环：简洁而高效的三步循环
        """
        while True:
            if self.task_list:
                # 步骤1: 获取下一个任务
                task = self.task_list.popleft()
                print(f"执行任务: {task}")
                
                # 步骤2: 执行任务
                result = self.execution_agent(
                    self.objective, 
                    task["task_name"]
                )
                
                # 步骤3: 存储结果到向量数据库
                enriched_result = {
                    "data": result
                }
                result_id = f"result_{task['task_id']}"
                self.index.upsert([(result_id, self.get_ada_embedding(result), enriched_result)])
                
                # 步骤4: 基于目标和结果创建新任务
                new_tasks = self.task_creation_agent(
                    self.objective,
                    enriched_result,
                    task["task_name"],
                    [t["task_name"] for t in self.task_list]
                )
                
                # 步骤5: 任务优先级排序
                if new_tasks:
                    self.task_list.extend(new_tasks)
                    self.prioritization_agent(self.task_id_counter)
                    
    def execution_agent(self, objective, task):
        """
        执行代理：负责具体任务的执行
        """
        context = self.context_agent(query=objective, n=5)
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=f"""
            根据以下目标完成任务: {objective}
            
            考虑这些先前完成的任务结果作为上下文:
            {context}
            
            你的任务: {task}
            回应:
            """,
            temperature=0.7,
            max_tokens=2000
        )
        return response.choices[0].text.strip()
        
    def task_creation_agent(self, objective, result, task_description, task_list):
        """
        任务创建代理：基于当前结果生成新任务
        """
        prompt = f"""
        你是一个任务创建AI，根据以下信息创建新任务:
        目标: {objective}
        最后完成的任务: {task_description}
        任务结果: {result}
        未完成任务列表: {task_list}
        
        基于结果，创建完成目标所需的新任务，每行一个任务。
        """
        
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            temperature=0.5,
            max_tokens=1500
        )
        
        new_tasks = response.choices[0].text.strip().split('\n')
        return [{"task_id": self.task_id_counter + i + 1, "task_name": task_name} 
                for i, task_name in enumerate(new_tasks) if task_name.strip()]
        
    def prioritization_agent(self, this_task_id):
        """
        优先级代理：重新排序任务列表
        """
        task_names = [t["task_name"] for t in self.task_list]
        
        prompt = f"""
        你是一个任务优先级AI。根据以下目标对任务重新排序:
        目标: {self.objective}
        任务: {task_names}
        
        按优先级顺序返回重新排序的任务，每行一个。
        """
        
        response = openai.Completion.create(
            engine="text-davinci-003",
            prompt=prompt,
            temperature=0.5,
            max_tokens=1000
        )
        
        prioritized_tasks = response.choices[0].text.strip().split('\n')
        # 重新构建任务列表
        # ...优先级排序逻辑

class AgentEvaluationFramework:
    """
    AI代理评测框架
    提供全面的性能指标评估
    """
    
    def __init__(self):
        self.metrics = {
            'task_completion_accuracy': 0.0,    # 任务完成准确性
            'response_time': 0.0,               # 响应时间
            'resource_consumption': 0.0,        # 资源消耗
            'scalability_score': 0.0,           # 可扩展性评分
            'usability_score': 0.0              # 易用性评分
        }
    
    def evaluate_task_completion(self, agent, test_cases):
        """
        评估任务完成准确性
        评分标准: 0-100分
        - 90-100: 优秀，任务完成度高，结果准确
        - 80-89:  良好，大部分任务能正确完成
        - 70-79:  中等，基本任务能完成，偶有错误
        - 60-69:  及格，简单任务能完成，复杂任务困难
        - <60:    不及格，任务完成能力不足
        """
        successful_tasks = 0
        total_tasks = len(test_cases)
        
        for test_case in test_cases:
            try:
                result = agent.execute_task(test_case['task'])
                if self.validate_result(result, test_case['expected']):
                    successful_tasks += 1
            except Exception as e:
                print(f"任务执行失败: {e}")
                
        accuracy = (successful_tasks / total_tasks) * 100
        self.metrics['task_completion_accuracy'] = accuracy
        return accuracy
    
    def evaluate_response_time(self, agent, test_tasks):
        """
        评估响应时间和效率
        评分标准:
        - <10秒: 优秀 (95-100分)
        - 10-30秒: 良好 (80-94分)
        - 30-60秒: 中等 (60-79分)
        - 60-120秒: 及格 (40-59分)
        - >120秒: 不及格 (<40分)
        """
        import time
        total_time = 0
        
        for task in test_tasks:
            start_time = time.time()
            agent.execute_task(task)
            end_time = time.time()
            total_time += (end_time - start_time)
            
        avg_time = total_time / len(test_tasks)
        
        if avg_time < 10:
            score = 95 + (10 - avg_time)
        elif avg_time < 30:
            score = 80 + (30 - avg_time) * 0.7
        elif avg_time < 60:
            score = 60 + (60 - avg_time) * 0.67
        elif avg_time < 120:
            score = 40 + (120 - avg_time) * 0.33
        else:
            score = max(0, 40 - (avg_time - 120) * 0.1)
            
        self.metrics['response_time'] = score
        return avg_time, score

class FrameworkSelector:
    """
    框架选择器：基于项目特征推荐最适合的框架
    """
    
    def __init__(self):
        self.criteria = {
            'complexity': 0,      # 任务复杂度 (1-5)
            'budget': 0,          # 预算水平 (1-5)
            'team_size': 0,       # 团队规模 (1-5)
            'timeline': 0,        # 时间要求 (1-5, 5为最紧急)
            'scalability': 0      # 可扩展性需求 (1-5)
        }
    
    def evaluate_project(self, complexity, budget, team_size, timeline, scalability):
        """
        项目评估函数
        """
        self.criteria['complexity'] = complexity
        self.criteria['budget'] = budget
        self.criteria['team_size'] = team_size
        self.criteria['timeline'] = timeline
        self.criteria['scalability'] = scalability
        
        # AutoGPT评分计算
        autogpt_score = (
            complexity * 0.3 +
            budget * 0.2 +
            team_size * 0.2 +
            scalability * 0.3
        )
        
        # BabyAGI评分计算
        babyagi_score = (
            (6 - complexity) * 0.2 +
            (6 - budget) * 0.3 +
            timeline * 0.3 +
            (6 - team_size) * 0.2
        )
        
        if autogpt_score > babyagi_score:
            recommendation = "AutoGPT"
            confidence = (autogpt_score - babyagi_score) / 5 * 100
        else:
            recommendation = "BabyAGI"
            confidence = (babyagi_score - autogpt_score) / 5 * 100
            
        return {
            'recommendation': recommendation,
            'confidence': f"{confidence:.1f}%",
            'autogpt_score': autogpt_score,
            'babyagi_score': babyagi_score,
            'reasoning': self.generate_reasoning(recommendation)
        }
    
    def generate_reasoning(self, recommendation):
        """生成推荐理由"""
        if recommendation == "AutoGPT":
            return """
            推荐AutoGPT的原因：
            1. 项目复杂度较高，需要多工具集成
            2. 团队规模和预算能支撑复杂架构
            3. 可扩展性需求强，插件化架构更适合
            4. 长期项目，可以承受较高的学习成本
            """
        else:
            return """
            推荐BabyAGI的原因：
            1. 项目时间紧迫，需要快速部署
            2. 预算有限，轻量级架构更经济
            3. 团队规模较小，简洁架构更易维护
            4. 专注特定领域，不需要过多工具集成
            """
# 使用示例
selector = FrameworkSelector()
result = selector.evaluate_project(
    complexity=4,      # 高复杂度
    budget=3,          # 中等预算
    team_size=2,       # 小团队
    timeline=4,        # 时间紧迫
    scalability=3      # 中等可扩展性需求
)
print(f"推荐框架: {result['recommendation']}")
print(f"置信度: {result['confidence']}")