Merge branch 'master' of https://github.com/MoFox-Studio/MoFox_Bot

src/plugin_system/apis/tool_api.py

@@ -1,9 +1,7 @@
-from typing import Any, Dict, List, Optional, Type, Union
-from datetime import datetime
+from typing import Optional, Type
 from src.plugin_system.base.base_tool import BaseTool
 from src.plugin_system.base.component_types import ComponentType
 
-from src.common.tool_history import ToolHistoryManager
 from src.common.logger import get_logger
 
 logger = get_logger("tool_api")
@@ -33,110 +31,4 @@ def get_llm_available_tool_definitions():
     from src.plugin_system.core import component_registry
 
     llm_available_tools = component_registry.get_llm_available_tools()
-    return [(name, tool_class.get_tool_definition()) for name, tool_class in llm_available_tools.items()]
-
-def get_tool_history(
-    tool_names: Optional[List[str]] = None,
-    start_time: Optional[Union[datetime, str]] = None,
-    end_time: Optional[Union[datetime, str]] = None,
-    chat_id: Optional[str] = None,
-    limit: Optional[int] = None,
-    status: Optional[str] = None
-) -> List[Dict[str, Any]]:
-    """
-    获取工具调用历史记录
-    
-    Args:
-        tool_names: 工具名称列表，为空则查询所有工具
-        start_time: 开始时间，可以是datetime对象或ISO格式字符串
-        end_time: 结束时间，可以是datetime对象或ISO格式字符串
-        chat_id: 会话ID，用于筛选特定会话的调用
-        limit: 返回记录数量限制
-        status: 执行状态筛选("completed"或"error")
-        
-    Returns:
-        List[Dict]: 工具调用记录列表，每条记录包含以下字段：
-            - tool_name: 工具名称
-            - timestamp: 调用时间
-            - arguments: 调用参数
-            - result: 调用结果
-            - execution_time: 执行时间
-            - status: 执行状态
-            - chat_id: 会话ID
-    """
-    history_manager = ToolHistoryManager()
-    return history_manager.query_history(
-        tool_names=tool_names,
-        start_time=start_time,
-        end_time=end_time,
-        chat_id=chat_id,
-        limit=limit,
-        status=status
-    )
-
-
-def get_tool_history_text(
-    tool_names: Optional[List[str]] = None,
-    start_time: Optional[Union[datetime, str]] = None,
-    end_time: Optional[Union[datetime, str]] = None,
-    chat_id: Optional[str] = None,
-    limit: Optional[int] = None,
-    status: Optional[str] = None
-) -> str:
-    """
-    获取工具调用历史记录的文本格式
-    
-    Args:
-        tool_names: 工具名称列表，为空则查询所有工具
-        start_time: 开始时间，可以是datetime对象或ISO格式字符串
-        end_time: 结束时间，可以是datetime对象或ISO格式字符串
-        chat_id: 会话ID，用于筛选特定会话的调用
-        limit: 返回记录数量限制
-        status: 执行状态筛选("completed"或"error")
-        
-    Returns:
-        str: 格式化的工具调用历史记录文本
-    """
-    history = get_tool_history(
-        tool_names=tool_names,
-        start_time=start_time,
-        end_time=end_time,
-        chat_id=chat_id,
-        limit=limit,
-        status=status
-    )
-
-    if not history:
-        return "没有找到工具调用记录"
-
-    text = "工具调用历史记录:\n"
-    for record in history:
-        # 提取结果中的name和content
-        result = record['result']
-        if isinstance(result, dict):
-            name = result.get('name', record['tool_name'])
-            content = result.get('content', str(result))
-        else:
-            name = record['tool_name']
-            content = str(result)
-
-        # 格式化内容
-        content = content.strip().replace('\n', ' ')
-        if len(content) > 200:
-            content = content[:200] + "..."
-
-        # 格式化时间
-        timestamp = datetime.fromisoformat(record['timestamp']).strftime("%Y-%m-%d %H:%M:%S")
-
-        text += f"[{timestamp}] {name}\n"
-        text += f"结果: {content}\n\n"
-
-    return text
-
-
-def clear_tool_history() -> None:
-    """
-    清除所有工具调用历史记录
-    """
-    history_manager = ToolHistoryManager()
-    history_manager.clear_history()
+    return [(name, tool_class.get_tool_definition()) for name, tool_class in llm_available_tools.items()]

src/plugin_system/base/base_event.py

@@ -119,17 +119,17 @@ class BaseEvent:
             for i, result in enumerate(results):
                 subscriber = sorted_subscribers[i]
                 handler_name = subscriber.handler_name if hasattr(subscriber, 'handler_name') else subscriber.__class__.__name__
-                
-                if isinstance(result, Exception):
-                    # 处理执行异常
-                    logger.error(f"事件处理器 {handler_name} 执行失败: {result}")
-                    processed_results.append(HandlerResult(False, True, str(result), handler_name))
-                else:
-                    # 正常执行结果
-                    if not result.handler_name:
-                        # 补充handler_name
-                        result.handler_name = handler_name
-                    processed_results.append(result)
+                if result:
+                    if isinstance(result, Exception):
+                        # 处理执行异常
+                        logger.error(f"事件处理器 {handler_name} 执行失败: {result}")
+                        processed_results.append(HandlerResult(False, True, str(result), handler_name))
+                    else:
+                        # 正常执行结果
+                        if not result.handler_name:
+                            # 补充handler_name
+                            result.handler_name = handler_name
+                        processed_results.append(result)
             
             return HandlerResultsCollection(processed_results)
     

src/plugin_system/base/base_events_handler.py

@@ -26,7 +26,6 @@ class BaseEventHandler(ABC):
 
     def __init__(self):
         self.log_prefix = "[EventHandler]"
-        self.plugin_name = ""
         """对应插件名"""
         self.plugin_config: Optional[Dict] = None
         """插件配置字典"""

src/plugin_system/base/base_plugin.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import List, Type, Tuple, Union, TYPE_CHECKING
+from typing import List, Type, Tuple, Union
 from .plugin_base import PluginBase
 
 from src.common.logger import get_logger

src/plugin_system/base/plus_command.py

@@ -4,7 +4,7 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Dict, Tuple, Optional, List
+from typing import Tuple, Optional, List
 import re
 
 from src.common.logger import get_logger

src/plugin_system/core/component_registry.py

@@ -166,7 +166,8 @@ class ComponentRegistry:
         if not isinstance(action_info, ActionInfo) or not issubclass(action_class, BaseAction):
             logger.error(f"注册失败: {action_name} 不是有效的Action")
             return False
-
+        
+        action_class.plugin_name = action_info.plugin_name
         self._action_registry[action_name] = action_class
 
         # 如果启用，添加到默认动作集
@@ -184,6 +185,7 @@ class ComponentRegistry:
             logger.error(f"注册失败: {command_name} 不是有效的Command")
             return False
 
+        command_class.plugin_name = command_info.plugin_name
         self._command_registry[command_name] = command_class
 
         # 如果启用了且有匹配模式
@@ -213,6 +215,7 @@ class ComponentRegistry:
         if not hasattr(self, '_plus_command_registry'):
             self._plus_command_registry: Dict[str, Type[PlusCommand]] = {}
 
+        plus_command_class.plugin_name = plus_command_info.plugin_name
         self._plus_command_registry[plus_command_name] = plus_command_class
 
         logger.debug(f"已注册PlusCommand组件: {plus_command_name}")
@@ -222,6 +225,7 @@ class ComponentRegistry:
         """注册Tool组件到Tool特定注册表"""
         tool_name = tool_info.name
 
+        tool_class.plugin_name = tool_info.plugin_name
         self._tool_registry[tool_name] = tool_class
 
         # 如果是llm可用的且启用的工具,添加到 llm可用工具列表
@@ -246,6 +250,7 @@ class ComponentRegistry:
             logger.warning(f"EventHandler组件 {handler_name} 未启用")
             return True  # 未启用，但是也是注册成功
         
+        handler_class.plugin_name = handler_info.plugin_name
         # 使用EventManager进行事件处理器注册
         from src.plugin_system.core.event_manager import event_manager
         return event_manager.register_event_handler(handler_class)

src/plugin_system/core/tool_use.py

@@ -7,8 +7,10 @@ from src.llm_models.utils_model import LLMRequest
 from src.llm_models.payload_content import ToolCall
 from src.config.config import global_config, model_config
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+import inspect
 from src.chat.message_receive.chat_stream import get_chat_manager
 from src.common.logger import get_logger
+from src.common.cache_manager import tool_cache
 
 logger = get_logger("tool_use")
 
@@ -184,21 +186,65 @@ class ToolExecutor:
         return tool_results, used_tools
 
     async def execute_tool_call(self, tool_call: ToolCall, tool_instance: Optional[BaseTool] = None) -> Optional[Dict[str, Any]]:
-        # sourcery skip: use-assigned-variable
-        """执行单个工具调用
+        """执行单个工具调用，并处理缓存"""
+        
+        function_args = tool_call.args or {}
+        tool_instance = tool_instance or get_tool_instance(tool_call.func_name)
 
-        Args:
-            tool_call: 工具调用对象
+        # 如果工具不存在或未启用缓存，则直接执行
+        if not tool_instance or not tool_instance.enable_cache:
+            return await self._original_execute_tool_call(tool_call, tool_instance)
 
-        Returns:
-            Optional[Dict]: 工具调用结果，如果失败则返回None
-        """
+        # --- 缓存逻辑开始 ---
+        try:
+            tool_file_path = inspect.getfile(tool_instance.__class__)
+            semantic_query = None
+            if tool_instance.semantic_cache_query_key:
+                semantic_query = function_args.get(tool_instance.semantic_cache_query_key)
+
+            cached_result = await tool_cache.get(
+                tool_name=tool_call.func_name,
+                function_args=function_args,
+                tool_file_path=tool_file_path,
+                semantic_query=semantic_query
+            )
+            if cached_result:
+                logger.info(f"{self.log_prefix}使用缓存结果，跳过工具 {tool_call.func_name} 执行")
+                return cached_result
+        except Exception as e:
+            logger.error(f"{self.log_prefix}检查工具缓存时出错: {e}")
+
+        # 缓存未命中，执行原始工具调用
+        result = await self._original_execute_tool_call(tool_call, tool_instance)
+
+        # 将结果存入缓存
+        try:
+            tool_file_path = inspect.getfile(tool_instance.__class__)
+            semantic_query = None
+            if tool_instance.semantic_cache_query_key:
+                semantic_query = function_args.get(tool_instance.semantic_cache_query_key)
+            
+            await tool_cache.set(
+                tool_name=tool_call.func_name,
+                function_args=function_args,
+                tool_file_path=tool_file_path,
+                data=result,
+                ttl=tool_instance.cache_ttl,
+                semantic_query=semantic_query
+            )
+        except Exception as e:
+            logger.error(f"{self.log_prefix}设置工具缓存时出错: {e}")
+        # --- 缓存逻辑结束 ---
+
+        return result
+
+    async def _original_execute_tool_call(self, tool_call: ToolCall, tool_instance: Optional[BaseTool] = None) -> Optional[Dict[str, Any]]:
+        """执行单个工具调用的原始逻辑"""
         try:
             function_name = tool_call.func_name
             function_args = tool_call.args or {}
-            logger.info(f"🤖 {self.log_prefix} 正在执行工具: [bold green]{function_name}[/bold green] | 参数: {function_args}")
+            logger.info(f"{self.log_prefix} 正在执行工具: [bold green]{function_name}[/bold green] | 参数: {function_args}")
             function_args["llm_called"] = True  # 标记为LLM调用
-
             # 获取对应工具实例
             tool_instance = tool_instance or get_tool_instance(function_name)
             if not tool_instance: