feat(agent): upgrade langchain to v1.0+

app/agent/tools/base.py

@@ -1,12 +1,11 @@
 import json
-import uuid
 from abc import ABCMeta, abstractmethod
 from typing import Any, Optional
 
-from langchain.tools import BaseTool
+from langchain_core.tools import BaseTool
 from pydantic import PrivateAttr
 
-from app.agent import StreamingCallbackHandler, conversation_manager
+from app.agent import StreamingHandler
 from app.chain import ChainBase
 from app.log import logger
 from app.schemas import Notification
@@ -18,15 +17,15 @@ class ToolChain(ChainBase):
 
 class MoviePilotTool(BaseTool, metaclass=ABCMeta):
     """
-    MoviePilot专用工具基类
+    MoviePilot专用工具基类（LangChain v1 / langchain_core）
     """
 
     _session_id: str = PrivateAttr()
     _user_id: str = PrivateAttr()
-    _channel: str = PrivateAttr(default=None)
-    _source: str = PrivateAttr(default=None)
-    _username: str = PrivateAttr(default=None)
-    _callback_handler: StreamingCallbackHandler = PrivateAttr(default=None)
+    _channel: Optional[str] = PrivateAttr(default=None)
+    _source: Optional[str] = PrivateAttr(default=None)
+    _username: Optional[str] = PrivateAttr(default=None)
+    _stream_handler: Optional[StreamingHandler] = PrivateAttr(default=None)
 
     def __init__(self, session_id: str, user_id: str, **kwargs):
         super().__init__(**kwargs)
@@ -34,93 +33,70 @@ class MoviePilotTool(BaseTool, metaclass=ABCMeta):
         self._user_id = user_id
 
     def _run(self, *args: Any, **kwargs: Any) -> Any:
-        pass
+        raise NotImplementedError("MoviePilotTool 只支持异步调用，请使用 _arun")
 
-    async def _arun(self, **kwargs) -> str:
+    async def _arun(self, *args: Any, **kwargs: Any) -> str:
         """
-        异步运行工具
+        异步运行工具，负责：
+        1. 在工具调用前将流式消息推送给用户
+        2. 持久化工具调用记录到会话记忆
+        3. 调用具体工具逻辑（子类实现的 execute 方法）
+        4. 持久化工具结果到会话记忆
         """
-        # 获取工具调用前的agent消息
-        agent_message = await self._callback_handler.get_message()
-
-        # 生成唯一的工具调用ID
-        call_id = f"call_{str(uuid.uuid4())[:16]}"
-
-        # 记忆工具调用
-        await conversation_manager.add_conversation(
-            session_id=self._session_id,
-            user_id=self._user_id,
-            role="tool_call",
-            content=agent_message,
-            metadata={
-                "call_id": call_id,
-                "tool_name": self.name,
-                "parameters": kwargs
-            }
+        # 获取工具调用前 Agent 已积累的流式文本
+        agent_message = (
+            self._stream_handler.take() if self._stream_handler else ""
         )
 
-        # 获取执行工具说明,优先使用工具自定义的提示消息，如果没有则使用 explanation
+        # 获取工具执行提示消息
         tool_message = self.get_tool_message(**kwargs)
         if not tool_message:
             explanation = kwargs.get("explanation")
             if explanation:
                 tool_message = explanation
 
-        # 合并agent消息和工具执行消息，一起发送
+        # 合并 Agent 消息和工具执行消息后一起发送
         messages = []
         if agent_message:
             messages.append(agent_message)
         if tool_message:
             messages.append(f"⚙️ => {tool_message}")
 
-        # 发送合并后的消息
         if messages:
             merged_message = "\n\n".join(messages)
             await self.send_tool_message(merged_message, title="MoviePilot助手")
 
-        logger.debug(f'Executing tool {self.name} with args: {kwargs}')
+        logger.debug(f"Executing tool {self.name} with args: {kwargs}")
 
-        # 执行工具，捕获异常确保结果总是被存储到记忆中
+        # 执行具体工具逻辑
         try:
             result = await self.run(**kwargs)
-            logger.debug(f'Tool {self.name} executed with result: {result}')
+            logger.debug(f"Tool {self.name} executed with result: {result}")
         except Exception as e:
-            # 记录异常详情
             error_message = f"工具执行异常 ({type(e).__name__}): {str(e)}"
-            logger.error(f'Tool {self.name} execution failed: {e}', exc_info=True)
+            logger.error(f"Tool {self.name} execution failed: {e}", exc_info=True)
             result = error_message
 
-        # 记忆工具调用结果
+        # 格式化结果
         if isinstance(result, str):
-            formated_result = result
+            formatted_result = result
         elif isinstance(result, (int, float)):
-            formated_result = str(result)
+            formatted_result = str(result)
         else:
-            formated_result = json.dumps(result, ensure_ascii=False, indent=2)
+            formatted_result = json.dumps(result, ensure_ascii=False, indent=2)
 
-        await conversation_manager.add_conversation(
-            session_id=self._session_id,
-            user_id=self._user_id,
-            role="tool_result",
-            content=formated_result,
-            metadata={
-                "call_id": call_id,
-                "tool_name": self.name,
-            }
-        )
-
-        return result
+        return formatted_result
 
     def get_tool_message(self, **kwargs) -> Optional[str]:
         """
-        获取工具执行时的友好提示消息
-        
+        获取工具执行时的友好提示消息。
+
         子类可以重写此方法，根据实际参数生成个性化的提示消息。
         如果返回 None 或空字符串，将回退使用 explanation 参数。
-        
+
         Args:
             **kwargs: 工具的所有参数（包括 explanation）
-            
+
         Returns:
             str: 友好的提示消息，如果返回 None 或空字符串则使用 explanation
         """
@@ -128,6 +104,7 @@ class MoviePilotTool(BaseTool, metaclass=ABCMeta):
 
     @abstractmethod
     async def run(self, **kwargs) -> str:
+        """子类实现具体的工具执行逻辑"""
         raise NotImplementedError
 
     def set_message_attr(self, channel: str, source: str, username: str):
@@ -138,11 +115,11 @@ class MoviePilotTool(BaseTool, metaclass=ABCMeta):
         self._source = source
         self._username = username
 
-    def set_callback_handler(self, callback_handler: StreamingCallbackHandler):
+    def set_stream_handler(self, stream_handler: StreamingHandler):
         """
         设置回调处理器
         """
-        self._callback_handler = callback_handler
+        self._stream_handler = stream_handler
 
     async def send_tool_message(self, message: str, title: str = ""):
         """
@@ -155,6 +132,6 @@ class MoviePilotTool(BaseTool, metaclass=ABCMeta):
                 userid=self._user_id,
                 username=self._username,
                 title=title,
-                text=message
+                text=message,
             )
         )

app/agent/tools/factory.py

@@ -54,7 +54,7 @@ class MoviePilotToolFactory:
     @staticmethod
     def create_tools(session_id: str, user_id: str,
                      channel: str = None, source: str = None, username: str = None,
-                     callback_handler: Callable = None) -> List[MoviePilotTool]:
+                     stream_handler: Callable = None) -> List[MoviePilotTool]:
         """
         创建MoviePilot工具列表
         """
@@ -109,7 +109,7 @@ class MoviePilotToolFactory:
                 user_id=user_id
             )
             tool.set_message_attr(channel=channel, source=source, username=username)
-            tool.set_callback_handler(callback_handler=callback_handler)
+            tool.set_stream_handler(stream_handler=stream_handler)
             tools.append(tool)
         
         # 加载插件提供的工具
@@ -131,7 +131,7 @@ class MoviePilotToolFactory:
                         user_id=user_id
                     )
                     tool.set_message_attr(channel=channel, source=source, username=username)
-                    tool.set_callback_handler(callback_handler=callback_handler)
+                    tool.set_stream_handler(stream_handler=stream_handler)
                     tools.append(tool)
                     plugin_tools_count += 1
                     logger.debug(f"成功加载插件 {plugin_name}({plugin_id}) 的工具: {ToolClass.__name__}")

app/agent/tools/manager.py

@@ -25,7 +25,7 @@ class MoviePilotToolsManager:
     def __init__(self, user_id: str = "api_user", session_id: str = uuid.uuid4()):
         """
         初始化工具管理器
-        
+
         Args:
             user_id: 用户ID
             session_id: 会话ID
@@ -47,7 +47,7 @@ class MoviePilotToolsManager:
                 channel=None,
                 source="api",
                 username="API Client",
-                callback_handler=None,
+                stream_handler=None,
             )
             logger.info(f"成功加载 {len(self.tools)} 个工具")
         except Exception as e:
@@ -57,40 +57,38 @@ class MoviePilotToolsManager:
     def list_tools(self) -> List[ToolDefinition]:
         """
         列出所有可用的工具
-        
+
         Returns:
             工具定义列表
         """
         tools_list = []
         for tool in self.tools:
             # 获取工具的输入参数模型
-            args_schema = getattr(tool, 'args_schema', None)
+            args_schema = getattr(tool, "args_schema", None)
             if args_schema:
                 # 将Pydantic模型转换为JSON Schema
                 input_schema = self._convert_to_json_schema(args_schema)
             else:
                 # 如果没有args_schema，使用基本信息
-                input_schema = {
-                    "type": "object",
-                    "properties": {},
-                    "required": []
-                }
+                input_schema = {"type": "object", "properties": {}, "required": []}
 
-            tools_list.append(ToolDefinition(
-                name=tool.name,
-                description=tool.description or "",
-                input_schema=input_schema
-            ))
+            tools_list.append(
+                ToolDefinition(
+                    name=tool.name,
+                    description=tool.description or "",
+                    input_schema=input_schema,
+                )
+            )
 
         return tools_list
 
     def get_tool(self, tool_name: str) -> Optional[Any]:
         """
         获取指定工具实例
-        
+
         Args:
             tool_name: 工具名称
-            
+
         Returns:
             工具实例，如果未找到返回None
         """
@@ -159,23 +157,26 @@ class MoviePilotToolsManager:
             return []
         return [
             MoviePilotToolsManager._normalize_scalar_value(item_type, item.strip(), key)
-            for item in trimmed.split(",") if item.strip()
+            for item in trimmed.split(",")
+            if item.strip()
         ]
 
     @staticmethod
-    def _normalize_arguments(tool_instance: Any, arguments: Dict[str, Any]) -> Dict[str, Any]:
+    def _normalize_arguments(
+        tool_instance: Any, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """
         根据工具的参数schema规范化参数类型
-        
+
         Args:
             tool_instance: 工具实例
             arguments: 原始参数
-            
+
         Returns:
             规范化后的参数
         """
         # 获取工具的参数schema
-        args_schema = getattr(tool_instance, 'args_schema', None)
+        args_schema = getattr(tool_instance, "args_schema", None)
         if not args_schema:
             return arguments
 
@@ -201,31 +202,35 @@ class MoviePilotToolsManager:
             # 数组类型：将字符串解析为列表
             if field_type == "array" and isinstance(value, str):
                 item_type = field_info.get("items", {}).get("type", "string")
-                normalized[key] = MoviePilotToolsManager._parse_array_string(value, key, item_type)
+                normalized[key] = MoviePilotToolsManager._parse_array_string(
+                    value, key, item_type
+                )
                 continue
 
             # 根据类型进行转换
-            normalized[key] = MoviePilotToolsManager._normalize_scalar_value(field_type, value, key)
+            normalized[key] = MoviePilotToolsManager._normalize_scalar_value(
+                field_type, value, key
+            )
 
         return normalized
 
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
         """
         调用工具
-        
+
         Args:
             tool_name: 工具名称
             arguments: 工具参数
-            
+
         Returns:
             工具执行结果（字符串）
         """
         tool_instance = self.get_tool(tool_name)
 
         if not tool_instance:
-            error_msg = json.dumps({
-                "error": f"工具 '{tool_name}' 未找到"
-            }, ensure_ascii=False)
+            error_msg = json.dumps(
+                {"error": f"工具 '{tool_name}' 未找到"}, ensure_ascii=False
+            )
             return error_msg
 
         try:
@@ -238,7 +243,7 @@ class MoviePilotToolsManager:
             # 确保返回字符串
             if isinstance(result, str):
                 formated_result = result
-            elif isinstance(result, int, float):
+            elif isinstance(result, (int, float)):
                 formated_result = str(result)
             else:
                 try:
@@ -250,19 +255,20 @@ class MoviePilotToolsManager:
             return formated_result
         except Exception as e:
             logger.error(f"调用工具 {tool_name} 时发生错误: {e}", exc_info=True)
-            error_msg = json.dumps({
-                "error": f"调用工具 '{tool_name}' 时发生错误: {str(e)}"
-            }, ensure_ascii=False)
+            error_msg = json.dumps(
+                {"error": f"调用工具 '{tool_name}' 时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )
             return error_msg
 
     @staticmethod
     def _convert_to_json_schema(args_schema: Any) -> Dict[str, Any]:
         """
         将Pydantic模型转换为JSON Schema
-        
+
         Args:
             args_schema: Pydantic模型类
-            
+
         Returns:
             JSON Schema字典
         """
@@ -275,7 +281,9 @@ class MoviePilotToolsManager:
 
         if "properties" in schema:
             for field_name, field_info in schema["properties"].items():
-                resolved_field_info = MoviePilotToolsManager._resolve_field_schema(field_info)
+                resolved_field_info = MoviePilotToolsManager._resolve_field_schema(
+                    field_info
+                )
                 # 转换字段类型
                 field_type = resolved_field_info.get("type", "string")
                 field_description = resolved_field_info.get("description", "")
@@ -286,14 +294,14 @@ class MoviePilotToolsManager:
                     default_value = resolved_field_info.get("default")
                     properties[field_name] = {
                         "type": field_type,
-                        "description": field_description
+                        "description": field_description,
                     }
                     if default_value is not None:
                         properties[field_name]["default"] = default_value
                 else:
                     properties[field_name] = {
                         "type": field_type,
-                        "description": field_description
+                        "description": field_description,
                     }
                     required.append(field_name)
 
@@ -305,11 +313,7 @@ class MoviePilotToolsManager:
                 if field_type == "array" and "items" in resolved_field_info:
                     properties[field_name]["items"] = resolved_field_info["items"]
 
-        return {
-            "type": "object",
-            "properties": properties,
-            "required": required
-        }
+        return {"type": "object", "properties": properties, "required": required}
 
 
 moviepilot_tool_manager = MoviePilotToolsManager()