feat: change engine to use new multi-turn conversation format

Author: Farmerobot

scripts/create_sft_dataset.py

@@ -19,9 +19,6 @@
 from transformers import AutoTokenizer
 
 from among_them.game_engine import GameEngine
-from among_them.models.phase import GamePhase
-from among_them.utils.prompt_utils import reconstruct_environment_prompt_from_history
-from among_them.utils.phase_utils import count_votes
 
 # Used as fallback to calculate token counts if actual tokenizer is not available
 CHARS_PER_TOKEN = 4

scripts/extract_benchmark_examples_llm.py

@@ -24,7 +24,7 @@
 from among_them.game_jsonencoder import game_object_hook
 from among_them.models.history import History
 from among_them.models.action_type import ActionType
-from among_them.utils.prompt_utils import reconstruct_environment_prompt_from_history
+from among_them.utils.prompt_utils import build_conversation_for_player
 from among_them.utils.player_utils import get_last_player_action, get_players_in_room, get_dead_players
 
 
@@ -70,11 +70,13 @@ def analyze_action_with_llm(
     if history_entry.phase.name == "DISCUSS":
         return None
 
-    # Reconstruct the full prompt
+    # Build conversation up to this point
     try:
-        full_prompt = reconstruct_environment_prompt_from_history(current_player, history, players, game_config)
+        conversation = build_conversation_for_player(current_player, history, players, game_config)
+        # Get last user message as the "full prompt" for analysis
+        full_prompt = conversation[-1]["content"] if conversation and conversation[-1]["role"] == "user" else ""
     except Exception as e:
-        print(f"Error reconstructing prompt for {player_name}: {e}")
+        print(f"Error building conversation for {player_name}: {e}")
         return None
 
     # Get LLM response and chain of thought
@@ -296,14 +298,16 @@ def extract_scenario_data(
     llm_cot = getattr(history_entry, "llm_cot", "")
     llm_response = getattr(history_entry, "llm_response", "")
 
-    # Reconstruct the full prompt
+    # Build conversation up to this point
     try:
         current_player = next((p for p in players if p.name == player_name), None)
         if not current_player:
             return None
-        full_prompt = reconstruct_environment_prompt_from_history(current_player, history, players, game_config)
+        conversation = build_conversation_for_player(current_player, history, players, game_config)
+        # Get last user message as the "full prompt" for analysis
+        full_prompt = conversation[-1]["content"] if conversation and conversation[-1]["role"] == "user" else ""
     except Exception as e:
-        print(f"Error reconstructing prompt for {player_name}: {e}")
+        print(f"Error building conversation for {player_name}: {e}")
         return None
 
     return {
@@ -420,12 +424,9 @@ def _norm(s: str) -> str:
             margin_ok = (chosen_baseline - baseline_best) >= 0.15
 
             # CoT quality judge
-            full_prompt = reconstruct_environment_prompt_from_history(
-                next((p for p in players if p.name == history_entry.action_taken.player_name), players[0]),
-                history_slice,
-                players,
-                game_config,
-            )
+            current_player_cot = next((p for p in players if p.name == history_entry.action_taken.player_name), players[0])
+            conversation = build_conversation_for_player(current_player_cot, history_slice, players, game_config)
+            full_prompt = conversation[-1]["content"] if conversation and conversation[-1]["role"] == "user" else ""
             cot_quality = analyze_cot_quality_with_llm(
                 history_entry,
                 history_entry.action_taken.player_name,

scripts/manual_llm_game.py

@@ -45,7 +45,7 @@ def main(reset=False, remove_last_n=0, game_config: GameConfig = None, state_fil
         print(history_item)
 
     while True:
-        turn_context_history, actions_player_can_take, system_prompt, user_prompt, pre_discussion_vote_prompts = engine.get_turn_context()
+        turn_context_history, actions_player_can_take, conversation, pre_discussion_vote_prompts = engine.get_turn_context()
         if not turn_context_history:
             print("Game over!")
             break
@@ -55,8 +55,7 @@ def main(reset=False, remove_last_n=0, game_config: GameConfig = None, state_fil
             print("--- Collecting Pre-Discussion Votes ---")
             for vote_prompt in pre_discussion_vote_prompts:
                 player = vote_prompt["player"]
-                system_prompt_pd = vote_prompt["system_prompt"]
-                user_prompt_pd = vote_prompt["user_prompt"]
+                pd_conversation = vote_prompt["conversation"]
                 actions_pd = vote_prompt["actions"]
 
                 # Retry loop for pre-discussion votes
@@ -68,8 +67,7 @@ def main(reset=False, remove_last_n=0, game_config: GameConfig = None, state_fil
                         # Build allowed actions for early-stop single-line streaming
                         allowed_actions_pd = [a.set_stories().command_perspective for a in actions_pd]
                         llm_response, cot = invoke_llm(
-                            system_prompt_pd,
-                            user_prompt_pd,
+                            pd_conversation,
                             player.llm_model_name,
                             allowed_actions=allowed_actions_pd,
                             single_line_only=True,
@@ -132,8 +130,7 @@ def main(reset=False, remove_last_n=0, game_config: GameConfig = None, state_fil
                 single_line_only = len(allowed_actions_main) > 0
                 allowed_actions_for_call = allowed_actions_main if single_line_only else None
                 llm_response, cot = invoke_llm(
-                    system_prompt,
-                    user_prompt,
+                    conversation,
                     current_player.llm_model_name,
                     allowed_actions=allowed_actions_for_call,
                     single_line_only=single_line_only,
@@ -182,7 +179,9 @@ def main(reset=False, remove_last_n=0, game_config: GameConfig = None, state_fil
 
         # Calculate token usage with tiktoken
         encoding = tiktoken.encoding_for_model("gpt-4o")
-        input_tokens = len(encoding.encode(system_prompt + user_prompt))
+        # Count tokens for all messages in conversation
+        conversation_text = "\n".join([msg["content"] for msg in conversation])
+        input_tokens = len(encoding.encode(conversation_text))
         output_tokens = len(encoding.encode(response_text + (cot or "")))
         token_usage = {"input_tokens": input_tokens, "output_tokens": output_tokens}
 

scripts/random_game.py

@@ -41,7 +41,7 @@ def main(reset=False, greedy=False, remove_last_n=0):
         print(history_item)
 
     while True:
-        turn_context_history, actions_player_can_take, system_prompt, user_prompt, pre_discussion_vote_prompts = engine.get_turn_context()
+        turn_context_history, actions_player_can_take, conversation, pre_discussion_vote_prompts = engine.get_turn_context()
         if not turn_context_history:
             print("Game over!")
             break

scripts/replay_games.py

@@ -106,7 +106,7 @@ def replay_game(json_file: Path, output_folder: Path):
             print("Game over - no turn context")
             break
 
-        turn_context_history, actions_player_can_take, system_prompt, user_prompt, pre_discussion_vote_prompts = turn_context_result
+        turn_context_history, actions_player_can_take, conversation, pre_discussion_vote_prompts = turn_context_result
 
         # Ensure available tasks match between replay and original game
         # The tasks are stored in the history item's tasks_left_to_do attribute

scripts/run_benchmark.py

@@ -34,7 +34,7 @@
 from among_them.models.action_type import ActionType  # type: ignore
 from among_them.models.player import Player  # type: ignore
 from among_them.game_jsonencoder import game_object_hook  # type: ignore
-from among_them.utils.prompt_utils import reconstruct_environment_prompt_from_history  # type: ignore
+from among_them.utils.prompt_utils import build_conversation_for_player  # type: ignore
 from among_them.utils.action_utils import get_task_phase_actions, get_vote_actions  # type: ignore
 from among_them.models.phase import GamePhase  # type: ignore
 from among_them.config import (  # type: ignore
@@ -69,10 +69,11 @@ def resolve_backend_model_name() -> str:
     return MODEL_NAME
 
 
-def try_reconstruct_full_prompt(example: Dict[str, Any], dataset_meta: Dict[str, Any]) -> Optional[str]:
-    """Reconstruct the full prompt from original game_state using example id and current_player.
+def try_reconstruct_conversation(example: Dict[str, Any], dataset_meta: Dict[str, Any]) -> Optional[List[dict]]:
+    """Reconstruct the conversation from original game_state using example id and current_player.
 
     Expects example['id'] like 'game_state_10.json:52' and example['current_player'].
+    Returns a conversation (list of message dicts) or None if reconstruction fails.
     """
     ex_id = example.get('id', '')
     if ':' not in ex_id:
@@ -128,17 +129,17 @@ def try_reconstruct_full_prompt(example: Dict[str, Any], dataset_meta: Dict[str,
 
     history_slice = history[: hist_idx + 1]
     try:
-        return reconstruct_environment_prompt_from_history(current_player_obj, history_slice, players, game_config)
+        return build_conversation_for_player(current_player_obj, history_slice, players, game_config)
     except Exception:
         return None
 
 
-def call_model_with_retry(full_prompt: str, exec_model_name: str, max_retries: int = 10) -> Tuple[str, Optional[str]]:
+def call_model_with_retry(conversation: List[dict], exec_model_name: str, max_retries: int = 10) -> Tuple[str, Optional[str]]:
     """Call invoke_llm with simple retry/backoff on rate-limit (429) errors."""
     last_err: Optional[Exception] = None
     for attempt in range(max_retries):
         try:
-            return invoke_llm(system_prompt="", prompt=full_prompt, model_name=exec_model_name, single_line_only=False)
+            return invoke_llm(conversation=conversation, model_name=exec_model_name, single_line_only=False)
         except Exception as e:
             last_err = e
             msg = str(e)
@@ -212,16 +213,19 @@ def run_example(example: Dict[str, Any], exec_model_name: str, dataset_meta: Dic
     """Run the model once on an example.
     Returns: (raw_output, chosen_idx, chosen_action_str)
     """
-    # Build prompts: we store full_prompt in the example; system prompt is included.
-    full_prompt = example.get('full_prompt', '')
-    if not full_prompt:
-        # Reconstruct from original game state if possible
-        full_prompt = try_reconstruct_full_prompt(example, dataset_meta) or ''
-    if not full_prompt:
-        raise ValueError(f"Example {example.get('id')} missing full_prompt")
-
-    # Our invoke_llm expects system_prompt and prompt; we pass system empty and put all into user prompt
-    response_text, cot = call_model_with_retry(full_prompt, exec_model_name)
+    # Try to get conversation from reconstruction first (returns List[dict])
+    conversation = try_reconstruct_conversation(example, dataset_meta)
+    
+    # Fall back to stored full_prompt (string) if reconstruction fails
+    if not conversation:
+        full_prompt = example.get('full_prompt', '')
+        if not full_prompt:
+            raise ValueError(f"Example {example.get('id')} missing full_prompt and cannot reconstruct")
+        # Convert string prompt to conversation format
+        conversation = [{"role": "user", "content": full_prompt}]
+
+    # Our invoke_llm expects conversation format
+    response_text, cot = call_model_with_retry(conversation, exec_model_name)
 
     actions = actions_from_strings(example.get('available_actions', []))
     if not actions:

src/among_them/game_engine.py

@@ -20,7 +20,6 @@
                                            get_players_in_room)
 from among_them.utils.end_utils import get_end_game_reason
 from among_them.utils.history_utils import initialize_history, create_system_message
-from among_them.utils.prompt_utils import reconstruct_environment_prompt_from_history
 from among_them.game_config import GameConfig
 
 class GameEngine:
@@ -44,7 +43,7 @@ def __init__(self, game_config: GameConfig = GameConfig(), file_path: Optional[s
         if file_path is not None:
             self.file_path = file_path
 
-    def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[History, List[Action], str, str, List[dict]]]:
+    def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[History, List[Action], List[dict], List[dict]]]:
         """Gathers all necessary context for the current player's turn.
 
         This method calculates everything needed for a turn up-front to avoid
@@ -56,8 +55,8 @@ def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[
         Returns:
             A tuple containing:
             - An incomplete History object representing the current turn's context.
-            - The system prompt for the LLM.
-            - The user prompt for the LLM.
+            - List of actions the player can take.
+            - The conversation history with the new user message appended (List[Dict]).
             - A list of pre-discussion vote prompts (empty if not in DISCUSS phase).
             Or None if the game is in a state that doesn't require player input.
         """
@@ -69,7 +68,7 @@ def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[
         # If game ended no further player input is required.
         if get_end_game_reason(self.history, self.players) is not None:
             print("Game over! {}".format(get_end_game_reason(self.history, self.players)))
-            return None, None, None, None, None
+            return None, None, None, None
 
         current_player, next_player_names = get_next_random_player(self.history, self.players)
 
@@ -104,7 +103,7 @@ def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[
             actions_player_can_take = get_vote_actions(self.history, self.players, current_player)
             location = Location.CAFETERIA
         else:
-            return None, None, None, None, None
+            return None, None, None, None
 
         # Create a placeholder action for the current player
         placeholder_action = Action(player_name=current_player.name, type=ActionType.SPEAK, target_message="placeholder")
@@ -127,12 +126,33 @@ def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[
             votes_before_this_discussion_message={},
         )
 
-        # Build new environment-like prompt
-        environment_prompt = reconstruct_environment_prompt_from_history(
+        # Build conversation history from existing turns + new user message
+        from among_them.utils.prompt_utils import build_conversation_for_player, get_initial_turn_prompt, get_incremental_observations
+        
+        # Get past conversation turns for this player
+        conversation = build_conversation_for_player(
             current_player, self.history, self.players, self.game_config
         )
-        system_prompt = ""  # System context is included in environment_prompt
-        user_prompt = environment_prompt
+        
+        # Find last turn index for this player to determine if this is first turn
+        player_turn_indices = [i for i, event in enumerate(self.history) if event.action_taken.player_name == current_player.name]
+        
+        # Generate new user message for current turn
+        if not player_turn_indices:
+            # First turn: include system prompt
+            new_user_msg = get_initial_turn_prompt(
+                current_player, self.history, self.players, self.game_config, len(self.history)
+            )
+        else:
+            # Subsequent turn: only incremental observations
+            last_turn_index = player_turn_indices[-1]
+            new_user_msg = get_incremental_observations(
+                current_player, self.history, self.players, self.game_config, 
+                last_turn_index, len(self.history)
+            )
+        
+        # Append new user message to conversation
+        conversation.append({"role": "user", "content": new_user_msg})
 
         pre_discussion_vote_prompts = []
         if phase == GamePhase.DISCUSS:
@@ -149,17 +169,38 @@ def get_turn_context(self, player_name: Optional[str] = None) -> Optional[tuple[
                         alive_player_names=alive_player_names,
                     )
                 )
-                voting_prompt = reconstruct_environment_prompt_from_history(
+                
+                # Build conversation for this player up to voting phase
+                voting_conversation = build_conversation_for_player(
                     player, fake_history, self.players, self.game_config
                 )
+                
+                # Find last turn for this player in fake_history
+                player_turn_indices = [i for i, event in enumerate(fake_history) if event.action_taken.player_name == player.name]
+                
+                # Generate voting prompt message
+                if not player_turn_indices:
+                    # First turn scenario (shouldn't happen in voting but handle it)
+                    voting_user_msg = get_initial_turn_prompt(
+                        player, fake_history, self.players, self.game_config, len(fake_history)
+                    )
+                else:
+                    last_turn_index = player_turn_indices[-1]
+                    voting_user_msg = get_incremental_observations(
+                        player, fake_history, self.players, self.game_config,
+                        last_turn_index, len(fake_history)
+                    )
+                
+                # Append the new voting message
+                voting_conversation.append({"role": "user", "content": voting_user_msg})
+                
                 pre_discussion_vote_prompts.append({
                     "player": player,
-                    "system_prompt": "",
-                    "user_prompt": voting_prompt,
+                    "conversation": voting_conversation,  # Now a conversation!
                     "actions": fake_voting_actions
                 })
 
-        return turn_history, actions_player_can_take, system_prompt, user_prompt, pre_discussion_vote_prompts
+        return turn_history, actions_player_can_take, conversation, pre_discussion_vote_prompts
 
     def step(self, turn_context: History, action_taken: Action, llm_response: str = "", llm_cot: str = "", token_usage: dict = {}, pre_discussion_votes: Optional[dict] = None) -> tuple[bool, Optional[EndGameReason]]:
         """Executes a single player action and updates the game state using pre-calculated context.

src/among_them/utils/llm_utils.py

@@ -6,36 +6,29 @@
 
 
 def invoke_llm(
-    system_prompt: str,
-    prompt: str,
+    conversation: List[dict],
     model_name: str,
     allowed_actions: Optional[List[str]] = None,
     single_line_only: bool = False,
     max_output_chars: Optional[int] = None,
 ) -> Tuple[str, Optional[str]]:
     """
-    Invoke the LLM with the given prompts and handle exceptions.
+    Invoke the LLM with the given conversation history and handle exceptions.
 
     Args:
-        system_prompt: The system prompt to use
-        prompt: The user prompt to send to the LLM
+        conversation: List of message dicts [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
         model_name: The model name to use
+        allowed_actions: Optional list of allowed actions for validation
+        single_line_only: Whether to enforce single-line responses
+        max_output_chars: Maximum output characters allowed
 
     Returns:
         Tuple of (response_text, chain_of_thought)
 
     Raises:
         ValueError: If no chain of thought is found in the response
     """
-    messages = [
-        {"role": "user", "content": system_prompt + "\n" + prompt},
-    ]
-
-    # Print chat history (ensure terminal color is reset beforehand)
-    print("\033[0m", end="")
-    print("\n\nChat history:\n")
-    for message in messages:
-        print(f"{message['role']}: {message['content']}")
+    messages = conversation
 
     raw = "<think>" if LLM_BACKEND == LLMBackend.MLX else ""
     raw_reasoning = ""