output format descriptions and kwargs

src/agent_interfaces.py

@@ -9,6 +9,7 @@ from output_formats import OutputFormat, OutputFormatModel
 from message import Message, AgentMessage
 from data_collection import save
 
+
 class BaseAgentInterface:
     """
     The interface that agents use to receive info from and interact with the game.
@@ -37,7 +38,13 @@ class BaseAgentInterface:
         self.add_message(response)
         return response
 
-    def respond_to_formatted(self, message: Message, output_format: OutputFormat, max_retries = 3) -> OutputFormatModel:
+    def respond_to_formatted(
+            self,
+            message: Message,
+            output_format: OutputFormat,
+            max_retries=3,
+            **kwargs
+    ) -> OutputFormatModel:
         """Adds a message to the message history, and generates a response matching the provided format."""
         initial_response = self.respond_to(message)
 
@@ -49,16 +56,18 @@ class BaseAgentInterface:
         while not output and retries < max_retries:
             try:
                 formatted_response = self.respond_to(reformat_message)
-                output = output_format.output_format_model.model_validate_json(formatted_response.content)
+                if kwargs:
+                    fields = json.loads(formatted_response.content)
+                    fields.update(kwargs)
+                    output = output_format.model_validate(fields)
+                else:
+                    output = output_format.model_validate_json(formatted_response.content)
+
             except ValidationError as e:
                 if retries > max_retries:
                     raise e
                 retry_message = Message(type="retry", content=f"Error formatting response: {e} \n\n Please try again.")
-                if output_format.few_shot_examples:
-                    self.add_message(retry_message)
-                    reformat_message = Message(type="few_shot", content=output_format.get_few_shot()) # not implemented
-                else:
-                    reformat_message = retry_message
+                reformat_message = retry_message
 
                 retries += 1
 
@@ -74,11 +83,13 @@ class BaseAgentInterface:
     def is_ai(self):
         return not self.is_human
 
+
 AgentInterface = NewType("AgentInterface", BaseAgentInterface)
 
 
 class OpenAIAgentInterface(BaseAgentInterface):
     """An interface that uses the OpenAI API (or compatible 3rd parties) to generate responses."""
+
     def __init__(self, agent_id: str, model_name: str = "gpt-3.5-turbo"):
         super().__init__(agent_id)
         self.model_name = model_name
@@ -97,15 +108,16 @@ class OpenAIAgentInterface(BaseAgentInterface):
 
 
 class HumanAgentInterface(BaseAgentInterface):
-
     is_human = True
 
     def respond_to_formatted(self, message: Message, output_format: OutputFormat, **kwargs) -> OutputFormatModel:
         """For Human agents, we can trust them enough to format their own responses... for now"""
         response = super().respond_to(message)
         # only works because current outputs have only 1 field...
-        field_name = output_format.output_format_model.model_fields.copy().popitem()[0]
-        output = output_format.output_format_model.model_validate({field_name: response.content})
+        fields = {output_format.model_fields.copy().popitem()[0], response.content}
+        if kwargs:
+            fields.update(kwargs)
+        output = output_format.model_validate(fields)
 
         return output
 

src/game.py

@@ -13,7 +13,7 @@ from agent_interfaces import HumanAgentCLI, OpenAIAgentInterface
 
 # Default Values
 NUMBER_OF_PLAYERS = 6
-WINNING_SCORE = 11
+WINNING_SCORE = 3
 
 
 class Game:
@@ -131,7 +131,17 @@ class Game:
         """Sets up the game. This includes assigning roles and gathering player names."""
         self.game_message(fetch_prompt("game_rules"))
 
-        await self.run_round()
+        winner = None
+        round_number = 0
+
+        while not winner:
+            round_results = await self.run_round()
+            round_number += 1
+
+            # Check for a Winner
+            for player in self.players:
+                if player.points >= self.winning_score:
+                    winner = player # ignoring the possibility of a tie for now
 
         # Log Game Info
         game_log = {
@@ -144,7 +154,7 @@ class Game:
 
         log(game_log, game_log_path)
 
-    async def run_round(self):
+    async def run_round(self) -> dict:
         """Starts the round."""
 
         # Phase I: Choose Animal and Assign Roles
@@ -175,7 +185,7 @@ class Game:
 
             # Get Player Animal Description
             message = Message(type="prompt", content=prompt)
-            response = current_player.interface.respond_to_formatted(message, OutputFormat(AnimalDescriptionFormat))
+            response = current_player.interface.respond_to_formatted(message, AnimalDescriptionFormat)
 
             self.player_responses.append({"sender": current_player.name, "response": response.description})
 
@@ -190,7 +200,7 @@ class Game:
         prompt = fetch_prompt("chameleon_guess_animal")
 
         message = Message(type="prompt", content=prompt)
-        response = chameleon.interface.respond_to_formatted(message, OutputFormat(ChameleonGuessFormat))
+        response = chameleon.interface.respond_to_formatted(message, ChameleonGuessFormat)
 
         chameleon_animal_guess = response.animal
 
@@ -208,14 +218,13 @@ class Game:
                 # Get Player Vote
                 message = Message(type="prompt", content=prompt)
                 player_names = [p.name for p in self.players]
-                response = player.interface.respond_to_formatted(message, OutputFormat(HerdVoteFormat, player_names))
+                response = player.interface.respond_to_formatted(message, HerdVoteFormat, player_names=player_names)
 
                 # Add Vote to Player Votes
                 player_votes.append({"voter": player, "vote": response.vote})
                 if player.interface.is_ai:
                     self.debug_message(f"{player.name} voted for {response.vote}")
 
-
         self.game_message("All players have voted!")
         formatted_votes = '\n'.join([f'{vote["voter"].name}: {vote["vote"]}' for vote in player_votes])
         self.game_message(f"Votes:\n{formatted_votes}")
@@ -225,7 +234,7 @@ class Game:
 
         # Phase V: Assign Points
 
-        self.game_message(f"The round is over. Caclulating results...")
+        self.game_message(f"The round is over. Calculating results...")
         self.game_message(
             f"The Chameleon was {chameleon.name}, and they guessed the secret animal was {chameleon_animal_guess}.")
         self.game_message(f"The secret animal was actually was {herd_animal}.")
@@ -259,8 +268,7 @@ class Game:
 
         self.game_message(f"Current Game Score: {player_points}")
 
-        # Log Round Info
-        round_log = {
+        return {
             "herd_animal": herd_animal,
             "chameleon_name": chameleon.name,
             "chameleon_guess": chameleon_animal_guess,

src/message.py

@@ -11,7 +11,7 @@ class Message(BaseModel):
     content: str
     """The content of the message."""
 
-    @computed_field
+    @property
     def conversation_role(self) -> str:
         """The message type in the format used by the LLM."""
 
@@ -20,7 +20,7 @@ class Message(BaseModel):
         # 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"]:
+        if self.type != "agent":
             return "user"
         else:
             return "assistant"

src/output_formats.py

@@ -2,52 +2,33 @@ import random
 from typing import Annotated, NewType, List, Optional, Type, Literal
 import json
 
-from pydantic import BaseModel, field_validator, Field
+from pydantic import BaseModel, field_validator, Field, model_validator
 
 FORMAT_INSTRUCTIONS = """Please reformat your previous response as a JSON instance that conforms to the JSON structure below.
 Here is the output format:
 {schema}
 """
-FEW_SHOT_INSTRUCTIONS = """Here are a few examples of correctly formatted responses: \n
-{examples}
-"""
-
-OutputFormatModel = NewType("OutputFormatModel", BaseModel)
-
-
-class OutputFormat:
-    """The base class for all output formats."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Instructions for formatting the output, it is combined with the JSON schema of the output format."""
-    few_shot_instructions: str = FEW_SHOT_INSTRUCTIONS
-    """Instructions for the few shot examples, it is combined with the few shot examples."""
-    few_shot_examples: Optional[List[dict]] = None
-    """A list of examples to be shown to the agent to help them understand the desired format of the output."""
 
-    def __init__(self, output_format_model: Type[OutputFormatModel], player_names: List[str] = None):
-        self.output_format_model = output_format_model
-        self.output_format_model.player_names = player_names
 
-    def get_format_instructions(self) -> str:
-        json_format = self.output_format_model().model_dump_json()
-
-        return self.format_instructions.format(schema=json_format)
+class OutputFormatModel(BaseModel):
+    @classmethod
+    def get_format_instructions(cls) -> str:
+        """Returns a string with instructions on how to format the output."""
+        json_format = {}
+        for field in cls.model_fields:
+            if not cls.model_fields[field].exclude:
+                json_format[field] = cls.model_fields[field].description
 
-    def get_few_shot(self, max_examples=3):
-        if len(self.few_shot_examples) <= max_examples:
-            examples = self.few_shot_examples
-        else:
-            examples = random.sample(self.few_shot_examples, max_examples)
+        # In the future, we could instead use get_annotations() to get the field descriptions
+        return FORMAT_INSTRUCTIONS.format(schema=json_format)
 
-        few_shot = "\n\n".join([f"Example Response:\n{json.dumps(example)}" for example in examples])
 
-        return self.few_shot_instructions.format(examples=few_shot)
+OutputFormat = NewType("OutputFormat", OutputFormatModel)
 
 
-class AnimalDescriptionFormat(BaseModel):
+class AnimalDescriptionFormat(OutputFormatModel):
     # Define fields of our class here
-    description: str = Field("A brief description of the animal")
+    description: str = Field(description="A brief description of the animal")
     """A brief description of the animal"""
 
     @field_validator('description')
@@ -58,8 +39,8 @@ class AnimalDescriptionFormat(BaseModel):
         return v
 
 
-class ChameleonGuessFormat(BaseModel):
-    animal: str = Field("The name of the animal you think the chameleon is")
+class ChameleonGuessFormat(OutputFormatModel):
+    animal: str = Field(description='Name of the animal you think the Herd is in its singular form, e.g. "animal" not "animals"')
 
     @field_validator('animal')
     @classmethod
@@ -69,15 +50,14 @@ class ChameleonGuessFormat(BaseModel):
         return v
 
 
-class HerdVoteFormat(BaseModel):
+class HerdVoteFormat(OutputFormatModel):
     player_names: List[str] = Field([], exclude=True)
     """The names of the players in the game"""
-    vote: str = Field("The name of the player you are voting for")
+    vote: str = Field(description="The name of the player you are voting for")
     """The name of the player you are voting for"""
 
-    @field_validator('vote')
-    @classmethod
-    def check_player_exists(cls, v) -> str:
-        if v.lower() not in [player.lower() for player in cls.player_names]:
-            raise ValueError(f"Player {v} does not exist")
-        return v
+    @model_validator(mode="after")
+    def check_player_exists(self) -> "HerdVoteFormat":
+        if self.vote.lower() not in [player.lower() for player in self.player_names]:
+            raise ValueError(f"Player {self.vote} does not exist, please vote for one of {self.player_names}")
+        return self