Fix Gemini MCP error handling and session management

- Improve error logging in call_agent() with full tracebacks and detailed error messages
- Add session health check with timeout to detect and recover from invalid sessions
- Automatically invalidate and recreate sessions on errors to force retry
- Enhance empty response handling in reasoning.py and supervisor.py with proper fallback
- Add timeout protection (2s) to health checks to prevent hanging
- Improve session initialization error messages with specific failure causes
- Better distinguish between different MCP failure modes for easier debugging

This fixes issues where MCP sessions would fail silently and fall back to default behavior without proper error reporting. The app now provides better diagnostics while maintaining graceful fallback functionality.

client.py

@@ -42,8 +42,32 @@ async def get_mcp_session():
         logger.warning("MCP not available - SDK not installed")
         return None
     
+    # Check if existing session is still valid
     if config.global_mcp_session is not None:
-        return config.global_mcp_session
+        try:
+            # Try to list tools as a quick health check (with timeout)
+            await asyncio.wait_for(config.global_mcp_session.list_tools(), timeout=2.0)
+            return config.global_mcp_session
+        except asyncio.TimeoutError:
+            logger.warning("MCP session health check timed out, recreating session")
+            # Clean up invalid session
+            try:
+                if config.global_mcp_stdio_ctx is not None:
+                    await config.global_mcp_stdio_ctx.__aexit__(None, None, None)
+            except Exception:
+                pass
+            config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
+        except Exception as e:
+            logger.warning(f"Existing MCP session appears invalid, recreating: {type(e).__name__}: {e}")
+            # Clean up invalid session
+            try:
+                if config.global_mcp_stdio_ctx is not None:
+                    await config.global_mcp_stdio_ctx.__aexit__(None, None, None)
+            except Exception:
+                pass
+            config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
     
     try:
         mcp_env = os.environ.copy()
@@ -96,16 +120,17 @@ async def get_mcp_session():
             logger.error(f"   - Invalid GEMINI_API_KEY")
             logger.error(f"   - agent.py server not starting correctly")
             logger.error(f"   - Network/firewall issues")
+            logger.error(f"   - MCP server process crashed or timed out")
             import traceback
-            logger.debug(f"   Full traceback: {traceback.format_exc()}")
+            logger.error(f"   Full traceback: {traceback.format_exc()}")
             try:
                 await session.__aexit__(None, None, None)
-            except Exception:
-                pass
+            except Exception as cleanup_error:
+                logger.debug(f"Session cleanup error (ignored): {cleanup_error}")
             try:
                 await stdio_ctx.__aexit__(None, None, None)
-            except Exception:
-                pass
+            except Exception as cleanup_error:
+                logger.debug(f"Stdio context cleanup error (ignored): {cleanup_error}")
             return None
         
         config.global_mcp_session = session
@@ -199,13 +224,18 @@ async def call_agent(user_prompt: str, system_prompt: str = None, files: list =
             logger.warning("Failed to get MCP session for Gemini call - check GEMINI_API_KEY and agent.py")
             # Invalidate session to force retry on next call
             config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
             return ""
         
         tools = await get_cached_mcp_tools()
         if not tools:
+            logger.info("MCP tools cache empty, refreshing...")
             tools = await get_cached_mcp_tools(force_refresh=True)
         if not tools:
             logger.error("Unable to obtain MCP tool catalog for Gemini calls")
+            # Invalidate session to force retry on next call
+            config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
             return ""
         
         generate_tool = None
@@ -232,16 +262,26 @@ async def call_agent(user_prompt: str, system_prompt: str = None, files: list =
         if temperature is not None:
             arguments["temperature"] = temperature
         
+        logger.debug(f"Calling MCP tool {generate_tool.name} with arguments: {list(arguments.keys())}")
         result = await session.call_tool(generate_tool.name, arguments=arguments)
         
         if hasattr(result, 'content') and result.content:
             for item in result.content:
                 if hasattr(item, 'text'):
                     response_text = item.text.strip()
-                    return response_text
+                    if response_text:
+                        logger.debug(f"Gemini MCP returned {len(response_text)} chars")
+                        return response_text
         logger.warning("⚠️ Gemini MCP returned empty or invalid result")
         return ""
     except Exception as e:
-        logger.error(f"Gemini MCP call error: {e}")
+        error_type = type(e).__name__
+        error_msg = str(e)
+        logger.error(f"Gemini MCP call error: {error_type}: {error_msg}")
+        import traceback
+        logger.debug(f"Full traceback: {traceback.format_exc()}")
+        # Invalidate session on error to force retry
+        config.global_mcp_session = None
+        config.global_mcp_stdio_ctx = None
         return ""
 

reasoning.py

@@ -41,14 +41,28 @@ Respond in JSON format:
         temperature=0.3
     )
     
+    if not response or not response.strip():
+        logger.warning("Gemini MCP returned empty response for reasoning, using fallback")
+        reasoning = {
+            "query_type": "general_info",
+            "complexity": "moderate",
+            "information_needs": ["medical information"],
+            "requires_rag": True,
+            "requires_web_search": False,
+            "sub_questions": [query]
+        }
+        return reasoning
+    
     try:
         json_start = response.find('{')
         json_end = response.rfind('}') + 1
         if json_start >= 0 and json_end > json_start:
             reasoning = json.loads(response[json_start:json_end])
         else:
-            raise ValueError("No JSON found")
-    except:
+            raise ValueError("No JSON found in response")
+    except Exception as e:
+        logger.error(f"Failed to parse reasoning response as JSON: {e}")
+        logger.debug(f"Response was: {response[:200]}...")
         reasoning = {
             "query_type": "general_info",
             "complexity": "moderate",

supervisor.py

@@ -72,6 +72,19 @@ Guidelines:
         temperature=0.3
     )
     
+    if not response or not response.strip():
+        logger.warning("[GEMINI SUPERVISOR] Gemini MCP returned empty response for breakdown, using fallback")
+        breakdown = {
+            "sub_topics": [
+                {"id": 1, "topic": "Core Question", "instruction": "Address the main medical question", "expected_tokens": 200, "priority": "high", "approach": "direct answer"},
+                {"id": 2, "topic": "Clinical Details", "instruction": "Provide key clinical insights", "expected_tokens": 200, "priority": "medium", "approach": "clinical perspective"},
+            ],
+            "strategy": "Sequential answer with key points",
+            "exploration_note": "Fallback breakdown - basic coverage"
+        }
+        logger.warning(f"[GEMINI SUPERVISOR] Using fallback breakdown")
+        return breakdown
+    
     try:
         json_start = response.find('{')
         json_end = response.rfind('}') + 1
@@ -80,9 +93,10 @@ Guidelines:
             logger.info(f"[GEMINI SUPERVISOR] Query broken into {len(breakdown.get('sub_topics', []))} sub-topics")
             return breakdown
         else:
-            raise ValueError("Supervisor JSON not found")
+            raise ValueError("Supervisor JSON not found in response")
     except Exception as exc:
         logger.error(f"[GEMINI SUPERVISOR] Breakdown parsing failed: {exc}")
+        logger.debug(f"Response was: {response[:200]}...")
         breakdown = {
             "sub_topics": [
                 {"id": 1, "topic": "Core Question", "instruction": "Address the main medical question", "expected_tokens": 200, "priority": "high", "approach": "direct answer"},