updated prompts, moved player input to game

src/controllers.py

@@ -1,18 +1,13 @@
 import os
 
-from langchain_core.runnables import RunnableLambda
+from langchain_core.runnables import Runnable
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import AIMessage
 
-
-def player_input(prompt):
-    # even though they are human, we still need to return an AIMessage, since the HumanMessages are from the GameMaster
-    response = AIMessage(content=input())
-    return response
-
 MAX_TOKENS = 50
 
-def controller_from_name(name: str):
+
+def controller_from_name(name: str) -> Runnable:
     if name == "tgi":
         return ChatOpenAI(
             api_base=os.environ['HF_ENDPOINT_URL'] + "/v1/",
@@ -22,7 +17,5 @@ def controller_from_name(name: str):
         return ChatOpenAI(model="gpt-3.5-turbo", max_tokens=MAX_TOKENS)
     elif name == "ollama":
         return ChatOpenAI(model="mistral", openai_api_key="ollama", openai_api_base="http://localhost:11434/v1", max_tokens=MAX_TOKENS)
-    elif name == "human":
-        return RunnableLambda(player_input)
     else:
         raise ValueError(f"Unknown controller name: {name}")

src/game.py

@@ -9,26 +9,33 @@ from models import *
 from player import Player
 from prompts import fetch_prompt, format_prompt
 
+from langchain_core.runnables import RunnableLambda
+from langchain_core.messages import AIMessage
+from controllers import controller_from_name
+
 # Default Values
 NUMBER_OF_PLAYERS = 6
 WINNING_SCORE = 11
 
 class Game:
+
     log_dir = os.path.join(os.pardir, "experiments")
-    player_log_file = "{player_id}.jsonl"
-    game_log_file = "{game_id}-game.jsonl"
+    """The directory where the logs will be saved."""
+    player_log_file_template = "{player_id}.jsonl"
+    """Template for the name of the log file for each player."""
+    game_log_file_template = "{game_id}-game.jsonl"
+    """Template for the name of the log file for the game."""
     number_of_players = NUMBER_OF_PLAYERS
     """The number of players in the game."""
     winning_score = WINNING_SCORE
     """The Number of points required to win the game."""
-    debug = True
-    """If True, the game will print debug messages to the console."""
 
     def __init__(
             self,
             number_of_players: int = NUMBER_OF_PLAYERS,
             human_name: str = None,
-            verbose = False
+            verbose: bool = False,
+            debug: bool = False
     ):
         # Game ID
         self.game_id = game_id()
@@ -48,16 +55,21 @@ class Game:
             self.human_index = None
 
         self.verbose = verbose
+        """If True, the game will display verbose messages to the player."""
+        self.debug = debug
+        """If True, the game will display debug messages to the player."""
 
         # Add Players
         self.players = []
         for i in range(0, number_of_players):
             if self.human_index == i:
                 name = human_name
-                controller = "human"
+                controller_name = "human"
+                controller = RunnableLambda(self.human_input)
             else:
                 name = ai_names.pop()
-                controller = "openai"
+                controller_name = "openai"
+                controller = controller_from_name(controller_name)
 
             if self.chameleon_index == i:
                 role = "chameleon"
@@ -66,12 +78,12 @@ class Game:
 
             player_id = f"{self.game_id}-{i + 1}"
 
-            log_path = os.path.join(
+            player_log_path = os.path.join(
                 self.log_dir,
-                self.player_log_file.format(player_id=player_id)
+                self.player_log_file_template.format(player_id=player_id)
             )
 
-            self.players.append(Player(name, controller, player_id, log_filepath=log_path))
+            self.players.append(Player(name, controller, controller_name, player_id, log_filepath=player_log_path))
 
         # Game State
         self.player_responses = []
@@ -102,7 +114,7 @@ class Game:
                     player.prompt_queue.append(message)
                     if player.controller_type == "human":
                         self.human_message(message)
-            if self.verbose:
+            if self.verbose and not self.human_index:
                 self.human_message(message)
         else:
             recipient.prompt_queue.append(message)
@@ -119,7 +131,13 @@ class Game:
     # The following methods are used to broadcast messages to a human.
     # They are design so that they can be overridden by a subclass for a different player interface.
     @staticmethod
-    def human_message(self, message: str):
+    def human_input(prompt: str) -> str:
+        """Gets input from the human player."""
+        response = AIMessage(content=input())
+        return response
+
+    @staticmethod
+    def human_message(message: str):
         """Sends a message for the human player to read. No response is expected."""
         print(message)
 
@@ -146,7 +164,7 @@ class Game:
             "number_of_players": len(self.players),
             "human_player": self.players[self.human_index].id if self.human_index else "None",
         }
-        game_log_path = os.path.join(self.log_dir, self.game_log_file.format(game_id=self.game_id))
+        game_log_path = os.path.join(self.log_dir, self.game_log_file_template.format(game_id=self.game_id))
 
         log(game_log, game_log_path)
 
@@ -166,11 +184,11 @@ class Game:
         for i, player in enumerate(self.players):
             if i == chameleon_index:
                 player.assign_role("chameleon")
-                self.game_message("You are the **Chameleon**, remain undetected and guess what animal the others are pretending to be", player)
+                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(f"You are a **{herd_animal}**, keep this secret at all costs and figure which player is not really a {herd_animal}", player)
+                self.game_message(format_prompt("assign_herd", herd_animal=herd_animal), player)
 
         # Phase II: Collect Player Animal Descriptions
 
@@ -179,11 +197,7 @@ class Game:
             if current_player.controller_type != "human":
                 self.verbose_message(f"{current_player.name} is thinking...")
 
-            if i == 0:
-                prompt = "Your Response:"
-            else:
-                prompt = "It's your turn to describe yourself. Do not repeat responses from other players.\nYour Response:"
-
+            prompt = fetch_prompt("player_describe_animal")
 
             # Get Player Animal Description
             response = await self.instructional_message(prompt, current_player, AnimalDescriptionModel)
@@ -207,8 +221,6 @@ class Game:
         # Phase IV: The Herd Votes for who they think the Chameleon is
         self.game_message("The Chameleon has guessed the animal. Now the Herd will vote on who they think the chameleon is.")
 
-        self.game_message("The Chameleon has decided not to guess the animal. Now all players will vote on who they think the chameleon is.")
-
         player_votes = []
         for player in self.players:
             if player.role == "herd":

src/player.py

@@ -2,7 +2,7 @@ import os
 from typing import Type, Literal, List
 import logging
 
-from langchain_core.runnables import Runnable, RunnableParallel, RunnableLambda, chain
+from langchain_core.runnables import Runnable, RunnableLambda
 
 from langchain.output_parsers import PydanticOutputParser
 from langchain_core.prompts import PromptTemplate
@@ -24,14 +24,14 @@ logger = logging.getLogger("chameleon")
 # 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["prompt", "player"]
+    type: Literal["prompt", "player", "retry", "error"]
     """The type of the message. Can be "prompt" or "player"."""
     content: str
     """The content of the message."""
     @property
     def langchain_type(self):
         """Returns the langchain message type for the message."""
-        if self.type == "prompt":
+        if self.type in ["prompt", "retry", "error"]:
             return "human"
         else:
             return "ai"
@@ -51,19 +51,20 @@ class Player:
     def __init__(
             self,
             name: str,
-            controller: str,
+            controller: Type[Runnable | RunnableLambda],
+            controller_name: str,
             player_id: str = None,
             log_filepath: str = None
     ):
         self.name = name
         self.id = player_id
 
-        if controller == "human":
+        if controller_name == "human":
             self.controller_type = "human"
         else:
             self.controller_type = "ai"
 
-        self.controller = controller_from_name(controller)
+        self.controller = controller
         """The controller for the player."""
         self.log_filepath = log_filepath
         """The filepath to the log file. If None, no logs will be written."""
@@ -78,7 +79,7 @@ class Player:
                 "name": self.name,
                 "role": self.role,
                 "controller": {
-                    "name": controller,
+                    "name": controller_name,
                     "type": self.controller_type
                 }
             }
@@ -113,10 +114,11 @@ 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(HumanMessage(content=f"Error formatting response: {e} \n\n Please try again."))
+                    self.add_to_history(Message(type="retry", content=f"Error formatting response: {e} \n\n Please try again."))
                     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."))
                     logging.error(f"Max retries reached due to Error: {e}")
                     raise e
         else:

src/prompts.py

@@ -62,7 +62,7 @@ class Task:
 
 
 _game_rules = '''\
-GAME RULES: You are playing a social deduction game where every player pretends the be the same animal. 
+You are playing a social deduction game where every player pretends the be the same animal. 
 During the round players go around the room and make an "I"-statement as if they were the animal. 
 All players know what animal they are pretending to be, except one who is known as the Chameleon. 
 The Chameleon and must blend in by providing details about the animal using context from other players. 
@@ -70,20 +70,21 @@ The other players must be careful not to give away too much information with the
 After all players have spoken, they vote on who they think the Chameleon is. \
 '''
 
-_herd_animal = """\
-You are a {animal}, keep this a secret at all costs. 
-In as few words as possible describe of yourself starting with "I". Your description should be vague but true, \
-since if the Chameleon can guess animal you are, you will LOSE. Do not repeat responses from other players.\
+_assign_herd = """\
+You are a **{herd_animal}**, keep this secret at all costs and figure which player is not really a {herd_animal}
 """
 
-_chameleon_animal = """\
-You are the Chameleon, keep this a secret at all costs. 
-You don't know what animal the other players are, your goal is to deduce it using the context they provide.
-Starting with "I" describe yourself in 10 words or less as if you are the same animal as the other players. 
-If no one else has said anything try to say something generic that could be true of any animals. 
-If the other players realize you are the Chameleon you will LOSE.\
+_assign_chameleon = """\
+"You are the **Chameleon**, remain undetected and guess what animal the others are pretending to be"
 """
 
+_player_describe_animal = """It's your turn to describe yourself. Remember:
+- Start your response with "I"
+- Keep your response as short as possible 
+- Do not repeat responses from other players.
+
+Your Response:"""
+
 _all_responses = """\
 Below are the responses from all the other players. 
 {player_responses}
@@ -107,8 +108,9 @@ Now it is time to vote. Choose from the players above who you think the Chameleo
 
 prompts = {
     "game_rules": _game_rules,
-    "herd_animal":   _herd_animal,
-    "chameleon_animal": _chameleon_animal,
+    "assign_herd": _assign_herd,
+    "assign_chameleon": _assign_chameleon,
+    "player_describe_animal": _player_describe_animal,
     "chameleon_guess_decision": _all_responses + _chameleon_guess_decision,
     "chameleon_guess_animal": _chameleon_guess_animal,
     "response": "Your response:",