chore: remove Google provider entirely

Google streaming through HF Spaces HTTP/2 edge never worked reliably
with Janitor AI. Strip all Google-specific code, providers, models,
keys, and docs. Keep only NVIDIA NIM path. google/gemma-4-31b-it
stays in NVIDIA model list (NVIDIA-hosted Gemma).

.env.example

@@ -1,11 +1,9 @@
 # Real provider API keys (keep these secret)
 REAL_NVIDIA_KEY=nvapi-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-REAL_GOOGLE_KEY=AIzaxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
 # Proxy keys your client apps will use
 # Generate with: python -c "import secrets; print('sk-nvidia-' + secrets.token_urlsafe(32))"
 SK_NVIDIA_KEY=sk-nvidia-xxxxxxxxxxxxxxxxxxxx
-SK_GOOGLE_KEY=sk-google-xxxxxxxxxxxxxxxxxxxx
 
 # Server
 HOST=127.0.0.1

.opencode/AGENTS.md

@@ -13,7 +13,7 @@ Rules:
 
 ## OpenAI API Proxy
 
-FastAPI proxy that routes OpenAI-compatible chat requests to NVIDIA NIM or Google AI Studio based on which `sk-{provider}` key the client uses.
+FastAPI proxy that routes OpenAI-compatible chat requests to NVIDIA NIM based on the `sk-nvidia` key the client uses.
 
 ### Setup & run
 - Install: `pip install -r requirements.txt`
@@ -30,7 +30,6 @@ FastAPI proxy that routes OpenAI-compatible chat requests to NVIDIA NIM or Googl
 
 ### Provider quirks
 - **NVIDIA**: Bearer token auth, async (202→poll), base URL `https://integrate.api.nvidia.com`
-- **Google**: `x-goog-api-key` header (no Bearer), no 202 handling, base URL `https://generativelanguage.googleapis.com/v1beta/openai`
 
 ### Adding a new provider
 1. Add `Provider(...)` to `proxy/providers.py:PROVIDERS` dict

PRODUCT.md

@@ -10,7 +10,7 @@ A single technical user (the owner) running this proxy locally or on cheap perso
 
 ## Product Purpose
 
-A lightweight OpenAI-compatible API gateway that forwards chat/completion requests to the right AI provider based on which `sk-` proxy key the client uses. One server, one set of routes, multiple backends (NVIDIA NIM, Google AI Studio, extensible to more). It makes apps that only accept OpenAI-style keys work with non-OpenAI providers.
+A lightweight OpenAI-compatible API gateway that forwards chat/completion requests to NVIDIA NIM based on the `sk-nvidia` proxy key the client uses. One server, one set of routes, one backend. It makes apps that only accept OpenAI-style keys work with non-OpenAI providers.
 
 ## Brand Personality
 

config.py

@@ -15,12 +15,10 @@ POLL_MAX_ATTEMPTS = int(os.getenv("POLL_MAX_ATTEMPTS", "60"))
 
 PROVIDER_KEYS = {
     "nvidia": os.getenv("SK_NVIDIA_KEY", ""),
-    "google": os.getenv("SK_GOOGLE_KEY", ""),
 }
 
 REAL_KEYS = {
     "nvidia": os.getenv("REAL_NVIDIA_KEY", ""),
-    "google": os.getenv("REAL_GOOGLE_KEY", ""),
 }
 
 

proxy/client.py

@@ -5,7 +5,7 @@ from typing import Any, AsyncIterator
 
 import httpx
 from fastapi import HTTPException
-from fastapi.responses import Response, StreamingResponse
+from fastapi.responses import StreamingResponse
 from starlette.requests import Request
 
 from config import POLL_INTERVAL, POLL_MAX_ATTEMPTS
@@ -24,20 +24,6 @@ def _build_headers(provider: Provider, real_key: str, incoming_headers: dict[str
     return headers
 
 
-_UNSUPPORTED_GOOGLE_PARAMS = {"frequency_penalty", "logprobs", "top_logprobs", "repetition_penalty", "top_k"}
-
-
-def _sanitize_body(provider: Provider, body: dict[str, Any]) -> dict[str, Any]:
-    """Remove parameters that Google's OpenAI-compatible endpoint rejects."""
-    if provider.name != "google":
-        return body
-    stripped = _UNSUPPORTED_GOOGLE_PARAMS & set(body.keys())
-    if not stripped:
-        return body
-    logger.info("Stripping unsupported Google parameters: %s", ", ".join(sorted(stripped)))
-    return {k: v for k, v in body.items() if k not in _UNSUPPORTED_GOOGLE_PARAMS}
-
-
 def _extract_request_id(response: httpx.Response) -> str | None:
     try:
         data = response.json()
@@ -82,71 +68,6 @@ def _upstream_error_message(status_code: int, content: bytes) -> str:
     return text
 
 
-def _strip_extra_content(data: bytes) -> bytes:
-    text = data.decode("utf-8")
-    lines = []
-    for line in text.split("\n"):
-        if line.startswith("data: ") and line != "data: [DONE]":
-            try:
-                obj = json.loads(line[6:])
-                for choice in obj.get("choices", []):
-                    choice.get("delta", {}).pop("extra_content", None)
-                    choice.get("message", {}).pop("extra_content", None)
-                lines.append("data: " + json.dumps(obj, ensure_ascii=False))
-            except (json.JSONDecodeError, KeyError, TypeError):
-                lines.append(line)
-        else:
-            lines.append(line)
-    return "\n".join(lines).encode("utf-8")
-
-
-def _strip_extra_content_json(content: bytes) -> bytes:
-    try:
-        obj = json.loads(content)
-        for choice in obj.get("choices", []):
-            choice.get("delta", {}).pop("extra_content", None)
-            choice.get("message", {}).pop("extra_content", None)
-        return json.dumps(obj, ensure_ascii=False).encode("utf-8")
-    except (json.JSONDecodeError, KeyError, TypeError, UnicodeDecodeError):
-        return content
-
-
-def _json_to_sse(content: bytes) -> bytes:
-    """Convert a non-streaming OpenAI JSON response into SSE chunks."""
-    try:
-        obj = json.loads(content)
-        base = {
-            "id": obj.get("id", "chatcmpl-proxy"),
-            "object": "chat.completion.chunk",
-            "created": obj.get("created", 0),
-            "model": obj.get("model", ""),
-        }
-        events = []
-        for choice in obj.get("choices", []):
-            idx = choice.get("index", 0)
-            message = choice.get("message", {})
-            content_text = message.get("content", "")
-            finish_reason = choice.get("finish_reason", None)
-
-            role_chunk = dict(base)
-            role_chunk["choices"] = [{"index": idx, "delta": {"role": message.get("role", "assistant")}, "finish_reason": None}]
-            events.append(f"data: {json.dumps(role_chunk, ensure_ascii=False)}\n\n")
-
-            if content_text:
-                content_chunk = dict(base)
-                content_chunk["choices"] = [{"index": idx, "delta": {"content": content_text}, "finish_reason": None}]
-                events.append(f"data: {json.dumps(content_chunk, ensure_ascii=False)}\n\n")
-
-            final_chunk = dict(base)
-            final_chunk["choices"] = [{"index": idx, "delta": {}, "finish_reason": finish_reason}]
-            events.append(f"data: {json.dumps(final_chunk, ensure_ascii=False)}\n\n")
-
-        events.append("data: [DONE]\n\n")
-        return "".join(events).encode("utf-8")
-    except (json.JSONDecodeError, KeyError, TypeError, UnicodeDecodeError):
-        return content
-
-
 async def _stream_response(provider: Provider, real_key: str, body: dict[str, Any]) -> AsyncIterator[bytes]:
     """Async generator that manages its own httpx client for streaming."""
     target_url = f"{provider.base_url}/v1/chat/completions"
@@ -157,30 +78,15 @@ async def _stream_response(provider: Provider, real_key: str, body: dict[str, An
                 content = await upstream.aread()
                 detail = _upstream_error_message(upstream.status_code, content)
                 raise HTTPException(status_code=upstream.status_code, detail=detail)
-            buffer = b""
             async for chunk in upstream.aiter_bytes():
-                buffer += chunk
-                while b"\n\n" in buffer:
-                    event, buffer = buffer.split(b"\n\n", 1)
-                    event += b"\n\n"
-                    if provider.name == "google":
-                        event = _strip_extra_content(event)
-                    yield event
-            if buffer:
-                if provider.name == "google":
-                    buffer = _strip_extra_content(buffer)
-                yield buffer
+                yield chunk
 
 
 async def forward_request(provider: Provider, real_key: str, request: Request, body: dict[str, Any]) -> Any:
-    body = _sanitize_body(provider, body)
     target_url = f"{provider.base_url}/v1/chat/completions"
     headers = _build_headers(provider, real_key, dict(request.headers))
-    original_stream = bool(body.get("stream"))
 
-    if original_stream and provider.name == "google":
-        body["stream"] = False
-    elif original_stream:
+    if bool(body.get("stream")):
         return StreamingResponse(_stream_response(provider, real_key, body), media_type="text/event-stream")
 
     async with httpx.AsyncClient(timeout=_TIMEOUT, follow_redirects=True) as client:
@@ -205,17 +111,8 @@ async def forward_request(provider: Provider, real_key: str, request: Request, b
             detail = _upstream_error_message(upstream.status_code, content)
             raise HTTPException(status_code=upstream.status_code, detail=detail)
 
-        content = upstream.content
-        if provider.name == "google":
-            content = _strip_extra_content_json(content)
-            if original_stream:
-                content = _json_to_sse(content)
-
-        if original_stream and provider.name == "google":
-            return Response(content=content, media_type="text/event-stream")
-
         return {
             "status_code": upstream.status_code,
             "headers": dict(upstream.headers),
-            "content": content,
+            "content": upstream.content,
         }

proxy/providers.py

@@ -21,12 +21,4 @@ PROVIDERS: dict[str, Provider] = {
         handles_202=True,
         env_real_key="REAL_NVIDIA_KEY",
     ),
-    "google": Provider(
-        name="google",
-        base_url="https://generativelanguage.googleapis.com/v1beta/openai",
-        auth_header="Authorization",
-        auth_value=lambda key: f"Bearer {key}",
-        handles_202=False,
-        env_real_key="REAL_GOOGLE_KEY",
-    ),
 }

proxy/router.py

@@ -24,10 +24,6 @@ MODELS = {
         "moonshotai/kimi-k2.5",
         "google/gemma-4-31b-it",
     ],
-    "google": [
-        "gemini-3.1-flash-lite",
-        "gemma-4-31b-it",
-    ],
 }