LightAgent 0.2.8__tar.gz → 0.2.9__tar.gz

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

@@ -11,6 +11,8 @@ import logging
 import os
 import httpx
 import importlib
+from openai.types.chat import ChatCompletionChunk
+import asyncio
 
 # 全局工具注册表
 _FUNCTION_MAPPINGS = {}  # 工具名称 -> 工具函数
@@ -18,7 +20,7 @@ _FUNCTION_INFO = {}   # 工具名称 -> 工具info信息
 _OPENAI_FUNCTION_SCHEMAS = []  # OpenAI 格式的工具描述
 _PROMPT_FUNCTION_SCHEMAS = []  # prompt 格式的工具描述
 
-__version__ = "0.2.8"  # 你可以根据需要设置版本号
+__version__ = "0.2.9"  # 你可以根据需要设置版本号
 
 
 def register_tool_manually(tools: List[Union[str, Callable]]) -> bool:
@@ -86,36 +88,41 @@ def load_tool(tool_name: str, tools_directory: str = "tools"):
             return tool_func
     raise AttributeError(f"Tool '{tool_name}' is not properly defined in {tool_path}")
 
+from typing import Dict, Any, Union, Generator, AsyncGenerator
+import inspect
+import traceback
 
-def dispatch_tool(tool_name: str, tool_params: Dict[str, Any]) -> Union[str, Generator[str, None, None]]:
+async def dispatch_tool(tool_name: str, tool_params: Dict[str, Any]) -> Union[str, Generator[str, None, None], AsyncGenerator[str, None]]:
     """
-    调用工具执行，支持流式输出。
-
-    :param tool_name: 工具名称
-    :param tool_params: 工具参数
-    :return: 如果工具是流式输出，返回生成器；否则返回字符串结果。
+    调用工具执行，支持同步/异步工具及流式输出。
     """
     if tool_name not in _FUNCTION_MAPPINGS:
         return f"Tool `{tool_name}` not found."
 
     tool_call = _FUNCTION_MAPPINGS[tool_name]
     try:
-        # print(f"Calling tool: {tool_name} with params: {tool_params}")  # 调试信息
-        result = tool_call(**tool_params)
+        # 区分同步/异步工具
+        if inspect.iscoroutinefunction(tool_call):
+            result = await tool_call(**tool_params)
+        else:
+            result = tool_call(**tool_params)
 
-        # 如果工具返回的是可迭代对象（如生成器），则逐块处理并返回生成器
-        if isinstance(result, Iterable) and not isinstance(result, (str, bytes)):
+        # 处理不同类型的流式输出
+        if inspect.isasyncgen(result):
+            return async_stream_generator(result)
+        elif inspect.isgenerator(result):
             return stream_generator(result)
-        # 否则，返回字符串结果
         else:
             return str(result)
     except Exception as e:
-        # print(f"Tool call failed: {e}")  # 调试信息
         return traceback.format_exc()
 
+async def async_stream_generator(async_gen: AsyncGenerator) -> AsyncGenerator[str, None]:
+    async for chunk in async_gen:
+        yield chunk
 
-def stream_generator(result):
-    for chunk in result:
+def stream_generator(sync_gen: Generator) -> Generator[str, None, None]:
+    for chunk in sync_gen:
         yield chunk
 
 
@@ -154,7 +161,7 @@ def get_tools_str() -> str:
 
 
 class LightAgent:
-    __version__ = "0.2.1"  # 将版本号放在类中
+    __version__ = "0.2.9"  # 将版本号放在类中
 
     def __init__(
             self,
@@ -478,20 +485,25 @@ class LightAgent:
                 output = ""
                 function_call_name = ""
                 tool_calls = response.choices[0].message.tool_calls
-                self.log("DEBUG", "tool_calls", {"tool_calls": tool_calls})
+                self.log("DEBUG", "non_stream tool_calls", {"tool_calls": tool_calls})
 
                 # 遍历所有工具调用
                 for tool_call in tool_calls:
                     function_call = tool_call.function
-                    self.log("DEBUG", "function_call", {"function_call": function_call.model_dump()})
 
+                    # 尝试自动修复常见转义问题
+                    fixed_args = function_call.arguments.replace('\\"', '"').replace('\\\\', '\\')
+                    self.log("DEBUG", "non_stream function_call", {"function_call": fixed_args})
+
+                    function_args = json.loads(fixed_args)
                     # 解析函数参数
-                    function_args = json.loads(function_call.arguments)
+                    # function_args = json.loads(function_call.arguments)
 
                     # 调用工具并获取响应
-                    tool_response = dispatch_tool(function_call.name, function_args)
+                    tool_response = asyncio.run(dispatch_tool(function_call.name, function_args))
                     function_call_name = function_call.name
                     combined_response = ""
+                    single_tool_response = ""
 
                     # 如果工具返回的是生成器（流式输出），则将所有 chunk 叠加
                     if isinstance(tool_response, Generator):
@@ -515,34 +527,38 @@ class LightAgent:
                         # 将 JSON 对象中的 Unicode 编码转换为中文字符
                         if isinstance(combined_response, dict):
                             combined_response = json.dumps(combined_response, ensure_ascii=False)  # 确保中文字符不转义
+                        single_tool_response = combined_response  # 处理单个工具的方法
 
-                        tool_responses.append(combined_response)  # 将叠加后的完整响应添加到列表
                     else:
                         # print(f"Non-streaming response from tool: {function_call.name}")
                         combined_response = tool_response
+                        # print("tool_response type:",type(combined_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:
+                                combined_response = tool_response
                                 pass  # 如果不是 JSON 字符串，保持原样
-                        tool_responses.append(combined_response)  # 直接添加普通响应
+                        single_tool_response = combined_response  # 处理单个工具的方法
 
-                    self.log("INFO", "tool_response", {"tool_response": combined_response})
 
-                    # 将工具调用的结果添加到列表中
-                    tool_responses.append(combined_response)
+                    self.log("DEBUG", "non_stream single_tool_response", {"single_tool_response": single_tool_response})
+
+                    # 将单个工具的响应结果添加到列表中
+                    tool_responses.append(single_tool_response)
 
                 # 将所有工具调用的结果合并为一个字符串
+                self.log("DEBUG", "non_stream tool_responses", {"tool_responses": tool_responses})
+
                 combined_tool_response = "\n".join(tool_responses)
 
                 # 将工具调用和响应添加到消息列表中
                 params["messages"].append(
                     {
                         "role": "assistant",
-                        "content": json.dumps(
-                            [tool_call.function.model_dump() for tool_call in tool_calls]),
+                        "content": f"使用工具： \n {json.dumps([tool_call.function.model_dump() for tool_call in tool_calls],ensure_ascii=False)}\n",
                     }
                 )
                 params["messages"].append(
@@ -560,8 +576,13 @@ class LightAgent:
             # 更新响应
             if function_call_name == 'finish':
                 return  # 如果最后调用了finish工具，则结束生成器
-            # print(params)
-            response = self.client.chat.completions.create(**params)
+            # print("params:",params)
+            self.log("DEBUG", "chat-completions params", {"params": params})
+
+            try:
+                response = self.client.chat.completions.create(**params)
+            except Exception as e:
+                print(f"An error occurred: {e}")
 
         # 重试次数用尽
         self.log("ERROR", "max_retry_reached", {"message": "Failed to generate a valid response."})
@@ -644,33 +665,42 @@ class LightAgent:
 
                                 for json_obj in json_objects:
                                     function_args = json.loads(json_obj)
-                                    tool_response = dispatch_tool(function_call["name"], function_args)
+                                    # tool_response = dispatch_tool(function_call["name"], function_args)
+                                    tool_response = asyncio.run(dispatch_tool(function_call["name"], function_args))
                                     function_call_name = function_call["name"]
+                                    combined_response = ""
+                                    single_tool_response = ""
 
                                     # 如果工具返回的是生成器（流式输出），则将所有 chunk 叠加
                                     if isinstance(tool_response, Generator):
                                         # print(f"Streaming response from tool: {function_call['name']}")
-                                        combined_response = ""
                                         for chunk in tool_response:
                                             # 将工具返回的数据继续流出
-                                            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 isinstance(chunk, ChatCompletionChunk):
+                                                yield chunk
+                                            else:
+                                                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 叠加
                                             else:
                                                 combined_response += chunk  # 将每个 chunk 叠加
-                                        tool_responses.append(combined_response)  # 将叠加后的完整响应添加到列表
+                                        single_tool_response = combined_response  # 处理单个工具的方法
                                     else:
-                                        # print(f"Non-streaming response from tool: {function_call['name']}")
-                                        tool_responses.append(tool_response)  # 直接添加普通响应
+                                        # print(f"Non-streaming response from tool: {tool_response}")
+                                        combined_response = tool_response
+                                        single_tool_response = combined_response  # 处理单个工具的方法
+                                    self.log("INFO", "stream single_tool_response", {"single_tool_response": single_tool_response})
+                                    # 将单个工具的响应结果添加到列表中
+                                    tool_responses.append(single_tool_response)
 
                             except json.JSONDecodeError as e:
                                 self.log("ERROR", "json_decode_error",
@@ -702,6 +732,7 @@ class LightAgent:
             # 更新响应
             if function_call_name == 'finish':
                 return  # 如果最后调用了finish工具，则结束生成器
+            self.log("DEBUG", "chat-completions params", {"params": params})
             response = self.client.chat.completions.create(**params)
 
         # 重试次数用尽
@@ -1005,6 +1036,7 @@ class LightAgent:
 # 在函数内部定义工具信息
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_title": "天气查询",
     "tool_description": "获取指定城市的当前天气信息",
     "tool_params": [
         {"name": "city_name", "description": "要查询的城市名称", "type": "string", "required": True},
@@ -1087,4 +1119,4 @@ class LightSwarm:
 if __name__ == "__main__":
     # Example of registering and using a tool
     print("This is LightAgent")
-    # print(dispatch_tool("example_tool", {"param1": "test"}))
+    # print(dispatch_tool("example_tool", {"param1": "test"}))

{lightagent-0.2.8 → lightagent-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightAgent
-Version: 0.2.8
+Version: 0.2.9
 Summary: **LightAgent** is an extremely lightweight active Agentic Framework with memory (`mem0`), tools (`Tools`), and a Tree of Thought (`ToT`). It supports swarm-like multi-agent collaboration, automated tool generation, and agent assessment, with underlying model support for OpenAI, Zhipu ChatGLM, Baichuan Large Model, DeepSeek R1, Qwen series large models, and more. At the same time, LightAgent supports OpenAI streaming format API service output, seamlessly integrating with major mainstream chat frameworks. 🌟
 Home-page: https://github.com/wxai-space/LightAgent
 License: Apache 2.0
@@ -58,6 +58,8 @@ Description-Content-Type: text/markdown
 
 ---
 
+![lightswarm_demo_en.png](docs%2Fimages%2Flightswarm_demo_en.png)
+
 ## ✨ Features
 
 - **Lightweight and Efficient** 🚀: Minimalist design, quick deployment, suitable for various application scenarios. (No LangChain, No LlamaIndex) 100% Python implementation, no additional dependencies, core code is only 1000 lines, fully open source. 
@@ -356,6 +358,7 @@ def get_weather(
 # Define tool information inside the function
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_title": "get weather",
     "tool_description": "Get current weather information for the specified city.",
     "tool_params": [
         {"name": "city_name", "description": "The name of the city to query", "type": "string", "required": True},
@@ -378,6 +381,7 @@ def search_news(
 # Define tool information inside the function
 search_news.tool_info = {
     "tool_name": "search_news",
+    "tool_title": "search news",
     "tool_description": "Search news based on keywords.",
     "tool_params": [
         {"name": "keyword", "description": "Search keyword", "type": "string", "required": True},
@@ -774,7 +778,7 @@ We look forward to your feedback and work together to make LightAgent even stron
 **LightAgent** 是一个极其轻量的带记忆（`mem0`）、工具（`Tools`）、思维树（`ToT`）的主动式 Agentic Framework（自主性框架）。它支持比Openai Swarm更简单的多智能体协同，构建具备自我学习能力的agent，并支持Agent测评，底层模型支持 OpenAI、智谱 ChatGLM、DeepSeek、阶跃星辰、Qwen通义千问大模型等。同时，LightAgent 支持 OpenAI 流格式 API 服务输出，无缝接入各大主流 Chat 框架。🌟
 
 ---
-
+![lightswarm_demo_cn.png](docs%2Fimages%2Flightswarm_demo_cn.png)
 ## ✨ 特性
 
 - **轻量高效** 🚀：极简设计，快速部署，适合各种规模的应用场景。（No LangChain, No LlamaIndex）100% Python 实现，无需额外依赖，核心代码仅1000行，完全开源。 
@@ -1077,6 +1081,7 @@ def get_weather(
 # 在函数内部定义工具信息
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_name": "获取天气",
     "tool_description": "获取指定城市的当前天气信息",
     "tool_params": [
         {"name": "city_name", "description": "要查询的城市名称", "type": "string", "required": True},
@@ -1099,6 +1104,7 @@ def search_news(
 # 在函数内部定义工具信息
 search_news.tool_info = {
     "tool_name": "search_news",
+    "tool_name": "联网搜索",
     "tool_description": "根据关键词搜索新闻",
     "tool_params": [
         {"name": "keyword", "description": "搜索关键词", "type": "string", "required": True},

{lightagent-0.2.8 → lightagent-0.2.9}/README.md

@@ -37,6 +37,8 @@
 
 ---
 
+![lightswarm_demo_en.png](docs%2Fimages%2Flightswarm_demo_en.png)
+
 ## ✨ Features
 
 - **Lightweight and Efficient** 🚀: Minimalist design, quick deployment, suitable for various application scenarios. (No LangChain, No LlamaIndex) 100% Python implementation, no additional dependencies, core code is only 1000 lines, fully open source. 
@@ -335,6 +337,7 @@ def get_weather(
 # Define tool information inside the function
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_title": "get weather",
     "tool_description": "Get current weather information for the specified city.",
     "tool_params": [
         {"name": "city_name", "description": "The name of the city to query", "type": "string", "required": True},
@@ -357,6 +360,7 @@ def search_news(
 # Define tool information inside the function
 search_news.tool_info = {
     "tool_name": "search_news",
+    "tool_title": "search news",
     "tool_description": "Search news based on keywords.",
     "tool_params": [
         {"name": "keyword", "description": "Search keyword", "type": "string", "required": True},

{lightagent-0.2.8 → lightagent-0.2.9}/README.zh-CN.md

@@ -36,7 +36,7 @@
 **LightAgent** 是一个极其轻量的带记忆（`mem0`）、工具（`Tools`）、思维树（`ToT`）的主动式 Agentic Framework（自主性框架）。它支持比Openai Swarm更简单的多智能体协同，构建具备自我学习能力的agent，并支持Agent测评，底层模型支持 OpenAI、智谱 ChatGLM、DeepSeek、阶跃星辰、Qwen通义千问大模型等。同时，LightAgent 支持 OpenAI 流格式 API 服务输出，无缝接入各大主流 Chat 框架。🌟
 
 ---
-
+![lightswarm_demo_cn.png](docs%2Fimages%2Flightswarm_demo_cn.png)
 ## ✨ 特性
 
 - **轻量高效** 🚀：极简设计，快速部署，适合各种规模的应用场景。（No LangChain, No LlamaIndex）100% Python 实现，无需额外依赖，核心代码仅1000行，完全开源。 
@@ -339,6 +339,7 @@ def get_weather(
 # 在函数内部定义工具信息
 get_weather.tool_info = {
     "tool_name": "get_weather",
+    "tool_name": "获取天气",
     "tool_description": "获取指定城市的当前天气信息",
     "tool_params": [
         {"name": "city_name", "description": "要查询的城市名称", "type": "string", "required": True},
@@ -361,6 +362,7 @@ def search_news(
 # 在函数内部定义工具信息
 search_news.tool_info = {
     "tool_name": "search_news",
+    "tool_name": "联网搜索",
     "tool_description": "根据关键词搜索新闻",
     "tool_params": [
         {"name": "keyword", "description": "搜索关键词", "type": "string", "required": True},

{lightagent-0.2.8 → lightagent-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "LightAgent"
-version = "0.2.8"
+version = "0.2.9"
 description = "**LightAgent** is an extremely lightweight active Agentic Framework with memory (`mem0`), tools (`Tools`), and a Tree of Thought (`ToT`). It supports swarm-like multi-agent collaboration, automated tool generation, and agent assessment, with underlying model support for OpenAI, Zhipu ChatGLM, Baichuan Large Model, DeepSeek R1, Qwen series large models, and more. At the same time, LightAgent supports OpenAI streaming format API service output, seamlessly integrating with major mainstream chat frameworks. 🌟"
 authors = ["caiweige <caiweige@qq.com>"]
 license = "Apache 2.0"