agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.2.0b1__py3-none-any.whl

agentscope_runtime/engine/deployers/local_deployer.py

@@ -29,7 +29,8 @@ class LocalDeployManager(DeployManager):
         self,
         host: str = "127.0.0.1",
         port: int = 8000,
-        shutdown_timeout: int = 120,
+        shutdown_timeout: int = 30,
+        startup_timeout: int = 30,
         logger: Optional[logging.Logger] = None,
     ):
         """Initialize LocalDeployManager.
@@ -44,6 +45,7 @@ class LocalDeployManager(DeployManager):
         self.host = host
         self.port = port
         self._shutdown_timeout = shutdown_timeout
+        self._startup_timeout = startup_timeout
         self._logger = logger or logging.getLogger(__name__)
 
         # State management
@@ -66,6 +68,7 @@ class LocalDeployManager(DeployManager):
 
     async def deploy(
         self,
+        app=None,
         runner: Optional[Any] = None,
         endpoint_path: str = "/process",
         request_model: Optional[Type] = None,
@@ -75,7 +78,11 @@ class LocalDeployManager(DeployManager):
         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,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs: Any,
     ) -> Dict[str, str]:
         """Deploy using unified FastAPI architecture.
@@ -90,7 +97,12 @@ class LocalDeployManager(DeployManager):
             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
+            backend_url: Celery backend URL for result storage
+            enable_embedded_worker: Whether to run Celery worker
+                embedded in the app
             **kwargs: Additional keyword arguments
 
         Returns:
@@ -102,6 +114,19 @@ class LocalDeployManager(DeployManager):
         if self.is_running:
             raise RuntimeError("Service is already running")
 
+        self._app = app
+        if self._app is not None:
+            runner = self._app._runner
+            endpoint_path = self._app.endpoint_path
+            response_type = self._app.response_type
+            stream = self._app.stream
+            request_model = self._app.request_model
+            before_start = self._app.before_start
+            after_finish = self._app.after_finish
+            backend_url = self._app.backend_url
+            broker_url = self._app.broker_url
+            custom_endpoints = self._app.custom_endpoints
+            protocol_adapters = self._app.protocol_adapters
         try:
             if mode == DeploymentMode.DAEMON_THREAD:
                 return await self._deploy_daemon_thread(
@@ -113,7 +138,11 @@ class LocalDeployManager(DeployManager):
                     before_start=before_start,
                     after_finish=after_finish,
                     services_config=services_config,
+                    custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
+                    broker_url=broker_url,
+                    backend_url=backend_url,
+                    enable_embedded_worker=enable_embedded_worker,
                     **kwargs,
                 )
             elif mode == DeploymentMode.DETACHED_PROCESS:
@@ -126,6 +155,7 @@ class LocalDeployManager(DeployManager):
                     before_start=before_start,
                     after_finish=after_finish,
                     services_config=services_config,
+                    custom_endpoints=custom_endpoints,
                     protocol_adapters=protocol_adapters,
                     **kwargs,
                 )
@@ -143,16 +173,22 @@ class LocalDeployManager(DeployManager):
         self,
         runner: Optional[Any] = None,
         protocol_adapters: Optional[list[ProtocolAdapter]] = None,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs,
     ) -> Dict[str, str]:
         """Deploy in daemon thread mode."""
         self._logger.info("Deploying FastAPI service in daemon thread mode...")
 
-        # Create FastAPI app using factory
+        # Create FastAPI app using factory with Celery support
         app = FastAPIAppFactory.create_app(
             runner=runner,
             mode=DeploymentMode.DAEMON_THREAD,
             protocol_adapters=protocol_adapters,
+            broker_url=broker_url,
+            backend_url=backend_url,
+            enable_embedded_worker=enable_embedded_worker,
             **kwargs,
         )
 
@@ -174,7 +210,7 @@ class LocalDeployManager(DeployManager):
         self._server_thread.start()
 
         # Wait for server to start
-        await self._wait_for_server_ready()
+        await self._wait_for_server_ready(self._startup_timeout)
 
         self.is_running = True
         self.deploy_id = f"daemon_{self.host}_{self.port}"
@@ -207,6 +243,8 @@ class LocalDeployManager(DeployManager):
             )
 
         agent = runner._agent
+        if "agent" in kwargs:
+            kwargs.pop("agent")
 
         # Create package project for detached deployment
         project_dir = await self.create_detached_project(
@@ -272,6 +310,13 @@ class LocalDeployManager(DeployManager):
         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
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        enable_embedded_worker: bool = False,
         **kwargs,  # pylint: disable=unused-argument
     ) -> str:
         """Create detached project using package_project method."""
@@ -288,6 +333,11 @@ class LocalDeployManager(DeployManager):
             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"]
@@ -301,6 +351,14 @@ class LocalDeployManager(DeployManager):
                     if config
                 )
                 else []
+            )
+            + (
+                [
+                    "celery",
+                    "redis",
+                ]  # Add Celery and Redis if Celery is configured
+                if broker_url or backend_url
+                else []
             ),
         )
 

agentscope_runtime/engine/deployers/modelstudio_deployer.py

@@ -201,16 +201,6 @@ async def _oss_create_bucket_if_not_exists(client, bucket_name: str) -> None:
         )
 
 
-def _create_bucket_name(prefix: str, base_name: str) -> str:
-    import re as _re
-
-    ts = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
-    base = _re.sub(r"\s+", "-", base_name)
-    base = _re.sub(r"[^a-zA-Z0-9-]", "", base).lower().strip("-")
-    name = f"{prefix}-{base}-{ts}"
-    return name[:63]
-
-
 async def _oss_put_and_presign(
     client,
     bucket_name: str,
@@ -569,6 +559,9 @@ class ModelstudioDeployManager(DeployManager):
         external_whl_path: Optional[str] = None,
         agent_id: Optional[str] = None,
         agent_desc: Optional[str] = None,
+        custom_endpoints: Optional[
+            List[Dict]
+        ] = None,  # New parameter for custom endpoints
         **kwargs,
     ) -> Dict[str, str]:
         """
@@ -579,7 +572,10 @@ class ModelstudioDeployManager(DeployManager):
         """
         if not agent_id:
             if not runner and not project_dir and not external_whl_path:
-                raise ValueError("")
+                raise ValueError(
+                    "Either runner, project_dir, "
+                    "or external_whl_path must be provided.",
+                )
 
         # convert services_config to Model body
         if services_config and isinstance(services_config, dict):
@@ -588,6 +584,8 @@ class ModelstudioDeployManager(DeployManager):
         try:
             if runner:
                 agent = runner._agent
+                if "agent" in kwargs:
+                    kwargs.pop("agent")
 
                 # Create package project for detached deployment
                 project_dir = await LocalDeployManager.create_detached_project(
@@ -595,6 +593,7 @@ class ModelstudioDeployManager(DeployManager):
                     endpoint_path=endpoint_path,
                     services_config=services_config,  # type: ignore[arg-type]
                     protocol_adapters=protocol_adapters,
+                    custom_endpoints=custom_endpoints,  # Pass custom endpoints
                     requirements=requirements,
                     extra_packages=extra_packages,
                     **kwargs,

agentscope_runtime/engine/deployers/utils/docker_image_utils/runner_image_factory.py

@@ -39,6 +39,9 @@ class RunnerImageConfig(BaseModel):
     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
 
     # Docker configuration
     base_image: str = "python:3.10-slim-bookworm"
@@ -184,6 +187,7 @@ class RunnerImageFactory:
                     endpoint_path=config.endpoint_path,
                     protocol_adapters=config.protocol_adapters,
                     services_config=config.services_config,
+                    custom_endpoints=config.custom_endpoints,
                 ),
                 dockerfile_path=dockerfile_path,
                 # caller_depth is no longer needed due to automatic
@@ -245,6 +249,9 @@ class RunnerImageFactory:
         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
         **kwargs,
     ) -> str:
         """
@@ -261,6 +268,7 @@ class RunnerImageFactory:
             push_to_registry: Whether to push to registry
             services_config: Optional services config
             protocol_adapters: Protocol adapters
+            custom_endpoints: Custom endpoints from agent app
             **kwargs: Additional configuration options
 
         Returns:
@@ -276,6 +284,7 @@ class RunnerImageFactory:
             push_to_registry=push_to_registry,
             protocol_adapters=protocol_adapters,
             services_config=services_config,
+            custom_endpoints=custom_endpoints,
             **kwargs,
         )
 

agentscope_runtime/engine/deployers/utils/package_project_utils.py

@@ -12,7 +12,7 @@ import shutil
 import tarfile
 import tempfile
 from pathlib import Path
-from typing import List, Optional, Any, Tuple
+from typing import List, Optional, Any, Tuple, Dict
 
 from pydantic import BaseModel
 
@@ -61,6 +61,173 @@ def _get_package_version() -> str:
         return ""
 
 
+def _prepare_custom_endpoints_for_template(
+    custom_endpoints: Optional[List[Dict]],
+    temp_dir: str,
+) -> Tuple[Optional[List[Dict]], List[str]]:
+    """
+    Prepare custom endpoints for template rendering.
+    Copy handler source directories to ensure all dependencies are available.
+
+    Args:
+        custom_endpoints: List of custom endpoint configurations
+        temp_dir: Temporary directory where files will be copied
+
+    Returns:
+        Tuple of:
+        - Prepared endpoint configurations with file information
+        - List of copied directory names (for sys.path setup)
+    """
+    if not custom_endpoints:
+        return None, []
+
+    prepared_endpoints = []
+    handler_dirs_copied = set()  # Track copied directories to avoid duplicates
+    copied_dir_names = []  # Track directory names for sys.path
+
+    for endpoint in custom_endpoints:
+        prepared_endpoint = {
+            "path": endpoint.get("path", "/unknown"),
+            "methods": endpoint.get("methods", ["POST"]),
+            "module": endpoint.get("module"),
+            "function_name": endpoint.get("function_name"),
+        }
+
+        # Try to get handler source file if handler is provided
+        handler = endpoint.get("handler")
+        if handler and callable(handler):
+            try:
+                # Get the source file of the handler
+                handler_file = inspect.getfile(handler)
+                handler_name = handler.__name__
+
+                # Skip if it's a built-in or from site-packages
+                if (
+                    not handler_file.endswith(".py")
+                    or "site-packages" in handler_file
+                ):
+                    raise ValueError("Handler from non-user code")
+
+                # Get the directory containing the handler file
+                handler_dir = os.path.dirname(os.path.abspath(handler_file))
+
+                # Copy the entire working directory if not already copied
+                if handler_dir not in handler_dirs_copied:
+                    # Create a subdirectory name for this handler's context
+                    dir_name = os.path.basename(handler_dir)
+                    if not dir_name or dir_name == ".":
+                        dir_name = "handler_context"
+
+                    # Sanitize directory name
+                    dir_name = re.sub(r"[^a-zA-Z0-9_]", "_", dir_name)
+
+                    # Ensure unique directory name
+                    counter = 1
+                    base_dir_name = dir_name
+                    dest_context_dir = os.path.join(temp_dir, dir_name)
+                    while os.path.exists(dest_context_dir):
+                        dir_name = f"{base_dir_name}_{counter}"
+                        dest_context_dir = os.path.join(temp_dir, dir_name)
+                        counter += 1
+
+                    # Copy entire directory structure
+                    # Exclude common non-essential directories
+                    ignore_patterns = shutil.ignore_patterns(
+                        "__pycache__",
+                        "*.pyc",
+                        "*.pyo",
+                        ".git",
+                        ".gitignore",
+                        ".pytest_cache",
+                        ".mypy_cache",
+                        ".tox",
+                        "venv",
+                        "env",
+                        ".venv",
+                        ".env",
+                        "node_modules",
+                        ".DS_Store",
+                        "*.egg-info",
+                        "build",
+                        "dist",
+                    )
+
+                    shutil.copytree(
+                        handler_dir,
+                        dest_context_dir,
+                        ignore=ignore_patterns,
+                        dirs_exist_ok=True,
+                    )
+
+                    handler_dirs_copied.add(handler_dir)
+                    copied_dir_names.append(dir_name)
+                else:
+                    # Find the existing copied directory name
+                    for existing_dir in os.listdir(temp_dir):
+                        existing_path = os.path.join(temp_dir, existing_dir)
+                        if os.path.isdir(existing_path):
+                            # Check if this is the directory we already copied
+                            original_handler_basename = os.path.basename(
+                                handler_dir,
+                            )
+                            if existing_dir.startswith(
+                                re.sub(
+                                    r"[^a-zA-Z0-9_]",
+                                    "_",
+                                    original_handler_basename,
+                                ),
+                            ):
+                                dir_name = existing_dir
+                                break
+                    else:
+                        # Fallback if not found
+                        dir_name = re.sub(
+                            r"[^a-zA-Z0-9_]",
+                            "_",
+                            os.path.basename(handler_dir),
+                        )
+
+                # Calculate the module path relative to the handler directory
+                handler_file_rel = os.path.relpath(handler_file, handler_dir)
+                # Convert file path to module path
+                module_parts = os.path.splitext(handler_file_rel)[0].split(
+                    os.sep,
+                )
+                if module_parts[-1] == "__init__":
+                    module_parts = module_parts[:-1]
+
+                # Construct the full import path
+                if module_parts:
+                    module_path = f"{dir_name}.{'.'.join(module_parts)}"
+                else:
+                    module_path = dir_name
+
+                # Set the module and function name for template
+                prepared_endpoint["handler_module"] = module_path
+                prepared_endpoint["function_name"] = handler_name
+
+            except (OSError, TypeError, ValueError) as e:
+                # If source file extraction fails, try module/function_name
+                import traceback
+
+                print(f"Warning: Failed to copy handler directory: {e}")
+                traceback.print_exc()
+
+        # Add inline code if no handler module/function available
+        if not prepared_endpoint.get("handler_module") and (
+            not prepared_endpoint["module"]
+            or not prepared_endpoint["function_name"]
+        ):
+            prepared_endpoint["inline_code"] = endpoint.get(
+                "inline_code",
+                'lambda request: {"error": "Handler not available"}',
+            )
+
+        prepared_endpoints.append(prepared_endpoint)
+
+    return prepared_endpoints, copied_dir_names
+
+
 class PackageConfig(BaseModel):
     """Configuration for project packaging"""
 
@@ -73,6 +240,13 @@ class PackageConfig(BaseModel):
         ServicesConfig
     ] = None  # New: services configuration
     protocol_adapters: Optional[List[Any]] = None  # New: protocol adapters
+    custom_endpoints: Optional[
+        List[Dict]
+    ] = None  # New: custom endpoints configuration
+    # Celery configuration parameters
+    broker_url: Optional[str] = None
+    backend_url: Optional[str] = None
+    enable_embedded_worker: bool = False
 
 
 def _find_agent_source_file(
@@ -742,6 +916,41 @@ def package_project(
                     f"# Protocol adapters\nprotocol_adapters = {instances_str}"
                 )
 
+        # Convert celery_config to string representation for template
+        celery_config_str = None
+        config_lines = []
+
+        # Generate celery configuration code
+        config_lines.append("# Celery configuration")
+
+        if config.broker_url:
+            config_lines.append(
+                f'celery_config["broker_url"] = "{config.broker_url}"',
+            )
+
+        if config.backend_url:
+            config_lines.append(
+                f'celery_config["backend_url"] = "{config.backend_url}"',
+            )
+
+        if config.enable_embedded_worker:
+            config_lines.append(
+                f'celery_config["enable_embedded_worker"] = '
+                f"{config.enable_embedded_worker}",
+            )
+
+        if config_lines:
+            celery_config_str = "\n".join(config_lines)
+
+        # Prepare custom endpoints and get copied directory names
+        (
+            custom_endpoints_data,
+            handler_dirs,
+        ) = _prepare_custom_endpoints_for_template(
+            config.custom_endpoints,
+            temp_dir,
+        )
+
         # Render template - use template file by default,
         # or user-provided string
         if template is None:
@@ -751,6 +960,9 @@ def package_project(
                 endpoint_path=config.endpoint_path or "/process",
                 deployment_mode=config.deployment_mode or "standalone",
                 protocol_adapters=protocol_adapters_str,
+                celery_config=celery_config_str,
+                custom_endpoints=custom_endpoints_data,
+                handler_dirs=handler_dirs,
             )
         else:
             # Use user-provided template string
@@ -760,6 +972,9 @@ def package_project(
                 endpoint_path=config.endpoint_path,
                 deployment_mode=config.deployment_mode or "standalone",
                 protocol_adapters=protocol_adapters_str,
+                celery_config=celery_config_str,
+                custom_endpoints=custom_endpoints_data,
+                handler_dirs=handler_dirs,
             )
 
         # Write main.py
@@ -802,9 +1017,25 @@ def package_project(
             if not config.requirements:
                 config.requirements = []
 
-            # Combine base requirements with user requirements
+            # Add Celery requirements if Celery is configured
+            celery_requirements = []
+            if (
+                config.broker_url
+                or config.backend_url
+                or config.enable_embedded_worker
+            ):
+                celery_requirements = ["celery", "redis"]
+
+            # Combine base requirements with user requirements and Celery
+            # requirements
             all_requirements = sorted(
-                list(set(base_requirements + config.requirements)),
+                list(
+                    set(
+                        base_requirements
+                        + config.requirements
+                        + celery_requirements,
+                    ),
+                ),
             )
             for req in all_requirements:
                 f.write(f"{req}\n")