agentscope-runtime 1.0.4a1__py3-none-any.whl → 1.0.5__py3-none-any.whl

agentscope_runtime/engine/app/agent_app.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# flake8: noqa: E501
 import logging
 import os
 import types
@@ -20,6 +21,7 @@ from ..deployers.adapter.a2a import (
 from ..deployers.adapter.responses.response_api_protocol_adapter import (
     ResponseAPIDefaultAdapter,
 )
+from ..deployers.adapter.agui import AGUIDefaultAdapter, AGUIAdaptorConfig
 from ..deployers.utils.deployment_modes import DeploymentMode
 from ..deployers.utils.service_utils.fastapi_factory import FastAPIAppFactory
 from ..runner import Runner
@@ -52,6 +54,7 @@ class AgentApp(BaseApp):
         runner: Optional[Runner] = None,
         enable_embedded_worker: bool = False,
         a2a_config: Optional["AgentCardWithRuntimeConfig"] = None,
+        agui_config: Optional[AGUIAdaptorConfig] = None,
         **kwargs,
     ):
         """
@@ -74,11 +77,14 @@ class AgentApp(BaseApp):
                 Must be an ``AgentCardWithRuntimeConfig`` instance, which
                 contains ``agent_card`` (AgentCard object or dict) and runtime
                 settings (host, port, registry, task_timeout, etc.).
-                Example:
-                    from a2a.types import AgentCard, AgentCapabilities
-                    from agentscope_runtime.engine.deployers.adapter.a2a import (  # noqa: E501
+
+                Example::
+
+                    from a2a.types import AgentCapabilities
+                    from agentscope_runtime.engine.deployers.adapter.a2a import (
                         AgentCardWithRuntimeConfig,
                     )
+
                     config = AgentCardWithRuntimeConfig(
                         agent_card={
                             "name": "MyAgent",
@@ -93,6 +99,7 @@ class AgentApp(BaseApp):
                         registry=[nacos_registry],
                         task_timeout=120,
                     )
+            agui_config: Config for AGUI adaptor.
             **kwargs: Additional keyword arguments passed to FastAPI app
         """
 
@@ -125,7 +132,12 @@ class AgentApp(BaseApp):
         )
 
         response_protocol = ResponseAPIDefaultAdapter()
-        self.protocol_adapters = [a2a_protocol, response_protocol]
+        agui_protocol = AGUIDefaultAdapter(config=agui_config)
+        self.protocol_adapters = [
+            a2a_protocol,
+            response_protocol,
+            agui_protocol,
+        ]
 
         self._app_kwargs = {
             "title": "Agent Service",

agentscope_runtime/engine/constant.py

@@ -5,4 +5,5 @@ ALLOWED_FRAMEWORK_TYPES = [
     "autogen",
     "langgraph",
     "agno",
+    "ms_agent_framework",
 ]

agentscope_runtime/engine/deployers/__init__.py

@@ -1,25 +1,48 @@
 # -*- coding: utf-8 -*-
-from .base import DeployManager
-from .local_deployer import LocalDeployManager
-from .kubernetes_deployer import (
-    KubernetesDeployManager,
-    K8sConfig,
-)
-from .modelstudio_deployer import (
-    ModelstudioDeployManager,
+from typing import TYPE_CHECKING
+from ...common.utils.lazy_loader import install_lazy_loader
+
+if TYPE_CHECKING:
+    from .base import DeployManager
+    from .local_deployer import LocalDeployManager
+    from .kubernetes_deployer import (
+        KubernetesDeployManager,
+        K8sConfig,
+    )
+    from .modelstudio_deployer import ModelstudioDeployManager
+    from .knative_deployer import KnativeDeployManager
+    from .agentrun_deployer import AgentRunDeployManager
+    from .fc_deployer import FCDeployManager
+
+install_lazy_loader(
+    globals(),
+    {
+        "DeployManager": ".base",
+        "LocalDeployManager": ".local_deployer",
+        "KubernetesDeployManager": ".kubernetes_deployer",
+        "K8sConfig": ".kubernetes_deployer",
+        "ModelstudioDeployManager": ".modelstudio_deployer",
+        "KnativeDeployManager": ".knative_deployer",
+        "AgentRunDeployManager": ".agentrun_deployer",
+        "FCDeployManager": ".fc_deployer",
+    },
 )
 
 try:
-    from .agentrun_deployer import (
-        AgentRunDeployManager,
+    from .pai_deployer import (
+        PAIDeployManager,
     )
 except ImportError:
-    AgentRunDeployManager = None  # type: ignore
+    PAIDeployManager = None  # type: ignore
 
 __all__ = [
+    "K8sConfig",
     "DeployManager",
     "LocalDeployManager",
     "KubernetesDeployManager",
     "ModelstudioDeployManager",
     "AgentRunDeployManager",
+    "KnativeDeployManager",
+    "FCDeployManager",
+    "PAIDeployManager",
 ]

agentscope_runtime/engine/deployers/adapter/__init__.py

@@ -1,2 +1,10 @@
 # -*- coding: utf-8 -*-
 from .a2a import A2AFastAPIDefaultAdapter
+from .agui import AGUIDefaultAdapter
+from .responses import ResponseAPIDefaultAdapter
+
+__all__ = [
+    "A2AFastAPIDefaultAdapter",
+    "AGUIDefaultAdapter",
+    "ResponseAPIDefaultAdapter",
+]

agentscope_runtime/engine/deployers/adapter/a2a/__init__.py

@@ -1,57 +1,32 @@
 # -*- coding: utf-8 -*-
-from .a2a_protocol_adapter import (
-    A2AFastAPIDefaultAdapter,
-    AgentCardWithRuntimeConfig,
-    extract_a2a_config,
-)
-from .a2a_registry import (
-    A2ARegistry,
-    A2ARegistrySettings,
-    get_registry_settings,
-    create_registry_from_env,
-)
+from typing import TYPE_CHECKING
+from .....common.utils.lazy_loader import install_lazy_loader
+
+if TYPE_CHECKING:
+    from .a2a_protocol_adapter import (
+        A2AFastAPIDefaultAdapter,
+        AgentCardWithRuntimeConfig,
+        extract_a2a_config,
+    )
+    from .a2a_registry import A2ARegistry
+    from .nacos_a2a_registry import NacosRegistry
 
 # NOTE: NacosRegistry is NOT imported at module import time to avoid forcing
 # an optional dependency on environments that don't have nacos SDK installed.
-# Instead, NacosRegistry is imported lazily via __getattr__ (see below) when
+# Instead, NacosRegistry is imported lazily via install_lazy_loader when
 # actually needed (e.g., when user does: from ... import NacosRegistry).
 
-__all__ = [
-    "A2AFastAPIDefaultAdapter",
-    "AgentCardWithRuntimeConfig",
-    "extract_a2a_config",
-    "A2ARegistry",
-    "A2ARegistrySettings",
-    "get_registry_settings",
-    "create_registry_from_env",
-    "NacosRegistry",  # pylint: disable=undefined-all-variable
-]
-
-
-def __getattr__(name: str):
-    """
-    Lazy import for NacosRegistry to avoid forcing optional nacos dependency.
-
-    This function is called by Python when an attribute is accessed
-    that doesn't exist at module level. This allows NacosRegistry
-    to be imported only when actually needed, rather than at module
-    import time.
-
-    If the nacos SDK is not installed, provides a helpful error message
-    instead of a confusing ImportError.
-    """
-    if name == "NacosRegistry":
-        try:
-            from .nacos_a2a_registry import NacosRegistry
-
-            return NacosRegistry
-        except ImportError as e:
-            # Check if it's the v2.nacos dependency that's missing
-            if "v2.nacos" in str(e) or "nacos" in str(e).lower():
-                raise ImportError(
-                    "NacosRegistry requires the 'v2-nacos' package. "
-                    "Install it with: pip install v2-nacos",
-                ) from e
-            # Re-raise other import errors as-is
-            raise
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+install_lazy_loader(
+    globals(),
+    {
+        "A2AFastAPIDefaultAdapter": ".a2a_protocol_adapter",
+        "AgentCardWithRuntimeConfig": ".a2a_protocol_adapter",
+        "extract_a2a_config": ".a2a_protocol_adapter",
+        "A2ARegistry": ".a2a_registry",
+        "NacosRegistry": {
+            "module": ".nacos_a2a_registry",
+            "hint": "NacosRegistry requires the 'nacos-sdk-python' package. "
+            "Install it with: pip install nacos-sdk-python",
+        },
+    },
+)

agentscope_runtime/engine/deployers/adapter/a2a/a2a_protocol_adapter.py

@@ -19,19 +19,18 @@ from a2a.types import (
     AgentCard,
     AgentSkill,
 )
+from a2a.utils import AGENT_CARD_WELL_KNOWN_PATH
 from fastapi import FastAPI
 from pydantic import ConfigDict, BaseModel, field_validator
 
 from agentscope_runtime.engine.deployers.utils.net_utils import (
     get_first_non_loopback_ip,
 )
-from agentscope_runtime.version import __version__ as runtime_version
 
 from .a2a_agent_adapter import A2AExecutor
 from .a2a_registry import (
     A2ARegistry,
     A2ATransportsProperties,
-    create_registry_from_env,
 )
 
 # NOTE: Do NOT import NacosRegistry at module import time to avoid
@@ -44,7 +43,7 @@ from ..protocol_adapter import ProtocolAdapter
 logger = logging.getLogger(__name__)
 
 A2A_JSON_RPC_URL = "/a2a"
-DEFAULT_WELLKNOWN_PATH = "/.wellknown/agent-card.json"
+DEFAULT_WELLKNOWN_PATH = AGENT_CARD_WELL_KNOWN_PATH
 DEFAULT_TASK_TIMEOUT = 60
 DEFAULT_TASK_EVENT_TIMEOUT = 10
 DEFAULT_TRANSPORT = "JSONRPC"
@@ -56,26 +55,37 @@ AGENT_VERSION = "1.0.0"
 def extract_a2a_config(
     a2a_config: Optional["AgentCardWithRuntimeConfig"] = None,
 ) -> "AgentCardWithRuntimeConfig":
-    """Normalize a2a_config to AgentCardWithRuntimeConfig object.
+    """Normalize ``a2a_config`` to an ``AgentCardWithRuntimeConfig`` object.
 
-    Ensures a non-null ``AgentCardWithRuntimeConfig`` instance and sets up
-    environment-based registry fallback if registry is not provided.
+    Registry resolution priority:
+
+    1. Use ``registry`` from ``a2a_config`` if provided.
+    2. Fallback to environment variables if ``a2a_config.registry`` is
+       ``None``.
+    3. If neither is available, registry remains ``None``
+       (user doesn't want it).
 
     Args:
-        a2a_config: Optional AgentCardWithRuntimeConfig instance.
+        a2a_config: Optional ``AgentCardWithRuntimeConfig`` instance.
 
     Returns:
-        Normalized AgentCardWithRuntimeConfig object.
+        Normalized ``AgentCardWithRuntimeConfig`` object.
     """
     if a2a_config is None:
         a2a_config = AgentCardWithRuntimeConfig()
 
-    # Fallback to environment registry if not provided
+    # Try environment variables only if registry is not explicitly provided
     if a2a_config.registry is None:
-        env_registry = create_registry_from_env()
-        if env_registry is not None:
-            a2a_config.registry = env_registry
-            logger.debug("[A2A] Using registry from environment variables")
+        try:
+            from .nacos_a2a_registry import create_nacos_registry_from_env
+
+            env_registry = create_nacos_registry_from_env()
+            if env_registry is not None:
+                a2a_config.registry = env_registry
+                logger.debug("[A2A] Using registry from environment variables")
+        except ImportError:
+            # Nacos SDK not available, registry remains None
+            logger.debug("[A2A] Nacos registry not available")
 
     return a2a_config
 

agentscope_runtime/engine/deployers/adapter/a2a/a2a_registry.py

@@ -2,35 +2,20 @@
 """
 A2A Registry Extension Point
 
-Defines the abstract interface and helper utilities for A2A registry
-implementations. Registry implementations are responsible for registering
-agent services to service discovery systems (for example: Nacos).
-
-This module focuses on clarity and small helper functions used by the
-runtime to instantiate registry implementations from environment
-configuration or .env files.
+Defines the abstract interface for A2A registry implementations.
+Registry implementations are responsible for registering agent services
+to service discovery systems (for example: Nacos).
 """
 import logging
-import os
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
-
-from dotenv import find_dotenv, load_dotenv
-from pydantic import ConfigDict
-from pydantic_settings import BaseSettings
+from typing import Any, Dict, List, Optional
 
 from a2a.types import AgentCard
 
-if TYPE_CHECKING:
-    from v2.nacos import ClientConfig
-
 __all__ = [
     "A2ARegistry",
     "A2ATransportsProperties",
-    "A2ARegistrySettings",
-    "get_registry_settings",
-    "create_registry_from_env",
 ]
 
 logger = logging.getLogger(__name__)
@@ -89,185 +74,3 @@ class A2ARegistry(ABC):
         depending on their semantics.
         """
         raise NotImplementedError("Subclasses must implement register()")
-
-
-class A2ARegistrySettings(BaseSettings):
-    """Settings that control A2A registry behavior.
-
-    Values are loaded from environment variables or a .env file when
-    `get_registry_settings()` is called.
-    """
-
-    # Feature toggle
-    A2A_REGISTRY_ENABLED: bool = True
-
-    # Registry type(s). Can be a single value like "nacos" or a comma-separated
-    # list of registry types (e.g. "nacos").
-    A2A_REGISTRY_TYPE: Optional[str] = None
-
-    # Nacos specific configuration
-    NACOS_SERVER_ADDR: str = "localhost:8848"
-    NACOS_USERNAME: Optional[str] = None
-    NACOS_PASSWORD: Optional[str] = None
-    NACOS_NAMESPACE_ID: Optional[str] = None
-    NACOS_ACCESS_KEY: Optional[str] = None
-    NACOS_SECRET_KEY: Optional[str] = None
-
-    model_config = ConfigDict(
-        extra="allow",
-    )
-
-
-_registry_settings: Optional[A2ARegistrySettings] = None
-
-
-def get_registry_settings() -> A2ARegistrySettings:
-    """Return a singleton settings instance, loading .env files if needed."""
-    global _registry_settings
-
-    if _registry_settings is None:
-        # Inline _load_env_files() logic
-        # prefer a .env file if present, otherwise fall back to .env.example
-        dotenv_path = find_dotenv(raise_error_if_not_found=False)
-        if dotenv_path:
-            load_dotenv(dotenv_path, override=False)
-        else:
-            # If find_dotenv didn't find a file, try the explicit fallback name
-            if os.path.exists(".env.example"):
-                load_dotenv(".env.example", override=False)
-        _registry_settings = A2ARegistrySettings()
-
-    return _registry_settings
-
-
-def _create_nacos_registry_from_settings(
-    settings: A2ARegistrySettings,
-) -> Optional[A2ARegistry]:
-    """Create a NacosRegistry instance from provided settings, or return
-    None if the required nacos SDK is not available or construction fails."""
-    try:
-        # lazy import so package is optional
-        from .nacos_a2a_registry import NacosRegistry
-    except ImportError:
-        logger.warning(
-            "[A2A] Nacos registry requested but nacos SDK not available. "
-            "Install with: pip install v2-nacos",
-            exc_info=False,
-        )
-        return None
-    except Exception as e:
-        logger.warning(
-            "[A2A] Unexpected error during Nacos registry import: %s",
-            str(e),
-            exc_info=True,
-        )
-        return None
-
-    try:
-        nacos_client_config = _build_nacos_client_config(settings)
-        registry = NacosRegistry(nacos_client_config=nacos_client_config)
-
-        # Determine authentication status
-        auth_methods = []
-        if settings.NACOS_USERNAME and settings.NACOS_PASSWORD:
-            auth_methods.append("username/password")
-        if settings.NACOS_ACCESS_KEY and settings.NACOS_SECRET_KEY:
-            auth_methods.append("access_key")
-        auth_status = ", ".join(auth_methods) if auth_methods else "disabled"
-
-        namespace_info = (
-            f", namespace={settings.NACOS_NAMESPACE_ID}"
-            if settings.NACOS_NAMESPACE_ID
-            else ""
-        )
-        logger.info(
-            f"[A2A] Created Nacos registry from environment: "
-            f"server={settings.NACOS_SERVER_ADDR}, "
-            f"authentication={auth_status}{namespace_info}",
-        )
-        return registry
-    except Exception:
-        logger.warning(
-            "[A2A] Failed to construct Nacos registry from settings",
-            exc_info=True,
-        )
-        return None
-
-
-def _build_nacos_client_config(
-    settings: A2ARegistrySettings,
-) -> Any:
-    """Build Nacos client configuration from settings.
-
-    Supports both username/password and access key authentication.
-    """
-    from v2.nacos import ClientConfigBuilder
-
-    builder = ClientConfigBuilder().server_address(settings.NACOS_SERVER_ADDR)
-
-    if settings.NACOS_NAMESPACE_ID:
-        builder.namespace_id(settings.NACOS_NAMESPACE_ID)
-        logger.debug(
-            "[A2A] Using Nacos namespace: %s",
-            settings.NACOS_NAMESPACE_ID,
-        )
-
-    if settings.NACOS_USERNAME and settings.NACOS_PASSWORD:
-        builder.username(settings.NACOS_USERNAME).password(
-            settings.NACOS_PASSWORD,
-        )
-        logger.debug("[A2A] Using Nacos username/password authentication")
-
-    if settings.NACOS_ACCESS_KEY and settings.NACOS_SECRET_KEY:
-        builder.access_key(settings.NACOS_ACCESS_KEY).secret_key(
-            settings.NACOS_SECRET_KEY,
-        )
-        logger.debug("[A2A] Using Nacos access key authentication")
-
-    return builder.build()
-
-
-def create_registry_from_env() -> (
-    Optional[Union[A2ARegistry, List[A2ARegistry]]]
-):
-    """Create registry instance(s) from environment settings.
-
-    Supports single or multiple registry types (comma-separated).
-    Returns None if disabled or no valid registry created.
-    """
-    settings = get_registry_settings()
-
-    if not settings.A2A_REGISTRY_ENABLED:
-        logger.debug("[A2A] Registry disabled via A2A_REGISTRY_ENABLED")
-        return None
-
-    # Inline _split_registry_types() logic
-    raw = settings.A2A_REGISTRY_TYPE
-    types = (
-        [r.strip().lower() for r in raw.split(",") if r.strip()] if raw else []
-    )
-    if not types:
-        logger.debug("[A2A] No registry type specified in A2A_REGISTRY_TYPE")
-        return None
-
-    registry_list: List[A2ARegistry] = []
-
-    for registry_type in types:
-        if registry_type == "nacos":
-            registry = _create_nacos_registry_from_settings(settings)
-            if registry:
-                registry_list.append(registry)
-            else:
-                logger.debug(
-                    "[A2A] Skipping nacos registry due to earlier errors",
-                )
-        else:
-            logger.warning(
-                f"[A2A] Unknown registry type requested: "
-                f"{registry_type}. Supported: nacos",
-            )
-
-    if not registry_list:
-        return None
-
-    return registry_list[0] if len(registry_list) == 1 else registry_list