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

agentscope_runtime/engine/agents/agentscope_agent.py

@@ -7,6 +7,7 @@ import json
 import traceback
 from functools import partial
 from typing import Optional, Type, List
+from urllib.parse import urlparse
 
 from agentscope import setup_logger
 from agentscope.agent import AgentBase, ReActAgent
@@ -24,10 +25,12 @@ from agentscope.message import (
     ToolUseBlock,
     ToolResultBlock,
     TextBlock,
+    ThinkingBlock,
     ImageBlock,
-    # AudioBlock,  # TODO: support
+    AudioBlock,
     # VideoBlock,  # TODO: support
     URLSource,
+    Base64Source,
 )
 from agentscope.model import (
     ChatModelBase,
@@ -54,6 +57,7 @@ from ..schemas.agent_schemas import (
     FunctionCall,
     FunctionCallOutput,
     MessageType,
+    RunStatus,
 )
 from ..schemas.context import Context
 
@@ -100,7 +104,7 @@ class AgentScopeContextAdapter:
             role_label = message.role
 
         result = {
-            "name": message.role,
+            "name": message.role,  # TODO: protocol support
             "role": role_label,
             "invocation_id": message.id,
         }
@@ -114,7 +118,7 @@ class AgentScopeContextAdapter:
                 ToolUseBlock(
                     type="tool_use",
                     id=message.content[0].data["call_id"],
-                    name=message.role,
+                    name=message.content[0].data["name"],
                     input=json.loads(message.content[0].data["arguments"]),
                 ),
             ]
@@ -128,15 +132,22 @@ class AgentScopeContextAdapter:
                 ToolResultBlock(
                     type="tool_result",
                     id=message.content[0].data["call_id"],
-                    name=message.role,
-                    output=message.content[0].data["output"],
+                    name=message.role,  # TODO: match id of ToolUseBlock
+                    output=json.loads(message.content[0].data["output"]),
+                ),
+            ]
+        elif message.type in (MessageType.REASONING,):
+            result["content"] = [
+                ThinkingBlock(
+                    type="thinking",
+                    thinking=message.content[0].text,
                 ),
             ]
         else:
             type_mapping = {
                 "text": (TextBlock, "text", None),
                 "image": (ImageBlock, "image_url", True),
-                # "audio": (AudioBlock, "audio_url", True),  # TODO: support
+                "audio": (AudioBlock, "data", None),
                 # "video": (VideoBlock, "video_url", True),  # TODO: support
             }
 
@@ -149,14 +160,32 @@ class AgentScopeContextAdapter:
 
                 block_cls, attr_name, is_url = type_mapping[cnt_type]
                 value = getattr(cnt, attr_name)
-
+                if cnt_type == "audio":
+                    result = urlparse(value)
+                    is_url = all([result.scheme, result.netloc])
                 if is_url:
                     url_source = URLSource(type="url", url=value)
                     msg_content.append(
                         block_cls(type=cnt_type, source=url_source),
                     )
                 else:
-                    msg_content.append(block_cls(type=cnt_type, text=value))
+                    if cnt_type == "audio":
+                        audio_format = getattr(cnt, "format")
+                        base64_source = Base64Source(
+                            type="base64",
+                            media_type=audio_format,
+                            data=value,
+                        )
+                        msg_content.append(
+                            block_cls(
+                                type=cnt_type,
+                                source=base64_source,
+                            ),
+                        )
+                    else:
+                        msg_content.append(
+                            block_cls(type=cnt_type, text=value),
+                        )
 
             result["content"] = msg_content
         return Msg(**result)
@@ -167,6 +196,10 @@ class AgentScopeContextAdapter:
 
     async def adapt_model(self):
         model = self.attr["model"]
+
+        if hasattr(model, "stream"):
+            model.stream = True
+
         formatter = self.attr["agent_config"].get("formatter")
         if formatter and isinstance(formatter, FormatterBase):
             return model, formatter
@@ -307,6 +340,7 @@ class AgentScopeAgent(Agent):
         as_context = AgentScopeContextAdapter(context=context, attr=self._attr)
         await as_context.initialize()
         local_truncate_memory = ""
+        local_truncate_reasoning_memory = ""
 
         # We should always build a new agent since the state is manage outside
         # the agent
@@ -316,7 +350,14 @@ class AgentScopeAgent(Agent):
         last_content = ""
 
         message = Message(type=MessageType.MESSAGE, role="assistant")
-        yield message.in_progress()
+        reasoning_message = Message(
+            type=MessageType.REASONING,
+            role="assistant",
+        )
+
+        should_start_message = True
+        should_start_reasoning_message = True
+
         index = None
 
         # Run agent
@@ -347,6 +388,10 @@ class AgentScopeAgent(Agent):
             else:
                 for element in content:
                     if isinstance(element, str) and element:
+                        if should_start_message:
+                            index = None
+                            yield message.in_progress()
+                            should_start_message = False
                         text_delta_content = TextContent(
                             delta=True,
                             index=index,
@@ -364,6 +409,11 @@ class AgentScopeAgent(Agent):
                                 "",
                             )
                             if text:
+                                if should_start_message:
+                                    index = None
+                                    yield message.in_progress()
+                                    should_start_message = False
+
                                 text_delta_content = TextContent(
                                     delta=True,
                                     index=index,
@@ -391,8 +441,20 @@ class AgentScopeAgent(Agent):
                                         role="assistant",
                                     )
                                     index = None
+                                    should_start_message = True
 
                         elif element.get("type") == "tool_use":
+                            if (
+                                reasoning_message.status
+                                == RunStatus.InProgress
+                            ):
+                                yield reasoning_message.completed()
+                                reasoning_message = Message(
+                                    type=MessageType.REASONING,
+                                    role="assistant",
+                                )
+                                index = None
+
                             json_str = json.dumps(element.get("input"))
                             data_delta_content = DataContent(
                                 index=index,
@@ -408,12 +470,15 @@ class AgentScopeAgent(Agent):
                                 content=[data_delta_content],
                             )
                             yield plugin_call_message.completed()
+                            index = None
+
                         elif element.get("type") == "tool_result":
+                            json_str = json.dumps(element.get("output"))
                             data_delta_content = DataContent(
                                 index=index,
                                 data=FunctionCallOutput(
                                     call_id=element.get("id"),
-                                    output=str(element.get("output")),
+                                    output=json_str,
                                 ).model_dump(),
                             )
                             plugin_output_message = Message(
@@ -422,7 +487,59 @@ class AgentScopeAgent(Agent):
                                 content=[data_delta_content],
                             )
                             yield plugin_output_message.completed()
+                            message = Message(
+                                type=MessageType.MESSAGE,
+                                role="assistant",
+                            )
+                            should_start_message = True
+                            index = None
+
+                        elif element.get("type") == "thinking":
+                            reasoning = element.get(
+                                "thinking",
+                                "",
+                            )
+                            if reasoning:
+                                if should_start_reasoning_message:
+                                    index = None
+                                    yield reasoning_message.in_progress()
+                                    should_start_reasoning_message = False
+                                text_delta_content = TextContent(
+                                    delta=True,
+                                    index=index,
+                                    text=reasoning.removeprefix(
+                                        local_truncate_reasoning_memory,
+                                    ),
+                                )
+                                local_truncate_reasoning_memory = element.get(
+                                    "thinking",
+                                    "",
+                                )
+                                text_delta_content = (
+                                    reasoning_message.add_delta_content(
+                                        new_content=text_delta_content,
+                                    )
+                                )
+                                index = text_delta_content.index
+
+                                # Only yield valid text
+                                if text_delta_content.text:
+                                    yield text_delta_content
+
+                                # The last won't happen in the thinking message
+                                if last:
+                                    yield reasoning_message.completed()
+                                    reasoning_message = Message(
+                                        type=MessageType.REASONING,
+                                        role="assistant",
+                                    )
+                                    index = None
                         else:
+                            if should_start_message:
+                                index = None
+                                yield message.in_progress()
+                                should_start_message = False
+
                             text_delta_content = TextContent(
                                 delta=True,
                                 index=index,
@@ -435,6 +552,9 @@ class AgentScopeAgent(Agent):
                             yield text_delta_content
 
         if last_content:
+            if should_start_message:
+                index = None
+                yield message.in_progress()
             text_delta_content = TextContent(
                 delta=True,
                 index=index,

agentscope_runtime/engine/agents/agno_agent.py

@@ -5,8 +5,8 @@ from typing import Optional, Type
 
 from agno.agent import Agent as AgAgent
 from agno.models.base import Model
-from agno.run.response import (
-    RunResponseContentEvent,
+from agno.run.agent import (
+    RunContentEvent,
     ToolCallStartedEvent,
     ToolCallCompletedEvent,
 )
@@ -163,12 +163,6 @@ class AgnoAgent(Agent):
         # the agent
         _agent = self.build(ag_context)
 
-        resp = await _agent.arun(
-            ag_context.new_message,
-            messages=ag_context.memory,
-            stream=True,
-        )
-
         text_message = Message(
             type=MessageType.MESSAGE,
             role="assistant",
@@ -178,8 +172,12 @@ class AgnoAgent(Agent):
 
         text_delta_content = TextContent(delta=True)
         is_text_delta = False
-        async for event in resp:
-            if isinstance(event, RunResponseContentEvent):
+        async for event in _agent.arun(
+            ag_context.new_message,
+            session_state=ag_context.memory,
+            stream=True,
+        ):
+            if isinstance(event, RunContentEvent):
                 is_text_delta = True
                 text_delta_content.text = event.content
                 text_delta_content = text_message.add_delta_content(

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/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