agentscope-runtime 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

agentscope_runtime/cli/utils/console.py

@@ -0,0 +1,378 @@
+# -*- coding: utf-8 -*-
+"""Console output utilities for CLI using Rich library."""
+
+import io
+import json
+from typing import Optional, Any
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.json import JSON
+
+
+# Centralized style configuration
+CONSOLE_CONFIG = {
+    "success": {
+        "emoji": "✓",
+        "style": "bold green",
+    },
+    "error": {
+        "emoji": "✗",
+        "style": "bold red",
+    },
+    "warning": {
+        "emoji": "⚠",
+        "style": "bold yellow",
+    },
+    "info": {
+        "emoji": "ℹ",
+        "style": "bold blue",
+    },
+}
+
+# Module-level console instances (lazy initialization)
+_console = None
+_err_console = None
+
+
+def _get_console() -> Console:
+    """Get or create the shared console instance for stdout."""
+    global _console
+    if _console is None:
+        _console = Console()
+    return _console
+
+
+def _get_err_console() -> Console:
+    """Get or create the shared console instance for stderr."""
+    global _err_console
+    if _err_console is None:
+        _err_console = Console(stderr=True)
+    return _err_console
+
+
+def _process_kwargs(kwargs: dict) -> tuple[dict, str]:
+    """
+    Process kwargs to handle Click-specific parameters.
+
+    Returns:
+        Tuple of (rich_kwargs, end_char)
+    """
+    # Handle Click's nl parameter
+    nl = kwargs.pop("nl", True)
+    end = "\n" if nl else ""
+
+    # Handle Click's err parameter (should be handled by console selection)
+    kwargs.pop("err", None)
+
+    # Click's color parameters - ignore, use theme instead
+    kwargs.pop("fg", None)
+    kwargs.pop("bg", None)
+    kwargs.pop("bold", None)
+    kwargs.pop("dim", None)
+
+    return kwargs, end
+
+
+def echo_success(message: str, **kwargs) -> None:
+    """
+    Print success message in green with checkmark.
+
+    Uses Rich library for enhanced terminal output with automatic
+    cross-platform support (including Windows).
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+                  (e.g., highlight=False, markup=False)
+
+    Note:
+        Legacy Click kwargs (nl, err, fg, bold) are supported for
+        backward compatibility but are deprecated.
+
+    Example:
+        >>> echo_success("Deployment completed successfully")
+        ✓ Deployment completed successfully
+    """
+    console = _get_console()
+    config = CONSOLE_CONFIG["success"]
+    kwargs, end = _process_kwargs(kwargs)
+
+    formatted_message = f"{config['emoji']} {message}"
+    console.print(formatted_message, style=config["style"], end=end, **kwargs)
+
+
+def echo_error(message: str, **kwargs) -> None:
+    """
+    Print error message in red with X mark to stderr.
+
+    Uses Rich library for enhanced terminal output with automatic
+    cross-platform support (including Windows).
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+
+    Note:
+        Legacy Click kwargs (nl, err, fg, bold) are supported for
+        backward compatibility but are deprecated.
+
+    Example:
+        >>> echo_error("Deployment failed")
+        ✗ Deployment failed
+    """
+    console = _get_err_console()
+    config = CONSOLE_CONFIG["error"]
+    kwargs, end = _process_kwargs(kwargs)
+
+    formatted_message = f"{config['emoji']} {message}"
+    console.print(formatted_message, style=config["style"], end=end, **kwargs)
+
+
+def echo_warning(message: str, **kwargs) -> None:
+    """
+    Print warning message in yellow with warning symbol.
+
+    Uses Rich library for enhanced terminal output with automatic
+    cross-platform support (including Windows).
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+
+    Note:
+        Legacy Click kwargs (nl, err, fg, bold) are supported for
+        backward compatibility but are deprecated.
+
+    Example:
+        >>> echo_warning("Configuration file not found, using defaults")
+        ⚠ Configuration file not found, using defaults
+    """
+    console = _get_console()
+    config = CONSOLE_CONFIG["warning"]
+    kwargs, end = _process_kwargs(kwargs)
+
+    formatted_message = f"{config['emoji']} {message}"
+    console.print(formatted_message, style=config["style"], end=end, **kwargs)
+
+
+def echo_info(message: str, **kwargs) -> None:
+    """
+    Print info message in blue with info symbol.
+
+    Uses Rich library for enhanced terminal output with automatic
+    cross-platform support (including Windows).
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+
+    Note:
+        Legacy Click kwargs (nl, err, fg, bold) are supported for
+        backward compatibility but are deprecated.
+
+    Example:
+        >>> echo_info("Loading configuration...")
+        ℹ Loading configuration...
+    """
+    console = _get_console()
+    config = CONSOLE_CONFIG["info"]
+    kwargs, end = _process_kwargs(kwargs)
+
+    formatted_message = f"{config['emoji']} {message}"
+    console.print(formatted_message, style=config["style"], end=end, **kwargs)
+
+
+def echo_header(message: str, **kwargs) -> None:
+    """
+    Print header message in bold.
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+
+    Example:
+        >>> echo_header("Deployment Summary")
+        Deployment Summary
+    """
+    console = _get_console()
+    kwargs, end = _process_kwargs(kwargs)
+    console.print(message, style="bold", end=end, **kwargs)
+
+
+def echo_dim(message: str, **kwargs) -> None:
+    """
+    Print dimmed message.
+
+    Args:
+        message: Message to display
+        **kwargs: Additional Rich Console.print() parameters
+
+    Example:
+        >>> echo_dim("Additional details...")
+        Additional details...
+    """
+    console = _get_console()
+    kwargs, end = _process_kwargs(kwargs)
+    console.print(message, style="dim", end=end, **kwargs)
+
+
+def format_table(
+    headers: list[str],
+    rows: list[list[Any]],
+    max_width: Optional[int] = None,
+) -> str:
+    """
+    Format data as a Rich Table (returns rendered string).
+
+    Uses Rich library for enhanced table rendering with better alignment
+    and visual appeal compared to ASCII tables.
+
+    Args:
+        headers: List of column headers
+        rows: List of rows, where each row is a list of cell values
+        max_width: Optional maximum width for columns
+
+    Returns:
+        Rendered table as a string for backward compatibility
+
+    Example:
+        >>> headers = ["ID", "Status"]
+        >>> rows = [["deploy_1", "running"], ["deploy_2", "stopped"]]
+        >>> print(format_table(headers, rows))
+    """
+    if not rows:
+        return "No data to display."
+
+    # Create Rich table
+    table = Table(show_header=True, header_style="bold cyan")
+
+    # Add columns
+    for header in headers:
+        table.add_column(header, max_width=max_width)
+
+    # Add rows
+    for row in rows:
+        table.add_row(*[str(cell) for cell in row])
+
+    # Render table to string for backward compatibility
+    string_io = io.StringIO()
+    temp_console = Console(file=string_io, force_terminal=True)
+    temp_console.print(table)
+    return string_io.getvalue()
+
+
+def format_json(data: Any, indent: int = 2) -> str:
+    """
+    Format data as JSON with syntax highlighting.
+
+    Uses Rich library for syntax-highlighted JSON output.
+
+    Args:
+        data: Data to format as JSON
+        indent: Indentation level (default: 2)
+
+    Returns:
+        Rendered JSON as a string with syntax highlighting
+
+    Example:
+        >>> data = {"key": "value", "number": 123}
+        >>> print(format_json(data))
+    """
+    # Rich's JSON requires a string, not an object
+    json_string = json.dumps(data, indent=indent, default=str)
+
+    # Render to string for backward compatibility
+    string_io = io.StringIO()
+    temp_console = Console(file=string_io, force_terminal=True)
+    temp_console.print(JSON(json_string, indent=indent))
+    return string_io.getvalue()
+
+
+def format_deployment_info(deployment: dict) -> str:
+    """
+    Format deployment information using Rich Table.
+
+    Uses Rich library for structured key-value display.
+
+    Args:
+        deployment: Dictionary containing deployment information
+
+    Returns:
+        Rendered deployment info as a string
+
+    Example:
+        >>> deployment = {
+        ...     "id": "local_123",
+        ...     "platform": "local",
+        ...     "status": "running",
+        ...     "url": "http://localhost:8000",
+        ...     "created_at": "2025-01-01 12:00:00",
+        ...     "agent_source": "agent.py"
+        ... }
+        >>> print(format_deployment_info(deployment))
+    """
+    # Create table with no header for key-value pairs
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="bold cyan")
+    table.add_column("Value", style="white")
+
+    # Add deployment information
+    table.add_row("Deployment ID", deployment["id"])
+    table.add_row("Platform", deployment["platform"])
+    table.add_row("Status", deployment["status"])
+    table.add_row("URL", deployment["url"])
+    table.add_row("Created", deployment["created_at"])
+    table.add_row("Agent Source", deployment["agent_source"])
+
+    # Add token if present
+    if deployment.get("token"):
+        token = deployment["token"]
+        display_token = f"{token[:20]}..." if len(token) > 20 else token
+        table.add_row("Token", display_token)
+
+    # Render to string for backward compatibility
+    string_io = io.StringIO()
+    temp_console = Console(file=string_io, force_terminal=True)
+    temp_console.print(table)
+    return string_io.getvalue()
+
+
+def confirm(message: str, default: bool = False) -> bool:
+    """
+    Prompt user for confirmation.
+
+    Uses Click's confirm function (unchanged from original implementation).
+
+    Args:
+        message: Confirmation message
+        default: Default value if user just presses Enter
+
+    Returns:
+        True if user confirms, False otherwise
+
+    Example:
+        >>> if confirm("Delete deployment?"):
+        ...     # proceed with deletion
+    """
+    return click.confirm(message, default=default)
+
+
+def prompt(message: str, default: Optional[str] = None) -> str:
+    """
+    Prompt user for input.
+
+    Uses Click's prompt function (unchanged from original implementation).
+
+    Args:
+        message: Prompt message
+        default: Default value if user just presses Enter
+
+    Returns:
+        User input as string
+
+    Example:
+        >>> name = prompt("Enter deployment name")
+    """
+    return click.prompt(message, default=default)

agentscope_runtime/cli/utils/validators.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+"""Input validation utilities for CLI."""
+
+import os
+
+from agentscope_runtime.engine.deployers.state import DeploymentStateManager
+
+
+class ValidationError(Exception):
+    """Raised when validation fails."""
+
+
+def validate_agent_source(source: str) -> tuple[str, str]:
+    """
+    Validate and determine the type of agent source.
+
+    Args:
+        source: Path to file/directory or deployment ID
+
+    Returns:
+        Tuple of (source_type, normalized_path/id)
+        source_type can be: 'file', 'directory', 'deployment_id'
+
+    Raises:
+        ValidationError: If source is invalid
+    """
+    if not source:
+        raise ValidationError("Agent source cannot be empty")
+
+    # Check if it's a file
+    if os.path.isfile(source):
+        if not source.endswith(".py"):
+            raise ValidationError(
+                f"Agent source file must be a Python file: {source}",
+            )
+        return ("file", os.path.abspath(source))
+
+    # Check if it's a directory
+    if os.path.isdir(source):
+        return ("directory", os.path.abspath(source))
+
+    # Check if it's a deployment ID by querying state manager
+    # This ensures we only accept deployment IDs that actually exist
+    # Support both formats: platform_timestamp_id (with underscore) and UUID
+    # format
+    state_manager = DeploymentStateManager()
+    if state_manager.exists(source):
+        return ("deployment_id", source)
+
+    raise ValidationError(
+        f"Invalid agent source: {source}\n"
+        "Must be a Python file (.py), directory, or deployment ID",
+    )
+
+
+def validate_port(port: int) -> int:
+    """Validate port number."""
+    if not isinstance(port, int):
+        try:
+            port = int(port)
+        except (ValueError, TypeError) as e:
+            raise ValidationError(f"Port must be an integer: {port}") from e
+
+    if port < 1 or port > 65535:
+        raise ValidationError(f"Port must be between 1 and 65535: {port}")
+
+    return port
+
+
+def validate_platform(platform: str, supported_platforms: list[str]) -> str:
+    """Validate platform name."""
+    if platform not in supported_platforms:
+        raise ValidationError(
+            f"Unsupported platform: {platform}\n"
+            f"Supported platforms: {', '.join(supported_platforms)}",
+        )
+    return platform
+
+
+def validate_file_exists(file_path: str) -> str:
+    """Validate that file exists."""
+    if not os.path.isfile(file_path):
+        raise ValidationError(f"File not found: {file_path}")
+    return os.path.abspath(file_path)
+
+
+def validate_directory_exists(dir_path: str) -> str:
+    """Validate that directory exists."""
+    if not os.path.isdir(dir_path):
+        raise ValidationError(f"Directory not found: {dir_path}")
+    return os.path.abspath(dir_path)
+
+
+def validate_url(url: str) -> str:
+    """Basic URL validation."""
+    if not url:
+        raise ValidationError("URL cannot be empty")
+
+    if not (url.startswith("http://") or url.startswith("https://")):
+        raise ValidationError(
+            f"URL must start with http:// or https://: {url}",
+        )
+
+    return url
+
+
+def validate_deployment_id(deploy_id: str) -> str:
+    """Validate deployment ID format."""
+    if not deploy_id:
+        raise ValidationError("Deployment ID cannot be empty")
+
+    if "_" not in deploy_id:
+        raise ValidationError(
+            f"Invalid deployment ID format: {deploy_id}\n"
+            "Expected format: platform_timestamp_id",
+        )
+
+    return deploy_id

agentscope_runtime/common/collections/redis_mapping.py

@@ -38,7 +38,10 @@ class RedisMapping(Mapping):
                 match=search_pattern,
             )
             for key in keys:
-                decoded_key = key.decode("utf-8")
+                if isinstance(key, bytes):
+                    decoded_key = key.decode("utf-8")
+                else:
+                    decoded_key = str(key)
                 yield self._strip_prefix(decoded_key)
 
             if cursor == 0:

agentscope_runtime/engine/app/agent_app.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
+import os
 import types
 import platform
 import subprocess
@@ -11,7 +12,11 @@ from pydantic import BaseModel
 
 from .base_app import BaseApp
 from ..deployers import DeployManager
-from ..deployers.adapter.a2a import A2AFastAPIDefaultAdapter
+from ..deployers.adapter.a2a import (
+    A2AFastAPIDefaultAdapter,
+    AgentCardWithRuntimeConfig,
+    extract_a2a_config,
+)
 from ..deployers.adapter.responses.response_api_protocol_adapter import (
     ResponseAPIDefaultAdapter,
 )
@@ -22,6 +27,8 @@ from ..schemas.agent_schemas import AgentRequest
 from ...version import __version__
 
 logger = logging.getLogger(__name__)
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", "8080"))
 
 
 class AgentApp(BaseApp):
@@ -44,14 +51,49 @@ class AgentApp(BaseApp):
         backend_url: Optional[str] = None,
         runner: Optional[Runner] = None,
         enable_embedded_worker: bool = False,
+        a2a_config: Optional["AgentCardWithRuntimeConfig"] = None,
         **kwargs,
     ):
         """
         Initialize the AgentApp.
 
         Args:
-            *args: Variable length argument list.
-            **kwargs: Arbitrary keyword arguments.
+            app_name: Name of the agent application
+            app_description: Description of the agent application
+            endpoint_path: API endpoint path for processing requests
+            response_type: Type of response (default: "sse")
+            stream: Whether to enable streaming responses
+            request_model: Request model class
+            before_start: Callback function to execute before starting
+            after_finish: Callback function to execute after finishing
+            broker_url: URL for message broker
+            backend_url: URL for backend service
+            runner: Optional runner instance
+            enable_embedded_worker: Whether to enable embedded worker
+            a2a_config: Optional A2A runtime configuration.
+                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
+                        AgentCardWithRuntimeConfig,
+                    )
+                    config = AgentCardWithRuntimeConfig(
+                        agent_card={
+                            "name": "MyAgent",
+                            "version": "1.0.0",
+                            "description": "My agent",
+                            "url": "http://localhost:8080",
+                            "capabilities": AgentCapabilities(),
+                            "default_input_modes": ["text"],
+                            "default_output_modes": ["text"],
+                            "skills": [],
+                        },
+                        registry=[nacos_registry],
+                        task_timeout=120,
+                    )
+            **kwargs: Additional keyword arguments passed to FastAPI app
         """
 
         self.endpoint_path = endpoint_path
@@ -73,9 +115,13 @@ class AgentApp(BaseApp):
         self._shutdown_handler: Optional[Callable] = None
         self._framework_type: Optional[str] = None
 
+        # Prepare A2A protocol adapter configuration
+        a2a_config = extract_a2a_config(a2a_config=a2a_config)
+
         a2a_protocol = A2AFastAPIDefaultAdapter(
             agent_name=app_name,
             agent_description=app_description,
+            a2a_config=a2a_config,
         )
 
         response_protocol = ResponseAPIDefaultAdapter()
@@ -93,8 +139,8 @@ class AgentApp(BaseApp):
             backend_url=backend_url,
         )
 
-        # Store custom endpoints and tasks for deployment
-        # but don't add them to FastAPI here - let FastAPIAppFactory handle it
+        # Store custom endpoints for deployment
+        # FastAPIAppFactory will handle adding them to FastAPI
 
     def init(self, func):
         """Register init hook (support async and sync functions)."""
@@ -150,8 +196,8 @@ class AgentApp(BaseApp):
 
     def run(
         self,
-        host="0.0.0.0",
-        port=8090,
+        host=HOST,
+        port=PORT,
         web_ui=False,
         **kwargs,
     ):
@@ -171,7 +217,7 @@ class AgentApp(BaseApp):
 
         Args:
             host (str): Host address to bind to. Default "0.0.0.0".
-            port (int): Port number to serve the application on. Default 8090.
+            port (int): Port number to serve the application on. Default 8080.
             web_ui (bool): If True, launches the Agentscope Web UI in a
                 separate process, pointing it to the API endpoint. This
                 allows interactive use via browser. Default False.
@@ -180,7 +226,7 @@ class AgentApp(BaseApp):
 
         Example:
             >>> app = AgentApp(app_name="MyAgent")
-            >>> app.run(host="127.0.0.1", port=8000, web_ui=True)
+            >>> app.chat(host="127.0.0.1", port=8080, web_ui=True)
         """
         # Build runner
         self._build_runner()

agentscope_runtime/engine/deployers/__init__.py

@@ -3,6 +3,7 @@ from .base import DeployManager
 from .local_deployer import LocalDeployManager
 from .kubernetes_deployer import (
     KubernetesDeployManager,
+    K8sConfig,
 )
 from .modelstudio_deployer import (
     ModelstudioDeployManager,