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

agentscope_runtime/adapters/agentscope/stream.py

@@ -9,7 +9,6 @@ from urllib.parse import urlparse
 from agentscope import setup_logger
 from agentscope.message import Msg
 
-from ..utils import _update_obj_attrs
 from ...engine.schemas.agent_schemas import (
     Message,
     Content,
@@ -27,6 +26,13 @@ from ...engine.schemas.agent_schemas import (
 setup_logger("ERROR")
 
 
+def _update_obj_attrs(obj, **attrs):
+    for key, value in attrs.items():
+        if hasattr(obj, key):
+            setattr(obj, key, value)
+    return obj
+
+
 async def adapt_agentscope_message_stream(
     source_stream: AsyncIterator[Tuple[Msg, bool]],
 ) -> AsyncIterator[Union[Message, Content]]:

agentscope_runtime/cli/commands/deploy.py

@@ -56,15 +56,6 @@ try:
 except ImportError:
     K8S_AVAILABLE = False
 
-try:
-    from agentscope_runtime.engine.deployers.knative_deployer import (
-        KnativeDeployManager,
-    )
-
-    KNATIVE_AVAILABLE = True
-except ImportError:
-    KNATIVE_AVAILABLE = False
-
 
 def _validate_source(source: str) -> tuple[str, str]:
     """
@@ -256,7 +247,6 @@ def deploy():
     - agentrun: Alibaba Cloud AgentRun
     - k8s: Kubernetes/ACK
     - local: Local deployment (detached mode)
-    - Knative: Knative/ACK Knative
 
     Use 'agentscope deploy <platform> --help' for platform-specific options.
     """
@@ -1080,366 +1070,5 @@ def k8s(
         sys.exit(1)
 
 
-@deploy.command()
-@click.argument("source", required=True)
-@click.option("--name", help="Deployment name", default=None)
-@click.option(
-    "--namespace",
-    help="Kubernetes namespace",
-    default="agentscope-runtime",
-)
-@click.option(
-    "--kube-config-path",
-    "-c",
-    type=click.Path(exists=True),
-    help="Path to knative service config file (.json, .yaml, or .yml)",
-)
-@click.option(
-    "--port",
-    help="Container port",
-    type=int,
-    default=8080,
-)
-@click.option(
-    "--image-name",
-    help="Docker image name",
-    default="agent_app",
-)
-@click.option(
-    "--image-tag",
-    help="Docker image tag",
-    default="linux-amd64",
-)
-@click.option(
-    "--registry-url",
-    help="Remote registry url",
-    default="localhost",
-)
-@click.option(
-    "--registry-namespace",
-    help="Remote registry namespace",
-    default="agentscope-runtime",
-)
-@click.option(
-    "--push",
-    is_flag=True,
-    help="Push image to registry",
-)
-@click.option(
-    "--entrypoint",
-    "-e",
-    help="Entrypoint file name for directory sources (e.g., 'app.py', "
-    "'main.py')",
-    default=None,
-)
-@click.option(
-    "--env",
-    "-E",
-    multiple=True,
-    help="Environment variable in KEY=VALUE format (can be repeated)",
-)
-@click.option(
-    "--env-file",
-    type=click.Path(exists=True),
-    help="Path to .env file with environment variables",
-)
-@click.option(
-    "--config",
-    "-c",
-    type=click.Path(exists=True),
-    help="Path to knative service config file (.json, .yaml, or .yml)",
-)
-@click.option(
-    "--base-image",
-    help="Base Docker image",
-    default="python:3.10-slim-bookworm",
-)
-@click.option(
-    "--requirements",
-    help="Python requirements (comma-separated or file path)",
-    default=None,
-)
-@click.option(
-    "--cpu-request",
-    help="CPU resource request (e.g., '200m', '1')",
-    default="200m",
-)
-@click.option(
-    "--cpu-limit",
-    help="CPU resource limit (e.g., '1000m', '2')",
-    default="1000m",
-)
-@click.option(
-    "--memory-request",
-    help="Memory resource request (e.g., '512Mi', '1Gi')",
-    default="512Mi",
-)
-@click.option(
-    "--memory-limit",
-    help="Memory resource limit (e.g., '2Gi', '4Gi')",
-    default="2Gi",
-)
-@click.option(
-    "--image-pull-policy",
-    help="Image pull policy",
-    type=click.Choice(["Always", "IfNotPresent", "Never"]),
-    default="IfNotPresent",
-)
-@click.option(
-    "--deploy-timeout",
-    help="Deployment timeout in seconds",
-    type=int,
-    default=300,
-)
-@click.option(
-    "--health-check",
-    is_flag=True,
-    help="Enable/disable health check",
-)
-@click.option(
-    "--platform",
-    help="Target platform (e.g., 'linux/amd64', 'linux/arm64')",
-    default="linux/amd64",
-)
-@click.option(
-    "--pypi-mirror",
-    help="PyPI mirror URL for pip package installation (e.g., "
-    "https://pypi.tuna.tsinghua.edu.cn/simple). If not specified, "
-    "uses pip default.",
-    default=None,
-)
-def knative(
-    source: str,
-    name: str,
-    namespace: str,
-    kube_config_path: str,
-    port: int,
-    image_name: str,
-    image_tag: str,
-    registry_url: str,
-    registry_namespace: str,
-    push: bool,
-    entrypoint: str,
-    env: tuple,
-    env_file: str,
-    config: str,
-    base_image: str,
-    requirements: str,
-    cpu_request: str,
-    cpu_limit: str,
-    memory_request: str,
-    memory_limit: str,
-    image_pull_policy: str,
-    deploy_timeout: int,
-    health_check: bool,
-    platform: str,
-    pypi_mirror: str,
-):
-    """
-    Deploy to Knative/ACK Knative.
-
-    SOURCE can be a Python file or project directory containing an agent.
-
-    This will build a Docker image and deploy it to your Knative cluster.
-    """
-    if not KNATIVE_AVAILABLE:
-        echo_error("Knative deployer is not available")
-        echo_info("Please ensure Knative are available")
-        sys.exit(1)
-
-    try:
-        echo_info(f"Preparing deployment from {source}...")
-
-        # Load config file if provided
-        config_dict = {}
-        if config:
-            echo_info(f"Loading configuration from {config}...")
-            config_dict = _load_config_file(config)
-
-        # make sure not to push if use local registry_url
-        if registry_url == "localhost":
-            push = False
-
-        # Merge CLI parameters with config (CLI takes precedence)
-        cli_params = {
-            "name": name,
-            "namespace": namespace,
-            "port": port,
-            "image_name": image_name,
-            "image_tag": image_tag,
-            "registry_url": registry_url,
-            "registry_namespace": registry_namespace,
-            "push_to_registry": push if push else None,
-            "entrypoint": entrypoint,
-            "base_image": base_image,
-            "requirements": requirements,
-            "image_pull_policy": image_pull_policy,
-            "deploy_timeout": deploy_timeout,
-            "health_check": health_check,
-            "platform": platform,
-            "pypi_mirror": pypi_mirror,
-        }
-        merged_config = _merge_config(config_dict, cli_params)
-
-        # Extract parameters with defaults
-        namespace = merged_config.get("namespace", "agentscope-runtime")
-        port = merged_config.get("port", 8080)
-        image_name = merged_config.get("image_name", "agent_llm")
-        image_tag = merged_config.get("image_tag", "latest")
-        registry_url = merged_config.get("registry_url", "localhost")
-        registry_namespace = merged_config.get(
-            "registry_namespace",
-            "agentscope-runtime",
-        )
-        push_to_registry = merged_config.get("push_to_registry", False)
-        entrypoint = merged_config.get("entrypoint")
-        base_image = merged_config.get("base_image")
-        deploy_timeout = merged_config.get("deploy_timeout", 300)
-        health_check = merged_config.get("health_check", True)
-        platform = merged_config.get("platform")
-        pypi_mirror = merged_config.get("pypi_mirror")
-
-        # Handle requirements (can be comma-separated string, list, or file
-        # path)
-        requirements = merged_config.get("requirements")
-        if requirements:
-            if isinstance(requirements, str):
-                # Check if it's a file path
-                if os.path.isfile(requirements):
-                    with open(requirements, "r", encoding="utf-8") as f:
-                        requirements = [
-                            line.strip()
-                            for line in f
-                            if line.strip() and not line.startswith("#")
-                        ]
-                else:
-                    # Treat as comma-separated string
-                    requirements = [r.strip() for r in requirements.split(",")]
-
-        # Handle extra_packages
-        extra_packages = merged_config.get("extra_packages", [])
-
-        # Handle image_pull_policy
-        image_pull_policy = merged_config.get("image_pull_policy")
-
-        # Build runtime_config from resource parameters
-        runtime_config = merged_config.get("runtime_config", {})
-        if not runtime_config.get("resources"):
-            resources = {}
-            if cpu_request or memory_request:
-                resources["requests"] = {}
-                if cpu_request:
-                    resources["requests"]["cpu"] = cpu_request
-                if memory_request:
-                    resources["requests"]["memory"] = memory_request
-            if cpu_limit or memory_limit:
-                resources["limits"] = {}
-                if cpu_limit:
-                    resources["limits"]["cpu"] = cpu_limit
-                if memory_limit:
-                    resources["limits"]["memory"] = memory_limit
-            if resources:
-                runtime_config["resources"] = resources
-
-        if image_pull_policy and "image_pull_policy" not in runtime_config:
-            runtime_config["image_pull_policy"] = image_pull_policy
-
-        # Validate source
-        abs_source, source_type = _validate_source(source)
-
-        # Parse environment variables (from config, env_file, and CLI)
-        environment = merged_config.get("environment", {}).copy()
-        cli_env = _parse_environment(env, env_file)
-        environment.update(cli_env)  # CLI env overrides config env
-
-        if environment:
-            echo_info(f"Using {len(environment)} environment variable(s)")
-
-        # Create deployer
-        k8s_config = K8sConfig(
-            k8s_namespace=namespace,
-            kubeconfig_path=kube_config_path,
-        )
-        registry_config = RegistryConfig(
-            registry_url=registry_url,
-            namespace=registry_namespace,
-        )
-        deployer = KnativeDeployManager(
-            kube_config=k8s_config,
-            registry_config=registry_config,
-        )
-
-        # Prepare entrypoint specification
-        if source_type == "directory":
-            # For directory: find entrypoint and create path
-            project_dir = abs_source
-            entry_script = _find_entrypoint(project_dir, entrypoint)
-            entrypoint_spec = os.path.join(project_dir, entry_script)
-
-            echo_info(f"Using project directory: {project_dir}")
-            echo_info(f"Entry script: {entry_script}")
-        else:
-            # For single file: use file path directly
-            entrypoint_spec = abs_source
-
-            echo_info(f"Using file: {abs_source}")
-
-        # Deploy to Knative using entrypoint
-        echo_info("Deploying to Knative...")
-
-        # Build deploy parameters
-        deploy_params = {
-            "entrypoint": entrypoint_spec,
-            "port": port,
-            "image_name": image_name,
-            "image_tag": image_tag,
-            "push_to_registry": push_to_registry,
-            "environment": environment if environment else None,
-        }
-
-        # Add optional parameters if provided
-        if base_image:
-            deploy_params["base_image"] = base_image
-        if requirements:
-            deploy_params["requirements"] = requirements
-        if extra_packages:
-            deploy_params["extra_packages"] = extra_packages
-        if runtime_config:
-            deploy_params["runtime_config"] = runtime_config
-        if deploy_timeout:
-            deploy_params["deploy_timeout"] = deploy_timeout
-        if health_check is not None:
-            deploy_params["health_check"] = health_check
-        if platform:
-            deploy_params["platform"] = platform
-        if pypi_mirror:
-            deploy_params["pypi_mirror"] = pypi_mirror
-
-        # Add agent_source for state saving
-        deploy_params["agent_source"] = abs_source
-        deploy_params["labels"] = {
-            "app": "agent-ksvc",
-        }
-
-        result = asyncio.run(deployer.deploy(**deploy_params))
-
-        deploy_id = result.get("deploy_id")
-        url = result.get("url")
-        resource_name = result.get("resource_name")
-
-        echo_success("Deployment successful!")
-        echo_info(f"Deployment ID: {deploy_id}")
-        echo_info(f"Resource Name: {resource_name}")
-        echo_info(f"URL: {url}")
-        echo_info(f"Namespace: {namespace}")
-
-    except Exception as e:
-        echo_error(f"Deployment failed: {e}")
-        import traceback
-
-        echo_error(traceback.format_exc())
-        sys.exit(1)
-
-
 if __name__ == "__main__":
     deploy()

agentscope_runtime/engine/__init__.py

@@ -11,10 +11,8 @@ if TYPE_CHECKING:
         DeployManager,
         LocalDeployManager,
         KubernetesDeployManager,
-        KnativeDeployManager,
         ModelstudioDeployManager,
         AgentRunDeployManager,
-        FCDeployManager,
     )
 
 
@@ -24,9 +22,7 @@ install_lazy_loader(
         "DeployManager": ".deployers",
         "LocalDeployManager": ".deployers",
         "KubernetesDeployManager": ".deployers",
-        "KnativeDeployManager": ".deployers",
         "ModelstudioDeployManager": ".deployers",
         "AgentRunDeployManager": ".deployers",
-        "FCDeployManager": ".deployers",
     },
 )

agentscope_runtime/engine/constant.py

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

agentscope_runtime/engine/deployers/__init__.py

@@ -8,9 +8,6 @@ from .kubernetes_deployer import (
 from .modelstudio_deployer import (
     ModelstudioDeployManager,
 )
-from .knative_deployer import (
-    KnativeDeployManager,
-)
 
 try:
     from .agentrun_deployer import (
@@ -19,19 +16,10 @@ try:
 except ImportError:
     AgentRunDeployManager = None  # type: ignore
 
-try:
-    from .fc_deployer import (
-        FCDeployManager,
-    )
-except ImportError:
-    FCDeployManager = None  # type: ignore
-
 __all__ = [
     "DeployManager",
     "LocalDeployManager",
     "KubernetesDeployManager",
     "ModelstudioDeployManager",
     "AgentRunDeployManager",
-    "KnativeDeployManager",
-    "FCDeployManager",
 ]

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

@@ -1,32 +1,57 @@
 # -*- coding: utf-8 -*-
-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
+from .a2a_protocol_adapter import (
+    A2AFastAPIDefaultAdapter,
+    AgentCardWithRuntimeConfig,
+    extract_a2a_config,
+)
+from .a2a_registry import (
+    A2ARegistry,
+    A2ARegistrySettings,
+    get_registry_settings,
+    create_registry_from_env,
+)
 
 # 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 install_lazy_loader when
+# Instead, NacosRegistry is imported lazily via __getattr__ (see below) when
 # actually needed (e.g., when user does: from ... import NacosRegistry).
 
-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",
-        },
-    },
-)
+__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}")

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

@@ -19,18 +19,19 @@ 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
@@ -43,7 +44,7 @@ from ..protocol_adapter import ProtocolAdapter
 logger = logging.getLogger(__name__)
 
 A2A_JSON_RPC_URL = "/a2a"
-DEFAULT_WELLKNOWN_PATH = AGENT_CARD_WELL_KNOWN_PATH
+DEFAULT_WELLKNOWN_PATH = "/.wellknown/agent-card.json"
 DEFAULT_TASK_TIMEOUT = 60
 DEFAULT_TASK_EVENT_TIMEOUT = 10
 DEFAULT_TRANSPORT = "JSONRPC"
@@ -57,12 +58,8 @@ def extract_a2a_config(
 ) -> "AgentCardWithRuntimeConfig":
     """Normalize a2a_config to AgentCardWithRuntimeConfig object.
 
-    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 registry)
+    Ensures a non-null ``AgentCardWithRuntimeConfig`` instance and sets up
+    environment-based registry fallback if registry is not provided.
 
     Args:
         a2a_config: Optional AgentCardWithRuntimeConfig instance.
@@ -73,18 +70,12 @@ def extract_a2a_config(
     if a2a_config is None:
         a2a_config = AgentCardWithRuntimeConfig()
 
-    # Try environment variables only if registry is not explicitly provided
+    # Fallback to environment registry if not provided
     if a2a_config.registry is None:
-        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")
+        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")
 
     return a2a_config