LightAgent 0.3.1__tar.gz → 0.3.3__tar.gz

{lightagent-0.3.1 → lightagent-0.3.3}/LightAgent/la_core.py

@@ -3,33 +3,32 @@
 
 """
 作者: [weego/WXAI-Team]
-版本: 0.3.0
-最后更新: 2025-03-31
+版本: 0.3.3
+最后更新: 2025-05-05
 """
 
-import re
-from typing import List, Dict, Any, Callable, Union, Iterable, Optional, Generator, AsyncGenerator
-from copy import deepcopy
+import asyncio
+import importlib
 import importlib.util
-import random
+import inspect
 import json
-from datetime import datetime
-from openai import OpenAI
 import logging
 import os
-import httpx
-import importlib
-from openai.types.chat import ChatCompletionChunk
-import inspect
+import random
+import re
 import traceback
-from mcp import ClientSession, StdioServerParameters, types
 from contextlib import AsyncExitStack
+from copy import deepcopy
+from datetime import datetime
+from functools import partial
+from typing import List, Dict, Any, Callable, Union, Optional, Generator, AsyncGenerator
+from uuid import uuid4
 
+import httpx
+from mcp import ClientSession, StdioServerParameters
 from mcp.client.sse import sse_client
 from mcp.client.stdio import stdio_client
-import asyncio
-from functools import partial
-
+from openai.types.chat import ChatCompletionChunk
 
 # 全局工具注册表
 _FUNCTION_MAPPINGS = {}  # 工具名称 -> 工具函数
@@ -37,7 +36,10 @@ _FUNCTION_INFO = {}  # 工具名称 -> 工具info信息
 _OPENAI_FUNCTION_SCHEMAS = []  # OpenAI 格式的工具描述
 _PROMPT_FUNCTION_SCHEMAS = []  # prompt 格式的工具描述
 
-__version__ = "0.3.0"  # 你可以根据需要设置版本号
+__version__ = "0.3.3"  # 你可以根据需要设置版本号
+
+
+# openai.langfuse_auth_check()
 
 
 def register_tool_manually(tools: List[Union[str, Callable]]) -> bool:
@@ -181,6 +183,44 @@ def get_tools_str() -> str:
     return tools_str
 
 
+def filter_tools_schemas(refined_content: str) -> json:
+    """
+    根据refined_content中的工具列表过滤全局_OPENAI_FUNCTION_SCHEMAS
+    :param refined_content: 包含工具列表的JSON字符串
+    """
+    # global _OPENAI_FUNCTION_SCHEMAS  # 声明操作全局变量
+    """安全解析可能包含 Markdown 代码块的 JSON"""
+    refined_content = refined_content.strip()
+    if refined_content.startswith('```json') and refined_content.endswith('```'):
+        refined_content = refined_content[7:-3].strip()  # 去除 ```json 和 ```
+    try:
+        # 解析工具列表
+        parsed_data: Dict[str, List[Dict]] = json.loads(refined_content)
+        valid_tools = {tool["name"].strip().lower() for tool in parsed_data.get("tools", [])}
+
+        # 原地过滤操作
+        filtered_schemas: List[Dict] = []
+        for schema in _OPENAI_FUNCTION_SCHEMAS:
+            if not isinstance(schema, dict):
+                continue
+
+            # 深度检查结构
+            function_info = schema.get("function", {})
+            if isinstance(function_info, dict):
+                schema_name = function_info.get("name", "").strip().lower()
+                if schema_name in valid_tools:
+                    filtered_schemas.append(schema)
+
+        # 直接替换全局变量内容
+        # _OPENAI_FUNCTION_SCHEMAS[:] = filtered_schemas
+        return filtered_schemas
+
+    except (json.JSONDecodeError, KeyError, AttributeError) as e:
+        # 错误处理：清空工具列表并记录日志
+        # _OPENAI_FUNCTION_SCHEMAS.clear()
+        raise ValueError(f"工具过滤失败: {str(e)}") from e
+
+
 class MCPClientManager:
     """增强版MCP客户端管理器"""
 
@@ -379,7 +419,7 @@ class MCPClientManager:
 
 
 class LightAgent:
-    __version__ = "0.3.0"  # 将版本号放在类中
+    __version__ = "0.3.3"  # 将版本号放在类中
 
     def __init__(
             self,
@@ -391,16 +431,18 @@ class LightAgent:
             api_key: str | None = None,  # 模型 api key
             base_url: str | httpx.URL | None = None,  # 模型 base url
             websocket_base_url: str | httpx.URL | None = None,  # 模型 websocket base url
-            memory=None,  # 支持外部传入记忆模块
+            memory: str | None = None,  # 支持外部传入记忆模块
             tree_of_thought: bool = False,  # 是否启用链式思考
             tot_model: str | None = None,  # 链式思考模型
             tot_api_key: str | None = None,  # 链式思考模型API密钥
             tot_base_url: str | httpx.URL | None = None,  # 链式思考模型base_url
+            filter_tools: bool = True,  # 是否启用工具过滤
             self_learning: bool = False,  # 是否启用agent自我学习
             tools: List[Union[str, Callable]] = None,  # 支持工具混合输入
             debug: bool = False,  # 是否启用调试模式
             log_level: str = "INFO",  # 日志级别（INFO, DEBUG, ERROR）
-            log_file: Optional[str] = None  # 日志文件路径
+            log_file: Optional[str] = None,  # 日志文件路径
+            tracetools: Optional[dict] = None,  # log跟踪工具
     ) -> None:
         """
         初始化 LightAgent。
@@ -417,10 +459,12 @@ class LightAgent:
         :param tot_model: 使用的模型名称。
         :param tot_api_key: API 密钥。
         :param tot_base_url: API 的基础 URL。
+        :param filter_tools: 是否启用工具过滤。
         :param tools: 工具列表，支持函数名称（字符串）或函数对象。
         :param debug: 是否启用调试模式。
         :param log_level: 日志级别（INFO, DEBUG, ERROR）。
         :param log_file: 日志文件路径。
+        :param tracetools: log跟踪工具。
         """
         self.mcp_setting = None
         self.mcp_client = None
@@ -443,9 +487,11 @@ class LightAgent:
         self.memory = memory
         self.tree_of_thought = tree_of_thought
         self.self_learning = self_learning
+        self.filter_tools = filter_tools
 
         self.debug = debug
         self.log_level = log_level.upper()
+        self.traceid = ""  # 用于存储 traceid
         # 确保 log 目录存在
         log_dir = 'logs'
         if not os.path.exists(log_dir):
@@ -463,7 +509,6 @@ class LightAgent:
             self.load_tools(tools)
             # register_tool_manually(tools)
 
-
         if api_key is None:
             raise ValueError(
                 "The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable"
@@ -474,10 +519,6 @@ class LightAgent:
         if base_url is None:
             base_url = f"https://api.openai.com/v1"
 
-        self.client = OpenAI(
-            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
@@ -486,10 +527,36 @@ class LightAgent:
             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
+
+        if tracetools is None:
+            self.tracetools = []
+        if tracetools:
+            self.tracetools = tracetools
+            # 初始化工具列表
+            from langfuse.openai import openai as la_openai
+            la_openai.langfuse_public_key = self.tracetools['TraceToolConfig']['langfuse_public_key']
+            la_openai.langfuse_secret_key = self.tracetools['TraceToolConfig']['langfuse_secret_key']
+            la_openai.langfuse_enabled = self.tracetools['TraceToolConfig'][
+                'langfuse_enabled']  # Default is True, set to False to disable Langfuse
+            la_openai.langfuse_host = self.tracetools['TraceToolConfig']['langfuse_host']  # 🇪🇺 EU region
+            la_openai.base_url = base_url
+            la_openai.api_key = self.api_key
+            self.client = la_openai
+            if self.tree_of_thought:
+                la_openai.base_url = tot_base_url
+                la_openai.api_key = tot_api_key
+                self.tot_client = la_openai
+        else:
+            from openai import OpenAI as la_openai
+            self.client = la_openai(
+                base_url=base_url,
+                api_key=self.api_key
             )
+            if self.tree_of_thought:
+                self.tot_client = la_openai(
+                    base_url=tot_base_url,
+                    api_key=tot_api_key
+                )
 
     def get_tool(self, tool_name: str) -> Callable:
         """
@@ -596,7 +663,10 @@ class LightAgent:
         """
         if not self.debug:
             return
-        log_message = f"{action}: {data}"
+        if self.traceid is not None:
+            log_message = f"[TraceID: {self.traceid}] {action}: {data}"
+        else:
+            log_message = f"{action}: {data}"
         if level == "DEBUG":
             self.logger.debug(log_message)
         elif level == "INFO":
@@ -605,8 +675,8 @@ class LightAgent:
             self.logger.error(log_message)
 
     async def setup_mcp(
-                        self,
-                        mcp_setting: dict | None = None,  # mcp 设置
+            self,
+            mcp_setting: dict | None = None,  # mcp 设置
     ):
         if mcp_setting:
             self.mcp_setting = mcp_setting
@@ -638,6 +708,7 @@ class LightAgent:
         :param metadata: 元数据。
         :return: 代理的回复。
         """
+        self.traceid = uuid4().hex
         self.log("INFO", "run", {"query": query, "user_id": user_id, "light_swarm": light_swarm, "stream": stream})
         if history is None:
             history = []
@@ -654,19 +725,25 @@ class LightAgent:
         #         self._transfer_to_agent(light_swarm.agents[target_agent_name], query, stream=stream)
         #         return  # 立即结束当前生成器
 
-        # 1. 判断是否需要转移任务
+        # 0. 判断是否需要转移任务
         if light_swarm:
             result = self._handle_task_transfer(query, light_swarm, stream)
             if result is not None:
                 return result
 
-        # 2. 正常处理任务
+        # 1. 正常处理任务
         now = datetime.now()
         current_date = now.strftime("%Y-%m-%d")
         current_time = now.strftime("%H:%M:%S")
         system_prompt = f"##代理名称：{self.name} ##代理指令 /n{self.instructions}  ##身份 /n {self.role} /n 请一步一步思考来完成用户的要求。尽可能完成用户的回答，如果有补充信息，请参考补充信息来调用工具，直到获取所有满足用户的提问所需的答案。 /n 今日的日期: {current_date} 当前时间: {current_time}"
         params = dict(model=self.model, stream=stream)
         memory = ''
+
+        # 2.添加langfuse的session
+        if self.tracetools:
+            params["session_id"] = self.traceid
+            self.log("DEBUG", "Query Trace ID", {"query": query})
+
         # 3. 从记忆中检索相关内容&保存记忆
         if self.memory:
             related_memories = self.memory.retrieve(query=query, user_id=user_id)
@@ -680,19 +757,29 @@ class LightAgent:
         query = f"{memory}\n##用户提问：\n{query}"
         # print(query)
 
-        # 4. 拼接tools工具
-        tools = get_tools()
+        # 4. 思维链
+        active_tools = []
+        if self.tree_of_thought:
+            tot_response, active_tools = self.run_thought(query=query)
+            system_prompt = system_prompt + f" /n ##以下是问题的补充说明 /n {tot_response}"
+            self.log("DEBUG", "tree_of_thought", {"response": tot_response, "active_tools": active_tools})
+
+        # 5. 拼接tools工具
+        # 带类型校验 自适应工具机制
+        try:
+            tools = active_tools if (
+                    len(active_tools) > 0
+            ) else get_tools()
+        except TypeError:
+            tools = get_tools()
+        # 带类型校验 自适应工具机制
+        # tools = get_tools() # v0.2.X的工具选取机制
         if tools:
             self.log("DEBUG", "register_tools", {"tools": list(_FUNCTION_MAPPINGS.keys())})
+            self.log("DEBUG", "active_tools", {"tools": tools})
             params["tools"] = tools
             params["tool_choice"] = "auto"
 
-        # 5. 思维链
-        if self.tree_of_thought:
-            tot_response = self.run_thought(query=query)
-            system_prompt = system_prompt + f" /n ##以下是问题的补充说明 /n {tot_response}"
-            self.log("DEBUG", "tree_of_thought", {"response": tot_response})
-
         # 6. 调用核心运行逻辑
         params["messages"] = [{"role": "system", "content": system_prompt}]
         # 将历史对话添加到消息列表中
@@ -700,6 +787,7 @@ class LightAgent:
             params["messages"].append({"role": item["role"], "content": item["content"]})
         # 最后添加当前用户的查询信息
         params["messages"].append({"role": "user", "content": query})
+
         response = self.client.chat.completions.create(**params)
 
         result = self._core_run_logic(response, params, stream, max_retry)
@@ -1075,10 +1163,10 @@ class LightAgent:
         :param related_memories: 从记忆中检索到的相关内容。
         :return: 结合记忆后的上下文。
         """
-        if not related_memories or not related_memories["memories"]:
+        if not related_memories or not related_memories["results"]:
             return ""
 
-        memory_context = "\n".join([m["memory"] for m in related_memories["memories"]])
+        memory_context = "\n".join([m["memory"] for m in related_memories["results"]])
         if not memory_context:
             return ""
 
@@ -1093,10 +1181,10 @@ class LightAgent:
         :param agent_memories: 从记忆中检索到的相关内容。
         :return: 结合记忆后的上下文。
         """
-        if not agent_memories or not agent_memories["memories"]:
+        if not agent_memories or not agent_memories["results"]:
             return ""
 
-        memory_context = "\n".join([m["memory"] for m in agent_memories["memories"]])
+        memory_context = "\n".join([m["memory"] for m in agent_memories["results"]])
         if not memory_context:
             return ""
 
@@ -1104,7 +1192,7 @@ class LightAgent:
         self.log("DEBUG", "agent_memories", {"memory_context": memory_context})
         return prompt
 
-    def run_thought(self, query: str, stream=False, tools=None):
+    def run_thought(self, query: str) -> tuple:
         """使用思维树的方式 让大模型先根据get_tools_str生成一个解答用户query的工具使用计划"""
         tot_model = self.tot_model  # self.model
         tools = get_tools_str()
@@ -1113,30 +1201,66 @@ class LightAgent:
         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}"""
+        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.tot_client.chat.completions.create(**params)
-        initial_content = response.choices[0].message.content
-        self.log("DEBUG", "initial_response", {"response": initial_content})
-
-        # 第二次请求，请求大模型反思并生成新的工具使用规划
-        reflection_prompt = "请反思你的回答，重新给出新的工具使用规划。仅输出新的工具使用规划，不要输出其他分析和回答。"
-        reflection_params = dict(model=tot_model, messages=[
-            {"role": "user", "content": f"{system_prompt} /n 开始思考问题: {query}"},
-            {"role": "assistant", "content": initial_content},
-            {"role": "user", "content": reflection_prompt}
-        ], stream=False)
-        self.log("DEBUG", "reflection_params", {"params": 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
+        try:
+            # 1. 第一次请求，生成初始的工具使用计划
+            params = dict(model=tot_model,
+                          messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": query}],
+                          stream=False)
+            response = self.tot_client.chat.completions.create(**params)
+            initial_content = response.choices[0].message.content
+            self.log("DEBUG", "initial_response", {"response": initial_content})
+
+            # 2. 第二次请求，请求大模型反思并生成新的工具使用规划
+            reflection_prompt = "请反思你的回答，请严格按照<工具列表>中的工具来规划，不可以创造其他新的工具。请输出新的任务规划，不要输出其他分析和回答。"
+            reflection_params = dict(model=tot_model, messages=[
+                {"role": "user", "content": f"{system_prompt} /n 开始思考问题: {query}"},
+                {"role": "assistant", "content": initial_content},
+                {"role": "user", "content": reflection_prompt}
+            ], stream=False)
+            self.log("DEBUG", "reflection_params", {"params": 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})
+
+            # 获取工具的使用集合
+            tool_reflection_prompt = """请严格按以下要求执行：
+            1. 分析问题需求并规划需要使用的工具
+            2. 仅输出包含工具名称的JSON格式结果
+            3. 使用以下结构（示例）：
+            {"tools": [{"name": "工具名称1"}, {"name": "工具名称2"}]}
+            4. 不要包含任何解释性内容"""
+
+            tool_reflection_params = dict(
+                model=tot_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"问题分析请求：{query}"},
+                    {"role": "assistant", "content": refined_content},
+                    {"role": "user", "content": tool_reflection_prompt}
+                ],
+                response_format={"type": "json_object"},  # 强制JSON输出格式
+                stream=False
+            )
+
+            self.log("DEBUG", "tool_reflection_params", {"params": tool_reflection_params})
+            tool_reflection_response = self.tot_client.chat.completions.create(**tool_reflection_params)
+            tool_reflection_result = tool_reflection_response.choices[0].message.content
+            self.log("DEBUG", "tool_reflection_result", {"result": tool_reflection_result})
+
+            # 3.执行自适应工具过滤
+            current_tools = []
+            if self.filter_tools:
+                current_tools = filter_tools_schemas(tool_reflection_result)
+                self.log("DEBUG", "current_tools", {"get_tools": current_tools})
+
+            return refined_content, current_tools
+
+        except Exception as e:
+            self.log("ERROR", "run_thought_failure", {"error": str(e)})
+            raise RuntimeError(f"思维链执行失败: {str(e)}") from e
 
     def _detect_intent(self, query: str, light_swarm=None) -> Optional[Dict]:
         """