agentscope-runtime 0.2.0b1__py3-none-any.whl → 1.0.0__py3-none-any.whl

agentscope_runtime/engine/deployers/cli_fc_deploy.py

@@ -109,7 +109,7 @@ async def _run(
     if mode == "native":
         # Build the current project directly as a wheel, then upload/deploy
         project_dir_path = Path.cwd()
-        built_whl = await build_wheel(project_dir_path)
+        built_whl = build_wheel(project_dir_path)
         return await deployer.deploy(
             project_dir=None,
             cmd=None,

agentscope_runtime/engine/deployers/kubernetes_deployer.py

@@ -9,13 +9,9 @@ from pydantic import BaseModel, Field
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.docker_image_utils import (
-    RunnerImageFactory,
+    ImageFactory,
     RegistryConfig,
 )
-from .utils.service_utils import (
-    ServicesConfig,
-)
-from ..runner import Runner
 from ...common.container_clients.kubernetes_client import (
     KubernetesClient,
 )
@@ -60,7 +56,7 @@ class KubernetesDeployManager(DeployManager):
         super().__init__()
         self.kubeconfig = kube_config
         self.registry_config = registry_config
-        self.image_factory = RunnerImageFactory()
+        self.image_factory = ImageFactory()
         self.use_deployment = use_deployment
         self.build_context_dir = build_context_dir
         self._deployed_resources = {}
@@ -73,10 +69,10 @@ class KubernetesDeployManager(DeployManager):
 
     async def deploy(
         self,
-        runner: Runner,
+        app=None,
+        runner=None,
         endpoint_path: str = "/process",
         stream: bool = True,
-        services_config: Optional[Union[ServicesConfig, dict]] = None,
         custom_endpoints: Optional[List[Dict]] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
         requirements: Optional[Union[str, List[str]]] = None,
@@ -96,11 +92,11 @@ class KubernetesDeployManager(DeployManager):
         Deploy runner to Kubernetes.
 
         Args:
+            app: Agent app to be deployed
             runner: Complete Runner object with agent, environment_manager,
                 context_manager
             endpoint_path: API endpoint path
             stream: Enable streaming responses
-            services_config: Services configuration for context manager
             custom_endpoints: Custom endpoints from agent app
             protocol_adapters: protocol adapters
             requirements: PyPI dependencies (following _agent_engines.py
@@ -130,20 +126,11 @@ class KubernetesDeployManager(DeployManager):
         try:
             logger.info(f"Starting deployment {deploy_id}")
 
-            # Handle backward compatibility
-            if runner is None:
-                raise ValueError(
-                    "Runner must be provided",
-                )
-
-            # convert services_config to Model body
-            if services_config and isinstance(services_config, dict):
-                services_config = ServicesConfig(**services_config)
-
             # Step 1: Build image with proper error handling
             logger.info("Building runner image...")
             try:
-                built_image_name = self.image_factory.build_runner_image(
+                built_image_name = self.image_factory.build_image(
+                    app=app,
                     runner=runner,
                     requirements=requirements,
                     extra_packages=extra_packages or [],
@@ -156,7 +143,6 @@ class KubernetesDeployManager(DeployManager):
                     image_tag=image_tag,
                     push_to_registry=push_to_registry,
                     port=port,
-                    services_config=services_config,  # type: ignore[arg-type]
                     protocol_adapters=protocol_adapters,
                     custom_endpoints=custom_endpoints,
                     **kwargs,
@@ -189,6 +175,8 @@ class KubernetesDeployManager(DeployManager):
 
             resource_name = f"agent-{deploy_id[:8]}"
 
+            logger.info(f"Building kubernetes deployment for {deploy_id}")
+
             # Create Deployment
             _id, ports, ip = self.k8s_client.create_deployment(
                 image=built_image_name,

agentscope_runtime/engine/deployers/local_deployer.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# pylint:disable=protected-access
+# pylint:disable=protected-access, unused-argument
 
 import asyncio
 import logging
@@ -13,12 +13,13 @@ import uvicorn
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.deployment_modes import DeploymentMode
-from .utils.package_project_utils import package_project, PackageConfig
+from .utils.detached_app import (
+    build_detached_app,
+    get_bundle_entry_script,
+)
 from .utils.service_utils import (
     FastAPIAppFactory,
-    FastAPITemplateManager,
     ProcessManager,
-    ServicesConfig,
 )
 
 
@@ -63,13 +64,10 @@ class LocalDeployManager(DeployManager):
             shutdown_timeout=shutdown_timeout,
         )
 
-        # Template manager
-        self.template_manager = FastAPITemplateManager()
-
     async def deploy(
         self,
         app=None,
-        runner: Optional[Any] = None,
+        runner=None,
         endpoint_path: str = "/process",
         request_model: Optional[Type] = None,
         response_type: str = "sse",
@@ -77,7 +75,6 @@ class LocalDeployManager(DeployManager):
         before_start: Optional[Callable] = None,
         after_finish: Optional[Callable] = None,
         mode: DeploymentMode = DeploymentMode.DAEMON_THREAD,
-        services_config: Optional[ServicesConfig] = None,
         custom_endpoints: Optional[List[Dict]] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
         broker_url: Optional[str] = None,
@@ -88,6 +85,7 @@ class LocalDeployManager(DeployManager):
         """Deploy using unified FastAPI architecture.
 
         Args:
+            app: Agent app to be deployed
             runner: Runner instance (for DAEMON_THREAD mode)
             endpoint_path: API endpoint path
             request_model: Pydantic model for request validation
@@ -96,7 +94,6 @@ class LocalDeployManager(DeployManager):
             before_start: Callback function called before server starts
             after_finish: Callback function called after server finishes
             mode: Deployment mode
-            services_config: Services configuration
             custom_endpoints: Custom endpoints from agent app
             protocol_adapters: Protocol adapters
             broker_url: Celery broker URL for background task processing
@@ -137,7 +134,6 @@ class LocalDeployManager(DeployManager):
                     stream=stream,
                     before_start=before_start,
                     after_finish=after_finish,
-                    services_config=services_config,
                     custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
                     broker_url=broker_url,
@@ -154,7 +150,6 @@ class LocalDeployManager(DeployManager):
                     stream=stream,
                     before_start=before_start,
                     after_finish=after_finish,
-                    services_config=services_config,
                     custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
                     **kwargs,
@@ -227,7 +222,6 @@ class LocalDeployManager(DeployManager):
     async def _deploy_detached_process(
         self,
         runner: Optional[Any] = None,
-        services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
         **kwargs,
     ) -> Dict[str, str]:
@@ -236,27 +230,29 @@ class LocalDeployManager(DeployManager):
             "Deploying FastAPI service in detached process mode...",
         )
 
-        # Extract agent from runner
-        if not runner or not runner._agent:
+        if runner is None and self._app is None:
             raise ValueError(
-                "Detached process mode requires a runner with an agent",
+                "Detached process mode requires an app or runner",
             )
 
-        agent = runner._agent
         if "agent" in kwargs:
             kwargs.pop("agent")
+        if "app" in kwargs:
+            kwargs.pop("app")
 
         # Create package project for detached deployment
         project_dir = await self.create_detached_project(
-            agent=agent,
-            services_config=services_config,
+            app=self._app,
+            runner=runner,
             protocol_adapters=protocol_adapters,
             **kwargs,
         )
 
         try:
+            entry_script = get_bundle_entry_script(project_dir)
+            script_path = os.path.join(project_dir, entry_script)
+
             # Start detached process using the packaged project
-            script_path = os.path.join(project_dir, "main.py")
             pid = await self.process_manager.start_detached_process(
                 script_path=script_path,
                 host=self.host,
@@ -304,68 +300,24 @@ class LocalDeployManager(DeployManager):
 
     @staticmethod
     async def create_detached_project(
-        agent: Any,
+        app=None,
+        runner: Optional[Any] = None,
         endpoint_path: str = "/process",
         requirements: Optional[Union[str, List[str]]] = None,
         extra_packages: Optional[List[str]] = None,
-        services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
-        custom_endpoints: Optional[
-            List[Dict]
-        ] = None,  # New parameter for custom endpoints
-        # Celery parameters
+        custom_endpoints: Optional[List[Dict]] = None,
         broker_url: Optional[str] = None,
         backend_url: Optional[str] = None,
         enable_embedded_worker: bool = False,
-        **kwargs,  # pylint: disable=unused-argument
+        **kwargs,
     ) -> str:
-        """Create detached project using package_project method."""
-        if requirements is None:
-            requirements = []
-
-        if isinstance(requirements, str):
-            requirements = [requirements]
-
-        # Create package configuration for detached deployment
-        package_config = PackageConfig(
-            endpoint_path=endpoint_path,
-            deployment_mode="detached_process",
+        project_dir, _ = build_detached_app(
+            app=app,
+            runner=runner,
+            requirements=requirements,
             extra_packages=extra_packages,
-            protocol_adapters=protocol_adapters,
-            services_config=services_config,
-            custom_endpoints=custom_endpoints,  # Add custom endpoints
-            # Celery configuration
-            broker_url=broker_url,
-            backend_url=backend_url,
-            enable_embedded_worker=enable_embedded_worker,
-            requirements=requirements
-            + (
-                ["redis"]
-                if services_config
-                and any(
-                    getattr(config, "provider", None) == "redis"
-                    for config in [
-                        services_config.memory,
-                        services_config.session_history,
-                    ]
-                    if config
-                )
-                else []
-            )
-            + (
-                [
-                    "celery",
-                    "redis",
-                ]  # Add Celery and Redis if Celery is configured
-                if broker_url or backend_url
-                else []
-            ),
-        )
-
-        # Use package_project to create the detached project
-        project_dir, _ = package_project(
-            agent=agent,
-            config=package_config,
+            **kwargs,
         )
 
         return project_dir
@@ -442,13 +394,34 @@ class LocalDeployManager(DeployManager):
     def _is_server_ready(self) -> bool:
         """Check if the server is ready to accept connections."""
         try:
+            # Normalize host for connection check
+            # When service binds to 0.0.0.0, we need to connect to 127.0.0.1
+            check_host = self._normalize_host_for_check(self.host)
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                 s.settimeout(0.1)
-                result = s.connect_ex((self.host, self.port))
+                result = s.connect_ex((check_host, self.port))
                 return result == 0
         except Exception:
             return False
 
+    @staticmethod
+    def _normalize_host_for_check(host: str) -> str:
+        """Normalize host for connection check.
+
+        When a service binds to 0.0.0.0 (all interfaces), it cannot be
+        directly connected to. We need to connect to 127.0.0.1 instead
+        to check if the service is running locally.
+
+        Args:
+            host: The host the service binds to
+
+        Returns:
+            The host to use for connection check
+        """
+        if host in ("0.0.0.0", "::"):
+            return "127.0.0.1"
+        return host
+
     async def _wait_for_server_ready(self, timeout: int = 30):
         """Wait for server to become ready."""
         end_time = asyncio.get_event_loop().time() + timeout