gemini-bridge 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

{gemini_bridge-1.0.2.dist-info → gemini_bridge-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-bridge
-Version: 1.0.2
+Version: 1.0.4
 Summary: Lightweight MCP server bridging Claude Code to Google's Gemini AI via official CLI
 Author-email: Shelakh <info@shelakh.com>
 License-Expression: MIT
@@ -537,10 +537,83 @@ gemini --version
 - Ensure Claude Code MCP configuration is correct
 - Check that the `gemini` command is in your PATH
 
+### Timeout Issues 🔥
+
+Gemini Bridge now includes comprehensive timeout debugging. If you're experiencing timeout issues:
+
+**1. Use the Debug Tool**
+```python
+# Get detailed diagnostics about your configuration
+get_debug_info()
+```
+
+This will show:
+- Current timeout configuration
+- Gemini CLI status and version
+- Authentication status
+- Environment variables
+- System information
+
+**2. Configure Appropriate Timeout**
+
+For different operation types, recommended timeouts:
+
+- **Default operations**: 60 seconds (default)
+- **Large file analysis**: 240 seconds
+- **Complex multi-file operations**: 300+ seconds
+
+**Configuration Examples:**
+
+```bash
+# Claude Code with 4-minute timeout for large operations
+claude mcp add gemini-bridge -s user --env GEMINI_BRIDGE_TIMEOUT=240 -- uvx gemini-bridge
+
+# Environment variable (if running manually)
+export GEMINI_BRIDGE_TIMEOUT=240
+```
+
+**3. Common Timeout Scenarios**
+
+| Scenario | Recommended Timeout | Reason |
+|----------|-------------------|---------|
+| Single file < 10KB | 60s (default) | Fast processing |
+| Multiple files or large files | 240s | More content to process |
+| Complex code analysis | 300s | Deep reasoning required |
+| Very large files (>100KB) | 300-600s | Processing overhead |
+
+**4. Debugging Steps**
+
+1. **Check your configuration**:
+   ```bash
+   # Run the debug tool to see current timeout
+   # Look for "Actual timeout used" in the output
+   ```
+
+2. **Monitor logs**: The server now logs detailed timing information
+
+3. **Test with smaller queries**: If large queries timeout, break them into smaller parts
+
+4. **Verify Gemini CLI performance**: Test `gemini` directly with similar queries
+
+**5. Advanced Troubleshooting**
+
+If timeouts persist even with high timeout values:
+
+- **Network issues**: Check your internet connection
+- **Gemini CLI version**: Update with `npm install -g @google/gemini-cli@latest`  
+- **Authentication**: Re-authenticate with `gemini auth login`
+- **System resources**: Check if your system is under high load
+- **File encoding**: Ensure files are UTF-8 encoded
+- **MCP client timeout**: Some clients have their own timeout settings
+
 ### Common Error Messages
 - **"CLI not available"**: Gemini CLI is not installed or not in PATH
 - **"Authentication required"**: Run `gemini auth login`
-- **"Timeout after 60 seconds"**: Query took too long, try breaking it into smaller parts
+- **"Timeout after X seconds"**: Operation took longer than configured timeout
+  - Solution: Increase `GEMINI_BRIDGE_TIMEOUT` environment variable
+  - For immediate testing: Use smaller files or simpler queries
+- **"Large content size warning"**: Files total >100KB, may need longer timeout
+- **"Very high timeout configured"**: Timeout >300s, failed operations will wait long
 
 ## 🤝 Contributing
 

gemini_bridge-1.0.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+gemini_bridge-1.0.4.dist-info/licenses/LICENSE,sha256=yTz_R8ocWu64Eubxr6vdZCKRS0dB_Pi3RbjUNn4qPxQ,1063
+src/__init__.py,sha256=U_gAa2Z0ljR0Mn193WDvGATLlzB_UPNkyRDPU7OLPVw,190
+src/__main__.py,sha256=12FoIYCXYYKu2_BYX1GS_h9E9qO41Q26B8zedRIDPBs,149
+src/mcp_server.py,sha256=jioHBNwa1zLExONL1p60a1JWht_K2y7zRPQ_nN1eF4s,14557
+gemini_bridge-1.0.4.dist-info/METADATA,sha256=wUJmFg56YQDH5ZmF9L-tqCuUQIV58-PNVOj2wpfFV7Y,16223
+gemini_bridge-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gemini_bridge-1.0.4.dist-info/entry_points.txt,sha256=ygWf0B23Gygq8mW_GzPx8rxIA19RR_RH4RG2I15lU3E,43
+gemini_bridge-1.0.4.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+gemini_bridge-1.0.4.dist-info/RECORD,,

src/__init__.py

@@ -5,5 +5,5 @@ Version 1.0.0 - Production ready, radically simplified.
 
 from .mcp_server import main
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"
 __all__ = ["main"]

src/mcp_server.py

@@ -10,11 +10,17 @@ import logging
 import os
 import shutil
 import subprocess
+import sys
 from typing import List, Optional
 
 from mcp.server.fastmcp import FastMCP
 
-mcp = FastMCP("gemini-assistant")
+# Configure logging for debugging timeout issues
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# FastMCP instance with correct port configuration
+mcp = FastMCP("gemini-assistant", port=int(os.getenv("PORT", "8080")))
 
 
 def _normalize_model_name(model: Optional[str]) -> str:
@@ -50,19 +56,37 @@ def _get_timeout() -> int:
         Timeout value in seconds (positive integer)
     """
     timeout_str = os.getenv("GEMINI_BRIDGE_TIMEOUT")
+    logger.debug(
+        "Reading timeout from environment: GEMINI_BRIDGE_TIMEOUT=%s", timeout_str
+    )
+
     if not timeout_str:
+        logger.info("GEMINI_BRIDGE_TIMEOUT not set, using default 60 seconds")
         return 60
-    
+
     try:
         timeout = int(timeout_str)
-        if timeout <= 0:
-            logging.warning("Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be positive). Using default 60 seconds.", timeout_str)
-            return 60
-        return timeout
     except ValueError:
-        logging.warning("Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be integer). Using default 60 seconds.", timeout_str)
+        logger.warning(
+            "Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be integer). Using default 60 seconds.",
+            timeout_str,
+        )
+        return 60
+
+    if timeout <= 0:
+        logger.warning(
+            "Invalid GEMINI_BRIDGE_TIMEOUT value '%s' (must be positive). Using default 60 seconds.",
+            timeout_str,
+        )
         return 60
 
+    logger.info("Using configured timeout: %s seconds", timeout)
+    if timeout > 300:
+        logger.warning(
+            "Large timeout configured (%ss). This may cause long waits for failed operations.",
+            timeout,
+        )
+    return timeout
 
 def execute_gemini_simple(query: str, directory: str = ".", model: Optional[str] = None) -> str:
     """
@@ -90,6 +114,9 @@ def execute_gemini_simple(query: str, directory: str = ".", model: Optional[str]
     
     # Execute CLI command - simple timeout, no retries
     timeout = _get_timeout()
+    logger.info(f"Executing Gemini CLI with timeout: {timeout}s, model: {selected_model}, directory: {directory}")
+    logger.debug(f"Query length: {len(query)} characters")
+    
     try:
         result = subprocess.run(
             cmd,
@@ -100,15 +127,25 @@ def execute_gemini_simple(query: str, directory: str = ".", model: Optional[str]
             input=query
         )
         
+        logger.debug(f"Gemini CLI completed with return code: {result.returncode}")
+        
         if result.returncode == 0:
-            return result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            output = result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            logger.info(f"Gemini CLI successful, output length: {len(output)} characters")
+            return output
         else:
-            return f"Gemini CLI Error: {result.stderr.strip()}"
+            error_msg = f"Gemini CLI Error: {result.stderr.strip()}"
+            logger.error(error_msg)
+            return error_msg
             
     except subprocess.TimeoutExpired:
-        return f"Error: Gemini CLI command timed out after {timeout} seconds"
+        timeout_msg = f"Error: Gemini CLI command timed out after {timeout} seconds. Try increasing GEMINI_BRIDGE_TIMEOUT environment variable for large operations."
+        logger.error(timeout_msg)
+        return timeout_msg
     except Exception as e:
-        return f"Error executing Gemini CLI: {str(e)}"
+        error_msg = f"Error executing Gemini CLI: {str(e)}"
+        logger.error(error_msg)
+        return error_msg
 
 
 def execute_gemini_with_files(query: str, directory: str = ".", files: Optional[List[str]] = None, model: Optional[str] = None) -> str:
@@ -162,6 +199,14 @@ def execute_gemini_with_files(query: str, directory: str = ".", files: Optional[
     
     # Execute CLI command - simple timeout, no retries
     timeout = _get_timeout()
+    total_content_size = len(stdin_content)
+    logger.info(f"Executing Gemini CLI with files, timeout: {timeout}s, model: {selected_model}, directory: {directory}")
+    logger.info(f"File count: {len(files)}, total content size: {total_content_size} characters")
+    
+    # Warn about large content that might timeout
+    if total_content_size > 100000:  # 100KB threshold
+        logger.warning(f"Large content size ({total_content_size} chars). Consider increasing timeout if you experience timeouts.")
+    
     try:
         result = subprocess.run(
             cmd,
@@ -172,15 +217,25 @@ def execute_gemini_with_files(query: str, directory: str = ".", files: Optional[
             input=stdin_content
         )
         
+        logger.debug(f"Gemini CLI completed with return code: {result.returncode}")
+        
         if result.returncode == 0:
-            return result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            output = result.stdout.strip() if result.stdout.strip() else "No output from Gemini CLI"
+            logger.info(f"Gemini CLI successful, output length: {len(output)} characters")
+            return output
         else:
-            return f"Gemini CLI Error: {result.stderr.strip()}"
+            error_msg = f"Gemini CLI Error: {result.stderr.strip()}"
+            logger.error(error_msg)
+            return error_msg
             
     except subprocess.TimeoutExpired:
-        return f"Error: Gemini CLI command timed out after {timeout} seconds"
+        timeout_msg = f"Error: Gemini CLI command timed out after {timeout} seconds with {len(files)} files ({total_content_size} chars). Try increasing GEMINI_BRIDGE_TIMEOUT environment variable (current: {os.getenv('GEMINI_BRIDGE_TIMEOUT', 'not set')})."
+        logger.error(timeout_msg)
+        return timeout_msg
     except Exception as e:
-        return f"Error executing Gemini CLI: {str(e)}"
+        error_msg = f"Error executing Gemini CLI: {str(e)}"
+        logger.error(error_msg)
+        return error_msg
 
 
 @mcp.tool()
@@ -232,9 +287,120 @@ def consult_gemini_with_files(
     return execute_gemini_with_files(query, directory, files, model)
 
 
+@mcp.tool()
+def get_debug_info() -> str:
+    """
+    Get diagnostic information about the Gemini Bridge configuration.
+    
+    Useful for troubleshooting timeout issues and verifying setup.
+    
+    Returns:
+        Formatted debug information including timeout configuration,
+        environment variables, and system status
+    """
+    debug_info = []
+    debug_info.append("=== Gemini Bridge Debug Information ===\n")
+    
+    # Timeout configuration
+    timeout_env = os.getenv("GEMINI_BRIDGE_TIMEOUT")
+    actual_timeout = _get_timeout()
+    debug_info.append("Timeout Configuration:")
+    debug_info.append(f"  GEMINI_BRIDGE_TIMEOUT env var: {timeout_env or 'not set'}")
+    debug_info.append(f"  Actual timeout used: {actual_timeout} seconds")
+    
+    if actual_timeout == 60 and not timeout_env:
+        debug_info.append("  ⚠️  Using default timeout. Set GEMINI_BRIDGE_TIMEOUT=240 for large operations.")
+    elif actual_timeout < 120:
+        debug_info.append("  ⚠️  Timeout may be too low for large files or complex queries.")
+    elif actual_timeout > 300:
+        debug_info.append(f"  ⚠️  Very high timeout configured. Failed operations will wait {actual_timeout}s.")
+    else:
+        debug_info.append("  ✓ Timeout looks reasonable for most operations.")
+    
+    debug_info.append("")
+    
+    # Gemini CLI status
+    gemini_path = shutil.which("gemini")
+    debug_info.append("Gemini CLI Status:")
+    debug_info.append(f"  CLI available: {'✓ Yes' if gemini_path else '✗ No'}")
+    if gemini_path:
+        debug_info.append(f"  CLI path: {gemini_path}")
+        try:
+            # Try to get version
+            result = subprocess.run(
+                ["gemini", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                version = result.stdout.strip()
+                debug_info.append(f"  CLI version: {version}")
+            else:
+                debug_info.append(f"  CLI version check failed: {result.stderr.strip()}")
+        except Exception as e:
+            debug_info.append(f"  CLI version check error: {str(e)}")
+    else:
+        debug_info.append("  ✗ Install with: npm install -g @google/gemini-cli")
+    
+    debug_info.append("")
+    # Environment details
+    debug_info.append("Environment:")
+    debug_info.append(f"  Python version: {sys.version.split()[0]}")
+    debug_info.append(f"  Current working directory: {os.getcwd()}")
+    debug_info.append(f"  PORT: {os.getenv('PORT', '8080')}")
+    
+    # Check authentication status
+    try:
+        result = subprocess.run(
+            ["gemini", "auth", "status"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            cwd="."
+        )
+        if result.returncode == 0:
+            debug_info.append("  Authentication: ✓ Logged in")
+        else:
+            debug_info.append("  Authentication: ✗ Not logged in - run 'gemini auth login'")
+    except Exception as e:
+        debug_info.append(f"  Authentication status check failed: {str(e)}")
+    
+    debug_info.append("")
+    
+    # Recent environment variables that might affect operation
+    relevant_env_vars = [
+        "GEMINI_BRIDGE_TIMEOUT", "NODE_PATH", "PATH", "HOME", 
+        "GOOGLE_APPLICATION_CREDENTIALS", "GOOGLE_CLOUD_PROJECT"
+    ]
+    
+    debug_info.append("Relevant Environment Variables:")
+    for var in relevant_env_vars:
+        value = os.getenv(var)
+        if value:
+            # Truncate very long values
+            display_value = value[:100] + "..." if len(value) > 100 else value
+            debug_info.append(f"  {var}: {display_value}")
+        else:
+            debug_info.append(f"  {var}: not set")
+    
+    debug_info.append("")
+    debug_info.append("=== End Debug Information ===")
+    
+    return "\n".join(debug_info)
+
+
 def main():
     """Entry point for the MCP server."""
-    mcp.run()
+    port = int(os.getenv("PORT", "8080"))
+    timeout = _get_timeout()  # Log timeout configuration at startup
+    
+    logger.info(f"Starting Gemini Bridge MCP Server on port {port}")
+    logger.info(f"Configured timeout: {timeout} seconds")
+    logger.info(f"Gemini CLI available: {shutil.which('gemini') is not None}")
+    
+    # Run the MCP server with SSE transport (port is managed by the library)
+    mcp.run(transport="sse")
 
 
 if __name__ == "__main__":

gemini_bridge-1.0.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-gemini_bridge-1.0.2.dist-info/licenses/LICENSE,sha256=yTz_R8ocWu64Eubxr6vdZCKRS0dB_Pi3RbjUNn4qPxQ,1063
-src/__init__.py,sha256=XwIQ60BQ748HOAFYiRvDP4HWUonSZfGNvNv6-YnuKgc,190
-src/__main__.py,sha256=12FoIYCXYYKu2_BYX1GS_h9E9qO41Q26B8zedRIDPBs,149
-src/mcp_server.py,sha256=vYykaYMSNtkwOB94VZPvnJ2fuBZkKgnqcoYL12ZM20k,7722
-gemini_bridge-1.0.2.dist-info/METADATA,sha256=UF7tWNaTxoCL6unvjkWKnjwp8cFzrz1X6k3dDfWKOu4,13798
-gemini_bridge-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gemini_bridge-1.0.2.dist-info/entry_points.txt,sha256=ygWf0B23Gygq8mW_GzPx8rxIA19RR_RH4RG2I15lU3E,43
-gemini_bridge-1.0.2.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-gemini_bridge-1.0.2.dist-info/RECORD,,