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

agentscope_runtime/engine/app/agent_app.py

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from typing import Optional, Any, Callable, List
+
+import uvicorn
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from .base_app import BaseApp
+from ..agents.base_agent import Agent
+from ..deployers.adapter.a2a import A2AFastAPIDefaultAdapter
+from ..deployers.adapter.responses.response_api_protocol_adapter import (
+    ResponseAPIDefaultAdapter,
+)
+from ..deployers.utils.deployment_modes import DeploymentMode
+from ..deployers.utils.service_utils.fastapi_factory import FastAPIAppFactory
+from ..deployers.utils.service_utils.service_config import (
+    DEFAULT_SERVICES_CONFIG,
+)
+from ..runner import Runner
+from ..schemas.agent_schemas import AgentRequest
+from ..services.context_manager import ContextManager
+from ..services.environment_manager import EnvironmentManager
+from ...version import __version__
+
+logger = logging.getLogger(__name__)
+
+
+class AgentApp(BaseApp):
+    """
+    The AgentApp class represents an application that runs as an agent.
+    """
+
+    def __init__(
+        self,
+        *,
+        agent: Optional[Agent] = None,
+        environment_manager: Optional[EnvironmentManager] = None,
+        context_manager: Optional[ContextManager] = None,
+        endpoint_path: str = "/process",
+        response_type: str = "sse",
+        stream: bool = True,
+        request_model: Optional[type[BaseModel]] = AgentRequest,
+        before_start: Optional[Callable] = None,
+        after_finish: Optional[Callable] = None,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        **kwargs,
+    ):
+        """
+        Initialize the AgentApp.
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
+
+        self.endpoint_path = endpoint_path
+        self.response_type = response_type
+        self.stream = stream
+        self.request_model = request_model
+        self.before_start = before_start
+        self.after_finish = after_finish
+        self.broker_url = broker_url
+        self.backend_url = backend_url
+
+        self._agent = agent
+        self._runner = None
+        self.custom_endpoints = []  # Store custom endpoints
+
+        a2a_protocol = A2AFastAPIDefaultAdapter(agent=self._agent)
+        response_protocol = ResponseAPIDefaultAdapter()
+        self.protocol_adapters = [a2a_protocol, response_protocol]
+
+        if self._agent:
+            self._runner = Runner(
+                agent=self._agent,
+                environment_manager=environment_manager,
+                context_manager=context_manager,
+            )
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> Any:
+            """Manage the application lifespan."""
+            if hasattr(self, "before_start") and self.before_start:
+                if asyncio.iscoroutinefunction(self.before_start):
+                    await self.before_start(app, **getattr(self, "kwargs", {}))
+                else:
+                    self.before_start(app, **getattr(self, "kwargs", {}))
+            yield
+            if hasattr(self, "after_finish") and self.after_finish:
+                if asyncio.iscoroutinefunction(self.after_finish):
+                    await self.after_finish(app, **getattr(self, "kwargs", {}))
+                else:
+                    self.after_finish(app, **getattr(self, "kwargs", {}))
+
+        kwargs = {
+            "title": "Agent Service",
+            "version": __version__,
+            "description": "Production-ready Agent Service API",
+            "lifespan": lifespan,
+            **kwargs,
+        }
+
+        if self._runner:
+            if self.stream:
+                self.func = self._runner.stream_query
+            else:
+                self.func = self._runner.query
+
+        super().__init__(
+            broker_url=broker_url,
+            backend_url=backend_url,
+            **kwargs,
+        )
+
+        # Store custom endpoints and tasks for deployment
+        # but don't add them to FastAPI here - let FastAPIAppFactory handle it
+
+    def run(
+        self,
+        host="0.0.0.0",
+        port=8090,
+        embed_task_processor=False,
+        services_config=None,
+        **kwargs,
+    ):
+        """
+        Run the AgentApp using FastAPIAppFactory directly.
+
+        Args:
+            host: Host to bind to
+            port: Port to bind to
+            embed_task_processor: Whether to embed task processor
+            services_config: Optional services configuration
+            **kwargs: Additional keyword arguments
+        """
+
+        try:
+            logger.info(
+                "[AgentApp] Starting AgentApp with FastAPIAppFactory...",
+            )
+
+            # Use default services config if not provided
+            if services_config is None:
+                services_config = DEFAULT_SERVICES_CONFIG
+
+            # Create FastAPI application using the factory
+            fastapi_app = FastAPIAppFactory.create_app(
+                runner=self._runner,
+                endpoint_path=self.endpoint_path,
+                request_model=self.request_model,
+                response_type=self.response_type,
+                stream=self.stream,
+                before_start=self.before_start,
+                after_finish=self.after_finish,
+                mode=DeploymentMode.DAEMON_THREAD,
+                services_config=services_config,
+                protocol_adapters=self.protocol_adapters,
+                custom_endpoints=self.custom_endpoints,
+                broker_url=self.broker_url,
+                backend_url=self.backend_url,
+                enable_embedded_worker=embed_task_processor,
+                **kwargs,
+            )
+
+            logger.info(f"[AgentApp] Starting server on {host}:{port}")
+
+            # Start the FastAPI application with uvicorn
+            uvicorn.run(
+                fastapi_app,
+                host=host,
+                port=port,
+                log_level="info",
+                access_log=True,
+            )
+
+        except Exception as e:
+            logger.error(f"[AgentApp] Error while running: {e}")
+            raise
+
+    async def deploy(self, deployer, **kwargs):
+        """Deploy the agent app with custom endpoints support"""
+        # Pass custom endpoints and tasks to the deployer
+
+        deploy_kwargs = {
+            **kwargs,
+            "custom_endpoints": self.custom_endpoints,
+            "agent": self._agent,
+            "runner": self._runner,
+            "endpoint_path": self.endpoint_path,
+            "stream": self.stream,
+            "protocol_adapters": self.protocol_adapters,
+        }
+        return await deployer.deploy(**deploy_kwargs)
+
+    def endpoint(self, path: str, methods: Optional[List[str]] = None):
+        """Decorator to register custom endpoints"""
+
+        if methods is None:
+            methods = ["POST"]
+
+        def decorator(func: Callable):
+            endpoint_info = {
+                "path": path,
+                "handler": func,
+                "methods": methods,
+                "module": getattr(func, "__module__", None),
+                "function_name": getattr(func, "__name__", None),
+            }
+            self.custom_endpoints.append(endpoint_info)
+            return func
+
+        return decorator
+
+    def task(self, path: str, queue: str = "default"):
+        """Decorator to register custom task endpoints"""
+
+        def decorator(func: Callable):
+            # Store task configuration for FastAPIAppFactory to handle
+            task_info = {
+                "path": path,
+                "handler": func,  # Store original function
+                "methods": ["POST"],
+                "module": getattr(func, "__module__", None),
+                "function_name": getattr(func, "__name__", None),
+                "queue": queue,
+                "task_type": True,  # Mark as task endpoint
+                "original_func": func,
+            }
+            self.custom_endpoints.append(
+                task_info,
+            )  # Add to endpoints for deployment
+
+            return func
+
+        return decorator

agentscope_runtime/engine/app/base_app.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+import inspect
+import logging
+import threading
+from typing import Callable, Optional
+
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+
+from .celery_mixin import CeleryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class BaseApp(FastAPI, CeleryMixin):
+    """
+    BaseApp extends FastAPI and integrates with Celery
+    for asynchronous background task execution.
+    """
+
+    def __init__(
+        self,
+        broker_url: Optional[str] = None,
+        backend_url: Optional[str] = None,
+        **kwargs,
+    ):
+        # Initialize CeleryMixin
+        CeleryMixin.__init__(self, broker_url, backend_url)
+
+        self.server = None
+
+        # Initialize FastAPI
+        FastAPI.__init__(self, **kwargs)
+
+    def task(self, path: str, queue: str = "celery"):
+        """
+        Register an asynchronous task endpoint.
+        POST <path>  -> Create a task and return task ID
+        GET  <path>/{task_id} -> Check the task status and result
+        Combines Celery and FastAPI routing functionality.
+        """
+        if self.celery_app is None:
+            raise RuntimeError(
+                f"[AgentApp] Cannot register task endpoint '{path}'.\n"
+                f"Reason: The @task decorator requires a background task "
+                f"queue to run asynchronous jobs.\n\n"
+                "If you want to use async task queue, you must initialize "
+                "AgentApp with broker_url and backend_url, e.g.: \n\n"
+                "    app = AgentApp(\n"
+                "        broker_url='redis://localhost:6379/0',\n"
+                "        backend_url='redis://localhost:6379/0'\n"
+                "    )\n",
+            )
+
+        def decorator(func: Callable):
+            # Register Celery task using CeleryMixin
+            celery_task = self.register_celery_task(func, queue=queue)
+
+            # Add FastAPI HTTP routes
+            @self.post(path)
+            async def create_task(request: Request):
+                if len(inspect.signature(func).parameters) > 0:
+                    body = await request.json()
+                    task = celery_task.delay(body)
+                else:
+                    task = celery_task.delay()
+                return {"task_id": task.id}
+
+            @self.get(path + "/{task_id}")
+            async def get_task(task_id: str):
+                return self.get_task_status(task_id)
+
+            return func
+
+        return decorator
+
+    def endpoint(self, path: str):
+        """
+        Unified POST endpoint decorator.
+        Pure FastAPI functionality, independent of Celery.
+        Supports:
+          - Sync functions
+          - Async functions (coroutines)
+          - Sync/async generator functions (streaming responses)
+        """
+
+        def decorator(func: Callable):
+            is_async_gen = inspect.isasyncgenfunction(func)
+            is_sync_gen = inspect.isgeneratorfunction(func)
+
+            if is_async_gen or is_sync_gen:
+                # Handle streaming responses
+                async def _stream_generator(request: Request):
+                    if is_async_gen:
+                        async for chunk in func(request):
+                            yield chunk
+                    else:
+                        for chunk in func(request):
+                            yield chunk
+
+                @self.post(path)
+                async def _wrapped(request: Request):
+                    return StreamingResponse(
+                        _stream_generator(request),
+                        media_type="text/plain",
+                    )
+
+            else:
+                # Handle regular responses
+                @self.post(path)
+                async def _wrapped(request: Request):
+                    if inspect.iscoroutinefunction(func):
+                        return await func(request)
+                    else:
+                        return func(request)
+
+            return func
+
+        return decorator
+
+    def run(
+        self,
+        host="0.0.0.0",
+        port=8090,
+        embed_task_processor=False,
+        **kwargs,
+    ):
+        """
+        Run FastAPI with uvicorn.
+        """
+        if embed_task_processor:
+            if self.celery_app is None:
+                logger.warning(
+                    "[AgentApp] Celery is not configured. "
+                    "Cannot run embedded worker.",
+                )
+            else:
+                logger.warning(
+                    "[AgentApp] embed_task_processor=True: Running "
+                    "task_processor in embedded thread mode. This is "
+                    "intended for development/debug purposes only. In "
+                    "production, run Celery worker in a separate process!",
+                )
+
+                queues = self._registered_queues or {"celery"}
+                queue_list = ",".join(sorted(queues))
+
+                def start_celery_worker():
+                    logger.info(
+                        f"[AgentApp] Embedded worker listening "
+                        f"queues: {queue_list}",
+                    )
+                    self.celery_app.worker_main(
+                        [
+                            "worker",
+                            "--loglevel=INFO",
+                            "-Q",
+                            queue_list,
+                        ],
+                    )
+
+                threading.Thread(
+                    target=start_celery_worker,
+                    daemon=True,
+                ).start()
+                logger.info(
+                    "[AgentApp] Embedded task processor started in background "
+                    "thread (DEV mode).",
+                )
+
+        # TODO: Add CLI to main entrypoint to control run/deploy
+
+        config = uvicorn.Config(
+            app=self,
+            host=host,
+            port=port,
+            **kwargs,
+        )
+        self.server = uvicorn.Server(config)
+        self.server.run()

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/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
 
@@ -60,6 +64,19 @@ def _parse_args() -> argparse.Namespace:
         default=None,
         help="Custom directory for temporary build artifacts (optional)",
     )
+    parser.add_argument(
+        "--update",
+        dest="agent_id",
+        default=None,
+        help="Update an existing agent. "
+        "Specify agent_id to update a particular agent (optional)",
+    )
+    parser.add_argument(
+        "--desc",
+        dest="agent_desc",
+        default=None,
+        help="Add description to current agent(optional)",
+    )
     return parser.parse_args()
 
 
@@ -72,6 +89,8 @@ async def _run(
     build_root: Optional[str],
     mode: str,
     whl_path: Optional[str],
+    agent_id: Optional[str],
+    agent_desc: Optional[str],
 ):
     deployer = ModelstudioDeployManager(build_root=build_root)
     # If a wheel path is provided, skip local build entirely
@@ -83,6 +102,8 @@ async def _run(
             skip_upload=skip_upload,
             telemetry_enabled=telemetry_enabled,
             external_whl_path=whl_path,
+            agent_id=agent_id,
+            agent_desc=agent_desc,
         )
 
     if mode == "native":
@@ -96,20 +117,25 @@ async def _run(
             skip_upload=skip_upload,
             telemetry_enabled=telemetry_enabled,
             external_whl_path=str(built_whl),
+            agent_id=agent_id,
+            agent_desc=agent_desc,
         )
 
     # wrapper mode (default): require dir and cmd
-    if not dir_path or not cmd:
-        raise SystemExit(
-            "In wrapper mode, --dir and --cmd are required. Alternatively "
-            "use --mode native or --whl-path.",
-        )
+    if not agent_id:
+        if not dir_path or not cmd:
+            raise SystemExit(
+                "In wrapper mode, --dir and --cmd are required. Alternatively "
+                "use --mode native or --whl-path.",
+            )
     return await deployer.deploy(
         project_dir=dir_path,
         cmd=cmd,
         deploy_name=deploy_name,
         skip_upload=skip_upload,
         telemetry_enabled=telemetry_enabled,
+        agent_id=agent_id,
+        agent_desc=agent_desc,
     )
 
 
@@ -126,17 +152,51 @@ def main() -> None:
             build_root=args.build_root,
             mode=args.mode,
             whl_path=args.whl_path,
+            agent_id=args.agent_id,
+            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("Deploy ID:", result.get("deploy_id"))
-    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"))
-    if result.get("url"):
-        print("Console Url:", result.get("url"))
+        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:
+        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