initial

.gitignore

@@ -0,0 +1,93 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a pyinstaller script; this is potentially
+# problematic if you check your scripts into source control.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyderworkspace
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# profiling data
+*.prof
+*.prof.*
+
+# VS Code settings
+.vscode/
+
+# Mac specific
+.DS_Store
+
+# Dotenv environment variable files
+.env.*
+!.env.example

README.md

@@ -1,11 +1,48 @@
 ---
-title: Helicone
-emoji: 🦀
-colorFrom: red
-colorTo: gray
-sdk: docker
+title: OpenAI Proxy Server
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: fastapi
+app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# OpenAI Format Proxy Server
+
+This is a FastAPI proxy server designed to expose non-OpenAI standard endpoints (`https://us.helicone.ai/api/llm` for chat and `https://openrouter.ai/api/v1/models` for models) under the standard OpenAI API paths (`/v1/chat/completions` and `/v1/models`).
+
+## Features
+
+*   **OpenAI Compatibility:** Access the proxied endpoints using the standard OpenAI API structure.
+*   **Streaming Support:** Handles both streaming and non-streaming chat completion requests.
+*   **Authentication:** Protects the proxy server with Bearer token authentication (configure via `PROXY_API_KEY` environment variable).
+*   **Asynchronous:** Built with FastAPI for non-blocking, parallel request handling.
+*   **Hugging Face Ready:** Configured for easy deployment on Hugging Face Spaces.
+
+## Endpoints
+
+*   `GET /v1/models`: Proxies requests to `https://openrouter.ai/api/v1/models`. Requires `Authorization: Bearer <PROXY_API_KEY>`.
+*   `POST /v1/chat/completions`: Proxies requests to `https://us.helicone.ai/api/llm`. Requires `Authorization: Bearer <PROXY_API_KEY>`. Supports `stream: true`.
+*   `GET /health`: Health check endpoint.
+
+## Setup & Deployment (Hugging Face)
+
+1.  Create a new Space on Hugging Face ([https://huggingface.co/new-space](https://huggingface.co/new-space)).
+2.  Choose **FastAPI** as the SDK.
+3.  Upload the files from this repository (`app.py`, `requirements.txt`, `README.md`).
+4.  Go to the **Settings** tab of your Space.
+5.  Under **Secrets**, add a new secret:
+    *   **Name:** `PROXY_API_KEY`
+    *   **Value:** Your desired secret API key for accessing *this proxy*.
+6.  The Space should build and deploy automatically.
+
+## Local Development
+
+1.  Clone the repository.
+2.  Create a virtual environment: `python -m venv venv && source venv/bin/activate` (or `venv\Scripts\activate` on Windows).
+3.  Install dependencies: `pip install -r requirements.txt`.
+4.  Create a `.env` file in the root directory with the line: `PROXY_API_KEY=your_secret_key`
+5.  Run the server: `uvicorn app:app --reload --port 8000`
+6.  Access the proxy at `http://localhost:8000`. Use `Authorization: Bearer your_secret_key` in your requests.

app.py

@@ -0,0 +1,162 @@
+import os
+import httpx
+import aiohttp
+from fastapi import FastAPI, Request, HTTPException, Depends
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware # Add CORS Middleware import
+from dotenv import load_dotenv
+import json
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configuration
+REMOTE_CHAT_COMPLETION_URL = "https://us.helicone.ai/api/llm"
+REMOTE_MODELS_URL = "https://openrouter.ai/api/v1/models"
+EXPECTED_API_KEY = os.getenv("PROXY_API_KEY", "default_insecure_key") # Load API key from .env or use a default
+
+# --- Authentication ---
+security = HTTPBearer()
+
+async def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify the provided API key."""
+    if credentials.scheme != "Bearer" or credentials.credentials != EXPECTED_API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+    return credentials.credentials
+
+# --- FastAPI App ---
+app = FastAPI(
+    title="OpenAI Format Proxy",
+    description="A proxy server that translates requests to an OpenAI-compatible format.",
+    version="1.0.0",
+)
+
+# --- CORS Middleware ---
+# Allows requests from any origin, with any method and headers.
+# Adjust origins if you need to restrict access to specific domains.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods (GET, POST, OPTIONS, etc.)
+    allow_headers=["*"],  # Allows all headers
+)
+
+# --- Helper Functions ---
+async def forward_request(request: Request, target_url: str):
+    """Forwards the request to the target URL, handling streaming."""
+    async with httpx.AsyncClient(timeout=None) as client: # Use httpx for simplicity in non-streaming and model requests
+        # Prepare headers, exclude Host header
+        headers = {key: value for key, value in request.headers.items() if key.lower() != 'host'}
+        headers["Authorization"] = f"Bearer {EXPECTED_API_KEY}" # Assuming remote API needs the same key? Or remove if not needed. Let's remove for now based on description.
+        headers.pop("authorization", None) # Remove incoming auth header before forwarding
+
+        # Read request body
+        body = await request.body()
+        req_data = {}
+        if body:
+            try:
+                req_data = json.loads(body.decode('utf-8'))
+            except json.JSONDecodeError:
+                raise HTTPException(status_code=400, detail="Invalid JSON body")
+
+
+        # Check for streaming
+        stream = req_data.get("stream", False)
+
+        # Prepare the request to the target server
+        rp_req = client.build_request(
+            method=request.method,
+            url=target_url,
+            headers=headers,
+            content=body, # Forward the original body
+        )
+
+        if stream:
+            # Use aiohttp for better streaming control if httpx causes issues, otherwise httpx stream is fine.
+            # Let's try httpx first
+            try:
+                async with client.stream(
+                    request.method, target_url, headers=headers, content=body
+                ) as rp_resp:
+                    # Check for non-200 status codes from the target server and raise HTTPException
+                    if rp_resp.status_code != 200:
+                         error_content = await rp_resp.aread()
+                         raise HTTPException(status_code=rp_resp.status_code, detail=error_content.decode())
+
+                    # Stream the response back
+                    return StreamingResponse(
+                        rp_resp.aiter_raw(),
+                        status_code=rp_resp.status_code,
+                        headers=dict(rp_resp.headers),
+                        media_type=rp_resp.headers.get("content-type")
+                    )
+            except httpx.RequestError as e:
+                 raise HTTPException(status_code=502, detail=f"Error communicating with target server: {e}")
+
+        else:
+            # Handle non-streaming request
+            try:
+                rp_resp = await client.send(rp_req)
+                rp_resp.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
+                return JSONResponse(
+                     content=rp_resp.json(), # Forward JSON response
+                     status_code=rp_resp.status_code,
+                     headers=dict(rp_resp.headers)
+                 )
+            except httpx.HTTPStatusError as e:
+                 # Forward the exact error response if possible
+                 error_detail = e.response.text
+                 try:
+                     error_detail = e.response.json() # Try parsing as JSON
+                 except json.JSONDecodeError:
+                     pass # Keep as text if not JSON
+                 raise HTTPException(status_code=e.response.status_code, detail=error_detail)
+            except httpx.RequestError as e:
+                raise HTTPException(status_code=502, detail=f"Error communicating with target server: {e}")
+
+
+# --- API Endpoints ---
+
+@app.get("/v1/models", dependencies=[Depends(verify_api_key)])
+async def get_models(request: Request):
+    """Proxies requests to the remote models endpoint."""
+    async with httpx.AsyncClient(timeout=30.0) as client: # Shorter timeout for potentially faster models endpoint
+        try:
+            # We don't need to forward auth or body for models usually
+            headers = {key: value for key, value in request.headers.items() if key.lower() not in ['host', 'authorization']}
+            resp = await client.get(REMOTE_MODELS_URL, headers=headers)
+            resp.raise_for_status()
+            return JSONResponse(
+                content=resp.json(),
+                status_code=resp.status_code,
+                headers=dict(resp.headers)
+            )
+        except httpx.HTTPStatusError as e:
+             error_detail = e.response.text
+             try:
+                 error_detail = e.response.json()
+             except json.JSONDecodeError:
+                 pass
+             raise HTTPException(status_code=e.response.status_code, detail=error_detail)
+        except httpx.RequestError as e:
+            raise HTTPException(status_code=502, detail=f"Error communicating with models server: {e}")
+
+
+@app.post("/v1/chat/completions", dependencies=[Depends(verify_api_key)])
+async def chat_completions(request: Request):
+    """Proxies chat completion requests to the remote server, handling streaming."""
+    return await forward_request(request, REMOTE_CHAT_COMPLETION_URL)
+
+# --- Health Check --- (Good practice for deployments)
+@app.get("/health")
+async def health_check():
+    """Simple health check endpoint."""
+    return {"status": "ok"}
+
+# --- Main Execution --- (For local testing with uvicorn)
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 8000)) # Allow port configuration via env
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn[standard]
+httpx
+python-dotenv
+aiohttp # Added for efficient async streaming