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

gemini_cli_proxy/__init__.py

@@ -0,0 +1,9 @@
+"""
+Gemini CLI Proxy - OpenAI-compatible API wrapper for Gemini CLI
+
+An OpenAI-compatible HTTP API wrapper for Google Gemini command line tool
+"""
+
+__version__ = "1.0.0"
+__author__ = "nettee"
+__description__ = "OpenAI-compatible API wrapper for Gemini CLI" 

gemini_cli_proxy/cli.py

@@ -0,0 +1,84 @@
+"""
+CLI entry module
+
+Uses Click to handle command line arguments and application startup
+"""
+
+import click
+import uvicorn
+
+
+@click.command()
+@click.option(
+    "--host",
+    default="127.0.0.1",
+    help="Server host address"
+)
+@click.option(
+    "--port",
+    default=8765,
+    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,
+    type=int,
+    help="Maximum requests per minute"
+)
+@click.option(
+    "--max-concurrency",
+    default=4,
+    type=int,
+    help="Maximum concurrent subprocesses"
+)
+@click.option(
+    "--timeout",
+    default=30.0,
+    type=float,
+    help="Gemini CLI command timeout in seconds"
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug mode"
+)
+def main(
+    host: str,
+    port: int,
+    log_level: str,
+    rate_limit: int,
+    max_concurrency: int,
+    timeout: float,
+    debug: bool
+):
+    """Start Gemini CLI Proxy server"""
+    
+    # Set configuration
+    from .config import config
+    config.host = host
+    config.port = port
+    config.log_level = log_level
+    config.rate_limit = rate_limit
+    config.max_concurrency = max_concurrency
+    config.timeout = timeout
+    config.debug = debug
+    
+    # Start server
+    uvicorn.run(
+        "gemini_cli_proxy.server:app",
+        host=host,
+        port=port,
+        log_level=log_level,
+        reload=debug
+    )
+
+
+if __name__ == "__main__":
+    main() 

gemini_cli_proxy/config.py

@@ -0,0 +1,34 @@
+"""
+Configuration management module
+
+Manages application configuration
+"""
+
+
+class Config:
+    """Application configuration class"""
+    
+    def __init__(self):
+        # Server configuration
+        self.host: str = "127.0.0.1"
+        self.port: int = 8765
+        self.log_level: str = "info"
+        self.debug: bool = False
+        
+        # Gemini CLI configuration
+        self.gemini_command: str = "gemini"  # Gemini CLI command path
+        self.timeout: float = 30.0
+        
+        # Limit configuration
+        self.rate_limit: int = 60  # Requests per minute
+        self.max_concurrency: int = 4  # Maximum concurrent subprocesses
+        
+        # Supported models list
+        self.supported_models: list = [
+            "gemini-2.5-pro",
+            "gemini-2.5-flash",
+        ]
+
+
+# Global configuration instance
+config = Config() 

gemini_cli_proxy/gemini_client.py

@@ -0,0 +1,175 @@
+"""
+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() 

gemini_cli_proxy/models.py

@@ -0,0 +1,97 @@
+"""
+Data model definition module
+
+Uses Pydantic to define OpenAI format request and response models
+"""
+
+from typing import List, Optional, Union, Dict, Any, Literal
+from pydantic import BaseModel, Field
+import time
+import uuid
+
+
+class ChatMessage(BaseModel):
+    """Chat message model"""
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    """Chat completion request model"""
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = Field(default=0.7, ge=0.0, le=2.0)
+    max_tokens: Optional[int] = Field(default=None, gt=0)
+    stream: Optional[bool] = False
+    top_p: Optional[float] = Field(default=1.0, ge=0.0, le=1.0)
+    frequency_penalty: Optional[float] = Field(default=0.0, ge=-2.0, le=2.0)
+    presence_penalty: Optional[float] = Field(default=0.0, ge=-2.0, le=2.0)
+    stop: Optional[Union[str, List[str]]] = None
+    user: Optional[str] = None
+
+
+class ChatCompletionChoice(BaseModel):
+    """Chat completion choice model"""
+    index: int
+    message: ChatMessage
+    finish_reason: Literal["stop", "length", "content_filter"] = "stop"
+
+
+class ChatCompletionResponse(BaseModel):
+    """Chat completion response model"""
+    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4().hex[:12]}")
+    object: str = "chat.completion"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    choices: List[ChatCompletionChoice]
+    # Note: According to design document, usage field is omitted since gemini CLI doesn't provide token usage info
+
+
+class ChatCompletionStreamChoice(BaseModel):
+    """Streaming chat completion choice model"""
+    index: int
+    delta: Dict[str, Any]
+    finish_reason: Optional[Literal["stop", "length", "content_filter"]] = None
+
+
+class ChatCompletionStreamResponse(BaseModel):
+    """Streaming chat completion response model"""
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: List[ChatCompletionStreamChoice]
+
+
+class ErrorDetail(BaseModel):
+    """Error detail model"""
+    message: str
+    type: str
+    param: Optional[str] = None
+    code: Optional[str] = None
+
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+    error: ErrorDetail
+
+
+class ModelInfo(BaseModel):
+    """Model information model"""
+    id: str
+    object: str = "model"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    owned_by: str = "gemini-cli-proxy"
+
+
+class ModelsResponse(BaseModel):
+    """Models list response model"""
+    object: str = "list"
+    data: List[ModelInfo]
+
+
+class HealthResponse(BaseModel):
+    """Health check response model"""
+    status: str = "ok"
+    version: str
+    timestamp: int = Field(default_factory=lambda: int(time.time())) 

gemini_cli_proxy/openai_adapter.py

@@ -0,0 +1,157 @@
+"""
+OpenAI adapter module
+
+Handles format conversion and compatibility
+"""
+
+import time
+import uuid
+import logging
+from typing import AsyncGenerator
+from fastapi.responses import StreamingResponse
+
+from .models import (
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ChatCompletionChoice,
+    ChatCompletionStreamResponse,
+    ChatCompletionStreamChoice,
+    ChatMessage
+)
+from .gemini_client import gemini_client
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIAdapter:
+    """OpenAI format adapter"""
+    
+    async def chat_completion(self, request: ChatCompletionRequest) -> ChatCompletionResponse:
+        """
+        Handle chat completion request (non-streaming)
+        
+        Args:
+            request: OpenAI format chat completion request
+            
+        Returns:
+            OpenAI format chat completion response
+        """
+        logger.info(f"Processing chat completion request, model: {request.model}, messages: {len(request.messages)}")
+        
+        try:
+            # Call Gemini CLI
+            response_text = await gemini_client.chat_completion(
+                messages=request.messages,
+                temperature=request.temperature,
+                max_tokens=request.max_tokens
+            )
+            
+            # Build OpenAI format response
+            response = ChatCompletionResponse(
+                model=request.model,
+                choices=[
+                    ChatCompletionChoice(
+                        index=0,
+                        message=ChatMessage(
+                            role="assistant",
+                            content=response_text
+                        ),
+                        finish_reason="stop"
+                    )
+                ]
+            )
+            
+            logger.info(f"Chat completion request processed successfully, response length: {len(response_text)}")
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error processing chat completion request: {e}")
+            raise
+    
+    async def chat_completion_stream(self, request: ChatCompletionRequest) -> StreamingResponse:
+        """
+        Handle streaming chat completion request
+        
+        Args:
+            request: OpenAI format chat completion request
+            
+        Returns:
+            Streaming response
+        """
+        logger.info(f"Processing streaming chat completion request, model: {request.model}, messages: {len(request.messages)}")
+        
+        async def generate_stream():
+            """Generate streaming response data"""
+            completion_id = f"chatcmpl-{uuid.uuid4().hex[:12]}"
+            created_time = int(time.time())
+            
+            try:
+                # Get streaming data generator
+                stream_generator = gemini_client.chat_completion_stream(
+                    messages=request.messages,
+                    temperature=request.temperature,
+                    max_tokens=request.max_tokens
+                )
+                
+                # Send data chunks one by one
+                async for chunk in stream_generator:
+                    stream_response = ChatCompletionStreamResponse(
+                        id=completion_id,
+                        created=created_time,
+                        model=request.model,
+                        choices=[
+                            ChatCompletionStreamChoice(
+                                index=0,
+                                delta={"content": chunk},
+                                finish_reason=None
+                            )
+                        ]
+                    )
+                    
+                    # Send data chunk
+                    yield f"data: {stream_response.model_dump_json()}\n\n"
+                
+                # Send end marker
+                final_response = ChatCompletionStreamResponse(
+                    id=completion_id,
+                    created=created_time,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionStreamChoice(
+                            index=0,
+                            delta={},
+                            finish_reason="stop"
+                        )
+                    ]
+                )
+                yield f"data: {final_response.model_dump_json()}\n\n"
+                yield "data: [DONE]\n\n"
+                
+                logger.info("Streaming chat completion request processed successfully")
+                
+            except Exception as e:
+                logger.error(f"Error processing streaming chat completion request: {e}")
+                # Send error information
+                error_response = {
+                    "error": {
+                        "message": str(e),
+                        "type": "internal_error"
+                    }
+                }
+                yield f"data: {error_response}\n\n"
+                yield "data: [DONE]\n\n"
+        
+        return StreamingResponse(
+            generate_stream(),
+            media_type="text/plain",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Headers": "*",
+            }
+        )
+
+
+# Global adapter instance
+openai_adapter = OpenAIAdapter() 

gemini_cli_proxy/server.py

@@ -0,0 +1,187 @@
+"""
+FastAPI server module
+
+Implements HTTP service and API endpoints
+"""
+
+import asyncio
+import logging
+import traceback
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+from . import __version__
+from .config import config
+from .models import (
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ErrorResponse,
+    ErrorDetail,
+    HealthResponse,
+    ModelsResponse,
+    ModelInfo
+)
+from .openai_adapter import openai_adapter
+
+# Configure logging
+logging.basicConfig(
+    level=getattr(logging, config.log_level.upper()),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Create rate limiter
+limiter = Limiter(key_func=get_remote_address)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifecycle management"""
+    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}")
+    yield
+    logger.info("Shutting down Gemini CLI Proxy")
+
+
+# Create FastAPI application
+app = FastAPI(
+    title="Gemini CLI Proxy",
+    description="OpenAI-compatible API wrapper for Gemini CLI",
+    version=__version__,
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Add rate limiting
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Global exception handler"""
+    logger.error(f"Unhandled exception occurred while processing request: {exc}")
+    logger.error(f"Exception details: {traceback.format_exc()}")
+    
+    error_response = ErrorResponse(
+        error=ErrorDetail(
+            message="Internal server error",
+            type="internal_error",
+            code="500"
+        )
+    )
+    
+    return JSONResponse(
+        status_code=500,
+        content=error_response.model_dump()
+    )
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    return HealthResponse(version=__version__)
+
+
+@app.get("/v1/models", response_model=ModelsResponse)
+async def list_models():
+    """List available models"""
+    models = [
+        ModelInfo(id=model_id) for model_id in config.supported_models
+    ]
+    
+    return ModelsResponse(data=models)
+
+
+@app.post("/v1/chat/completions")
+@limiter.limit(f"{config.rate_limit}/minute")
+async def chat_completions(
+    chat_request: ChatCompletionRequest,
+    request: Request
+):
+    """
+    Chat completion endpoint
+    
+    Implements OpenAI-compatible chat completion API
+    """
+    logger.info(f"Received chat completion request: model={chat_request.model}, stream={chat_request.stream}")
+    
+    try:
+        # Validate model
+        if chat_request.model not in config.supported_models:
+            raise HTTPException(
+                status_code=400,
+                detail=ErrorResponse(
+                    error=ErrorDetail(
+                        message=f"Unsupported model: {chat_request.model}. Supported models: {', '.join(config.supported_models)}",
+                        type="invalid_request_error",
+                        param="model"
+                    )
+                ).model_dump()
+            )
+        
+        # Handle streaming request
+        if chat_request.stream:
+            return await openai_adapter.chat_completion_stream(chat_request)
+        
+        # Handle non-streaming request
+        response = await openai_adapter.chat_completion(chat_request)
+        return response
+        
+    except HTTPException:
+        raise
+    except asyncio.TimeoutError:
+        logger.error("Gemini CLI command execution timeout")
+        raise HTTPException(
+            status_code=502,
+            detail=ErrorResponse(
+                error=ErrorDetail(
+                    message="Gemini CLI command execution timeout",
+                    type="bad_gateway",
+                    code="502"
+                )
+            ).model_dump()
+        )
+    except RuntimeError as e:
+        logger.error(f"Gemini CLI execution error: {e}")
+        raise HTTPException(
+            status_code=502,
+            detail=ErrorResponse(
+                error=ErrorDetail(
+                    message=str(e),
+                    type="bad_gateway",
+                    code="502"
+                )
+            ).model_dump()
+        )
+    except Exception as e:
+        logger.error(f"Error processing chat completion request: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=ErrorResponse(
+                error=ErrorDetail(
+                    message="Internal server error",
+                    type="internal_error",
+                    code="500"
+                )
+            ).model_dump()
+        )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host=config.host, port=config.port) 

gemini_cli_proxy-1.0.3.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: gemini-cli-proxy
+Version: 1.0.3
+Summary: OpenAI-compatible API wrapper for Gemini CLI
+Author: nettee
+License: MIT
+License-File: LICENSE
+Keywords: api,cli,gemini,openai,proxy
+Requires-Python: >=3.8
+Requires-Dist: click<9.0,>=8.0.0
+Requires-Dist: fastapi<1.0,>=0.104.0
+Requires-Dist: pydantic<3.0,>=2.0.0
+Requires-Dist: slowapi<1.0,>=0.1.9
+Requires-Dist: uvicorn[standard]<1.0,>=0.24.0
+Description-Content-Type: text/markdown
+
+# Gemini CLI Proxy
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Wrap Gemini CLI as an OpenAI-compatible API service, allowing you to enjoy the free Gemini 2.5 Pro model through API!
+
+[English](./README.md) | [简体中文](./README_zh.md)
+
+## ✨ Features
+
+- 🔌 **OpenAI API Compatible**: Implements `/v1/chat/completions` endpoint
+- 🚀 **Quick Setup**: Zero-config run with `uvx`
+- ⚡ **High Performance**: Built on FastAPI + asyncio with concurrent request support
+
+## 🚀 Quick Start
+
+### Network Configuration
+
+Since Gemini needs to access Google services, you may need to configure terminal proxy in certain network environments:
+
+```bash
+# Configure proxy (adjust according to your proxy server)
+export https_proxy=http://127.0.0.1:7890
+export http_proxy=http://127.0.0.1:7890  
+export all_proxy=socks5://127.0.0.1:7890
+```
+
+### Install Gemini CLI
+
+Install Gemini CLI:
+```bash
+npm install -g @google/gemini-cli
+```
+
+After installation, use the `gemini` command to run Gemini CLI. You need to start it once first for login and initial configuration.
+
+After configuration is complete, please confirm you can successfully run the following command:
+
+```bash
+gemini -p "Hello, Gemini"
+```
+
+### Start Gemini CLI Proxy
+
+```bash
+uv run gemini-cli-proxy
+```
+
+Gemini CLI Proxy listens on port `8765` by default. You can customize the startup port with the `--port` parameter.
+
+After startup, test the service with curl:
+
+```bash
+curl http://localhost:8765/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer dummy-key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{"role": "user", "content": "Hello!"}]
+  }'
+```
+
+### Usage Examples
+
+#### OpenAI Client
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url='http://localhost:8765/v1',
+    api_key='dummy-key'  # Any string works
+)
+
+response = client.chat.completions.create(
+    model='gemini-2.5-pro',
+    messages=[
+        {'role': 'user', 'content': 'Hello!'}
+    ],
+)
+
+print(response.choices[0].message.content)
+```
+
+#### Cherry Studio
+
+Add Model Provider in Cherry Studio settings:
+- Provider Type: OpenAI
+- API Host: `http://localhost:8765`
+- API Key: Any string works
+- Model Name: `gemini-2.5-pro` or `gemini-2.5-flash`
+
+![Cherry Studio Config 1](./img/cherry-studio-1.jpg)
+
+![Cherry Studio Config 2](./img/cherry-studio-2.jpg)
+
+## ⚙️ Configuration Options
+
+View command line parameters:
+
+```bash
+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
+
+## ❓ FAQ
+
+### Q: Why do requests keep timing out?
+
+A: This is usually a network connectivity issue. Gemini needs to access Google services, which may require proxy configuration in certain regions:
+
+```bash
+# Configure proxy (adjust according to your proxy server)
+export https_proxy=http://127.0.0.1:7890
+export http_proxy=http://127.0.0.1:7890
+export all_proxy=socks5://127.0.0.1:7890
+
+# Then start the service
+uvx gemini-cli-proxy
+```
+
+## 📄 License
+
+MIT License
+
+## 🤝 Contributing
+
+Issues and Pull Requests are welcome! 

gemini_cli_proxy-1.0.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+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,,

gemini_cli_proxy-1.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gemini_cli_proxy-1.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gemini-cli-proxy = gemini_cli_proxy.cli:main

gemini_cli_proxy-1.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.