agentrun-sdk 0.0.4__py3-none-any.whl

agentrun/integration/builtin/model.py

@@ -0,0 +1,97 @@
+"""内置模型集成函数 / Built-in Model Integration Functions
+
+提供快速创建通用模型对象的便捷函数。
+Provides convenient functions for quickly creating common model objects.
+"""
+
+from typing import Optional, overload, TypedDict, Union
+
+from typing_extensions import NotRequired, Unpack
+
+from agentrun.integration.utils.model import CommonModel
+from agentrun.model import ModelService
+from agentrun.model.model import BackendType
+from agentrun.model.model_proxy import ModelProxy
+from agentrun.utils.config import Config
+
+
+class ModelArgs(TypedDict):
+    model: NotRequired[Optional[str]]
+    backend_type: NotRequired[Optional[BackendType]]
+    config: NotRequired[Optional[Config]]
+
+
+@overload
+def model(input: ModelService, **kwargs: Unpack[ModelArgs]) -> CommonModel:
+    ...
+
+
+@overload
+def model(input: ModelProxy, **kwargs: Unpack[ModelArgs]) -> CommonModel:
+    ...
+
+
+@overload
+def model(input: str, **kwargs: Unpack[ModelArgs]) -> CommonModel:
+    ...
+
+
+def model(
+    input: Union[str, ModelProxy, ModelService], **kwargs: Unpack[ModelArgs]
+) -> CommonModel:
+    """获取 AgentRun 模型并封装为通用 Model 对象 / Get AgentRun model and wrap as CommonModel
+
+    等价于 ModelClient.get(),但返回通用 Model 对象。
+    Equivalent to ModelClient.get(), but returns a CommonModel object.
+
+    Args:
+        input: AgentRun 模型名称、ModelProxy 或 ModelService 实例 / Model name, ModelProxy or ModelService instance
+        model: 要请求的模型名称（默认请求数组的第一个模型或模型治理的自动负载均衡模型） / Model name to request (defaults to the first model in the array or the auto-load balancing model of model governance)
+        backend_type: 后端类型(PROXY 或 SERVICE) / Backend type (PROXY or SERVICE)
+        config: 配置对象 / Configuration object
+
+    Returns:
+        CommonModel: 通用模型实例 / CommonModel instance
+
+    Examples:
+        >>> # 从模型名称创建 / Create from model name
+        >>> m = model("qwen-max")
+        >>>
+        >>> # 从 ModelProxy 创建 / Create from ModelProxy
+        >>> proxy = ModelProxy.get_by_name("my-proxy")
+        >>> m = model(proxy)
+        >>>
+        >>> # 从 ModelService 创建 / Create from ModelService
+        >>> service = ModelService.get_by_name("my-service")
+        >>> m = model(service)
+    """
+    config = kwargs.get("config")
+    backend_type = kwargs.get("backend_type")
+    model = kwargs.get("model")
+
+    if isinstance(input, ModelProxy):
+        return CommonModel(
+            model=model or "",
+            model_obj=input,
+            backend_type=BackendType.PROXY,
+            config=config,
+        )
+    elif isinstance(input, ModelService):
+        return CommonModel(
+            model=model or "",
+            model_obj=input,
+            backend_type=BackendType.SERVICE,
+            config=config,
+        )
+
+    from agentrun.model.client import ModelClient
+
+    client = ModelClient(config=config)
+    model_obj = client.get(name=input, backend_type=backend_type, config=config)
+
+    return CommonModel(
+        model=input,
+        model_obj=model_obj,
+        backend_type=backend_type,
+        config=config,
+    )

agentrun/integration/builtin/sandbox.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import atexit
+import threading
+import time
+from typing import Any, Callable, Dict, Optional
+
+from agentrun.integration.utils.tool import CommonToolSet, tool
+from agentrun.sandbox import Sandbox, TemplateType
+from agentrun.sandbox.browser_sandbox import BrowserSandbox
+from agentrun.sandbox.client import SandboxClient
+from agentrun.sandbox.code_interpreter_sandbox import CodeInterpreterSandbox
+from agentrun.utils.config import Config
+from agentrun.utils.log import logger
+
+
+class SandboxToolSet(CommonToolSet):
+
+    def __init__(
+        self,
+        template_name: str,
+        template_type: TemplateType,
+        *,
+        sandbox_idle_timeout_seconds: int,
+        config: Optional[Config],
+    ):
+        super().__init__()
+
+        self.config = config
+        self.client = SandboxClient(config)
+        self.lock = threading.Lock()
+
+        self.template_name = template_name
+        self.template_type = template_type
+        self.sandbox_idle_timeout_seconds = sandbox_idle_timeout_seconds
+
+        self.sandbox: Optional[Sandbox] = None
+        self.sandbox_id = ""
+
+    def close(self):
+        if self.sandbox:
+            try:
+                self.sandbox.stop()
+            except Exception as e:
+                logger.debug("delete sandbox failed, due to %s", e)
+
+    def _ensure_sandbox(self):
+        # 先确定当前是否有 sandbox，如果有的话提供这个
+        if self.sandbox is not None:
+            return self.sandbox
+
+        # 如果没有，则创建一个新的 Sandbox
+        with self.lock:
+            if self.sandbox is None:
+                self.sandbox = Sandbox.create(
+                    template_type=self.template_type,
+                    template_name=self.template_name,
+                    sandbox_idle_timeout_seconds=self.sandbox_idle_timeout_seconds,
+                    config=self.config,
+                )
+                self.sandbox_id = self.sandbox.sandbox_id
+                self.sandbox.__enter__()
+
+        return self.sandbox
+
+    def _run_in_sandbox(self, callback: Callable[[Sandbox], Any]):
+        sb = self._ensure_sandbox()
+        try:
+            return callback(sb)
+        except Exception as e:
+            try:
+                logger.debug(
+                    "run in sandbox failed, due to %s, try to re-create"
+                    " sandbox",
+                    e,
+                )
+
+                self.sandbox = None
+                sb = self._ensure_sandbox()
+                return callback(sb)
+            except Exception as e2:
+                logger.debug("re-created sandbox run failed, due to %s", e2)
+                return {"error": f"{e!s}"}
+
+
+class CodeInterpreterToolSet(SandboxToolSet):
+    """LangChain 代码沙箱工具适配器。"""
+
+    def __init__(
+        self,
+        template_name: str,
+        config: Optional[Config],
+        sandbox_idle_timeout_seconds: int,
+    ) -> None:
+        super().__init__(
+            template_name=template_name,
+            template_type=TemplateType.CODE_INTERPRETER,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            config=config,
+        )
+
+    @tool()
+    def execute_code(
+        self,
+        code: str,
+        language: str = "python",
+        timeout: int = 60,
+    ) -> Dict[str, Any]:
+        "在指定的 Code Interpreter 沙箱中执行代码"
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, CodeInterpreterSandbox)
+            with sb.context.create() as ctx:
+                try:
+                    result = ctx.execute(code=code, timeout=timeout)
+                finally:
+                    try:
+                        ctx.delete()
+                    except Exception:
+                        pass
+                return {
+                    "stdout": result.get("stdout"),
+                    "stderr": result.get("stderr"),
+                    "raw": result,
+                }
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def list_directory(self, path: str = "/") -> Dict[str, Any]:
+        """列出沙箱中的文件"""
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, CodeInterpreterSandbox)
+            return {
+                "path": path,
+                "entries": sb.file_system.list(path=path),
+            }
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def read_file(self, path: str) -> Dict[str, Any]:
+        """读取沙箱文件内容"""
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, CodeInterpreterSandbox)
+            return {
+                "path": path,
+                "content": sb.file.read(path=path),
+            }
+
+        return self._run_in_sandbox(inner)
+
+    @tool(
+        name="sandbox_write_file",
+        description="向沙箱写入文本文件",
+    )
+    def write_file(self, path: str, content: str) -> Dict[str, Any]:
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, CodeInterpreterSandbox)
+            return {
+                "path": path,
+                "result": sb.file.write(path=path, content=content),
+            }
+
+        return self._run_in_sandbox(inner)
+
+
+class BrowserToolSet(SandboxToolSet):
+    """LangChain 浏览器工具适配器。"""
+
+    def __init__(
+        self,
+        template_name: str,
+        config: Optional[Config],
+        sandbox_idle_timeout_seconds: int,
+    ) -> None:
+
+        super().__init__(
+            template_name=template_name,
+            template_type=TemplateType.BROWSER,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            config=config,
+        )
+
+    @tool()
+    def goto(self, url: str):
+        """导航到 URL"""
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, BrowserSandbox)
+            with sb.sync_playwright() as p:
+                return p.goto(url)
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def html_content(
+        self,
+    ):
+        """获取页面 html 内容"""
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, BrowserSandbox)
+            with sb.sync_playwright() as p:
+                return p.html_content()
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def fill(self, selector: str, value: str):
+        """在页面中填充输入框"""
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, BrowserSandbox)
+            with sb.sync_playwright() as p:
+                return p.fill(selector, value)
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def click(self, selector: str):
+        """
+        在网页上执行点击操作
+
+        Args:
+            selector: 要点击的元素选择器
+        """
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, BrowserSandbox)
+            with sb.sync_playwright() as p:
+                return p.click(selector)
+
+        return self._run_in_sandbox(inner)
+
+    @tool()
+    def evaluate(self, expression: str):
+        """
+        在网页上执行 js 脚本
+
+        Args:
+            expression: 要执行的脚本
+        """
+
+        def inner(sb: Sandbox):
+            assert isinstance(sb, BrowserSandbox)
+            with sb.sync_playwright() as p:
+                return p.evaluate(expression)
+
+        return self._run_in_sandbox(inner)
+
+
+def sandbox_toolset(
+    template_name: str,
+    *,
+    template_type: TemplateType = TemplateType.CODE_INTERPRETER,
+    config: Optional[Config] = None,
+    sandbox_idle_timeout_seconds: int = 5 * 60,
+) -> CommonToolSet:
+    """将沙箱模板封装为 LangChain ``StructuredTool`` 列表。"""
+
+    if template_type != TemplateType.CODE_INTERPRETER:
+        return BrowserToolSet(
+            template_name=template_name,
+            config=config,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+        )
+    else:
+        return CodeInterpreterToolSet(
+            template_name=template_name,
+            config=config,
+            sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+        )

agentrun/integration/builtin/toolset.py

@@ -0,0 +1,47 @@
+"""内置工具集集成函数 / Built-in ToolSet Integration Functions
+
+提供快速创建通用工具集对象的便捷函数。
+Provides convenient functions for quickly creating common toolset objects.
+"""
+
+from typing import Optional, Union
+
+from agentrun.integration.utils.tool import CommonToolSet
+from agentrun.toolset import ToolSet, ToolSetClient
+from agentrun.utils.config import Config
+
+
+def toolset(
+    input: Union[str, ToolSet], config: Optional[Config] = None
+) -> CommonToolSet:
+    """将内置工具集封装为通用工具集 / Wrap built-in toolset as CommonToolSet
+
+    支持从工具集名称或 ToolSet 实例创建通用工具集。
+    Supports creating CommonToolSet from toolset name or ToolSet instance.
+
+    Args:
+        input: 工具集名称或 ToolSet 实例 / Toolset name or ToolSet instance
+        config: 配置对象 / Configuration object
+
+    Returns:
+        CommonToolSet: 通用工具集实例 / CommonToolSet instance
+
+    Examples:
+        >>> # 从工具集名称创建 / Create from toolset name
+        >>> ts = toolset("my-toolset")
+        >>>
+        >>> # 从 ToolSet 实例创建 / Create from ToolSet instance
+        >>> toolset_obj = ToolSetClient().get("my-toolset")
+        >>> ts = toolset(toolset_obj)
+        >>>
+        >>> # 转换为 LangChain 工具 / Convert to LangChain tools
+        >>> lc_tools = ts.to_langchain()
+    """
+
+    toolset = (
+        input
+        if isinstance(input, ToolSet)
+        else ToolSetClient().get(name=input, config=config)
+    )
+
+    return CommonToolSet.from_agentrun_toolset(toolset, config=config)

agentrun/integration/crewai/__init__.py

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

agentrun/integration/crewai/adapter.py

@@ -0,0 +1,9 @@
+"""CrewAI 适配器 / CrewAI Adapters"""
+
+from .model_adapter import CrewAIModelAdapter
+from .tool_adapter import CrewAIToolAdapter
+
+__all__ = [
+    "CrewAIToolAdapter",
+    "CrewAIModelAdapter",
+]

agentrun/integration/crewai/builtin.py

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

agentrun/integration/crewai/model_adapter.py

@@ -0,0 +1,27 @@
+"""LangChain 模型适配器 / CrewAI Model Adapter
+
+将 CommonModel 包装为 LangChain BaseChatModel。"""
+
+from typing import Any
+
+from agentrun.integration.utils.adapter import ModelAdapter
+
+
+class CrewAIModelAdapter(ModelAdapter):
+    """CrewAI 模型适配器 / CrewAI Model Adapter
+
+    将 CommonModel 包装为 CrewAI BaseChatModel。"""
+
+    def wrap_model(self, common_model: Any) -> Any:
+        """包装 CommonModel 为 CrewAI BaseChatModel / CrewAI Model Adapter"""
+        from crewai import LLM
+
+        info = common_model.get_model_info()  # 确保模型可用
+        return LLM(
+            api_key=info.api_key,
+            model=f"{info.provider or 'openai'}/{info.model}",
+            base_url=info.base_url,
+            default_headers=info.headers,
+            stream_options={"include_usage": True},
+            # async_client=AsyncClient(headers=info.headers),
+        )

agentrun/integration/crewai/tool_adapter.py

@@ -0,0 +1,26 @@
+"""LangChain 工具适配器 / CrewAI Tool Adapter
+
+将标准工具定义转换为 LangChain StructuredTool 格式。"""
+
+from typing import Any, List
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+
+
+class CrewAIToolAdapter(ToolAdapter):
+    """CrewAI 工具适配器 / CrewAI Tool Adapter
+
+    实现 CanonicalTool → CrewAI StructuredTool 的转换。"""
+
+    def from_canonical(self, tools: List[CanonicalTool]) -> Any:
+        """将标准格式转换为 CrewAI StructuredTool / CrewAI Tool Adapter"""
+        try:
+            from crewai.tools import tool
+        except ImportError as e:
+            raise ImportError(
+                "LangChain is not installed. "
+                "Install it with: pip install langchain-core"
+            ) from e
+
+        return [tool(t) for t in self.function_tools(tools)]

agentrun/integration/google_adk/__init__.py

@@ -0,0 +1,12 @@
+"""Google ADK 集成模块。 / Google ADK 集成 Module
+
+提供与 Google Agent Development Kit 的模型与沙箱工具集成。 / 提供with Google Agent Development Kit 的模型with沙箱工具集成。
+"""
+
+from .builtin import model, sandbox_toolset, toolset
+
+__all__ = [
+    "model",
+    "toolset",
+    "sandbox_toolset",
+]

agentrun/integration/google_adk/adapter.py

@@ -0,0 +1,15 @@
+"""Google ADK 适配器 / Google ADK Adapters
+
+提供 Google ADK 框架的消息、工具和模型适配器。"""
+
+from agentrun.integration.google_adk.message_adapter import (
+    GoogleADKMessageAdapter,
+)
+from agentrun.integration.google_adk.model_adapter import GoogleADKModelAdapter
+from agentrun.integration.google_adk.tool_adapter import GoogleADKToolAdapter
+
+__all__ = [
+    "GoogleADKMessageAdapter",
+    "GoogleADKToolAdapter",
+    "GoogleADKModelAdapter",
+]

agentrun/integration/google_adk/builtin.py

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