Upd MCP Gemini timeout bufer

agent.py

@@ -288,19 +288,29 @@ 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 20s to stay under 120s function limit
-                timeout_seconds = min(GEMINI_TIMEOUT / 1000.0, 20.0)
+                # Convert timeout from milliseconds to seconds
+                # Cap at 18s to leave buffer for client timeout (25s) and communication overhead
+                # This ensures server completes before client times out
+                timeout_seconds = min(GEMINI_TIMEOUT / 1000.0, 18.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():
-                    return gemini_client.models.generate_content(
-                        model=model,
-                        contents=gemini_contents,
-                        config=generation_config,
-                    )
+                    try:
+                        logger.debug(f"Calling Gemini API synchronously (model={model})...")
+                        result = gemini_client.models.generate_content(
+                            model=model,
+                            contents=gemini_contents,
+                            config=generation_config,
+                        )
+                        logger.debug("Gemini API synchronous call completed")
+                        return result
+                    except Exception as sync_error:
+                        logger.error(f"Error in synchronous Gemini API call: {type(sync_error).__name__}: {sync_error}")
+                        raise
                 
+                logger.debug(f"Starting async wrapper for Gemini API call (timeout={timeout_seconds}s)...")
                 response = await asyncio.wait_for(
                     asyncio.to_thread(generate_sync),
                     timeout=timeout_seconds
@@ -329,10 +339,11 @@ async def call_tool(name: str, arguments: dict) -> Sequence[TextContent | ImageC
                     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}")]
+                logger.error(f"   Model: {model}, Prompt length: {len(user_prompt)} chars")
+                logger.error(f"   This may indicate network issues, API rate limiting, or the request is too complex")
+                return [TextContent(type="text", text=f"Error: {error_msg}. The request may be too complex or there may be network issues.")]
             except Exception as e:
                 logger.error(f"❌ Error generating content: {type(e).__name__}: {e}")
                 import traceback

client.py

@@ -375,18 +375,23 @@ async def call_agent(user_prompt: str, system_prompt: str = None, files: list =
         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)
+        # Add timeout to prevent hanging
+        # Client timeout should be longer than server timeout to account for communication overhead
+        # Server timeout is ~18s, so client should wait ~25s to allow for processing + communication
+        client_timeout = 25.0
         try:
-            logger.debug("Starting MCP tool call with 20s timeout...")
+            logger.debug(f"Starting MCP tool call with {client_timeout}s timeout...")
             result = await asyncio.wait_for(
                 session.call_tool(generate_tool.name, arguments=arguments),
-                timeout=20.0
+                timeout=client_timeout
             )
             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"❌ MCP tool call timed out after {client_timeout}s")
+            logger.error(f"   Tool: {generate_tool.name}, Model: {model or 'default'}")
+            logger.error(f"   This suggests the MCP server (agent.py) is not responding or the Gemini API call is taking too long")
             logger.error(f"   Check if agent.py process is still running and responsive")
+            logger.error(f"   Consider increasing GEMINI_TIMEOUT or checking network connectivity")
             # Invalidate session on timeout to force retry
             config.global_mcp_session = None
             # Properly cleanup stdio context