Allow !include in yaml files

Author: klieret

.pre-commit-config.yaml

@@ -7,7 +7,7 @@ repos:
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
-      - id: check-yaml
+      # - id: check-yaml
       - id: check-added-large-files
       - id: check-merge-conflict
       - id: debug-statements

codeclash/agents/minisweagent.py

@@ -4,19 +4,17 @@
 import traceback
 from collections.abc import Callable
 from dataclasses import asdict
-from pathlib import Path
 
-import yaml
 from jinja2 import Template
 from minisweagent import Model
 from minisweagent.agents.default import AgentConfig, DefaultAgent
 from minisweagent.environments.docker import DockerEnvironment
-from minisweagent.models.litellm_model import LitellmModel
+from minisweagent.models import get_model
 from minisweagent.run.utils.save import save_traj
 from rich.console import Console
 
 from codeclash.agents.abstract import Player
-from codeclash.agents.utils import GameContext, resolve_api_key
+from codeclash.agents.utils import GameContext
 from codeclash.utils.environment import copy_to_container
 
 
@@ -71,16 +69,14 @@ def __init__(self, config: dict, environment: DockerEnvironment, game_context: G
         super().__init__(config, environment=environment, game_context=game_context)
 
     def run(self):
+        model = get_model(config=self.config["config"]["model"])
         self.agent = ClashAgent(
-            LitellmModel(
-                model_name=self.config["model"],
-                model_kwargs={"api_key": resolve_api_key(self.config["model"])},
-            ),
-            self.environment,
-            self.name,
-            self.game_context,
+            model=model,
+            env=self.environment,
+            name=self.name,
+            game_context=self.game_context,
             logger=self.logger,
-            **yaml.safe_load(Path(self.config["config"]).read_text())["agent"],
+            **self.config["config"]["agent"],
         )
         exit_status = None
         result = None

codeclash/agents/utils.py

@@ -1,4 +1,3 @@
-import os
 from pathlib import Path
 
 from dotenv import load_dotenv
@@ -8,14 +7,6 @@
 load_dotenv()
 
 
-def resolve_api_key(model: str) -> str:
-    if "claude" in model:
-        return os.getenv("ANTHROPIC_API_KEY")
-    if "gpt" in model:
-        return os.getenv("OPENAI_API_KEY")
-    return ""
-
-
 class GameContext(BaseModel):
     """
     A class that gives agent access to a partial view of the game state.

codeclash/tournaments/single_player.py

@@ -10,7 +10,7 @@
 from codeclash.agents.utils import GameContext
 from codeclash.constants import DIR_WORK
 from codeclash.games import get_game
-from codeclash.games.abstract import CodeGame
+from codeclash.games.abstract import CodeGame, RoundRecord
 from codeclash.tournaments.abstract import AbstractTournament
 from codeclash.tournaments.utils.git_utils import filter_git_diff
 from codeclash.utils.environment import copy_to_container
@@ -31,7 +31,7 @@ def __init__(self, config: dict, *, cleanup: bool = False):
         self.mirror_agent: Player = self.get_agent(mirror_agent_config, round=0)
 
     @property
-    def scoreboard(self) -> list[tuple[int, str]]:
+    def scoreboard(self) -> list[tuple[int, RoundRecord]]:
         return self._metadata.setdefault("scoreboard", [])
 
     @property
@@ -90,18 +90,19 @@ def run_training_round(self, round_num: int) -> None:
         record = self.game.run_round([self.agent, self.mirror_agent])
 
         # Handle bookkeeping that was previously in the game
-        self.scoreboard.append(record.stats)
+        self.scoreboard.append((round_num, record))
         self.logger.info(f"Round {round_num}:\n{record.stats}")
 
         # Write log to file
-        for idx, lo in enumerate(record.logs):
+        for idx, lo in enumerate(record.data.logs):
             round_log_path = self.game.log_local / f"round_{round_num}" / f"sim_{idx}.log"
+            round_log_path.parent.mkdir(parents=True, exist_ok=True)
             round_log_path.write_text(lo)
 
         # Copy log to main agent environment only
         self.logger.info(f"Copying round {round_num} log(s) to {self.agent.name}'s container...")
         copy_to_container(
-            self.agent,
+            self.agent.environment,
             self.game.log_local / f"round_{round_num}",
             f"logs/round_{round_num}/",
         )

codeclash/utils/yaml_utils.py

@@ -0,0 +1,55 @@
+import re
+from pathlib import Path
+
+
+def resolve_includes(yaml_content: str, *, base_dir: Path = Path(".")) -> str:
+    """Pre-process YAML content to resolve all !include directives.
+    This will take the yaml content as a string and return the same string with all
+    !include directives resolved.
+
+    The reason we don't go with pyyaml-include or similar options is that they don't
+    support merge keys, see https://github.com/tanbro/pyyaml-include/issues/53 .
+    """
+
+    def include_replacer(match):
+        indentation = match.group(1)  # Capture the indentation
+        prefix = match.group(2)  # What comes before !include (like "<<: " or "key: ")
+        include_path = match.group(3)
+        full_path = base_dir / include_path
+
+        included_content = full_path.read_text().strip()
+
+        # Handle merge key specially
+        if prefix.strip() == "<<:":
+            # For merge keys, include the content with proper indentation
+            if indentation:
+                included_lines = included_content.splitlines()
+                indented_lines = [indentation + line if line.strip() else line for line in included_lines]
+                return indentation + "<<:\n" + "\n".join(indented_lines)
+            else:
+                # Indent the included content by 2 spaces for proper merge format
+                included_lines = included_content.splitlines()
+                indented_lines = ["  " + line if line.strip() else line for line in included_lines]
+                return "<<:\n" + "\n".join(indented_lines)
+        else:
+            # For regular includes, we need to handle indentation properly
+            # If the prefix ends with ': ', we need to add a newline and indent the content
+            if prefix.strip().endswith(":"):
+                # Calculate the indentation for the included content
+                content_indent = indentation + "  "  # Add 2 spaces for proper YAML nesting
+                included_lines = included_content.splitlines()
+                indented_lines = [content_indent + line if line.strip() else line for line in included_lines]
+                return indentation + prefix.strip() + "\n" + "\n".join(indented_lines)
+            else:
+                # For cases where it's not a key assignment, just replace with content
+                return indentation + prefix + included_content
+
+    # Pattern to match !include directives with proper capture groups
+    # Group 1: indentation, Group 2: prefix (like "<<: " or "key: "), Group 3: file path
+    include_pattern = r"^(\s*)(.*?)!include\s+(.+)$"
+
+    # Keep resolving includes until no more are found
+    while re.search(include_pattern, yaml_content, re.MULTILINE):
+        yaml_content = re.sub(include_pattern, include_replacer, yaml_content, flags=re.MULTILINE)
+
+    return yaml_content

configs/battlesnake.yaml

@@ -8,12 +8,14 @@ game:
 tournament:
   rounds: 2
 players:
-- agent: mini
-  name: p1
-  config: configs/mini/default.yaml
-  model: openai/gpt-5-mini
-- agent: dummy
-  name: p2
+  - agent: mini
+    name: p1
+    config:
+      agent: !include mini/default.yaml
+      model:
+        model_name: openai/gpt-5-mini
+  - agent: dummy
+    name: p2
 prompts:
   game_description: |
     You are a software developer ({{player_id}}) competing in a coding game called BattleSnake.

configs/battlesnake_single_player.yaml

@@ -10,9 +10,11 @@ tournament:
   evaluate_matrix: true
 player:
   agent: mini
-  config: configs/mini/default.yaml
-  model: openai/gpt-5-mini
   name: main
+  config:
+    agent: !include mini/default.yaml
+    model:
+      model_name: openai/gpt-5-mini
 prompts:
   game_description: |
     You are a software developer ({{player_id}}) competing in a coding game called BattleSnake.