Add timeout mcp

agent.py

@@ -169,10 +169,12 @@ async def list_tools() -> list[Tool]:
 @app.call_tool()
 async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageContent | EmbeddedResource]:
     """Handle tool calls"""
+    logger.info(f"🔵 MCP tool call received: {name}")
     if name == "generate_content":
         try:
             user_prompt = arguments.get("user_prompt")
             if not user_prompt:
+                logger.error("❌ user_prompt is required but missing")
                 return [TextContent(type="text", text="Error: user_prompt is required")]
             
             system_prompt = arguments.get("system_prompt")
@@ -221,6 +223,10 @@ async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageC
                     "max_output_tokens": GEMINI_MAX_OUTPUT_TOKENS
                 }
                 
+                # Convert timeout from milliseconds to seconds, cap at 100s to stay under 120s function limit
+                timeout_seconds = min(GEMINI_TIMEOUT / 1000.0, 100.0)
+                logger.info(f"🔵 Calling Gemini API with model={model}, timeout={timeout_seconds}s...")
+                
                 # Use asyncio.to_thread to make the blocking call async
                 # The API accepts contents as a list and config as a separate parameter
                 def generate_sync():
@@ -230,7 +236,11 @@ async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageC
                         config=generation_config,
                     )
                 
-                response = await asyncio.to_thread(generate_sync)
+                response = await asyncio.wait_for(
+                    asyncio.to_thread(generate_sync),
+                    timeout=timeout_seconds
+                )
+                logger.info(f"✅ Gemini API call completed successfully")
                 
                 # Extract text from response
                 if response and hasattr(response, 'text') and response.text:
@@ -253,8 +263,15 @@ async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageC
                     logger.warning("Gemini returned empty response")
                     return [TextContent(type="text", text="Error: No response from Gemini")]
                     
+            except asyncio.TimeoutError:
+                timeout_seconds = min(GEMINI_TIMEOUT / 1000.0, 100.0)
+                error_msg = f"Gemini API call timed out after {timeout_seconds}s"
+                logger.error(f"❌ {error_msg}")
+                return [TextContent(type="text", text=f"Error: {error_msg}")]
             except Exception as e:
-                logger.error(f"Error generating content: {e}")
+                logger.error(f"❌ Error generating content: {type(e).__name__}: {e}")
+                import traceback
+                logger.debug(f"Full traceback: {traceback.format_exc()}")
                 return [TextContent(type="text", text=f"Error: {str(e)}")]
                 
         except Exception as e:

client.py

@@ -44,6 +44,7 @@ async def get_mcp_session():
     
     # Reuse existing session if available
     if config.global_mcp_session is not None:
+        logger.debug("Reusing existing MCP session")
         return config.global_mcp_session
     
     try:
@@ -198,23 +199,27 @@ async def call_agent(user_prompt: str, system_prompt: str = None, files: list =
     try:
         session = await get_mcp_session()
         if session is None:
-            logger.warning("Failed to get MCP session for Gemini call - check GEMINI_API_KEY and agent.py")
+            logger.error("❌ 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 ""
         
+        logger.debug(f"MCP session obtained: {type(session).__name__}")
+        
         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")
+            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 ""
         
+        logger.debug(f"Found {len(tools)} MCP tools available")
+        
         generate_tool = None
         for tool in tools:
             if tool.name == "generate_content" or "generate_content" in tool.name.lower():
@@ -239,24 +244,51 @@ 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)
+        logger.info(f"🔵 Calling MCP tool '{generate_tool.name}' with model={model or 'default'}, temperature={temperature}")
+        logger.debug(f"MCP tool arguments keys: {list(arguments.keys())}")
+        logger.debug(f"User prompt length: {len(user_prompt)} chars")
+        
+        # Add timeout to prevent hanging (max 20s to stay under 120s function limit)
+        # Also add a shorter timeout for the initial connection check
+        try:
+            logger.debug("Starting MCP tool call with 20s timeout...")
+            result = await asyncio.wait_for(
+                session.call_tool(generate_tool.name, arguments=arguments),
+                timeout=20.0
+            )
+            logger.info(f"✅ MCP tool call completed successfully")
+        except asyncio.TimeoutError:
+            logger.error(f"❌ MCP tool call timed out after 20s - this exceeds the function time limit")
+            logger.error(f"   This suggests the MCP server (agent.py) is not responding or the Gemini API call is hanging")
+            logger.error(f"   Check if agent.py process is still running and responsive")
+            # Invalidate session on timeout to force retry
+            config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
+            return ""
+        except Exception as call_error:
+            logger.error(f"❌ MCP tool call failed with exception: {type(call_error).__name__}: {call_error}")
+            import traceback
+            logger.error(f"   Traceback: {traceback.format_exc()}")
+            # Invalidate session on error to force retry
+            config.global_mcp_session = None
+            config.global_mcp_stdio_ctx = None
+            raise  # Re-raise to be caught by outer exception handler
         
         if hasattr(result, 'content') and result.content:
             for item in result.content:
                 if hasattr(item, 'text'):
                     response_text = item.text.strip()
                     if response_text:
-                        logger.debug(f"Gemini MCP returned {len(response_text)} chars")
+                        logger.info(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:
         error_type = type(e).__name__
         error_msg = str(e)
-        logger.error(f"Gemini MCP call error: {error_type}: {error_msg}")
+        logger.error(f"❌ Gemini MCP call error: {error_type}: {error_msg}")
         import traceback
-        logger.debug(f"Full traceback: {traceback.format_exc()}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         # Invalidate session on error to force retry
         config.global_mcp_session = None
         config.global_mcp_stdio_ctx = None