Simplified tool selection for ChessAgent

agent.py

@@ -9,7 +9,7 @@ from smolagents import LiteLLMModel, CodeAgent
 from smolagents import GoogleSearchTool, VisitWebpageTool, FinalAnswerTool
 from smolagents.local_python_executor import BASE_PYTHON_TOOLS
 from tools import GetTaskFileTool, VideoUnderstandingTool, AudioUnderstandingTool
-from tools import ChessPiecePlacementTool, ChessGameFenTool, BestChessMoveTool, ConvertChessMoveTool
+from tools import ChessBoardFENTool, BestChessMoveTool, ConvertChessMoveTool
 
 
 # Base tools may use these to process files
@@ -63,8 +63,7 @@ class ChessAgent:
             name="chess_player",
             description="Makes a chess move. Give it a query including board image filepath and player turn (black or white).",
             add_base_tools=False,
-            tools=[ChessPiecePlacementTool(),
-                   ChessGameFenTool(settings, OpenRouterModelID.GPT_O4_MINI),
+            tools=[ChessBoardFENTool(),
                    BestChessMoveTool(settings),
                    ConvertChessMoveTool(settings, OpenRouterModelID.QWEN_3_14B_FREE),
                    ],

tools.py

@@ -2,6 +2,7 @@ import os
 import json
 import logging
 logger = logging.getLogger(__name__)
+import re
 import requests
 import shutil
 from typing import Any
@@ -125,10 +126,12 @@ class ConvertChessMoveTool(BaseCustomTool):
         self.model = model
 
     def forward(self, piece_placement: str, move: str) -> str:
-        move_message = f"""Convert this chess move from coordinate notation to algebraic
-notation: {move}. Use the following {piece_placement}. Do not provide any additional
-thinking or commentary in the response, the algebraic notation only."""
-        messages = [{ "content": move_message,"role": "user"}]
+        move_message = (
+            f"Convert this chess move from coordinate notation to algebraic "
+            f"notation: {move}. Use the following {piece_placement}. Do not provide any additional "
+            "thinking or commentary in the response, the algebraic notation only."
+            )
+        messages = [{ "content": move_message, "role": "user"}]
         response = completion(
                     model=self.model, 
                     temperature=0.0,
@@ -158,45 +161,164 @@ class BestChessMoveTool(BaseCustomTool):
         except Exception as e:
             logger.error(f"Error getting chess evaluation: {e}")
 
-class ChessGameFenTool(BaseCustomTool):
-    name = "ChessGameFen"
-    description = "Get a FEN representation given chess piece placement and a move."
+class ChessBoardFENTool(Tool):
+    name = "ChessBoardFEN"
+    description = "Get the FEN representation from an image of a chess board and a player turn."
     inputs = {
-        "piece_placement": {"type": "string", "description": "The chess piece placement in plain text"},
+        "image_path": {"type": "string", "description": "The local file of the chess board image"},
         "player_turn": {"type": "string", 
-                        "description": "The player with the next turn in the match, black or white"},
+                "description": "The player with the next turn in the match, black or white"}
     }
     output_type = "string"
+    
+    def _expand_fen_rank(self, rank_str):
+        """
+        Expands a single rank string from FEN notation (e.g., 'p2b4')
+        into a list of 8 characters representing the squares.
+        Uses ' ' for empty squares.
+        """
+        expanded_rank = []
+        for char in rank_str:
+            if char.isdigit():
+                # Add number of empty squares specified by the digit
+                expanded_rank.extend([' '] * int(char))
+            else:
+                # Add the piece character
+                expanded_rank.append(char)
+        # Validate rank length
+        if len(expanded_rank) != 8:
+            raise ValueError(f"Invalid FEN rank string (length != 8): {rank_str}")
+        return expanded_rank
 
-    def __init__(self, settings, model):
-        super().__init__(settings)
-        self.model = model
+    def _compress_fen_rank(self, rank_list):
+        """
+        Compresses a list of 8 characters (representing a rank)
+        back into FEN rank notation (e.g., turns [' ', 'K', ...] into '1K6').
+        Assumes ' ' represents an empty square.
+        """
+        if len(rank_list) != 8:
+            raise ValueError(f"Invalid rank list (length != 8): {rank_list}")
 
-    def forward(self, piece_placement: str, player_turn: str) -> str:
-        """Use the tool."""
-        fen_message = f"""First, invert the FEN string making it (rank 1 at top) 
-and mirrored (file 'a' at right), but formatted according to the strict FEN 
-standard (reading from the top-left of the standard board layout). Then, 
-assuming {player_turn} has the next turn, Use the following placement
-{piece_placement} and provide the board state as FEN. Do not provide any
-additional thinking or commentary in the response, the FEN only."""
-        messages = [{ "content": fen_message,"role": "user"}]
-        response = completion(
-                    model=self.model,
-                    temperature=0.0,
-                    messages=messages,
-                    api_key=self.settings.openrouter_api_key.get_secret_value()
-                )
-        return response.choices[0].message.content
+        compressed_rank = ""
+        empty_count = 0
+        for char in rank_list:
+            if char == ' ':
+                empty_count += 1
+            else:
+                # If we encountered a piece after empty squares, add the count
+                if empty_count > 0:
+                    compressed_rank += str(empty_count)
+                    empty_count = 0
+                # Add the piece
+                compressed_rank += char
+        # If the rank ends with empty squares, add the final count
+        if empty_count > 0:
+            compressed_rank += str(empty_count)
+        return compressed_rank
 
-class ChessPiecePlacementTool(Tool):
-    name = "ChessPiecePlacement"
-    description = "Get chess piece placement information from an image of a board."
-    inputs = {
-        "image_path": {"type": "string", "description": "The local file of the chess board image"},
-    }
-    output_type = "string"
-    
-    def forward(self, image_path: str) -> str:
-        return get_fen_from_image_path(image_path)
+    def _invert_mirror_fen(self, fen_string):
+        """
+        Takes a FEN string, inverts the board vertically, mirrors it horizontally,
+        and returns the new FEN string representing this transformed view.
+        The other FEN fields (turn, castling, etc.) are preserved.
+        """
+        try:
+            # 1. Split FEN into parts
+            parts = fen_string.strip().split(' ')
+            if len(parts) != 6:
+                raise ValueError("FEN string must have 6 space-separated fields.")
+            board_part = parts[0]
+            other_parts = parts[1:] # Side-to-move, castling, ep, halfmove, fullmove
+
+            # 2. Parse the board part into an 8x8 representation
+            rank_strings = board_part.split('/')
+            if len(rank_strings) != 8:
+                raise ValueError("FEN board part must have 8 ranks separated by '/'.")
+
+            # original_board[0] corresponds to rank 8, original_board[7] to rank 1
+            original_board = [self._expand_fen_rank(r) for r in rank_strings]
+
+            # 3. Create a new empty 8x8 board for the transformed state
+            # Using ' ' as the placeholder for empty squares
+            transformed_board = [[' ' for _ in range(8)] for _ in range(8)]
+
+            # 4. Apply the inversion (vertical flip) and mirror (horizontal flip)
+            for r in range(8): # Iterate through original rows (ranks 8 down to 1)
+                for c in range(8): # Iterate through original columns (files a to h)
+                    # The piece at original [r][c] moves to transformed [7-r][7-c]
+                    transformed_board[7 - r][7 - c] = original_board[r][c]
+
+            # 5. Generate the new FEN board string from the transformed board
+            # Read ranks from top (index 0 = rank 8) to bottom (index 7 = rank 1)
+            new_rank_strings = [self._compress_fen_rank(row) for row in transformed_board]
+            new_board_part = "/".join(new_rank_strings)
+
+            # 6. Reassemble the full FEN string
+            return " ".join([new_board_part] + other_parts)
+
+        except Exception as e:
+            # Return error message if parsing or processing fails
+            return f"Error processing FEN: {e}. Input: '{fen_string}'"
+
+    def _add_fen_game_state(self, board_placement,
+                        side_to_move,
+                        castling="-",
+                        en_passant="-",
+                        halfmove_clock=0,
+                        fullmove_number=1):
+        """
+        Appends standard game state information to a FEN board placement string.
+
+        Args:
+            board_placement (str): The board layout part of the FEN string
+                                (e.g., "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR").
+            side_to_move (str): The active color ('w' for White, 'b' for Black).
+                                Case-insensitive, will be converted to lowercase.
+            castling (str, optional): Castling availability string (e.g., "KQkq", "-").
+                                    Defaults to "-".
+            en_passant (str, optional): En passant target square string (e.g., "e3", "-").
+                                        Defaults to "-".
+            halfmove_clock (int, optional): The number of halfmoves since the last
+                                        capture or pawn advance. Defaults to 0.
+            fullmove_number (int, optional): The number of the full move. Starts at 1
+                                        and increments after Black's move. Defaults to 1.
+
+        Returns:
+            str: The complete FEN string including the game state,
+                or an error message string if inputs are invalid.
+        """
+        # Validate side_to_move
+        side_to_move_lower = str(side_to_move).lower()
+        if side_to_move_lower not in ['w', 'b']:
+            return f"Error: side_to_move must be 'w' or 'b', received '{side_to_move}'"
+
+        # Validate clock values (should be non-negative integers, fullmove >= 1)
+        try:
+            halfmove_clock = int(halfmove_clock)
+            fullmove_number = int(fullmove_number)
+            if halfmove_clock < 0:
+                raise ValueError("halfmove_clock cannot be negative.")
+            if fullmove_number < 1:
+                raise ValueError("fullmove_number must be 1 or greater.")
+        except (ValueError, TypeError):
+            return (f"Error: halfmove_clock ('{halfmove_clock}') and "
+                    f"fullmove_number ('{fullmove_number}') must be valid integers "
+                    f"(non-negative and positive respectively).")
+
+        # Assemble the full FEN string using the validated/defaulted values
+        # Note: castling and en_passant strings are used directly as passed or defaulted.
+        # More complex validation could be added for them if needed.
+        full_fen = (f"{board_placement} {side_to_move_lower} {castling} "
+                    f"{en_passant} {halfmove_clock} {fullmove_number}")
+
+        return full_fen
+
+    def forward(self, image_path: str, player_turn: str) -> str:
+        board_placement = get_fen_from_image_path(image_path)
+        
+        #  Inversion makes board_to_fen output Stockfish compatible
+        board_fen = self._add_fen_game_state(board_placement, player_turn)
+        board_fen_inverted = self._invert_mirror_fen(board_fen) 
+        
+        return board_fen_inverted