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

agentscope_runtime/engine/agents/autogen_agent.py

@@ -11,6 +11,7 @@ from autogen_agentchat.messages import (
     ModelClientStreamingChunkEvent,
 )
 
+from .utils import build_agent
 from ..agents import Agent
 from ..schemas.context import Context
 from ..schemas.agent_schemas import (
@@ -136,20 +137,24 @@ class AutogenAgent(Agent):
             "agent_config": self.agent_config,
             "agent_builder": agent_builder,
         }
-        self._agent = None
         self.tools = tools
 
     def copy(self) -> "AutogenAgent":
         return AutogenAgent(**self._attr)
 
     def build(self, as_context):
-        self._agent = self._attr["agent_builder"](
+        params = {
             **self._attr["agent_config"],
-            model_client=as_context.model,
-            tools=as_context.toolkit,
-        )
+            **{
+                "model_client": as_context.model,
+                "tools": as_context.toolkit,
+            },  # Context will be added at `_agent.run_stream`
+        }
+
+        builder_cls = self._attr["agent_builder"]
+        _agent = build_agent(builder_cls, params)
 
-        return self._agent
+        return _agent
 
     async def run(self, context):
         ag_context = AutogenContextAdapter(context=context, attr=self._attr)
@@ -157,9 +162,9 @@ class AutogenAgent(Agent):
 
         # We should always build a new agent since the state is manage outside
         # the agent
-        self._agent = self.build(ag_context)
+        _agent = self.build(ag_context)
 
-        resp = self._agent.run_stream(
+        resp = _agent.run_stream(
             task=ag_context.memory + [ag_context.new_message],
         )
 

agentscope_runtime/engine/agents/langgraph_agent.py

@@ -3,22 +3,65 @@ import json
 
 from langgraph.graph.state import CompiledStateGraph
 
+from ..schemas.agent_schemas import Message, TextContent
 from .base_agent import Agent
-from ..schemas.agent_schemas import (
-    Message,
-    TextContent,
-)
 
 
 def _state_folder(messages):
-    if len(messages) > 0:
-        return json.loads(messages[0]["content"])
-    else:
+    if not messages or len(messages) == 0:
+        # Return empty list if no messages
         return []
 
+    content = messages[0]["content"]
+    role = messages[0]["role"]
+
+    # If content is a list, extract the text content
+    if isinstance(content, list) and len(content) > 0:
+        if isinstance(content[0], dict) and content[0].get("type") == "text":
+            text_content = content[0].get("text", "")
+        else:
+            # If not text type, convert to string
+            text_content = str(content)
+        return {"messages": [{"role": role, "content": text_content}]}
+
+    # If content is string, parse it as JSON, if failed, return directly
+    if isinstance(content, str):
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            # If not valid JSON, return the original string
+            return {"messages": [{"role": role, "content": content}]}
+
+    # If content is already a dictionary, return directly
+    if isinstance(content, dict):
+        return content
+
+    # For other cases, wrap in messages and return
+    return {"messages": [{"role": role, "content": str(content)}]}
+
 
 def _state_unfolder(state):
-    state_jsons = json.dumps(state)
+    # Process state that may contain non-serializable objects
+    def default_serializer(obj):
+        # If object has __dict__ method, use it
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        # If object has model_dump method, use it
+        elif hasattr(obj, "model_dump"):
+            return obj.model_dump()
+        # If object is a message type, extract its content
+        elif hasattr(obj, "content"):
+            return str(obj.content)
+        # For other cases, convert to string
+        else:
+            return str(obj)
+
+    # Serialize state to JSON string with custom serializer
+    state_jsons = json.dumps(
+        state,
+        default=default_serializer,
+        ensure_ascii=False,
+    )
     return state_jsons
 
 
@@ -40,7 +83,7 @@ class LangGraphAgent(Agent):
         context,
         **kwargs,
     ):
-        # fold the last m
+        # Convert messages to list format
         list_messages = []
         for m in context.session.messages:
             dumped = m.model_dump()

agentscope_runtime/engine/agents/utils.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+import inspect
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def build_agent(builder_cls, params):
+    """
+    Filters out unsupported parameters based on the __init__ signature of
+    builder_cls
+    and instantiates the class.
+
+    Args:
+        builder_cls (type): The class to instantiate.
+        params (dict): Dictionary of parameters to pass to the constructor.
+
+    Returns:
+        object: An instance of builder_cls.
+    """
+    try:
+        # Get the signature of the __init__ method
+        sig = inspect.signature(builder_cls.__init__)
+        allowed_params = set(sig.parameters.keys())
+        # Remove 'self' from the list of allowed parameters
+        allowed_params.discard("self")
+    except (TypeError, ValueError):
+        # If signature cannot be inspected, allow all given params
+        allowed_params = set(params.keys())
+
+    filtered_params = {}  # Parameters that are accepted by the constructor
+    unsupported = []  # Parameters that are not accepted
+
+    # Separate supported and unsupported parameters
+    for k, v in params.items():
+        if k in allowed_params:
+            filtered_params[k] = v
+        else:
+            unsupported.append(f"{k}={v!r}")
+
+    # Log a warning if there are unsupported parameters
+    if unsupported:
+        unsupported_str = ", ".join(unsupported)
+        logger.warning(
+            f"The following parameters are not supported by "
+            f"{builder_cls.__name__} and have been ignored: "
+            f"{unsupported_str}. If you require these parameters, "
+            f"please update the `__init__` method of "
+            f"{builder_cls.__name__} to accept and handle them.",
+        )
+
+    # Instantiate the class with only supported parameters
+    return builder_cls(**filtered_params)

agentscope_runtime/engine/app/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+from .agent_app import AgentApp
+
+__all__ = [
+    "AgentApp",
+]

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()