messages can be assigned to multiple players

src/agent_interfaces.py

@@ -19,6 +19,9 @@ class BaseAgentInterface(BaseModel):
 
     agent_id: str
     """The id of the agent."""
+    game_id: str
+    """The id of the game the agent is in."""
+
     log_messages: bool = True
     """Whether to log messages or not."""
     messages: List[Message] = []
@@ -32,10 +35,7 @@ class BaseAgentInterface(BaseModel):
 
     def add_message(self, message: Message):
         """Adds a message to the message history, without generating a response."""
-        bound_message = AgentMessage.from_message(message, self.agent_id, len(self.messages))
-        if self.log_messages:
-            save(bound_message)
-        self.messages.append(bound_message)
+        self.messages.append(message)
 
     # Respond To methods - These take a message as input and generate a response
 
@@ -64,6 +64,7 @@ class BaseAgentInterface(BaseModel):
         if content:
             response = Message(type="agent", content=content)
             self.add_message(response)
+            save(AgentMessage.from_message(response, [self.agent_id], self.game_id))
             return response
         else:
             return None
@@ -128,7 +129,7 @@ class OpenAIAgentInterface(BaseAgentInterface):
     """An interface that uses the OpenAI API (or compatible 3rd parties) to generate responses."""
     model_config = ConfigDict(protected_namespaces=())
 
-    model_name: str ="gpt-3.5-turbo"
+    model_name: str = "gpt-3.5-turbo"
     """The name of the model to use for generating responses."""
     client: Any = Field(default_factory=OpenAI, exclude=True)
     """The OpenAI client used to generate responses."""

src/game.py

@@ -3,7 +3,7 @@ from typing import Optional, Type, List, ClassVar
 from pydantic import BaseModel, Field
 
 from game_utils import *
-from message import Message, MessageType
+from message import Message, MessageType, AgentMessage
 from agent_interfaces import HumanAgentCLI, OpenAIAgentInterface, HumanAgentInterface
 from player import Player
 from data_collection import save
@@ -14,12 +14,12 @@ class Game(BaseModel):
 
     # Required
 
+    game_id: str
+    """The unique id of the game."""
     players: List[Player] = Field(exclude=True)
     """The players in the game."""
-    observer: Optional[Player] = Field(exclude=True)
+    observer: Optional[Player]
     """An observer who can see all public messages, but doesn't actually play."""
-    game_id: str
-    """The unique id of the game."""
 
     # Default
 
@@ -48,7 +48,7 @@ class Game(BaseModel):
     def game_message(
             self,
             content: str,
-            recipient: Optional[Player] = None,  # If None, message is broadcast to all players
+            recipient: Player | List[Player] | None = None,  # If None, message is broadcast to all players
             exclude: bool = False,  # If True, the message is broadcast to all players except the chosen player
             message_type: MessageType = "info"
     ):
@@ -58,14 +58,28 @@ class Game(BaseModel):
         If exclude is True, the message is broadcast to all players except the recipient.
         Some message types are only available to player with access (e.g. verbose, debug).
         """
-        message = Message(type=message_type, content=content)
-
         if exclude or not recipient:
-            for player in self.players + [self.observer] if self.observer else self.players:
-                if player != recipient and player.can_receive_message(message_type):
-                    player.interface.add_message(message)
+            # These are public messages, exclude is used to exclude the sender from the recipient list.
+            recipients = [player for player in self.players if player != recipient]
+            if self.observer:
+                recipients.append(self.observer)
         else:
-            recipient.interface.add_message(message)
+            if isinstance(recipient, Player):
+                recipients = [recipient]
+            else:
+                recipients = recipient
+
+        message = Message(type=message_type, content=content)
+        recipient_ids = []
+
+        for player in recipients:
+            if player.can_receive_message(message_type):
+                player.interface.add_message(message)
+                recipient_ids.append(player.player_id)
+
+        agent_message = AgentMessage.from_message(message, recipient_ids, self.game_id)
+        save(agent_message)
+
 
     def verbose_message(self, content: str, **kwargs):
         """
@@ -96,8 +110,6 @@ class Game(BaseModel):
 
         save(self)
 
-
-
     @classmethod
     def from_human_name(
             cls, human_name: str = None,
@@ -122,19 +134,21 @@ class Game(BaseModel):
         players = []
 
         for i in range(0, cls.number_of_players):
-            player_id = f"{game_id}-{i + 1}"
-            player_dict = {"game_id": game_id, "player_id": player_id}
+            player_dict = {"game_id": game_id}
 
             if human_index == i:
                 player_dict["name"] = human_name
-                player_dict["interface"] = human_interface(agent_id=player_id)
+                player_id = f"{game_id}-human"
+                player_dict["interface"] = human_interface(agent_id=player_id, game_id=game_id)
                 player_dict["message_level"] = human_message_level
             else:
                 player_dict["name"] = ai_names.pop()
+                player_id = f"{game_id}-{player_dict['name']}"
                 # all AI players use the OpenAI interface for now - this can be changed in the future
-                player_dict["interface"] = OpenAIAgentInterface(agent_id=player_id)
+                player_dict["interface"] = OpenAIAgentInterface(agent_id=player_id, game_id=game_id)
                 player_dict["message_level"] = "info"
 
+            player_dict["player_id"] = player_id
             players.append(cls.player_class(**player_dict))
 
         # Add Observer - an Agent who can see all the messages, but doesn't actually play

src/game_chameleon.py

@@ -49,6 +49,11 @@ class ChameleonGame(Game):
         """Returns the current chameleon."""
         return self.player_from_id(self.chameleon_ids[-1])
 
+    @property
+    def chameleon_id(self) -> str:
+        """Returns the current chameleon's id."""
+        return self.chameleon_ids[-1]
+
     @property
     def herd_animal(self) -> str:
         """Returns the current herd animal."""
@@ -146,16 +151,29 @@ class ChameleonGame(Game):
 
         # Assign Roles
         chameleon_index = random_index(len(self.players))
-        self.chameleon_ids.append(self.players[chameleon_index].player_id)
+        chameleon = self.players[chameleon_index]
+
+        self.chameleon_ids.append(chameleon.player_id)
+
+        self.game_message(fetch_prompt("assign_chameleon"), chameleon)
+
+        herd = []
+        for i, player in enumerate(self.players):
+            if i == chameleon_index:
+                player.assign_role("chameleon")
+                self.debug_message(f"{player.name} is the Chameleon!")
+            else:
+                player.assign_role("herd")
+                herd.append(player)
+
+        self.game_message(format_prompt("assign_herd", herd_animal=herd_animal), herd)
 
         for i, player in enumerate(self.players):
             if i == chameleon_index:
                 player.assign_role("chameleon")
-                self.game_message(fetch_prompt("assign_chameleon"), player)
                 self.debug_message(f"{player.name} is the Chameleon!")
             else:
                 player.assign_role("herd")
-                self.game_message(format_prompt("assign_herd", herd_animal=herd_animal), player)
 
         # Empty Animal Descriptions
         self.all_animal_descriptions.append([])

src/message.py

@@ -1,8 +1,17 @@
-from typing import Literal
-from pydantic import BaseModel, computed_field
+from typing import Literal, List
+from pydantic import BaseModel, computed_field, Field
 
 MessageType = Literal["prompt", "info", "agent", "retry", "error", "format", "verbose", "debug"]
 
+message_number = 0
+
+
+def next_message_number():
+    global message_number
+    current_message_number = message_number
+    message_number += 1
+    return current_message_number
+
 
 class Message(BaseModel):
     """A generic message, these are used to communicate between the game and the players."""
@@ -37,24 +46,26 @@ class Message(BaseModel):
 
 
 class AgentMessage(Message):
-    """A message bound to a specific agent, this happens when an agent receives a message from the game."""
+    """A message that has been sent to 1 or more agents."""
 
-    agent_id: str
-    """The id of the controller that the message was sent by/to."""
-    message_number: int
+    agent_ids: List[str]
+    """The id/ids of the agent that the message was sent by/to."""
+    game_id: str
+    """The id of the game the message was sent during."""
+    message_number: int = Field(default_factory=next_message_number)
     """The number of the message, indicating the order in which it was sent."""
 
     @computed_field
     def message_id(self) -> str:
         """Returns the message id in the format used by the LLM."""
-        return f"{self.agent_id}-{self.message_number}"
+        return f"{self.game_id}-{self.message_number}"
 
     @classmethod
-    def from_message(cls, message: Message, agent_id: str, message_number: int) -> "AgentMessage":
+    def from_message(cls, message: Message, agent_ids: List[str], game_id: str) -> "AgentMessage":
         """Creates an AgentMessage from a Message."""
         return cls(
             type=message.type,
             content=message.content,
-            agent_id=agent_id,
-            message_number=message_number
+            agent_ids=agent_ids,
+            game_id=game_id
         )

src/player.py

@@ -43,7 +43,7 @@ class Player(BaseModel):
         """Creates an observer player."""
         name = "Observer"
         player_id = f"{game_id}-observer"
-        interface = interface_type(agent_id=player_id)
+        interface = interface_type(agent_id=player_id, game_id=game_id)
 
         return cls(name=name, player_id=player_id, game_id=game_id, interface=interface, message_level=message_level)