LightAgent 0.2.5__tar.gz → 0.2.8__tar.gz

{lightagent-0.2.5 → lightagent-0.2.8}/LightAgent/la_core.py

@@ -14,10 +14,11 @@ import importlib
 
 # 全局工具注册表
 _FUNCTION_MAPPINGS = {}  # 工具名称 -> 工具函数
+_FUNCTION_INFO = {}   # 工具名称 -> 工具info信息
 _OPENAI_FUNCTION_SCHEMAS = []  # OpenAI 格式的工具描述
 _PROMPT_FUNCTION_SCHEMAS = []  # prompt 格式的工具描述
 
-__version__ = "0.2.1"  # 你可以根据需要设置版本号
+__version__ = "0.2.8"  # 你可以根据需要设置版本号
 
 
 def register_tool_manually(tools: List[Union[str, Callable]]) -> bool:
@@ -32,6 +33,9 @@ def register_tool_manually(tools: List[Union[str, Callable]]) -> bool:
 
         tool_info = func.tool_info
         tool_name = tool_info["tool_name"]
+
+        # 注册到全局字典
+        _FUNCTION_INFO[tool_name] = tool_info
         _FUNCTION_MAPPINGS[tool_name] = func  # 注册工具
 
         # 构建 OpenAI 格式的工具描述
@@ -159,11 +163,14 @@ class LightAgent:
             instructions: Optional[str] = None,  # 代理指令
             role: Optional[str] = None,
             model: str,
-            api_key: str,
+            api_key: str | None = None,
             base_url: str | httpx.URL | None = None,
             websocket_base_url: str | httpx.URL | None = None,
             memory=None,  # 支持外部传入记忆模块
             tree_of_thought: bool = False,  # 是否启用链式思考
+            tot_model: str | None = None,
+            tot_api_key: str | None = None,
+            tot_base_url: str | httpx.URL | None = None,
             self_learning: bool = False,  # 是否启用agent自我学习
             tools: List[Union[str, Callable]] = None,  # 支持混合输入
             debug: bool = False,  # 是否启用调试模式
@@ -182,6 +189,9 @@ class LightAgent:
         :param websocket_base_url: WebSocket 的基础 URL。
         :param memory: 外部传入的记忆模块，需实现 `retrieve` 和 `store` 方法。
         :param tree_of_thought: 是否启用思维链功能。
+        :param tot_model: 使用的模型名称。
+        :param tot_api_key: API 密钥。
+        :param tot_base_url: API 的基础 URL。
         :param tools: 工具列表，支持函数名称（字符串）或函数对象。
         :param debug: 是否启用调试模式。
         :param log_level: 日志级别（INFO, DEBUG, ERROR）。
@@ -236,9 +246,21 @@ class LightAgent:
             base_url = f"https://api.openai.com/v1"
 
         self.client = OpenAI(
-            base_url=base_url,
-            api_key=self.api_key
+            base_url = base_url,
+            api_key = self.api_key
         )
+        if self.tree_of_thought:
+            if tot_api_key is None:
+                tot_api_key = api_key
+            if tot_base_url is None:
+                tot_base_url = base_url
+            if not tot_model:
+                tot_model = "deepseek-r1"  # 默认思维推理模型为deepseek-r1
+            self.tot_model = tot_model
+            self.tot_client = OpenAI(
+                base_url = tot_base_url,
+                api_key = tot_api_key
+            )
 
     def get_tool(self, tool_name: str) -> Callable:
         """
@@ -272,6 +294,7 @@ class LightAgent:
                 # 注册工具函数
                 if hasattr(tool_func, "tool_info"):
                     tool_info = tool_func.tool_info
+                    _FUNCTION_INFO[tool_name] = tool_info  # 注册工具info信息
                     _FUNCTION_MAPPINGS[tool_name] = tool_func
 
                     # 构建 OpenAI 格式的工具描述
@@ -358,7 +381,7 @@ class LightAgent:
             query: str,
             light_swarm=None,
             stream: bool = False,
-            max_retry: int = 5,
+            max_retry: int = 10,
             user_id: str = "default_user",
             history: list = None,
             metadata: Optional[Dict] = None,
@@ -398,7 +421,6 @@ class LightAgent:
                 return result
 
         # 2. 正常处理任务
-
         now = datetime.now()
         current_date = now.strftime("%Y-%m-%d")
         current_time = now.strftime("%H:%M:%S")
@@ -435,7 +457,7 @@ class LightAgent:
         params["messages"] = [{"role": "system", "content": system_prompt}]
         # 将历史对话添加到消息列表中
         for item in history:
-            params["messages"].append({"role": item["role"], "content": item["input"]})
+            params["messages"].append({"role": item["role"], "content": item["content"]})
         # 最后添加当前用户的查询信息
         params["messages"].append({"role": "user", "content": query})
         response = self.client.chat.completions.create(**params)
@@ -483,10 +505,28 @@ class LightAgent:
                                 combined_response += chunk  # 将每个 chunk 叠加
                         if combined_response == "":
                             combined_response = "".join(tool_response)
+
+                        # 将 combined_response 解析为 JSON 对象（如果它是 JSON 字符串）
+                        try:
+                            combined_response = json.loads(combined_response)  # 解析 JSON
+                        except json.JSONDecodeError:
+                            pass  # 如果不是 JSON 字符串，保持原样
+
+                        # 将 JSON 对象中的 Unicode 编码转换为中文字符
+                        if isinstance(combined_response, dict):
+                            combined_response = json.dumps(combined_response, ensure_ascii=False)  # 确保中文字符不转义
+
                         tool_responses.append(combined_response)  # 将叠加后的完整响应添加到列表
                     else:
                         # print(f"Non-streaming response from tool: {function_call.name}")
                         combined_response = tool_response
+                        # 如果是 JSON 字符串，解析并转换为中文
+                        if isinstance(combined_response, str):
+                            try:
+                                combined_response = json.loads(combined_response)  # 解析 JSON
+                                combined_response = json.dumps(combined_response, ensure_ascii=False)  # 转换为中文
+                            except json.JSONDecodeError:
+                                pass  # 如果不是 JSON 字符串，保持原样
                         tool_responses.append(combined_response)  # 直接添加普通响应
 
                     self.log("INFO", "tool_response", {"tool_response": combined_response})
@@ -520,6 +560,7 @@ class LightAgent:
             # 更新响应
             if function_call_name == 'finish':
                 return  # 如果最后调用了finish工具，则结束生成器
+            # print(params)
             response = self.client.chat.completions.create(**params)
 
         # 重试次数用尽
@@ -583,6 +624,7 @@ class LightAgent:
                         if tool_call["name"]:  # 确保工具调用有名称
                             function_call = {
                                 "name": tool_call["name"],
+                                "title": _FUNCTION_INFO.get(tool_call["name"], {}).get('tool_title') or '',
                                 "arguments": tool_call["arguments"],
                             }
                             self.log("INFO", "tool_call", {"function_call": function_call})
@@ -610,7 +652,16 @@ class LightAgent:
                                         # print(f"Streaming response from tool: {function_call['name']}")
                                         combined_response = ""
                                         for chunk in tool_response:
-                                            yield chunk
+                                            # 将工具返回的数据继续流出
+                                            tool_output = {
+                                                "name": tool_call["name"],
+                                                "title": _FUNCTION_INFO.get(tool_call["name"], {}).get(
+                                                    'tool_title') or '',
+                                                "output": chunk,
+                                            }
+                                            self.log("INFO", "tool_call", {"tool_output": tool_output})
+                                            yield tool_output
+                                            # 将工具的调用信息推送给开发者
                                             if function_call_name == 'finish':
                                                 content = chunk.choices[0].delta.content or ""
                                                 combined_response += content  # 将每个 chunk 叠加
@@ -788,18 +839,21 @@ class LightAgent:
 
     def run_thought(self, query: str, stream=False, tools=None):
         """使用思维树的方式 让大模型先根据get_tools_str生成一个解答用户query的工具使用计划"""
-        tot_model = "deepseek-chat"  # self.model
+        tot_model = self.tot_model  # self.model
         tools = get_tools_str()
         if not isinstance(tools, str):
             tools = str(tools)  # 确保 tools 是字符串
-        system_prompt = f"""你是一个智能助手，请根据用户输入的问题，结合工具使用计划，生成一个思维树，并按照思维树依次调用工具步骤，最终生成一个最终回答。/n 工具列表: {tools}"""
+        now = datetime.now()
+        current_date = now.strftime("%Y-%m-%d")
+        current_time = now.strftime("%H:%M:%S")
+        system_prompt = f"""你是一个智能助手，请根据用户输入的问题，结合工具使用计划，生成一个思维树，并按照思维树依次调用工具步骤，最终生成一个最终回答。/n 今日的日期: {current_date} 当前时间: {current_time} /n 工具列表: {tools}"""
         self.log("DEBUG", "run_thought", {"system_prompt": system_prompt})
 
         # 第一次请求，生成初始的工具使用计划
         params = dict(model=tot_model,
                       messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": query}],
                       stream=False)
-        response = self.client.chat.completions.create(**params)
+        response = self.tot_client.chat.completions.create(**params)
         initial_content = response.choices[0].message.content
         self.log("DEBUG", "initial_response", {"response": initial_content})
 
@@ -812,7 +866,7 @@ class LightAgent:
         ], stream=False)
         self.log("DEBUG", "reflection_params", {"params": reflection_params})
 
-        reflection_response = self.client.chat.completions.create(**reflection_params)
+        reflection_response = self.tot_client.chat.completions.create(**reflection_params)
         refined_content = reflection_response.choices[0].message.content
         self.log("DEBUG", "refined_response", {"response": refined_content})
         return refined_content