gemini-cli-proxy 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

gemini_cli_proxy/cli.py

@@ -20,12 +20,6 @@ import uvicorn
     type=int,
     help="Server port"
 )
-@click.option(
-    "--log-level",
-    default="info",
-    type=click.Choice(["debug", "info", "warning", "error", "critical"]),
-    help="Log level"
-)
 @click.option(
     "--rate-limit",
     default=60,
@@ -52,7 +46,6 @@ import uvicorn
 def main(
     host: str,
     port: int,
-    log_level: str,
     rate_limit: int,
     max_concurrency: int,
     timeout: float,
@@ -61,21 +54,33 @@ def main(
     """Start Gemini CLI Proxy server"""
     
     # Set configuration
+    import os
     from .config import config
+    
+    # Set environment variable for reload mode
+    os.environ['GEMINI_CLI_PROXY_DEBUG'] = str(debug)
+    
     config.host = host
     config.port = port
-    config.log_level = log_level
+    config.log_level = "debug" if debug else "info"
     config.rate_limit = rate_limit
     config.max_concurrency = max_concurrency
     config.timeout = timeout
     config.debug = debug
     
+    # Update logging level based on configuration
+    import logging
+    # Set root logger level
+    logging.getLogger().setLevel(getattr(logging, config.log_level.upper()))
+    # Also set level for all gemini_cli_proxy loggers
+    logging.getLogger('gemini_cli_proxy').setLevel(getattr(logging, config.log_level.upper()))
+    
     # Start server
     uvicorn.run(
         "gemini_cli_proxy.server:app",
         host=host,
         port=port,
-        log_level=log_level,
+        log_level=config.log_level,
         reload=debug
     )
 

gemini_cli_proxy/config.py

@@ -9,15 +9,18 @@ class Config:
     """Application configuration class"""
     
     def __init__(self):
+        import os
+        
         # Server configuration
         self.host: str = "127.0.0.1"
         self.port: int = 8765
-        self.log_level: str = "info"
-        self.debug: bool = False
+        # Read from environment variable if available (for reload mode)
+        self.debug: bool = os.environ.get('GEMINI_CLI_PROXY_DEBUG', 'false').lower() == 'true'
+        self.log_level: str = "debug" if self.debug else "info"
         
         # Gemini CLI configuration
         self.gemini_command: str = "gemini"  # Gemini CLI command path
-        self.timeout: float = 30.0
+        self.timeout: float = 120.0
         
         # Limit configuration
         self.rate_limit: int = 60  # Requests per minute

gemini_cli_proxy/gemini_client.py

@@ -6,11 +6,16 @@ Handles interaction with Gemini CLI tool
 
 import asyncio
 import logging
-from typing import List, Optional, AsyncGenerator
+import os
+import tempfile
+import uuid
+import base64
+import re
+from typing import List, Optional, AsyncGenerator, Tuple
 from .models import ChatMessage
 from .config import config
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('gemini_cli_proxy')
 
 
 class GeminiClient:
@@ -19,9 +24,43 @@ class GeminiClient:
     def __init__(self):
         self.semaphore = asyncio.Semaphore(config.max_concurrency)
     
+    def _simplify_error_message(self, raw_error: str) -> Optional[str]:
+        """
+        Convert Gemini CLI error messages to more readable user-friendly messages
+        
+        Args:
+            raw_error: Raw error message from Gemini CLI
+            
+        Returns:
+            Simplified error message, or None if the error cannot be recognized
+        """
+        if not raw_error:
+            return None
+            
+        lower_err = raw_error.lower()
+        
+        # Check for rate limiting related keywords
+        rate_limit_indicators = [
+            "code\": 429",
+            "status 429", 
+            "ratelimitexceeded",
+            "resource_exhausted",
+            "quota exceeded",
+            "quota metric",
+            "requests per day",
+            "requests per minute",
+            "limit exceeded"
+        ]
+        
+        if any(keyword in lower_err for keyword in rate_limit_indicators):
+            return "Gemini CLI rate limit exceeded. Please run `gemini` directly to check."
+        
+        return None
+
     async def chat_completion(
         self,
         messages: List[ChatMessage],
+        model: str,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
         **kwargs
@@ -31,6 +70,7 @@ class GeminiClient:
         
         Args:
             messages: List of chat messages
+            model: Model name to use
             temperature: Temperature parameter
             max_tokens: Maximum number of tokens
             **kwargs: Other parameters
@@ -44,12 +84,13 @@ class GeminiClient:
         """
         async with self.semaphore:
             return await self._execute_gemini_command(
-                messages, temperature, max_tokens, **kwargs
+                messages, model, temperature, max_tokens, **kwargs
             )
     
     async def chat_completion_stream(
         self,
         messages: List[ChatMessage],
+        model: str,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
         **kwargs
@@ -59,6 +100,7 @@ class GeminiClient:
         
         Args:
             messages: List of chat messages
+            model: Model name to use
             temperature: Temperature parameter
             max_tokens: Maximum number of tokens
             **kwargs: Other parameters
@@ -68,7 +110,7 @@ class GeminiClient:
         """
         # First get complete response
         full_response = await self.chat_completion(
-            messages, temperature, max_tokens, **kwargs
+            messages, model, temperature, max_tokens, **kwargs
         )
         
         # Split by lines and yield one by one
@@ -82,6 +124,7 @@ class GeminiClient:
     async def _execute_gemini_command(
         self,
         messages: List[ChatMessage],
+        model: str,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
         **kwargs
@@ -91,6 +134,7 @@ class GeminiClient:
         
         Args:
             messages: List of chat messages
+            model: Model name to use
             temperature: Temperature parameter
             max_tokens: Maximum number of tokens
             **kwargs: Other parameters
@@ -98,14 +142,12 @@ class GeminiClient:
         Returns:
             Command output result
         """
-        # Build command arguments
-        cmd_args = [config.gemini_command]
+        # Build command arguments and get temporary files
+        prompt, temp_files = self._build_prompt_with_images(messages)
         
-        # Build prompt text (simplified implementation: combine all messages)
-        prompt = self._build_prompt(messages)
-        
-        # Use --prompt parameter to pass prompt text
-        cmd_args.extend(["--prompt", prompt])
+        cmd_args = [config.gemini_command]
+        cmd_args.extend(["-m", model])
+        cmd_args.extend(["-p", prompt])
         
         # Note: Real gemini CLI doesn't support temperature and max_tokens parameters
         # We ignore these parameters here but log them
@@ -133,42 +175,161 @@ class GeminiClient:
             # Check return code
             if process.returncode != 0:
                 error_msg = stderr.decode('utf-8').strip()
-                raise RuntimeError(f"Gemini CLI execution failed (exit code: {process.returncode}): {error_msg}")
+                
+                # Try to simplify error message to more user-friendly format
+                simplified_msg = self._simplify_error_message(error_msg)
+                if simplified_msg:
+                    logger.warning(f"Gemini CLI error (simplified): {simplified_msg}")
+                    raise RuntimeError(simplified_msg)
+                else:
+                    logger.warning(f"Gemini CLI execution failed: {error_msg}")
+                    raise RuntimeError(f"Gemini CLI execution failed (exit code: {process.returncode}): {error_msg}")
             
             # Return standard output
             result = stdout.decode('utf-8').strip()
-            logger.debug(f"Command executed successfully, output length: {len(result)}")
+            logger.debug(f"Gemini CLI response: {result}")
             return result
             
         except asyncio.TimeoutError:
             logger.error(f"Gemini CLI command timeout ({config.timeout}s)")
+            raise RuntimeError(f"Gemini CLI execution timeout ({config.timeout} seconds), please retry later or check your network connection")
+        except RuntimeError:
+            # Re-raise already processed RuntimeError
             raise
         except Exception as e:
             logger.error(f"Error executing Gemini CLI command: {e}")
-            raise
+            raise RuntimeError(f"Error executing Gemini CLI command: {str(e)}")
+        finally:
+            # Clean up temporary files (skip in debug mode)
+            if not config.debug:
+                for temp_file in temp_files:
+                    try:
+                        if os.path.exists(temp_file):
+                            os.unlink(temp_file)
+                    except Exception as e:
+                        logger.warning(f"Failed to clean up temp file {temp_file}: {e}")
     
-    def _build_prompt(self, messages: List[ChatMessage]) -> str:
+    def _build_prompt_with_images(self, messages: List[ChatMessage]) -> Tuple[str, List[str]]:
         """
-        Build prompt text
+        Build prompt text with image processing
         
         Args:
             messages: List of chat messages
             
         Returns:
-            Formatted prompt text
+            Tuple of (formatted prompt text, list of temporary file paths)
         """
-        # Simplified implementation: format all messages by role
         prompt_parts = []
+        temp_files = []
+        
+        for i, message in enumerate(messages):
+            if isinstance(message.content, str):
+                # Simple string content
+                if message.role == "system":
+                    prompt_parts.append(f"System: {message.content}")
+                elif message.role == "user":
+                    prompt_parts.append(f"User: {message.content}")
+                elif message.role == "assistant":
+                    prompt_parts.append(f"Assistant: {message.content}")
+            else:
+                # List of content parts (vision support)
+                content_parts = []
+                
+                for j, part in enumerate(message.content):
+                    if part.type == "text" and part.text:
+                        content_parts.append(part.text)
+                    elif part.type == "image_url" and part.image_url:
+                        url = part.image_url.get("url", "")
+                        if url.startswith("data:"):
+                            # Process base64 image
+                            temp_file_path = self._save_base64_image(url)
+                            temp_files.append(temp_file_path)
+                            content_parts.append(f"@{temp_file_path}")
+                        else:
+                            # For regular URLs, we'll just pass them through for now
+                            # TODO: Download and save remote images if needed
+                            content_parts.append(f"<image_url>{url}</image_url>")
+                
+                combined_content = " ".join(content_parts)
+                if message.role == "system":
+                    prompt_parts.append(f"System: {combined_content}")
+                elif message.role == "user":
+                    prompt_parts.append(f"User: {combined_content}")
+                elif message.role == "assistant":
+                    prompt_parts.append(f"Assistant: {combined_content}")
+
+        final_prompt = "\n".join(prompt_parts)
+        logger.debug(f"Prompt sent to Gemini CLI: {final_prompt}")
         
-        for message in messages:
-            if message.role == "system":
-                prompt_parts.append(f"System: {message.content}")
-            elif message.role == "user":
-                prompt_parts.append(f"User: {message.content}")
-            elif message.role == "assistant":
-                prompt_parts.append(f"Assistant: {message.content}")
+        return final_prompt, temp_files
+    
+    def _save_base64_image(self, data_url: str) -> str:
+        """
+        Save base64 image data to temporary file
         
-        return "\n".join(prompt_parts)
+        Args:
+            data_url: Data URL in format "data:image/type;base64,..."
+            
+        Returns:
+            Path to temporary file
+            
+        Raises:
+            ValueError: Invalid data URL format
+        """
+        try:
+            # Parse data URL
+            if not data_url.startswith("data:"):
+                raise ValueError("Invalid data URL format")
+            
+            # Extract MIME type and base64 data
+            header, data = data_url.split(",", 1)
+            mime_info = header.split(";")[0].split(":")[1]  # e.g., "image/png"
+            
+            # Determine file extension
+            if "png" in mime_info.lower():
+                ext = ".png"
+            elif "jpeg" in mime_info.lower() or "jpg" in mime_info.lower():
+                ext = ".jpg"
+            elif "gif" in mime_info.lower():
+                ext = ".gif"
+            elif "webp" in mime_info.lower():
+                ext = ".webp"
+            else:
+                ext = ".png"  # Default to PNG
+            
+            # Decode base64 data
+            image_data = base64.b64decode(data)
+            
+            # Create .gemini-cli-proxy directory in project root
+            temp_dir = ".gemini-cli-proxy"
+            os.makedirs(temp_dir, exist_ok=True)
+            
+            # Create temporary file with simplified name
+            filename = f"{uuid.uuid4().hex[:8]}{ext}"
+            temp_file_path = os.path.join(temp_dir, filename)
+            
+            # Write image data
+            with open(temp_file_path, 'wb') as f:
+                f.write(image_data)
+            
+            return temp_file_path
+            
+        except Exception as e:
+            logger.error(f"Error saving base64 image: {e}")
+            raise ValueError(f"Failed to save base64 image: {e}")
+
+    def _build_prompt(self, messages: List[ChatMessage]) -> str:
+        """
+        Build prompt text (legacy method, kept for compatibility)
+        
+        Args:
+            messages: List of chat messages
+            
+        Returns:
+            Formatted prompt text
+        """
+        prompt, _ = self._build_prompt_with_images(messages)
+        return prompt
 
 
 # Global client instance

gemini_cli_proxy/models.py

@@ -10,10 +10,17 @@ import time
 import uuid
 
 
+class ChatContentPart(BaseModel):
+    """Chat content part model for vision support"""
+    type: Literal["text", "image_url"]
+    text: Optional[str] = None
+    image_url: Optional[Dict[str, str]] = None  # {"url": "..."}
+
+
 class ChatMessage(BaseModel):
     """Chat message model"""
     role: Literal["system", "user", "assistant"]
-    content: str
+    content: Union[str, List[ChatContentPart]]
 
 
 class ChatCompletionRequest(BaseModel):

gemini_cli_proxy/openai_adapter.py

@@ -20,7 +20,7 @@ from .models import (
 )
 from .gemini_client import gemini_client
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('gemini_cli_proxy')
 
 
 class OpenAIAdapter:
@@ -42,6 +42,7 @@ class OpenAIAdapter:
             # Call Gemini CLI
             response_text = await gemini_client.chat_completion(
                 messages=request.messages,
+                model=request.model,
                 temperature=request.temperature,
                 max_tokens=request.max_tokens
             )
@@ -89,6 +90,7 @@ class OpenAIAdapter:
                 # Get streaming data generator
                 stream_generator = gemini_client.chat_completion_stream(
                     messages=request.messages,
+                    model=request.model,
                     temperature=request.temperature,
                     max_tokens=request.max_tokens
                 )

gemini_cli_proxy/server.py

@@ -29,12 +29,12 @@ from .models import (
 )
 from .openai_adapter import openai_adapter
 
-# Configure logging
+# Configure logging (will be updated when config is set)
 logging.basicConfig(
-    level=getattr(logging, config.log_level.upper()),
+    level=logging.INFO,  # Default level, will be updated in CLI
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('gemini_cli_proxy')
 
 # Create rate limiter
 limiter = Limiter(key_func=get_remote_address)
@@ -43,8 +43,13 @@ limiter = Limiter(key_func=get_remote_address)
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifecycle management"""
+    # Ensure logging level is applied after uvicorn starts
+    import logging
+    logging.getLogger('gemini_cli_proxy').setLevel(getattr(logging, config.log_level.upper()))
+    
     logger.info(f"Starting Gemini CLI Proxy v{__version__}")
     logger.info(f"Configuration: port={config.port}, rate_limit={config.rate_limit}/min, concurrency={config.max_concurrency}")
+    logger.debug(f"Debug logging is enabled (log_level={config.log_level})")
     yield
     logger.info("Shutting down Gemini CLI Proxy")
 

{gemini_cli_proxy-1.0.3.dist-info → gemini_cli_proxy-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-cli-proxy
-Version: 1.0.3
+Version: 1.1.0
 Summary: OpenAI-compatible API wrapper for Gemini CLI
 Author: nettee
 License: MIT
@@ -59,6 +59,12 @@ gemini -p "Hello, Gemini"
 
 ### Start Gemini CLI Proxy
 
+Method 1: Direct startup
+```bash
+uvx gemini-cli-proxy
+```
+
+Method 2: Clone this repository and run:
 ```bash
 uv run gemini-cli-proxy
 ```
@@ -122,11 +128,10 @@ gemini-cli-proxy --help
 Available options:
 - `--host`: Server host address (default: 127.0.0.1)
 - `--port`: Server port (default: 8765)
-- `--log-level`: Log level (debug/info/warning/error/critical)
 - `--rate-limit`: Max requests per minute (default: 60)
 - `--max-concurrency`: Max concurrent subprocesses (default: 4)
 - `--timeout`: Gemini CLI command timeout in seconds (default: 30.0)
-- `--debug`: Enable debug mode
+- `--debug`: Enable debug mode (enables debug logging and file watching)
 
 ## ❓ FAQ
 

gemini_cli_proxy-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+gemini_cli_proxy/__init__.py,sha256=fOI3EtGmmggiMc3uGV8lGLsbzXmM3ADfnFbaHnwrKtg,257
+gemini_cli_proxy/cli.py,sha256=3_ZgcvEDzRtY6AVA0-8VbQtUWOcpn3waoAsH-soOQ18,1863
+gemini_cli_proxy/config.py,sha256=Ly7_eGTssitIbSVhxq7Tq-bQao83oDWzIyI-t1PJpvM,1043
+gemini_cli_proxy/gemini_client.py,sha256=wWIZ4gaT1CqFbZaFsUKRiDf0RHWpou1AZGYwGeuw_1o,12180
+gemini_cli_proxy/models.py,sha256=SiyesskO4J3rLb4nayxHc4cpbTKQQ6j7osTOsTo7Ems,3033
+gemini_cli_proxy/openai_adapter.py,sha256=oi4W4SjuFjii-v42KVWqh1UGzaTXI_KvrUIhBTcOiFM,5482
+gemini_cli_proxy/server.py,sha256=a25eSsTUWyTLxNjFfcOFiL2TUgykaQRc3dBgfp6pC-8,5696
+gemini_cli_proxy-1.1.0.dist-info/METADATA,sha256=ujEj4r8IPPIfqHnA2HfsWOYjfOj6XCBhh9aWAnKzl3E,4085
+gemini_cli_proxy-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gemini_cli_proxy-1.1.0.dist-info/entry_points.txt,sha256=wDLl4ePzvEWNQMSxoE7rKV5k8_MpK6yQwpYdiaXjcWI,63
+gemini_cli_proxy-1.1.0.dist-info/licenses/LICENSE,sha256=-LKYkZXXzjCmYRVwR74fDmMHP3gNlKIW_UUuEbY9hq8,1068
+gemini_cli_proxy-1.1.0.dist-info/RECORD,,

gemini_cli_proxy-1.0.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-gemini_cli_proxy/__init__.py,sha256=fOI3EtGmmggiMc3uGV8lGLsbzXmM3ADfnFbaHnwrKtg,257
-gemini_cli_proxy/cli.py,sha256=hc83w1AUobLN_-ONITforwdyQBx_0jwGyn-M_zbh4LQ,1555
-gemini_cli_proxy/config.py,sha256=5erCL5v5sb2Kz-Kje-luCw7EJUB8oq5wU3fdBnMS3H0,854
-gemini_cli_proxy/gemini_client.py,sha256=nfRbgzTHvh7w4QsLzG-s5B964JIBzwt--PE3jvQT0R4,5735
-gemini_cli_proxy/models.py,sha256=3FNvKk4CuLUU7MrFM0X12HeEN5paRPrRoJO0083KLfQ,2779
-gemini_cli_proxy/openai_adapter.py,sha256=x_8dUcob1DOLnKbTLQBsmN_e1dO6mX0DFaXqUmzcBzY,5394
-gemini_cli_proxy/server.py,sha256=6u6vEc4nqrh6eocflmx8JuHTZuWoH4uKJdfdblMnJfo,5383
-gemini_cli_proxy-1.0.3.dist-info/METADATA,sha256=vi5AG8BOBCWU25lJyIUXmKybadk4GzwOcZ8mJzhSzrg,4006
-gemini_cli_proxy-1.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gemini_cli_proxy-1.0.3.dist-info/entry_points.txt,sha256=wDLl4ePzvEWNQMSxoE7rKV5k8_MpK6yQwpYdiaXjcWI,63
-gemini_cli_proxy-1.0.3.dist-info/licenses/LICENSE,sha256=-LKYkZXXzjCmYRVwR74fDmMHP3gNlKIW_UUuEbY9hq8,1068
-gemini_cli_proxy-1.0.3.dist-info/RECORD,,