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

agentscope_runtime/cli/commands/invoke.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+"""agentscope invoke command - Invoke a deployed agent."""
+# pylint: disable=no-value-for-parameter
+
+import click
+
+from agentscope_runtime.cli.commands.chat import chat
+from agentscope_runtime.cli.utils.console import echo_info
+
+
+@click.command()
+@click.argument("deploy_id", required=True)
+@click.option(
+    "--query",
+    "-q",
+    help="Single query to execute (non-interactive mode)",
+    default=None,
+)
+@click.option(
+    "--session-id",
+    help="Session ID for conversation continuity",
+    default=None,
+)
+@click.option(
+    "--user-id",
+    help="User ID for the session",
+    default="default_user",
+)
+def invoke(deploy_id: str, query: str, session_id: str, user_id: str):
+    """
+    Invoke a deployed agent (alias for 'run' with deployment ID).
+
+    This is a convenience command that is equivalent to:
+    $ agentscope chat <deploy_id> [options]
+
+    Examples:
+    \b
+    # Interactive mode
+    $ agentscope invoke local_20250101_120000_abc123
+
+    # Single query
+    $ agentscope invoke local_20250101_120000_abc123 --query "Hello"
+    """
+    echo_info(f"Invoking deployment: {deploy_id}")
+
+    # Delegate to run command
+    ctx = click.get_current_context()
+    ctx.invoke(
+        chat,
+        source=deploy_id,
+        query=query,
+        session_id=session_id,
+        user_id=user_id,
+    )
+
+
+if __name__ == "__main__":
+    invoke()

agentscope_runtime/cli/commands/list_cmd.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""agentscope list command - List all deployments."""
+# pylint: disable=no-value-for-parameter, too-many-branches, protected-access
+
+import sys
+from typing import Optional
+
+import click
+
+from agentscope_runtime.engine.deployers.state import DeploymentStateManager
+from agentscope_runtime.cli.utils.console import (
+    echo_error,
+    echo_info,
+    format_table,
+    format_json,
+)
+
+
+@click.command(name="list")
+@click.option(
+    "--status",
+    "-s",
+    help="Filter by status (e.g., running, stopped)",
+    default=None,
+)
+@click.option(
+    "--platform",
+    "-p",
+    help="Filter by platform (e.g., local, k8s, agentrun)",
+    default=None,
+)
+@click.option(
+    "--output-format",
+    "-f",
+    help="Output format: table or json",
+    type=click.Choice(["table", "json"], case_sensitive=False),
+    default="table",
+)
+def list_deployments(
+    status: Optional[str],
+    platform: Optional[str],
+    output_format: str,
+):
+    """
+    List all deployments.
+
+    Examples:
+    \b
+    # List all deployments
+    $ agentscope list
+
+    # Filter by status
+    $ agentscope list --status running
+
+    # Filter by platform
+    $ agentscope list --platform k8s
+
+    # JSON output
+    $ agentscope list --output-format json
+    """
+    try:
+        # Initialize state manager
+        state_manager = DeploymentStateManager()
+
+        # Get deployments
+        deployments = state_manager.list(status=status, platform=platform)
+
+        if not deployments:
+            echo_info("No deployments found")
+            return
+
+        if output_format == "json":
+            # JSON output
+            output = [d.to_dict() for d in deployments]
+            print(format_json(output))
+        else:
+            # Table output
+            headers = ["ID", "Platform", "Status", "Created", "URL"]
+            rows = []
+
+            for d in deployments:
+                # Truncate long IDs and URLs
+                deploy_id = d.id if len(d.id) <= 30 else d.id[:27] + "..."
+                url = d.url if len(d.url) <= 40 else d.url[:37] + "..."
+                created = (
+                    d.created_at[:19]
+                    if len(d.created_at) > 19
+                    else d.created_at
+                )
+
+                rows.append([deploy_id, d.platform, d.status, created, url])
+
+            print(format_table(headers, rows))
+
+            echo_info(f"\nTotal: {len(deployments)} deployment(s)")
+
+    except Exception as e:
+        echo_error(f"Failed to list deployments: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    list_deployments()

agentscope_runtime/cli/commands/run.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+"""agentscope run command - Start agent service without interactive mode."""
+# pylint: disable=too-many-statements, no-value-for-parameter
+
+import logging
+import os
+import sys
+from typing import Optional
+
+import click
+
+from agentscope_runtime.cli.loaders.agent_loader import (
+    UnifiedAgentLoader,
+    AgentLoadError,
+)
+from agentscope_runtime.cli.utils.validators import validate_agent_source
+from agentscope_runtime.engine.deployers.state import DeploymentStateManager
+from agentscope_runtime.cli.utils.console import (
+    echo_error,
+    echo_info,
+    echo_success,
+    echo_warning,
+)
+
+
+@click.command()
+@click.argument("source", required=True)
+@click.option(
+    "--host",
+    "-h",
+    help="Host address to bind to",
+    default="0.0.0.0",
+)
+@click.option(
+    "--port",
+    "-p",
+    help="Port number to serve the application on",
+    type=int,
+    default=8080,
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show verbose output including logs",
+    default=False,
+)
+@click.option(
+    "--entrypoint",
+    "-e",
+    help="Entrypoint file name for directory sources (e.g., 'app.py', "
+    "'main.py')",
+    default=None,
+)
+def run(
+    source: str,
+    host: str,
+    port: int,
+    verbose: bool,
+    entrypoint: Optional[str],
+):
+    """
+    Start agent service and run continuously.
+
+    SOURCE can be:
+    \b
+    - Path to Python file (e.g., agent.py)
+    - Path to project directory (e.g., ./my-agent)
+    - Deployment ID (e.g., local_20250101_120000_abc123)
+
+    The agent service will start and run continuously, allowing users to
+    interact with it via HTTP API endpoints. Logs will be printed based
+    on the verbose flag.
+
+    Examples:
+    \b
+    # Run agent service
+    $ agentscope run agent.py
+
+    # Run with verbose logging
+    $ agentscope run agent.py --verbose
+
+    # Specify custom host and port
+    $ agentscope run agent.py --host 127.0.0.1 --port 8090
+
+    # Use custom entrypoint for directory source
+    $ agentscope run ./my-project --entrypoint custom_app.py
+
+    # Run a deployed agent
+    $ agentscope run local_20250101_120000_abc123
+    """
+    # Configure logging and tracing based on verbose flag
+    if not verbose:
+        # Disable console tracing output (JSON logs)
+        os.environ["TRACE_ENABLE_LOG"] = "false"
+        # Set root logger to WARNING to suppress INFO logs
+        logging.getLogger().setLevel(logging.WARNING)
+        # Also suppress specific library loggers
+        logging.getLogger("agentscope").setLevel(logging.WARNING)
+        logging.getLogger("agentscope_runtime").setLevel(logging.WARNING)
+    else:
+        # Enable console tracing output for verbose mode
+        os.environ["TRACE_ENABLE_LOG"] = "true"
+        # Set root logger to DEBUG for verbose output
+        logging.getLogger().setLevel(logging.INFO)
+        # Also suppress specific library loggers
+        logging.getLogger("agentscope").setLevel(logging.INFO)
+        logging.getLogger("agentscope_runtime").setLevel(logging.INFO)
+
+    try:
+        # Initialize state manager
+        state_manager = DeploymentStateManager()
+
+        # Check if source is a deployment ID
+        try:
+            source_type, _ = validate_agent_source(source)
+        except Exception:
+            # If validation fails, treat as file/directory
+            source_type = None
+
+        if source_type == "deployment_id":
+            # Handle deployment ID
+
+            echo_error(
+                f"Run command not support for Deployment, query the "
+                f"deployment by curl or by `agentscope chat {source}` ",
+            )
+            sys.exit(1)
+
+        else:
+            # Handle file/directory source - load and run agent locally
+            echo_info(f"Loading agent from: {source}")
+            loader = UnifiedAgentLoader(state_manager=state_manager)
+
+            try:
+                agent_app = loader.load(source, entrypoint=entrypoint)
+                echo_success("Agent loaded successfully")
+            except AgentLoadError as e:
+                echo_error(f"Failed to load agent: {e}")
+                sys.exit(1)
+
+            # Start the agent service
+            echo_info("Starting agent service...")
+            echo_info(f"Host: {host}")
+            echo_info(f"Port: {port}")
+            echo_info(
+                "The service will run continuously. Press Ctrl+C to stop.",
+            )
+
+            try:
+                # Run the agent service
+                agent_app.run(host=host, port=port)
+            except KeyboardInterrupt:
+                echo_warning("\nService interrupted by user")
+                sys.exit(0)
+            except Exception as e:
+                echo_error(f"Service error: {e}")
+                import traceback
+
+                if verbose:
+                    traceback.print_exc()
+                sys.exit(1)
+
+    except KeyboardInterrupt:
+        echo_warning("\nInterrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        echo_error(f"Unexpected error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run()

agentscope_runtime/cli/commands/sandbox.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+"""agentscope sandbox command - Sandbox management commands."""
+
+import sys
+
+import click
+
+from agentscope_runtime.cli.utils.console import (
+    echo_error,
+    echo_info,
+)
+
+
+@click.group()
+def sandbox():
+    """
+    Sandbox management commands.
+
+    This consolidates existing sandbox commands under a unified CLI.
+
+    Available commands:
+    \b
+    - mcp: Start MCP server for sandbox
+    - server: Start sandbox manager server
+    - build: Build sandbox environments
+    """
+
+
+@sandbox.command()
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def mcp(args):
+    """
+    Start MCP server for sandbox (delegates to runtime-sandbox-mcp).
+
+    Examples:
+    \b
+    $ agentscope sandbox mcp
+    $ agentscope sandbox mcp --help
+    """
+    try:
+        from agentscope_runtime.sandbox.mcp_server import main as mcp_main
+
+        # Set sys.argv to simulate command line arguments
+        original_argv = sys.argv
+        sys.argv = ["runtime-sandbox-mcp"] + list(args)
+
+        try:
+            mcp_main()
+        finally:
+            # Restore original sys.argv
+            sys.argv = original_argv
+    except ImportError as e:
+        echo_error(f"Failed to import MCP server module: {e}")
+        echo_info("Make sure agentscope-runtime is properly installed")
+        sys.exit(1)
+    except Exception as e:
+        echo_error(f"Failed to run MCP server: {e}")
+        sys.exit(1)
+
+
+@sandbox.command()
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def server(args):
+    """
+    Start sandbox manager server (delegates to runtime-sandbox-server).
+
+    Examples:
+    \b
+    $ agentscope sandbox server
+    $ agentscope sandbox server --help
+    """
+    try:
+        from agentscope_runtime.sandbox.manager.server.app import (
+            main as server_main,
+        )
+
+        # Set sys.argv to simulate command line arguments
+        original_argv = sys.argv
+        sys.argv = ["runtime-sandbox-server"] + list(args)
+
+        try:
+            server_main()
+        finally:
+            # Restore original sys.argv
+            sys.argv = original_argv
+    except ImportError as e:
+        echo_error(f"Failed to import sandbox server module: {e}")
+        echo_info("Make sure agentscope-runtime is properly installed")
+        sys.exit(1)
+    except Exception as e:
+        echo_error(f"Failed to run sandbox server: {e}")
+        sys.exit(1)
+
+
+@sandbox.command()
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def build(args):
+    """
+    Build sandbox environments (delegates to runtime-sandbox-builder).
+
+    Examples:
+    \b
+    $ agentscope sandbox build
+    $ agentscope sandbox build --help
+    """
+    try:
+        from agentscope_runtime.sandbox.build import main as builder_main
+
+        # Set sys.argv to simulate command line arguments
+        original_argv = sys.argv
+        sys.argv = ["runtime-sandbox-builder"] + list(args)
+
+        try:
+            builder_main()
+        finally:
+            # Restore original sys.argv
+            sys.argv = original_argv
+    except ImportError as e:
+        echo_error(f"Failed to import sandbox builder module: {e}")
+        echo_info("Make sure agentscope-runtime is properly installed")
+        sys.exit(1)
+    except Exception as e:
+        echo_error(f"Failed to run sandbox builder: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    sandbox()

agentscope_runtime/cli/commands/status.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+"""agentscope status command - Show deployment status."""
+# pylint: disable=no-value-for-parameter
+
+import sys
+
+import click
+
+from agentscope_runtime.engine.deployers.state import DeploymentStateManager
+from agentscope_runtime.cli.utils.console import (
+    echo_error,
+    format_deployment_info,
+    format_json,
+)
+
+
+@click.command()
+@click.argument("deploy_id", required=True)
+@click.option(
+    "--output-format",
+    "-f",
+    help="Output format: text or json",
+    type=click.Choice(["text", "json"], case_sensitive=False),
+    default="text",
+)
+def status(deploy_id: str, output_format: str):
+    """
+    Show detailed deployment status.
+
+    Examples:
+    \b
+    # Show deployment status
+    $ agentscope status local_20250101_120000_abc123
+
+    # JSON output
+    $ agentscope status local_20250101_120000_abc123 --output-format json
+    """
+    try:
+        # Initialize state manager
+        state_manager = DeploymentStateManager()
+
+        # Get deployment
+        deployment = state_manager.get(deploy_id)
+
+        if deployment is None:
+            echo_error(f"Deployment not found: {deploy_id}")
+            sys.exit(1)
+
+        if output_format == "json":
+            print(format_json(deployment.to_dict()))
+        else:
+            print(format_deployment_info(deployment.to_dict()))
+
+    except Exception as e:
+        echo_error(f"Failed to get deployment status: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    status()

agentscope_runtime/cli/commands/stop.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""agentscope stop command - Stop a deployment."""
+# pylint: disable=too-many-return-statements, too-many-branches
+# pylint: disable=no-value-for-parameter, too-many-statements, unused-argument
+
+import asyncio
+import sys
+from typing import Optional
+
+import click
+
+from agentscope_runtime.engine.deployers.state import DeploymentStateManager
+from agentscope_runtime.cli.utils.console import (
+    echo_error,
+    echo_info,
+    echo_success,
+    echo_warning,
+    confirm,
+)
+from agentscope_runtime.engine.deployers.base import DeployManager
+
+
+def _create_deployer(
+    platform: str,
+    deployment_state: dict,
+) -> Optional[DeployManager]:
+    """Create deployer instance for platform.
+
+    Args:
+        platform: Platform name (local, k8s, modelstudio, agentrun)
+        deployment_state: Deployment state dictionary
+
+    Returns:
+        DeployManager instance or None if creation fails
+    """
+    try:
+        if platform == "local":
+            from agentscope_runtime.engine.deployers import (
+                LocalDeployManager,
+            )
+
+            return LocalDeployManager()
+        elif platform == "k8s":
+            from agentscope_runtime.engine.deployers import (
+                KubernetesDeployManager,
+                K8sConfig,
+            )
+
+            # Create K8sConfig with default namespace
+            k8s_config = K8sConfig(k8s_namespace="agentscope-runtime")
+            return KubernetesDeployManager(kube_config=k8s_config)
+        elif platform == "modelstudio":
+            from agentscope_runtime.engine.deployers import (
+                ModelstudioDeployManager,
+            )
+
+            return ModelstudioDeployManager()
+        elif platform == "agentrun":
+            from agentscope_runtime.engine.deployers.agentrun_deployer import (
+                AgentRunDeployManager,
+            )
+
+            return AgentRunDeployManager()
+        else:
+            echo_warning(f"Unknown platform: {platform}")
+            return None
+    except ImportError as e:
+        echo_warning(f"Failed to import deployer for platform {platform}: {e}")
+        return None
+    except Exception as e:
+        echo_warning(f"Failed to create deployer for platform {platform}: {e}")
+        return None
+
+
+@click.command()
+@click.argument("deploy_id", required=True)
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip confirmation prompt",
+)
+def stop(deploy_id: str, yes: bool):
+    """
+    Stop a deployment and clean up resources.
+
+    This command will:
+    1. Call the platform-specific stop method to clean up deployed resources
+    2. Update the local deployment status to 'stopped'
+
+    Use --force to skip platform cleanup and only update local state.
+
+    Examples:
+    \b
+    # Stop deployment with confirmation
+    $ agentscope stop local_20250101_120000_abc123
+
+    # Skip confirmation
+    $ agentscope stop local_20250101_120000_abc123 --yes
+
+    """
+    try:
+        # Initialize state manager
+        state_manager = DeploymentStateManager()
+
+        # Check if deployment exists
+        deployment = state_manager.get(deploy_id)
+
+        if deployment is None:
+            echo_error(f"Deployment not found: {deploy_id}")
+            sys.exit(1)
+
+        # Check current status
+        if deployment.status == "stopped":
+            echo_warning(f"Deployment {deploy_id} is already stopped")
+            return
+
+        # Get deployment info
+        platform = getattr(deployment, "platform", "unknown")
+
+        # Confirm
+        if not yes:
+            if not confirm(
+                f"Stop deployment {deploy_id} (platform: {platform})?",
+            ):
+                echo_info("Cancelled")
+                return
+
+        # Call deployer stop (unless --force)
+
+        echo_info(f"Calling platform cleanup for {platform}...")
+
+        deployer = _create_deployer(
+            platform,
+            deployment.__dict__ if hasattr(deployment, "__dict__") else {},
+        )
+
+        if deployer:
+            try:
+                # Call stop method - deployer will fetch all needed info
+                # from state
+                result = asyncio.run(deployer.stop(deploy_id))
+
+                if result.get("success"):
+                    echo_success(
+                        f"Platform cleanup: "
+                        f"{result.get('message', 'Success')}",
+                    )
+                else:
+                    echo_error(
+                        f"Platform cleanup failed: "
+                        f"{result.get('message', 'Unknown error')}",
+                    )
+                    echo_error(
+                        "Cannot mark deployment as stopped - platform "
+                        "cleanup failed",
+                    )
+                    sys.exit(1)
+            except Exception as e:
+                echo_error(f"Error during platform cleanup: {e}")
+                echo_error(
+                    "Cannot mark deployment as stopped - platform "
+                    "cleanup failed",
+                )
+                sys.exit(1)
+        else:
+            echo_error(
+                f"Could not create deployer for platform: {platform}",
+            )
+            echo_error(
+                "Cannot mark deployment as stopped - deployer creation "
+                "failed",
+            )
+            echo_info(
+                "\nTip: Use --force flag to skip platform cleanup and "
+                "only update local state",
+            )
+            sys.exit(1)
+    except Exception as e:
+        echo_error(f"Failed to stop deployment: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    stop()