agentrun-inner-test 0.0.46__py3-none-any.whl

agentrun/integration/utils/canonical.py

@@ -0,0 +1,164 @@
+"""中间格式定义 / Canonical Format Definition
+
+提供统一的中间格式(Canonical Format),作为所有框架转换的桥梁。
+Provides a unified canonical format that serves as a bridge for all framework conversions.
+
+这样可以最大化代码复用,减少重复的转换逻辑。
+This maximizes code reuse and reduces redundant conversion logic.
+"""
+
+from dataclasses import dataclass
+import json
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Protocol
+else:
+    Protocol = object
+
+from enum import Enum
+
+from agentrun.integration.utils.tool import normalize_tool_name
+
+
+class MessageRole(str, Enum):
+    """统一的消息角色枚举"""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+
+
+@dataclass
+class CanonicalToolCall:
+    """统一的工具调用格式
+
+    所有框架的工具调用都转换为这个格式，然后再转换为目标框架格式。
+    """
+
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+
+
+@dataclass
+class CanonicalMessage:
+    """统一的消息格式
+
+    这是所有框架消息格式的中间表示。
+    转换流程：框架A格式 → CanonicalMessage → 框架B格式
+    """
+
+    role: MessageRole
+    content: Optional[str] = None
+    name: Optional[str] = None
+    tool_calls: Optional[List[CanonicalToolCall]] = None
+    tool_call_id: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式（用于序列化）
+
+        注意：OpenAI API 要求 tool_calls 中的 arguments 必须是 JSON 字符串，
+        而不是字典。这里会自动转换。
+        """
+        result = {
+            "role": self.role.value,
+        }
+        if self.content is not None:
+            result["content"] = self.content
+        if self.name is not None:
+            result["name"] = self.name
+        if self.tool_calls is not None:
+            result["tool_calls"] = [
+                {
+                    "id": call.id,
+                    "type": "function",
+                    "function": {
+                        "name": call.name,
+                        # arguments 必须是 JSON 字符串（OpenAI API 要求）
+                        "arguments": (
+                            json.dumps(call.arguments)
+                            if isinstance(call.arguments, dict)
+                            else str(call.arguments)
+                        ),
+                    },
+                }
+                for call in self.tool_calls
+            ]
+        if self.tool_call_id is not None:
+            result["tool_call_id"] = self.tool_call_id
+        return result
+
+
+@dataclass
+class CanonicalTool:
+    """统一的工具格式
+
+    所有框架的工具都转换为这个格式。
+    参数使用 JSON Schema 格式，这是最通用的工具描述格式。
+    """
+
+    name: str
+    description: str
+    parameters: Dict[str, Any]  # JSON Schema 格式
+    func: Optional[Callable] = None
+
+    def __post_init__(self):
+        # Normalize canonical tool name to avoid exceeding provider limits
+        if self.name:
+            self.name = normalize_tool_name(self.name)
+
+    def to_openai_function(self) -> Dict[str, Any]:
+        """转换为 OpenAI Function Calling 格式"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+        }
+
+    def to_anthropic_tool(self) -> Dict[str, Any]:
+        """转换为 Anthropic Claude Tools 格式"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self.parameters,
+        }
+
+
+@dataclass
+class CanonicalModelResponse:
+    """统一的模型响应格式"""
+
+    content: Optional[str] = None
+    tool_calls: Optional[List[CanonicalToolCall]] = None
+    usage: Optional[Dict[str, int]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式
+
+        注意：OpenAI API 要求 tool_calls 中的 arguments 必须是 JSON 字符串。
+        """
+        result = {}
+        if self.content is not None:
+            result["content"] = self.content
+        if self.tool_calls is not None:
+            result["tool_calls"] = [
+                {
+                    "id": call.id,
+                    "type": "function",
+                    "function": {
+                        "name": call.name,
+                        # arguments 必须是 JSON 字符串（OpenAI API 要求）
+                        "arguments": (
+                            json.dumps(call.arguments)
+                            if isinstance(call.arguments, dict)
+                            else str(call.arguments)
+                        ),
+                    },
+                }
+                for call in self.tool_calls
+            ]
+        if self.usage is not None:
+            result["usage"] = self.usage
+        return result

agentrun/integration/utils/converter.py

@@ -0,0 +1,134 @@
+"""框架转换器 / Framework Converter
+
+提供统一的框架适配器注册中心。
+Provides a unified registry for framework adapters.
+"""
+
+from typing import Dict, Optional
+
+from agentrun.integration.utils.adapter import ModelAdapter, ToolAdapter
+from agentrun.utils.log import logger
+
+
+class FrameworkConverter:
+    """框架适配器注册中心
+
+    管理所有框架的工具和模型适配器。
+    MessageAdapter 不再单独注册，而是作为 ModelAdapter 的内部组件。
+    """
+
+    def __init__(self):
+        self._tool_adapters: Dict[str, ToolAdapter] = {}
+        self._model_adapters: Dict[str, ModelAdapter] = {}
+
+    def register_tool_adapter(
+        self, framework: str, adapter: ToolAdapter
+    ) -> None:
+        """注册工具适配器"""
+        self._tool_adapters[framework] = adapter
+
+    def register_model_adapter(
+        self, framework: str, adapter: ModelAdapter
+    ) -> None:
+        """注册模型适配器"""
+        self._model_adapters[framework] = adapter
+
+    def get_model_adapter(self, framework: str) -> Optional[ModelAdapter]:
+        """获取模型适配器"""
+        return self._model_adapters.get(framework)
+
+
+# 全局转换器实例
+_converter = FrameworkConverter()
+
+
+def get_converter() -> FrameworkConverter:
+    """获取全局转换器实例"""
+    return _converter
+
+
+def _auto_register_adapters() -> None:
+    """自动注册所有可用的适配器
+
+    延迟导入，避免循环依赖。
+    MessageAdapter 不再单独注册，由 ModelAdapter 内部管理。
+    """
+    # LangChain 适配器
+    try:
+        from agentrun.integration.langchain.adapter import (
+            LangChainModelAdapter,
+            LangChainToolAdapter,
+        )
+
+        _converter.register_tool_adapter("langchain", LangChainToolAdapter())
+        _converter.register_model_adapter("langchain", LangChainModelAdapter())
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register LangChain adapters, due to %s", e)
+
+    # Google ADK 适配器
+    try:
+        from agentrun.integration.google_adk.adapter import (
+            GoogleADKModelAdapter,
+            GoogleADKToolAdapter,
+        )
+
+        _converter.register_tool_adapter("google_adk", GoogleADKToolAdapter())
+        _converter.register_model_adapter("google_adk", GoogleADKModelAdapter())
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register Google ADK adapters, due to %s", e)
+
+    # AgentScope 适配器
+    try:
+        from agentrun.integration.agentscope.adapter import (
+            AgentScopeModelAdapter,
+            AgentScopeToolAdapter,
+        )
+
+        _converter.register_tool_adapter("agentscope", AgentScopeToolAdapter())
+        _converter.register_model_adapter(
+            "agentscope", AgentScopeModelAdapter()
+        )
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register AgentScope adapters, due to %s", e)
+
+    # LangGraph 适配器（复用 LangChain）
+    try:
+        from agentrun.integration.langgraph.adapter import (
+            LangGraphModelAdapter,
+            LangGraphToolAdapter,
+        )
+
+        _converter.register_tool_adapter("langgraph", LangGraphToolAdapter())
+        _converter.register_model_adapter("langgraph", LangGraphModelAdapter())
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register LangGraph adapters, due to %s", e)
+
+    # CrewAI 适配器（复用 LangChain）
+    try:
+        from agentrun.integration.crewai.adapter import (
+            CrewAIModelAdapter,
+            CrewAIToolAdapter,
+        )
+
+        _converter.register_tool_adapter("crewai", CrewAIToolAdapter())
+        _converter.register_model_adapter("crewai", CrewAIModelAdapter())
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register CrewAI adapters, due to %s", e)
+
+    # PydanticAI 适配器
+    try:
+        from agentrun.integration.pydantic_ai.adapter import (
+            PydanticAIModelAdapter,
+            PydanticAIToolAdapter,
+        )
+
+        _converter.register_tool_adapter("pydantic_ai", PydanticAIToolAdapter())
+        _converter.register_model_adapter(
+            "pydantic_ai", PydanticAIModelAdapter()
+        )
+    except (ImportError, AttributeError) as e:
+        logger.warning("failed to register PydanticAI adapters, due to %s", e)
+
+
+# 初始化时自动注册
+_auto_register_adapters()

agentrun/integration/utils/model.py

@@ -0,0 +1,110 @@
+"""通用模型定义和转换模块 / Common Model Definition and Conversion Module
+
+提供跨框架的通用模型定义和转换功能。
+Provides cross-framework model definition and conversion capabilities.
+"""
+
+from typing import Any, Optional, Union
+
+from agentrun.model import BackendType, ModelProxy, ModelService
+from agentrun.utils.config import Config
+from agentrun.utils.log import logger
+
+
+class CommonModel:
+    """通用模型定义
+
+    封装 AgentRun 模型，提供跨框架转换能力。
+    """
+
+    def __init__(
+        self,
+        model_obj: Union[ModelService, ModelProxy],
+        backend_type: Optional[BackendType] = None,
+        specific_model: Optional[str] = None,
+        config: Optional[Config] = None,
+    ):
+        self.model_obj = model_obj
+        self.backend_type = backend_type
+        self.specific_model = specific_model
+        self.config = config or Config()
+
+    def completions(self, *args, **kwargs):
+        """调用底层模型的 completions 方法"""
+        return self.model_obj.completions(*args, **kwargs)
+
+    def responses(self, *args, **kwargs):
+        """调用底层模型的 responses 方法"""
+        return self.model_obj.responses(*args, **kwargs)
+
+    def get_model_info(self, config: Optional[Config] = None):
+        """获取模型信息"""
+        cfg = Config.with_configs(self.config, config)
+        info = self.model_obj.model_info(config=cfg)
+        if self.specific_model:
+            info.model = self.specific_model
+        return info
+
+    def __convert_model(self, adapter_name: str):
+        try:
+            from agentrun.integration.utils.converter import get_converter
+
+            converter = get_converter()
+            adapter = converter.get_model_adapter(adapter_name)
+            if adapter is not None:
+                return adapter.wrap_model(self)
+        except (ImportError, AttributeError, KeyError) as e:
+            logger.warning("convert model failed, due to %s", e)
+            pass
+
+        logger.warning(
+            f"Model adapter '{adapter_name}' not found. Falling back to default"
+            " implementation."
+        )
+
+        return ""
+
+    def to_google_adk(self) -> Any:
+        """转换为 Google ADK BaseLlm
+
+        优先使用适配器模式，如果适配器未注册则回退到旧实现。
+        """
+        # 尝试使用适配器模式
+        return self.__convert_model("google_adk")
+
+    def to_langchain(self) -> Any:
+        """转换为 LangChain ChatModel
+
+        优先使用适配器模式，如果适配器未注册则回退到旧实现。
+        """
+        # 尝试使用适配器模式
+        return self.__convert_model("langchain")
+
+    def __call__(self, messages: list, **kwargs) -> Any:
+        """直接调用模型"""
+        return self.completions(messages=messages, **kwargs)
+
+    def to_langgraph(self) -> Any:
+        """转换为 LangGraph 兼容的模型。
+
+        LangGraph 与 LangChain 完全兼容，因此使用相同的接口。
+        """
+        return self.__convert_model("langgraph")
+
+    def to_crewai(self) -> Any:
+        """转换为 CrewAI 兼容的模型。
+
+        CrewAI 内部使用 LangChain，因此使用相同的接口。
+        """
+        return self.__convert_model("crewai")
+
+    def to_pydantic_ai(self) -> Any:
+        """转换为 PydanticAI 兼容的模型。
+
+        PydanticAI 支持 OpenAI 兼容的接口，返回一个包装对象。
+        """
+        return self.__convert_model("pydantic_ai")
+
+    def to_agentscope(self) -> Any:
+        """转换为 AgentScope ChatModelBase。"""
+        return self.__convert_model("agentscope")