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

agentrun/toolset/client.py

@@ -0,0 +1,102 @@
+"""
+This file is auto generated by the code generation script.
+Do not modify this file manually.
+Use the `make codegen` command to regenerate.
+
+当前文件为自动生成的控制 API 客户端代码。请勿手动修改此文件。
+使用 `make codegen` 命令重新生成。
+
+source: agentrun/toolset/__client_async_template.py
+
+ToolSet 客户端 / ToolSet Client
+
+此模块提供工具集的客户端API。
+This module provides the client API for toolsets.
+"""
+
+from typing import Optional
+
+from alibabacloud_devs20230714.models import ListToolsetsRequest
+
+from agentrun.toolset.api.control import ToolControlAPI
+from agentrun.toolset.model import ToolSetListInput
+from agentrun.utils.config import Config
+from agentrun.utils.exception import HTTPError
+
+from .toolset import ToolSet
+
+
+class ToolSetClient:
+    """ToolSet 客户端 / ToolSet Client
+
+    提供工具集的获取和列表功能。
+    Provides get and list functions for toolsets.
+    """
+
+    def __init__(self, config: Optional[Config] = None):
+        """初始化客户端 / Initialize client
+
+        Args:
+            config: 配置对象,可选 / Configuration object, optional
+        """
+        self.__control_api = ToolControlAPI(config)
+
+    async def get_async(
+        self,
+        name: str,
+        config: Optional[Config] = None,
+    ):
+        try:
+            result = await self.__control_api.get_toolset_async(
+                name=name,
+                config=config,
+            )
+        except HTTPError as e:
+            raise e.to_resource_error("ToolSet", name) from e
+
+        return ToolSet.from_inner_object(result)
+
+    def get(
+        self,
+        name: str,
+        config: Optional[Config] = None,
+    ):
+        try:
+            result = self.__control_api.get_toolset(
+                name=name,
+                config=config,
+            )
+        except HTTPError as e:
+            raise e.to_resource_error("ToolSet", name) from e
+
+        return ToolSet.from_inner_object(result)
+
+    async def list_async(
+        self,
+        input: Optional[ToolSetListInput] = None,
+        config: Optional[Config] = None,
+    ):
+        if input is None:
+            input = ToolSetListInput()
+
+        result = await self.__control_api.list_toolsets_async(
+            input=ListToolsetsRequest().from_map(input.model_dump()),
+            config=config,
+        )
+
+        return [ToolSet.from_inner_object(item) for item in result.data]
+
+    def list(
+        self,
+        input: Optional[ToolSetListInput] = None,
+        config: Optional[Config] = None,
+    ):
+        if input is None:
+            input = ToolSetListInput()
+
+        result = self.__control_api.list_toolsets(
+            input=ListToolsetsRequest().from_map(input.model_dump()),
+            config=config,
+        )
+
+        return [ToolSet.from_inner_object(item) for item in result.data]

agentrun/toolset/model.py

@@ -0,0 +1,321 @@
+"""ToolSet 模型定义 / ToolSet Model Definitions
+
+定义工具集相关的数据模型和枚举。
+Defines data models and enumerations related to toolsets.
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from agentrun.utils.model import BaseModel, Field, PageableInput
+
+
+class SchemaType(str, Enum):
+    """Schema 类型 / Schema Type"""
+
+    MCP = "MCP"
+    """MCP 协议 / MCP Protocol"""
+    OpenAPI = "OpenAPI"
+    """OpenAPI 规范 / OpenAPI Specification"""
+
+
+class ToolSetStatusOutputsUrls(BaseModel):
+    internet_url: Optional[str] = None
+    intranet_url: Optional[str] = None
+
+
+class MCPServerConfig(BaseModel):
+    headers: Optional[Dict[str, str]] = None
+    transport_type: Optional[str] = None
+    url: Optional[str] = None
+
+
+class ToolMeta(BaseModel):
+    description: Optional[str] = None
+    input_schema: Optional[Dict[str, Any]] = None
+    name: Optional[str] = None
+
+
+class OpenAPIToolMeta(BaseModel):
+    method: Optional[str] = None
+    path: Optional[str] = None
+    tool_id: Optional[str] = None
+    tool_name: Optional[str] = None
+
+
+class ToolSetStatusOutputs(BaseModel):
+    function_arn: Optional[str] = None
+    mcp_server_config: Optional[MCPServerConfig] = None
+    open_api_tools: Optional[List[OpenAPIToolMeta]] = None
+    tools: Optional[List[ToolMeta]] = None
+    urls: Optional[ToolSetStatusOutputsUrls] = None
+
+
+class APIKeyAuthParameter(BaseModel):
+    encrypted: Optional[bool] = None
+    in_: Optional[str] = None
+    key: Optional[str] = None
+    value: Optional[str] = None
+
+
+class AuthorizationParameters(BaseModel):
+    api_key_parameter: Optional[APIKeyAuthParameter] = None
+
+
+class Authorization(BaseModel):
+    parameters: Optional[AuthorizationParameters] = None
+    type: Optional[str] = None
+
+
+class ToolSetSchema(BaseModel):
+    detail: Optional[str] = None
+    type: Optional[SchemaType] = None
+
+
+class ToolSetSpec(BaseModel):
+    auth_config: Optional[Authorization] = None
+    tool_schema: Optional[ToolSetSchema] = Field(alias="schema", default=None)
+
+
+class ToolSetStatus(BaseModel):
+    observed_generation: Optional[int] = None
+    observed_time: Optional[str] = None
+    outputs: Optional[ToolSetStatusOutputs] = None
+    phase: Optional[str] = None
+
+
+class ToolSetListInput(PageableInput):
+    keyword: Optional[str] = None
+    label_selector: Optional[List[str]] = None
+
+
+class ToolSchema(BaseModel):
+    """JSON Schema 兼容的工具参数描述
+
+    支持完整的 JSON Schema 字段，能够描述复杂的嵌套数据结构。
+    """
+
+    # 基本字段
+    type: Optional[str] = None
+    description: Optional[str] = None
+    title: Optional[str] = None
+
+    # 对象类型字段
+    properties: Optional[Dict[str, "ToolSchema"]] = None
+    required: Optional[List[str]] = None
+    additional_properties: Optional[bool] = None
+
+    # 数组类型字段
+    items: Optional["ToolSchema"] = None
+    min_items: Optional[int] = None
+    max_items: Optional[int] = None
+
+    # 字符串类型字段
+    pattern: Optional[str] = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    format: Optional[str] = None  # date, date-time, email, uri 等
+    enum: Optional[List[Any]] = None
+
+    # 数值类型字段
+    minimum: Optional[float] = None
+    maximum: Optional[float] = None
+    exclusive_minimum: Optional[float] = None
+    exclusive_maximum: Optional[float] = None
+
+    # 联合类型
+    any_of: Optional[List["ToolSchema"]] = None
+    one_of: Optional[List["ToolSchema"]] = None
+    all_of: Optional[List["ToolSchema"]] = None
+
+    # 默认值
+    default: Optional[Any] = None
+
+    @classmethod
+    def from_any_openapi_schema(cls, schema: Any) -> "ToolSchema":
+        """从任意 OpenAPI/JSON Schema 创建 ToolSchema
+
+        递归解析所有嵌套结构，保留完整的 schema 信息。
+        """
+        if not schema or not isinstance(schema, dict):
+            return cls(type="string")
+
+        from pydash import get as pg
+
+        # 解析 properties
+        properties_raw = pg(schema, "properties", {})
+        properties = (
+            {
+                key: cls.from_any_openapi_schema(value)
+                for key, value in properties_raw.items()
+            }
+            if properties_raw
+            else None
+        )
+
+        # 解析 items
+        items_raw = pg(schema, "items")
+        items = cls.from_any_openapi_schema(items_raw) if items_raw else None
+
+        # 解析联合类型
+        any_of_raw = pg(schema, "anyOf")
+        any_of = (
+            [cls.from_any_openapi_schema(s) for s in any_of_raw]
+            if any_of_raw
+            else None
+        )
+
+        one_of_raw = pg(schema, "oneOf")
+        one_of = (
+            [cls.from_any_openapi_schema(s) for s in one_of_raw]
+            if one_of_raw
+            else None
+        )
+
+        all_of_raw = pg(schema, "allOf")
+        all_of = (
+            [cls.from_any_openapi_schema(s) for s in all_of_raw]
+            if all_of_raw
+            else None
+        )
+
+        return cls(
+            # 基本字段
+            type=pg(schema, "type"),
+            description=pg(schema, "description"),
+            title=pg(schema, "title"),
+            # 对象类型
+            properties=properties,
+            required=pg(schema, "required"),
+            additional_properties=pg(schema, "additionalProperties"),
+            # 数组类型
+            items=items,
+            min_items=pg(schema, "minItems"),
+            max_items=pg(schema, "maxItems"),
+            # 字符串类型
+            pattern=pg(schema, "pattern"),
+            min_length=pg(schema, "minLength"),
+            max_length=pg(schema, "maxLength"),
+            format=pg(schema, "format"),
+            enum=pg(schema, "enum"),
+            # 数值类型
+            minimum=pg(schema, "minimum"),
+            maximum=pg(schema, "maximum"),
+            exclusive_minimum=pg(schema, "exclusiveMinimum"),
+            exclusive_maximum=pg(schema, "exclusiveMaximum"),
+            # 联合类型
+            any_of=any_of,
+            one_of=one_of,
+            all_of=all_of,
+            # 默认值
+            default=pg(schema, "default"),
+        )
+
+    def to_json_schema(self) -> Dict[str, Any]:
+        """转换为标准 JSON Schema 格式"""
+        result: Dict[str, Any] = {}
+
+        # 基本字段
+        if self.type:
+            result["type"] = self.type
+        if self.description:
+            result["description"] = self.description
+        if self.title:
+            result["title"] = self.title
+
+        # 对象类型
+        if self.properties:
+            result["properties"] = {
+                k: v.to_json_schema() for k, v in self.properties.items()
+            }
+        if self.required:
+            result["required"] = self.required
+        if self.additional_properties is not None:
+            result["additionalProperties"] = self.additional_properties
+
+        # 数组类型
+        if self.items:
+            result["items"] = self.items.to_json_schema()
+        if self.min_items is not None:
+            result["minItems"] = self.min_items
+        if self.max_items is not None:
+            result["maxItems"] = self.max_items
+
+        # 字符串类型
+        if self.pattern:
+            result["pattern"] = self.pattern
+        if self.min_length is not None:
+            result["minLength"] = self.min_length
+        if self.max_length is not None:
+            result["maxLength"] = self.max_length
+        if self.format:
+            result["format"] = self.format
+        if self.enum:
+            result["enum"] = self.enum
+
+        # 数值类型
+        if self.minimum is not None:
+            result["minimum"] = self.minimum
+        if self.maximum is not None:
+            result["maximum"] = self.maximum
+        if self.exclusive_minimum is not None:
+            result["exclusiveMinimum"] = self.exclusive_minimum
+        if self.exclusive_maximum is not None:
+            result["exclusiveMaximum"] = self.exclusive_maximum
+
+        # 联合类型
+        if self.any_of:
+            result["anyOf"] = [s.to_json_schema() for s in self.any_of]
+        if self.one_of:
+            result["oneOf"] = [s.to_json_schema() for s in self.one_of]
+        if self.all_of:
+            result["allOf"] = [s.to_json_schema() for s in self.all_of]
+
+        # 默认值
+        if self.default is not None:
+            result["default"] = self.default
+
+        return result
+
+
+class ToolInfo(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    parameters: Optional[ToolSchema] = None
+
+    @classmethod
+    def from_mcp_tool(cls, tool: Any):
+        """从 MCP tool 创建 ToolInfo"""
+        if hasattr(tool, "name"):
+            # MCP Tool 对象
+            tool_name = tool.name
+            tool_description = getattr(tool, "description", None)
+            input_schema = getattr(tool, "inputSchema", None) or getattr(
+                tool, "input_schema", None
+            )
+        elif isinstance(tool, dict):
+            # 字典格式
+            tool_name = tool.get("name")
+            tool_description = tool.get("description")
+            input_schema = tool.get("inputSchema") or tool.get("input_schema")
+        else:
+            raise ValueError(f"Unsupported MCP tool format: {type(tool)}")
+
+        if not tool_name:
+            raise ValueError("MCP tool must have a name")
+
+        # 构建 parameters schema
+        parameters = None
+        if input_schema:
+            if isinstance(input_schema, dict):
+                parameters = ToolSchema.from_any_openapi_schema(input_schema)
+            elif hasattr(input_schema, "model_dump"):
+                parameters = ToolSchema.from_any_openapi_schema(
+                    input_schema.model_dump()
+                )
+
+        return cls(
+            name=tool_name,
+            description=tool_description,
+            parameters=parameters or ToolSchema(type="object", properties={}),
+        )

agentrun/toolset/toolset.py

@@ -0,0 +1,270 @@
+"""
+This file is auto generated by the code generation script.
+Do not modify this file manually.
+Use the `make codegen` command to regenerate.
+
+当前文件为自动生成的控制 API 客户端代码。请勿手动修改此文件。
+使用 `make codegen` 命令重新生成。
+
+source: agentrun/toolset/__toolset_async_template.py
+
+ToolSet 资源类 / ToolSet Resource Class
+
+提供工具集资源的面向对象封装和完整生命周期管理。
+Provides object-oriented wrapper and complete lifecycle management for toolset resources.
+"""
+
+from typing import Any, Dict, Optional, Tuple
+
+import pydash
+
+from agentrun.utils.config import Config
+from agentrun.utils.log import logger
+from agentrun.utils.model import BaseModel
+
+from .model import (
+    MCPServerConfig,
+    SchemaType,
+    ToolInfo,
+    ToolSetSpec,
+    ToolSetStatus,
+)
+
+
+class ToolSet(BaseModel):
+    """工具集资源 / ToolSet Resource
+
+    提供工具集的查询、调用等功能。
+    Provides query, invocation and other functionality for toolsets.
+
+    Attributes:
+        created_time: 创建时间 / Creation time
+        description: 描述 / Description
+        generation: 版本号 / Generation number
+        kind: 资源类型 / Resource kind
+        labels: 标签 / Labels
+        name: 工具集名称 / ToolSet name
+        spec: 规格配置 / Specification
+        status: 状态 / Status
+        uid: 唯一标识符 / Unique identifier
+    """
+
+    created_time: Optional[str] = None
+    description: Optional[str] = None
+    generation: Optional[int] = None
+    kind: Optional[str] = None
+    labels: Optional[Dict[str, str]] = None
+    name: Optional[str] = None
+    spec: Optional[ToolSetSpec] = None
+    status: Optional[ToolSetStatus] = None
+    uid: Optional[str] = None
+
+    @classmethod
+    def __get_client(cls, config: Optional[Config] = None):
+        from .client import ToolSetClient
+
+        return ToolSetClient(config)
+
+    @classmethod
+    async def get_by_name_async(
+        cls, name: str, config: Optional[Config] = None
+    ):
+        cli = cls.__get_client(config)
+        return await cli.get_async(name=name)
+
+    @classmethod
+    def get_by_name(cls, name: str, config: Optional[Config] = None):
+        cli = cls.__get_client(config)
+        return cli.get(name=name)
+
+    def type(self):
+        return SchemaType(pydash.get(self, "spec.tool_schema.type", ""))
+
+    def _get_openapi_auth_defaults(
+        self,
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        headers: Dict[str, Any] = {}
+        query: Dict[str, Any] = {}
+
+        auth_config = pydash.get(self, "spec.auth_config", None)
+        auth_type = getattr(auth_config, "type", None) if auth_config else None
+
+        if auth_type == "APIKey":
+            api_key_param = pydash.get(
+                auth_config,
+                "parameters.api_key_parameter",
+                None,
+            )
+            if api_key_param:
+                key = getattr(api_key_param, "key", None)
+                value = getattr(api_key_param, "value", None)
+                location = getattr(api_key_param, "in_", None)
+                if key and value is not None:
+                    if location == "header":
+                        headers[key] = value
+                    elif location == "query":
+                        query[key] = value
+
+        return headers, query
+
+    def _get_openapi_base_url(self) -> Optional[str]:
+        return pydash.get(
+            self,
+            "status.outputs.urls.intranet_url",
+            None,
+        ) or pydash.get(self, "status.outputs.urls.internet_url", None)
+
+    async def get_async(self, config: Optional[Config] = None):
+        if self.name is None:
+            raise ValueError("ToolSet name is required to get the ToolSet.")
+
+        result = await self.get_by_name_async(name=self.name, config=config)
+        return self.update_self(result)
+
+    def get(self, config: Optional[Config] = None):
+        if self.name is None:
+            raise ValueError("ToolSet name is required to get the ToolSet.")
+
+        result = self.get_by_name(name=self.name, config=config)
+        return self.update_self(result)
+
+    async def list_tools_async(self, config: Optional[Config] = None):
+        """异步获取工具列表,返回统一的 ToolInfo 列表"""
+        if self.type() == SchemaType.MCP:
+            mcp_tools = pydash.get(self, "status.outputs.tools", [])
+            return [ToolInfo.from_mcp_tool(tool) for tool in mcp_tools]
+        elif self.type() == SchemaType.OpenAPI:
+            # 直接使用 to_apiset 转换
+            apiset = self.to_apiset(config=config)
+            return apiset.tools()
+        return []
+
+    def list_tools(self, config: Optional[Config] = None):
+        """同步获取工具列表,返回统一的 ToolInfo 列表"""
+        if self.type() == SchemaType.MCP:
+            mcp_tools = pydash.get(self, "status.outputs.tools", [])
+            return [ToolInfo.from_mcp_tool(tool) for tool in mcp_tools]
+        elif self.type() == SchemaType.OpenAPI:
+            # 直接使用 to_apiset 转换
+            apiset = self.to_apiset(config=config)
+            return apiset.tools()
+        return []
+
+    async def call_tool_async(
+        self,
+        name: str,
+        arguments: Optional[Dict[str, str]] = None,
+        config: Optional[Config] = None,
+    ):
+        """异步调用工具,统一使用 ApiSet 实现"""
+        apiset = self.to_apiset(config=config)
+
+        # 对于 OpenAPI,可能需要解析 operation name
+        if self.type() == SchemaType.OpenAPI:
+            # 尝试查找实际的 operation name
+            tool = apiset.get_tool(name)
+            if tool is None:
+                # 尝试通过 tool_id 映射查找
+                openapi_tools = (
+                    pydash.get(self, "status.outputs.open_api_tools", []) or []
+                )
+                for tool_meta in openapi_tools:
+                    if tool_meta is None:
+                        continue
+                    if hasattr(tool_meta, "model_dump"):
+                        tool_meta = tool_meta.model_dump()
+                    if not isinstance(tool_meta, dict):
+                        continue
+                    if tool_meta.get("tool_id") == name:
+                        name = tool_meta.get("tool_name") or name
+                        break
+
+        logger.debug("invoke tool %s with arguments %s", name, arguments)
+        result = await apiset.invoke_async(
+            name=name, arguments=arguments, config=config
+        )
+        logger.debug("invoke tool %s got result %s", name, result)
+        return result
+
+    def call_tool(
+        self,
+        name: str,
+        arguments: Optional[Dict[str, str]] = None,
+        config: Optional[Config] = None,
+    ):
+        """同步调用工具,统一使用 ApiSet 实现"""
+        apiset = self.to_apiset(config=config)
+
+        # 对于 OpenAPI,可能需要解析 operation name
+        if self.type() == SchemaType.OpenAPI:
+            # 尝试查找实际的 operation name
+            tool = apiset.get_tool(name)
+            if tool is None:
+                # 尝试通过 tool_id 映射查找
+                openapi_tools = (
+                    pydash.get(self, "status.outputs.open_api_tools", []) or []
+                )
+                for tool_meta in openapi_tools:
+                    if tool_meta is None:
+                        continue
+                    if hasattr(tool_meta, "model_dump"):
+                        tool_meta = tool_meta.model_dump()
+                    if not isinstance(tool_meta, dict):
+                        continue
+                    if tool_meta.get("tool_id") == name:
+                        name = tool_meta.get("tool_name") or name
+                        break
+
+        logger.debug("invoke tool %s with arguments %s", name, arguments)
+        result = apiset.invoke(name=name, arguments=arguments, config=config)
+        logger.debug("invoke tool %s got result %s", name, result)
+        return result
+
+    def to_apiset(self, config: Optional[Config] = None):
+        """将 ToolSet 转换为统一的 ApiSet 对象
+
+        Returns:
+            ApiSet: 统一的工具集接口
+        """
+        from .api.openapi import ApiSet
+
+        if self.type() == SchemaType.MCP:
+            from .api.mcp import MCPToolSet
+
+            mcp_server_config: MCPServerConfig = pydash.get(
+                self, "status.outputs.mcp_server_config", None
+            )
+            assert (
+                mcp_server_config.url is not None
+            ), "MCP server URL is missing."
+
+            cfg = Config.with_configs(
+                config, Config(headers=mcp_server_config.headers)
+            )
+
+            mcp_client = MCPToolSet(
+                url=mcp_server_config.url,
+                config=cfg,
+            )
+
+            # 获取 MCP tools
+            mcp_tools = pydash.get(self, "status.outputs.tools", [])
+
+            return ApiSet.from_mcp_tools(
+                tools=mcp_tools,
+                mcp_client=mcp_client,
+                config=cfg,
+            )
+
+        elif self.type() == SchemaType.OpenAPI:
+            headers, query = self._get_openapi_auth_defaults()
+
+            return ApiSet.from_openapi_schema(
+                schema=pydash.get(self, "spec.tool_schema.detail", None),
+                base_url=self._get_openapi_base_url(),
+                headers=headers,
+                query_params=query,
+                config=config,
+            )
+
+        raise ValueError(f"Unsupported ToolSet type: {self.type()}")