A programming framework for agentic AI
Add require response and remove generic types (#13)
Jack Gerrits8d1f4aedc0ac
diff --git a/examples/futures.py b/examples/futures.pyindex 70cf9ee43..c60d9d74c 100644--- a/examples/futures.py+++ b/examples/futures.py@@ -5,6 +5,7 @@ from agnext.agent_components.type_routed_agent import TypeRoutedAgent, message_hfrom agnext.application_components.single_threaded_agent_runtime import SingleThreadedAgentRuntimefrom agnext.core.agent import Agentfrom agnext.core.agent_runtime import AgentRuntime+from agnext.core.cancellation_token import CancellationToken@dataclass@@ -13,30 +14,36 @@ class MessageType:sender: str-class Inner(TypeRoutedAgent[MessageType]):- def __init__(self, name: str, router: AgentRuntime[MessageType]) -> None:+class Inner(TypeRoutedAgent):+ def __init__(self, name: str, router: AgentRuntime) -> None:super().__init__(name, router)@message_handler(MessageType)- async def on_new_message(self, message: MessageType) -> MessageType:+ async def on_new_message(+ self, message: MessageType, require_response: bool, cancellation_token: CancellationToken+ ) -> MessageType:+ assert require_responsereturn MessageType(body=f"Inner: {message.body}", sender=self.name)-class Outer(TypeRoutedAgent[MessageType]):- def __init__(self, name: str, router: AgentRuntime[MessageType], inner: Agent[MessageType]) -> None:+class Outer(TypeRoutedAgent):+ def __init__(self, name: str, router: AgentRuntime, inner: Agent) -> None:super().__init__(name, router)self._inner = inner@message_handler(MessageType)- async def on_new_message(self, message: MessageType) -> MessageType:- inner_response = self._send_message(message, self._inner)+ async def on_new_message(+ self, message: MessageType, require_response: bool, cancellation_token: CancellationToken+ ) -> MessageType:+ assert require_response+ inner_response = self._send_message(message, self._inner, require_response=True)inner_message = await inner_response+ assert isinstance(inner_message, MessageType)return MessageType(body=f"Outer: {inner_message.body}", sender=self.name)async def main() -> None:- router = SingleThreadedAgentRuntime[MessageType]()-+ router = SingleThreadedAgentRuntime()inner = Inner("inner", router)outer = Outer("outer", router, inner)response = router.send_message(MessageType(body="Hello", sender="external"), outer)diff --git a/examples/patterns.py b/examples/patterns.pyindex 7a9ef1cfd..1cb5707cc 100644--- a/examples/patterns.py+++ b/examples/patterns.py@@ -3,15 +3,15 @@ import asyncioimport openaifrom agnext.agent_components.models_clients.openai_client import OpenAI+from agnext.application_components.single_threaded_agent_runtime import SingleThreadedAgentRuntimefrom agnext.chat.agents.oai_assistant import OpenAIAssistantAgentfrom agnext.chat.messages import ChatMessagefrom agnext.chat.patterns.group_chat import GroupChatfrom agnext.chat.patterns.orchestrator import Orchestrator-from agnext.chat.runtimes import SingleThreadedRuntimeasync def group_chat() -> None:- runtime = SingleThreadedRuntime()+ runtime = SingleThreadedAgentRuntime()joe_oai_assistant = openai.beta.assistants.create(model="gpt-3.5-turbo",@@ -56,11 +56,11 @@ async def group_chat() -> None:while not response.done():await runtime.process_next()- print((await response).body)+ print((await response).body) # type: ignoreasync def orchestrator() -> None:- runtime = SingleThreadedRuntime()+ runtime = SingleThreadedAgentRuntime()developer_oai_assistant = openai.beta.assistants.create(model="gpt-3.5-turbo",@@ -111,7 +111,7 @@ async def orchestrator() -> None:while not response.done():await runtime.process_next()- print((await response).body)+ print((await response).body) # type: ignoreif __name__ == "__main__":diff --git a/src/agnext/agent_components/type_routed_agent.py b/src/agnext/agent_components/type_routed_agent.pyindex e9dc39e2a..490f3c03c 100644--- a/src/agnext/agent_components/type_routed_agent.py+++ b/src/agnext/agent_components/type_routed_agent.py@@ -1,29 +1,39 @@-from typing import Any, Awaitable, Callable, Dict, Sequence, Type, TypeVar+from typing import Any, Callable, Coroutine, Dict, NoReturn, Sequence, Type, TypeVarfrom agnext.core.agent_runtime import AgentRuntimefrom agnext.core.base_agent import BaseAgentfrom agnext.core.cancellation_token import CancellationTokenfrom agnext.core.exceptions import CantHandleException-T = TypeVar("T")+ReceivesT = TypeVar("ReceivesT")+ProducesT = TypeVar("ProducesT", covariant=True)++# TODO: Generic typevar bound binding U to agent type+# Can't do because python doesnt support it# NOTE: this works on concrete types and not inheritancedef message_handler(- target_type: Type[T],-) -> Callable[[Callable[..., Awaitable[T]]], Callable[..., Awaitable[T]]]:- def decorator(func: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]:+ target_type: Type[ReceivesT],+) -> Callable[+ [Callable[[Any, ReceivesT, bool, CancellationToken], Coroutine[Any, Any, ProducesT | None]]],+ Callable[[Any, ReceivesT, bool, CancellationToken], Coroutine[Any, Any, ProducesT | None]],+]:+ def decorator(+ func: Callable[[Any, ReceivesT, bool, CancellationToken], Coroutine[Any, Any, ProducesT | None]],+ ) -> Callable[[Any, ReceivesT, bool, CancellationToken], Coroutine[Any, Any, ProducesT | None]]:func._target_type = target_type # type: ignorereturn funcreturn decorator-class TypeRoutedAgent(BaseAgent[T]):- def __init__(self, name: str, router: AgentRuntime[T]) -> None:+class TypeRoutedAgent(BaseAgent):+ def __init__(self, name: str, router: AgentRuntime) -> None:super().__init__(name, router)- self._handlers: Dict[Type[Any], Callable[[T, CancellationToken], Awaitable[T]]] = {}+ # Self is already bound to the handlers+ self._handlers: Dict[Type[Any], Callable[[Any, bool, CancellationToken], Coroutine[Any, Any, Any | None]]] = {}router.add_agent(self)@@ -31,19 +41,23 @@ class TypeRoutedAgent(BaseAgent[T]):if callable(getattr(self, attr, None)):handler = getattr(self, attr)if hasattr(handler, "_target_type"):- # TODO do i need to partially apply self?self._handlers[handler._target_type] = handler@property- def subscriptions(self) -> Sequence[Type[T]]:+ def subscriptions(self) -> Sequence[Type[Any]]:return list(self._handlers.keys())- async def on_message(self, message: T, cancellation_token: CancellationToken) -> T:- handler = self._handlers.get(type(message))+ async def on_message(+ self, message: Any, require_response: bool, cancellation_token: CancellationToken+ ) -> Any | None:+ key_type: Type[Any] = type(message) # type: ignore+ handler = self._handlers.get(key_type) # type: ignoreif handler is not None:- return await handler(message, cancellation_token)+ return await handler(message, require_response, cancellation_token)else:- return await self.on_unhandled_message(message, cancellation_token)+ return await self.on_unhandled_message(message, require_response, cancellation_token)- async def on_unhandled_message(self, message: T, cancellation_token: CancellationToken) -> T:+ async def on_unhandled_message(+ self, message: Any, require_response: bool, cancellation_token: CancellationToken+ ) -> NoReturn:raise CantHandleException()diff --git a/src/agnext/application_components/single_threaded_agent_runtime.py b/src/agnext/application_components/single_threaded_agent_runtime.pyindex 749f431f3..b21a382b8 100644--- a/src/agnext/application_components/single_threaded_agent_runtime.py+++ b/src/agnext/application_components/single_threaded_agent_runtime.py@@ -1,7 +1,7 @@import asynciofrom asyncio import Futurefrom dataclasses import dataclass-from typing import Awaitable, Dict, Generic, List, Set, Type, TypeVar, cast+from typing import Any, Awaitable, Dict, List, Sequence, Set, castfrom agnext.core.cancellation_token import CancellationTokenfrom agnext.core.exceptions import MessageDroppedException@@ -10,64 +10,61 @@ from agnext.core.intervention import DropMessage, InterventionHandlerfrom ..core.agent import Agentfrom ..core.agent_runtime import AgentRuntime-T = TypeVar("T")-@dataclass(kw_only=True)-class BroadcastMessageEnvelope(Generic[T]):+class BroadcastMessageEnvelope:"""A message envelope for broadcasting messages to all agents that can handlethe message of the type T."""- message: T- future: Future[List[T]]+ message: Any+ future: Future[Sequence[Any] | None]cancellation_token: CancellationToken- sender: Agent[T] | None+ sender: Agent | None+ require_response: bool@dataclass(kw_only=True)-class SendMessageEnvelope(Generic[T]):+class SendMessageEnvelope:"""A message envelope for sending a message to a specific agent that can handlethe message of the type T."""- message: T- sender: Agent[T] | None- recipient: Agent[T]- future: Future[T]+ message: Any+ sender: Agent | None+ recipient: Agent+ future: Future[Any | None]cancellation_token: CancellationToken+ require_response: bool@dataclass(kw_only=True)-class ResponseMessageEnvelope(Generic[T]):+class ResponseMessageEnvelope:"""A message envelope for sending a response to a message."""- message: T- future: Future[T]- sender: Agent[T]- recipient: Agent[T] | None+ message: Any+ future: Future[Any]+ sender: Agent+ recipient: Agent | None@dataclass(kw_only=True)-class BroadcastResponseMessageEnvelope(Generic[T]):+class BroadcastResponseMessageEnvelope:"""A message envelope for sending a response to a message."""- message: List[T]- future: Future[List[T]]- recipient: Agent[T] | None+ message: Sequence[Any]+ future: Future[Sequence[Any]]+ recipient: Agent | None-class SingleThreadedAgentRuntime(AgentRuntime[T]):- def __init__(self, *, before_send: InterventionHandler[T] | None = None) -> None:+class SingleThreadedAgentRuntime(AgentRuntime):+ def __init__(self, *, before_send: InterventionHandler | None = None) -> None:self._message_queue: List[- BroadcastMessageEnvelope[T]- | SendMessageEnvelope[T]- | ResponseMessageEnvelope[T]- | BroadcastResponseMessageEnvelope[T]+ BroadcastMessageEnvelope | SendMessageEnvelope | ResponseMessageEnvelope | BroadcastResponseMessageEnvelope] = []- self._per_type_subscribers: Dict[Type[T], List[Agent[T]]] = {}- self._agents: Set[Agent[T]] = set()+ self._per_type_subscribers: Dict[type, List[Agent]] = {}+ self._agents: Set[Agent] = set()self._before_send = before_send- def add_agent(self, agent: Agent[T]) -> None:+ def add_agent(self, agent: Agent) -> None:for message_type in agent.subscriptions:if message_type not in self._per_type_subscribers:self._per_type_subscribers[message_type] = []@@ -77,17 +74,19 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):# Returns the response of the messagedef send_message(self,- message: T,- recipient: Agent[T],+ message: Any,+ recipient: Agent,*,- sender: Agent[T] | None = None,+ require_response: bool = True,+ sender: Agent | None = None,cancellation_token: CancellationToken | None = None,- ) -> Future[T]:+ ) -> Future[Any | None]:if cancellation_token is None:cancellation_token = CancellationToken()- loop = asyncio.get_event_loop()- future: Future[T] = loop.create_future()+ future = asyncio.get_event_loop().create_future()+ if recipient not in self._agents:+ future.set_exception(Exception("Recipient not found"))self._message_queue.append(SendMessageEnvelope(@@ -96,53 +95,78 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):future=future,cancellation_token=cancellation_token,sender=sender,+ require_response=require_response,))return future- # Returns the response of all handling agents+ # send message, require_response=False -> returns after delivery, gives None+ # send message, require_response=True -> returns after handling, gives Responsedef broadcast_message(- self, message: T, *, sender: Agent[T] | None = None, cancellation_token: CancellationToken | None = None- ) -> Future[List[T]]:+ self,+ message: Any,+ *,+ require_response: bool = True,+ sender: Agent | None = None,+ cancellation_token: CancellationToken | None = None,+ ) -> Future[Sequence[Any] | None]:if cancellation_token is None:cancellation_token = CancellationToken()- future: Future[List[T]] = asyncio.get_event_loop().create_future()+ future = asyncio.get_event_loop().create_future()self._message_queue.append(BroadcastMessageEnvelope(- message=message, future=future, cancellation_token=cancellation_token, sender=sender+ message=message,+ future=future,+ cancellation_token=cancellation_token,+ sender=sender,+ require_response=require_response,))+return future- async def _process_send(self, message_envelope: SendMessageEnvelope[T]) -> None:+ async def _process_send(self, message_envelope: SendMessageEnvelope) -> None:recipient = message_envelope.recipient- if recipient not in self._agents:- message_envelope.future.set_exception(Exception("Recipient not found"))- return+ assert recipient in self._agentstry:response = await recipient.on_message(- message_envelope.message, cancellation_token=message_envelope.cancellation_token+ message_envelope.message,+ require_response=message_envelope.require_response,+ cancellation_token=message_envelope.cancellation_token,)except BaseException as e:message_envelope.future.set_exception(e)return- self._message_queue.append(- ResponseMessageEnvelope(- message=response,- future=message_envelope.future,- sender=message_envelope.recipient,- recipient=message_envelope.sender,- )- )+ if not message_envelope.require_response and response is not None:+ raise Exception("Recipient returned a response for a message that did not request a response")- async def _process_broadcast(self, message_envelope: BroadcastMessageEnvelope[T]) -> None:- responses: List[Awaitable[T]] = []- for agent in self._per_type_subscribers.get(type(message_envelope.message), []):- future = agent.on_message(message_envelope.message, cancellation_token=message_envelope.cancellation_token)+ if message_envelope.require_response and response is None:+ raise Exception("Recipient did not return a response for a message that requested a response")++ if message_envelope.require_response:+ self._message_queue.append(+ ResponseMessageEnvelope(+ message=response,+ future=message_envelope.future,+ sender=message_envelope.recipient,+ recipient=message_envelope.sender,+ )+ )+ else:+ message_envelope.future.set_result(None)++ async def _process_broadcast(self, message_envelope: BroadcastMessageEnvelope) -> None:+ responses: List[Awaitable[Any]] = []+ for agent in self._per_type_subscribers.get(type(message_envelope.message), []): # type: ignore+ future = agent.on_message(+ message_envelope.message,+ require_response=message_envelope.require_response,+ cancellation_token=message_envelope.cancellation_token,+ )responses.append(future)try:@@ -151,16 +175,21 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):message_envelope.future.set_exception(e)return- self._message_queue.append(- BroadcastResponseMessageEnvelope(- message=all_responses, future=message_envelope.future, recipient=message_envelope.sender+ if message_envelope.require_response:+ self._message_queue.append(+ BroadcastResponseMessageEnvelope(+ message=all_responses,+ future=cast(Future[Sequence[Any]], message_envelope.future),+ recipient=message_envelope.sender,+ ))- )+ else:+ message_envelope.future.set_result(None)- async def _process_response(self, message_envelope: ResponseMessageEnvelope[T]) -> None:+ async def _process_response(self, message_envelope: ResponseMessageEnvelope) -> None:message_envelope.future.set_result(message_envelope.message)- async def _process_broadcast_response(self, message_envelope: BroadcastResponseMessageEnvelope[T]) -> None:+ async def _process_broadcast_response(self, message_envelope: BroadcastResponseMessageEnvelope) -> None:message_envelope.future.set_result(message_envelope.message)async def process_next(self) -> None:@@ -179,7 +208,7 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):future.set_exception(MessageDroppedException())return- message_envelope.message = cast(T, temp_message)+ message_envelope.message = temp_messageasyncio.create_task(self._process_send(message_envelope))case BroadcastMessageEnvelope(@@ -193,7 +222,7 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):future.set_exception(MessageDroppedException())return- message_envelope.message = cast(T, temp_message)+ message_envelope.message = temp_messageasyncio.create_task(self._process_broadcast(message_envelope))case ResponseMessageEnvelope(message=message, sender=sender, recipient=recipient, future=future):@@ -203,7 +232,7 @@ class SingleThreadedAgentRuntime(AgentRuntime[T]):future.set_exception(MessageDroppedException())return- message_envelope.message = cast(T, temp_message)+ message_envelope.message = temp_messageasyncio.create_task(self._process_response(message_envelope))diff --git a/src/agnext/chat/agents/base.py b/src/agnext/chat/agents/base.pyindex 34a6ccd36..3cece5005 100644--- a/src/agnext/chat/agents/base.py+++ b/src/agnext/chat/agents/base.py@@ -1,13 +1,12 @@-from ...agent_components.type_routed_agent import TypeRoutedAgent, message_handler-from ...core.cancellation_token import CancellationToken-from ..messages import ChatMessage-from ..runtimes import SingleThreadedRuntime+from agnext.core.agent_runtime import AgentRuntime+from ...agent_components.type_routed_agent import TypeRoutedAgent-class BaseChatAgent(TypeRoutedAgent[ChatMessage]):++class BaseChatAgent(TypeRoutedAgent):"""The BaseAgent class for the chat API."""- def __init__(self, name: str, description: str, runtime: SingleThreadedRuntime) -> None:+ def __init__(self, name: str, description: str, runtime: AgentRuntime) -> None:super().__init__(name, runtime)self._description = description@@ -15,15 +14,3 @@ class BaseChatAgent(TypeRoutedAgent[ChatMessage]):def description(self) -> str:"""The description of the agent."""return self._description-- async def on_chat_message(self, message: ChatMessage) -> ChatMessage:- """The method to handle chat messages."""- raise NotImplementedError-- # TODO: how should we expose cancellation in chat layer?- @message_handler(ChatMessage)- async def on_chat_message_with_cancellation(- self, message: ChatMessage, cancellation_token: CancellationToken- ) -> ChatMessage:- """The method to handle chat messages with cancellation."""- return await self.on_chat_message(message)diff --git a/src/agnext/chat/agents/oai_assistant.py b/src/agnext/chat/agents/oai_assistant.pyindex 891eab25a..11ef741f9 100644--- a/src/agnext/chat/agents/oai_assistant.py+++ b/src/agnext/chat/agents/oai_assistant.py@@ -1,8 +1,11 @@import openai-from ..agents.base import BaseChatAgent+from agnext.agent_components.type_routed_agent import message_handler+from agnext.chat.agents.base import BaseChatAgent+from agnext.core.agent_runtime import AgentRuntime+from agnext.core.cancellation_token import CancellationToken+from ..messages import ChatMessage-from ..runtimes import SingleThreadedRuntimeclass OpenAIAssistantAgent(BaseChatAgent):@@ -10,7 +13,7 @@ class OpenAIAssistantAgent(BaseChatAgent):self,name: str,description: str,- runtime: SingleThreadedRuntime,+ runtime: AgentRuntime,client: openai.AsyncClient,assistant_id: str,thread_id: str,@@ -21,7 +24,11 @@ class OpenAIAssistantAgent(BaseChatAgent):self._thread_id = thread_idself._current_session_window_length = 0- async def on_chat_message(self, message: ChatMessage) -> ChatMessage:+ # TODO: use require_response+ @message_handler(ChatMessage)+ async def on_chat_message_with_cancellation(+ self, message: ChatMessage, require_response: bool, cancellation_token: CancellationToken+ ) -> ChatMessage | None:print("---------------")print(f"{self.name} received message from {message.sender}: {message.body}")print("---------------")diff --git a/src/agnext/chat/agents/random_agent.py b/src/agnext/chat/agents/random_agent.pyindex 67029318a..0581ac437 100644--- a/src/agnext/chat/agents/random_agent.py+++ b/src/agnext/chat/agents/random_agent.py@@ -1,11 +1,18 @@import random+from agnext.agent_components.type_routed_agent import message_handler+from agnext.core.cancellation_token import CancellationToken+from ..agents.base import BaseChatAgentfrom ..messages import ChatMessageclass RandomResponseAgent(BaseChatAgent):- async def on_chat_message(self, message: ChatMessage) -> ChatMessage:+ # TODO: use require_response+ @message_handler(ChatMessage)+ async def on_chat_message_with_cancellation(+ self, message: ChatMessage, require_response: bool, cancellation_token: CancellationToken+ ) -> ChatMessage | None:print(f"{self.name} received message from {message.sender}: {message.body}")if message.save_message_only:return ChatMessage(body="OK", sender=self.name)diff --git a/src/agnext/chat/patterns/group_chat.py b/src/agnext/chat/patterns/group_chat.pyindex 2a6c90d90..f837b6f27 100644--- a/src/agnext/chat/patterns/group_chat.py+++ b/src/agnext/chat/patterns/group_chat.py@@ -1,8 +1,8 @@from typing import List, Sequence+from ...core.agent_runtime import AgentRuntimefrom ..agents.base import BaseChatAgentfrom ..messages import ChatMessage-from ..runtimes import SingleThreadedRuntimeclass GroupChat(BaseChatAgent):@@ -10,7 +10,7 @@ class GroupChat(BaseChatAgent):self,name: str,description: str,- runtime: SingleThreadedRuntime,+ runtime: AgentRuntime,agents: Sequence[BaseChatAgent],num_rounds: int,) -> None:@@ -61,8 +61,9 @@ class GroupChat(BaseChatAgent):speaker,)- # 4. Append the response to the history.- self._history.append(response)+ if response is not None:+ # 4. Append the response to the history.+ self._history.append(response)# 5. Update the previous speaker.previous_speaker = speakerdiff --git a/src/agnext/chat/patterns/orchestrator.py b/src/agnext/chat/patterns/orchestrator.pyindex 30f914a56..0c5e4915d 100644--- a/src/agnext/chat/patterns/orchestrator.py+++ b/src/agnext/chat/patterns/orchestrator.py@@ -1,11 +1,14 @@import jsonfrom typing import Any, List, Sequence, Tuple+from agnext.core.agent_runtime import AgentRuntime+from agnext.core.cancellation_token import CancellationToken+from ...agent_components.model_client import ModelClient+from ...agent_components.type_routed_agent import message_handlerfrom ...agent_components.types import AssistantMessage, LLMMessage, UserMessagefrom ..agents.base import BaseChatAgentfrom ..messages import ChatMessage-from ..runtimes import SingleThreadedRuntimeclass Orchestrator(BaseChatAgent):@@ -13,7 +16,7 @@ class Orchestrator(BaseChatAgent):self,name: str,description: str,- runtime: SingleThreadedRuntime,+ runtime: AgentRuntime,agents: Sequence[BaseChatAgent],model_client: ModelClient,max_turns: int = 30,@@ -28,7 +31,10 @@ class Orchestrator(BaseChatAgent):self._max_retry_attempts_before_educated_guess = max_retry_attemptsself._history: List[ChatMessage] = []- async def on_chat_message(self, message: ChatMessage) -> ChatMessage:+ @message_handler(ChatMessage)+ async def on_chat_message(+ self, message: ChatMessage, require_response: bool, cancellation_token: CancellationToken+ ) -> ChatMessage:# A task is received.task = message.body@@ -169,6 +175,8 @@ Some additional points to consider:speaker,)+ assert speaker_response is not None+# Update the ledger.ledger.append(AssistantMessage(diff --git a/src/agnext/chat/runtimes.py b/src/agnext/chat/runtimes.pydeleted file mode 100644index 1284ee232..000000000--- a/src/agnext/chat/runtimes.py+++ /dev/null@@ -1,12 +0,0 @@-from ..application_components.single_threaded_agent_runtime import (- SingleThreadedAgentRuntime,-)-from .messages import ChatMessage---# The built-in runtime for the chat API.-class SingleThreadedRuntime(SingleThreadedAgentRuntime[ChatMessage]):- pass---# Each new built-in runtime should be able to handle ChatMessage type.diff --git a/src/agnext/core/agent.py b/src/agnext/core/agent.pyindex d6078be68..038ffd2a3 100644--- a/src/agnext/core/agent.py+++ b/src/agnext/core/agent.py@@ -1,15 +1,16 @@-from typing import Protocol, Sequence, Type, TypeVar+from typing import Any, Protocol, Sequence, runtime_checkablefrom agnext.core.cancellation_token import CancellationToken-T = TypeVar("T")--class Agent(Protocol[T]):+@runtime_checkable+class Agent(Protocol):@propertydef name(self) -> str: ...@property- def subscriptions(self) -> Sequence[Type[T]]: ...+ def subscriptions(self) -> Sequence[type]: ...- async def on_message(self, message: T, cancellation_token: CancellationToken) -> T: ...+ async def on_message(+ self, message: Any, require_response: bool, cancellation_token: CancellationToken+ ) -> Any | None: ...diff --git a/src/agnext/core/agent_runtime.py b/src/agnext/core/agent_runtime.pyindex aae215246..67f558c6f 100644--- a/src/agnext/core/agent_runtime.py+++ b/src/agnext/core/agent_runtime.py@@ -1,28 +1,32 @@from asyncio import Future-from typing import List, Protocol, TypeVar+from typing import Any, Protocol, Sequencefrom agnext.core.agent import Agentfrom agnext.core.cancellation_token import CancellationToken-T = TypeVar("T")-# Undeliverable - error-class AgentRuntime(Protocol[T]):- def add_agent(self, agent: Agent[T]) -> None: ...+class AgentRuntime(Protocol):+ def add_agent(self, agent: Agent) -> None: ...# Returns the response of the messagedef send_message(self,- message: T,- recipient: Agent[T],+ message: Any,+ recipient: Agent,*,- sender: Agent[T] | None = None,- cancellation_token: CancellationToken | None,- ) -> Future[T]: ...+ require_response: bool = True,+ sender: Agent | None = None,+ cancellation_token: CancellationToken | None = None,+ ) -> Future[Any | None]: ...# Returns the response of all handling agentsdef broadcast_message(- self, message: T, *, sender: Agent[T] | None = None, cancellation_token: CancellationToken | None = None- ) -> Future[List[T]]: ...+ self,+ message: Any,+ *,+ require_response: bool = True,+ sender: Agent | None = None,+ cancellation_token: CancellationToken | None = None,+ ) -> Future[Sequence[Any] | None]: ...diff --git a/src/agnext/core/base_agent.py b/src/agnext/core/base_agent.pyindex ee90258e5..9560328ac 100644--- a/src/agnext/core/base_agent.py+++ b/src/agnext/core/base_agent.py@@ -1,17 +1,21 @@from abc import ABC, abstractmethodfrom asyncio import Future-from typing import List, Sequence, Type, TypeVar+from typing import Any, Sequence, TypeVarfrom agnext.core.agent_runtime import AgentRuntimefrom agnext.core.cancellation_token import CancellationTokenfrom .agent import Agent-T = TypeVar("T")+ConsumesT = TypeVar("ConsumesT")+ProducesT = TypeVar("ProducesT", covariant=True)+OtherConsumesT = TypeVar("OtherConsumesT")+OtherProducesT = TypeVar("OtherProducesT")-class BaseAgent(ABC, Agent[T]):- def __init__(self, name: str, router: AgentRuntime[T]) -> None:++class BaseAgent(ABC, Agent):+ def __init__(self, name: str, router: AgentRuntime) -> None:self._name = nameself._router = router@@ -21,26 +25,47 @@ class BaseAgent(ABC, Agent[T]):@property@abstractmethod- def subscriptions(self) -> Sequence[Type[T]]:+ def subscriptions(self) -> Sequence[type]:return []@abstractmethod- async def on_message(self, message: T, cancellation_token: CancellationToken) -> T: ...+ async def on_message(+ self, message: Any, require_response: bool, cancellation_token: CancellationToken+ ) -> Any | None: ...+ # Returns the response of the messagedef _send_message(- self, message: T, recipient: Agent[T], cancellation_token: CancellationToken | None = None- ) -> Future[T]:+ self,+ message: Any,+ recipient: Agent,+ *,+ require_response: bool = True,+ cancellation_token: CancellationToken | None = None,+ ) -> Future[Any | None]:if cancellation_token is None:cancellation_token = CancellationToken()+future = self._router.send_message(- message, sender=self, recipient=recipient, cancellation_token=cancellation_token+ message,+ sender=self,+ recipient=recipient,+ require_response=require_response,+ cancellation_token=cancellation_token,)cancellation_token.link_future(future)return future- def _broadcast_message(self, message: T, cancellation_token: CancellationToken | None = None) -> Future[List[T]]:+ # Returns the response of all handling agents+ def _broadcast_message(+ self,+ message: Any,+ *,+ require_response: bool = True,+ cancellation_token: CancellationToken | None = None,+ ) -> Future[Sequence[Any] | None]:if cancellation_token is None:cancellation_token = CancellationToken()- future = self._router.broadcast_message(message, sender=self, cancellation_token=cancellation_token)- cancellation_token.link_future(future)+ future = self._router.broadcast_message(+ message, sender=self, require_response=require_response, cancellation_token=cancellation_token+ )return futurediff --git a/src/agnext/core/intervention.py b/src/agnext/core/intervention.pyindex a8e5833eb..5a002c331 100644--- a/src/agnext/core/intervention.py+++ b/src/agnext/core/intervention.py@@ -1,4 +1,4 @@-from typing import Awaitable, Callable, Protocol, Sequence, TypeVar, final+from typing import Any, Awaitable, Callable, Protocol, Sequence, finalfrom agnext.core.agent import Agent@@ -7,33 +7,29 @@ from agnext.core.agent import Agentclass DropMessage: ...-T = TypeVar("T")+InterventionFunction = Callable[[Any], Any | Awaitable[type[DropMessage]]]-InterventionFunction = Callable[[T], T | Awaitable[type[DropMessage]]]--class InterventionHandler(Protocol[T]):- async def on_send(self, message: T, *, sender: Agent[T] | None, recipient: Agent[T]) -> T | type[DropMessage]: ...- async def on_broadcast(self, message: T, *, sender: Agent[T] | None) -> T | type[DropMessage]: ...- async def on_response(- self, message: T, *, sender: Agent[T], recipient: Agent[T] | None- ) -> T | type[DropMessage]: ...+class InterventionHandler(Protocol):+ async def on_send(self, message: Any, *, sender: Agent | None, recipient: Agent) -> Any | type[DropMessage]: ...+ async def on_broadcast(self, message: Any, *, sender: Agent | None) -> Any | type[DropMessage]: ...+ async def on_response(self, message: Any, *, sender: Agent, recipient: Agent | None) -> Any | type[DropMessage]: ...async def on_broadcast_response(- self, message: Sequence[T], *, recipient: Agent[T] | None- ) -> Sequence[T] | type[DropMessage]: ...+ self, message: Sequence[Any], *, recipient: Agent | None+ ) -> Sequence[Any] | type[DropMessage]: ...-class DefaultInterventionHandler(InterventionHandler[T]):- async def on_send(self, message: T, *, sender: Agent[T] | None, recipient: Agent[T]) -> T | type[DropMessage]:+class DefaultInterventionHandler(InterventionHandler):+ async def on_send(self, message: Any, *, sender: Agent | None, recipient: Agent) -> Any | type[DropMessage]:return message- async def on_broadcast(self, message: T, *, sender: Agent[T] | None) -> T | type[DropMessage]:+ async def on_broadcast(self, message: Any, *, sender: Agent | None) -> Any | type[DropMessage]:return message- async def on_response(self, message: T, *, sender: Agent[T], recipient: Agent[T] | None) -> T | type[DropMessage]:+ async def on_response(self, message: Any, *, sender: Agent, recipient: Agent | None) -> Any | type[DropMessage]:return messageasync def on_broadcast_response(- self, message: Sequence[T], *, recipient: Agent[T] | None- ) -> Sequence[T] | type[DropMessage]:+ self, message: Sequence[Any], *, recipient: Agent | None+ ) -> Sequence[Any] | type[DropMessage]:return messagediff --git a/tests/test_cancellation.py b/tests/test_cancellation.pyindex 253806043..de256ce40 100644--- a/tests/test_cancellation.py+++ b/tests/test_cancellation.py@@ -16,14 +16,14 @@ class MessageType:# To do cancellation, only the token should be interacted with as a user# If you cancel a future, it may not work as you expect.-class LongRunningAgent(TypeRoutedAgent[MessageType]):- def __init__(self, name: str, router: AgentRuntime[MessageType]) -> None:+class LongRunningAgent(TypeRoutedAgent):+ def __init__(self, name: str, router: AgentRuntime) -> None:super().__init__(name, router)self.called = Falseself.cancelled = False@message_handler(MessageType)- async def on_new_message(self, message: MessageType, cancellation_token: CancellationToken) -> MessageType:+ async def on_new_message(self, message: MessageType, require_response: bool, cancellation_token: CancellationToken) -> MessageType:self.called = Truesleep = asyncio.ensure_future(asyncio.sleep(100))cancellation_token.link_future(sleep)@@ -34,19 +34,22 @@ class LongRunningAgent(TypeRoutedAgent[MessageType]):self.cancelled = Trueraise-class NestingLongRunningAgent(TypeRoutedAgent[MessageType]):- def __init__(self, name: str, router: AgentRuntime[MessageType], nested_agent: Agent[MessageType]) -> None:+class NestingLongRunningAgent(TypeRoutedAgent):+ def __init__(self, name: str, router: AgentRuntime, nested_agent: Agent) -> None:super().__init__(name, router)self.called = Falseself.cancelled = Falseself._nested_agent = nested_agent@message_handler(MessageType)- async def on_new_message(self, message: MessageType, cancellation_token: CancellationToken) -> MessageType:+ async def on_new_message(self, message: MessageType, require_response: bool, cancellation_token: CancellationToken) -> MessageType:+ assert require_response == Trueself.called = True- response = self._send_message(message, self._nested_agent, cancellation_token)+ response = self._send_message(message, self._nested_agent, require_response=require_response, cancellation_token=cancellation_token)try:- return await response+ val = await response+ assert isinstance(val, MessageType)+ return valexcept asyncio.CancelledError:self.cancelled = Trueraise@@ -54,7 +57,7 @@ class NestingLongRunningAgent(TypeRoutedAgent[MessageType]):@pytest.mark.asyncioasync def test_cancellation_with_token() -> None:- router = SingleThreadedAgentRuntime[MessageType]()+ router = SingleThreadedAgentRuntime()long_running = LongRunningAgent("name", router)token = CancellationToken()@@ -75,7 +78,7 @@ async def test_cancellation_with_token() -> None:@pytest.mark.asyncioasync def test_nested_cancellation_only_outer_called() -> None:- router = SingleThreadedAgentRuntime[MessageType]()+ router = SingleThreadedAgentRuntime()long_running = LongRunningAgent("name", router)nested = NestingLongRunningAgent("nested", router, long_running)@@ -98,7 +101,7 @@ async def test_nested_cancellation_only_outer_called() -> None:@pytest.mark.asyncioasync def test_nested_cancellation_inner_called() -> None:- router = SingleThreadedAgentRuntime[MessageType]()+ router = SingleThreadedAgentRuntime()long_running = LongRunningAgent("name", router)nested = NestingLongRunningAgent("nested", router, long_running)diff --git a/tests/test_intervention.py b/tests/test_intervention.pyindex 79a5c5b03..7750eedf7 100644--- a/tests/test_intervention.py+++ b/tests/test_intervention.py@@ -13,30 +13,30 @@ from agnext.core.intervention import DefaultInterventionHandler, DropMessageclass MessageType:...-class LoopbackAgent(TypeRoutedAgent[MessageType]):- def __init__(self, name: str, router: AgentRuntime[MessageType]) -> None:+class LoopbackAgent(TypeRoutedAgent):+ def __init__(self, name: str, router: AgentRuntime) -> None:super().__init__(name, router)self.num_calls = 0@message_handler(MessageType)- async def on_new_message(self, message: MessageType, cancellation_token: CancellationToken) -> MessageType:+ async def on_new_message(self, message: MessageType, require_response: bool, cancellation_token: CancellationToken) -> MessageType:self.num_calls += 1return message@pytest.mark.asyncioasync def test_intervention_count_messages() -> None:- class DebugInterventionHandler(DefaultInterventionHandler[MessageType]):+ class DebugInterventionHandler(DefaultInterventionHandler):def __init__(self):self.num_messages = 0- async def on_send(self, message: MessageType, *, sender: Agent[MessageType] | None, recipient: Agent[MessageType]) -> MessageType:+ async def on_send(self, message: MessageType, *, sender: Agent | None, recipient: Agent) -> MessageType:self.num_messages += 1return messagehandler = DebugInterventionHandler()- router = SingleThreadedAgentRuntime[MessageType](before_send=handler)+ router = SingleThreadedAgentRuntime(before_send=handler)long_running = LoopbackAgent("name", router)response = router.send_message(MessageType(), recipient=long_running)@@ -50,12 +50,12 @@ async def test_intervention_count_messages() -> None:@pytest.mark.asyncioasync def test_intervention_drop_send() -> None:- class DropSendInterventionHandler(DefaultInterventionHandler[MessageType]):- async def on_send(self, message: MessageType, *, sender: Agent[MessageType] | None, recipient: Agent[MessageType]) -> MessageType | type[DropMessage]:+ class DropSendInterventionHandler(DefaultInterventionHandler):+ async def on_send(self, message: MessageType, *, sender: Agent | None, recipient: Agent) -> MessageType | type[DropMessage]:return DropMessagehandler = DropSendInterventionHandler()- router = SingleThreadedAgentRuntime[MessageType](before_send=handler)+ router = SingleThreadedAgentRuntime(before_send=handler)long_running = LoopbackAgent("name", router)response = router.send_message(MessageType(), recipient=long_running)@@ -72,12 +72,12 @@ async def test_intervention_drop_send() -> None:@pytest.mark.asyncioasync def test_intervention_drop_response() -> None:- class DropResponseInterventionHandler(DefaultInterventionHandler[MessageType]):- async def on_response(self, message: MessageType, *, sender: Agent[MessageType], recipient: Agent[MessageType] | None) -> MessageType | type[DropMessage]:+ class DropResponseInterventionHandler(DefaultInterventionHandler):+ async def on_response(self, message: MessageType, *, sender: Agent, recipient: Agent | None) -> MessageType | type[DropMessage]:return DropMessagehandler = DropResponseInterventionHandler()- router = SingleThreadedAgentRuntime[MessageType](before_send=handler)+ router = SingleThreadedAgentRuntime(before_send=handler)long_running = LoopbackAgent("name", router)response = router.send_message(MessageType(), recipient=long_running)