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

agentrun/integration/google_adk/tool_adapter.py

@@ -0,0 +1,235 @@
+"""Google ADK 工具适配器 / Google ADK Tool Adapter
+
+将标准工具定义转换为 Google ADK 函数格式。"""
+
+from typing import Any, Dict, List, Optional
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+from agentrun.integration.utils.tool import normalize_tool_name
+
+
+def _json_schema_to_google_schema(
+    schema: Dict[str, Any],
+    root_schema: Optional[Dict[str, Any]] = None,
+) -> Any:
+    """将 JSON Schema 转换为 Google ADK Schema
+
+    Google ADK 不支持 $ref 和 $defs，所以需要内联所有引用。
+
+    Args:
+        schema: JSON Schema 定义
+        root_schema: 根 schema，用于解析 $ref 引用
+
+    Returns:
+        Google ADK types.Schema 对象
+    """
+    from google.genai import types
+
+    if not schema or not isinstance(schema, dict):
+        return types.Schema(type=types.Type.OBJECT)
+
+    if root_schema is None:
+        root_schema = schema
+
+    # 处理 $ref 引用
+    if "$ref" in schema:
+        ref = schema["$ref"]
+        resolved = _resolve_schema_ref(ref, root_schema)
+        if resolved:
+            return _json_schema_to_google_schema(resolved, root_schema)
+        return types.Schema(type=types.Type.OBJECT)
+
+    schema_type = schema.get("type")
+    description = schema.get("description")
+
+    # 类型映射
+    type_mapping = {
+        "string": types.Type.STRING,
+        "integer": types.Type.INTEGER,
+        "number": types.Type.NUMBER,
+        "boolean": types.Type.BOOLEAN,
+        "array": types.Type.ARRAY,
+        "object": types.Type.OBJECT,
+    }
+
+    google_type = type_mapping.get(
+        str(schema_type or "object"), types.Type.OBJECT
+    )
+
+    # 处理数组类型
+    if schema_type == "array":
+        items_schema = schema.get("items")
+        items = None
+        if items_schema:
+            items = _json_schema_to_google_schema(items_schema, root_schema)
+        return types.Schema(
+            type=google_type,
+            description=description,
+            items=items,
+        )
+
+    # 处理对象类型
+    if schema_type == "object":
+        props = schema.get("properties", {})
+        required = schema.get("required", [])
+
+        google_props = {}
+        for prop_name, prop_schema in props.items():
+            google_props[prop_name] = _json_schema_to_google_schema(
+                prop_schema, root_schema
+            )
+
+        return types.Schema(
+            type=google_type,
+            description=description,
+            properties=google_props if google_props else None,
+            required=required if required else None,
+        )
+
+    # 基本类型
+    return types.Schema(
+        type=google_type,
+        description=description,
+    )
+
+
+def _resolve_schema_ref(
+    ref: str, root_schema: Dict[str, Any]
+) -> Optional[Dict[str, Any]]:
+    """解析 JSON Schema $ref 引用
+
+    Args:
+        ref: $ref 字符串，如 "#/$defs/MyType" 或 "#/definitions/MyType"
+        root_schema: 根 schema，包含 $defs 或 definitions
+
+    Returns:
+        解析后的 schema，如果无法解析则返回 None
+    """
+    if not ref or not ref.startswith("#/"):
+        return None
+
+    # 解析路径，如 "#/$defs/MyType" -> ["$defs", "MyType"]
+    path_parts = ref[2:].split("/")
+    current = root_schema
+
+    for part in path_parts:
+        if not isinstance(current, dict) or part not in current:
+            return None
+        current = current[part]
+
+    return current if isinstance(current, dict) else None
+
+
+def _create_custom_function_tool_class():
+    """创建自定义 FunctionTool 类
+
+    延迟创建以避免在模块导入时依赖 google.adk。
+    """
+    from google.adk.tools.base_tool import BaseTool
+
+    class CustomFunctionTool(BaseTool):
+        """自定义 Google ADK 工具类
+
+        允许手动指定 FunctionDeclaration，避免 Pydantic 模型的 $ref 问题。
+        继承自 google.adk.tools.BaseTool 以确保与 ADK Agent 兼容。
+        """
+
+        def __init__(
+            self,
+            func,
+            declaration,
+        ):
+            # 调用父类 __init__，传递 name 和 description
+            super().__init__(
+                name=declaration.name,
+                description=declaration.description or "",
+            )
+            self._func = func
+            self._declaration = declaration
+
+        def _get_declaration(self):
+            return self._declaration
+
+        async def run_async(self, *, args: Dict[str, Any], tool_context):
+            """异步执行工具函数"""
+            return self._func(**args)
+
+    return CustomFunctionTool
+
+
+# 缓存类，避免重复创建
+_CustomFunctionToolClass = None
+
+
+def _get_custom_function_tool_class():
+    """获取 CustomFunctionTool 类（延迟加载）"""
+    global _CustomFunctionToolClass
+    if _CustomFunctionToolClass is None:
+        _CustomFunctionToolClass = _create_custom_function_tool_class()
+    return _CustomFunctionToolClass
+
+
+class GoogleADKToolAdapter(ToolAdapter):
+    """Google ADK 工具适配器 / Google ADK Tool Adapter
+
+    实现 CanonicalTool → Google ADK 函数的转换。
+    由于 Google ADK 不支持复杂的 JSON Schema（包含 $ref 和 $defs），
+    此适配器会手动构建 FunctionDeclaration 并使用自定义工具类。
+    """
+
+    def get_registered_tool(self, name: str) -> Optional[CanonicalTool]:
+        """根据名称获取最近注册的工具定义 / Google ADK Tool Adapter"""
+        return self._registered_tools.get(normalize_tool_name(name))
+
+    def from_canonical(self, tools: List[CanonicalTool]):
+        """将标准格式转换为 Google ADK 工具 / Google ADK Tool Adapter
+
+        为每个工具创建自定义的 FunctionTool，手动指定参数 schema，
+        以避免 Pydantic 模型产生的 $ref 问题。
+        """
+        from google.genai import types
+
+        result = []
+
+        for tool in tools:
+            # 记录工具定义
+            self._registered_tools[tool.name] = tool
+
+            # 从 parameters schema 构建 Google ADK Schema
+            parameters_schema = tool.parameters or {
+                "type": "object",
+                "properties": {},
+            }
+
+            google_schema = _json_schema_to_google_schema(
+                parameters_schema, parameters_schema
+            )
+
+            # 创建 FunctionDeclaration
+            declaration = types.FunctionDeclaration(
+                name=normalize_tool_name(tool.name),
+                description=tool.description or "",
+                parameters=google_schema,
+            )
+
+            # 创建包装函数
+            def make_wrapper(canonical_tool: CanonicalTool):
+                def wrapper(**kwargs):
+                    if canonical_tool.func is None:
+                        raise NotImplementedError(
+                            f"Tool function for '{canonical_tool.name}' "
+                            "is not implemented."
+                        )
+                    return canonical_tool.func(**kwargs)
+
+                return wrapper
+
+            wrapper_func = make_wrapper(tool)
+
+            # 创建自定义工具
+            CustomFunctionTool = _get_custom_function_tool_class()
+            custom_tool = CustomFunctionTool(wrapper_func, declaration)
+            result.append(custom_tool)
+
+        return result

agentrun/integration/langchain/__init__.py

@@ -0,0 +1,30 @@
+"""LangChain 集成模块
+
+使用 AgentRunConverter 将 LangChain 事件转换为 AG-UI 协议事件：
+
+    >>> from agentrun.integration.langchain import AgentRunConverter
+    >>>
+    >>> async def invoke_agent(request: AgentRequest):
+    ...     converter = AgentRunConverter()
+    ...     async for event in agent.astream_events(input_data, version="v2"):
+    ...         for item in converter.convert(event):
+    ...             yield item
+
+支持多种调用方式：
+- agent.astream_events(input, version="v2") - 支持 token by token
+- agent.stream(input, stream_mode="updates") - 按节点输出
+- agent.astream(input, stream_mode="updates") - 异步按节点输出
+"""
+
+from agentrun.integration.langgraph.agent_converter import (
+    AgentRunConverter,
+)  # 向后兼容
+
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "AgentRunConverter",
+    "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 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,
+            default_headers=info.headers,
+            stream_usage=True,
+            streaming=True,  # 启用流式输出以支持 token by token
+        )

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,35 @@
+"""LangGraph 集成模块
+
+使用 AgentRunConverter 将 LangGraph 事件转换为 AG-UI 协议事件：
+
+    >>> from agentrun.integration.langgraph import AgentRunConverter
+    >>>
+    >>> async def invoke_agent(request: AgentRequest):
+    ...     converter = AgentRunConverter()
+    ...     async for event in agent.astream_events(input_data, version="v2"):
+    ...         for item in converter.convert(event):
+    ...             yield item
+
+或使用静态方法（无状态）：
+
+    >>> from agentrun.integration.langgraph import AgentRunConverter
+    >>>
+    >>> async for event in agent.astream_events(input_data, version="v2"):
+    ...     for item in AgentRunConverter.to_agui_events(event):
+    ...         yield item
+
+支持多种调用方式：
+- agent.astream_events(input, version="v2") - 支持 token by token
+- agent.stream(input, stream_mode="updates") - 按节点输出
+- agent.astream(input, stream_mode="updates") - 异步按节点输出
+"""
+
+from .agent_converter import AgentRunConverter
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "AgentRunConverter",
+    "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",
+]