import os
from openai import OpenAI
from dotenv import load_dotenv
from typing import List, Dict

# 加载 .env 文件中的环境变量
load_dotenv()


class HelloAgentsLLM:

    def __init__(self, model: str = None, api_key: str = None, base_url: str = None, timeout: int = None):
        """
        初始化客户端。优先使用传入参数，如果未提供，则从环境变量加载。
        """
        self.model = model or os.getenv("AI_MODEL_NAME")
        api_key = api_key or os.getenv("AI_API_KEY")
        base_url = base_url or os.getenv("AI_API_BASE_URL")
        timeout = timeout or int(os.getenv("AI_LLM_TIMEOUT", 60))

        if not all([self.model, api_key, base_url]):
            raise ValueError("模型ID、API密钥和服务地址必须被提供或在.env文件中定义。")

        self.client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)

    def think(self, messages: List[Dict[str, str]], temperature: float = 0) -> str:
        """
        调用大语言模型进行思考，并返回其响应。
        """
        print(f"🧠 正在调用 {self.model} 模型...")
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=temperature,
                stream=True,
            )

            # 处理流式响应
            print("✅ 大语言模型响应成功:")
            collected_content = []
            for chunk in response:
                content = chunk.choices[0].delta.content or ""
                print(content, end="", flush=True)
                collected_content.append(content)
            print()  # 在流式输出结束后换行
            return "".join(collected_content)

        except Exception as e:
            print(f"❌ 调用LLM API时发生错误: {e}")
            return None


# --- 客户端使用示例 ---
if __name__ == '__main__':
    try:
        llmClient = HelloAgentsLLM()

        exampleMessages = [
            {"role": "system", "content": "You are a helpful assistant that writes Python code."},
            {"role": "user", "content": "写一个快速排序算法"}
        ]

        print("--- 调用LLM ---")
        responseText = llmClient.think(exampleMessages)
        if responseText:
            print("\n\n--- 完整模型响应 ---")
            print(responseText)

    except ValueError as e:
        print(e)

pip install tavily-python

from tavily import TavilyClient
import os
from dotenv import load_dotenv
from typing import Dict, Any

# 加载 .env 文件中的环境变量
load_dotenv()


def search(query: str) -> str:
    """
    一个基于 Tavily 的 AI 专用搜索引擎工具。
    它不仅返回网页链接，还能直接生成问题的简短答案或相关上下文。
    """
    print(f"🔍 正在执行 [Tavily] 网页搜索: {query}")
    try:
        api_key = os.getenv("TAVILY_API_KEY")
        if not api_key:
            return "错误: TAVILY_API_KEY 未在 .env 文件中配置。"

        # 初始化 Tavily 客户端
        client = TavilyClient(api_key=api_key)

        # 执行搜索
        # search_depth="basic" 速度快，"advanced" 质量高但慢
        # include_answer=True 让 Tavily 尝试直接生成一个简短回答
        response = client.search(
            query=query,
            search_depth="basic",
            include_answer=True,
            max_results=3
        )

        # 智能解析: 优先返回 Tavily 生成的直接答案
        if response.get("answer"):
            return f"直接答案: {response['answer']}"

        # 如果没有直接答案，返回上下文片段 (Context)
        if response.get("results"):
            snippets = []
            for i, res in enumerate(response["results"]):
                # 清洗内容，防止过长
                content = res.get('content', '')[:300]
                snippets.append(f"[{i + 1}] {res.get('title', '')}\n{content}...")
            return "\n\n".join(snippets)

        return f"对不起，没有找到关于 '{query}' 的信息。"

    except Exception as e:
        return f"搜索时发生错误: {e}"


class ToolExecutor:
    """
    一个工具执行器，负责管理和执行工具。
    """

    def __init__(self):
        self.tools: Dict[str, Dict[str, Any]] = {}

    def register_tool(self, name: str, description: str, func: callable):
        """
        向工具箱中注册一个新工具。
        """
        if name in self.tools:
            print(f"警告:工具 '{name}' 已存在，将被覆盖。")
        self.tools[name] = {"description": description, "func": func}
        print(f"工具 '{name}' 已注册。")

    def get_tool(self, name: str) -> callable:
        """
        根据名称获取一个工具的执行函数。
        """
        return self.tools.get(name, {}).get("func")

    def get_available_tools(self) -> str:
        """
        获取所有可用工具的格式化描述字符串。
        """
        return "\n".join([
            f"- {name}: {info['description']}"
            for name, info in self.tools.items()
        ])


if __name__ == "__main__":
    # 1. 初始化工具执行器
    toolExecutor = ToolExecutor()

    # 2. 注册我们的实战搜索工具
    search_description = "一个网页搜索引擎。当你需要回答关于时事、事实以及在你的知识库中找不到的信息时，应使用此工具。"
    toolExecutor.register_tool("Search", search_description, search)

    # 3. 打印可用的工具
    print("\n--- 可用的工具 ---")
    print(toolExecutor.get_available_tools())

    # 4. 智能体的Action调用，这次我们问一个实时性的问题
    print("\n--- 执行 Action: Search['英伟达最新的GPU型号是什么'] ---")
    tool_name = "Search"
    tool_input = "英伟达最新的GPU型号是什么"

    tool_function = toolExecutor.get_tool(tool_name)
    if tool_function:
        observation = tool_function(tool_input)
        print("--- 观察 (Observation) ---")
        print(observation)
    else:
        print(f"错误:未找到名为 '{tool_name}' 的工具。")

工具 'Search' 已注册。

--- 可用的工具 ---
- Search: 一个网页搜索引擎。当你需要回答关于时事、事实以及在你的知识库中找不到的信息时，应使用此工具。

--- 执行 Action: Search['英伟达最新的GPU型号是什么'] ---
🔍 正在执行 [Tavily] 网页搜索: 英伟达最新的GPU型号是什么
--- 观察 (Observation) ---
直接答案: 英伟达最新的GPU型号是H100，专为高性能AI训练优化。它具有极高的带宽和计算能力。H100在Transformer模型训练和推理性能方面表现卓越。

# ReAct 提示词模板
REACT_PROMPT_TEMPLATE = """
请注意，你是一个有能力调用外部工具的智能助手。

可用工具如下:
{tools}

请严格按照以下格式进行回应:

Thought: 你的思考过程，用于分析问题、拆解任务和规划下一步行动。
Action: 你决定采取的行动，必须是以下格式之一:
- `{{tool_name}}[{{tool_input}}]`:调用一个可用工具。
- `Finish[最终答案]`:当你认为已经获得最终答案时。
- 当你收集到足够的信息，能够回答用户的最终问题时，你必须在Action:字段后使用 finish(answer="...") 来输出最终答案。

现在，请开始解决以下问题:
Question: {question}
History: {history}
"""

from tool import ToolExecutor, search, get_current_time
from llm import HelloAgentsLLM
import re

REACT_PROMPT_TEMPLATE = """
请注意，你是一个有能力调用外部工具的智能助手。

可用工具如下:
{tools}

请严格按照以下格式进行回应:

Thought: 你的思考过程，用于分析问题、拆解任务和规划下一步行动。
Action: 你决定采取的行动，必须是以下格式之一:
- `{{tool_name}}[{{tool_input}}]`:调用一个可用工具。
- `Finish[最终答案]`:当你认为已经获得最终答案时。
- 当你收集到足够的信息，能够回答用户的最终问题时，你必须在Action:字段后使用 finish(answer="...") 来输出最终答案。

现在，请开始解决以下问题:
Question: {question}
History: {history}
"""


class ReActAgent:
    def __init__(self, llm_client: HelloAgentsLLM, tool_executor: ToolExecutor, max_steps: int = 5):
        self.llm_client = llm_client
        self.tool_executor = tool_executor
        self.max_steps = max_steps
        self.history = []

    def run(self, question: str):
        """
        运行ReAct智能体来回答一个问题。
        """
        self.history = []  # 每次运行时重置历史记录
        current_step = 0

        while current_step < self.max_steps:
            current_step += 1
            print(f"--- 第 {current_step} 步 ---")

            # 1. 格式化提示词
            tools_desc = self.tool_executor.get_available_tools()
            history_str = "\n".join(self.history)
            prompt = REACT_PROMPT_TEMPLATE.format(
                tools=tools_desc,
                question=question,
                history=history_str
            )

            # 2. 调用LLM进行思考
            messages = [{"role": "user", "content": prompt}]
            response_text = self.llm_client.think(messages=messages)

            if not response_text:
                print("错误:LLM未能返回有效响应。")
                break

            # 3. 解析LLM的输出
            thought, action = self._parse_output(response_text)

            if thought:
                print(f"思考: {thought}")

            if not action:
                print("警告:未能解析出有效的Action，流程终止。")
                break

            # 4. 执行Action
            if action.startswith("Finish"):
                # 如果是Finish指令，提取最终答案并结束
                final_answer = re.match(r"Finish\[(.*)\]", action).group(1)
                print(f"🎉 最终答案: {final_answer}")
                return final_answer

            tool_name, tool_input = self._parse_action(action)
            if not tool_name:
                # ... 处理无效Action格式 ...
                continue

            print(f"🎬 行动: {tool_name}[{tool_input}]")

            tool_function = self.tool_executor.get_tool(tool_name)
            if not tool_function:
                observation = f"错误:未找到名为 '{tool_name}' 的工具。"
            else:
                if tool_input:
                    observation = tool_function(tool_input)  # 调用真实工具
                else:
                    observation = tool_function()
            print(f"👀 观察: {observation}")

            # 将本轮的Action和Observation添加到历史记录中
            self.history.append(f"Action: {action}")
            self.history.append(f"Observation: {observation}")
        print("已达到最大步数，流程终止。")
        return None

    @staticmethod
    def _parse_output(text: str):
        """解析LLM的输出，提取Thought和Action。"""
        thought_match = re.search(r"Thought: (.*)", text)
        action_match = re.search(r"Action: (.*)", text)
        thought = thought_match.group(1).strip() if thought_match else None
        action = action_match.group(1).strip() if action_match else None
        return thought, action

    @staticmethod
    def _parse_action(action_text: str):
        """解析Action字符串，提取工具名称和输入。"""
        match = re.match(r"(\w+)\[(.*)\]", action_text)
        if match:
            return match.group(1), match.group(2)
        return None, None


if __name__ == "__main__":
    # 1. 初始化工具执行器
    tool_executor = ToolExecutor()
    llm_agent = HelloAgentsLLM()
    # 2. 注册工具
    # 搜索工具
    search_description = "一个网页搜索引擎。当你需要回答关于时事、事实以及在你的知识库中找不到的信息时，应使用此工具。"
    tool_executor.register_tool("Search", search_description, search)
    time_description = "获取当前系统精确时间的工具，用于回答时间日期问题、推算相对时间，并为处理涉及“最新”或“时效性”的任务（如搜索最新新闻）提供必要的时间基准。"
    # 获取时间工具
    tool_executor.register_tool("CurrentTime", time_description, get_current_time)
    # 获取时间工具
    agent = ReActAgent(llm_agent, tool_executor)
    agent.run("华为最新的手机是哪一款？它的主要卖点是什么？")

工具 'Search' 已注册。
工具 'CurrentTime' 已注册。
--- 第 1 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户询问华为最新的手机是哪一款以及其主要卖点。这是一个关于当前产品信息的问题，具有时效性。我的知识库可能没有最新的产品发布信息，因此我需要使用搜索工具来获取准确和最新的信息。为了确保搜索结果的时效性，我应该先获取当前时间，以便在搜索时能指定时间范围或验证信息的时效性。

Action: CurrentTime[]
思考: 用户询问华为最新的手机是哪一款以及其主要卖点。这是一个关于当前产品信息的问题，具有时效性。我的知识库可能没有最新的产品发布信息，因此我需要使用搜索工具来获取准确和最新的信息。为了确保搜索结果的时效性，我应该先获取当前时间，以便在搜索时能指定时间范围或验证信息的时效性。
🎬 行动: CurrentTime[]
👀 观察: 2025-12-24 14:59:27
--- 第 2 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户询问华为最新的手机型号及其主要卖点。这是一个关于当前产品信息的问题，具有时效性。我刚刚获取了当前时间是2025年12月24日。为了提供准确信息，我需要搜索关于华为最新手机型号的近期新闻或官方发布信息。

Action: Search[华为最新手机 2025年 型号 主要卖点]
思考: 用户询问华为最新的手机型号及其主要卖点。这是一个关于当前产品信息的问题，具有时效性。我刚刚获取了当前时间是2025年12月24日。为了提供准确信息，我需要搜索关于华为最新手机型号的近期新闻或官方发布信息。
🎬 行动: Search[华为最新手机 2025年 型号 主要卖点]
🔍 正在执行 [Tavily] 网页搜索: 华为最新手机 2025年 型号 主要卖点
👀 观察: 直接答案: 2025年华为手机主要卖点是拍照能力和时尚设计，特别是HUAWEI Mate 60 Pro，融合科技与美学。
--- 第 3 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户询问华为最新的手机是哪一款以及其主要卖点。根据历史记录，我已经获取了当前时间（2025年12月24日）并进行了搜索。搜索结果显示，在2025年，华为最新的旗舰手机之一是HUAWEI Mate 60 Pro，其主要卖点是拍照能力和时尚设计，融合了科技与美学。这个信息直接回答了用户的问题，并且基于当前时间，可以认为是“最新”的。因此，我可以基于这个观察结果来组织最终答案。

Action: Finish[根据2025年的信息，华为最新的旗舰手机之一是HUAWEI Mate 60 Pro。它的主要卖点在于其卓越的拍照能力和时尚的设计美学，体现了科技与艺术的融合。]
思考: 用户询问华为最新的手机是哪一款以及其主要卖点。根据历史记录，我已经获取了当前时间（2025年12月24日）并进行了搜索。搜索结果显示，在2025年，华为最新的旗舰手机之一是HUAWEI Mate 60 Pro，其主要卖点是拍照能力和时尚设计，融合了科技与美学。这个信息直接回答了用户的问题，并且基于当前时间，可以认为是“最新”的。因此，我可以基于这个观察结果来组织最终答案。
🎉 最终答案: 根据2025年的信息，华为最新的旗舰手机之一是HUAWEI Mate 60 Pro。它的主要卖点在于其卓越的拍照能力和时尚的设计美学，体现了科技与艺术的融合。

PLANNER_PROMPT_TEMPLATE = """
你是一个顶级的AI规划专家。你的任务是将用户提出的复杂问题分解成一个由多个简单步骤组成的行动计划。
请确保计划中的每个步骤都是一个独立的、可执行的子任务，并且严格按照逻辑顺序排列。
你的输出必须是一个Python列表，其中每个元素都是一个描述子任务的字符串。

问题: {question}

请严格按照以下格式输出你的计划,```python与```作为前后缀是必要的:
-```python
["步骤1", "步骤2", "步骤3", ...]
-```
"""

EXECUTOR_PROMPT_TEMPLATE = """
你是一位顶级的AI执行专家。你的任务是严格按照给定的计划，一步步地解决问题。
你将收到原始问题、完整的计划、以及到目前为止已经完成的步骤和结果。
请你专注于解决“当前步骤”，并仅输出该步骤的最终答案，不要输出任何额外的解释或对话。

# 原始问题:
{question}

# 完整计划:
{plan}

# 历史步骤与结果:
{history}

# 当前步骤:
{current_step}

请仅输出针对“当前步骤”的回答:
"""

import ast
from llm import HelloAgentsLLM

class Planner:
    def __init__(self, llm_client: HelloAgentsLLM):
        self.llm_client = llm_client

    def plan(self, question: str) -> list[str]:
        """
        根据用户问题生成一个行动计划。
        """
        prompt = PLANNER_PROMPT_TEMPLATE.format(question=question)

        # 为了生成计划，我们构建一个简单的消息列表
        messages = [{"role": "user", "content": prompt}]

        print("--- 正在生成计划 ---")
        # 使用流式输出来获取完整的计划
        response_text = self.llm_client.think(messages=messages) or ""

        print(f"✅ 计划已生成:\n{response_text}")

        # 解析LLM输出的列表字符串
        try:
            # 找到```python和```之间的内容
            plan_str = response_text.split("```python")[1].split("```")[0].strip()
            # 使用ast.literal_eval来安全地执行字符串，将其转换为Python列表
            plan = ast.literal_eval(plan_str)
            return plan if isinstance(plan, list) else []
        except (ValueError, SyntaxError, IndexError) as e:
            print(f"❌ 解析计划时出错: {e}")
            print(f"原始响应: {response_text}")
            return []
        except Exception as e:
            print(f"❌ 解析计划时发生未知错误: {e}")
            return []


class Executor:
    def __init__(self, llm_client: HelloAgentsLLM):
        self.llm_client = llm_client

    def execute(self, question: str, plan: list[str]) -> str:
        """
        根据计划，逐步执行并解决问题。
        """
        response_text = ""
        history = ""  # 用于存储历史步骤和结果的字符串

        print("\n--- 正在执行计划 ---")

        for i, step in enumerate(plan):
            print(f"\n-> 正在执行步骤 {i + 1}/{len(plan)}: {step}")

            prompt = EXECUTOR_PROMPT_TEMPLATE.format(
                question=question,
                plan=plan,
                history=history if history else "无",  # 如果是第一步，则历史为空
                current_step=step
            )

            messages = [{"role": "user", "content": prompt}]

            response_text = self.llm_client.think(messages=messages) or ""

            # 更新历史记录，为下一步做准备
            history += f"步骤 {i + 1}: {step}\n结果: {response_text}\n\n"

            print(f"✅ 步骤 {i + 1} 已完成，结果: {response_text}")

        # 循环结束后，最后一步的响应就是最终答案
        final_answer = response_text
        return final_answer


class PlanAndSolveAgent:
    def __init__(self, llm_client: HelloAgentsLLM):
        """
        初始化智能体，同时创建规划器和执行器实例。
        """
        self.llm_client = llm_client
        self.planner = Planner(self.llm_client)
        self.executor = Executor(self.llm_client)

    def run(self, question: str):
        """
        运行智能体的完整流程:先规划，后执行。
        """
        print(f"\n--- 开始处理问题 ---\n问题: {question}")

        # 1. 调用规划器生成计划
        plan = self.planner.plan(question)

        # 检查计划是否成功生成
        if not plan:
            print("\n--- 任务终止 --- \n无法生成有效的行动计划。")
            return

        # 2. 调用执行器执行计划
        final_answer = self.executor.execute(question, plan)

        print(f"\n--- 任务完成 ---\n最终答案: {final_answer}")


if __name__ == "__main__":
    llm_client = HelloAgentsLLM()
    planner = PlanAndSolveAgent(llm_client)
    planner.run(
        "一个水果店周一卖出了15个苹果。周二卖出的苹果数量是周一的两倍。周三卖出的数量比周二少了5个。请问这三天总共卖出了多少个苹果？")

--- 开始处理问题 ---
问题: 一个水果店周一卖出了15个苹果。周二卖出的苹果数量是周一的两倍。周三卖出的数量比周二少了5个。请问这三天总共卖出了多少个苹果？
--- 正在生成计划 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
-```python
["计算周二卖出的苹果数量：周一卖出的15个苹果乘以2", "计算周三卖出的苹果数量：周二卖出的数量减去5个", "计算三天卖出的苹果总数：将周一、周二、周三卖出的数量相加"]
-```
✅ 计划已生成:
-```python
["计算周二卖出的苹果数量：周一卖出的15个苹果乘以2", "计算周三卖出的苹果数量：周二卖出的数量减去5个", "计算三天卖出的苹果总数：将周一、周二、周三卖出的数量相加"]
-```

--- 正在执行计划 ---

-> 正在执行步骤 1/3: 计算周二卖出的苹果数量：周一卖出的15个苹果乘以2
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
30
✅ 步骤 1 已完成，结果: 30

-> 正在执行步骤 2/3: 计算周三卖出的苹果数量：周二卖出的数量减去5个
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
25
✅ 步骤 2 已完成，结果: 25

-> 正在执行步骤 3/3: 计算三天卖出的苹果总数：将周一、周二、周三卖出的数量相加
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
70
✅ 步骤 3 已完成，结果: 70

--- 任务完成 ---
最终答案: 70

from typing import List, Dict, Any, Optional

class Memory:
    """
    一个简单的短期记忆模块，用于存储智能体的行动与反思轨迹。
    """

    def __init__(self):
        """
        初始化一个空列表来存储所有记录。
        """
        self.records: List[Dict[str, Any]] = []

    def add_record(self, record_type: str, content: str):
        """
        向记忆中添加一条新记录。

        参数:
        - record_type (str): 记录的类型 ('execution' 或 'reflection')。
        - content (str): 记录的具体内容 (例如，生成的代码或反思的反馈)。
        """
        record = {"type": record_type, "content": content}
        self.records.append(record)
        print(f"📝 记忆已更新，新增一条 '{record_type}' 记录。")

    def get_trajectory(self) -> str:
        """
        将所有记忆记录格式化为一个连贯的字符串文本，用于构建提示词。
        """
        trajectory_parts = []
        for record in self.records:
            if record['type'] == 'execution':
                trajectory_parts.append(f"--- 上一轮尝试 (代码) ---\n{record['content']}")
            elif record['type'] == 'reflection':
                trajectory_parts.append(f"--- 评审员反馈 ---\n{record['content']}")
        
        return "\n\n".join(trajectory_parts)

    def get_last_execution(self) -> Optional[str]:
        """
        获取最近一次的执行结果 (例如，最新生成的代码)。
        如果不存在，则返回 None。
        """
        for record in reversed(self.records):
            if record['type'] == 'execution':
                return record['content']
        return None

class ReflectionAgent:
    def __init__(self, llm_client, max_iterations=3):
        self.llm_client = llm_client
        self.memory = Memory()
        self.max_iterations = max_iterations

    def run(self, task: str):
        print(f"\n--- 开始处理任务 ---\n任务: {task}")

        # --- 1. 初始执行 ---
        print("\n--- 正在进行初始尝试 ---")
        initial_prompt = INITIAL_PROMPT_TEMPLATE.format(task=task)
        initial_code = self._get_llm_response(initial_prompt)
        self.memory.add_record("execution", initial_code)

        # --- 2. 迭代循环:反思与优化 ---
        for i in range(self.max_iterations):
            print(f"\n--- 第 {i + 1}/{self.max_iterations} 轮迭代 ---")

            # a. 反思
            print("\n-> 正在进行反思...")
            last_code = self.memory.get_last_execution()
            reflect_prompt = REFLECT_PROMPT_TEMPLATE.format(task=task, code=last_code)
            feedback = self._get_llm_response(reflect_prompt)
            self.memory.add_record("reflection", feedback)

            # b. 检查是否需要停止
            if "无需改进" in feedback:
                print("\n✅ 反思认为代码已无需改进，任务完成。")
                break

            # c. 优化
            print("\n-> 正在进行优化...")
            refine_prompt = REFINE_PROMPT_TEMPLATE.format(
                task=task,
                last_code_attempt=last_code,
                feedback=feedback
            )
            refined_code = self._get_llm_response(refine_prompt)
            self.memory.add_record("execution", refined_code)

        final_code = self.memory.get_last_execution()
        print(f"\n--- 任务完成 ---\n最终生成的代码:\n```python\n{final_code}\n```")
        return final_code

    def _get_llm_response(self, prompt: str) -> str:
        """一个辅助方法，用于调用LLM并获取完整的流式响应。"""
        messages = [{"role": "user", "content": prompt}]
        response_text = self.llm_client.think(messages=messages) or ""
        return response_text


if __name__ == "__main__":
    llm_client = HelloAgentsLLM()
    reflection_agent = ReflectionAgent(llm_client)
    reflection_agent.run(task="编写一个Python函数，找出1到n之间所有的素数 (prime numbers)。")

--- 开始处理任务 ---
任务: 编写一个Python函数，找出1到n之间所有的素数 (prime numbers)。

--- 正在进行初始尝试 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
(python代码)
...
📝 记忆已更新，新增一条 'execution' 记录。

--- 第 1/3 轮迭代 ---

-> 正在进行反思...
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
当前代码使用了标准的埃拉托斯特尼筛法，其时间复杂度为 O(n log log n)，这在算法层面对于生成从1到n的所有素数已经接近最优。

然而，该实现存在一个主要的性能瓶颈：内存使用和缓存效率。`is_prime` 列表长度为 `n+1`，当 `n` 很大（例如超过 10^8）时，会消耗大量内存（约 `n` 字节），并且对一个大数组进行顺序访问和修改，可能导致缓存未命中率较高，影响速度。

**算法上更优的解决方案**：
可以采用**分段筛法（Segmented Sieve）**。其核心思想是将区间 `[2, n]` 分成多个较小的段，每次只筛一个段，从而将内存使用量从 O(n) 降低到 O(√n + S)，其中 S 是段的大小。这允许处理远大于内存容量的 `n`。

**具体改进建议**：
1.  计算所有小于等于 √n 的素数（使用普通筛法）。
2.  将区间 `[2, n]` 划分为大小为 `segment_size`（通常约为 √n 或与CPU缓存匹配）的段。
3.  对于每个段 `[low, high]`，创建一个布尔数组 `is_prime_segment` 表示该段内的数是否为素数（初始为True）。
4.  对于第1步中得到的每个小素数 `p`，在段 `[low, high]` 内找到第一个 `p` 的倍数，然后标记段内所有 `p` 的倍数为非素数。
5.  收集该段中剩余的素数。
6.  重复步骤3-5，直到处理完整个区间。

分段筛法的时间复杂度仍为 O(n log log n)，但空间复杂度显著降低，并且由于更好地利用了CPU缓存，实际运行速度（特别是对于非常大的 `n`）可以比普通筛法快数倍。

因此，对于处理极大 `n` 的场景，当前代码在算法效率上**存在改进空间**，应采用分段筛法进行优化。
📝 记忆已更新，新增一条 'reflection' 记录。

-> 正在进行优化...
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
(python代码)
...
--- 第 2/3 轮迭代 ---

-> 正在进行反思...
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
当前代码实现了分段筛法，时间复杂度为 O(n log log n)，空间复杂度为 O(√n)。对于大范围（例如 n > 10^7）的素数查找，这已经是理论最优的算法之一。

然而，在算法层面仍存在一个可优化的点：**小素数筛选部分可以进一步优化以减少冗余操作**。具体来说，在生成小素数（≤ √n）时，代码使用了标准的埃拉托斯特尼筛法，但其内层循环的起始点可以更精确地优化。

**改进建议**：
1. **优化小素数筛法的内层循环**：在标记合数时，可以从 `i*i` 开始，步长为 `i`，但当前代码在 `i*i < limit` 时才进入内层循环。虽然这避免了小数字的冗余标记，但对于接近 √n 的素数，`i*i` 可能已经超出 `limit`，导致循环被跳过。实际上，当 `i` 较大时，`i*i` 可能远大于 `limit`，因此这个检查是必要的，但可以进一步优化循环条件，避免不必要的判断。
2. **使用位图（bit array）替代布尔列表**：虽然这更多是内存和常数优化，但可以显著减少缓存未命中，提升实际性能。例如，使用 `bytearray` 或 `bitarray` 库。
3. **并行化分段处理**：对于极大的 n（例如 n > 10^9），可以考虑将不同段分配给多个线程或进程并行筛选，但这需要处理并发和合并结果。

**具体优化代码示例（小素数筛选部分）**：
（python代码）
...

**总结**：当前算法在渐进复杂度上已是最优，但通过上述低级优化（如使用 `bytearray` 和切片赋值）可以提升常数因子，尤其在大规模数据时效果明显。因此，从纯算法角度看，无需改进；但从极致性能角度，建议实施上述低级优化。
📝 记忆已更新，新增一条 'reflection' 记录。

✅ 反思认为代码已无需改进，任务完成。

--- 任务完成 ---
最终生成的代码:
（python代码）
...