agentrun-sdk 0.0.4__py3-none-any.whl

agentrun/integration/google_adk/message_adapter.py

@@ -0,0 +1,144 @@
+"""Google ADK 消息适配器 / Google ADK Message Adapter
+
+将 Google ADK LlmRequest 转换为标准格式,供 ModelAdapter 内部使用。
+Converts Google ADK LlmRequest to canonical format for internal use by ModelAdapter.
+"""
+
+import json
+from typing import Any, List
+
+from agentrun.integration.utils.adapter import MessageAdapter
+from agentrun.integration.utils.canonical import (
+    CanonicalMessage,
+    CanonicalToolCall,
+    MessageRole,
+)
+
+
+class GoogleADKMessageAdapter(MessageAdapter):
+    """Google ADK 消息适配器 / Google ADK Message Adapter
+
+    实现 Google ADK LlmRequest → CanonicalMessage 的转换。
+    Implements conversion from Google ADK LlmRequest to CanonicalMessage.
+    """
+
+    def to_canonical(self, messages: Any) -> List[CanonicalMessage]:
+        """将 Google ADK LlmRequest 转换为标准格式 / Google ADK Message Adapter"""
+        canonical = []
+
+        # Google ADK 使用 LlmRequest，包含 contents 列表
+        if hasattr(messages, "contents"):
+            contents = messages.contents
+        elif isinstance(messages, list):
+            contents = messages
+        else:
+            contents = [messages]
+
+        # 处理 system_instruction (在 config 中)
+        if hasattr(messages, "config") and messages.config:
+            if (
+                hasattr(messages.config, "system_instruction")
+                and messages.config.system_instruction
+            ):
+                canonical.append(
+                    CanonicalMessage(
+                        role=MessageRole.SYSTEM,
+                        content=messages.config.system_instruction,
+                    )
+                )
+
+        # 处理 contents
+        for content in contents:
+            # 确定角色
+            role = MessageRole.USER
+            if hasattr(content, "role"):
+                role_str = str(content.role).lower()
+                if "model" in role_str or "assistant" in role_str:
+                    role = MessageRole.ASSISTANT
+                elif "system" in role_str:
+                    role = MessageRole.SYSTEM
+                elif "tool" in role_str:
+                    role = MessageRole.TOOL
+                elif "function" in role_str:
+                    role = MessageRole.TOOL
+                else:
+                    role = MessageRole.USER
+
+            # 处理 parts
+            if hasattr(content, "parts"):
+                text_parts = []
+                tool_calls = []
+
+                for part in content.parts:
+                    # 处理文本
+                    if hasattr(part, "text") and part.text:
+                        text_parts.append(part.text)
+
+                    # 处理 function_call
+                    elif hasattr(part, "function_call") and part.function_call:
+                        func_call = part.function_call
+                        args = {}
+                        if hasattr(func_call, "args"):
+                            if isinstance(func_call.args, dict):
+                                args = func_call.args
+                            else:
+                                try:
+                                    args = json.loads(str(func_call.args))
+                                except (json.JSONDecodeError, TypeError):
+                                    args = {}
+
+                        tool_calls.append(
+                            CanonicalToolCall(
+                                id=getattr(
+                                    func_call, "id", f"call_{len(tool_calls)}"
+                                ),
+                                name=getattr(func_call, "name", ""),
+                                arguments=args,
+                            )
+                        )
+
+                    # 处理 function_response
+                    elif (
+                        hasattr(part, "function_response")
+                        and part.function_response
+                    ):
+                        func_resp = part.function_response
+                        response_content = ""
+                        if hasattr(func_resp, "response"):
+                            if isinstance(func_resp.response, dict):
+                                response_content = json.dumps(
+                                    func_resp.response
+                                )
+                            else:
+                                response_content = str(func_resp.response)
+                        else:
+                            response_content = str(func_resp)
+
+                        # function_response 表示工具返回结果
+                        canonical.append(
+                            CanonicalMessage(
+                                role=MessageRole.TOOL,
+                                content=response_content,
+                                tool_call_id=getattr(func_resp, "id", "call_0"),
+                            )
+                        )
+                        continue
+
+                # 构建消息
+                if text_parts or tool_calls:
+                    content_text = " ".join(text_parts) if text_parts else None
+                    canonical.append(
+                        CanonicalMessage(
+                            role=role,
+                            content=content_text,
+                            tool_calls=tool_calls if tool_calls else None,
+                        )
+                    )
+            else:
+                # 没有 parts，直接使用字符串内容
+                content_text = str(content) if content else None
+                canonical.append(
+                    CanonicalMessage(role=role, content=content_text)
+                )
+
+        return canonical

agentrun/integration/google_adk/model_adapter.py

@@ -0,0 +1,43 @@
+"""Google ADK 模型适配器 / Google ADK Model Adapter
+
+将 CommonModel 包装为 Google ADK BaseLlm。"""
+
+from typing import Any
+
+from agentrun.integration.google_adk.message_adapter import (
+    GoogleADKMessageAdapter,
+)
+from agentrun.integration.utils.adapter import ModelAdapter
+from agentrun.integration.utils.model import CommonModel
+
+
+class GoogleADKModelAdapter(ModelAdapter):
+    """Google ADK 模型适配器 / Google ADK Model Adapter
+
+    将 CommonModel 包装为 Google ADK BaseLlm。"""
+
+    def __init__(self):
+        """初始化适配器，创建内部的消息适配器 / Google ADK Message Adapter"""
+        self._message_adapter = GoogleADKMessageAdapter()
+
+    def wrap_model(self, common_model: CommonModel) -> Any:
+        """包装 CommonModel 为 Google ADK BaseLlm / Google ADK Model Adapter"""
+
+        try:
+            from google.adk.models.lite_llm import LiteLlm  # type: ignore
+        except ImportError as e:
+            raise ImportError(
+                "import google.adk.models.lite_llm failed."
+                "Google ADK may not installed, "
+                "Install it with: pip install google-adk"
+            ) from e
+
+        info = common_model.get_model_info()
+
+        return LiteLlm(
+            model=f"{info.provider or 'openai'}/{info.model}",
+            api_base=info.base_url,
+            api_key=info.api_key,
+            extra_headers=info.headers,
+            stream_options={"include_usage": True},
+        )

agentrun/integration/google_adk/tool_adapter.py

@@ -0,0 +1,25 @@
+"""Google ADK 工具适配器 / Google ADK Tool Adapter
+
+将标准工具定义转换为 Google ADK 函数格式。"""
+
+from typing import List, Optional
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+
+
+class GoogleADKToolAdapter(ToolAdapter):
+    """Google ADK 工具适配器 / Google ADK Tool Adapter
+
+    实现 CanonicalTool → Google ADK 函数的转换。
+        Google ADK 直接使用 Python 函数作为工具。"""
+
+    def get_registered_tool(self, name: str) -> Optional[CanonicalTool]:
+        """根据名称获取最近注册的工具定义 / Google ADK Tool Adapter"""
+        return self._registered_tools.get(name)
+
+    def from_canonical(self, tools: List[CanonicalTool]):
+        """将标准格式转换为 Google ADK 工具 / Google ADK Tool Adapter
+
+        Google ADK 通过函数的类型注解推断参数，需要动态创建带注解的函数。"""
+        return self.function_tools(tools)

agentrun/integration/langchain/__init__.py

@@ -0,0 +1,9 @@
+"""LangChain 集成模块,提供 AgentRun 模型与沙箱的 LangChain 适配。 / LangChain 集成 Module"""
+
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "model",
+    "toolset",
+    "sandbox_toolset",
+]

agentrun/integration/langchain/adapter.py

@@ -0,0 +1,15 @@
+"""LangChain 适配器 / LangChain Adapters
+
+提供 LangChain 框架的消息、工具和模型适配器。"""
+
+from agentrun.integration.langchain.message_adapter import (
+    LangChainMessageAdapter,
+)
+from agentrun.integration.langchain.model_adapter import LangChainModelAdapter
+from agentrun.integration.langchain.tool_adapter import LangChainToolAdapter
+
+__all__ = [
+    "LangChainMessageAdapter",
+    "LangChainToolAdapter",
+    "LangChainModelAdapter",
+]

agentrun/integration/langchain/builtin.py

@@ -0,0 +1,71 @@
+"""LangChain 内置集成函数 / LangChain Built-in Integration Functions
+
+提供快速创建 LangChain 兼容模型和工具的便捷函数。
+Provides convenient functions for quickly creating LangChain-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``。 / LangChain Built-in Integration Functions"""
+
+    m = _model(input=name, **kwargs)
+    return m.to_langchain()
+
+
+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`` 列表。 / LangChain Built-in Integration Functions"""
+
+    ts = _toolset(input=name, config=config)
+    return ts.to_langchain(
+        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,
+    sandbox_idle_timeout_seconds: int = 600,
+    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`` 列表。 / LangChain 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_langchain(
+        prefix=prefix,
+        modify_tool_name=modify_tool_name,
+        filter_tools_by_name=filter_tools_by_name,
+    )

agentrun/integration/langchain/message_adapter.py

@@ -0,0 +1,141 @@
+"""LangChain 消息适配器 / LangChain Message Adapter
+
+将 LangChain BaseMessage 转换为标准格式,供 ModelAdapter 内部使用。
+Converts LangChain BaseMessage to canonical format for internal use by ModelAdapter.
+"""
+
+import json
+from typing import Any, List
+
+from agentrun.integration.utils.adapter import MessageAdapter
+from agentrun.integration.utils.canonical import (
+    CanonicalMessage,
+    CanonicalToolCall,
+    MessageRole,
+)
+
+
+class LangChainMessageAdapter(MessageAdapter):
+    """LangChain 消息适配器 / LangChain Message Adapter
+
+    实现 LangChain BaseMessage → CanonicalMessage 的转换。
+    Implements conversion from LangChain BaseMessage to CanonicalMessage.
+    """
+
+    def to_canonical(self, messages: Any) -> List[CanonicalMessage]:
+        """将 LangChain BaseMessage 转换为标准格式 / LangChain Message Adapter"""
+        try:
+            from langchain_core.messages import (
+                AIMessage,
+                HumanMessage,
+                SystemMessage,
+                ToolMessage,
+            )
+        except ImportError as e:
+            raise ImportError(
+                "LangChain is not installed. "
+                "Install it with: pip install langchain-core"
+            ) from e
+
+        canonical = []
+        for msg in messages:
+            if isinstance(msg, SystemMessage):
+                canonical.append(
+                    CanonicalMessage(
+                        role=MessageRole.SYSTEM,
+                        content=msg.content
+                        if hasattr(msg, "content")
+                        else None,
+                    )
+                )
+            elif isinstance(msg, HumanMessage):
+                canonical.append(
+                    CanonicalMessage(
+                        role=MessageRole.USER,
+                        content=msg.content
+                        if hasattr(msg, "content")
+                        else None,
+                    )
+                )
+            elif isinstance(msg, AIMessage):
+                tool_calls = None
+                if hasattr(msg, "tool_calls") and msg.tool_calls:
+                    tool_calls = []
+                    for call in msg.tool_calls:
+                        # LangChain tool_calls: {"id": ..., "name": ..., "args": ...}
+                        call_id = (
+                            call.get("id")
+                            if isinstance(call, dict)
+                            else getattr(call, "id", "")
+                        )
+                        call_name = (
+                            call.get("name")
+                            if isinstance(call, dict)
+                            else getattr(call, "name", "")
+                        )
+                        call_args = (
+                            call.get("args")
+                            if isinstance(call, dict)
+                            else getattr(call, "args", {})
+                        )
+
+                        # 如果 args 是字符串，尝试解析
+                        if isinstance(call_args, str):
+                            try:
+                                call_args = json.loads(call_args)
+                            except json.JSONDecodeError:
+                                call_args = {}
+
+                        tool_calls.append(
+                            CanonicalToolCall(
+                                id=str(call_id),
+                                name=str(call_name),
+                                arguments=(
+                                    call_args
+                                    if isinstance(call_args, dict)
+                                    else {}
+                                ),
+                            )
+                        )
+
+                canonical.append(
+                    CanonicalMessage(
+                        role=MessageRole.ASSISTANT,
+                        content=msg.content
+                        if hasattr(msg, "content")
+                        else None,
+                        tool_calls=tool_calls,
+                    )
+                )
+            elif isinstance(msg, ToolMessage):
+                content = msg.content
+                if type(content) is not str:
+                    content = str(content)
+
+                canonical.append(
+                    CanonicalMessage(
+                        role=MessageRole.TOOL,
+                        content=content,
+                        tool_call_id=(
+                            msg.tool_call_id
+                            if hasattr(msg, "tool_call_id")
+                            else None
+                        ),
+                    )
+                )
+            else:
+                # 未知消息类型，尝试提取基本信息
+                role_str = getattr(msg, "type", "user").lower()
+                if "system" in role_str:
+                    role = MessageRole.SYSTEM
+                elif "assistant" in role_str or "ai" in role_str:
+                    role = MessageRole.ASSISTANT
+                elif "tool" in role_str:
+                    role = MessageRole.TOOL
+                else:
+                    role = MessageRole.USER
+
+                content = getattr(msg, "content", None)
+                canonical.append(CanonicalMessage(role=role, content=content))
+
+        return canonical

agentrun/integration/langchain/model_adapter.py

@@ -0,0 +1,37 @@
+"""LangChain 模型适配器 / LangChain Model Adapter
+
+将 CommonModel 包装为 LangChain BaseChatModel。"""
+
+import inspect
+import json
+from typing import Any, List, Optional
+
+from agentrun.integration.langchain.message_adapter import (
+    LangChainMessageAdapter,
+)
+from agentrun.integration.utils.adapter import ModelAdapter
+
+
+class LangChainModelAdapter(ModelAdapter):
+    """LangChain 模型适配器 / LangChain Model Adapter
+
+    将 CommonModel 包装为 LangChain BaseChatModel。"""
+
+    def __init__(self):
+        """初始化适配器，创建内部的消息适配器 / LangChain Message Adapter"""
+        self._message_adapter = LangChainMessageAdapter()
+
+    def wrap_model(self, common_model: Any) -> Any:
+        """包装 CommonModel 为 LangChain BaseChatModel / LangChain Model Adapter"""
+        from httpx import AsyncClient
+        from langchain_openai import ChatOpenAI
+
+        info = common_model.get_model_info()  # 确保模型可用
+        return ChatOpenAI(
+            name=info.model,
+            api_key=info.api_key,
+            model=info.model,
+            base_url=info.base_url,
+            async_client=AsyncClient(headers=info.headers),
+            stream_usage=True,
+        )

agentrun/integration/langchain/tool_adapter.py

@@ -0,0 +1,50 @@
+"""LangChain 工具适配器 / LangChain Tool Adapter
+
+将标准工具定义转换为 LangChain StructuredTool 格式。"""
+
+from typing import Any, List
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+
+
+class LangChainToolAdapter(ToolAdapter):
+    """LangChain 工具适配器 / LangChain Tool Adapter
+
+    实现 CanonicalTool → LangChain StructuredTool 的转换。"""
+
+    def from_canonical(self, tools: List[CanonicalTool]) -> Any:
+        """将标准格式转换为 LangChain StructuredTool / LangChain Tool Adapter"""
+        try:
+            from langchain_core.tools import StructuredTool
+        except ImportError as e:
+            raise ImportError(
+                "LangChain is not installed. "
+                "Install it with: pip install langchain-core"
+            ) from e
+
+        from agentrun.integration.utils.tool import _json_schema_to_pydantic
+
+        result = []
+        for tool in tools:
+            # 从 JSON Schema 创建 Pydantic 模型
+            args_schema = _json_schema_to_pydantic(
+                f"{tool.name}_Args", tool.parameters
+            )
+
+            if args_schema is None:
+                # 如果无法创建 schema，使用空模型
+                from pydantic import create_model
+
+                args_schema = create_model(f"{tool.name}_Args")
+
+            result.append(
+                StructuredTool.from_function(
+                    func=tool.func,
+                    name=tool.name,
+                    description=tool.description,
+                    args_schema=args_schema,
+                )
+            )
+
+        return result

agentrun/integration/langgraph/__init__.py

@@ -0,0 +1,13 @@
+"""LangGraph 集成模块。 / LangGraph 集成 Module
+
+提供 AgentRun 模型与沙箱工具的 LangGraph 适配入口。 / 提供 AgentRun 模型with沙箱工具的 LangGraph 适配入口。
+LangGraph 与 LangChain 兼容，因此直接复用 LangChain 的转换逻辑。 / LangGraph with LangChain 兼容，因此直接复用 LangChain 的转换逻辑。
+"""
+
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "model",
+    "toolset",
+    "sandbox_toolset",
+]

agentrun/integration/langgraph/adapter.py

@@ -0,0 +1,20 @@
+"""LangGraph 适配器 / LangGraph Adapters
+
+LangGraph 与 LangChain 完全兼容，因此直接复用 LangChain 的适配器。"""
+
+from agentrun.integration.langchain.adapter import (
+    LangChainMessageAdapter,
+    LangChainModelAdapter,
+    LangChainToolAdapter,
+)
+
+# LangGraph 使用与 LangChain 相同的适配器
+LangGraphMessageAdapter = LangChainMessageAdapter
+LangGraphToolAdapter = LangChainToolAdapter
+LangGraphModelAdapter = LangChainModelAdapter
+
+__all__ = [
+    "LangGraphMessageAdapter",
+    "LangGraphToolAdapter",
+    "LangGraphModelAdapter",
+]

agentrun/integration/langgraph/builtin.py

@@ -0,0 +1,65 @@
+"""LangGraph 内置集成函数 / LangGraph Built-in Integration Functions
+
+提供快速创建 LangGraph 兼容模型和工具的便捷函数。
+Provides convenient functions for quickly creating LangGraph-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``。 / LangGraph Built-in Integration Functions"""
+
+    m = _model(input=name, **kwargs)  # type: ignore
+    return m.to_langgraph()
+
+
+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`` 列表。 / LangGraph Built-in Integration Functions"""
+
+    ts = _toolset(input=name, config=config)
+    return ts.to_langgraph(
+        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`` 列表。 / LangGraph 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_langgraph(prefix=prefix)

agentrun/integration/pydantic_ai/__init__.py

@@ -0,0 +1,12 @@
+"""PydanticAI 集成模块。 / PydanticAI 集成 Module
+
+提供 AgentRun 模型与沙箱工具的 PydanticAI 适配入口。 / 提供 AgentRun 模型with沙箱工具的 PydanticAI 适配入口。
+"""
+
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "model",
+    "toolset",
+    "sandbox_toolset",
+]

agentrun/integration/pydantic_ai/adapter.py

@@ -0,0 +1,13 @@
+"""PydanticAI 适配器 / PydanticAI Adapters
+
+提供 PydanticAI 框架的工具和模型适配器。"""
+
+from agentrun.integration.pydantic_ai.model_adapter import (
+    PydanticAIModelAdapter,
+)
+from agentrun.integration.pydantic_ai.tool_adapter import PydanticAIToolAdapter
+
+__all__ = [
+    "PydanticAIToolAdapter",
+    "PydanticAIModelAdapter",
+]