gemini-cli-proxy 1.0.3__tar.gz → 1.1.0__tar.gz

{gemini_cli_proxy-1.0.3 → gemini_cli_proxy-1.1.0}/.gitignore

@@ -195,3 +195,6 @@ cython_debug/
 
 /local-docs/
 /local-scripts/
+
+# Temporary image files for Gemini CLI
+.gemini-cli-proxy/

{gemini_cli_proxy-1.0.3 → gemini_cli_proxy-1.1.0}/PKG-INFO

@@ -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.0.3 → gemini_cli_proxy-1.1.0}/README.md

@@ -43,6 +43,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
 ```
@@ -106,11 +112,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.0.3 → gemini_cli_proxy-1.1.0}/README_zh.md

@@ -43,6 +43,12 @@ gemini -p "Hello, Gemini"
 
 ### 启动 Gemini CLI Proxy
 
+方法一：直接启动运行
+```bash
+uvx gemini-cli-proxy
+```
+
+方法二：克隆本仓库，然后运行：
 ```bash
 uv run gemini-cli-proxy
 ```
@@ -106,11 +112,10 @@ gemini-cli-proxy --help
 可用选项：
 - `--host`: 服务器主机地址 (默认: 127.0.0.1)
 - `--port`: 服务器端口 (默认: 8765)
-- `--log-level`: 日志级别 (debug/info/warning/error/critical)
 - `--rate-limit`: 每分钟最大请求数 (默认: 60)
 - `--max-concurrency`: 最大并发子进程数 (默认: 4)
 - `--timeout`: Gemini CLI 命令超时时间，单位秒 (默认: 30.0)
-- `--debug`: 启用调试模式
+- `--debug`: 启用调试模式 (启用调试日志和文件监控)
 
 ## ❓ 常见问题
 

{gemini_cli_proxy-1.0.3 → gemini_cli_proxy-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gemini-cli-proxy"
-version = "1.0.3"
+version = "1.1.0"
 description = "OpenAI-compatible API wrapper for Gemini CLI"
 readme = "README.md"
 license = { text = "MIT" }

{gemini_cli_proxy-1.0.3 → gemini_cli_proxy-1.1.0}/src/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-1.0.3 → gemini_cli_proxy-1.1.0}/src/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-1.1.0/src/gemini_cli_proxy/gemini_client.py

@@ -0,0 +1,336 @@
+"""
+Gemini client module
+
+Handles interaction with Gemini CLI tool
+"""
+
+import asyncio
+import logging
+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('gemini_cli_proxy')
+
+
+class GeminiClient:
+    """Gemini CLI client"""
+    
+    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
+    ) -> str:
+        """
+        Execute chat completion request
+        
+        Args:
+            messages: List of chat messages
+            model: Model name to use
+            temperature: Temperature parameter
+            max_tokens: Maximum number of tokens
+            **kwargs: Other parameters
+            
+        Returns:
+            Response text from Gemini CLI
+            
+        Raises:
+            asyncio.TimeoutError: Timeout error
+            subprocess.CalledProcessError: Command execution error
+        """
+        async with self.semaphore:
+            return await self._execute_gemini_command(
+                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
+    ) -> AsyncGenerator[str, None]:
+        """
+        Execute streaming chat completion request (fake streaming implementation)
+        
+        Args:
+            messages: List of chat messages
+            model: Model name to use
+            temperature: Temperature parameter
+            max_tokens: Maximum number of tokens
+            **kwargs: Other parameters
+            
+        Yields:
+            Response text chunks split by lines
+        """
+        # First get complete response
+        full_response = await self.chat_completion(
+            messages, model, temperature, max_tokens, **kwargs
+        )
+        
+        # Split by lines and yield one by one
+        lines = full_response.split('\n')
+        for line in lines:
+            if line.strip():  # Skip empty lines
+                yield line.strip()
+                # Add small delay to simulate streaming effect
+                await asyncio.sleep(0.05)
+    
+    async def _execute_gemini_command(
+        self,
+        messages: List[ChatMessage],
+        model: str,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> str:
+        """
+        Execute Gemini CLI command
+        
+        Args:
+            messages: List of chat messages
+            model: Model name to use
+            temperature: Temperature parameter
+            max_tokens: Maximum number of tokens
+            **kwargs: Other parameters
+            
+        Returns:
+            Command output result
+        """
+        # Build command arguments and get temporary files
+        prompt, temp_files = self._build_prompt_with_images(messages)
+        
+        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
+        if temperature is not None:
+            logger.debug(f"Ignoring temperature parameter: {temperature} (gemini CLI doesn't support)")
+        if max_tokens is not None:
+            logger.debug(f"Ignoring max_tokens parameter: {max_tokens} (gemini CLI doesn't support)")
+        
+        logger.debug(f"Executing command: {' '.join(cmd_args)}")
+        
+        try:
+            # Use asyncio to execute subprocess
+            process = await asyncio.create_subprocess_exec(
+                *cmd_args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            
+            # Wait for command execution to complete with timeout
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=config.timeout
+            )
+            
+            # Check return code
+            if process.returncode != 0:
+                error_msg = stderr.decode('utf-8').strip()
+                
+                # 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"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 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_with_images(self, messages: List[ChatMessage]) -> Tuple[str, List[str]]:
+        """
+        Build prompt text with image processing
+        
+        Args:
+            messages: List of chat messages
+            
+        Returns:
+            Tuple of (formatted prompt text, list of temporary file paths)
+        """
+        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}")
+        
+        return final_prompt, temp_files
+    
+    def _save_base64_image(self, data_url: str) -> str:
+        """
+        Save base64 image data to temporary file
+        
+        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_client = GeminiClient() 

{gemini_cli_proxy-1.0.3 → gemini_cli_proxy-1.1.0}/src/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-1.0.3 → gemini_cli_proxy-1.1.0}/src/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-1.0.3 → gemini_cli_proxy-1.1.0}/src/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 → gemini_cli_proxy-1.1.0}/uv.lock

@@ -379,7 +379,7 @@ wheels = [
 
 [[package]]
 name = "gemini-cli-proxy"
-version = "1.0.3"
+version = "1.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },

gemini_cli_proxy-1.0.3/src/gemini_cli_proxy/gemini_client.py

@@ -1,175 +0,0 @@
-"""
-Gemini client module
-
-Handles interaction with Gemini CLI tool
-"""
-
-import asyncio
-import logging
-from typing import List, Optional, AsyncGenerator
-from .models import ChatMessage
-from .config import config
-
-logger = logging.getLogger(__name__)
-
-
-class GeminiClient:
-    """Gemini CLI client"""
-    
-    def __init__(self):
-        self.semaphore = asyncio.Semaphore(config.max_concurrency)
-    
-    async def chat_completion(
-        self,
-        messages: List[ChatMessage],
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> str:
-        """
-        Execute chat completion request
-        
-        Args:
-            messages: List of chat messages
-            temperature: Temperature parameter
-            max_tokens: Maximum number of tokens
-            **kwargs: Other parameters
-            
-        Returns:
-            Response text from Gemini CLI
-            
-        Raises:
-            asyncio.TimeoutError: Timeout error
-            subprocess.CalledProcessError: Command execution error
-        """
-        async with self.semaphore:
-            return await self._execute_gemini_command(
-                messages, temperature, max_tokens, **kwargs
-            )
-    
-    async def chat_completion_stream(
-        self,
-        messages: List[ChatMessage],
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> AsyncGenerator[str, None]:
-        """
-        Execute streaming chat completion request (fake streaming implementation)
-        
-        Args:
-            messages: List of chat messages
-            temperature: Temperature parameter
-            max_tokens: Maximum number of tokens
-            **kwargs: Other parameters
-            
-        Yields:
-            Response text chunks split by lines
-        """
-        # First get complete response
-        full_response = await self.chat_completion(
-            messages, temperature, max_tokens, **kwargs
-        )
-        
-        # Split by lines and yield one by one
-        lines = full_response.split('\n')
-        for line in lines:
-            if line.strip():  # Skip empty lines
-                yield line.strip()
-                # Add small delay to simulate streaming effect
-                await asyncio.sleep(0.05)
-    
-    async def _execute_gemini_command(
-        self,
-        messages: List[ChatMessage],
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> str:
-        """
-        Execute Gemini CLI command
-        
-        Args:
-            messages: List of chat messages
-            temperature: Temperature parameter
-            max_tokens: Maximum number of tokens
-            **kwargs: Other parameters
-            
-        Returns:
-            Command output result
-        """
-        # Build command arguments
-        cmd_args = [config.gemini_command]
-        
-        # 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])
-        
-        # Note: Real gemini CLI doesn't support temperature and max_tokens parameters
-        # We ignore these parameters here but log them
-        if temperature is not None:
-            logger.debug(f"Ignoring temperature parameter: {temperature} (gemini CLI doesn't support)")
-        if max_tokens is not None:
-            logger.debug(f"Ignoring max_tokens parameter: {max_tokens} (gemini CLI doesn't support)")
-        
-        logger.debug(f"Executing command: {' '.join(cmd_args)}")
-        
-        try:
-            # Use asyncio to execute subprocess
-            process = await asyncio.create_subprocess_exec(
-                *cmd_args,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
-            )
-            
-            # Wait for command execution to complete with timeout
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(),
-                timeout=config.timeout
-            )
-            
-            # 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}")
-            
-            # Return standard output
-            result = stdout.decode('utf-8').strip()
-            logger.debug(f"Command executed successfully, output length: {len(result)}")
-            return result
-            
-        except asyncio.TimeoutError:
-            logger.error(f"Gemini CLI command timeout ({config.timeout}s)")
-            raise
-        except Exception as e:
-            logger.error(f"Error executing Gemini CLI command: {e}")
-            raise
-    
-    def _build_prompt(self, messages: List[ChatMessage]) -> str:
-        """
-        Build prompt text
-        
-        Args:
-            messages: List of chat messages
-            
-        Returns:
-            Formatted prompt text
-        """
-        # Simplified implementation: format all messages by role
-        prompt_parts = []
-        
-        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 "\n".join(prompt_parts)
-
-
-# Global client instance
-gemini_client = GeminiClient()