AstrBot 4.5.0__py3-none-any.whl → 4.5.2__py3-none-any.whl

astrbot/core/agent/runners/tool_loop_agent_runner.py

@@ -1,31 +1,33 @@
 import sys
 import traceback
 import typing as T
-from .base import BaseAgentRunner, AgentResponse, AgentState
-from ..hooks import BaseAgentRunHooks
-from ..tool_executor import BaseFunctionToolExecutor
-from ..run_context import ContextWrapper, TContext
-from ..response import AgentResponseData
-from astrbot.core.provider.provider import Provider
+
+from mcp.types import (
+    BlobResourceContents,
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+    TextResourceContents,
+)
+
+from astrbot import logger
 from astrbot.core.message.message_event_result import (
     MessageChain,
 )
 from astrbot.core.provider.entities import (
-    ProviderRequest,
     LLMResponse,
-    ToolCallMessageSegment,
-    AssistantMessageSegment,
+    ProviderRequest,
     ToolCallsResult,
 )
-from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
-    TextResourceContents,
-    BlobResourceContents,
-    CallToolResult,
-)
-from astrbot import logger
+from astrbot.core.provider.provider import Provider
+
+from ..hooks import BaseAgentRunHooks
+from ..message import AssistantMessageSegment, ToolCallMessageSegment
+from ..response import AgentResponseData
+from ..run_context import ContextWrapper, TContext
+from ..tool_executor import BaseFunctionToolExecutor
+from .base import AgentResponse, AgentState, BaseAgentRunner
 
 if sys.version_info >= (3, 12):
     from typing import override
@@ -70,8 +72,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
 
     @override
     async def step(self):
-        """
-        Process a single step of the agent.
+        """Process a single step of the agent.
         This method should return the result of the step.
         """
         if not self.req:
@@ -99,7 +100,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                     yield AgentResponse(
                         type="streaming_delta",
                         data=AgentResponseData(
-                            chain=MessageChain().message(llm_response.completion_text)
+                            chain=MessageChain().message(llm_response.completion_text),
                         ),
                     )
                 continue
@@ -120,8 +121,8 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                 type="err",
                 data=AgentResponseData(
                     chain=MessageChain().message(
-                        f"LLM 响应错误: {llm_resp.completion_text or '未知错误'}"
-                    )
+                        f"LLM 响应错误: {llm_resp.completion_text or '未知错误'}",
+                    ),
                 ),
             )
 
@@ -144,7 +145,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             yield AgentResponse(
                 type="llm_result",
                 data=AgentResponseData(
-                    chain=MessageChain().message(llm_resp.completion_text)
+                    chain=MessageChain().message(llm_resp.completion_text),
                 ),
             )
 
@@ -155,7 +156,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                 yield AgentResponse(
                     type="tool_call",
                     data=AgentResponseData(
-                        chain=MessageChain().message(f"🔨 调用工具: {tool_call_name}")
+                        chain=MessageChain().message(f"🔨 调用工具: {tool_call_name}"),
                     ),
                 )
             async for result in self._handle_function_tools(self.req, llm_resp):
@@ -169,8 +170,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
             # 将结果添加到上下文中
             tool_calls_result = ToolCallsResult(
                 tool_calls_info=AssistantMessageSegment(
-                    role="assistant",
-                    tool_calls=llm_resp.to_openai_tool_calls(),
+                    tool_calls=llm_resp.to_openai_to_calls_model(),
                     content=llm_resp.completion_text,
                 ),
                 tool_calls_result=tool_call_result_blocks,
@@ -205,7 +205,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                             role="tool",
                             tool_call_id=func_tool_id,
                             content=f"error: 未找到工具 {func_tool_name}",
-                        )
+                        ),
                     )
                     continue
 
@@ -214,7 +214,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                 # 获取实际的 handler 函数
                 if func_tool.handler:
                     logger.debug(
-                        f"工具 {func_tool_name} 期望的参数: {func_tool.parameters}"
+                        f"工具 {func_tool_name} 期望的参数: {func_tool.parameters}",
                     )
                     if func_tool.parameters and func_tool.parameters.get("properties"):
                         expected_params = set(func_tool.parameters["properties"].keys())
@@ -227,20 +227,21 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
 
                     # 记录被忽略的参数
                     ignored_params = set(func_tool_args.keys()) - set(
-                        valid_params.keys()
+                        valid_params.keys(),
                     )
                     if ignored_params:
                         logger.warning(
-                            f"工具 {func_tool_name} 忽略非期望参数: {ignored_params}"
+                            f"工具 {func_tool_name} 忽略非期望参数: {ignored_params}",
                         )
                 else:
                     # 如果没有 handler（如 MCP 工具），使用所有参数
                     valid_params = func_tool_args
-                    logger.warning(f"工具 {func_tool_name} 没有 handler，使用所有参数")
 
                 try:
                     await self.agent_hooks.on_tool_start(
-                        self.run_context, func_tool, valid_params
+                        self.run_context,
+                        func_tool,
+                        valid_params,
                     )
                 except Exception as e:
                     logger.error(f"Error in on_tool_start hook: {e}", exc_info=True)
@@ -262,7 +263,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                     role="tool",
                                     tool_call_id=func_tool_id,
                                     content=res.content[0].text,
-                                )
+                                ),
                             )
                             yield MessageChain().message(res.content[0].text)
                         elif isinstance(res.content[0], ImageContent):
@@ -271,10 +272,10 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                     role="tool",
                                     tool_call_id=func_tool_id,
                                     content="返回了图片(已直接发送给用户)",
-                                )
+                                ),
                             )
                             yield MessageChain(type="tool_direct_result").base64_image(
-                                res.content[0].data
+                                res.content[0].data,
                             )
                         elif isinstance(res.content[0], EmbeddedResource):
                             resource = res.content[0].resource
@@ -284,7 +285,7 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                         role="tool",
                                         tool_call_id=func_tool_id,
                                         content=resource.text,
-                                    )
+                                    ),
                                 )
                                 yield MessageChain().message(resource.text)
                             elif (
@@ -297,10 +298,10 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                         role="tool",
                                         tool_call_id=func_tool_id,
                                         content="返回了图片(已直接发送给用户)",
-                                    )
+                                    ),
                                 )
                                 yield MessageChain(
-                                    type="tool_direct_result"
+                                    type="tool_direct_result",
                                 ).base64_image(resource.blob)
                             else:
                                 tool_call_result_blocks.append(
@@ -308,41 +309,41 @@ class ToolLoopAgentRunner(BaseAgentRunner[TContext]):
                                         role="tool",
                                         tool_call_id=func_tool_id,
                                         content="返回的数据类型不受支持",
-                                    )
+                                    ),
                                 )
                                 yield MessageChain().message("返回的数据类型不受支持。")
 
                     elif resp is None:
                         # Tool 直接请求发送消息给用户
                         # 这里我们将直接结束 Agent Loop。
+                        # 发送消息逻辑在 ToolExecutor 中处理了。
+                        logger.warning(
+                            f"{func_tool_name} 没有没有返回值或者将结果直接发送给用户，此工具调用不会被记录到历史中。"
+                        )
                         self._transition_state(AgentState.DONE)
-                        if res := self.run_context.event.get_result():
-                            if res.chain:
-                                yield MessageChain(
-                                    chain=res.chain, type="tool_direct_result"
-                                )
                     else:
                         # 不应该出现其他类型
                         logger.warning(
-                            f"Tool 返回了不支持的类型: {type(resp)}，将忽略。"
+                            f"Tool 返回了不支持的类型: {type(resp)}，将忽略。",
                         )
 
                 try:
                     await self.agent_hooks.on_tool_end(
-                        self.run_context, func_tool, func_tool_args, _final_resp
+                        self.run_context,
+                        func_tool,
+                        func_tool_args,
+                        _final_resp,
                     )
                 except Exception as e:
                     logger.error(f"Error in on_tool_end hook: {e}", exc_info=True)
-
-                self.run_context.event.clear_result()
             except Exception as e:
                 logger.warning(traceback.format_exc())
                 tool_call_result_blocks.append(
                     ToolCallMessageSegment(
                         role="tool",
                         tool_call_id=func_tool_id,
-                        content=f"error: {str(e)}",
-                    )
+                        content=f"error: {e!s}",
+                    ),
                 )
 
         # 处理函数调用响应

astrbot/core/agent/tool.py

@@ -1,55 +1,75 @@
-from dataclasses import dataclass
+from collections.abc import Awaitable, Callable
+from typing import Any, Generic
+
+import jsonschema
+import mcp
 from deprecated import deprecated
-from typing import Awaitable, Callable, Literal, Any, Optional
-from .mcp_client import MCPClient
+from pydantic import model_validator
+from pydantic.dataclasses import dataclass
+
+from .run_context import ContextWrapper, TContext
+
+ParametersType = dict[str, Any]
 
 
 @dataclass
-class FunctionTool:
-    """A class representing a function tool that can be used in function calling."""
+class ToolSchema:
+    """A class representing the schema of a tool for function calling."""
 
     name: str
-    parameters: dict | None = None
-    description: str | None = None
+    """The name of the tool."""
+
+    description: str
+    """The description of the tool."""
+
+    parameters: ParametersType
+    """The parameters of the tool, in JSON Schema format."""
+
+    @model_validator(mode="after")
+    def validate_parameters(self) -> "ToolSchema":
+        jsonschema.validate(
+            self.parameters, jsonschema.Draft202012Validator.META_SCHEMA
+        )
+        return self
+
+
+@dataclass
+class FunctionTool(ToolSchema, Generic[TContext]):
+    """A callable tool, for function calling."""
+
     handler: Callable[..., Awaitable[Any]] | None = None
-    """处理函数, 当 origin 为 mcp 时，这个为空"""
-    handler_module_path: str | None = None
-    """处理函数的模块路径，当 origin 为 mcp 时，这个为空
+    """a callable that implements the tool's functionality. It should be an async function."""
 
-    必须要保留这个字段, handler 在初始化会被 functools.partial 包装，导致 handler 的 __module__ 为 functools
+    handler_module_path: str | None = None
+    """
+    The module path of the handler function. This is empty when the origin is mcp.
+    This field must be retained, as the handler will be wrapped in functools.partial during initialization,
+    causing the handler's __module__ to be functools
     """
     active: bool = True
-    """是否激活"""
-
-    origin: Literal["local", "mcp"] = "local"
-    """函数工具的来源, local 为本地函数工具, mcp 为 MCP 服务"""
-
-    # MCP 相关字段
-    mcp_server_name: str | None = None
-    """MCP 服务名称，当 origin 为 mcp 时有效"""
-    mcp_client: MCPClient | None = None
-    """MCP 客户端，当 origin 为 mcp 时有效"""
+    """
+    Whether the tool is active. This field is a special field for AstrBot.
+    You can ignore it when integrating with other frameworks.
+    """
 
     def __repr__(self):
-        return f"FuncTool(name={self.name}, parameters={self.parameters}, description={self.description}, active={self.active}, origin={self.origin})"
-
-    def __dict__(self) -> dict[str, Any]:
-        """将 FunctionTool 转换为字典格式"""
-        return {
-            "name": self.name,
-            "parameters": self.parameters,
-            "description": self.description,
-            "active": self.active,
-            "origin": self.origin,
-            "mcp_server_name": self.mcp_server_name,
-        }
+        return f"FuncTool(name={self.name}, parameters={self.parameters}, description={self.description})"
+
+    async def call(
+        self, context: ContextWrapper[TContext], **kwargs
+    ) -> str | mcp.types.CallToolResult:
+        """Run the tool with the given arguments. The handler field has priority."""
+        raise NotImplementedError(
+            "FunctionTool.call() must be implemented by subclasses or set a handler."
+        )
 
 
 class ToolSet:
     """A set of function tools that can be used in function calling.
 
     This class provides methods to add, remove, and retrieve tools, as well as
-    convert the tools to different API formats (OpenAI, Anthropic, Google GenAI)."""
+    convert the tools to different API formats (OpenAI, Anthropic, Google GenAI).
+    """
 
     def __init__(self, tools: list[FunctionTool] | None = None):
         self.tools: list[FunctionTool] = tools or []
@@ -71,7 +91,7 @@ class ToolSet:
         """Remove a tool by its name."""
         self.tools = [tool for tool in self.tools if tool.name != name]
 
-    def get_tool(self, name: str) -> Optional[FunctionTool]:
+    def get_tool(self, name: str) -> FunctionTool | None:
         """Get a tool by its name."""
         for tool in self.tools:
             if tool.name == name:
@@ -132,10 +152,8 @@ class ToolSet:
             }
 
             if (
-                tool.parameters
-                and tool.parameters.get("properties")
-                or not omit_empty_parameter_field
-            ):
+                tool.parameters and tool.parameters.get("properties")
+            ) or not omit_empty_parameter_field:
                 func_def["function"]["parameters"] = tool.parameters
 
             result.append(func_def)
@@ -185,7 +203,8 @@ class ToolSet:
             if "type" in schema and schema["type"] in supported_types:
                 result["type"] = schema["type"]
                 if "format" in schema and schema["format"] in supported_formats.get(
-                    result["type"], set()
+                    result["type"],
+                    set(),
                 ):
                     result["format"] = schema["format"]
             else:
@@ -222,7 +241,7 @@ class ToolSet:
 
         tools = []
         for tool in self.tools:
-            d = {
+            d: dict[str, Any] = {
                 "name": tool.name,
                 "description": tool.description,
             }

astrbot/core/agent/tool_executor.py

@@ -1,11 +1,17 @@
+from collections.abc import AsyncGenerator
+from typing import Any, Generic
+
 import mcp
-from typing import Any, Generic, AsyncGenerator
-from .run_context import TContext, ContextWrapper
+
+from .run_context import ContextWrapper, TContext
 from .tool import FunctionTool
 
 
 class BaseFunctionToolExecutor(Generic[TContext]):
     @classmethod
     async def execute(
-        cls, tool: FunctionTool, run_context: ContextWrapper[TContext], **tool_args
+        cls,
+        tool: FunctionTool,
+        run_context: ContextWrapper[TContext],
+        **tool_args,
     ) -> AsyncGenerator[Any | mcp.types.CallToolResult, None]: ...

astrbot/core/astr_agent_context.py

@@ -1,4 +1,6 @@
 from dataclasses import dataclass
+
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.provider import Provider
 from astrbot.core.provider.entities import ProviderRequest
 
@@ -9,4 +11,4 @@ class AstrAgentContext:
     first_provider_request: ProviderRequest
     curr_provider_request: ProviderRequest
     streaming: bool
-    tool_call_timeout: int = 60  # Default tool call timeout in seconds
+    event: AstrMessageEvent

astrbot/core/astrbot_config_mgr.py

@@ -1,13 +1,14 @@
 import os
 import uuid
+from typing import TypedDict, TypeVar
+
 from astrbot.core import AstrBotConfig, logger
-from astrbot.core.utils.shared_preferences import SharedPreferences
 from astrbot.core.config.astrbot_config import ASTRBOT_CONFIG_PATH
 from astrbot.core.config.default import DEFAULT_CONFIG
 from astrbot.core.platform.message_session import MessageSession
 from astrbot.core.umop_config_router import UmopConfigRouter
 from astrbot.core.utils.astrbot_path import get_astrbot_config_path
-from typing import TypeVar, TypedDict
+from astrbot.core.utils.shared_preferences import SharedPreferences
 
 _VT = TypeVar("_VT")
 
@@ -48,7 +49,10 @@ class AstrBotConfigManager:
         """获取所有的 abconf 数据"""
         if self.abconf_data is None:
             self.abconf_data = self.sp.get(
-                "abconf_mapping", {}, scope="global", scope_id="global"
+                "abconf_mapping",
+                {},
+                scope="global",
+                scope_id="global",
             )
         return self.abconf_data
 
@@ -64,7 +68,7 @@ class AstrBotConfigManager:
                 self.confs[uuid_] = conf
             else:
                 logger.warning(
-                    f"Config file {conf_path} for UUID {uuid_} does not exist, skipping."
+                    f"Config file {conf_path} for UUID {uuid_} does not exist, skipping.",
                 )
                 continue
 
@@ -73,6 +77,7 @@ class AstrBotConfigManager:
 
         Returns:
             ConfInfo: 包含配置文件的 uuid, 路径和名称等信息, 是一个 dict 类型
+
         """
         # uuid -> { "path": str, "name": str }
         abconf_data = self._get_abconf_data()
@@ -103,7 +108,10 @@ class AstrBotConfigManager:
     ) -> None:
         """保存配置文件的映射关系"""
         abconf_data = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
+            "abconf_mapping",
+            {},
+            scope="global",
+            scope_id="global",
         )
         random_word = abconf_name or uuid.uuid4().hex[:8]
         abconf_data[abconf_id] = {
@@ -177,13 +185,17 @@ class AstrBotConfigManager:
 
         Raises:
             ValueError: 如果试图删除默认配置文件
+
         """
         if conf_id == "default":
             raise ValueError("不能删除默认配置文件")
 
         # 从映射中移除
         abconf_data = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
+            "abconf_mapping",
+            {},
+            scope="global",
+            scope_id="global",
         )
         if conf_id not in abconf_data:
             logger.warning(f"配置文件 {conf_id} 不存在于映射中")
@@ -191,7 +203,8 @@ class AstrBotConfigManager:
 
         # 获取配置文件路径
         conf_path = os.path.join(
-            get_astrbot_config_path(), abconf_data[conf_id]["path"]
+            get_astrbot_config_path(),
+            abconf_data[conf_id]["path"],
         )
 
         # 删除配置文件
@@ -224,12 +237,16 @@ class AstrBotConfigManager:
 
         Returns:
             bool: 更新是否成功
+
         """
         if conf_id == "default":
             raise ValueError("不能更新默认配置文件的信息")
 
         abconf_data = self.sp.get(
-            "abconf_mapping", {}, scope="global", scope_id="global"
+            "abconf_mapping",
+            {},
+            scope="global",
+            scope_id="global",
         )
         if conf_id not in abconf_data:
             logger.warning(f"配置文件 {conf_id} 不存在于映射中")
@@ -246,7 +263,10 @@ class AstrBotConfigManager:
         return True
 
     def g(
-        self, umo: str | None = None, key: str | None = None, default: _VT = None
+        self,
+        umo: str | None = None,
+        key: str | None = None,
+        default: _VT = None,
     ) -> _VT:
         """获取配置项。umo 为 None 时使用默认配置"""
         if umo is None:

astrbot/core/config/__init__.py

@@ -1,9 +1,9 @@
-from .default import DEFAULT_CONFIG, VERSION, DB_PATH
 from .astrbot_config import *
+from .default import DB_PATH, DEFAULT_CONFIG, VERSION
 
 __all__ = [
+    "DB_PATH",
     "DEFAULT_CONFIG",
     "VERSION",
-    "DB_PATH",
     "AstrBotConfig",
 ]

astrbot/core/config/astrbot_config.py

@@ -1,11 +1,12 @@
-import os
+import enum
 import json
 import logging
-import enum
-from .default import DEFAULT_CONFIG, DEFAULT_VALUE_MAP
-from typing import Dict
+import os
+
 from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
+from .default import DEFAULT_CONFIG, DEFAULT_VALUE_MAP
+
 ASTRBOT_CONFIG_PATH = os.path.join(get_astrbot_data_path(), "cmd_config.json")
 logger = logging.getLogger("astrbot")
 
@@ -27,7 +28,7 @@ class AstrBotConfig(dict):
         self,
         config_path: str = ASTRBOT_CONFIG_PATH,
         default_config: dict = DEFAULT_CONFIG,
-        schema: dict = None,
+        schema: dict | None = None,
     ):
         super().__init__()
 
@@ -45,7 +46,7 @@ class AstrBotConfig(dict):
                 json.dump(default_config, f, indent=4, ensure_ascii=False)
                 object.__setattr__(self, "first_deploy", True)  # 标记第一次部署
 
-        with open(config_path, "r", encoding="utf-8-sig") as f:
+        with open(config_path, encoding="utf-8-sig") as f:
             conf_str = f.read()
             conf = json.loads(conf_str)
 
@@ -65,7 +66,7 @@ class AstrBotConfig(dict):
             for k, v in schema.items():
                 if v["type"] not in DEFAULT_VALUE_MAP:
                     raise TypeError(
-                        f"不受支持的配置类型 {v['type']}。支持的类型有：{DEFAULT_VALUE_MAP.keys()}"
+                        f"不受支持的配置类型 {v['type']}。支持的类型有：{DEFAULT_VALUE_MAP.keys()}",
                     )
                 if "default" in v:
                     default = v["default"]
@@ -82,7 +83,7 @@ class AstrBotConfig(dict):
 
         return conf
 
-    def check_config_integrity(self, refer_conf: Dict, conf: Dict, path=""):
+    def check_config_integrity(self, refer_conf: dict, conf: dict, path=""):
         """检查配置完整性，如果有新的配置项或顺序不一致则返回 True"""
         has_new = False
 
@@ -97,27 +98,28 @@ class AstrBotConfig(dict):
                 logger.info(f"检查到配置项 {path_} 不存在，已插入默认值 {value}")
                 new_conf[key] = value
                 has_new = True
-            else:
-                if conf[key] is None:
-                    # 配置项为 None，使用默认值
+            elif conf[key] is None:
+                # 配置项为 None，使用默认值
+                new_conf[key] = value
+                has_new = True
+            elif isinstance(value, dict):
+                # 递归检查子配置项
+                if not isinstance(conf[key], dict):
+                    # 类型不匹配，使用默认值
                     new_conf[key] = value
                     has_new = True
-                elif isinstance(value, dict):
-                    # 递归检查子配置项
-                    if not isinstance(conf[key], dict):
-                        # 类型不匹配，使用默认值
-                        new_conf[key] = value
-                        has_new = True
-                    else:
-                        # 递归检查并同步顺序
-                        child_has_new = self.check_config_integrity(
-                            value, conf[key], path + "." + key if path else key
-                        )
-                        new_conf[key] = conf[key]
-                        has_new |= child_has_new
                 else:
-                    # 直接使用现有配置
+                    # 递归检查并同步顺序
+                    child_has_new = self.check_config_integrity(
+                        value,
+                        conf[key],
+                        path + "." + key if path else key,
+                    )
                     new_conf[key] = conf[key]
+                    has_new |= child_has_new
+            else:
+                # 直接使用现有配置
+                new_conf[key] = conf[key]
 
         # 检查是否存在参考配置中没有的配置项
         for key in list(conf.keys()):
@@ -140,7 +142,7 @@ class AstrBotConfig(dict):
 
         return has_new
 
-    def save_config(self, replace_config: Dict = None):
+    def save_config(self, replace_config: dict | None = None):
         """将配置写入文件
 
         如果传入 replace_config，则将配置替换为 replace_config