agentscope-runtime 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

agentscope_runtime/engine/agents/agentscope_agent/agent.py

@@ -1,11 +1,14 @@
 # -*- coding: utf-8 -*-
 # pylint:disable=too-many-nested-blocks, too-many-branches, too-many-statements
+# pylint:disable=line-too-long, protected-access
+
 import json
 import threading
 import uuid
 from functools import partial
 from typing import Optional, Type
 
+from agentscope import setup_logger
 from agentscope.agent import ReActAgent
 from agentscope.formatter import (
     FormatterBase,
@@ -15,6 +18,8 @@ from agentscope.formatter import (
     OllamaChatFormatter,
     GeminiChatFormatter,
 )
+from agentscope.memory import InMemoryMemory
+from agentscope.message import Msg, ToolUseBlock, ToolResultBlock
 from agentscope.model import (
     ChatModelBase,
     DashScopeChatModel,
@@ -23,9 +28,6 @@ from agentscope.model import (
     OllamaChatModel,
     GeminiChatModel,
 )
-from agentscope.memory import InMemoryMemory
-from agentscope.message import Msg
-from agentscope import setup_logger
 from agentscope.tool import (
     Toolkit,
     ToolResponse,
@@ -46,7 +48,6 @@ from ...schemas.agent_schemas import (
     FunctionCall,
     FunctionCallOutput,
     MessageType,
-    RunStatus,
 )
 from ...schemas.context import Context
 
@@ -90,12 +91,33 @@ class AgentScopeContextAdapter:
             role_label = "user"
         else:
             role_label = message.role
-
-        return {
+        result = {
             "name": message.role,
             "role": role_label,
-            "content": message.content[0].text if message.content else "",
         }
+        if message.type == MessageType.PLUGIN_CALL:
+            result["content"] = [
+                ToolUseBlock(
+                    type="tool_use",
+                    id=message.content[0].data["call_id"],
+                    name=message.role,
+                    input=json.loads(message.content[0].data["arguments"]),
+                ),
+            ]
+        elif message.type == MessageType.PLUGIN_CALL_OUTPUT:
+            result["content"] = [
+                ToolResultBlock(
+                    type="tool_result",
+                    id=message.content[0].data["call_id"],
+                    name=message.role,
+                    output=message.content[0].data["output"],
+                ),
+            ]
+        else:
+            result["content"] = (
+                message.content[0].text if message.content else ""
+            )
+        return result
 
     async def adapt_new_message(self):
         last_message = self.context.session.messages[-1]
@@ -213,6 +235,7 @@ class AgentScopeAgent(Agent):
             memory=as_context.memory,
             toolkit=as_context.toolkit,
         )
+        self._agent._disable_console_output = True
 
         self._agent.register_instance_hook(
             "pre_print",
@@ -225,6 +248,7 @@ class AgentScopeAgent(Agent):
     async def run(self, context):
         as_context = AgentScopeContextAdapter(context=context, attr=self._attr)
         await as_context.initialize()
+        local_truncate_memory = ""
 
         # We should always build a new agent since the state is manage outside
         # the agent
@@ -245,89 +269,120 @@ class AgentScopeAgent(Agent):
             # Yield new Msg instances as they are logged
             last_content = ""
 
+            message = Message(type=MessageType.MESSAGE, role="assistant")
+            yield message.in_progress()
+            index = None
+
             for msg, msg_len in get_msg_instances(thread_id=thread_id):
                 if msg:
                     content = msg.content
-
                     if isinstance(content, str):
                         last_content = content
                     else:
                         for element in content:
-                            if isinstance(element, str):
-                                content = TextContent(text=element)
-                                message = Message(
-                                    type=MessageType.MESSAGE,
-                                    role="assistant",
-                                    content=[content],
-                                    status=RunStatus.Completed,
+                            if isinstance(element, str) and element:
+                                text_delta_content = TextContent(
+                                    delta=True,
+                                    index=index,
+                                    text=element,
+                                )
+                                text_delta_content = message.add_delta_content(
+                                    new_content=text_delta_content,
                                 )
-                                yield message
+                                index = text_delta_content.index
+                                yield text_delta_content
                             elif isinstance(element, dict):
                                 if element.get("type") == "text":
-                                    content = TextContent(
-                                        text=element.get("text"),
-                                    )
-                                    message = Message(
-                                        type=MessageType.MESSAGE,
-                                        role="assistant",
-                                        status=RunStatus.Completed,
-                                        content=[content],
+                                    text = element.get(
+                                        "text",
+                                        "",
                                     )
-                                    yield message
+                                    if text:
+                                        text_delta_content = TextContent(
+                                            delta=True,
+                                            index=index,
+                                            text=text.removeprefix(
+                                                local_truncate_memory,
+                                            ),
+                                        )
+                                        local_truncate_memory = element.get(
+                                            "text",
+                                            "",
+                                        )
+                                        text_delta_content = (
+                                            message.add_delta_content(
+                                                new_content=text_delta_content,
+                                            )
+                                        )
+                                        index = text_delta_content.index
+                                        yield text_delta_content
+                                        if hasattr(msg, "is_last"):
+                                            yield message.completed()
+                                            message = Message(
+                                                type=MessageType.MESSAGE,
+                                                role="assistant",
+                                            )
+                                            index = None
+
                                 elif element.get("type") == "tool_use":
                                     json_str = json.dumps(element.get("input"))
-                                    data = DataContent(
+                                    data_delta_content = DataContent(
+                                        index=index,
                                         data=FunctionCall(
                                             call_id=element.get("id"),
                                             name=element.get("name"),
                                             arguments=json_str,
                                         ).model_dump(),
                                     )
-                                    message = Message(
+                                    plugin_call_message = Message(
                                         type=MessageType.PLUGIN_CALL,
                                         role="assistant",
-                                        status=RunStatus.Completed,
-                                        content=[data],
+                                        content=[data_delta_content],
                                     )
-                                    yield message
+                                    yield plugin_call_message.completed()
                                 elif element.get("type") == "tool_result":
-                                    data = DataContent(
+                                    data_delta_content = DataContent(
+                                        index=index,
                                         data=FunctionCallOutput(
                                             call_id=element.get("id"),
                                             output=str(element.get("output")),
                                         ).model_dump(),
                                     )
-                                    message = Message(
+                                    plugin_output_message = Message(
                                         type=MessageType.PLUGIN_CALL_OUTPUT,
                                         role="assistant",
-                                        status=RunStatus.Completed,
-                                        content=[data],
+                                        content=[data_delta_content],
                                     )
-                                    yield message
+                                    yield plugin_output_message.completed()
                                 else:
-                                    message = Message(
-                                        type=MessageType.MESSAGE,
-                                        role="assistant",
-                                        status=RunStatus.Completed,
-                                        content=[
-                                            TextContent(text=f"{element}"),
-                                        ],
+                                    text_delta_content = TextContent(
+                                        delta=True,
+                                        index=index,
+                                        text=f"{element}",
                                     )
-                                    yield message
+                                    text_delta_content = (
+                                        message.add_delta_content(
+                                            new_content=text_delta_content,
+                                        )
+                                    )
+                                    index = text_delta_content.index
+                                    yield text_delta_content
 
                 # Break if the thread is dead and no more messages are expected
                 if not thread.is_alive() and msg_len == 0:
                     break
 
             if last_content:
-                content = TextContent(text=last_content)
-                message = Message(
-                    type=MessageType.MESSAGE,
-                    role="assistant",
-                    content=[content],
-                    status=RunStatus.Completed,
+                text_delta_content = TextContent(
+                    delta=True,
+                    index=index,
+                    text=last_content,
+                )
+                text_delta_content = message.add_delta_content(
+                    new_content=text_delta_content,
                 )
-                yield message
+                yield text_delta_content
+                yield message.completed()
 
             # Wait for the function to finish
             thread.join()

agentscope_runtime/engine/agents/agentscope_agent/hooks.py

@@ -2,19 +2,20 @@
 """ Hooks for stream output """
 # pylint: disable=unused-argument,too-many-nested-blocks
 import asyncio
+import os
 import time
 import threading
 import logging
 
 from collections import defaultdict
-from typing import Union, Optional, Generator, Any
+from typing import Union, Optional, Generator, Any, List
 
 from agentscope.agent import AgentBase
 from agentscope.message import Msg
 
 _MSG_INSTANCE = defaultdict(list)
 _LOCKS = defaultdict(threading.Lock)
-TIMEOUT = 30
+TIMEOUT = int(os.getenv("AGENTSCOPE_AGENT_TIMEOUT", "30"))
 
 
 def run_async_in_thread(coro):
@@ -83,7 +84,19 @@ def pre_speak_msg_buffer_hook(
     thread_id = threading.current_thread().name
     if thread_id.startswith("pipeline"):
         with _LOCKS[thread_id]:
-            _MSG_INSTANCE[thread_id].append(msg)
+            if kwargs.get("last", True):
+                msg.is_last = True
+                _MSG_INSTANCE[thread_id].append(msg)
+            else:
+                new_blocks = []
+                if isinstance(msg.content, List):
+                    for block in msg.content:
+                        if block.get("type", "") != "tool_use":
+                            new_blocks.append(block)
+                    msg.content = new_blocks
+                if msg.content:
+                    _MSG_INSTANCE[thread_id].append(msg)
+
     return kwargs
 
 

agentscope_runtime/engine/helpers/helper.py

@@ -93,6 +93,39 @@ async def simple_call_agent_tool(agent, query):
     return all_result
 
 
+async def simple_call_agent_tool_auto_lifecycle(agent, query):
+    all_result = ""
+    async with Runner(
+        agent=agent,
+        context_manager=create_context_manager(),
+        environment_manager=create_environment_manager(),
+    ) as runner:
+        request = AgentRequest(
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": query,
+                        },
+                    ],
+                },
+            ],
+        )
+
+        async for message in runner.stream_query(
+            request=request,
+        ):
+            if (
+                message.object == "message"
+                and MessageType.MESSAGE == message.type
+                and RunStatus.Completed == message.status
+            ):
+                all_result = message.content[0].text
+    return all_result
+
+
 async def simple_call_agent_tool_wo_env(agent, query):
     all_result = ""
     async with create_context_manager() as context_manager:

agentscope_runtime/engine/runner.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import uuid
 from typing import Optional, List, AsyncGenerator, Any
+from contextlib import AsyncExitStack
 
 from openai.types.chat import ChatCompletion
 
@@ -41,8 +42,35 @@ class Runner:
         self._environment_manager = environment_manager
         self._context_manager = context_manager
         self._deploy_managers = {}
+        self._exit_stack = AsyncExitStack()
+
+    async def __aenter__(self) -> "Runner":
+        """
+        Initializes the runner and ensures context/environment managers
+        are fully entered so that attributes like compose_session are
+        available.
+        """
+        if self._environment_manager:
+            # enter_async_context returns the "real" object
+            self._environment_manager = (
+                await self._exit_stack.enter_async_context(
+                    self._environment_manager,
+                )
+            )
+
+        if self._context_manager:
+            self._context_manager = await self._exit_stack.enter_async_context(
+                self._context_manager,
+            )
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        try:
+            await self._exit_stack.aclose()
+        except Exception:
+            pass
 
-    # TODO: should be sync method?
     async def deploy(
         self,
         deploy_manager: DeployManager = LocalDeployManager(),
@@ -139,18 +167,22 @@ class Runner:
             request_input=request_input,
         )
 
+        sequence_number = 0
         async for event in context.agent.run_async(context):
             if (
                 event.status == RunStatus.Completed
                 and event.object == "message"
             ):
                 response.add_new_message(event)
+            event.sequence_number = sequence_number
             yield event
+            sequence_number += 1
 
         await context.context_manager.append(
             session=context.session,
             event_output=response.output,
         )
+        response.sequence_number = sequence_number
         yield response.completed()
 
     @trace(TraceType.AGENT_STEP)