Update app.py

app.py

@@ -602,51 +602,51 @@ def validate_answer(proposed_answer: str, original_question: str = "") -> str:
     start_time = time.time()
     
     try:
-        print(f"✓ Validating: '{answer[:50]}...'")
-        
+        print(f"✓ Validating: '{proposed_answer[:50]}...'")
+
         warnings = []
         errors = []
         normalization_needed = []
-        
+
         # Normalize for validation
-        normalized = normalize_answer(answer)
-        
-        if normalized != answer:
+        normalized = normalize_answer(proposed_answer)
+
+        if normalized != proposed_answer:
             normalization_needed.append(f"Consider using normalized form: '{normalized}'")
-        
+
         # Check 1: Empty answer
-        if not answer or not answer.strip():
+        if not proposed_answer or not proposed_answer.strip():
             errors.append("Answer is empty")
-        
+
         # Check 2: Too long (probably explaining instead of answering)
-        if len(answer) > 200:
+        if len(proposed_answer) > 200:
             warnings.append("Answer is very long (>200 chars). Consider if question asks for brief response.")
-        
+
         # Check 3: Contains question words
         question_words = ['what', 'who', 'when', 'where', 'why', 'how', 'which']
-        if any(word in answer.lower() for word in question_words):
+        if any(word in proposed_answer.lower() for word in question_words):
             warnings.append("Answer contains question words. Make sure you're providing the answer, not rephrasing the question.")
-        
+
         # Check 4: List ordering
-        if "," in answer:
-            items = [item.strip() for item in answer.split(",")]
+        if "," in proposed_answer:
+            items = [item.strip() for item in proposed_answer.split(",")]
             if len(items) > 1:
                 warnings.append(f"List detected with {len(items)} items. Verify order matches question requirements.")
-        
+
         # Check 5: Capitalization consistency
-        if answer.lower() in ['right', 'left', 'yes', 'no', 'true', 'false']:
-            if not answer[0].isupper():
-                normalization_needed.append(f"Consider capitalizing: '{answer.capitalize()}'")
-        
+        if proposed_answer.lower() in ['right', 'left', 'yes', 'no', 'true', 'false']:
+            if not proposed_answer[0].isupper():
+                normalization_needed.append(f"Consider capitalizing: '{proposed_answer.capitalize()}'")
+
         # Check 6: Abbreviations
-        if any(abbrev in answer.lower() for abbrev in ['st.', 'dr.', 'mt.']):
-            if "without abbreviations" in str(answer).lower() or "full" in str(answer).lower():
+        if any(abbrev in proposed_answer.lower() for abbrev in ['st.', 'dr.', 'mt.']):
+            if "without abbreviations" in str(proposed_answer).lower() or "full" in str(proposed_answer).lower():
                 warnings.append("Question may ask for full form without abbreviations")
-        
+
         # Check 7: Spacing in lists
-        if "," in answer:
+        if "," in proposed_answer:
             # Check for inconsistent spacing
-            if ", " in answer and "," in answer.replace(", ", ""):
+            if ", " in proposed_answer and "," in proposed_answer.replace(", ", ""):
                 normalization_needed.append("Inconsistent spacing in list. Use consistent ', ' format")
         
         # Build result
@@ -1115,7 +1115,7 @@ Generated Analysis Code:
 **IMPORTANT**: The code above needs column names adjusted. 
 Use code_interpreter() with the corrected code to get the answer.
 
-Columns available: {", ".join(pd.read_csv(data_file) if file_ext == '.csv' else pd.read_excel(data_file)).columns.tolist()}
+Columns available: {", ".join((pd.read_csv(data_file) if file_ext == '.csv' else pd.read_excel(data_file)).columns.tolist())}
 """
         
         telemetry.record_call("analyze_data_file", time.time() - start_time, True)
@@ -1271,30 +1271,30 @@ class ChessAnalysisInput(BaseModel):
     description: str = Field(description="Context about position", default="")
 
 @tool(args_schema=ChessAnalysisInput)
-def analyze_chess_position(file_path: str) -> str:
+def analyze_chess_position(image_path: str, description: str = "") -> str:
     """
     Analyze chess position from image using Gemini Vision + Stockfish.
     Extracts FEN, analyzes best move.
     """
     start_time = time.time()
-    
+
     try:
-        print(f"♟️ Analyzing chess: {file_path}")
-        
+        print(f"♟️ Analyzing chess: {image_path}")
+
         # Find file
-        image_path = find_file(file_path)
-        if not image_path and os.path.exists(file_path):
-            image_path = Path(file_path)
-        
-        if not image_path or not image_path.exists():
-            raise FileNotFoundError(f"Image not found: {file_path}")
+        image_path_obj = find_file(image_path)
+        if not image_path_obj and os.path.exists(image_path):
+            image_path_obj = Path(image_path)
+
+        if not image_path_obj or not image_path_obj.exists():
+            raise FileNotFoundError(f"Image not found: {image_path}")
         
         GOOGLE_API_KEY = os.getenv("GEMINI_API_KEY")
         if not GOOGLE_API_KEY:
             raise ValueError("GEMINI_API_KEY not set")
         
         # Read image as base64
-        with open(image_path, "rb") as f:
+        with open(image_path_obj, "rb") as f:
             image_data = base64.b64encode(f.read()).decode("utf-8")
         
         # Use Gemini to extract FEN
@@ -1431,7 +1431,7 @@ def analyze_image(file_path: str, query: str) -> str:
         message = HumanMessage(
             content=[
                 {"type": "text", "text": query},
-                {"type": "image_url", "image_url": f"data:image/jpeg;base64,{img_base64}"}
+                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"}}
             ]
         )
         
@@ -1885,38 +1885,33 @@ def analyze_video(file_path: str, query: str) -> str:
         GOOGLE_API_KEY = os.getenv("GEMINI_API_KEY")
         if not GOOGLE_API_KEY:
             raise ValueError("GEMINI_API_KEY not set")
-        
-        # Read video as base64
-        print(f"   Reading video file...")
-        with open(video_path, "rb") as f:
-            video_data = base64.b64encode(f.read()).decode("utf-8")
-        
-        # Use Gemini via LangChain
+
+        # Use Google GenAI SDK directly — LangChain wrapper doesn't support video_url
+        import google.generativeai as genai
+        genai.configure(api_key=GOOGLE_API_KEY)
+
+        print(f"   Uploading video to Gemini Files API...")
+        video_file = genai.upload_file(str(video_path))
+
+        # Poll until processing is complete
+        import time as _time
+        while video_file.state.name == "PROCESSING":
+            _time.sleep(2)
+            video_file = genai.get_file(video_file.name)
+
+        if video_file.state.name == "FAILED":
+            raise RuntimeError(f"Gemini file processing failed: {video_file.state}")
+
         print(f"   Analyzing with Gemini...")
-        llm = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash",
-            google_api_key=GOOGLE_API_KEY,
-            temperature=0
-        )
-        
-        # Create message with video
-        message = HumanMessage(
-            content=[
-                {
-                    "type": "text",
-                    "text": query
-                },
-                {
-                    "type": "video_url",
-                    "video_url": {
-                        "url": f"data:video/mp4;base64,{video_data}"
-                    }
-                }
-            ]
-        )
-        
-        response = llm.invoke([message])
-        result = response.content
+        model = genai.GenerativeModel("gemini-2.5-flash")
+        response = model.generate_content([query, video_file])
+        result = response.text
+
+        # Clean up uploaded file
+        try:
+            genai.delete_file(video_file.name)
+        except Exception:
+            pass
         
         print(f"✓ Analysis complete: {len(result)} chars")
         
@@ -2364,28 +2359,40 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
             Keeps system message + recent history to stay under token limits.
             """
             messages = state.get("messages", [])
-            
+
             # Keep first message (system prompt) + last N messages
-            MAX_MESSAGES = 20  # Adjust based on your needs
-            
+            MAX_MESSAGES = 20
+            # ~6000 token limit on Groq; system msg ~3000 chars leaves ~18000 for the rest
+            MAX_TOOL_CONTENT = 1500
+
+            # Prune by count
             if len(messages) > MAX_MESSAGES:
                 print(f"⚠️ Context pruning: {len(messages)} messages → {MAX_MESSAGES}")
-                
-                # Always keep system message (if it exists)
+
                 system_msg = None
                 if messages and isinstance(messages[0], SystemMessage):
                     system_msg = messages[0]
                     messages = messages[1:]
-                
-                # Keep only recent messages
+
                 recent_messages = messages[-(MAX_MESSAGES-1):]
-                
-                # Reconstruct
+
                 if system_msg:
-                    state["messages"] = [system_msg] + recent_messages
+                    messages = [system_msg] + recent_messages
                 else:
-                    state["messages"] = recent_messages
-            
+                    messages = recent_messages
+
+            # Truncate oversized tool outputs to prevent 413 errors
+            pruned = []
+            for msg in messages:
+                if isinstance(msg, ToolMessage) and len(msg.content) > MAX_TOOL_CONTENT:
+                    msg = ToolMessage(
+                        content=msg.content[:MAX_TOOL_CONTENT] + "...[truncated]",
+                        tool_call_id=msg.tool_call_id,
+                        name=msg.name
+                    )
+                pruned.append(msg)
+
+            state["messages"] = pruned
             return state
         
         # Build agent graph
@@ -2468,23 +2475,60 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
                     print(f"⚠️ Groq error (attempt {attempt+1}): {error_str[:200]}")
                     
                     # ===== IMPROVED RATE LIMIT HANDLING =====
-                    # Check for rate limit FIRST
+                    # Context too large — truncate aggressively and retry immediately
+                    if "413" in error_str or "request too large" in error_str.lower():
+                        print("❌ Request too large (413) - aggressively pruning context")
+                        # Keep system message + last 4 messages, truncate tool content to 1000 chars
+                        pruned = []
+                        for msg in messages_to_send:
+                            if isinstance(msg, SystemMessage):
+                                pruned.append(msg)
+                                break
+                        pruned += messages_to_send[-4:]
+                        for msg in pruned:
+                            if isinstance(msg, ToolMessage) and len(msg.content) > 1000:
+                                msg = ToolMessage(
+                                    content=msg.content[:1000] + "...[truncated]",
+                                    tool_call_id=msg.tool_call_id,
+                                    name=msg.name
+                                )
+                        messages_to_send = pruned
+                        print(f"   Pruned to {len(messages_to_send)} messages, retrying...")
+                        continue
+
+                    # Check for rate limit
                     if "429" in error_str or "rate limit" in error_str.lower():
                         print("❌ Groq rate limit hit!")
-                        
+
                         if attempt < max_retries - 1:
                             wait = 10 * (2 ** attempt)  # 10s, 20s, 40s
                             print(f"   Waiting {wait}s before retry...")
                             time.sleep(wait)
                             continue
-                        
-                        # FINAL FALLBACK: Force search_tool as safe default
-                        print("🔄 Final attempt failed - using search_tool fallback")
+
+                        # FINAL FALLBACK: If Claude is available use it, otherwise fail fast
+                        if self.claude_llm:
+                            print("🔄 Groq rate limit - switching to Claude fallback")
+                            self.llm_with_tools = self.claude_llm
+                            self.current_llm = "claude"
+                            try:
+                                ai_message = self.claude_llm.invoke(messages_to_send)
+                                break
+                            except Exception as claude_err:
+                                print(f"❌ Claude fallback also failed: {claude_err}")
+
+                        # No LLM available — extract question and do one targeted search
+                        print("🔄 No LLM available - attempting targeted search fallback")
+                        question_text = ""
+                        for msg in state["messages"]:
+                            if isinstance(msg, HumanMessage) and msg.content:
+                                question_text = str(msg.content)[:200].strip()
+                                break
                         ai_message = AIMessage(
                             content="",
                             tool_calls=[ToolCall(
                                 name="search_tool",
-                                args={"query": "answer to question"},
+                                args={"query": question_text or "unknown question"},
                                 id=str(uuid.uuid4())
                             )]
                         )
@@ -2649,7 +2693,7 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
         all_messages = []
         
         try:
-            config_dict = {"recursion_limit": config.MAX_TURNS + 10}
+            config_dict = {"recursion_limit": config.MAX_TURNS * 2 + 10}
             
             for event in self.graph.stream(graph_input, stream_mode="values", config=config_dict):
                 if not event.get('messages'):
@@ -2664,7 +2708,7 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
                         if tool_call.get("name") == "final_answer_tool":
                             args = tool_call.get('args', {})
                             if 'answer' in args:
-                                final_answer = args['answer']
+                                final_answer = normalize_answer(args['answer'])
                                 print(f"\n✅ FINAL: '{final_answer}'\n")
                                 break