add illustrator-critics demo; handle multi-modal messages in agents; refactored examples to use Textual app; equality comparison for AgentId (#87)

* add illustrator-critics demo; handle multi-modal messages in agents

* fix

* Refactored examples to use Textual app. Add equality comparison for AgentId

Author: ekzhu

examples/chat_room.py

@@ -1,11 +1,11 @@
-"""This is an example of a chat room with AI agents. It demonstrates how to use the
-`TypeRoutedAgent` class to create custom agents that can use custom message types,
-and interact with other using event-based messaging without an orchestrator."""
-
 import argparse
 import asyncio
 import json
-from dataclasses import dataclass
+import logging
+import os
+import sys
+
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
 
 from agnext.application import SingleThreadedAgentRuntime
 from agnext.chat.memory import BufferedChatMemory, ChatMemory
@@ -14,18 +14,7 @@
 from agnext.components import TypeRoutedAgent, message_handler
 from agnext.components.models import ChatCompletionClient, OpenAI, SystemMessage
 from agnext.core import AgentRuntime, CancellationToken
-from colorama import Fore, Style, init
-
-
-# Define a custom message type for chat room messages.
-@dataclass
-class ChatRoomMessage(TextMessage):  # type: ignore
-    pass
-
-
-sep = "-" * 50
-
-init(autoreset=True)
+from utils import TextualChatApp, TextualUserAgent, start_runtime
 
 
 # Define a custom agent that can handle chat room messages.
@@ -38,7 +27,6 @@ def __init__(  # type: ignore
         background_story: str,
         memory: ChatMemory,  # type: ignore
         model_client: ChatCompletionClient,  # type: ignore
-        color: str = Style.RESET_ALL,
     ) -> None:  # type: ignore
         super().__init__(name, description, runtime)
         system_prompt = f"""Your name is {name}.
@@ -58,10 +46,9 @@ def __init__(  # type: ignore
         self._system_messages = [SystemMessage(system_prompt)]
         self._memory = memory
         self._client = model_client
-        self._color = color
 
     @message_handler()  # type: ignore
-    async def on_chat_room_message(self, message: ChatRoomMessage, cancellation_token: CancellationToken) -> None:  # type: ignore
+    async def on_chat_room_message(self, message: TextMessage, cancellation_token: CancellationToken) -> None:  # type: ignore
         # Save the message to memory as structured JSON.
         from_message = TextMessage(
             content=json.dumps({"sender": message.source, "content": message.content}), source=message.source
@@ -77,7 +64,7 @@ async def on_chat_room_message(self, message: ChatRoomMessage, cancellation_toke
         assert isinstance(raw_response.content, str)
 
         # Save the response to memory.
-        await self._memory.add_message(ChatRoomMessage(source=self.metadata["name"], content=raw_response.content))
+        await self._memory.add_message(TextMessage(source=self.metadata["name"], content=raw_response.content))
 
         # Parse the response.
         data = json.loads(raw_response.content)
@@ -86,76 +73,75 @@ async def on_chat_room_message(self, message: ChatRoomMessage, cancellation_toke
 
         # Publish the response if needed.
         if respond is True or str(respond).lower().strip() == "true":
-            await self._publish_message(ChatRoomMessage(source=self.metadata["name"], content=str(response)))
-            print(f"{sep}\n{self._color}{self.metadata['name']}:{Style.RESET_ALL}\n{response}")
+            await self._publish_message(TextMessage(source=self.metadata["name"], content=str(response)))
+
+
+class ChatRoomUserAgent(TextualUserAgent):  # type: ignore
+    """An agent that is used to receive messages from the runtime."""
+
+    @message_handler  # type: ignore
+    async def on_chat_room_message(self, message: TextMessage, cancellation_token: CancellationToken) -> None:  # type: ignore
+        await self._app.post_runtime_message(message)
 
 
 # Define a chat room with participants -- the runtime is the chat room.
-def chat_room(runtime: AgentRuntime) -> None:  # type: ignore
-    _ = ChatRoomAgent(
+def chat_room(runtime: AgentRuntime, app: TextualChatApp) -> None:  # type: ignore
+    _ = ChatRoomUserAgent(
+        name="User",
+        description="The user in the chat room.",
+        runtime=runtime,
+        app=app,
+    )
+    alice = ChatRoomAgent(
         name="Alice",
         description="Alice in the chat room.",
         runtime=runtime,
         background_story="Alice is a software engineer who loves to code.",
         memory=BufferedChatMemory(buffer_size=10),
         model_client=OpenAI(model="gpt-4-turbo"),  # type: ignore
-        color=Fore.CYAN,
     )
-    _ = ChatRoomAgent(
+    bob = ChatRoomAgent(
         name="Bob",
         description="Bob in the chat room.",
         runtime=runtime,
         background_story="Bob is a data scientist who loves to analyze data.",
         memory=BufferedChatMemory(buffer_size=10),
         model_client=OpenAI(model="gpt-4-turbo"),  # type: ignore
-        color=Fore.GREEN,
     )
-    _ = ChatRoomAgent(
+    charlie = ChatRoomAgent(
         name="Charlie",
         description="Charlie in the chat room.",
         runtime=runtime,
         background_story="Charlie is a designer who loves to create art.",
         memory=BufferedChatMemory(buffer_size=10),
         model_client=OpenAI(model="gpt-4-turbo"),  # type: ignore
-        color=Fore.MAGENTA,
     )
+    app.welcoming_notice = f"""Welcome to the chat room demo with the following participants:
+1. 👧 {alice.metadata['name']}: {alice.metadata['description']}
+2. 👱🏼‍♂️ {bob.metadata['name']}: {bob.metadata['description']}
+3. 👨🏾‍🦳 {charlie.metadata['name']}: {charlie.metadata['description']}
 
+Each participant decides on its own whether to respond to the latest message.
 
-async def get_user_input(prompt: str) -> str:
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, input, prompt)
+You can greet the chat room by typing your first message below.
+"""
 
 
-async def main(user_name: str, wait_seconds: int) -> None:
+async def main() -> None:
     runtime = SingleThreadedAgentRuntime()
-    chat_room(runtime)
-    while True:
-        # TODO: allow user to input at any time while runtime is running.
-        # Get user input and send messages to the chat room.
-        # TODO: use Textual to build the UI.
-        user_input = await get_user_input(f"{sep}\nYou:\n")
-        if user_input.strip():
-            # Publish user message if it is not empty.
-            await runtime.publish_message(ChatRoomMessage(source=user_name, content=user_input))
-        # Wait for agents to respond.
-        while runtime.unprocessed_messages:
-            await runtime.process_next()
-            await asyncio.sleep(wait_seconds)
+    app = TextualChatApp(runtime, user_name="You")
+    chat_room(runtime, app)
+    asyncio.create_task(start_runtime(runtime))
+    await app.run_async()
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Run a chat room simulation.")
-    parser.add_argument(
-        "--user-name",
-        type=str,
-        default="Host",
-        help="The name of the user who is participating in the chat room.",
-    )
-    parser.add_argument(
-        "--wait-seconds",
-        type=int,
-        default=5,
-        help="The number of seconds to wait between processing messages.",
-    )
+    parser = argparse.ArgumentParser(description="Chat room demo with self-driving AI agents.")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging.")
     args = parser.parse_args()
-    asyncio.run(main(args.user_name, args.wait_seconds))
+    if args.verbose:
+        logging.basicConfig(level=logging.WARNING)
+        logging.getLogger("agnext").setLevel(logging.DEBUG)
+        handler = logging.FileHandler("chat_room.log")
+        logging.getLogger("agnext").addHandler(handler)
+    asyncio.run(main())

examples/coder_reviewer.py

@@ -1,15 +1,28 @@
+import argparse
 import asyncio
+import logging
+import logging.handlers
+import os
+import sys
+
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
 
 from agnext.application import SingleThreadedAgentRuntime
 from agnext.chat.agents import ChatCompletionAgent
 from agnext.chat.memory import BufferedChatMemory
 from agnext.chat.patterns import GroupChatManager
-from agnext.chat.types import TextMessage
 from agnext.components.models import OpenAI, SystemMessage
 from agnext.core import AgentRuntime
+from utils import TextualChatApp, TextualUserAgent, start_runtime
 
 
-def coder_reviewer(runtime: AgentRuntime) -> None:
+def coder_reviewer(runtime: AgentRuntime, app: TextualChatApp) -> None:
+    _ = TextualUserAgent(
+        name="Human",
+        description="A human user that provides a problem statement.",
+        runtime=runtime,
+        app=app,
+    )
     coder = ChatCompletionAgent(
         name="Coder",
         description="An agent that writes code",
@@ -30,8 +43,13 @@ def coder_reviewer(runtime: AgentRuntime) -> None:
         system_messages=[
             SystemMessage(
                 "You are a code reviewer. You focus on correctness, efficiency and safety of the code.\n"
-                "Provide reviews only.\n"
-                "Output only 'APPROVE' to approve the code and end the conversation."
+                "Respond using the following format:\n"
+                "Code Review:\n"
+                "Correctness: <Your comments>\n"
+                "Efficiency: <Your comments>\n"
+                "Safety: <Your comments>\n"
+                "Approval: <APPROVE or REVISE>\n"
+                "Suggested Changes: <Your comments>"
             )
         ],
         model_client=OpenAI(model="gpt-4-turbo"),
@@ -44,24 +62,31 @@ def coder_reviewer(runtime: AgentRuntime) -> None:
         participants=[coder.id, reviewer.id],  # The order of the participants indicates the order of speaking.
         memory=BufferedChatMemory(buffer_size=10),
         termination_word="APPROVE",
-        on_message_received=lambda message: print(f"{'-'*80}\n{message.source}: {message.content}"),
     )
+    app.welcoming_notice = f"""Welcome to the coder-reviewer demo with the following roles:
+1. 🤖 {coder.metadata['name']}: {coder.metadata['description']}
+2. 🧐 {reviewer.metadata['name']}: {reviewer.metadata['description']}
+The coder will write code to solve a problem, and the reviewer will review the code.
+The conversation will end when the reviewer approves the code.
+Let's get started by providing a problem statement.
+"""
 
 
 async def main() -> None:
     runtime = SingleThreadedAgentRuntime()
-    coder_reviewer(runtime)
-    runtime.publish_message(
-        TextMessage(
-            content="Write a Python script that find near-duplicate paragraphs in a directory of many text files. "
-            "Output the file names, line numbers and the similarity score of the near-duplicate paragraphs. ",
-            source="Human",
-        )
-    )
-    # Start the runtime.
-    while True:
-        await runtime.process_next()
-        await asyncio.sleep(1)
+    app = TextualChatApp(runtime, user_name="You")
+    coder_reviewer(runtime, app)
+    asyncio.create_task(start_runtime(runtime))
+    await app.run_async()
 
 
-asyncio.run(main())
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Coder-reviewer pattern for code writing and review.")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging.")
+    args = parser.parse_args()
+    if args.verbose:
+        logging.basicConfig(level=logging.WARNING)
+        logging.getLogger("agnext").setLevel(logging.DEBUG)
+        handler = logging.FileHandler("coder_reviewer.log")
+        logging.getLogger("agnext").addHandler(handler)
+    asyncio.run(main())

examples/illustrator_critics.py

@@ -0,0 +1,106 @@
+import argparse
+import asyncio
+import logging
+import os
+import sys
+
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
+
+import openai
+from agnext.application import SingleThreadedAgentRuntime
+from agnext.chat.agents import ChatCompletionAgent, ImageGenerationAgent
+from agnext.chat.memory import BufferedChatMemory
+from agnext.chat.patterns.group_chat_manager import GroupChatManager
+from agnext.components.models import OpenAI, SystemMessage
+from agnext.core import AgentRuntime
+from utils import TextualChatApp, TextualUserAgent, start_runtime
+
+
+def illustrator_critics(runtime: AgentRuntime, app: TextualChatApp) -> str:  # type: ignore
+    _ = TextualUserAgent(
+        name="User",
+        description="A user looking for illustration.",
+        runtime=runtime,
+        app=app,
+    )
+    descriptor = ChatCompletionAgent(
+        name="Descriptor",
+        description="An AI agent that provides a description of the image.",
+        runtime=runtime,
+        system_messages=[
+            SystemMessage(
+                "You create short description for image. \n"
+                "In this conversation, you will be given either: \n"
+                "1. Request for new image. \n"
+                "2. Feedback on some image created. \n"
+                "In both cases, you will provide a description of a new image to be created. \n"
+                "Only provide the description of the new image and nothing else. \n"
+                "Be succinct and precise."
+            ),
+        ],
+        memory=BufferedChatMemory(buffer_size=10),
+        model_client=OpenAI(model="gpt-4-turbo", max_tokens=500),
+    )
+    illustrator = ImageGenerationAgent(
+        name="Illustrator",
+        description="An AI agent that generates images.",
+        runtime=runtime,
+        client=openai.AsyncOpenAI(),
+        model="dall-e-3",
+        memory=BufferedChatMemory(buffer_size=1),
+    )
+    critic = ChatCompletionAgent(
+        name="Critic",
+        description="An AI agent that provides feedback on images given user's requirements.",
+        runtime=runtime,
+        system_messages=[
+            SystemMessage(
+                "You are an expert in image understanding. \n"
+                "In this conversation, you will judge an image given the description and provide feedback. \n"
+                "Pay attention to the details like the spelling of words and number of objects. \n"
+                "Use the following format in your response: \n"
+                "Number of each object type in the image: <Type 1 (e.g., Husky Dog)>: 1, <Type 2>: 2, ...\n"
+                "Feedback: <Your feedback here> \n"
+                "Approval: <APPROVE or REVISE> \n"
+            ),
+        ],
+        memory=BufferedChatMemory(buffer_size=2),
+        model_client=OpenAI(model="gpt-4-turbo"),
+    )
+    _ = GroupChatManager(
+        name="GroupChatManager",
+        description="A chat manager that handles group chat.",
+        runtime=runtime,
+        memory=BufferedChatMemory(buffer_size=5),
+        participants=[illustrator.id, critic.id, descriptor.id],
+        termination_word="APPROVE",
+    )
+
+    app.welcoming_notice = f"""You are now in a group chat with the following agents:
+
+1. 🤖 {descriptor.metadata['name']}: {descriptor.metadata.get('description')}
+2. 🤖 {illustrator.metadata['name']}: {illustrator.metadata.get('description')}
+3. 🤖 {critic.metadata['name']}: {critic.metadata.get('description')}
+
+Provide a prompt for the illustrator to generate an image.
+"""
+
+
+async def main() -> None:
+    runtime = SingleThreadedAgentRuntime()
+    app = TextualChatApp(runtime, user_name="You")
+    illustrator_critics(runtime, app)
+    asyncio.create_task(start_runtime(runtime))
+    await app.run_async()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Illustrator-critics pattern for image generation demo.")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging.")
+    args = parser.parse_args()
+    if args.verbose:
+        logging.basicConfig(level=logging.WARNING)
+        logging.getLogger("agnext").setLevel(logging.DEBUG)
+        handler = logging.FileHandler("illustrator_critics.log")
+        logging.getLogger("agnext").addHandler(handler)
+    asyncio.run(main())