agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-argument,line-too-long
+import logging
+import traceback
+from typing import Callable, Dict
+
+from agentscope_runtime.engine.deployers.adapter.responses.response_api_adapter_utils import (  # noqa: E501
+    ResponsesAdapter,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ResponseAPIExecutor:
+    def __init__(self, func: Callable, **kwargs):
+        self._func = func
+
+    async def execute(
+        self,
+        request: Dict,
+    ):
+        # Start executing agent
+        sequence_counter = 0
+        responses_adapter = ResponsesAdapter()
+
+        # Convert input parameters to agent api
+        agent_request = (
+            responses_adapter.convert_responses_request_to_agent_request(
+                request,
+            )
+        )
+
+        try:
+            async for event in self._func(request=agent_request):
+                # Convert Agent API events to Responses API events
+                responses_event = (
+                    responses_adapter.convert_agent_event_to_responses_event(
+                        event,
+                    )
+                )
+
+                event_count = 0
+                if responses_event:
+                    for event in responses_event:
+                        # Uniformly set sequence_number
+                        event.sequence_number = sequence_counter
+                        sequence_counter += 1
+                        event_count += 1
+                        yield event
+        except Exception as e:
+            logger.error(f"An error occurred: {e}, {traceback.format_exc()}")

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

@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import json
+import logging
+import traceback
+from typing import Callable, Dict, Any, Optional, AsyncGenerator
+from uuid import uuid4
+
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+
+# OpenAI Response API official type definition
+from openai.types.responses import ResponseCreateParams
+
+from .response_api_adapter_utils import ResponsesAdapter
+from .response_api_agent_adapter import ResponseAPIExecutor
+from ..protocol_adapter import ProtocolAdapter
+from ....schemas.agent_schemas import AgentRequest, BaseResponse
+
+logger = logging.getLogger(__name__)
+
+RESPONSES_ENDPOINT_PATH = "/compatible-mode/v1/responses"
+SSE_HEADERS = {
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "X-Accel-Buffering": "no",  # disable Nginx buffering
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+}
+
+
+class ResponseAPIDefaultAdapter(ProtocolAdapter):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._executor: Optional[ResponseAPIExecutor] = None
+        self._timeout = kwargs.get("timeout", 300)  # seconds
+        self._max_concurrent_requests = kwargs.get(
+            "max_concurrent_requests",
+            100,
+        )
+        self._semaphore = asyncio.Semaphore(self._max_concurrent_requests)
+
+    async def _handle_requests(self, request: Request) -> StreamingResponse:
+        """
+        Handle OpenAI Response API request.
+
+        Args:
+            request: FastAPI Request object
+
+        Returns:
+            StreamingResponse: SSE streaming response
+        """
+        # Concurrency guard per request
+        await self._semaphore.acquire()
+        request_id = f"resp_{uuid4()}"
+        logger.info("[ResponseAPI] start request_id=%s", request_id)
+        try:
+            # Parse request body
+            request_data = await request.json()
+
+            stream = request_data.get("stream", False)
+
+            # Stream or non-stream
+            if stream:
+                # Return SSE streaming response with timeout control
+                return StreamingResponse(
+                    self._generate_stream_response_with_timeout(
+                        request=request_data,
+                        request_id=request_id,
+                    ),
+                    media_type="text/event-stream",
+                    headers=SSE_HEADERS,
+                )
+
+            # Non-stream JSON response
+            response_obj = await self._collect_non_stream_response(
+                request=request_data,
+                request_id=request_id,
+            )
+            return JSONResponse(content=response_obj)
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(
+                f"Unexpected error in _handle_requests: {e}\n"
+                f"{traceback.format_exc()}",
+            )
+            raise HTTPException(
+                status_code=500,
+                detail="Internal server error",
+            ) from e
+        finally:
+            self._semaphore.release()
+            logger.info("[ResponseAPI] end request_id=%s", request_id)
+
+    def _convert_response_request_to_agent_request(
+        self,
+        response_request: ResponseCreateParams,
+    ) -> AgentRequest:
+        """
+        Convert an OpenAI Response API request to Agent API request.
+
+        Args:
+            response_request: OpenAI Response API request
+
+        Returns:
+            AgentRequest: Agent API request
+        """
+        # Convert with ResponsesAdapter
+        adapter = ResponsesAdapter()
+        agent_request = adapter.convert_responses_request_to_agent_request(
+            response_request.model_dump(),
+        )
+
+        return agent_request
+
+    async def _collect_non_stream_response(
+        self,
+        request: Dict,
+        request_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Run the agent and build a non-streaming OpenAI Responses API object.
+
+        This collects events until completion and returns a single JSON object
+        representing the final response.
+        """
+        last_agent_response: Optional[BaseResponse] = None
+        try:
+            async for event in self._executor.execute(request):
+                last_agent_response = event
+        except Exception:
+            # Map to Responses error shape
+            return {
+                "id": request_id,
+                "object": "response",
+                "status": "failed",
+                "error": {
+                    "code": "non_stream_error",
+                    "message": "Failed to build non-stream response",
+                },
+            }
+
+        if not last_agent_response:
+            # No response produced
+            return {
+                "id": request_id,
+                "object": "response",
+                "status": "failed",
+                "error": {
+                    "code": "empty_response",
+                    "message": "No response produced by agent",
+                },
+            }
+
+        # Convert to dict for JSONResponse
+        return last_agent_response.model_dump(exclude_none=True)
+
+    async def _generate_stream_response_with_timeout(
+        self,
+        request: Dict,
+        request_id: str,
+    ) -> AsyncGenerator[str, None]:
+        """
+        Generate SSE streaming response with timeout.
+
+        Args:
+            agent_request: Agent API request
+
+        Yields:
+            str: SSE data chunks
+        """
+        try:
+            # Add timeout with asyncio.wait_for
+            async for chunk in self._generate_stream_response(
+                request=request,
+                request_id=request_id,
+            ):
+                yield chunk
+        except asyncio.TimeoutError:
+            logger.error(f"Request timeout after {self._timeout} seconds")
+            # Send timeout error event
+            timeout_event = {
+                "id": request_id,
+                "object": "response",
+                "status": "failed",
+                "error": {
+                    "code": "timeout",
+                    "message": f"Request timed out after "
+                    f"{self._timeout} seconds",
+                },
+            }
+            yield (
+                f"event: response.failed\n"
+                f"data: {json.dumps(timeout_event)}\n\n"
+            )
+        except Exception as e:
+            logger.error(
+                f"Error in timeout-controlled stream: {e}\n"
+                f"{traceback.format_exc()}",
+            )
+            # Send error event
+            error_event = {
+                "id": request_id,
+                "object": "response",
+                "status": "failed",
+                "error": {
+                    "code": "stream_error",
+                    "message": str(e),
+                },
+            }
+            yield (
+                f"event: response.failed\n"
+                f"data: {json.dumps(error_event)}\n\n"
+            )
+
+    async def _generate_stream_response(
+        self,
+        request: Dict,
+        request_id: str,
+    ) -> AsyncGenerator[str, None]:
+        """
+        Generate SSE streaming response.
+
+        Args:
+            request: Responses API request
+
+        Yields:
+            str: SSE data chunks
+        """
+        try:
+            # Handle streaming events
+            async for event in self._executor.execute(request):
+                try:
+                    if event:
+                        # Serialize event
+                        event_data = event.model_dump(exclude_none=True)
+                        data = json.dumps(event_data, ensure_ascii=False)
+
+                        # Set SSE event type based on event type
+                        event_type = event_data.get("type", "message")
+                        yield f"event: {event_type}\ndata: {data}\n\n"
+
+                except Exception as e:
+                    logger.error(
+                        f"Error processing event: {e}\n"
+                        f"{traceback.format_exc()}",
+                    )
+                    # Send error event
+                    error_event = {
+                        "id": request_id,
+                        "object": "response",
+                        "status": "failed",
+                        "error": {
+                            "code": "processing_error",
+                            "message": str(e),
+                        },
+                    }
+                    yield (
+                        f"event: response.failed\n"
+                        f"data: {json.dumps(error_event)}\n\n"
+                    )
+                    break
+        except Exception as e:
+            logger.error(
+                f"Error in stream generation: {e}\n{traceback.format_exc()}",
+            )
+            # Send error event
+            error_event = {
+                "id": request_id,
+                "object": "response",
+                "status": "failed",
+                "error": {
+                    "code": "stream_error",
+                    "message": str(e),
+                },
+            }
+            yield (
+                f"event: response.failed\n"
+                f"data: {json.dumps(error_event)}\n\n"
+            )
+
+    def add_endpoint(self, app: FastAPI, func: Callable, **kwargs) -> None:
+        """
+        Add endpoint to FastAPI app.
+
+        Args:
+            app: FastAPI application instance
+            func: handler function
+            **kwargs: extra options
+        """
+        # Create executor
+        self._executor = ResponseAPIExecutor(func=func)
+
+        # Register route
+        app.post(
+            RESPONSES_ENDPOINT_PATH,
+            openapi_extra={
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/ResponseAPI",
+                            },
+                        },
+                    },
+                    "required": True,
+                    "description": "OpenAI Response API compatible "
+                    "request format",
+                },
+            },
+        )(self._handle_requests)

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

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+import argparse
+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
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="One-click deploy your service to Alibaba Bailian "
+        "Function Compute (FC)",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=["wrapper", "native"],
+        default="wrapper",
+        help="Build mode: wrapper (default) packages your project into a "
+        "starter; native builds your current project directly.",
+    )
+    parser.add_argument(
+        "--whl-path",
+        dest="whl_path",
+        default=None,
+        help="Path to an external wheel file to deploy directly (skip build)",
+    )
+    parser.add_argument(
+        "--dir",
+        default=None,
+        help="Path to your project directory (wrapper mode)",
+    )
+    parser.add_argument(
+        "--cmd",
+        default=None,
+        help="Command to start your service (wrapper mode), e.g., 'python "
+        "app.py'",
+    )
+    parser.add_argument(
+        "--deploy-name",
+        dest="deploy_name",
+        default=None,
+        help="Deploy name (agent_name). Random if omitted",
+    )
+    parser.add_argument(
+        "--skip-upload",
+        action="store_true",
+        help="Only build wheel, do not upload/deploy",
+    )
+    parser.add_argument(
+        "--telemetry",
+        choices=["enable", "disable"],
+        default="enable",
+        help="Enable or disable telemetry (default: enable)",
+    )
+    parser.add_argument(
+        "--build-root",
+        dest="build_root",
+        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()
+
+
+async def _run(
+    dir_path: Optional[str],
+    cmd: Optional[str],
+    deploy_name: Optional[str],
+    skip_upload: bool,
+    telemetry_enabled: bool,
+    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
+    if whl_path:
+        return await deployer.deploy(
+            project_dir=None,
+            cmd=None,
+            deploy_name=deploy_name,
+            skip_upload=skip_upload,
+            telemetry_enabled=telemetry_enabled,
+            external_whl_path=whl_path,
+            agent_id=agent_id,
+            agent_desc=agent_desc,
+        )
+
+    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)
+        return await deployer.deploy(
+            project_dir=None,
+            cmd=None,
+            deploy_name=deploy_name,
+            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 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,
+    )
+
+
+def main() -> None:
+    args = _parse_args()
+    telemetry_enabled = args.telemetry == "enable"
+    result = asyncio.run(
+        _run(
+            dir_path=args.dir,
+            cmd=args.cmd,
+            deploy_name=args.deploy_name,
+            skip_upload=args.skip_upload,
+            telemetry_enabled=telemetry_enabled,
+            build_root=args.build_root,
+            mode=args.mode,
+            whl_path=args.whl_path,
+            agent_id=args.agent_id,
+            agent_desc=args.agent_desc,
+        ),
+    )
+
+    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"):
+        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"):
+        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
+    main()