more robust message logging

src/game.py

@@ -39,7 +39,7 @@ class Game:
     ):
         # Game ID
         self.game_id = game_id()
-        self.start_time = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
+        self.start_time = datetime.now().strftime('%y%m%d-%H%M%S')
         self.log_dir = os.path.join(self.log_dir, f"{self.start_time}-{self.game_id}")
         os.makedirs(self.log_dir, exist_ok=True)
 

src/message.py

@@ -1,36 +1,56 @@
 from typing import Literal
+from pydantic import BaseModel, computed_field
 
-from pydantic import BaseModel
+"""
+Right now we have two separate systems that use the word "message":
+
+1. The Game class uses messages to communicate with the players
+     - "game" messages pile up in the queue and are responded to by the player once an "instructional" message is sent.
+     - "verbose", and "debug" currently for the human player only
+   This does **NOT** use the Message class defined below 
 
+2. The Player class uses messages to communicate with the controller (either the AI or the human)
+   - "prompt" type messages come from the Game and are responded to by the player.
+   - "retry", "error", and "format" are internal messages used by the player to ensure the correct format
+   - "player" is used to communicate with the AI or human player.
+   All of these messages are logged, and use the Message class defined below
+
+For the future we should investigate redesigning/merging these two systems to avoid confusion
+"""
+
+MessageType = Literal["prompt", "player", "retry", "error", "format"]
 
-# Lots of AI Libraries use HumanMessage and AIMessage as the base classes for their messages.
-# This doesn't make sense for our as Humans and AIs are both players in the game, meaning they have the same role.
-# The Langchain type field is used to convert to that syntax.
 class Message(BaseModel):
-    type: Literal["game", "player", "retry", "error", "format"]
-    """The type of the message. Can be "prompt" or "player"."""
+    player_id: str
+    """The id of the player that the message was sent by/to."""
+    message_number: int
+    """The number of the message, indicating the order in which it was sent."""
+    type: MessageType
+    """The type of the message. Can be "prompt", "player", "retry", "error", or "format"."""
     content: str
     """The content of the message."""
-    @property
-    def langchain_type(self):
-        """Returns the langchain message type for the message."""
-        if self.type in ["game", "retry", "error", "format"]:
-            return "human"
+
+    @computed_field
+    def conversation_role(self) -> str:
+        """The message type in the format used by the LLM."""
+
+        # Most LLMs expect the "prompt" to come from a "user" and the "response" to come from an "assistant"
+        # Since the agents are the ones responding to messages, take on the llm_type of "assistant"
+        # This can be counterintuitive since they can be controlled by either human or ai
+        # Further, The programmatic messages from the game are always "user"
+
+        if self.type in ["prompt", "retry", "error", "format"]:
+            return "user"
         else:
-            return "ai"
+            return "assistant"
+
+    @computed_field
+    def message_id(self) -> str:
+        """Returns the message id in the format used by the LLM."""
+        return f"{self.player_id}-{self.message_number}"
+
+    def to_controller(self) -> tuple[str, str]:
+        """Returns the message in a format that can be used by the controller."""
+        return self.conversation_role, self.content
 
 
-"""
-Right now we have two separate systems that use the word "message":
-1. The Game class uses messages to communicate with the players
-   They have types:
-     - "game" used for all players, these are sent to the players and converted into the the above message class
-     - "verbose", and "debug" currently for the human player only
-2. The Player class uses messsage is to communicate with the controller (either the AI or the human)
-   - "game" type messages come from the Game and are responded to by the format.
-   - "retry", "error", and "format"
-   - "player" is used to communicate with the AI or human player.
-   All of these messages are logged
-   
-Long term we should investigate merging these two systems so we can log verbose and debug messages if desired.
-"""

src/player.py

@@ -12,21 +12,22 @@ from langchain_core.exceptions import OutputParserException
 from pydantic import BaseModel
 
 from game_utils import log
-from message import Message
+from message import Message, MessageType
 
 Role = Literal["chameleon", "herd"]
 
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger("chameleon")
 
+
 class Player:
 
     role: Role | None = None
-    """The role of the player in the game. Can be "chameleon" or "herd"."""
+    """The role of the player in the game. Can be "chameleon" or "herd". This changes every round."""
     rounds_played_as_chameleon: int = 0
-    """The number of times the player has been the chameleon."""
+    """The number of times the player has been the Chameleon."""
     rounds_played_as_herd: int = 0
-    """The number of times the player has been in the herd."""
+    """The number of times the player has been in the Herd."""
     points: int = 0
     """The number of points the player has."""
 
@@ -86,7 +87,7 @@ class Player:
             # Clear the prompt queue
             self.prompt_queue = []
 
-        message = Message(type="game", content=prompt)
+        message = self.player_message("prompt", prompt)
         output = await self.generate.ainvoke(message)
         if self.controller_type == "ai":
             retries = 0
@@ -96,11 +97,13 @@ class Player:
                 if retries < max_retries:
                     retries += 1
                     logger.warning(f"Player {self.id} failed to format response: {output} due to an exception: {e} \n\n Retrying {retries}/{max_retries}")
-                    self.add_to_history(Message(type="retry", content=f"Error formatting response: {e} \n\n Please try again."))
+                    retry_message = self.player_message("retry", f"Error formatting response: {e} \n\n Please try again.")
+                    self.add_to_history(retry_message)
                     output = await self.format_output.ainvoke({"output_format": output_format})
 
                 else:
-                    self.add_to_history(Message(type="error", content=f"Error formatting response: {e} \n\n Max retries reached."))
+                    error_message = self.player_message("error", f"Error formatting response: {e} \n\n Max retries reached.")
+                    self.add_to_history(error_message)
                     logging.error(f"Max retries reached due to Error: {e}")
                     raise e
         else:
@@ -110,6 +113,11 @@ class Player:
 
         return output
 
+    def player_message(self, message_type: MessageType, content: str) -> Message:
+        """Creates a message assigned to the player."""
+        return Message(player_id=self.id, message_number=len(self.messages), type=message_type, content=content)
+
+
     def add_to_history(self, message: Message):
         self.messages.append(message)
         log(message.model_dump(), self.log_filepath)
@@ -128,10 +136,10 @@ class Player:
         if self.controller_type == "human":
             response = await self.controller.ainvoke(message.content)
         else:
-            formatted_messages = [(message.langchain_type, message.content) for message in self.messages]
+            formatted_messages = [message.to_controller() for message in self.messages]
             response = await self.controller.ainvoke(formatted_messages)
 
-        self.add_to_history(Message(type="player", content=response.content))
+        self.add_to_history(self.player_message("player", response.content))
 
         return response
 
@@ -147,7 +155,7 @@ class Player:
 
         prompt = prompt_template.invoke({"format_instructions": parser.get_format_instructions()})
 
-        message = Message(type="format", content=prompt.text)
+        message = self.player_message("format", prompt.text)
 
         response = await self.generate.ainvoke(message)