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

agentscope_runtime/engine/deployers/knative_deployer.py

@@ -1,290 +0,0 @@
-# -*- coding: utf-8 -*-
-import logging
-import os
-from typing import Optional, Dict, List, Union, Any
-
-from pydantic import BaseModel, Field
-from .utils.docker_image_utils import (
-    ImageFactory,
-    RegistryConfig,
-)
-from .adapter.protocol_adapter import ProtocolAdapter
-from .base import DeployManager
-from ...common.container_clients.knative_client import (
-    KnativeClient,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class K8sConfig(BaseModel):
-    # Kubernetes settings
-    k8s_namespace: Optional[str] = Field(
-        "agentscope-runtime",
-        description="Kubernetes namespace to deploy KService. ",
-    )
-    kubeconfig_path: Optional[str] = Field(
-        None,
-        description="Path to kubeconfig file. If not set, will try "
-        "in-cluster config or default kubeconfig.",
-    )
-
-
-class BuildConfig(BaseModel):
-    """Build configuration"""
-
-    build_context_dir: str = "/tmp/k8s_build"
-    dockerfile_template: str = None
-    build_timeout: int = 600  # 10 minutes
-    push_timeout: int = 300  # 5 minutes
-    cleanup_after_build: bool = True
-
-
-class KnativeDeployManager(DeployManager):
-    """
-    Deploy an AgentScope runner as a Knative Service.
-    Requires a Kubernetes cluster with Knative Serving installed.
-    """
-
-    def __init__(
-        self,
-        kube_config: K8sConfig = None,
-        registry_config: RegistryConfig = RegistryConfig(),
-        build_context_dir: str = "/tmp/k8s_build",
-    ):
-        """
-        Initialize the Knative deployer.
-        """
-        super().__init__()
-        self.kubeconfig = kube_config
-        self.registry_config = registry_config
-        self.image_factory = ImageFactory()
-        self.build_context_dir = build_context_dir
-        self._deployed_resources = {}
-        self._built_images = {}
-
-        self.knative_client = KnativeClient(
-            config=self.kubeconfig,
-            image_registry=self.registry_config.get_full_url(),
-        )
-
-    async def deploy(
-        self,
-        app=None,
-        runner=None,
-        stream: bool = True,
-        protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        requirements: Optional[Union[str, List[str]]] = None,
-        extra_packages: Optional[List[str]] = None,
-        base_image: str = "python:3.9-slim",
-        environment: Dict = None,
-        runtime_config: Dict = None,
-        annotations: Dict = None,
-        labels: Dict = None,
-        port: int = 8080,
-        mount_dir: str = None,
-        image_name: str = "agent_llm",
-        image_tag: str = "latest",
-        push_to_registry: bool = False,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        """
-        Deploy the runner as a Knative Service.
-
-        Args:
-            app: Agent app to be deployed
-            runner: Complete Runner object with agent, environment_manager,
-                context_manager
-            stream: Enable streaming responses
-            protocol_adapters: protocol adapters
-            requirements: PyPI dependencies (following _agent_engines.py
-                pattern)
-            extra_packages: User code directory/file path
-            base_image: Docker base image
-            port: Container port
-            environment: Environment variables dict
-            mount_dir: Mount directory
-            runtime_config: K8s runtime configuration
-            annotations: knative service annotations
-            labels: knative service labels
-            # Backward compatibility
-            image_name: Image name
-            image_tag: Image tag
-            push_to_registry: Push to registry
-            **kwargs: Additional arguments
-
-        Returns:
-            Dict containing deploy_id, url, resource_name
-
-        Raises:
-            RuntimeError: If kservice fails
-
-        """
-        created_resources = []
-        deploy_id = self.deploy_id
-        try:
-            logger.info(f"Starting Knative Service {deploy_id}")
-
-            # Step 1: Build image with proper error handling
-            logger.info("Building runner image...")
-            try:
-                built_image_name = self.image_factory.build_image(
-                    app=app,
-                    runner=runner,
-                    base_image=base_image,
-                    build_context_dir=self.build_context_dir,
-                    registry_config=self.registry_config,
-                    image_name=image_name,
-                    image_tag=image_tag,
-                    push_to_registry=push_to_registry,
-                    port=port,
-                    protocol_adapters=protocol_adapters,
-                    **kwargs,
-                )
-                if not built_image_name:
-                    raise RuntimeError(
-                        "Image build failed - no image name returned",
-                    )
-
-                created_resources.append(f"image:{built_image_name}")
-                self._built_images[deploy_id] = built_image_name
-                logger.info(f"Image built successfully: {built_image_name}")
-            except Exception as e:
-                logger.error(f"Image build failed: {e}")
-                raise RuntimeError(f"Failed to build image: {e}") from e
-
-            if mount_dir:
-                if not os.path.isabs(mount_dir):
-                    mount_dir = os.path.abspath(mount_dir)
-
-                volume_bindings = {
-                    mount_dir: {
-                        "bind": mount_dir,
-                        "mode": "rw",
-                    },
-                }
-            else:
-                volume_bindings = {}
-
-            resource_name = self.get_resource_name(deploy_id)
-
-            logger.info(f"Building Knative Service for {deploy_id}")
-
-            # Create Knative Service
-            name, url = self.knative_client.create_kservice(
-                name=resource_name,
-                image=built_image_name,
-                ports=[port],
-                volumes=volume_bindings,
-                environment=environment,
-                runtime_config=runtime_config or {},
-                annotations=annotations or {},
-                labels=labels or {},
-            )
-            if not url:
-                import traceback
-
-                raise RuntimeError(
-                    f"Failed to create resource: "
-                    f"{resource_name}, {traceback.format_exc()}",
-                )
-
-            logger.info(f"Knative Service url {url} successful")
-            self._deployed_resources[deploy_id] = {
-                "resource_name": name,
-                "config": {
-                    "runner": runner.__class__.__name__,
-                    "extra_packages": extra_packages,
-                    "requirements": requirements,  # New format
-                    "base_image": base_image,
-                    "port": port,
-                    "environment": environment,
-                    "runtime_config": runtime_config,
-                    "stream": stream,
-                    "protocol_adapters": protocol_adapters,
-                    **kwargs,
-                },
-            }
-            return {
-                "deploy_id": deploy_id,
-                "resource_name": resource_name,
-                "url": url,
-            }
-
-        except Exception as e:
-            import traceback
-
-            logger.error(f"Knative Service {deploy_id} failed: {e}")
-            # Enhanced rollback with better error handling
-            raise RuntimeError(
-                f"Knative Service failed: {e}, {traceback.format_exc()}",
-            ) from e
-
-    @staticmethod
-    def get_resource_name(deploy_id: str) -> str:
-        return f"agent-{deploy_id[:8]}"
-
-    async def stop(
-        self,
-        deploy_id: str,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        """Stop Knative Service.
-
-        Args:
-            deploy_id: Deployment identifier
-            **kwargs: Additional parameters
-
-        Returns:
-            Dict with success status, message, and details
-        """
-
-        resource_name = self.get_resource_name(deploy_id)
-        try:
-            # Try to remove the KService
-            success = self.knative_client.delete_kservice(resource_name)
-
-            if success:
-                return {
-                    "success": True,
-                    "message": f"Knative deployment {resource_name} "
-                    f"removed",
-                    "details": {
-                        "deploy_id": deploy_id,
-                        "resource_name": resource_name,
-                    },
-                }
-            else:
-                return {
-                    "success": False,
-                    "message": f"Knative deployment {resource_name} not "
-                    f"found (may already be deleted), Please check the "
-                    f"detail in cluster",
-                    "details": {
-                        "deploy_id": deploy_id,
-                        "resource_name": resource_name,
-                    },
-                }
-        except Exception as e:
-            logger.error(
-                f"Failed to remove Knative service {resource_name}: {e}",
-            )
-            return {
-                "success": False,
-                "message": f"Failed to remove Knative service: {e}",
-                "details": {
-                    "deploy_id": deploy_id,
-                    "resource_name": resource_name,
-                    "error": str(e),
-                },
-            }
-
-    def get_status(self) -> str:
-        """Get KService status"""
-        if self.deploy_id not in self._deployed_resources:
-            return "not_found"
-
-        resources = self._deployed_resources[self.deploy_id]
-        kservice_name = resources["resource_name"]
-
-        return self.knative_client.get_kservice_status(kservice_name)

agentscope_runtime/sandbox/client/async_http_client.py

@@ -1,339 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint: disable=unused-argument
-import logging
-import asyncio
-from typing import Any, Optional
-
-import httpx
-from pydantic import Field
-
-from .base import SandboxHttpBase
-from ..model import ContainerModel
-
-logger = logging.getLogger(__name__)
-
-
-class SandboxHttpAsyncClient(SandboxHttpBase):
-    """
-    A Python async client for interacting with the runtime API.
-    Connect directly to the container.
-    """
-
-    def __init__(
-        self,
-        model: Optional[ContainerModel] = None,
-        timeout: int = 60,
-        domain: str = "localhost",
-    ) -> None:
-        """
-        Initialize the Python async client.
-
-        Args:
-            model (ContainerModel): The pydantic model representing the
-            runtime sandbox.
-        """
-        super().__init__(model, timeout, domain)
-        self.client = httpx.AsyncClient(
-            timeout=self.timeout,
-            headers=self.headers,
-        )
-
-    async def __aenter__(self):
-        # Wait for the runtime api server to be healthy
-        await self.wait_until_healthy()
-        return self
-
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        await self.client.aclose()
-
-    async def _request(self, method: str, url: str, **kwargs):
-        return await self.client.request(method, url, **kwargs)
-
-    async def safe_request(self, method: str, url: str, **kwargs):
-        """
-        Unified HTTP request method with async exception handling.
-        Returns JSON if possible, otherwise plain text.
-        """
-        try:
-            r = await self._request(method, url, **kwargs)
-            r.raise_for_status()
-            try:
-                return r.json()
-            except ValueError:
-                return r.text
-        except httpx.RequestError as e:
-            logger.error(f"HTTP error: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
-
-    async def check_health(self) -> bool:
-        """
-        Check if the runtime service is running by verifying the health
-        endpoint.
-
-        Returns:
-            bool: True if the service is reachable, False otherwise.
-        """
-        try:
-            r = await self._request(
-                "get",
-                f"{self.base_url}/healthz",
-            )
-            return r.status_code == 200
-        except httpx.RequestError:
-            return False
-
-    async def wait_until_healthy(self) -> None:
-        """
-        Wait until the runtime service is running for a specified timeout.
-        """
-        start_time = asyncio.get_event_loop().time()
-        while (
-            asyncio.get_event_loop().time() - start_time < self.start_timeout
-        ):
-            if await self.check_health():
-                return
-            await asyncio.sleep(1)
-        raise TimeoutError(
-            "Runtime service did not start within the specified timeout.",
-        )
-
-    async def add_mcp_servers(self, server_configs, overwrite=False):
-        """
-        Add MCP servers to runtime.
-        """
-        endpoint = f"{self.base_url}/mcp/add_servers"
-        return await self.safe_request(
-            "post",
-            endpoint,
-            json={"server_configs": server_configs, "overwrite": overwrite},
-        )
-
-    async def list_tools(self, tool_type=None, **kwargs) -> dict:
-        """
-        List available MCP tools plus generic built-in tools.
-        """
-        data = await self.safe_request(
-            "get",
-            f"{self.base_url}/mcp/list_tools",
-        )
-        if isinstance(data, dict) and "isError" not in data:
-            data["generic"] = self.generic_tools
-            if tool_type:
-                return {tool_type: data.get(tool_type, {})}
-        return data
-
-    async def call_tool(
-        self,
-        name: str,
-        arguments: Optional[dict[str, Any]] = None,
-    ) -> dict:
-        """
-        Call a specific MCP tool.
-
-        If it's a generic tool, call the corresponding local method.
-        """
-        if arguments is None:
-            arguments = {}
-        if name in self.generic_tools:
-            if name == "run_ipython_cell":
-                return await self.run_ipython_cell(**arguments)
-            elif name == "run_shell_command":
-                return await self.run_shell_command(**arguments)
-
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/mcp/call_tool",
-            json={"tool_name": name, "arguments": arguments},
-        )
-
-    async def run_ipython_cell(
-        self,
-        code: str = Field(description="IPython code to execute"),
-    ) -> dict:
-        """
-        Run an IPython cell.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/tools/run_ipython_cell",
-            json={"code": code},
-        )
-
-    async def run_shell_command(
-        self,
-        command: str = Field(description="Shell command to execute"),
-    ) -> dict:
-        """
-        Run a shell command.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/tools/run_shell_command",
-            json={"command": command},
-        )
-
-    async def commit_changes(
-        self,
-        commit_message: str = "Automated commit",
-    ) -> dict:
-        """
-        Commit the uncommitted changes with a given commit message.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/watcher/commit_changes",
-            json={"commit_message": commit_message},
-        )
-
-    async def generate_diff(
-        self,
-        commit_a: Optional[str] = None,
-        commit_b: Optional[str] = None,
-    ) -> dict:
-        """
-        Generate the diff between two commits or between uncommitted changes
-        and the latest commit.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/watcher/generate_diff",
-            json={"commit_a": commit_a, "commit_b": commit_b},
-        )
-
-    async def git_logs(self) -> dict:
-        """
-        Retrieve the git logs.
-        """
-        return await self.safe_request(
-            "get",
-            f"{self.base_url}/watcher/git_logs",
-        )
-
-    # -------- Workspace File APIs --------
-
-    async def get_workspace_file(self, file_path: str) -> dict:
-        """
-        Retrieve a file from the /workspace directory.
-        """
-        try:
-            endpoint = f"{self.base_url}/workspace/files"
-            params = {"file_path": file_path}
-            r = await self._request("get", endpoint, params=params)
-            r.raise_for_status()
-
-            # Check for empty content
-            if r.headers.get("Content-Length") == "0":
-                logger.warning(f"The file {file_path} is empty.")
-                return {"data": b""}
-
-            # Accumulate the content in chunks
-            file_content = bytearray()
-            async for chunk in r.aiter_bytes():
-                file_content.extend(chunk)
-
-            return {"data": bytes(file_content)}
-        except httpx.RequestError as e:
-            logger.error(f"An error occurred while retrieving the file: {e}")
-            return {
-                "isError": True,
-                "content": [{"type": "text", "text": str(e)}],
-            }
-
-    async def create_or_edit_workspace_file(
-        self,
-        file_path: str,
-        content: str,
-    ) -> dict:
-        """
-        Create or edit a file within the /workspace directory.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/files",
-            params={"file_path": file_path},
-            json={"content": content},
-        )
-
-    async def list_workspace_directories(
-        self,
-        directory: str = "/workspace",
-    ) -> dict:
-        """
-        List files in the specified directory within the /workspace.
-        """
-        return await self.safe_request(
-            "get",
-            f"{self.base_url}/workspace/list-directories",
-            params={"directory": directory},
-        )
-
-    async def create_workspace_directory(self, directory_path: str) -> dict:
-        """
-        Create a directory within the /workspace directory.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/directories",
-            params={"directory_path": directory_path},
-        )
-
-    async def delete_workspace_file(self, file_path: str) -> dict:
-        """
-        Delete a file within the /workspace directory.
-        """
-        return await self.safe_request(
-            "delete",
-            f"{self.base_url}/workspace/files",
-            params={"file_path": file_path},
-        )
-
-    async def delete_workspace_directory(
-        self,
-        directory_path: str,
-        recursive: bool = False,
-    ) -> dict:
-        """
-        Delete a directory within the /workspace directory.
-        """
-        return await self.safe_request(
-            "delete",
-            f"{self.base_url}/workspace/directories",
-            params={"directory_path": directory_path, "recursive": recursive},
-        )
-
-    async def move_or_rename_workspace_item(
-        self,
-        source_path: str,
-        destination_path: str,
-    ) -> dict:
-        """
-        Move or rename a file or directory within the /workspace directory.
-        """
-        return await self.safe_request(
-            "put",
-            f"{self.base_url}/workspace/move",
-            params={
-                "source_path": source_path,
-                "destination_path": destination_path,
-            },
-        )
-
-    async def copy_workspace_item(
-        self,
-        source_path: str,
-        destination_path: str,
-    ) -> dict:
-        """
-        Copy a file or directory within the /workspace directory.
-        """
-        return await self.safe_request(
-            "post",
-            f"{self.base_url}/workspace/copy",
-            params={
-                "source_path": source_path,
-                "destination_path": destination_path,
-            },
-        )

agentscope_runtime/sandbox/client/base.py

@@ -1,74 +0,0 @@
-# -*- coding: utf-8 -*-
-import logging
-from urllib.parse import urljoin
-
-DEFAULT_TIMEOUT = 60
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class SandboxHttpBase:
-    _generic_tools = {
-        "run_ipython_cell": {
-            "name": "run_ipython_cell",
-            "json_schema": {
-                "type": "function",
-                "function": {
-                    "name": "run_ipython_cell",
-                    "description": "Run an IPython cell.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "code": {
-                                "type": "string",
-                                "description": "IPython code to execute",
-                            },
-                        },
-                        "required": ["code"],
-                    },
-                },
-            },
-        },
-        "run_shell_command": {
-            "name": "run_shell_command",
-            "json_schema": {
-                "type": "function",
-                "function": {
-                    "name": "run_shell_command",
-                    "description": "Run a shell command.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "command": {
-                                "type": "string",
-                                "description": "Shell command to execute",
-                            },
-                        },
-                        "required": ["command"],
-                    },
-                },
-            },
-        },
-    }
-
-    def __init__(self, model, timeout: int = 60, domain: str = "localhost"):
-        self.base_url = urljoin(
-            model.url.replace("localhost", domain),
-            "fastapi",
-        )
-        self.start_timeout = timeout
-        self.timeout = model.timeout or DEFAULT_TIMEOUT
-        self.secret = model.runtime_token
-
-        self.headers = {
-            "Content-Type": "application/json",
-            "x-agentrun-session-id": "s" + model.container_id,
-            "x-agentscope-runtime-session-id": "s" + model.container_id,
-        }
-        if self.secret:
-            self.headers["Authorization"] = f"Bearer {self.secret}"
-
-    @property
-    def generic_tools(self) -> dict:
-        return self._generic_tools