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

agentscope_runtime/engine/deployers/utils/docker_image_utils/{runner_image_factory.py → image_factory.py}

@@ -2,34 +2,27 @@
 # pylint:disable=protected-access
 
 import hashlib
+import json
 import logging
 import os
 from typing import Optional, List, Dict, Union
 
 from pydantic import BaseModel, Field
 
-from agentscope_runtime.engine.runner import Runner
-
-# from .package_project import PackageConfig, package_project, create_tar_gz
-from ..package_project_utils import (
-    PackageConfig,
-    package_project,
-)
-from ..service_utils import (
-    ServicesConfig,
-)
-from .dockerfile_generator import DockerfileGenerator, DockerfileConfig
 from .docker_image_builder import (
     DockerImageBuilder,
     BuildConfig,
     RegistryConfig,
 )
-
+from .dockerfile_generator import DockerfileGenerator, DockerfileConfig
+from ..detached_app import build_detached_app
+from ..package import DEFAULT_ENTRYPOINT_FILE
+from .....engine.runner import Runner
 
 logger = logging.getLogger(__name__)
 
 
-class RunnerImageConfig(BaseModel):
+class ImageConfig(BaseModel):
     """Complete configuration for building a Runner image"""
 
     # Package configuration
@@ -38,7 +31,6 @@ class RunnerImageConfig(BaseModel):
     build_context_dir: str = "/tmp/k8s_build"
     endpoint_path: str = "/process"
     protocol_adapters: Optional[List] = None  # New: protocol adapters
-    services_config: Optional[ServicesConfig] = None
     custom_endpoints: Optional[
         List[Dict]
     ] = None  # New: custom endpoints configuration
@@ -49,6 +41,13 @@ class RunnerImageConfig(BaseModel):
     env_vars: Dict[str, str] = Field(default_factory=lambda: {})
     startup_command: Optional[str] = None
 
+    # Runtime configuration
+    host: str = "0.0.0.0"  # Container-friendly default
+    embed_task_processor: bool = False
+    extra_startup_args: Dict[str, Union[str, int, bool]] = Field(
+        default_factory=dict,
+    )
+
     # Build configuration
     no_cache: bool = False
     quiet: bool = False
@@ -64,7 +63,7 @@ class RunnerImageConfig(BaseModel):
     push_to_registry: bool = False
 
 
-class RunnerImageFactory:
+class ImageFactory:
     """
     Factory class for building Runner Docker images.
     Coordinates ProjectPackager, DockerfileGenerator, and DockerImageBuilder.
@@ -79,15 +78,13 @@ class RunnerImageFactory:
 
     @staticmethod
     def _generate_image_name(
-        runner: Runner,
-        config: RunnerImageConfig,
+        config: ImageConfig,
     ) -> str:
         """Generate a unique image tag based on runner content and config"""
         # Create hash based on runner and configuration
         if config.image_name:
             return config.image_name
         hash_content = (
-            f"{str(runner._agent.name)}"
             f"{str(config.requirements)}"
             f"{str(config.extra_files)}"
             f"{config.base_image}"
@@ -95,19 +92,7 @@ class RunnerImageFactory:
         )
         content_hash = hashlib.md5(hash_content.encode()).hexdigest()[:8]
 
-        return f"agent-{content_hash}"
-
-    @staticmethod
-    def _validate_runner(runner: Runner):
-        """Validate runner object"""
-        if not hasattr(runner, "_agent") or runner._agent is None:
-            raise ValueError("Runner must have a valid agent")
-
-        # Log warnings for missing components
-        if not hasattr(runner, "_environment_manager"):
-            logger.warning("Runner missing _environment_manager")
-        if not hasattr(runner, "_context_manager"):
-            logger.warning("Runner missing _context_manager")
+        return f"agentscope-runtime-{content_hash}"
 
     @staticmethod
     def _validate_requirements(
@@ -131,10 +116,61 @@ class RunnerImageFactory:
                 f"Invalid requirements type: {type(requirements)}",
             )
 
-    def _build_runner_image(
+    @staticmethod
+    def _generate_startup_command(
+        entrypoint_file: str,
+        config: ImageConfig,
+    ) -> str:
+        """
+        Generate a comprehensive startup command for the containerized
+        application.
+
+        This method creates a startup command that includes all necessary
+        parameters for running the AgentScope application in a container
+        environment, similar to what's used in the app_main.py.j2 template.
+
+        Args:
+            entrypoint_file: Project  entrypoint details
+            config: ImageConfig with runtime settings
+
+        Returns:
+            str: Complete startup command with all parameters
+        """
+        # If a custom startup command is provided, use it directly
+        if config.startup_command:
+            return config.startup_command
+
+        # Start with basic python command
+        cmd_parts = ["python", entrypoint_file]
+
+        # Add host configuration
+        cmd_parts.extend(["--host", config.host])
+
+        # Add port configuration
+        cmd_parts.extend(["--port", str(config.port)])
+
+        # Add embed-task-processor flag if enabled
+        if config.embed_task_processor:
+            cmd_parts.append("--embed-task-processor")
+
+        # Add any extra startup arguments
+        for arg_name, arg_value in config.extra_startup_args.items():
+            # Convert underscore to dash for CLI compatibility
+            cli_arg = f"--{arg_name.replace('_', '-')}"
+
+            if isinstance(arg_value, bool):
+                if arg_value:  # Only add flag if True
+                    cmd_parts.append(cli_arg)
+            else:
+                cmd_parts.extend([cli_arg, str(arg_value)])
+
+        return json.dumps(cmd_parts)
+
+    def _build_image(
         self,
-        runner: Runner,
-        config: RunnerImageConfig,
+        app,
+        runner: Optional[Runner],
+        config: ImageConfig,
     ) -> str:
         """
         Build a complete Docker image for the Runner.
@@ -157,18 +193,22 @@ class RunnerImageFactory:
             RuntimeError: If any step of the build process fails
         """
         try:
-            # Validation
-            self._validate_runner(runner)
-
             logger.info(f"Building Runner image: {config.image_tag}")
 
             # Generate Dockerfile
             logger.info("Generating Dockerfile...")
+
+            # Generate comprehensive startup command
+            startup_command = self._generate_startup_command(
+                entrypoint_file=DEFAULT_ENTRYPOINT_FILE,
+                config=config,
+            )
+
             dockerfile_config = DockerfileConfig(
                 base_image=config.base_image,
                 port=config.port,
                 env_vars=config.env_vars,
-                startup_command=config.startup_command,
+                startup_command=startup_command,
             )
 
             dockerfile_path = self.dockerfile_generator.create_dockerfile(
@@ -176,23 +216,18 @@ class RunnerImageFactory:
             )
             logger.info(f"Dockerfile created: {dockerfile_path}")
 
-            # Package the project
+            # Package the project using detached bundle logic
             logger.info("Packaging Runner project...")
-            project_dir, is_updated = package_project(
-                agent=runner._agent,
-                config=PackageConfig(
-                    requirements=config.requirements,
-                    extra_packages=config.extra_packages,
-                    output_dir=config.build_context_dir,
-                    endpoint_path=config.endpoint_path,
-                    protocol_adapters=config.protocol_adapters,
-                    services_config=config.services_config,
-                    custom_endpoints=config.custom_endpoints,
-                ),
+
+            project_dir, _ = build_detached_app(
+                app=app,
+                runner=runner,
+                requirements=config.requirements,
+                extra_packages=config.extra_packages,
+                output_dir=config.build_context_dir,
                 dockerfile_path=dockerfile_path,
-                # caller_depth is no longer needed due to automatic
-                # stack search
             )
+            is_updated = True
             logger.info(f"Project packaged: {project_dir}")
 
             # Build Docker image
@@ -209,7 +244,7 @@ class RunnerImageFactory:
                 # Build and push to registry
                 full_image_name = self.image_builder.build_and_push(
                     build_context=project_dir,
-                    image_name=self._generate_image_name(runner, config),
+                    image_name=self._generate_image_name(config),
                     image_tag=config.image_tag,
                     build_config=build_config,
                     registry_config=config.registry_config,
@@ -220,7 +255,7 @@ class RunnerImageFactory:
                 # Just build locally
                 full_image_name = self.image_builder.build_image(
                     build_context=project_dir,
-                    image_name=self._generate_image_name(runner, config),
+                    image_name=self._generate_image_name(config),
                     image_tag=config.image_tag,
                     config=build_config,
                     source_updated=is_updated,
@@ -237,9 +272,10 @@ class RunnerImageFactory:
             # Cleanup temporary resources
             self.cleanup()
 
-    def build_runner_image(
+    def build_image(
         self,
-        runner: Runner,
+        app=None,
+        runner: Optional[Runner] = None,
         requirements: Optional[Union[str, List[str]]] = None,
         extra_packages: Optional[List[str]] = None,
         base_image: str = "python:3.10-slim-bookworm",
@@ -247,17 +283,21 @@ class RunnerImageFactory:
         image_tag: Optional[str] = None,
         registry_config: Optional[RegistryConfig] = None,
         push_to_registry: bool = False,
-        services_config: Optional[ServicesConfig] = None,
         protocol_adapters: Optional[List] = None,  # New: protocol adapters
         custom_endpoints: Optional[
             List[Dict]
         ] = None,  # New parameter for custom endpoints
+        # New runtime configuration parameters
+        host: str = "0.0.0.0",
+        embed_task_processor: bool = True,
+        extra_startup_args: Optional[Dict[str, Union[str, int, bool]]] = None,
         **kwargs,
     ) -> str:
         """
         Simplified interface for building Runner images.
 
         Args:
+            app: agent app object
             runner: Runner object
             requirements: Python requirements
             extra_packages: Additional files to include
@@ -266,15 +306,33 @@ class RunnerImageFactory:
             image_tag: Optional image tag
             registry_config: Optional registry config
             push_to_registry: Whether to push to registry
-            services_config: Optional services config
             protocol_adapters: Protocol adapters
             custom_endpoints: Custom endpoints from agent app
+            host: Host to bind to (default: 0.0.0.0 for containers)
+            embed_task_processor: Whether to embed task processor
+            extra_startup_args: Additional startup arguments
             **kwargs: Additional configuration options
 
         Returns:
             str: Built image name
         """
-        config = RunnerImageConfig(
+        if app is not None:
+            custom_endpoints = custom_endpoints or getattr(
+                app,
+                "custom_endpoints",
+                None,
+            )
+            protocol_adapters = protocol_adapters or getattr(
+                app,
+                "protocol_adapters",
+                None,
+            )
+            kwargs.setdefault(
+                "endpoint_path",
+                getattr(app, "endpoint_path", "/process"),
+            )
+
+        config = ImageConfig(
             requirements=self._validate_requirements(requirements),
             extra_packages=extra_packages or [],
             base_image=base_image,
@@ -283,12 +341,14 @@ class RunnerImageFactory:
             registry_config=registry_config,
             push_to_registry=push_to_registry,
             protocol_adapters=protocol_adapters,
-            services_config=services_config,
             custom_endpoints=custom_endpoints,
+            host=host,
+            embed_task_processor=embed_task_processor,
+            extra_startup_args=extra_startup_args or {},
             **kwargs,
         )
 
-        return self._build_runner_image(runner, config)
+        return self._build_image(app, runner, config)
 
     def cleanup(self):
         """Clean up all temporary resources"""