agentrun-sdk 0.0.4__py3-none-any.whl

agentrun/integration/pydantic_ai/builtin.py

@@ -0,0 +1,65 @@
+"""PydanticAI 内置集成函数 / PydanticAI Built-in Integration Functions
+
+提供快速创建 PydanticAI 兼容模型和工具的便捷函数。
+Provides convenient functions for quickly creating PydanticAI-compatible models and tools.
+"""
+
+from typing import Any, Callable, List, Optional, Union
+
+from typing_extensions import Unpack
+
+from agentrun.integration.builtin import model as _model
+from agentrun.integration.builtin import ModelArgs
+from agentrun.integration.builtin import sandbox_toolset as _sandbox_toolset
+from agentrun.integration.builtin import toolset as _toolset
+from agentrun.integration.utils.tool import Tool
+from agentrun.model import ModelProxy, ModelService
+from agentrun.sandbox import TemplateType
+from agentrun.toolset import ToolSet
+from agentrun.utils.config import Config
+
+
+def model(
+    name: Union[str, ModelProxy, ModelService],
+    **kwargs: Unpack[ModelArgs],
+):
+    """获取 AgentRun 模型并转换为 LangChain ``BaseChatModel``。 / PydanticAI Built-in Integration Functions"""
+
+    m = _model(input=name, **kwargs)  # type: ignore
+    return m.to_pydantic_ai()
+
+
+def toolset(
+    name: Union[str, ToolSet],
+    *,
+    prefix: Optional[str] = None,
+    modify_tool_name: Optional[Callable[[Tool], Tool]] = None,
+    filter_tools_by_name: Optional[Callable[[str], bool]] = None,
+    config: Optional[Config] = None,
+) -> List[Any]:
+    """将内置工具集封装为 LangChain ``StructuredTool`` 列表。 / PydanticAI Built-in Integration Functions"""
+
+    ts = _toolset(input=name, config=config)
+    return ts.to_pydantic_ai(
+        prefix=prefix,
+        modify_tool_name=modify_tool_name,
+        filter_tools_by_name=filter_tools_by_name,
+    )
+
+
+def sandbox_toolset(
+    template_name: str,
+    *,
+    template_type: TemplateType = TemplateType.CODE_INTERPRETER,
+    config: Optional[Config] = None,
+    sandbox_idle_timeout_seconds: int = 600,
+    prefix: Optional[str] = None,
+) -> List[Any]:
+    """将沙箱模板封装为 LangChain ``StructuredTool`` 列表。 / PydanticAI Built-in Integration Functions"""
+
+    return _sandbox_toolset(
+        template_name=template_name,
+        template_type=template_type,
+        config=config,
+        sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+    ).to_pydantic_ai(prefix=prefix)

agentrun/integration/pydantic_ai/model_adapter.py

@@ -0,0 +1,44 @@
+"""PydanticAI 模型适配器 / PydanticAI Model Adapter"""
+
+from typing import Any
+
+from agentrun.integration.utils.adapter import ModelAdapter
+from agentrun.integration.utils.model import CommonModel
+
+
+class PydanticAIModelAdapter(ModelAdapter):
+    """PydanticAI 模型适配器 / PydanticAI Model Adapter
+
+    PydanticAI 支持 OpenAI 兼容的接口，我们提供一个轻量级包装。"""
+
+    def wrap_model(self, common_model: CommonModel) -> Any:
+        """将 CommonModel 包装为 PydanticAI 兼容的模型 / PydanticAI Model Adapter"""
+
+        try:
+            from pydantic_ai.models.openai import OpenAIChatModel
+            from pydantic_ai.providers.openai import OpenAIProvider
+            from pydantic_ai.settings import ModelSettings
+        except Exception as e:
+            raise ImportError(
+                "PydanticAI is not installed. "
+                "Install it with: pip install pydantic-ai"
+            ) from e
+
+        from httpx import AsyncClient
+
+        info = common_model.get_model_info()
+
+        return OpenAIChatModel(
+            info.model or "",
+            provider=OpenAIProvider(
+                base_url=info.base_url,
+                api_key=info.api_key,
+                http_client=AsyncClient(headers=info.headers),
+            ),
+            settings=ModelSettings(
+                extra_body={"stream_options": {"include_usage": True}}
+            ),
+        )
+
+
+__all__ = ["PydanticAIModelAdapter"]

agentrun/integration/pydantic_ai/tool_adapter.py

@@ -0,0 +1,19 @@
+"""PydanticAI 工具适配器 / PydanticAI Tool Adapter"""
+
+from typing import Any, List
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+
+
+class PydanticAIToolAdapter(ToolAdapter):
+    """PydanticAI 工具适配器 / PydanticAI Tool Adapter
+
+    PydanticAI 使用函数作为工具，需要附加元数据信息。"""
+
+    def from_canonical(self, tools: List[CanonicalTool]) -> List[Any]:
+        """将标准工具转换为 PydanticAI 函数格式 / PydanticAI Tool Adapter"""
+        return self.function_tools(tools)
+
+
+__all__ = ["PydanticAIToolAdapter"]

agentrun/integration/utils/__init__.py

@@ -0,0 +1,112 @@
+"""通用集成工具模块 / 通用集成工具 Module
+
+提供跨框架的通用工具定义和转换功能。 / 提供跨framework的通用工具定义和转换功能。
+
+支持多种工具定义方式:
+1. 使用 @tool 装饰器 - 最简单,推荐
+2. 使用 Pydantic BaseModel - 类型安全
+3. 使用 ToolParameter 列表 - 灵活但繁琐
+4. 从 AgentRun ToolSet 转换 - 直接使用远程工具集
+
+支持模型集成:
+1. 使用 model() 函数 - 获取模型并转换为各种框架格式 / 1. 使用 model() 函数 - 获取模型并转换为各种framework格式
+2. 从已有模型对象创建 - from_agentrun_model()
+
+Examples:
+>>> # 工具集成示例
+>>> # 方式 1: 使用装饰器从函数创建 Tool
+>>> from agentrun.integration.common import tool
+>>> from typing import Literal
+>>>
+>>> @tool()
+... def calculator(
+...     operation: Literal["add", "subtract"],
+...     a: float,
+...     b: float,
+... ) -> float:
+...     '''执行数学运算'''
+...     if operation == "add":
+...         return a + b
+...     return a - b
+>>>
+>>> # 方式 2: 使用 Pydantic 模型
+>>> from agentrun.integration.common import Tool
+>>> from pydantic import BaseModel, Field
+>>>
+>>> class SearchArgs(BaseModel):
+...     query: str = Field(description="搜索关键词")
+...     limit: int = Field(description="结果数量", ge=1, le=100, default=10)
+>>>
+>>> search_tool = Tool(
+...     name="search",
+...     description="搜索网络信息",
+...     args_schema=SearchArgs,
+...     func=lambda query, limit: f"搜索: {query}"
+... )
+>>>
+>>> # 方式 3: 使用 ToolParameter
+>>> from agentrun.integration.common import ToolParameter
+>>>
+>>> weather_tool = Tool(
+...     name="weather",
+...     description="获取天气信息",
+...     parameters=[
+...         ToolParameter(
+...             name="city",
+...             param_type="string",
+...             description="城市名称",
+...             required=True
+...         )
+...     ]
+... )
+>>>
+>>> # 方式 4: 从 AgentRun ToolSet 转换
+>>> from agentrun.toolset.client import ToolSetClient
+>>> from agentrun.integration.common import from_agentrun_toolset
+>>>
+>>> client = ToolSetClient()
+>>> remote_toolset = client.get(name="my-toolset")
+>>> common_toolset = from_agentrun_toolset(remote_toolset)
+>>>
+>>> # 导出为各种框架格式 / >>> # 导出为各种framework格式
+>>> openai_tools = common_toolset.to_openai_function()
+>>> langchain_tools = common_toolset.to_langchain()
+>>>
+>>> # 模型集成示例
+>>> # 方式 1: 使用 model() 函数
+>>> from agentrun.integration.common import model
+>>>
+>>> # 获取模型并转换为 LangChain
+>>> llm = model("my-model").to_langchain()
+>>>
+>>> # 转换为 Google ADK
+>>> google_model = model("my-model").to_google_adk()
+>>>
+>>> # 方式 2: 从已有模型对象创建
+>>> from agentrun.model.client import ModelClient
+>>> from agentrun.integration.common import from_agentrun_model
+>>>
+>>> client = ModelClient()
+>>> remote_model = client.get("my-model")
+>>> common_model = from_agentrun_model(remote_model)
+>>> llm = common_model.to_langchain()"""
+
+from agentrun.integration.utils.model import CommonModel
+from agentrun.integration.utils.tool import (
+    CommonToolSet,
+    from_pydantic,
+    Tool,
+    tool,
+    ToolParameter,
+)
+
+__all__ = [
+    # Tool related
+    "Tool",
+    "ToolParameter",
+    "CommonToolSet",
+    "tool",
+    "from_pydantic",
+    # Model related
+    "CommonModel",
+]

agentrun/integration/utils/adapter.py

@@ -0,0 +1,167 @@
+"""适配器接口定义 / Adapter Interface Definition
+
+定义统一的适配器接口,所有框架适配器都实现这些接口。
+Defines unified adapter interfaces that all framework adapters implement.
+
+这样可以确保一致的转换行为,并最大化代码复用。
+This ensures consistent conversion behavior and maximizes code reuse.
+"""
+
+from abc import ABC, abstractmethod
+import inspect
+from typing import Any, Callable, Dict, List, Optional
+
+from agentrun.integration.utils.canonical import CanonicalMessage, CanonicalTool
+from agentrun.integration.utils.model import CommonModel
+
+
+class MessageAdapter(ABC):
+    """消息格式适配器接口
+
+    用于在 ModelAdapter 内部进行消息格式转换。
+    只需要将框架消息转换为标准 OpenAI 格式。
+
+    转换流程：
+    - 框架消息 → to_canonical() → CanonicalMessage（OpenAI 格式）
+    """
+
+    @abstractmethod
+    def to_canonical(self, messages: Any) -> List[CanonicalMessage]:
+        """将框架消息转换为标准格式（供 ModelAdapter 内部使用）
+
+        Args:
+            messages: 框架特定的消息格式
+
+        Returns:
+            标准格式消息列表
+        """
+        pass
+
+
+class ToolAdapter(ABC):
+    """工具格式适配器接口 / Utils Adapters
+
+    用于将标准工具定义转换为框架特定格式。
+        单向转换：CanonicalTool → 框架工具"""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # 记录工具定义，便于模型适配器回溯参数 schema
+        self._registered_tools: Dict[str, CanonicalTool] = {}
+
+    @abstractmethod
+    def from_canonical(self, tools: List[CanonicalTool]) -> Any:
+        """将标准工具转换为框架特定格式 / 将标准工具Converts为框架特定格式
+
+        Args:
+                    tools: 标准格式工具列表
+
+                Returns:
+                    框架特定的工具格式"""
+        pass
+
+    def function_tools(
+        self,
+        tools: List[CanonicalTool],
+        modify_func: Optional[Callable[..., Any]] = None,
+    ):
+        """将标准格式转换为 Google ADK 工具 / 将标准格式Converts为 Google ADK 工具
+
+        Google ADK 通过函数的类型注解推断参数，需要动态创建带注解的函数。"""
+        result = []
+
+        for tool in tools:
+            # 记录工具定义
+            self._registered_tools[tool.name] = tool
+
+            # 从 parameters schema 构建函数签名
+            parameters_schema = tool.parameters or {
+                "type": "object",
+                "properties": {},
+            }
+            properties = parameters_schema.get("properties", {})
+            required = set(parameters_schema.get("required", []))
+
+            # 构建函数参数
+            params = []
+            annotations = {}
+
+            for param_name, param_schema in properties.items():
+                # 映射 JSON Schema 类型到 Python 类型
+                param_type_str = param_schema.get("type", "string")
+                type_mapping = {
+                    "string": str,
+                    "integer": int,
+                    "number": float,
+                    "boolean": bool,
+                    "array": list,
+                    "object": dict,
+                }
+                param_type = type_mapping.get(param_type_str, str)
+
+                # 设置默认值
+                default = (
+                    inspect.Parameter.empty if param_name in required else None
+                )
+
+                params.append(
+                    inspect.Parameter(
+                        param_name,
+                        inspect.Parameter.KEYWORD_ONLY,
+                        default=default,
+                        annotation=param_type,
+                    )
+                )
+                annotations[param_name] = param_type
+
+            # 创建带正确签名的函数
+            def make_tool_function(
+                canonical_tool: CanonicalTool,
+                sig: inspect.Signature,
+                annots: dict,
+            ):
+                def tool_func(**kwargs):
+                    if canonical_tool.func is None:
+                        raise NotImplementedError(
+                            f"Tool function for '{canonical_tool.name}' "
+                            "is not implemented."
+                        )
+
+                    if modify_func:
+                        return modify_func(canonical_tool, **kwargs)
+
+                    return canonical_tool.func(**kwargs)
+
+                # 设置函数元数据
+                tool_func.__name__ = canonical_tool.name
+                tool_func.__doc__ = canonical_tool.description
+                tool_func.__annotations__ = annots
+                object.__setattr__(tool_func, "__signature__", sig)
+
+                return tool_func
+
+            # 创建签名
+            signature = inspect.Signature(params)
+            wrapped_func = make_tool_function(tool, signature, annotations)
+
+            result.append(wrapped_func)
+
+        return result
+
+
+class ModelAdapter(ABC):
+    """模型适配器接口 / Utils Model Adapter
+
+    用于包装框架模型，使其能够与 CommonModel 协同工作。"""
+
+    @abstractmethod
+    def wrap_model(self, common_model: CommonModel) -> Any:
+        """包装 CommonModel 为框架特定的模型格式 / 包装 CommonModel 为framework特定的模型格式
+
+        Args:
+                    common_model: CommonModel 实例
+
+                Returns:
+                    框架特定的模型对象"""
+        pass

agentrun/integration/utils/canonical.py

@@ -0,0 +1,157 @@
+"""中间格式定义 / 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
+
+
+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 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()