Added user proxy agent

Author: AumJavalgikar

nextpy/ai/agent/assistant_agent.py

@@ -1,11 +1,11 @@
-from typing import Any, Dict, Union
+from typing import Any, Callable, Tuple
 from nextpy.ai.agent.base_agent import BaseAgent
 import logging
 from pathlib import Path
 from nextpy.ai import engine
-from typing import Callable, Tuple
 import inspect
 import asyncio
+import logging
 
 
 def _call_functions(functions):
@@ -59,7 +59,7 @@ class AssistantAgent(BaseAgent):
     {{#user~}}
     Read the following CONVERSATION :
     {{messages}}
-    Respond. Do not thank any team member or show appreciation."
+    Respond as {{name}}. Do not thank any team member or show appreciation."
     {{~/user}}
     
     {{#assistant~}}
@@ -78,6 +78,7 @@ def __init__(self,
                                               Tuple[Any], Tuple[Any]] | None = None,
                  functions_after_call: Tuple[Callable,
                                              Tuple[Any], Tuple[Any]] | None = None,
+                 description: str = "Helpful AI Assistant Agent",
                  **kwargs):
         """
         Initializes an instance of the AssistantAgent class.
@@ -101,6 +102,7 @@ def __init__(self,
         :param kwargs: Additional keyword arguments.
         """
         super().__init__(llm=llm, **kwargs)
+        self.name = name
         self.prompt = self.DEFAULT_PROMPT
         self.system_message = system_message
         # This is used by multiagent manager to determine whether to use receive or a_receive
@@ -111,18 +113,19 @@ def __init__(self,
                 system_message = Path(system_message).read_text()
             except Exception:
                 pass
-            self.prompt = self.prompt[:self.DEFAULT_PROMPT.find(
-                '{{~/system}}')] + system_message + self.prompt[self.DEFAULT_PROMPT.find('{{~/system}}'):]
+            self.prompt = self.prompt[:self.prompt.find(
+                '{{~/system}}')] + system_message + self.prompt[self.prompt.find('{{~/system}}'):]
 
         # Either llm or engine must be provided
-        assert llm is not None or engine is not None, "Either llm or engine must be provided."
+        if llm is not None or engine is not None:
+            logging.debug("Warning! Either llm or engine must be provided.")
 
         self.engine = custom_engine if custom_engine is not None else engine(
             template=self.prompt, llm=llm, memory=memory, async_mode=async_mode, **kwargs)
         self.output_key = 'answer'
-        self.name = name
         self.functions_before_call = functions_before_call
         self.functions_after_call = functions_after_call
+        self.description = description
 
     @staticmethod
     def function_call_decorator(func):

nextpy/ai/agent/multiagent_manager.py

@@ -1,6 +1,4 @@
-from typing import Tuple, List, Optional, Any
-
-from nextpy.ai.agent.base_agent import BaseAgent
+from typing import Tuple, List, Any
 from nextpy.ai.agent.assistant_agent import AssistantAgent
 from nextpy.ai import engine
 
@@ -25,12 +23,12 @@ class MultiAgentManager:
         debug_mode (bool): A flag indicating whether to enable debug mode.
     """
     DEFAULT_PROMPT = '''   
-    {{#system~}} You are playing a role playing game with the following participants : {{agents}}{{~/system}}
+    {{#system~}} You are playing a role playing game with the following participants : \n{{agents}}{{~/system}}
 
     {{#user~}}
     Read the following conversation and choose who the next speaker will be:
     {{messages}}
-    Simply respond with the NAME of the next speaker. Do not include any numbers. Note, User is not a participant, you cannot choose User.
+    Simply respond with the NAME of the next speaker without any other characters such as numbers or punctuations.
     {{~/user}}
 
     {{#assistant~}}
@@ -70,6 +68,13 @@ def __init__(self,
 
         self.debug_mode = debug_mode
 
+        if not any([isinstance(agent, AssistantAgent)
+                    for agent in agents]):
+            self.DEFAULT_PROMPT = self.DEFAULT_PROMPT[:self.DEFAULT_PROMPT.find(
+                '{{~/system}}')] + '\nNote, User is also a participant, you can choose User.' + self.DEFAULT_PROMPT[self.DEFAULT_PROMPT.find('{{~/system}}'):]
+        else:
+            self.DEFAULT_PROMPT = self.DEFAULT_PROMPT[:self.DEFAULT_PROMPT.find(
+                '{{~/system}}')] + '\nNote, User is not a participant, you cannot choose User.' + self.DEFAULT_PROMPT[self.DEFAULT_PROMPT.find('{{~/system}}'):]
         self.engine = engine(
             self.DEFAULT_PROMPT, llm=llm, memory=memory, async_mode=async_mode)
         self.solution_summarizer = engine(
@@ -90,7 +95,7 @@ def agent_string(self):
         """
         Returns a string representation of all the agent names separated by commas.
         """
-        return ','.join([agent.name for agent in self.agents])
+        return '\n\n'.join([f'NAME: {agent.name}\n DESC: {agent.description}' for agent in self.agents])
 
     def run_sequence(self, context):
         """
@@ -103,7 +108,7 @@ def run_sequence(self, context):
             A list of messages exchanged between agents during the sequence.
         """
         self.messages.append(['User', context])
-        while self.rounds > 0 and not self._termination_message_received():
+        while self.rounds != 0 and not self._termination_message_received():
             if self.debug_mode:
                 print(
                     f'{"-"*5}Messaging next agent : {self.agents[self.current_agent].name}{"-"*5}\n\n')
@@ -130,7 +135,7 @@ async def a_run_sequence(self, context):
             A list of messages exchanged between agents during the sequence.
         """
         self.messages.append(['User', context])
-        while self.rounds > 0 and not self._termination_message_received():
+        while self.rounds != 0 and not self._termination_message_received():
             if self.debug_mode:
                 print(
                     f'{"-"*5}Messaging next agent : {self.agents[self.current_agent].name}{"-"*5}\n\n')
@@ -157,7 +162,7 @@ def run_auto(self, context):
             A list containing the messages exchanged between agents and the final solution.
         """
         self.messages.append(['User', context])
-        while self.rounds > 0 and not self._termination_message_received():
+        while self.rounds != 0 and not self._termination_message_received():
             next_agent = self._choose_next_agent()
             if self.debug_mode:
                 print(

nextpy/ai/agent/userproxy_agent.py

@@ -0,0 +1,69 @@
+from nextpy.ai.agent.assistant_agent import AssistantAgent
+from typing import Any, Tuple, Callable
+
+
+class UserProxyAgent(AssistantAgent):
+
+    def __init__(self,
+                 async_mode: bool = False,
+                 functions_before_call: Tuple[Callable,
+                                              Tuple[Any], Tuple[Any]] | None = None,
+                 functions_after_call: Tuple[Callable,
+                                             Tuple[Any], Tuple[Any]] | None = None,
+                 description: str = "User Proxy Agent capable of receiving user input.",
+                 **kwargs):
+        self.name = 'User'
+        self.description = description
+        self.async_mode = async_mode
+        self.functions_before_call = functions_before_call
+        self.functions_after_call = functions_after_call
+
+    @AssistantAgent.function_call_decorator
+    def receive(self, *args, **kwargs):
+        """
+        Receives messages from other agents and generates a response.
+
+        :param agents: The list of agents involved in the conversation.
+        :type agents: List[str]
+        :param messages: The list of messages in the conversation.
+        :type messages: List[str]
+        :param termination_message: The termination message for the conversation.
+        :type termination_message: str
+        :return: The generated response.
+        :rtype: str
+        """
+        return self._receive_user_input()
+
+    @AssistantAgent.function_call_decorator
+    async def a_receive(self, *args, **kwargs):
+        """
+        Asynchronously receives messages from other agents and generates a response.
+
+        :param agents: The list of agents involved in the conversation.
+        :type agents: List[str]
+        :param messages: The list of messages in the conversation.
+        :type messages: List[str]
+        :param termination_message: The termination message for the conversation.
+        :type termination_message: str
+        :return: The generated response.
+        :rtype: str
+        """
+        return await self.a_receive_user_input()
+
+    def _receive_user_input(self):
+        """
+        Receives user input and returns it as the response.
+
+        :return: The user input.
+        :rtype: str
+        """
+        return input('Provide feedback to chat_manager:')
+
+    async def a_receive_user_input(self):
+        """
+        Asynchronously receives user input and returns it as the response.
+
+        :return: The user input.
+        :rtype: str
+        """
+        return input('Provide feedback to chat_manager:')