Update app.py

app.py

@@ -650,7 +650,7 @@ def analyze_image(file_path: str, query: str) -> str:
         
         # Use Gemini Vision
         vision_llm = ChatGoogleGenerativeAI(
-            model="gemini-2.0-flash-exp",
+            model="gemini-2.0-flash",
             google_api_key=GOOGLE_API_KEY,
             temperature=0
         )
@@ -816,22 +816,22 @@ class ChessAnalysisInput(BaseModel):
     image_path: str = Field(description="Path to chess board image file")
     description: str = Field(description="Any additional context about the position (optional)", default="")
 
-@tool(args_schema=ChessAnalysisInput)
 def analyze_chess_position(image_path: str, description: str = "") -> str:
     """
-    Analyzes a chess position from an image and returns the best move.
+    Analyzes a chess position from an image using Stockfish engine.
+    
+    MUCH MORE RELIABLE than Lichess API because:
+    - Works offline
+    - Analyzes ANY position (not just cloud database)
+    - Stronger engine (Stockfish 16+)
+    - No rate limits or 404 errors
     
     Use this tool when:
     - Question mentions chess, checkmate, or chess notation
     - An image file shows a chess board
     - Need to find the best move in a position
     
-    The tool will:
-    1. Extract the position from the image using Gemini Vision
-    2. Analyze it using Lichess cloud API
-    3. Return the best move in algebraic notation (e.g., "Qh5" or "Nf6")
-    
-    Example: analyze_chess_position(image_path="/tmp/chess_board.png")
+    Returns: Best move in algebraic notation (e.g., "Qh5", "Nf6+", "Rd5")
     """
     if not image_path:
         return "Error: image_path is required."
@@ -841,7 +841,7 @@ def analyze_chess_position(image_path: str, description: str = "") -> str:
     # Find the file
     chess_image = find_file(image_path)
     
-    # If not found via find_file, try direct path (for /tmp files on HF)
+    # If not found via find_file, try direct path
     if not chess_image and os.path.exists(image_path):
         chess_image = Path(image_path)
     
@@ -851,188 +851,212 @@ def analyze_chess_position(image_path: str, description: str = "") -> str:
     print(f"✓ Found chess image at: {chess_image}")
     
     try:
-        # Step 1: Extract FEN notation from image using Gemini
+        # ====================================================================
+        # STEP 1: Extract FEN notation from image using Gemini Vision
+        # ====================================================================
         GOOGLE_API_KEY = os.getenv("GEMINI_API_KEY")
         if not GOOGLE_API_KEY:
             return "Error: GEMINI_API_KEY not set in Space secrets."
         
         print("📸 Extracting chess position from image using Gemini...")
         
-        try:
-            # Load image
-            img = Image.open(chess_image)
-            print(f"   Image loaded: {img.size}, mode: {img.mode}")
-            
-            # Convert to RGB if needed
-            if img.mode not in ['RGB', 'RGBA']:
-                img = img.convert('RGB')
-            
-            # Encode to base64
-            buffered = io.BytesIO()
-            img.save(buffered, format="JPEG")
-            img_base64 = base64.b64encode(buffered.getvalue()).decode()
-            
-            # Use Gemini Vision to extract FEN
-            vision_llm = ChatGoogleGenerativeAI(
-                model="gemini-2.0-flash",
-                google_api_key=GOOGLE_API_KEY,
-                temperature=0
-            )
-            
-            fen_prompt = """Analyze this chess board image and provide the position in FEN notation.
+        # Load and encode image
+        img = Image.open(chess_image)
+        print(f"   Image loaded: {img.size}, mode: {img.mode}")
+        
+        if img.mode not in ['RGB', 'RGBA']:
+            img = img.convert('RGB')
+        
+        buffered = io.BytesIO()
+        img.save(buffered, format="JPEG")
+        img_base64 = base64.b64encode(buffered.getvalue()).decode()
+        
+        # Use Gemini Vision to extract FEN
+        vision_llm = ChatGoogleGenerativeAI(
+            model="gemini-2.0-flash-exp",
+            google_api_key=GOOGLE_API_KEY,
+            temperature=0
+        )
+        
+        fen_prompt = """Analyze this chess board image and provide the position in FEN notation.
 
 CRITICAL INSTRUCTIONS:
-1. Carefully identify each piece (uppercase for White: K, Q, R, B, N, P; lowercase for Black: k, q, r, b, n, p)
+1. Carefully identify each piece:
+   - White pieces (UPPERCASE): K=King, Q=Queen, R=Rook, B=Bishop, N=Knight, P=Pawn
+   - Black pieces (lowercase): k, q, r, b, n, p
+
 2. Read the board from rank 8 (top) to rank 1 (bottom), left to right
+   - Use numbers (1-8) for consecutive empty squares
+   - Use '/' to separate ranks
+
 3. Determine whose turn it is:
-   - If text says "Black to move" or "Black's turn" → use 'b'
-   - If text says "White to move" or "White's turn" → use 'w'
-   - If no indication, analyze the position and make your best guess
-4. Return ONLY the FEN string in this exact format:
-   piece_placement active_color castling en_passant halfmove fullmove
+   - Look for text like "Black to move" or "White to move"
+   - If unclear, analyze the position context
+   - Return 'w' for white, 'b' for black
 
-Example FEN: rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
+4. Return ONLY the FEN string in this format:
+   piece_placement active_color castling en_passant halfmove fullmove
 
-For piece placement:
-- Use numbers for empty squares (1-8)
-- Use '/' to separate ranks
-- White pieces: UPPERCASE (K, Q, R, B, N, P)
-- Black pieces: lowercase (k, q, r, b, n, p)
+Example: rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
 
 Return ONLY the FEN string, nothing else."""
-
-            message = HumanMessage(
-                content=[
-                    {"type": "text", "text": fen_prompt},
-                    {
-                        "type": "image_url",
-                        "image_url": f"data:image/jpeg;base64,{img_base64}"
-                    }
-                ]
+        
+        message = HumanMessage(
+            content=[
+                {"type": "text", "text": fen_prompt},
+                {
+                    "type": "image_url",
+                    "image_url": f"data:image/jpeg;base64,{img_base64}"
+                }
+            ]
+        )
+        
+        response = vision_llm.invoke([message])
+        fen_raw = response.content.strip()
+        print(f"📝 Raw FEN response: {fen_raw}")
+        
+        # Clean up FEN (remove markdown, explanations, etc.)
+        fen = None
+        for line in fen_raw.split('\n'):
+            line = line.strip().replace('```', '').replace('fen', '')
+            # FEN should have '/' for ranks and spaces for components
+            if '/' in line and ' ' in line and not line.startswith('#'):
+                if any(c in line for c in 'kqrbnpKQRBNP12345678'):
+                    fen = line
+                    break
+        
+        if not fen:
+            return f"Error: Could not extract valid FEN notation from image. Response: {fen_raw[:200]}"
+        
+        print(f"✓ Extracted FEN: {fen}")
+        
+        # ====================================================================
+        # STEP 2: Validate FEN with python-chess
+        # ====================================================================
+        try:
+            import chess
+        except ImportError:
+            return "Error: python-chess not installed. Add 'python-chess' to requirements.txt"
+        
+        try:
+            board = chess.Board(fen)
+            print(f"✓ FEN validated successfully")
+            print(f"   Turn: {'White' if board.turn else 'Black'}")
+            print(f"   Legal moves: {board.legal_moves.count()}")
+        except ValueError as e:
+            return f"Error: Invalid FEN notation: {e}\nExtracted FEN: {fen}"
+        
+        # ====================================================================
+        # STEP 3: Analyze with Stockfish
+        # ====================================================================
+        print("🔍 Analyzing position with Stockfish...")
+        
+        try:
+            from stockfish import Stockfish
+        except ImportError:
+            return "Error: stockfish not installed. Add 'stockfish' to requirements.txt and install Stockfish binary"
+        
+        # Try to find Stockfish binary
+        stockfish_paths = [
+            "/usr/games/stockfish",      # Linux (apt-get install)
+            "/usr/local/bin/stockfish",  # Mac (brew install)
+            "/usr/bin/stockfish",        # Alternative Linux
+            "stockfish",                 # In PATH
+            "./stockfish",               # Local directory
+            "C:\\Program Files\\stockfish\\stockfish.exe"  # Windows
+        ]
+        
+        stockfish_path = None
+        for path in stockfish_paths:
+            if os.path.exists(path) or os.path.isfile(path):
+                stockfish_path = path
+                break
+        
+        if not stockfish_path:
+            # Try running 'which stockfish' on Unix systems
+            try:
+                import subprocess
+                result = subprocess.run(['which', 'stockfish'], 
+                                       capture_output=True, 
+                                       text=True, 
+                                       timeout=5)
+                if result.returncode == 0:
+                    stockfish_path = result.stdout.strip()
+            except:
+                pass
+        
+        if not stockfish_path:
+            return """Error: Stockfish binary not found. Install it:
+- Linux: sudo apt-get install stockfish
+- Mac: brew install stockfish  
+- Windows: Download from stockfishchess.org
+Or set the path manually in the code."""
+        
+        print(f"✓ Found Stockfish at: {stockfish_path}")
+        
+        # Initialize Stockfish
+        try:
+            stockfish = Stockfish(
+                path=stockfish_path,
+                depth=20,  # Analysis depth (higher = stronger but slower)
+                parameters={
+                    "Threads": 2,
+                    "Minimum Thinking Time": 500,  # milliseconds
+                    "Hash": 512,  # MB of RAM
+                }
             )
-            
-            response = vision_llm.invoke([message])
-            fen_raw = response.content.strip()
-            
-            print(f"📝 Raw FEN response: {fen_raw}")
-            
-            # Clean up FEN (remove markdown, explanations, etc.)
-            fen = None
-            fen_lines = fen_raw.split('\n')
-            
-            for line in fen_lines:
-                line = line.strip()
-                # Remove markdown code fences
-                line = line.replace('```', '').replace('fen', '').strip()
-                
-                # FEN should have '/' for ranks and spaces for components
-                if '/' in line and ' ' in line and not line.startswith('#'):
-                    # Basic validation: should have pieces or numbers, slashes, and spaces
-                    if any(c in line for c in 'kqrbnpKQRBNP12345678'):
-                        fen = line
-                        break
-            
-            if not fen:
-                # Try to extract from any line with slash and space
-                for line in fen_lines:
-                    if '/' in line and ' ' in line:
-                        fen = line.strip()
-                        break
-            
-            if not fen:
-                return f"Error: Could not extract valid FEN notation from image. Gemini response: {fen_raw[:200]}"
-            
-            print(f"✓ Extracted FEN: {fen}")
-            
         except Exception as e:
-            return f"Error extracting position from image: {str(e)}\n{traceback.format_exc()}"
+            return f"Error initializing Stockfish: {e}"
+        
+        # Set position
+        stockfish.set_fen_position(fen)
+        
+        # Get best move
+        print("   Computing best move...")
+        best_move_uci = stockfish.get_best_move()
+        
+        if not best_move_uci:
+            return "Error: Stockfish could not find a legal move. Check if position is valid."
+        
+        print(f"🎯 Best move (UCI): {best_move_uci}")
+        
+        # Get evaluation
+        evaluation = stockfish.get_evaluation()
+        eval_type = evaluation.get("type", "cp")
+        eval_value = evaluation.get("value", 0)
         
-        # Step 2: Analyze position using Lichess cloud API
-        print("🔍 Analyzing position with Lichess cloud engine...")
+        if eval_type == "mate":
+            eval_str = f" (Mate in {abs(eval_value)})"
+        else:
+            # Centipawns to pawns
+            eval_str = f" (Eval: {eval_value/100:+.2f})"
         
+        # ====================================================================
+        # STEP 4: Convert UCI to Standard Algebraic Notation (SAN)
+        # ====================================================================
         try:
-            # Try python-chess for better move notation (optional)
-            try:
-                import chess
-                use_python_chess = True
-                print("✓ Using python-chess for move conversion")
-            except ImportError:
-                use_python_chess = False
-                print("⚠️ python-chess not available, using UCI notation")
-            
-            # Query Lichess cloud evaluation
-            lichess_url = "https://lichess.org/api/cloud-eval"
-            params = {
-                "fen": fen.strip(),
-                "multiPv": 1  # Get only the best move
-            }
-            
-            response = requests.get(lichess_url, params=params, timeout=15)
-            
-            if response.status_code != 200:
-                return f"Error: Lichess API returned status {response.status_code}. Position may not be in cloud database."
-            
-            data = response.json()
-            print(f"📊 Lichess response: {data}")
-            
-            # Extract best move
-            if "pvs" not in data or len(data["pvs"]) == 0:
-                return "Error: Position not found in Lichess cloud database. Try a different position or check if the FEN is valid."
-            
-            best_pv = data["pvs"][0]
-            moves = best_pv.get("moves", "").split()
+            uci_move = chess.Move.from_uci(best_move_uci)
+            san_move = board.san(uci_move)
+            
+            # Check if move leads to check/checkmate
+            board.push(uci_move)
+            if board.is_checkmate():
+                check_str = " - Checkmate!"
+            elif board.is_check():
+                check_str = " - Check"
+            else:
+                check_str = ""
             
-            if not moves:
-                return "Error: No moves found in Lichess analysis."
+            final_result = f"{san_move}{eval_str}{check_str}"
+            print(f"✅ Best move: {final_result}")
             
-            best_move_uci = moves[0]
-            print(f"🎯 Best move (UCI): {best_move_uci}")
+            # Return JUST the move notation for clean submission
+            return san_move
             
-            # Convert UCI to Standard Algebraic Notation (SAN)
-            if use_python_chess:
-                try:
-                    board = chess.Board(fen)
-                    uci_move = chess.Move.from_uci(best_move_uci)
-                    san_move = board.san(uci_move)
-                    
-                    # Get evaluation
-                    cp = best_pv.get("cp")  # centipawns
-                    mate = best_pv.get("mate")  # mate in X moves
-                    
-                    if mate is not None:
-                        eval_str = f" (Mate in {abs(mate)})"
-                    elif cp is not None:
-                        eval_str = f" (Eval: {cp/100:+.2f})"
-                    else:
-                        eval_str = ""
-                    
-                    # Check if move leads to check/checkmate
-                    board.push(uci_move)
-                    if board.is_checkmate():
-                        check_str = " - Checkmate!"
-                    elif board.is_check():
-                        check_str = " - Check"
-                    else:
-                        check_str = ""
-                    
-                    final_result = f"{san_move}{eval_str}{check_str}"
-                    print(f"✅ Best move: {final_result}")
-                    return final_result
-                    
-                except Exception as e:
-                    print(f"⚠️ Could not convert to SAN: {e}")
-                    # Fall back to UCI notation
-                    return best_move_uci
-            else:
-                # Return UCI notation if python-chess not available
-                return best_move_uci
-                
-        except requests.Timeout:
-            return "Error: Lichess API request timed out. Try again."
-        except requests.RequestException as e:
-            return f"Error querying Lichess API: {str(e)}"
         except Exception as e:
-            return f"Error analyzing position: {str(e)}\n{traceback.format_exc()}"
+            print(f"⚠️ Could not convert to SAN: {e}")
+            # Fall back to UCI notation
+            return best_move_uci
             
     except Exception as e:
         error_msg = f"Chess analysis failed: {str(e)}"