Refactoring

Author: Aculeasis

README.md

@@ -1,6 +1,7 @@
 # OpenRouter Proxy
 
-A simple proxy server for OpenRouter API that helps bypass rate limits on free API keys by rotating through multiple keys in a round-robin fashion.
+A simple proxy server for OpenRouter API that helps bypass rate limits on free API keys 
+by rotating through multiple API keys in a round-robin fashion.
 
 ## Features
 
@@ -9,20 +10,21 @@ A simple proxy server for OpenRouter API that helps bypass rate limits on free A
 - Automatically disables API keys temporarily when rate limits are reached
 - Streams responses chunk by chunk for efficient data transfer
 - Simple authentication for accessing the proxy
+- Uses OpenAI SDK for compatible endpoints for reliable handling
 
 ## Setup
 
 1. Clone the repository
 2. Create a virtual environment and install dependencies:
-```
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install -r requirements.txt
-```
+    ```
+    python -m venv venv
+    source venv/bin/activate  # On Windows: venv\Scripts\activate
+    pip install -r requirements.txt
+    ```
 3. Create a configuration file:
-```
-cp config.yml.example config.yml
-```
+    ```
+    cp config.yml.example config.yml
+    ```
 4. Edit `config.yml` to add your OpenRouter API keys and configure the server
 
 ## Configuration
@@ -36,13 +38,14 @@ server:
   port: 5555       # Port to listen on
   access_key: "your_local_access_key_here"  # Authentication key
   log_level: "INFO"  # Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+  http_log_level: "INFO"  # HTTP access logs level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
 
 # OpenRouter API keys
 openrouter:
   keys:
     - "sk-or-v1-your-first-api-key"
     - "sk-or-v1-your-second-api-key"
-  rate_limit_cooldown: 7200  # Seconds to disable key after rate limit (2 hours)
+  rate_limit_cooldown: 14400  # Seconds to disable key after rate limit (4 hours)
 ```
 
 ## Usage
@@ -92,13 +95,21 @@ Authorization: Bearer your_local_access_key_here
 
 ## API Endpoints
 
-The proxy supports all OpenRouter API v1 endpoints, including:
+The proxy supports all OpenRouter API v1 endpoints through the following endpoint:
+
+- `/api/v1/{path}` - Proxies all requests to OpenRouter API v1
+
+It also provides a health check endpoint:
+
+- `/health` - Health check endpoint that returns `{"status": "ok"}`
+
+## Dependencies
 
-- `/api/v1/chat/completions` - Chat completions
-- `/api/v1/completions` - Text completions
-- `/api/v1/embeddings` - Text embeddings
-- `/api/v1/models` - List available models (no auth required)
-- `/api/v1/models/:author/:slug/endpoints` - Get specific model endpoints (no auth required)
+- FastAPI - Web framework
+- uvicorn - ASGI server
+- httpx - HTTP client
+- OpenAI - SDK for handling OpenAI-compatible endpoints
+- PyYAML - YAML parsing
 
 ## License
 

routes.py

@@ -53,10 +53,7 @@ async def proxy_endpoint(
 
     # Verify authorization for non-public endpoints
     if not is_public:
-        await verify_access_key(
-            authorization=authorization,
-            access_key=config["server"]["access_key"],
-        )
+        await verify_access_key(authorization=authorization)
 
     # Log the full request URL including query parameters
     full_url = str(request.url).replace(str(request.base_url), "/")
@@ -68,7 +65,14 @@ async def proxy_endpoint(
     # Parse request body (if any)
     request_body = None
     is_stream = False
-
+    # Get API key to use
+    if not is_public:
+        api_key = await key_manager.get_next_key()
+        if not api_key:
+            raise HTTPException(status_code=503, detail="No available API keys")
+    else:
+        # For public endpoints, we don't need an API key
+        api_key = ""
     try:
         body_bytes = await request.body()
         if body_bytes:
@@ -93,21 +97,12 @@ async def proxy_endpoint(
         logger.debug("Could not parse request body: %s", str(e))
         request_body = None
 
-    # For binary, models endpoint, non-OpenAI-compatible endpoints or requests with model-specific parameters, fall back to httpx
+    # For models, non-OpenAI-compatible endpoints or requests with model-specific parameters, fall back to httpx
     if is_httpx or not is_openai:
-        return await proxy_with_httpx(request, path, is_public, is_stream, is_completion)
+        return await proxy_with_httpx(request, path, api_key, is_stream, is_completion)
 
     # For OpenAI-compatible endpoints, use the OpenAI library
     try:
-        # Get API key to use
-        if not is_public:
-            api_key = await key_manager.get_next_key()
-            if not api_key:
-                raise HTTPException(status_code=503, detail="No available API keys")
-        else:
-            # For public endpoints, we don't need an API key
-            api_key = ""
-
         # Create an OpenAI client
         client = await get_openai_client(api_key)
 
@@ -119,7 +114,7 @@ async def proxy_endpoint(
         else:
             # Fallback for other endpoints
             return await proxy_with_httpx(
-                request, path, is_public, is_stream, is_completion
+                request, path, api_key, is_stream, is_completion
             )
 
     except Exception as e:
@@ -234,10 +229,19 @@ async def stream_response() -> AsyncGenerator[bytes, None]:
         raise HTTPException(500, f"Error processing chat completion: {str(e)}") from e
 
 
+async def _check_httpx_err(body: str or bytes, api_key: str or None):
+    if api_key and (isinstance(body, str) and body.startswith("data: ") or (
+            isinstance(body, bytes) and body.startswith(b"data: "))):
+        body = body[6:]
+        has_rate_limit_error, reset_time_ms = check_rate_limit(body)
+        if has_rate_limit_error:
+            logger.warning("Rate limit detected in stream. Disabling key.")
+            await key_manager.disable_key(api_key, reset_time_ms)
+
 async def proxy_with_httpx(
     request: Request,
     path: str,
-    is_public: bool,
+    api_key: str,
     is_stream: bool,
     is_completion: bool,
 ) -> Response:
@@ -260,20 +264,20 @@ async def proxy_with_httpx(
             if request.query_params:
                 req_kwargs["url"] = f"{req_kwargs['url']}?{request.url.query}"
 
-            if not is_public:
-                # For authenticated endpoints, use API key rotation
-                api_key = await key_manager.get_next_key()
+            if api_key:
                 req_kwargs["headers"]["Authorization"] = f"Bearer {api_key}"
 
 
             openrouter_resp = await client.request(**req_kwargs)
             if not is_stream:
+                body = await openrouter_resp.aread()
+                await _check_httpx_err(body, api_key)
                 return Response(
-                    content=await openrouter_resp.aread(),
+                    content=body,
                     status_code=openrouter_resp.status_code,
                     headers=dict(openrouter_resp.headers),
                 )
-            if is_public and not is_completion:
+            if not api_key and not is_completion:
                 return StreamingResponse(
                     openrouter_resp.aiter_bytes(),
                     status_code=openrouter_resp.status_code,
@@ -296,19 +300,13 @@ async def stream_completion():
                             yield f"{line}\n\n".encode("utf-8")
                 except Exception as err:
                     logger.error("stream_completion error: %s", err)
-                if not is_public and data.startswith('data: '):
-                    data = data[6:]
-                    has_rate_limit_error, reset_time_ms = check_rate_limit(data)
-                    if has_rate_limit_error:
-                        logger.warning("Rate limit detected in stream. Disabling key.")
-                        await key_manager.disable_key(api_key, reset_time_ms)
+                await _check_httpx_err(data, api_key)
 
             return StreamingResponse(
                 stream_completion(),
                 status_code=openrouter_resp.status_code,
                 headers=dict(openrouter_resp.headers),
             )
-
         except httpx.ConnectError as e:
             logger.error("Connection error to OpenRouter: %s", str(e))
             raise HTTPException(503, "Unable to connect to OpenRouter API") from e

test.py

@@ -50,8 +50,10 @@ async def test_openrouter_streaming():
     )
 
     headers = {
-        "HTTP-Referer": config.get("test", {}).get("http_referer", "http://localhost"),  # Optional. Site URL for rankings on openrouter.ai.
-        "X-Title": config.get("test", {}).get("x_title", "Local Test"),  # Optional. Site title for rankings on openrouter.ai.
+        # Optional. Site URL for rankings on openrouter.ai.
+        "HTTP-Referer": config.get("test", {}).get("http_referer", "http://localhost"),
+        # Optional. Site title for rankings on openrouter.ai.
+        "X-Title": config.get("test", {}).get("x_title", "Local Test"),
     }
     if not ACCESS_KEY:
         print("No valid access key found. Request may fail if server requires authentication.")

utils.py

@@ -10,7 +10,7 @@
 from fastapi import Header, HTTPException
 from openai import APIError
 
-from config import logger
+from config import config, logger
 from constants import RATE_LIMIT_ERROR_MESSAGE, RATE_LIMIT_ERROR_CODE
 
 
@@ -29,14 +29,12 @@ def get_local_ip() -> str:
 
 async def verify_access_key(
     authorization: Optional[str] = Header(None),
-    access_key: str = None,
 ) -> bool:
     """
     Verify the local access key for authentication.
 
     Args:
         authorization: Authorization header
-        access_key: Access key to verify
 
     Returns:
         True if authentication is successful
@@ -52,7 +50,7 @@ async def verify_access_key(
     if scheme.lower() != "bearer":
         raise HTTPException(status_code=401, detail="Invalid authentication scheme")
 
-    if token != access_key:
+    if token != config["server"]["access_key"]:
         raise HTTPException(status_code=401, detail="Invalid access key")
 
     return True
@@ -74,7 +72,7 @@ def check_rate_limit_openai(err: APIError) -> Tuple[bool, Optional[int]]:
         try:
             reset_time_ms = int(err.body["metadata"]["headers"]["X-RateLimit-Reset"])
             has_rate_limit_error = True
-        except Exception as _:
+        except (TypeError, KeyError):
             pass
 
     if reset_time_ms is None and RATE_LIMIT_ERROR_MESSAGE in err.message:
@@ -83,7 +81,7 @@ def check_rate_limit_openai(err: APIError) -> Tuple[bool, Optional[int]]:
     return has_rate_limit_error, reset_time_ms
 
 
-def check_rate_limit(data: str) -> Tuple[bool, Optional[int]]:
+def check_rate_limit(data: str or bytes) -> Tuple[bool, Optional[int]]:
     """
     Check for rate limit error.
 
@@ -99,21 +97,19 @@ def check_rate_limit(data: str) -> Tuple[bool, Optional[int]]:
         err = json.loads(data)
     except Exception as e:
         logger.warning('Json.loads error %s', e)
-        return has_rate_limit_error, reset_time_ms
-    if not isinstance(err, dict) or "error" not in err:
-        return has_rate_limit_error, reset_time_ms
-
-    code = err["error"].get("code", 0)
-    msg = err["error"].get("message", 0)
-    try:
-        x_rate_limit = int(err["error"]["metadata"]["headers"]["X-RateLimit-Reset"])
-    except (TypeError, KeyError):
-        x_rate_limit = None
-
-    if x_rate_limit :
-        has_rate_limit_error = True
-        reset_time_ms = x_rate_limit
-    elif code == RATE_LIMIT_ERROR_CODE and msg == RATE_LIMIT_ERROR_MESSAGE:
-        has_rate_limit_error = True
+    else:
+        if isinstance(err, dict) and "error" in err:
+            code = err["error"].get("code", 0)
+            msg = err["error"].get("message", 0)
+            try:
+                x_rate_limit = int(err["error"]["metadata"]["headers"]["X-RateLimit-Reset"])
+            except (TypeError, KeyError):
+                x_rate_limit = 0
+
+            if x_rate_limit > 0:
+                has_rate_limit_error = True
+                reset_time_ms = x_rate_limit
+            elif code == RATE_LIMIT_ERROR_CODE and msg == RATE_LIMIT_ERROR_MESSAGE:
+                has_rate_limit_error = True
 
     return has_rate_limit_error, reset_time_ms