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

agentscope_runtime/engine/app/celery_mixin.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+import inspect
+import asyncio
+import logging
+from typing import Callable, Optional, List
+from celery import Celery
+
+logger = logging.getLogger(__name__)
+
+
+class CeleryMixin:
+    """
+    Celery task processing mixin that provides core Celery functionality.
+    Can be reused by BaseApp and FastAPIAppFactory.
+    """
+
+    def __init__(
+        self,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+    ):
+        if broker_url and backend_url:
+            self.celery_app = Celery(
+                "agentscope_runtime",
+                broker=broker_url,
+                backend=backend_url,
+            )
+        else:
+            self.celery_app = None
+
+        self._registered_queues: set[str] = set()
+
+    def get_registered_queues(self) -> set[str]:
+        return self._registered_queues
+
+    def register_celery_task(self, func: Callable, queue: str = "celery"):
+        """Register a Celery task for the given function."""
+        if self.celery_app is None:
+            raise RuntimeError("Celery is not configured.")
+
+        self._registered_queues.add(queue)
+
+        @self.celery_app.task(queue=queue)
+        def wrapper(*args, **kwargs):
+            if inspect.iscoroutinefunction(func):
+                return asyncio.run(func(*args, **kwargs))
+            else:
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    def run_task_processor(
+        self,
+        loglevel: str = "INFO",
+        concurrency: Optional[int] = None,
+        queues: Optional[List[str]] = None,
+    ):
+        """Run Celery worker in this process."""
+        if self.celery_app is None:
+            raise RuntimeError("Celery is not configured.")
+
+        cmd = ["worker", f"--loglevel={loglevel}"]
+        if concurrency:
+            cmd.append(f"--concurrency={concurrency}")
+        if queues:
+            cmd.append(f"-Q {','.join(queues)}")
+
+        self.celery_app.worker_main(cmd)
+
+    def get_task_status(self, task_id: str):
+        """Get task status from Celery result backend."""
+        if self.celery_app is None:
+            return {"error": "Celery not configured"}
+
+        result = self.celery_app.AsyncResult(task_id)
+        if result.state == "PENDING":
+            return {"status": "pending", "result": None}
+        elif result.state == "SUCCESS":
+            return {"status": "finished", "result": result.result}
+        elif result.state == "FAILURE":
+            return {"status": "error", "result": str(result.info)}
+        else:
+            return {"status": result.state, "result": None}
+
+    def submit_task(self, func: Callable, *args, **kwargs):
+        """Submit task directly to Celery queue."""
+        if not hasattr(func, "celery_task"):
+            raise RuntimeError(
+                f"Function {func.__name__} is not registered as a task",
+            )
+
+        return func.celery_task.delay(*args, **kwargs)

agentscope_runtime/engine/deployers/adapter/responses/response_api_adapter_utils.py

@@ -71,6 +71,10 @@ from openai.types.responses.response_reasoning_item import (
     ResponseReasoningItem,
 )
 
+from openai.types.responses.response_reasoning_item import (
+    Content as ReasoningContent,
+)
+
 from agentscope_runtime.engine.schemas.agent_schemas import (
     AgentRequest,
     BaseResponse,
@@ -1399,7 +1403,7 @@ class ResponsesAdapter:
             id=message.id,
             summary=[],  # Empty summary
             content=(
-                [Content(type="reasoning_text", text=reasoning_text)]
+                [ReasoningContent(type="reasoning_text", text=reasoning_text)]
                 if reasoning_text
                 else None
             ),

agentscope_runtime/engine/deployers/base.py

@@ -9,6 +9,7 @@ from typing import Dict
 class DeployManager(ABC):
     def __init__(self):
         self.deploy_id = str(uuid.uuid4())
+        self._app = None
 
     @abstractmethod
     async def deploy(self, *args, **kwargs) -> Dict[str, str]:

agentscope_runtime/engine/deployers/cli_fc_deploy.py

@@ -4,6 +4,10 @@ import asyncio
 from pathlib import Path
 from typing import Optional
 
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
 from .modelstudio_deployer import ModelstudioDeployManager
 from .utils.wheel_packager import build_wheel
 
@@ -152,32 +156,47 @@ def main() -> None:
             agent_desc=args.agent_desc,
         ),
     )
-    print("Built wheel at:", result.get("wheel_path", ""))
+
+    console = Console()
+
+    # Create a table for basic information
+    info_table = Table(show_header=False, box=None, padding=(0, 2))
+    info_table.add_column("Key", style="bold cyan")
+    info_table.add_column("Value", style="white")
+
+    if result.get("wheel_path"):
+        info_table.add_row("Built wheel at", result.get("wheel_path", ""))
+
     if result.get("artifact_url"):
-        print("Artifact URL:", result.get("artifact_url"))
-    print("Resource Name:", result.get("resource_name"))
+        info_table.add_row("Artifact URL", result.get("artifact_url"))
+
+    if result.get("resource_name"):
+        info_table.add_row("Resource Name", result.get("resource_name"))
+
     if result.get("workspace_id"):
-        print("Workspace:", result.get("workspace_id"))
+        info_table.add_row("Workspace", result.get("workspace_id"))
+
+    console.print(info_table)
 
+    # Display deploy result in a panel
     console_url = result.get("url")
     deploy_id = result.get("deploy_id")
     if console_url and deploy_id:
-        title = "Deploy Result"
-        console_url_str = f"Console URL: {console_url}"
-        deploy_id_str = f"Deploy ID: {deploy_id}"
-        url_len = len(console_url_str)
-        box_width = max(url_len, len(title), 20)
-
-        # print title
-        print("")
-        print(title.center(box_width + 4))
-
-        # print content
-        print("┏" + "━" * (box_width + 2) + "┓")
-        print(f"┃ {console_url_str.ljust(box_width)} ┃")
-        print(f"┃ {deploy_id_str.ljust(box_width)} ┃")
-        print("┗" + "━" * (box_width + 2) + "┛")
-        print("")
+        console.print()  # Add spacing
+        panel_content = (
+            f"[bold cyan]Console URL:[/bold cyan] {console_url}\n"
+            f"[bold cyan]Deploy ID:[/bold cyan] {deploy_id}"
+        )
+        console.print(
+            Panel(
+                panel_content,
+                title="[bold green]Deploy Result[/bold green]",
+                title_align="center",
+                expand=False,
+                border_style="green",
+            ),
+        )
+        console.print()  # Add spacing
 
 
 if __name__ == "__main__":  # pragma: no cover

agentscope_runtime/engine/deployers/kubernetes_deployer.py

@@ -6,10 +6,6 @@ from typing import Optional, Dict, List, Union, Any
 
 from pydantic import BaseModel, Field
 
-from agentscope_runtime.engine.runner import Runner
-from agentscope_runtime.sandbox.manager.container_clients import (
-    KubernetesClient,
-)
 from .adapter.protocol_adapter import ProtocolAdapter
 from .base import DeployManager
 from .utils.docker_image_utils import (
@@ -19,6 +15,10 @@ from .utils.docker_image_utils import (
 from .utils.service_utils import (
     ServicesConfig,
 )
+from ..runner import Runner
+from ...common.container_clients.kubernetes_client import (
+    KubernetesClient,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -77,6 +77,7 @@ class KubernetesDeployManager(DeployManager):
         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,
         extra_packages: Optional[List[str]] = None,
@@ -100,6 +101,7 @@ class KubernetesDeployManager(DeployManager):
             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
                 pattern)
@@ -156,6 +158,7 @@ class KubernetesDeployManager(DeployManager):
                     port=port,
                     services_config=services_config,  # type: ignore[arg-type]
                     protocol_adapters=protocol_adapters,
+                    custom_endpoints=custom_endpoints,
                     **kwargs,
                 )
                 if not built_image_name:
@@ -205,7 +208,11 @@ class KubernetesDeployManager(DeployManager):
                     f"{resource_name}, {traceback.format_exc()}",
                 )
 
-            url = f"http://{ip}:{ports[0]}"
+            if ports:
+                url = f"http://{ip}:{ports[0]}"
+            else:
+                url = f"http://{ip}:8080"
+
             logger.info(f"Deployment {deploy_id} successful: {url}")
 
             self._deployed_resources[deploy_id] = {

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 []
             ),
         )