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

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

@@ -2,20 +2,35 @@
 """
 A2A Registry Extension Point
 
-Defines the abstract interface for A2A registry implementations.
-Registry implementations are responsible for registering agent services
-to service discovery systems (for example: Nacos).
+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.
 """
 import logging
+import os
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+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 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__)
@@ -74,3 +89,185 @@ 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

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

@@ -8,17 +8,11 @@ for A2A protocol adapters.
 """
 import asyncio
 import logging
-import os
-import threading
 from enum import Enum
-from typing import Any, Optional, TYPE_CHECKING, List
+from typing import Optional, TYPE_CHECKING, List
+import threading
 
 from a2a.types import AgentCard
-from dotenv import find_dotenv, load_dotenv
-from pydantic import ConfigDict
-from pydantic_settings import BaseSettings
-
-logger = logging.getLogger(__name__)
 
 # Make the v2.nacos imports optional to avoid hard dependency at
 # module import time.
@@ -42,10 +36,6 @@ else:
 
         _NACOS_SDK_AVAILABLE = True
     except Exception:
-        logger.warning(
-            "[NacosRegistry] Nacos SDK (nacos-sdk-python) is not available. "
-            "Install it with: pip install nacos-sdk-python",
-        )
 
         class ClientConfig:
             pass
@@ -65,129 +55,12 @@ else:
         _NACOS_SDK_AVAILABLE = False
 
 # Import after conditional imports to avoid circular dependencies
-# flake8: noqa: E402
 from .a2a_registry import (  # pylint: disable=wrong-import-position
     A2ARegistry,
     A2ATransportsProperties,
 )
 
-
-class NacosSettings(BaseSettings):
-    """Nacos-specific settings loaded from environment variables."""
-
-    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",
-    )
-
-
-_nacos_settings: Optional[NacosSettings] = None
-
-
-def get_nacos_settings() -> NacosSettings:
-    """Return a singleton Nacos settings instance, loading .env files
-    if needed."""
-    global _nacos_settings
-
-    if _nacos_settings is None:
-        dotenv_path = find_dotenv(raise_error_if_not_found=False)
-        if dotenv_path:
-            load_dotenv(dotenv_path, override=False)
-        else:
-            if os.path.exists(".env.example"):
-                load_dotenv(".env.example", override=False)
-        _nacos_settings = NacosSettings()
-
-    return _nacos_settings
-
-
-def _build_nacos_client_config(settings: NacosSettings) -> Any:
-    """Build Nacos client configuration from settings.
-
-    Supports both username/password and access key authentication.
-    """
-    try:
-        from v2.nacos import ClientConfigBuilder
-    except (ImportError, ModuleNotFoundError) as e:
-        logger.warning(
-            "[A2A] Nacos SDK (nacos-sdk-python) is not available. "
-            "Install it with: pip install nacos-sdk-python",
-        )
-        raise ImportError(
-            "Nacos SDK (nacos-sdk-python) is not available. "
-            "Install it with: pip install nacos-sdk-python",
-        ) from e
-
-    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_nacos_registry_from_env() -> Optional[A2ARegistry]:
-    """Create a NacosRegistry instance from environment settings.
-
-    Returns None if the required nacos SDK is not available or
-    construction fails.
-    """
-    if not _NACOS_SDK_AVAILABLE:
-        return None
-
-    try:
-        nacos_settings = get_nacos_settings()
-        nacos_client_config = _build_nacos_client_config(nacos_settings)
-        registry = NacosRegistry(nacos_client_config=nacos_client_config)
-
-        auth_methods = []
-        if nacos_settings.NACOS_USERNAME and nacos_settings.NACOS_PASSWORD:
-            auth_methods.append("username/password")
-        if nacos_settings.NACOS_ACCESS_KEY and nacos_settings.NACOS_SECRET_KEY:
-            auth_methods.append("access_key")
-        auth_status = ", ".join(auth_methods) if auth_methods else "disabled"
-
-        namespace_info = (
-            f", namespace={nacos_settings.NACOS_NAMESPACE_ID}"
-            if nacos_settings.NACOS_NAMESPACE_ID
-            else ""
-        )
-        logger.info(
-            f"[A2A] Created Nacos registry from environment: "
-            f"server={nacos_settings.NACOS_SERVER_ADDR}, "
-            f"authentication={auth_status}{namespace_info}",
-        )
-        return registry
-    except (ImportError, ModuleNotFoundError):
-        return None
-    except Exception:
-        logger.warning(
-            "[A2A] Failed to construct Nacos registry from settings",
-            exc_info=True,
-        )
-        return None
+logger = logging.getLogger(__name__)
 
 
 class RegistrationStatus(Enum):
@@ -254,10 +127,11 @@ class NacosRegistry(A2ARegistry):
             a2a_transports_properties: List of transport configurations.
                 Each transport will be registered separately.
         """
+        # If Nacos SDK is not available, log and return
         if not _NACOS_SDK_AVAILABLE:
-            logger.warning(
-                "[NacosRegistry] Nacos SDK (nacos-sdk-python) is not "
-                "available. Install it with: pip install nacos-sdk-python",
+            logger.debug(
+                "[NacosRegistry] Nacos SDK is not available; "
+                "skipping registration",
             )
             return
 
@@ -280,7 +154,11 @@ class NacosRegistry(A2ARegistry):
         thread and run the registration using asyncio.run so
         registration still occurs in synchronous contexts.
         """
+        # All status checks and updates must be within the lock to
+        # ensure atomicity
         with self._registration_lock:
+            # Check if shutdown was already requested (inside lock
+            # for atomicity)
             if self._shutdown_event.is_set():
                 logger.info(
                     "[NacosRegistry] Shutdown already requested, "
@@ -289,6 +167,7 @@ class NacosRegistry(A2ARegistry):
                 self._registration_status = RegistrationStatus.CANCELLED
                 return
 
+            # Check if registration is already in progress or completed
             if self._registration_status in (
                 RegistrationStatus.IN_PROGRESS,
                 RegistrationStatus.COMPLETED,
@@ -305,6 +184,8 @@ class NacosRegistry(A2ARegistry):
             try:
                 loop = asyncio.get_running_loop()
             except RuntimeError:
+                # No running loop in this thread; we'll fall back to a
+                # background thread
                 loop = None
 
             if loop is not None:
@@ -322,6 +203,7 @@ class NacosRegistry(A2ARegistry):
                 )
                 return
 
+            # No running loop: use a background thread to run asyncio.run
             def _thread_runner():
                 try:
                     with self._registration_lock:
@@ -375,6 +257,8 @@ class NacosRegistry(A2ARegistry):
                 daemon=True,
             )
             thread.start()
+            # Store thread reference after successful start for
+            # proper tracking and cleanup
             with self._registration_lock:
                 self._register_thread = thread
             logger.info(
@@ -398,7 +282,14 @@ class NacosRegistry(A2ARegistry):
         if self._nacos_client_config is not None:
             return self._nacos_client_config
 
-        settings = get_nacos_settings()
+        # Use centralized config builder from a2a_registry module
+        # This ensures consistent behavior with env-based registry creation
+        from .a2a_registry import (
+            get_registry_settings,
+            _build_nacos_client_config,
+        )
+
+        settings = get_registry_settings()
         return _build_nacos_client_config(settings)
 
     # pylint: disable=too-many-branches,too-many-statements

agentscope_runtime/engine/deployers/agentrun_deployer.py

@@ -7,7 +7,7 @@ import logging
 import os
 import time
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, Optional, List, Any, Union, Tuple
 
@@ -1011,7 +1011,7 @@ ls -lh /output/{zip_filename}
         try:
             presign_result = oss_client.presign(
                 GetObjectRequest(bucket=bucket_name, key=object_key),
-                expires=timedelta(hours=3),
+                expires=datetime.timedelta(hours=3),
             )
             presigned_url = presign_result.url
             logger.info("Presigned URL generated (valid for 3 hours)")

agentscope_runtime/engine/runner.py

@@ -272,18 +272,6 @@ class Runner:
             kwargs.update(
                 {"msgs": await message_to_agno_message(request.input)},
             )
-        elif self.framework_type == "ms_agent_framework":
-            from ..adapters.ms_agent_framework.stream import (
-                adapt_ms_agent_framework_message_stream,
-            )
-            from ..adapters.ms_agent_framework.message import (
-                message_to_ms_agent_framework_message,
-            )
-
-            stream_adapter = adapt_ms_agent_framework_message_stream
-            kwargs.update(
-                {"msgs": message_to_ms_agent_framework_message(request.input)},
-            )
         # TODO: support other frameworks
         else:
 

agentscope_runtime/engine/tracing/wrapper.py

@@ -26,11 +26,7 @@ from typing import (
 from pydantic import BaseModel
 from opentelemetry.propagate import extract
 from opentelemetry.context import attach
-from opentelemetry.trace import (
-    ProxyTracerProvider,
-    StatusCode,
-    NoOpTracerProvider,
-)
+from opentelemetry.trace import StatusCode, NoOpTracerProvider
 from opentelemetry import trace as ot_trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter as OTLPSpanGrpcExporter,
@@ -921,22 +917,12 @@ def _get_ot_tracer() -> ot_trace.Tracer:
         ot_trace.Tracer: The OpenTelemetry tracer instance.
     """
 
-    def _has_existing_trace_provider() -> bool:
-        from opentelemetry.trace import _TRACER_PROVIDER
-
+    def _get_ot_tracer_inner() -> ot_trace.Tracer:
         existing_provider = ot_trace.get_tracer_provider()
-        if isinstance(existing_provider, NoOpTracerProvider):
-            return False
-        elif isinstance(existing_provider, ProxyTracerProvider):
-            # ProxyTracerProvider will use the _TRACER_PROVIDER as real tracer
-            # provider to get the tracer
-            return bool(_TRACER_PROVIDER)
 
-        return True
-
-    def _get_ot_tracer_inner() -> ot_trace.Tracer:
-        if _has_existing_trace_provider():
+        if not isinstance(existing_provider, NoOpTracerProvider):
             return ot_trace.get_tracer("agentscope_runtime")
+
         resource = Resource(
             attributes={
                 SERVICE_NAME: _get_service_name(),

agentscope_runtime/sandbox/__init__.py

@@ -3,30 +3,22 @@
 # This ensures SandboxRegistry.register() runs at import time.
 # Without this, lazy loading delays module import and types may not be
 # registered.
-from .box.base.base_sandbox import BaseSandbox, BaseSandboxAsync
-from .box.browser.browser_sandbox import BrowserSandbox, BrowserSandboxAsync
-from .box.filesystem.filesystem_sandbox import (
-    FilesystemSandbox,
-    FilesystemSandboxAsync,
-)
-from .box.gui.gui_sandbox import GuiSandbox, GuiSandboxAsync
-from .box.mobile.mobile_sandbox import MobileSandbox, MobileSandboxAsync
+from .box.base.base_sandbox import BaseSandbox
+from .box.browser.browser_sandbox import BrowserSandbox
+from .box.filesystem.filesystem_sandbox import FilesystemSandbox
+from .box.gui.gui_sandbox import GuiSandbox
 from .box.training_box.training_box import TrainingSandbox
 from .box.cloud.cloud_sandbox import CloudSandbox
+from .box.mobile.mobile_sandbox import MobileSandbox
 from .box.agentbay.agentbay_sandbox import AgentbaySandbox
 
 __all__ = [
     "BaseSandbox",
-    "BaseSandboxAsync",
     "BrowserSandbox",
-    "BrowserSandboxAsync",
     "FilesystemSandbox",
-    "FilesystemSandboxAsync",
     "GuiSandbox",
-    "GuiSandboxAsync",
-    "MobileSandbox",
-    "MobileSandboxAsync",
     "TrainingSandbox",
     "CloudSandbox",
+    "MobileSandbox",
     "AgentbaySandbox",
 ]

agentscope_runtime/sandbox/box/base/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .base_sandbox import BaseSandbox, BaseSandboxAsync
+from .base_sandbox import BaseSandbox
 
-__all__ = ["BaseSandbox", "BaseSandboxAsync"]
+__all__ = ["BaseSandbox"]

agentscope_runtime/sandbox/box/base/base_sandbox.py

@@ -4,7 +4,7 @@ from typing import Optional
 from ...utils import build_image_uri
 from ...registry import SandboxRegistry
 from ...enums import SandboxType
-from ...box.sandbox import Sandbox, SandboxAsync
+from ...box.sandbox import Sandbox
 from ...constant import TIMEOUT
 
 
@@ -49,53 +49,3 @@ class BaseSandbox(Sandbox):
             command (str): Shell command to execute.
         """
         return self.call_tool("run_shell_command", {"command": command})
-
-
-@SandboxRegistry.register(
-    build_image_uri("runtime-sandbox-base"),
-    sandbox_type=SandboxType.BASE_ASYNC,
-    security_level="medium",
-    timeout=TIMEOUT,
-    description="Base Sandbox (Async)",
-)
-class BaseSandboxAsync(SandboxAsync):
-    def __init__(
-        self,
-        sandbox_id: Optional[str] = None,
-        timeout: int = 3000,
-        base_url: Optional[str] = None,
-        bearer_token: Optional[str] = None,
-        sandbox_type: SandboxType = SandboxType.BASE_ASYNC,
-    ):
-        super().__init__(
-            sandbox_id,
-            timeout,
-            base_url,
-            bearer_token,
-            sandbox_type,
-        )
-
-    async def run_ipython_cell(self, code: str):
-        """
-        Run an IPython cell asynchronously.
-
-        Args:
-            code (str): IPython code to execute.
-        Returns:
-            Any: Response from sandbox execution
-        """
-        return await self.call_tool_async("run_ipython_cell", {"code": code})
-
-    async def run_shell_command(self, command: str):
-        """
-        Run a shell command asynchronously.
-
-        Args:
-            command (str): Shell command to execute.
-        Returns:
-            Any: Response from sandbox execution
-        """
-        return await self.call_tool_async(
-            "run_shell_command",
-            {"command": command},
-        )

agentscope_runtime/sandbox/box/browser/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
-from .browser_sandbox import BrowserSandbox, BrowserSandboxAsync
+from .browser_sandbox import BrowserSandbox
 
-__all__ = ["BrowserSandbox", "BrowserSandboxAsync"]
+__all__ = ["BrowserSandbox"]