feat(models): integrate Gemini Hub (Veo 3 video + Gemini 3 image/text)

Adds first-class support for the public Gemini Hub backend at
https://gemini-rag-api.pespinoza.online which is NOT OpenAI-compatible
on the wire (custom /call/{tool_name} + /query endpoints).

New config:
- GEMINI_HUB_URL constant in config.py

New code in index.py:
- GEMINI_HUB_VIDEO_MODELS → veo-3 / veo-3-fast / veo-3.1-fast
- GEMINI_HUB_IMAGE_MODELS → gemini-3-image variants (flash/pro)
- GEMINI_HUB_TEXT_MODELS → gemini-3 / gemini-3-flash / gemini-3-pro
- _gemini_hub_extract_prompt(): flatten OpenAI chat messages to a single
prompt (multi-modal content arrays collapsed to text parts)
- _gemini_hub_chat_envelope(): produce a non-streaming chat.completion
- _gemini_hub_chat(): pick the right Gemini Hub endpoint based on model
family, forward generation knobs (aspect_ratio, duration_seconds,
resolution, image_url), and wrap the response (video/image URL or RAG
text) in an OpenAI assistant message with Markdown media links

chat_completions() short-circuits on Gemini Hub models BEFORE the
normal upstream proxy path. Streaming clients get a synthesized
single-chunk SSE response so OpenAI SDKs keep working.

_available_models is appended with sorted(GEMINI_HUB_MODELS) in all
three places where it is rebuilt. /admin/models lists each model with
type="video-backend" / "image-backend" / "text-backend" and
provider="GeminiHub" so the dashboard renders them next to dynamic
providers.

app/config.py

@@ -46,6 +46,14 @@ QWEN_LOCAL_KEY = _decrypt("enc:v1:I5MWk2kg-lfUAMJZ:L74MW5GaciwIIsV0gWDbfc0vZyBm5
 # ── ChatGPT Image Generation API ─────────────────────────────────────────────
 CHATGPT_IMAGE_API_URL = "http://89.47.113.13:3999"
 
+# ── Gemini Hub (Veo 3 video + Gemini 3 image/text) ───────────────────────────
+# Public OpenAPI: https://gemini-rag-api.pespinoza.online/openapi.json
+# Exposes the following capabilities through /call/{tool_name}:
+#   - generar_video   → Veo 3.1 Fast (text-to-video, image-to-video)
+#   - generar_imagen  → Gemini 3.1 Flash Image (flash/pro variants)
+#   - query           → RAG-grounded text response (defaults to gemini-flash-latest)
+GEMINI_HUB_URL = "https://gemini-rag-api.pespinoza.online"
+
 UPSTREAMS = {
     # ── Existing aliases ──
     "claude-opus-4.6": [

app/index.py

@@ -23,7 +23,7 @@ from config import (
     MASTER_KEY,
     AI_GATEWAY_URL, UPSTREAM_14448_URL,
     BLOCKED_IPS,
-    CHATGPT_IMAGE_API_URL,
+    CHATGPT_IMAGE_API_URL, GEMINI_HUB_URL,
     TURNSTILE_SITE_KEY, TURNSTILE_SECRET_KEY, BALANCE_ENDPOINTS,
 )
 from pydantic import BaseModel
@@ -48,6 +48,16 @@ RPM_LIMIT = 4
 KEYS_FILE = os.path.join(os.path.dirname(__file__), "data", "api_keys.json")
 PROVIDERS_FILE = os.path.join(os.path.dirname(__file__), "data", "providers.json")
 
+# ── Gemini Hub model aliases ─────────────────────────────────────────────────
+# Public Gemini Hub backend (see config.GEMINI_HUB_URL) exposes Veo 3 video,
+# Gemini 3 image, and RAG-grounded text generation. We surface these as
+# regular OpenAI model ids; chat_completions short-circuits on them and
+# routes to the dedicated adapter (_gemini_hub_chat) defined further below.
+GEMINI_HUB_VIDEO_MODELS = {"veo-3", "veo-3-fast", "veo-3.1-fast"}
+GEMINI_HUB_IMAGE_MODELS = {"gemini-3-image", "gemini-3-flash-image", "gemini-3.1-flash-image"}
+GEMINI_HUB_TEXT_MODELS  = {"gemini-3", "gemini-3-flash", "gemini-3-pro"}
+GEMINI_HUB_MODELS = GEMINI_HUB_VIDEO_MODELS | GEMINI_HUB_IMAGE_MODELS | GEMINI_HUB_TEXT_MODELS
+
 _rate_limits: dict = defaultdict(list)
 
 # ── Dynamic Providers (runtime-imported OpenAI-compatible backends) ─────────
@@ -396,7 +406,7 @@ async def _fetch_upstream_models():
     await client.aclose()
 
     # Build available models from UPSTREAMS keys + image models
-    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"]
+    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"] + sorted(GEMINI_HUB_MODELS)
     logger.info("Available models: %s", _available_models)
 
 
@@ -1248,6 +1258,18 @@ async def admin_models(request: Request):
             # Mark the raw upstream id as "owned" by a dynamic provider so we
             # don't double-list it from the built-in UPSTREAMS dict.
             dynamic_models.add(upstream_id)
+
+    # Gemini Hub (Veo 3 + Gemini 3) virtual provider — surfaced for the
+    # dashboard so it can render the same as any other registered backend.
+    for vid in sorted(GEMINI_HUB_VIDEO_MODELS):
+        models.append({"name": vid, "provider": "GeminiHub", "type": "video-backend"})
+        dynamic_models.add(vid)
+    for iid in sorted(GEMINI_HUB_IMAGE_MODELS):
+        models.append({"name": iid, "provider": "GeminiHub", "type": "image-backend"})
+        dynamic_models.add(iid)
+    for tid in sorted(GEMINI_HUB_TEXT_MODELS):
+        models.append({"name": tid, "provider": "GeminiHub", "type": "text-backend"})
+        dynamic_models.add(tid)
     
     def _provider_from_url(url: str) -> str:
         """Extract provider name from upstream URL."""
@@ -1670,7 +1692,7 @@ async def admin_import_provider(request: Request, body: ProviderImportRequest):
     # Refresh global available models list (built-in only — prefixed models
     # are surfaced separately by /v1/models)
     global _available_models
-    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"]
+    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"] + sorted(GEMINI_HUB_MODELS)
     logger.info(
         "Imported provider %s (prefix=%r) with %d selected models (%d available)",
         pid, prefix, len(cleaned_aliases), len(available),
@@ -1782,7 +1804,7 @@ async def admin_delete_provider(request: Request, provider_id: str):
 
     _save_providers()
     global _available_models
-    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"]
+    _available_models = list(UPSTREAMS.keys()) + ["gpt-image-1", "gpt-image-2"] + sorted(GEMINI_HUB_MODELS)
     return {"success": True}
 
 
@@ -2397,6 +2419,158 @@ async def admin_settings_page():
 # ── Image Generation Endpoint ─────────────────────────────────────────────────
 
 @app.post("/v1/images/generations")
+def _gemini_hub_extract_prompt(messages: list) -> str:
+    """Flatten OpenAI chat messages into a single prompt string for Gemini Hub.
+
+    We concatenate every user/system turn (skipping tool noise) and return
+    the joined plain text. Multi-modal ``content`` arrays are reduced to their
+    textual parts; image parts are dropped because the dashboard exposes only
+    text-to-* generation today.
+    """
+    parts: list[str] = []
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        role = msg.get("role")
+        if role not in ("system", "user"):
+            continue
+        content = msg.get("content")
+        if isinstance(content, str):
+            parts.append(content.strip())
+        elif isinstance(content, list):
+            for piece in content:
+                if isinstance(piece, dict) and piece.get("type") in ("text", "input_text"):
+                    txt = piece.get("text") or piece.get("input_text") or ""
+                    if txt:
+                        parts.append(str(txt).strip())
+    return "\n\n".join(p for p in parts if p)
+
+
+def _gemini_hub_chat_envelope(model: str, content: str, *, usage_prompt: int = 0) -> dict:
+    """Wrap ``content`` in a non-streaming OpenAI chat.completion response."""
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": content},
+                "finish_reason": "stop",
+            }
+        ],
+        "usage": {
+            "prompt_tokens": usage_prompt,
+            "completion_tokens": len(content) // 4,
+            "total_tokens": usage_prompt + len(content) // 4,
+        },
+    }
+
+
+async def _gemini_hub_chat(model: str, messages: list, body: dict) -> dict:
+    """Route a chat completion to the Gemini Hub backend based on ``model``.
+
+    Returns an OpenAI-compatible ``chat.completion`` dict. Raises HTTPException
+    on upstream failures so the outer ``chat_completions`` handler reports them
+    consistently with the rest of the stack.
+    """
+    prompt = _gemini_hub_extract_prompt(messages)
+    if not prompt:
+        raise HTTPException(
+            status_code=400,
+            detail={"error": {"message": "No textual prompt found in messages"}},
+        )
+
+    # Optional generation knobs forwarded from the request body (best-effort).
+    aspect_ratio = body.get("aspect_ratio") or body.get("size")
+    duration = body.get("duration_seconds") or body.get("duration")
+    resolution = body.get("resolution")
+
+    if model in GEMINI_HUB_VIDEO_MODELS:
+        payload: dict = {"prompt": prompt}
+        if aspect_ratio in ("16:9", "9:16"):
+            payload["aspect_ratio"] = aspect_ratio
+        if duration and str(duration) in ("4", "6", "8"):
+            payload["duration_seconds"] = str(duration)
+        if resolution in ("720p", "1080p"):
+            payload["resolution"] = resolution
+        # Allow image-to-video when the client passes an image_url in the body
+        if isinstance(body.get("image_url"), str):
+            payload["image_url"] = body["image_url"]
+
+        url = f"{GEMINI_HUB_URL}/call/generar_video"
+        logger.info("GeminiHub video request model=%s prompt=%s", model, prompt[:80])
+        async with httpx.AsyncClient(timeout=600.0) as client:
+            try:
+                resp = await client.post(url, json=payload)
+            except Exception as e:
+                raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub unreachable: {e}"}})
+        if resp.status_code != 200:
+            raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub {resp.status_code}: {resp.text[:300]}"}})
+        data = resp.json() or {}
+        if data.get("error"):
+            raise HTTPException(status_code=400, detail={"error": {"message": str(data["error"])}})
+
+        video_url = data.get("video_url") or data.get("url")
+        if not video_url:
+            raise HTTPException(status_code=502, detail={"error": {"message": "Gemini Hub returned no video_url"}})
+        # OpenAI clients render Markdown; embed both a clickable link and
+        # the raw URL so plain-text consumers still see it.
+        content = (
+            f"🎬 Generated with **{data.get('model', model)}** "
+            f"({data.get('resolution', payload.get('resolution', '720p'))}, "
+            f"{data.get('aspect_ratio', payload.get('aspect_ratio', '16:9'))}, "
+            f"{data.get('duration_seconds', payload.get('duration_seconds', '8'))}s)\n\n"
+            f"[▶ Video]({video_url})\n\n{video_url}"
+        )
+        return _gemini_hub_chat_envelope(model, content, usage_prompt=len(prompt) // 4)
+
+    if model in GEMINI_HUB_IMAGE_MODELS:
+        payload = {"prompt": prompt, "model": "pro" if model.endswith("-pro") else "flash"}
+        if aspect_ratio in ("1:1", "16:9", "9:16", "4:3", "3:4"):
+            payload["aspect_ratio"] = aspect_ratio
+        url = f"{GEMINI_HUB_URL}/call/generar_imagen"
+        logger.info("GeminiHub image request model=%s prompt=%s", model, prompt[:80])
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            try:
+                resp = await client.post(url, json=payload)
+            except Exception as e:
+                raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub unreachable: {e}"}})
+        if resp.status_code != 200:
+            raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub {resp.status_code}: {resp.text[:300]}"}})
+        data = resp.json() or {}
+        if data.get("error"):
+            raise HTTPException(status_code=400, detail={"error": {"message": str(data["error"])}})
+        image_url = data.get("image_url") or data.get("url")
+        if not image_url:
+            raise HTTPException(status_code=502, detail={"error": {"message": "Gemini Hub returned no image_url"}})
+        content = (
+            f"🖼️ Generated with **{data.get('model', model)}** "
+            f"({data.get('aspect_ratio', payload.get('aspect_ratio', '1:1'))})\n\n"
+            f"![image]({image_url})\n\n{image_url}"
+        )
+        return _gemini_hub_chat_envelope(model, content, usage_prompt=len(prompt) // 4)
+
+    # Text models → /query (RAG-grounded). Trim noisy "Fuentes:" tail so
+    # OpenAI clients see the answer first.
+    payload = {"query": prompt, "top_k": int(body.get("top_k") or 5)}
+    url = f"{GEMINI_HUB_URL}/query"
+    logger.info("GeminiHub text request model=%s prompt=%s", model, prompt[:80])
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        try:
+            resp = await client.post(url, json=payload)
+        except Exception as e:
+            raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub unreachable: {e}"}})
+    if resp.status_code != 200:
+        raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub {resp.status_code}: {resp.text[:300]}"}})
+    data = resp.json() or {}
+    answer = data.get("response") or data.get("text") or ""
+    if not answer:
+        raise HTTPException(status_code=502, detail={"error": {"message": "Gemini Hub returned empty response"}})
+    return _gemini_hub_chat_envelope(model, answer, usage_prompt=len(prompt) // 4)
+
+
 async def generate_images(request: Request, credentials: HTTPAuthorizationCredentials = Depends(security)):
     """OpenAI-compatible image generation endpoint. Routes to gpt-image-2 backend."""
     api_key = credentials.credentials
@@ -2535,6 +2709,48 @@ async def chat_completions(request: Request, _auth=Depends(verify_request)):
     safe_body["has_tools"] = bool(body.get("tools"))
     logger.info("CHAT_REQ ip=%s model=%s->%s stream=%s body_keys=%s",
                 get_client_ip(request), model_raw, model, stream, list(safe_body.keys()))
+
+    # ── Gemini Hub short-circuit (Veo 3 video, Gemini 3 image/text) ─────
+    # These models talk to a non-OpenAI backend; bypass the upstream proxy
+    # entirely. Streaming is emulated as a single chunk so clients that
+    # set ``stream=true`` still work.
+    if model in GEMINI_HUB_MODELS:
+        try:
+            completion = await _gemini_hub_chat(model, messages, body)
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.exception("Gemini Hub adapter failed: %s", e)
+            raise HTTPException(status_code=502, detail={"error": {"message": f"Gemini Hub error: {e}"}})
+
+        if not stream:
+            return completion
+
+        # Emulate a single-chunk SSE stream so OpenAI-style clients still work.
+        async def _gemini_hub_stream():
+            choice = completion["choices"][0]
+            chunk = {
+                "id": completion["id"],
+                "object": "chat.completion.chunk",
+                "created": completion["created"],
+                "model": completion["model"],
+                "choices": [{
+                    "index": 0,
+                    "delta": {"role": "assistant", "content": choice["message"]["content"]},
+                    "finish_reason": None,
+                }],
+            }
+            yield f"data: {json.dumps(chunk)}\n\n"
+            final = {
+                "id": completion["id"],
+                "object": "chat.completion.chunk",
+                "created": completion["created"],
+                "model": completion["model"],
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+            }
+            yield f"data: {json.dumps(final)}\n\n"
+            yield "data: [DONE]\n\n"
+        return StreamingResponse(_gemini_hub_stream(), media_type="text/event-stream")
     tools = body.get("tools")
     tool_choice = body.get("tool_choice")
     req_id = uuid.uuid4().hex