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

agentrun/credential/model.py

@@ -0,0 +1,248 @@
+"""Credential 模型定义 / Credential Model Definitions
+
+定义凭证相关的数据模型和枚举。
+Defines data models and enumerations related to credentials.
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from agentrun.utils.config import Config
+from agentrun.utils.model import BaseModel, PageableInput
+
+
+class CredentialAuthType(str, Enum):
+    """凭证认证类型 / Credential Authentication Type"""
+
+    JWT = "jwt"
+    API_KEY = "api_key"
+    BASIC = "basic"
+    AKSK = "ak_sk"
+    CUSTOM_HEADER = "custom_header"
+
+
+class CredentialSourceType(str, Enum):
+    """凭证来源类型 / Credential Source Type"""
+
+    LLM = "external_llm"
+    """模型凭证"""
+    TOOL = "external_tool"
+    """工具凭证"""
+    INTERNAL = "internal"
+    """自定义凭证"""
+
+
+class CredentialBasicAuth(BaseModel):
+    username: Optional[str]
+    password: Optional[str]
+
+
+class RelatedResource(BaseModel):
+    resource_id: Optional[str] = None
+    """资源 ID"""
+    resource_name: Optional[str] = None
+    """资源名称"""
+    resource_type: Optional[str] = None
+    """资源类型"""
+
+
+class CredentialConfigInner(BaseModel):
+    credential_auth_type: Optional[CredentialAuthType] = None
+    """凭证认证类型"""
+    credential_source_type: Optional[CredentialSourceType] = None
+    """凭证来源类型"""
+    credential_public_config: Optional[Dict[str, Any]] = None
+    """凭证公共配置"""
+    credential_secret: Optional[str] = None
+    """凭证密钥"""
+
+
+class CredentialConfig(CredentialConfigInner):
+    """凭证配置"""
+
+    @classmethod
+    def inbound_api_key(cls, api_key: str, header_key: str = "Authorization"):
+        """配置访问 AgentRun 的 api key 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.INTERNAL,
+            credential_auth_type=CredentialAuthType.API_KEY,
+            credential_public_config={"headerKey": header_key},
+            credential_secret=api_key,
+        )
+
+    @classmethod
+    def inbound_static_jwt(cls, jwks: str):
+        """配置访问 AgentRun 的静态 JWKS 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.INTERNAL,
+            credential_auth_type=CredentialAuthType.JWT,
+            credential_public_config={"authType": "static_jwks", "jwks": jwks},
+            credential_secret="",
+        )
+
+    @classmethod
+    def inbound_remote_jwt(
+        cls, uri: str, timeout: int = 3000, ttl: int = 30000, **kwargs
+    ):
+        """配置访问 AgentRun 的远程 JWT 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.INTERNAL,
+            credential_auth_type=CredentialAuthType.JWT,
+            credential_public_config={
+                "uri": uri,
+                "timeout": timeout,
+                "ttl": ttl,
+                **kwargs,
+            },
+            credential_secret="",
+        )
+
+    @classmethod
+    def inbound_basic(cls, users: List[CredentialBasicAuth]):
+        """配置访问 AgentRun 的 Basic 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.INTERNAL,
+            credential_auth_type=CredentialAuthType.BASIC,
+            credential_public_config={
+                "users": [user.model_dump() for user in users]
+            },
+            credential_secret="",
+        )
+
+    @classmethod
+    def outbound_llm_api_key(cls, api_key: str, provider: str):
+        """配置访问第三方模型的 api key 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.LLM,
+            credential_auth_type=CredentialAuthType.API_KEY,
+            credential_public_config={"provider": provider},
+            credential_secret=api_key,
+        )
+
+    @classmethod
+    def outbound_tool_api_key(cls, api_key: str):
+        """配置访问第三方工具的 api key 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.TOOL,
+            credential_auth_type=CredentialAuthType.API_KEY,
+            credential_public_config={},
+            credential_secret=api_key,
+        )
+
+    @classmethod
+    def outbound_tool_ak_sk(
+        cls,
+        provider: str,
+        access_key_id: str,
+        access_key_secret: str,
+        account_id: str,
+    ):
+        """配置访问第三方工具的 ak/sk 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.TOOL,
+            credential_auth_type=CredentialAuthType.AKSK,
+            credential_public_config={
+                "provider": provider,
+                "authConfig": {
+                    "accessKey": access_key_id,
+                    "accountId": account_id,
+                },
+            },
+            credential_secret=access_key_secret,
+        )
+
+    @classmethod
+    def outbound_tool_ak_sk_custom(cls, auth_config: Dict[str, str]):
+        """配置访问第三方工具的自定义凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.TOOL,
+            credential_auth_type=CredentialAuthType.AKSK,
+            credential_public_config={
+                "provider": "custom",
+                "authConfig": auth_config,
+            },
+            credential_secret="",
+        )
+
+    @classmethod
+    def outbound_tool_custom_header(cls, headers: Dict[str, str]):
+        """配置访问第三方工具的自定义 Header 凭证"""
+        return cls(
+            credential_source_type=CredentialSourceType.TOOL,
+            credential_auth_type=CredentialAuthType.CUSTOM_HEADER,
+            credential_public_config={"authConfig": headers},
+            credential_secret="",
+        )
+
+
+class CredentialMutableProps(BaseModel):
+    """凭证公共配置"""
+
+    # credential_secret: Optional[str] = None
+    """凭证密钥"""
+    description: Optional[str] = None
+    """描述"""
+    enabled: Optional[bool] = None
+    """是否启用"""
+
+
+class CredentialImmutableProps(BaseModel):
+    credential_name: Optional[str] = None
+    """凭证名称"""
+
+
+class CredentialSystemProps(CredentialConfigInner):
+    credential_id: Optional[str] = None
+    """凭证 ID"""
+    created_at: Optional[str] = None
+    """创建时间"""
+    updated_at: Optional[str] = None
+    """更新时间"""
+    related_resources: Optional[List[RelatedResource]] = None
+    """关联资源"""
+
+
+class CredentialCreateInput(CredentialImmutableProps, CredentialMutableProps):
+    """凭证创建输入参数"""
+
+    credential_config: CredentialConfig
+
+
+class CredentialUpdateInput(CredentialMutableProps):
+    credential_config: Optional[CredentialConfig] = None
+
+
+class CredentialListInput(PageableInput):
+    credential_auth_type: Optional[CredentialAuthType] = None
+    """凭证认证类型"""
+    credential_name: Optional[str] = None
+    """凭证名称"""
+    credential_source_type: Optional[CredentialSourceType] = None
+    """凭证来源类型（必填）"""
+    provider: Optional[str] = None
+    """提供商"""
+
+
+class CredentialListOutput(BaseModel):
+    created_at: Optional[str] = None
+    credential_auth_type: Optional[str] = None
+    credential_id: Optional[str] = None
+    credential_name: Optional[str] = None
+    credential_source_type: Optional[str] = None
+    enabled: Optional[bool] = None
+    related_resource_count: Optional[int] = None
+    updated_at: Optional[str] = None
+
+    async def to_credential_async(self, config: Optional[Config] = None):
+        from .client import CredentialClient
+
+        return await CredentialClient(config).get_async(
+            self.credential_name or "", config=config
+        )
+
+    def to_credential(self, config: Optional[Config] = None):
+        from .client import CredentialClient
+
+        return CredentialClient(config).get(
+            self.credential_name or "", config=config
+        )

agentrun/integration/__init__.py

@@ -0,0 +1,21 @@
+"""Integration 模块 / Integration Module
+
+提供与主流 AI 框架的集成适配器。
+Provides integration adapters for mainstream AI frameworks.
+
+支持的框架 / Supported Frameworks:
+- LangChain: 流行的 LLM 应用开发框架 / Popular LLM application development framework
+- LangGraph: LangChain 的图形化工作流扩展 / Graph-based workflow extension for LangChain
+- Google ADK: Google 的 AI Development Kit / Google's AI Development Kit
+- AgentScope: 阿里云的 Agent 开发框架 / Alibaba Cloud's agent development framework
+- PydanticAI: 基于 Pydantic 的 AI 框架 / Pydantic-based AI framework
+- CrewAI: 多 Agent 协作框架 / Multi-agent collaboration framework
+
+使用方法 / Usage:
+>>> from agentrun.integration.langchain import wrap_model, wrap_tools
+>>> # 或 / Or
+>>> from agentrun.integration.utils.model import CommonModel
+>>> from agentrun.integration.utils.tool import CommonToolSet
+"""
+
+__all__ = []

agentrun/integration/agentscope/__init__.py

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

agentrun/integration/agentscope/adapter.py

@@ -0,0 +1,17 @@
+"""AgentScope 适配器兼容性导出 / AgentScope Adapters Compatibility Exports
+
+提供 AgentScope 框架的所有适配器。
+Provides all adapters for the AgentScope framework.
+"""
+
+from agentrun.integration.agentscope.message_adapter import (
+    AgentScopeMessageAdapter,
+)
+from agentrun.integration.agentscope.model_adapter import AgentScopeModelAdapter
+from agentrun.integration.agentscope.tool_adapter import AgentScopeToolAdapter
+
+__all__ = [
+    "AgentScopeMessageAdapter",
+    "AgentScopeToolAdapter",
+    "AgentScopeModelAdapter",
+]

agentrun/integration/agentscope/builtin.py

@@ -0,0 +1,88 @@
+"""AgentScope 内置集成函数 / AgentScope Built-in Integration Functions
+
+提供快速创建 AgentScope 兼容模型和工具的便捷函数。
+Provides convenient functions for quickly creating AgentScope-compatible models and tools.
+"""
+
+from typing import Any, Callable, List, Optional, Union
+
+from typing_extensions import Unpack
+
+from agentrun.integration.builtin import (
+    knowledgebase_toolset as _knowledgebase_toolset,
+)
+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``。 / AgentScope Built-in Integration Functions"""
+
+    m = _model(input=name, **kwargs)
+    return m.to_agentscope()
+
+
+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`` 列表。 / AgentScope 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`` 列表。 / AgentScope 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_agentscope(prefix=prefix)
+
+
+def knowledgebase_toolset(
+    knowledge_base_names: List[str],
+    *,
+    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]:
+    """将知识库检索封装为 AgentScope 工具列表。 / AgentScope Built-in Integration Functions"""
+
+    return _knowledgebase_toolset(
+        knowledge_base_names=knowledge_base_names,
+        config=config,
+    ).to_agentscope(
+        prefix=prefix,
+        modify_tool_name=modify_tool_name,
+        filter_tools_by_name=filter_tools_by_name,
+    )

agentrun/integration/agentscope/message_adapter.py

@@ -0,0 +1,185 @@
+"""消息适配器，负责 AgentScope <-> CanonicalMessage 的转换。 / AgentScope Message Adapter"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Iterable, List
+
+from agentrun.integration.utils.adapter import MessageAdapter
+from agentrun.integration.utils.canonical import (
+    CanonicalMessage,
+    CanonicalToolCall,
+    MessageRole,
+)
+
+
+def _ensure_agentscope_installed() -> None:
+    try:
+        import agentscope  # noqa: F401
+    except ImportError as exc:  # pragma: no cover - defensive
+        raise ImportError(
+            "AgentScope is not installed. Install it with: pip install"
+            " agentscope"
+        ) from exc
+
+
+class AgentScopeMessageAdapter(MessageAdapter):
+    """AgentScope 消息适配器。 / AgentScope Message Adapter"""
+
+    def to_canonical(self, messages: Any) -> List[CanonicalMessage]:
+        _ensure_agentscope_installed()
+
+        from agentscope.message import Msg
+
+        if messages is None:
+            return []
+
+        if isinstance(messages, Msg):
+            iterable: Iterable[Any] = [messages]
+        elif isinstance(messages, Iterable):
+            iterable = messages
+        else:
+            iterable = [messages]
+
+        canonical: List[CanonicalMessage] = []
+        for item in iterable:
+            msg = self._ensure_msg(item)
+            text_segments: List[str] = []
+            tool_calls: List[CanonicalToolCall] = []
+
+            blocks = (
+                msg.content
+                if isinstance(msg.content, list)
+                else msg.get_content_blocks()
+            ) or []
+
+            for block in blocks:
+                block_type = block.get("type")
+                if block_type == "text":
+                    text = block.get("text")
+                    if text:
+                        text_segments.append(str(text))
+                elif block_type == "tool_use":
+                    tool_calls.append(
+                        CanonicalToolCall(
+                            id=str(block.get("id", "")),
+                            name=str(block.get("name", "")),
+                            arguments=block.get("input", {}) or {},
+                        )
+                    )
+                elif block_type == "tool_result":
+                    canonical.append(
+                        CanonicalMessage(
+                            role=MessageRole.TOOL,
+                            content=self._format_tool_result(block),
+                            tool_call_id=str(block.get("id", "")),
+                            name=block.get("name"),
+                        )
+                    )
+
+            if text_segments or tool_calls or msg.role:
+                canonical.append(
+                    CanonicalMessage(
+                        role=self._resolve_role(msg.role),
+                        content="\n".join(text_segments)
+                        if text_segments
+                        else None,
+                        name=msg.name,
+                        tool_calls=tool_calls or None,
+                    )
+                )
+
+        return canonical
+
+    def from_canonical(self, messages: List[CanonicalMessage]) -> Any:
+        _ensure_agentscope_installed()
+
+        from agentscope.message import (
+            Msg,
+            TextBlock,
+            ToolResultBlock,
+            ToolUseBlock,
+        )
+
+        result: List[Msg] = []
+        for msg in messages:
+            role = msg.role.value
+            blocks: List[dict] = []
+
+            if msg.role == MessageRole.TOOL:
+                blocks.append(
+                    ToolResultBlock(
+                        type="tool_result",
+                        id=msg.tool_call_id or "",
+                        name=msg.name or "",
+                        output=msg.content or "",
+                    )
+                )
+            else:
+                if msg.content:
+                    blocks.append(
+                        TextBlock(
+                            type="text",
+                            text=msg.content,
+                        )
+                    )
+                for call in msg.tool_calls or []:
+                    blocks.append(
+                        ToolUseBlock(
+                            type="tool_use",
+                            id=call.id,
+                            name=call.name,
+                            input=call.arguments,
+                        )
+                    )
+
+            content: Any
+            if len(blocks) == 1 and blocks[0]["type"] == "text":
+                content = blocks[0]["text"]
+            else:
+                content = blocks or ""
+
+            result.append(
+                Msg(
+                    name=msg.name or role,
+                    role=role,
+                    content=content,
+                )
+            )
+
+        return result
+
+    @staticmethod
+    def _ensure_msg(message: Any):
+        from agentscope.message import Msg
+
+        if isinstance(message, Msg):
+            return message
+        if isinstance(message, dict):
+            return Msg(
+                name=message.get("name", message.get("role", "user")),
+                role=message.get("role", "user"),
+                content=message.get("content"),
+            )
+        raise TypeError(f"Unsupported AgentScope message type: {type(message)}")
+
+    @staticmethod
+    def _resolve_role(role: str) -> MessageRole:
+        role_lower = (role or "user").lower()
+        if role_lower.startswith("system"):
+            return MessageRole.SYSTEM
+        if role_lower.startswith("assistant"):
+            return MessageRole.ASSISTANT
+        if role_lower.startswith("tool"):
+            return MessageRole.TOOL
+        return MessageRole.USER
+
+    @staticmethod
+    def _format_tool_result(block: dict) -> str:
+        output = block.get("output")
+        if isinstance(output, str):
+            return output
+        try:
+            return json.dumps(output, ensure_ascii=False)
+        except (TypeError, ValueError):  # pragma: no cover - fallback
+            return str(output)

agentrun/integration/agentscope/model_adapter.py

@@ -0,0 +1,60 @@
+"""AgentScope 模型适配器 / AgentScope Model Adapter
+
+将 CommonModel 包装为 AgentScope ChatModelBase。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentrun.integration.agentscope.message_adapter import (
+    AgentScopeMessageAdapter,
+)
+from agentrun.integration.utils.adapter import ModelAdapter
+from agentrun.integration.utils.model import CommonModel
+
+
+def _ensure_agentscope_installed() -> None:
+    try:
+        import agentscope  # noqa: F401
+    except ImportError as exc:  # pragma: no cover - defensive
+        raise ImportError(
+            "AgentScope is not installed. Install it with: pip install"
+            " agentscope"
+        ) from exc
+
+
+class AgentScopeModelAdapter(ModelAdapter):
+    """AgentScope 模型适配器 / AgentScope Model Adapter
+
+    将 CommonModel 包装为 AgentScope ChatModelBase。"""
+
+    def __init__(self):
+        """初始化适配器，创建内部的消息适配器 / AgentScope Message Adapter"""
+        self._message_adapter = AgentScopeMessageAdapter()
+
+    def wrap_model(self, common_model: CommonModel) -> Any:
+        """包装 CommonModel 为 AgentScope ChatModelBase / AgentScope Model Adapter"""
+        _ensure_agentscope_installed()
+
+        try:
+            from agentscope.model import OpenAIChatModel
+        except Exception as e:
+            raise ImportError(
+                "AgentScope is not installed. Install it with: pip install"
+                " agentscope"
+            ) from e
+
+        from httpx import AsyncClient
+
+        info = common_model.get_model_info()
+
+        return OpenAIChatModel(
+            model_name=info.model or "",
+            api_key=info.api_key,
+            stream=True,
+            client_args={
+                "base_url": info.base_url,
+                "http_client": AsyncClient(headers=info.headers),
+            },
+            generate_kwargs={"stream_options": {"include_usage": True}},
+        )

agentrun/integration/agentscope/tool_adapter.py

@@ -0,0 +1,59 @@
+"""AgentScope 工具适配器 / AgentScope Tool Adapter
+
+将标准工具定义转换为 AgentScope 工具格式。"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, List
+
+from agentscope.message import TextBlock
+from agentscope.tool import ToolResponse
+
+from agentrun.integration.utils.adapter import ToolAdapter
+from agentrun.integration.utils.canonical import CanonicalTool
+
+
+def _ensure_agentscope_installed() -> None:
+    try:
+        import agentscope  # noqa: F401
+    except ImportError as exc:  # pragma: no cover - defensive
+        raise ImportError(
+            "AgentScope is not installed. Install it with: pip install"
+            " agentscope"
+        ) from exc
+
+
+class AgentScopeToolAdapter(ToolAdapter):
+    """AgentScope 工具适配器 / AgentScope Tool Adapter
+
+    实现 CanonicalTool → AgentScope 工具格式的转换。"""
+
+    def _modify_tool(self, tool: CanonicalTool, *args, **kwargs) -> Any:
+        """修改工具函数以符合 AgentScope 的要求 / AgentScope Tool Adapter"""
+        _ensure_agentscope_installed()
+
+        if tool.func is None:
+            return ToolResponse(
+                content=[
+                    TextBlock(
+                        type="text",
+                        text="工具未实现。",
+                    ),
+                ],
+            )
+
+        result = tool.func(*args, **kwargs)
+        return ToolResponse(
+            content=[
+                TextBlock(
+                    type="text",
+                    text=result if type(result) is str else json.dumps(result),
+                ),
+            ],
+        )
+
+    def from_canonical(self, tools: List[CanonicalTool]) -> Any:
+        """将标准格式转换为 AgentScope 工具 / AgentScope Tool Adapter"""
+
+        return self.function_tools(tools, modify_func=self._modify_tool)