def search(query: str) -> str:
    """
    一个基于SerApi的实战网页搜索工具
    他会智能地解析搜索结果,优先返回直接答案或指示图谱信息
    """
    print(f"🔍 正在执行 [SerApi] 网页搜索: {query}")
    try:
        api_key = os.getenv("SERPAPI_API_KEY")
        if not api_key:
            return "错误: SERPAPI_API_KEY 未在 .env文件中配置."

        params = {
            "engine": "google",
            "q": query,
            "api_key": api_key,
            "gl": "cn", # 国家代码
            "hl": "zh-cn", # 语言代码
        }

        client = SerpApiClient(params)
        results = client.get_dict()

        if "answer_box_list" in results:
            return "\n".join(results["answer_box_list"])
        if "answer_box" in results and "answer" in results["answer_box"]:
            return results["answer_box"]["answer"]
        if "knowledge_graph" in results and "description" in results["knowledge_graph"]:
            return results["knowledge_graph"]["description"]
        if "organic_results" in results and results["organic_results"]:
            snippets = [
                f"[{i+1}] {res.get('title', '')}\n{res.get('snippet', '')}"
                for i, res in enumerate(results["organic_results"])
            ]
            return "\n\n".join(snippets)

        return f"对不起, 没有找到关于 '{query}'的信息."
    except Exception as e:
        return f"搜索时发生错误: {e}"

class HelloAgentsLLM:
    """
    它用于调用任何兼容OpenAI接口的服务, 并默认使用流式响应
    """
    def __init__(self, model: str = None, apikey: str = None, baseUrl: str = None, timeout: int = None):
        """
        初始化客户端。优先使用传入参数，如果未提供，则从环境变量加载
        """
        self.model = model or os.getenv("LLM_MODEL_ID")
        apikey = apikey or os.getenv("LLM_API_KEY")
        baseUrl = baseUrl or os.getenv("LLM_BASE_URL")
        timeout = timeout or int(os.getenv("LLM_TIMEOUT", 60))

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

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

    def think(self, messages: List[Dict[str, str]], temperature: float = 0) -> str:
        """
        调用大语言模型进行思考，并返回其响应。

        :param self: 说明
        :param messages: 说明
        :type messages: List[Dict[str, str]]
        :param temperature: 说明
        :type temperature: float
        :return: 说明
        :rtype: 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

def run(self, question: str):
    self.history = []
    current_step = 0

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

        tools_desc = self.tool_exectuor.getAvailableTools()
        history_str = "\n".join(self.history)
        prompt = REACT_PROMPT_TEMPLATE.format(
            tools=tools_desc,
            question=question,
            history=history_str
        )

        messages = [{"role": "user", "content": prompt}]
        response_text = self.llm_client.think(messages=messages)

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

        thought, action = self._parse_output(response_text)

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

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

        if action.startswith("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 or not tool_input:
            continue

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

        too_function = self.tool_exectuor.getTool(tool_name)
        if not too_function:
            observation = f"❌ 错误:未找到名为 '{tool_name}' 的工具"
        else:
            observation = too_function(tool_input)

        print(f"👀 观察: {observation}")

        self.history.append(f"Action: {action}")
        self.history.append(f"Observation: {observation}")

    print("已达到最大步数，流程终止。")
    return None

def _parse_output(self, text: str):
    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

def _parse_action(self, action_text: str):
    if action_text.startswith("Finish"):
        final_answer_match = re.match(r"Finish\[answer=\"(.*)\"]", action_text)
        if final_answer_match:
            return "Finish", final_answer_match.group(1)

    match = re.match(r"(\w+)\[(.*)\]", action_text)
    if match:
        return match.group(1), match.group(2)
    return None, None