flexgate 0.6.0__tar.gz → 0.7.0__tar.gz

{flexgate-0.6.0 → flexgate-0.7.0}/CLAUDE.md

@@ -73,10 +73,13 @@ without a systemd user instance.
 
 ```
 Claude Code → POST /v1/messages (model="claude-sonnet-4-6")
-  → server.py   (Starlette app, single route)
+  → server.py   (Starlette app, /v1/messages + /v1/images/* routes)
   → router.py   (resolve(): regex match model, check schedule windows first, then default routes)
   → proxy.py    (rewrite model field if override, swap x-api-key, SSE streaming pass-through)
   → Upstream provider (z.ai, minimax, xiaomi, etc.)
+
+OpenAI-style client → POST /v1/images/generations
+  → images.py   (translate to MiniMax /v1/image_generation; provider auto-detected by base_url)
 ```
 
 ### Source files (`flexgate/`)
@@ -89,7 +92,9 @@ Claude Code → POST /v1/messages (model="claude-sonnet-4-6")
 | `router.py` | `resolve(config, model)` — schedule-first then default routes, first regex match wins; model aliases normalized before matching |
 | `proxy.py` | `handle_request()` — httpx async proxy, per-key fallback retry loop, SSE streaming + JSON pass-through |
 | `usage.py` | `flexgate status` usage queries — per-platform adapters (MiniMax coding_plan API, Kimi Code usages API, z.ai quota API, LiteLLM `/key/info`) plus a minimal chat probe fallback |
-| `server.py` | Starlette app creation, `POST /v1/messages` endpoint, `SIGUSR1` lifespan reload |
+| `server.py` | Starlette app creation, `POST /v1/messages` + `POST /v1/images/{generations,edits}` endpoints, `SIGUSR1` lifespan reload |
+| `images.py` | OpenAI Images API → MiniMax `/v1/image_generation` translation (`image-01`, size→width/height clamped to 512–2048 mult of 8, `data.image_base64[]`→`data[].b64_json`); edits endpoint returns 501; unknown image model names get 501 `model_not_supported` |
+| `fallback.py` | Catch-all route: merged Anthropic/OpenAI-shaped JSON errors for every unserved path — 404 `route_not_found` (lists valid routes), 405 `method_not_allowed`, 501 `endpoint_not_supported` per recognized API family with an actionable reason |
 | `main.py` | Thin bootstrap: load config → create app → run uvicorn |
 | `service.py` | Authoritative systemd user-service install/start/stop/restart/reload/status and legacy PID migration |
 | `healthcheck.py` | Upstream connectivity probing (`POST /v1/messages`, max_tokens=1) for each referenced (provider, model) pair; called by `doctor` (`flexgate check` is a deprecated alias of doctor) |

{flexgate-0.6.0 → flexgate-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flexgate
-Version: 0.6.0
+Version: 0.7.0
 Summary: Flexible local API gateway for Claude Code — route models to different providers
 Project-URL: Homepage, https://github.com/Agony5757/flexible-gateway
 Project-URL: Repository, https://github.com/Agony5757/flexible-gateway

{flexgate-0.6.0 → flexgate-0.7.0}/flexgate/__init__.py

@@ -1,3 +1,3 @@
 """Flexgate — Flexible API Gateway for Claude Code."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"

flexgate-0.7.0/flexgate/fallback.py

@@ -0,0 +1,99 @@
+"""Structured errors for every route and capability flexgate does not serve.
+
+A bare Starlette 404 tells an API client nothing: it cannot tell "wrong port"
+apart from "right gateway, unsupported endpoint". Every unmatched request
+instead gets a JSON error explaining what was asked for and what flexgate
+does support, so client-side fallback logic (and humans reading logs) can
+react without guessing.
+
+Error payload shape is a merge of the Anthropic and OpenAI conventions so
+both client families parse it:
+
+    {"type": "error", "error": {"type": ..., "message": ..., "code": ...}}
+
+Status code policy:
+- 404 route_not_found        unknown path entirely; message lists valid routes
+- 405 method_not_allowed     known path, wrong HTTP method
+- 501 endpoint_not_supported recognized API family flexgate does not serve
+- 501 capability_not_supported / model_not_supported for valid routes with
+  unsupported operations or model names (raised by the owning module)
+"""
+
+from __future__ import annotations
+
+import re
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+SUPPORTED_ROUTES = ("POST /v1/messages", "POST /v1/images/generations")
+
+
+def error_json(message: str, status: int, error_type: str, code: str) -> JSONResponse:
+    return JSONResponse(
+        {"type": "error", "error": {"type": error_type, "message": message, "code": code}},
+        status_code=status,
+    )
+
+
+# Recognized-but-unsupported API families: (path regex, human reason).
+# Order matters; first match wins. Keep reasons actionable: say what the
+# caller probably wanted and where that capability lives, if anywhere.
+_UNSUPPORTED_FAMILIES: list[tuple[re.Pattern[str], str]] = [
+    (
+        re.compile(r"^/v1/messages/count_tokens$"),
+        "Token counting is not proxied; flexgate only forwards POST /v1/messages. "
+        "Count tokens client-side (e.g. with a tokenizer) instead.",
+    ),
+    (
+        re.compile(r"^/v1/(chat/completions|responses)(/.*)?$"),
+        "OpenAI chat is not served: flexgate proxies Anthropic-style POST /v1/messages only. "
+        "Point an Anthropic-compatible client at this gateway, or call the upstream provider directly.",
+    ),
+    (
+        re.compile(r"^/v1/images/edits$"),
+        # Owning module (images.py) normally answers this first; kept as a safety net.
+        "Image editing/inpainting is not available: the MiniMax image-01 backend is text-to-image only. "
+        "Use POST /v1/images/generations, or edit the image with another tool and upload the result.",
+    ),
+    (
+        re.compile(r"^/v1/embeddings"),
+        "Embeddings are not proxied: no configured provider exposes an embedding endpoint. "
+        "Call an embedding-capable provider directly.",
+    ),
+    (
+        re.compile(r"^/v1/(audio|videos?)(/.*)?$"),
+        "Audio/video endpoints are not proxied by flexgate. "
+        "Call the upstream provider's native API directly.",
+    ),
+    (
+        re.compile(r"^/v1/(models|files|fine_tuning|batches|moderations|vector_stores|assistants|threads|uploads)(/.*)?$"),
+        "This OpenAI platform endpoint is not proxied: flexgate is a routing gateway, not an API platform. "
+        "It only serves POST /v1/messages and POST /v1/images/generations.",
+    ),
+]
+
+
+async def fallback(request: Request) -> JSONResponse:
+    """Catch-all handler for every path/method flexgate does not serve."""
+    path = request.url.path.rstrip("/") or "/"
+
+    if path in ("/v1/messages", "/v1/images/generations"):
+        return error_json(
+            f"{request.method} is not allowed on {path}; use POST.",
+            405,
+            "invalid_request_error",
+            "method_not_allowed",
+        )
+
+    for pattern, reason in _UNSUPPORTED_FAMILIES:
+        if pattern.match(path):
+            return error_json(reason, 501, "not_implemented", "endpoint_not_supported")
+
+    return error_json(
+        f"Unknown route: {request.method} {path}. "
+        f"flexgate serves exactly: {', '.join(SUPPORTED_ROUTES)}.",
+        404,
+        "not_found_error",
+        "route_not_found",
+    )

flexgate-0.7.0/flexgate/images.py

@@ -0,0 +1,192 @@
+"""OpenAI-compatible Images API endpoint, backed by MiniMax image generation.
+
+Exposes `POST /v1/images/generations` so OpenAI-style clients (e.g. editppt's
+openai-compatible-api image backend) can generate images through the gateway
+without any per-provider configuration: the upstream is derived from whichever
+configured provider points at MiniMax (`api.minimaxi.com` / `api.minimax.io`).
+
+Translation notes:
+- MiniMax only has text-to-image (`POST /v1/image_generation`, model
+  `image-01`). `size` ("WxH") is mapped to width/height clamped to 512-2048
+  and rounded to multiples of 8; unrecognized sizes are omitted.
+- MiniMax replies with `data.image_base64[]` (JPEG bytes); it is forwarded
+  verbatim as OpenAI `data[].b64_json` — downstream tools sniff the real
+  content type, so no transcoding dependency is introduced here.
+- `/v1/images/edits` is answered 501: MiniMax has no general image-editing or
+  inpainting capability (its subject_reference is character-only).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from urllib.parse import urlsplit
+
+import httpx
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from flexgate.config import GatewayConfig, ProviderConfig
+from flexgate.fallback import error_json
+
+logger = logging.getLogger("flexgate.images")
+
+MINIMAX_MODEL = "image-01"
+MINIMAX_MIN_EDGE = 512
+MINIMAX_MAX_EDGE = 2048
+MINIMAX_MAX_PROMPT_CHARS = 1500
+
+# Requested model names containing any of these hints are accepted and mapped
+# to MiniMax image-01 (the only image backend behind this gateway).
+_IMAGE_MODEL_HINTS = (
+    "gpt-image",
+    "dall-e",
+    "image-01",
+    "seedream",
+    "flux",
+    "sdxl",
+    "stable-diffusion",
+    "minimax",
+)
+
+
+def _error_json(message: str, status: int, code: str = "minimax_error") -> JSONResponse:
+    error_type = {
+        400: "invalid_request_error",
+        501: "not_implemented",
+        503: "not_implemented",
+    }.get(status, "api_error")
+    return error_json(message, status, error_type, code)
+
+
+def _find_minimax_provider(config: GatewayConfig) -> ProviderConfig | None:
+    candidates = [p for p in config.providers.values() if "minimax" in p.base_url]
+    for provider in candidates:
+        if provider.name == "minimax":
+            return provider
+    return candidates[0] if candidates else None
+
+
+def _image_api_root(base_url: str) -> str:
+    parts = urlsplit(base_url)
+    return f"{parts.scheme}://{parts.netloc}"
+
+
+def _clamp_edge(value: int) -> int:
+    return max(MINIMAX_MIN_EDGE, min(MINIMAX_MAX_EDGE, value))
+
+
+def _round8(value: float) -> int:
+    return max(8, int(round(value / 8)) * 8)
+
+
+def _map_size(size: object) -> dict[str, int]:
+    if not isinstance(size, str):
+        return {}
+    match = re.fullmatch(r"(\d+)x(\d+)", size)
+    if not match:
+        return {}
+    w, h = int(match.group(1)), int(match.group(2))
+    if w <= 0 or h <= 0:
+        return {}
+    scale = min(1.0, MINIMAX_MAX_EDGE / max(w, h))
+    w, h = w * scale, h * scale
+    if min(w, h) < MINIMAX_MIN_EDGE:
+        boost = MINIMAX_MIN_EDGE / min(w, h)
+        w, h = w * boost, h * boost
+        if max(w, h) > MINIMAX_MAX_EDGE:
+            shrink = MINIMAX_MAX_EDGE / max(w, h)
+            w, h = w * shrink, h * shrink
+    return {"width": _clamp_edge(_round8(w)), "height": _clamp_edge(_round8(h))}
+
+
+async def images_generate(request: Request) -> JSONResponse:
+    t0 = time.monotonic()
+    config: GatewayConfig = request.app.state.config
+    client: httpx.AsyncClient = request.app.state.client
+
+    try:
+        body = json.loads(await request.body())
+    except json.JSONDecodeError:
+        return _error_json("Invalid JSON in request body", 400, "bad_request")
+
+    provider = _find_minimax_provider(config)
+    if provider is None:
+        return _error_json(
+            "No MiniMax provider configured (need a provider whose base_url points at MiniMax)",
+            503,
+            "provider_not_found",
+        )
+
+    prompt = body.get("prompt")
+    if not isinstance(prompt, str) or not prompt.strip():
+        return _error_json("Missing required field: prompt", 400, "bad_request")
+
+    requested_model = str(body.get("model") or "")
+    if requested_model and not any(h in requested_model.lower() for h in _IMAGE_MODEL_HINTS):
+        return _error_json(
+            f"Model '{requested_model}' is not a supported image model. flexgate maps image "
+            f"generation to MiniMax {MINIMAX_MODEL} (text-to-image only); request a gpt-image-* "
+            f"alias or '{MINIMAX_MODEL}'.",
+            501,
+            "model_not_supported",
+        )
+    logger.info(
+        "images/generations model=%s -> %s via %s",
+        requested_model or "(default)", MINIMAX_MODEL, provider.name,
+    )
+
+    n = body.get("n", 1)
+    payload: dict = {
+        "model": MINIMAX_MODEL,
+        "prompt": prompt[:MINIMAX_MAX_PROMPT_CHARS],
+        "response_format": "base64",
+        "n": max(1, min(9, int(n))) if isinstance(n, (int, float)) else 1,
+    }
+    payload.update(_map_size(body.get("size")))
+
+    url = f"{_image_api_root(provider.base_url)}/v1/image_generation"
+    headers = {
+        "Authorization": f"Bearer {provider.api_key}",
+        "Content-Type": "application/json",
+    }
+
+    try:
+        resp = await client.post(url, headers=headers, json=payload)
+    except httpx.ConnectError as exc:
+        logger.error("Provider %s unreachable: %s", provider.name, exc)
+        return _error_json(f"Provider unreachable: {provider.name}", 502)
+
+    try:
+        data = resp.json()
+    except Exception:
+        return _error_json(resp.text[:500], 502)
+
+    base_resp = data.get("base_resp") or {}
+    status_code = base_resp.get("status_code", 0)
+    if resp.status_code != 200 or status_code != 0:
+        message = base_resp.get("status_msg") or f"HTTP {resp.status_code}"
+        logger.error("MiniMax image generation failed: %s", message)
+        return _error_json(f"MiniMax upstream: {message}", 502)
+
+    images = (data.get("data") or {}).get("image_base64") or []
+    if not images:
+        return _error_json("MiniMax returned no image_base64 payload", 502)
+
+    elapsed_ms = int((time.monotonic() - t0) * 1000)
+    logger.info("images/generations <- %s | %d image(s) | %dms", provider.name, len(images), elapsed_ms)
+    return JSONResponse({
+        "created": int(time.time()),
+        "data": [{"b64_json": img, "revised_prompt": None} for img in images],
+    })
+
+
+async def images_edits(request: Request) -> JSONResponse:
+    return _error_json(
+        "MiniMax image-01 does not support image editing/inpainting; "
+        "only /v1/images/generations (text-to-image) is available through this gateway.",
+        501,
+        "edits_not_supported",
+    )

{flexgate-0.6.0 → flexgate-0.7.0}/flexgate/server.py

@@ -13,6 +13,8 @@ from starlette.responses import JSONResponse
 from starlette.routing import Route
 
 from flexgate.config import GatewayConfig, load_config
+from flexgate.fallback import fallback
+from flexgate.images import images_edits, images_generate
 from flexgate.proxy import handle_request
 from flexgate.router import NoRouteMatchError, resolve
 
@@ -65,7 +67,17 @@ def create_app(config: GatewayConfig, config_path: str | None = None) -> Starlet
         timeout=httpx.Timeout(connect=10, read=3600, write=10, pool=10),
     )
 
-    routes = [Route("/v1/messages", messages, methods=["POST"])]
+    routes = [
+        Route("/v1/messages", messages, methods=["POST"]),
+        Route("/v1/images/generations", images_generate, methods=["POST"]),
+        Route("/v1/images/edits", images_edits, methods=["POST"]),
+        # Catch-all last: structured, reasoned errors for anything unsupported.
+        Route(
+            "/{path:path}",
+            fallback,
+            methods=["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+        ),
+    ]
 
     async def lifespan(app: Starlette) -> AsyncGenerator[None, None]:
         app.state.config = config