ccgw 0.1.0__py3-none-any.whl

ccgw/__init__.py

@@ -0,0 +1,7 @@
+"""cc-gateway: a multi-provider Anthropic-dialect gateway for Claude Code."""
+
+__version__ = "0.1.0"
+
+__all__ = ["create_app"]
+
+from .app import create_app  # noqa: E402

ccgw/app.py

@@ -0,0 +1,182 @@
+"""HTTP surface: the three endpoints Claude Code actually calls."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from .config import Config
+from .errors import anthropic_error
+from .provider import Registry, UpstreamError
+
+log = logging.getLogger("ccgw")
+
+CONFIG_PATH = os.environ.get("CCGW_CONFIG", "config.toml")
+
+
+def create_app(config: Config | None = None) -> FastAPI:
+    config = config or Config.load(CONFIG_PATH)
+    registry = Registry(config)
+
+    @asynccontextmanager
+    async def lifespan(_: FastAPI):
+        for warning in await registry.refresh():
+            log.warning("%s", warning)
+        log.info(
+            "catalogue ready: %d model(s) across %d provider(s)",
+            len(registry.models),
+            len(registry.clients),
+        )
+        for entry in registry.models.values():
+            log.info("  %-38s -> %s/%s", entry.public_id, entry.provider, entry.upstream)
+        yield
+        await registry.aclose()
+
+    app = FastAPI(title="cc-gateway", lifespan=lifespan)
+
+    # ------------------------------------------------------------ /v1/models
+
+    @app.get("/v1/models")
+    async def list_models():
+        """Claude Code keeps only `id` and `display_name`; everything else is
+        dropped by its parser. It also fails discovery on any redirect and
+        gives up after 3 seconds, so this must be served locally and fast."""
+        return {
+            "object": "list",
+            "has_more": False,
+            "data": [
+                {
+                    "id": entry.public_id,
+                    "type": "model",
+                    "display_name": entry.display_name,
+                    "created_at": "2026-01-01T00:00:00Z",
+                }
+                for entry in registry.models.values()
+            ],
+        }
+
+    # ---------------------------------------------- /v1/messages/count_tokens
+
+    @app.post("/v1/messages/count_tokens")
+    async def count_tokens(request: Request):
+        """Answered locally and never forwarded.
+
+        coconut does not implement this endpoint at all, and Claude Code allows
+        10 seconds before falling back to its own estimate -- proxying would
+        only add latency. A rough local estimate keeps the context meter
+        approximately honest.
+        """
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+        blob = json.dumps(
+            {
+                "system": body.get("system"),
+                "messages": body.get("messages"),
+                "tools": body.get("tools"),
+            },
+            ensure_ascii=False,
+        )
+        # ~3.5 chars per token is a better fit for mixed CJK/code than /4.
+        return {"input_tokens": max(1, int(len(blob) / 3.5))}
+
+    # ---------------------------------------------------------- /v1/messages
+
+    @app.post("/v1/messages")
+    async def messages(request: Request):
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse(
+                anthropic_error(400, "Request body must be valid JSON."), 400
+            )
+
+        entry = registry.resolve(body.get("model"))
+        if entry is None:
+            return JSONResponse(
+                anthropic_error(404, "No models are configured on this gateway."), 404
+            )
+
+        client = registry.client_for(entry)
+        session = request.headers.get("x-claude-code-session-id", "-")
+        surface = request.headers.get("x-app", "-")
+        log.info(
+            "%s %s -> %s/%s (session=%s)",
+            surface,
+            body.get("model"),
+            entry.provider,
+            entry.upstream,
+            session[:8],
+        )
+
+        try:
+            headers = client.build_headers(dict(request.headers))
+        except RuntimeError as exc:
+            return JSONResponse(anthropic_error(500, str(exc)), 500)
+
+        payload = client.build_payload(body, entry)
+
+        if not payload.get("stream"):
+            try:
+                upstream = await client.messages_once(payload, headers)
+            except UpstreamError as exc:
+                return JSONResponse(exc.payload, exc.status)
+            except Exception as exc:
+                return JSONResponse(
+                    anthropic_error(502, f"[{entry.provider}] {exc}"), 502
+                )
+            result = upstream.json()
+            # Report the id the client asked for, not the upstream one.
+            if isinstance(result, dict):
+                result["model"] = body.get("model") or entry.public_id
+            return JSONResponse(result, upstream.status_code)
+
+        try:
+            stream = client.messages_stream(payload, headers)
+            first = await stream.__anext__()
+        except StopAsyncIteration:
+            return JSONResponse(
+                anthropic_error(502, f"[{entry.provider}] empty upstream response"), 502
+            )
+        except UpstreamError as exc:
+            return JSONResponse(exc.payload, exc.status)
+        except Exception as exc:
+            return JSONResponse(anthropic_error(502, f"[{entry.provider}] {exc}"), 502)
+
+        async def relay():
+            yield first
+            async for chunk in stream:
+                yield chunk
+
+        return StreamingResponse(
+            relay(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache, no-transform",
+                "Connection": "keep-alive",
+                # Defeat any buffering proxy sitting in front of us.
+                "X-Accel-Buffering": "no",
+            },
+        )
+
+    @app.get("/healthz")
+    async def healthz():
+        return {"ok": True, "models": len(registry.models)}
+
+    @app.head("/api/hello")
+    async def hello():
+        # Claude Code fires this once at startup as a fire-and-forget TCP
+        # preconnect probe and ignores the response; answer so it does not
+        # land in the access log as a 404.
+        return Response(status_code=204)
+
+    return app
+
+
+app = create_app

ccgw/cli.py

@@ -0,0 +1,63 @@
+"""Command-line entry point: `ccgw` (installed via [project.scripts])."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+from pathlib import Path
+
+import uvicorn
+
+from ccgw.app import create_app
+from ccgw.config import Config
+
+DEFAULT_CONFIG_DIRS = (Path.cwd(), Path.home() / ".config" / "ccgw")
+
+
+def find_config() -> str | None:
+    """First existing config.toml among the well-known locations."""
+    for directory in DEFAULT_CONFIG_DIRS:
+        candidate = directory / "config.toml"
+        if candidate.is_file():
+            return str(candidate)
+    return None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Claude Code multi-provider gateway")
+    parser.add_argument(
+        "--config",
+        default=os.environ.get("CCGW_CONFIG"),
+        help="Config file path (default: $CCGW_CONFIG, ./config.toml, ~/.config/ccgw/config.toml)",
+    )
+    parser.add_argument("--host", default=None)
+    parser.add_argument("--port", type=int, default=None)
+    args = parser.parse_args()
+
+    config_path = args.config or find_config()
+    if not config_path:
+        parser.error(
+            "no config found: pass --config, set $CCGW_CONFIG, "
+            "or place config.toml in the cwd or ~/.config/ccgw/"
+        )
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(name)s | %(message)s",
+    )
+
+    config = Config.load(config_path)
+    app = create_app(config)
+    uvicorn.run(
+        app,
+        host=args.host or config.server.host,
+        port=args.port or config.server.port,
+        log_level="info",
+        # Streaming correctness: never let the server buffer responses.
+        timeout_keep_alive=75,
+    )
+
+
+if __name__ == "__main__":
+    main()

ccgw/config.py

@@ -0,0 +1,131 @@
+"""Configuration loading and the public model registry.
+
+The registry maps the *public* model id that Claude Code sees onto a concrete
+(provider, upstream model name) pair. Public ids are synthesised so that they
+always satisfy Claude Code's two naming constraints:
+
+* the id must contain "claude" (otherwise gateway model discovery drops it);
+* an id containing "[1m]" makes Claude Code assume a 1M context window, so the
+  suffix is only appended for models that really have one.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Claude Code treats an id containing "[1m]" as a 1M-context model. coconut's
+# models report 936k, which is close enough to round up to the same bucket.
+ONE_M_THRESHOLD = 900_000
+ONE_M_SUFFIX = "[1m]"
+PUBLIC_PREFIX = "claude-"
+
+
+def _slug(value: str) -> str:
+    slug = re.sub(r"[^a-z0-9.]+", "-", str(value).strip().lower())
+    return slug.strip("-")
+
+
+def make_public_id(provider: str, upstream: str, context: int) -> str:
+    name = str(upstream).strip()
+    name = re.sub(r"\[1m\]$", "", name, flags=re.IGNORECASE)
+    name = re.sub(r"^(claude|anthropic)[-_]", "", name, flags=re.IGNORECASE)
+    name = _slug(name)
+    return PUBLIC_PREFIX + name + (ONE_M_SUFFIX if context >= ONE_M_THRESHOLD else "")
+
+
+@dataclass(frozen=True)
+class ModelEntry:
+    public_id: str
+    display_name: str
+    provider: str
+    upstream: str
+    context: int
+    max_tokens: int | None = None
+
+
+@dataclass
+class Provider:
+    name: str
+    base_url: str
+    auth_style: str = "bearer"  # "bearer" | "x-api-key" | "none"
+    api_key: str | None = None
+    api_key_env: str | None = None
+    force_host: str | None = None
+    user_agent: str | None = None
+    discover: bool = False
+    drop_thinking_param: bool = False
+    normalize_thinking: bool = False
+    strip_cache_control: bool = False
+    proxy: str | None = None
+    models: list[dict] = field(default_factory=list)
+
+    def resolve_key(self) -> str | None:
+        """Read the credential, preferring the environment over the file."""
+        if self.api_key_env:
+            value = os.environ.get(self.api_key_env, "").strip()
+            if not value:
+                raise RuntimeError(
+                    f"provider {self.name!r} needs environment variable "
+                    f"{self.api_key_env}, which is unset or empty"
+                )
+            return value
+        return self.api_key
+
+    def auth_headers(self) -> dict[str, str]:
+        key = self.resolve_key()
+        if self.auth_style == "none" or not key:
+            return {}
+        if self.auth_style == "x-api-key":
+            return {"x-api-key": key}
+        return {"Authorization": f"Bearer {key}"}
+
+
+@dataclass
+class ServerConfig:
+    host: str = "127.0.0.1"
+    port: int = 8788
+    ping_interval: float = 15.0
+    connect_timeout: float = 30.0
+    read_timeout: float = 600.0
+
+
+@dataclass
+class Config:
+    server: ServerConfig
+    providers: dict[str, Provider]
+
+    @classmethod
+    def load(cls, path: str | Path) -> "Config":
+        raw = tomllib.loads(Path(path).read_text(encoding="utf-8"))
+        server = ServerConfig(**raw.get("server", {}))
+        providers: dict[str, Provider] = {}
+        for name, body in raw.get("providers", {}).items():
+            body = dict(body)
+            models = body.pop("models", [])
+            providers[name] = Provider(name=name, models=models, **body)
+        if not providers:
+            raise RuntimeError("no providers configured")
+        return cls(server=server, providers=providers)
+
+    def static_models(self) -> list[ModelEntry]:
+        """Model entries declared inline in the config file."""
+        entries: list[ModelEntry] = []
+        for provider in self.providers.values():
+            for model in provider.models:
+                upstream = model["upstream"]
+                context = int(model.get("context", 200_000))
+                entries.append(
+                    ModelEntry(
+                        public_id=make_public_id(provider.name, upstream, context),
+                        display_name=model.get("display_name", upstream),
+                        provider=provider.name,
+                        upstream=upstream,
+                        context=context,
+                        max_tokens=model.get("max_tokens"),
+                    )
+                )
+        return entries

ccgw/errors.py

@@ -0,0 +1,80 @@
+"""Upstream error normalisation.
+
+Claude Code parses gateway error bodies and uses them to drive automatic
+capability downgrade and retry, so the *shape* must be the Anthropic one:
+
+    {"type": "error", "error": {"type": ..., "message": ...}}
+
+GLM and MiMo both return non-conforming bodies (GLM auth errors look like
+`{"error": {"message": ..., "type": "1001"}}`, MiMo returns
+`{"error": {"message": ..., "code": "401", "type": "invalid_key"}}`), so we
+re-shape them. The upstream *message text* is always preserved verbatim --
+Claude Code matches on it, and rewriting it would break its retry heuristics.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+STATUS_TO_ANTHROPIC_TYPE = {
+    400: "invalid_request_error",
+    401: "authentication_error",
+    403: "permission_error",
+    404: "not_found_error",
+    413: "request_too_large",
+    422: "invalid_request_error",
+    429: "rate_limit_error",
+    500: "api_error",
+    502: "api_error",
+    503: "overloaded_error",
+    504: "api_error",
+}
+
+
+def anthropic_error(status: int, message: str, error_type: str | None = None) -> dict:
+    return {
+        "type": "error",
+        "error": {
+            "type": error_type or STATUS_TO_ANTHROPIC_TYPE.get(status, "api_error"),
+            "message": message,
+        },
+    }
+
+
+def normalize_upstream_error(status: int, body: bytes, provider: str) -> dict:
+    """Coerce an upstream error body into Anthropic shape, keeping the text."""
+    try:
+        parsed: Any = json.loads(body)
+    except Exception:
+        text = body.decode("utf-8", "replace").strip() or f"HTTP {status}"
+        return anthropic_error(status, f"[{provider}] {text[:2000]}")
+
+    # Already Anthropic shaped -- forward untouched.
+    if (
+        isinstance(parsed, dict)
+        and parsed.get("type") == "error"
+        and isinstance(parsed.get("error"), dict)
+        and parsed["error"].get("message")
+    ):
+        return parsed
+
+    message = None
+    error_type = None
+    if isinstance(parsed, dict):
+        inner = parsed.get("error")
+        if isinstance(inner, dict):
+            message = inner.get("message")
+            raw_type = str(inner.get("type", ""))
+            # GLM and MiMo put HTTP-ish codes in `type`; those are not valid
+            # Anthropic error types, so fall back to the status mapping.
+            if raw_type and not raw_type.isdigit() and "_" in raw_type:
+                error_type = raw_type
+        elif isinstance(inner, str):
+            message = inner
+        message = message or parsed.get("message")
+
+    if not message:
+        message = body.decode("utf-8", "replace").strip()[:2000] or f"HTTP {status}"
+
+    return anthropic_error(status, f"[{provider}] {message}", error_type)

ccgw/provider.py

@@ -0,0 +1,335 @@
+"""Anthropic-dialect upstream provider.
+
+Every backend this gateway talks to already speaks the Anthropic Messages API,
+so there is deliberately no OpenAI translation layer here. A provider only
+differs in three respects: how it authenticates, which request fields it
+tolerates, and how malformed its error bodies are.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import Any, AsyncIterator
+
+import httpx
+
+from .config import Config, ModelEntry, Provider, make_public_id
+from .errors import normalize_upstream_error
+from .sanitize import (
+    enforce_tool_pairing,
+    sanitize_messages,
+    strip_cache_control,
+)
+
+# Hop-by-hop and client-specific headers that must never be relayed upstream.
+DROP_REQUEST_HEADERS = {
+    "host",
+    "content-length",
+    "content-type",
+    "connection",
+    "keep-alive",
+    "transfer-encoding",
+    "authorization",
+    "x-api-key",
+    "accept-encoding",
+    "user-agent",
+}
+
+DROP_RESPONSE_HEADERS = {
+    "content-length",
+    "content-encoding",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+}
+
+PING_EVENT = b'event: ping\ndata: {"type":"ping"}\n\n'
+
+LOOPBACK_HOSTS = {"127.0.0.1", "localhost", "::1", "[::1]"}
+
+
+def _proxy_for(provider: Provider) -> str | None:
+    """Pick the egress proxy for a provider.
+
+    Local daemons must be reached directly; remote providers go through the
+    environment's proxy when one is configured.
+    """
+    if provider.proxy is not None:
+        return provider.proxy or None
+    host = httpx.URL(provider.base_url).host
+    if host in LOOPBACK_HOSTS:
+        return None
+    for key in ("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"):
+        value = os.environ.get(key)
+        if value:
+            return value
+    return None
+
+
+class UpstreamError(Exception):
+    def __init__(self, status: int, payload: dict):
+        super().__init__(payload.get("error", {}).get("message", "upstream error"))
+        self.status = status
+        self.payload = payload
+
+
+class ProviderClient:
+    def __init__(self, provider: Provider, config: Config):
+        self.provider = provider
+        self.config = config
+        # `trust_env` is off on purpose: httpx chokes on NO_PROXY entries that
+        # contain IPv6 literals or CIDR blocks, which corporate environments
+        # routinely set. Proxy selection is therefore explicit.
+        self.client = httpx.AsyncClient(
+            timeout=httpx.Timeout(
+                config.server.read_timeout,
+                connect=config.server.connect_timeout,
+            ),
+            follow_redirects=False,
+            trust_env=False,
+            proxy=_proxy_for(provider),
+        )
+
+    async def aclose(self) -> None:
+        await self.client.aclose()
+
+    # ---------------------------------------------------------------- headers
+
+    def build_headers(self, incoming: dict[str, str]) -> dict[str, str]:
+        headers = {
+            key: value
+            for key, value in incoming.items()
+            if key.lower() not in DROP_REQUEST_HEADERS
+        }
+        headers.update(self.provider.auth_headers())
+        headers["Content-Type"] = "application/json"
+        headers.setdefault("anthropic-version", "2023-06-01")
+        # coconut refuses a non-loopback Host and gates /v1/models on a
+        # User-Agent containing "claude".
+        if self.provider.force_host:
+            headers["Host"] = self.provider.force_host
+        if self.provider.user_agent:
+            headers["User-Agent"] = self.provider.user_agent
+        else:
+            headers.setdefault("User-Agent", "claude-cli/2.1.0 (external, cli)")
+        return headers
+
+    # ---------------------------------------------------------------- payload
+
+    def build_payload(self, body: dict, entry: ModelEntry) -> dict:
+        payload = dict(body)
+        payload["model"] = entry.upstream
+
+        messages, stripped = sanitize_messages(payload.get("messages"))
+        payload["messages"] = enforce_tool_pairing(messages)
+
+        # Removing thinking blocks while keeping the top-level `thinking`
+        # parameter is itself a 400 on strict backends -- the two must move
+        # together.
+        if self.provider.drop_thinking_param or stripped:
+            payload.pop("thinking", None)
+
+        if self.provider.normalize_thinking and "thinking" in payload:
+            thinking = payload.get("thinking")
+            if isinstance(thinking, dict):
+                # MiMo only accepts enabled/disabled and rejects budget_tokens.
+                kind = thinking.get("type")
+                payload["thinking"] = {
+                    "type": "disabled" if kind == "disabled" else "enabled"
+                }
+            else:
+                payload.pop("thinking", None)
+
+        if self.provider.strip_cache_control:
+            payload = strip_cache_control(payload)
+
+        # MiMo silently truncates to a small per-model default when max_tokens
+        # is absent, so always send an explicit ceiling.
+        if entry.max_tokens:
+            requested = payload.get("max_tokens")
+            if not isinstance(requested, int) or requested <= 0:
+                payload["max_tokens"] = entry.max_tokens
+            else:
+                payload["max_tokens"] = min(requested, entry.max_tokens)
+
+        return payload
+
+    # ------------------------------------------------------------------ calls
+
+    def _url(self, path: str) -> str:
+        return self.provider.base_url.rstrip("/") + path
+
+    async def messages_once(self, payload: dict, headers: dict[str, str]) -> httpx.Response:
+        response = await self.client.post(
+            self._url("/v1/messages"), json=payload, headers=headers
+        )
+        if response.status_code >= 400:
+            raise UpstreamError(
+                response.status_code,
+                normalize_upstream_error(
+                    response.status_code, response.content, self.provider.name
+                ),
+            )
+        return response
+
+    async def messages_stream(
+        self, payload: dict, headers: dict[str, str]
+    ) -> AsyncIterator[bytes]:
+        """Relay an upstream SSE stream with zero buffering.
+
+        Claude Code aborts a stream after 300 seconds without bytes, so a ping
+        is injected whenever the upstream goes quiet.
+        """
+        request = self.client.build_request(
+            "POST", self._url("/v1/messages"), json=payload, headers=headers
+        )
+        response = await self.client.send(request, stream=True)
+
+        if response.status_code >= 400:
+            body = await response.aread()
+            await response.aclose()
+            raise UpstreamError(
+                response.status_code,
+                normalize_upstream_error(
+                    response.status_code, body, self.provider.name
+                ),
+            )
+
+        queue: asyncio.Queue[bytes | None] = asyncio.Queue(maxsize=64)
+
+        async def pump() -> None:
+            try:
+                async for chunk in response.aiter_raw():
+                    if chunk:
+                        await queue.put(chunk)
+            except Exception as exc:  # surface mid-stream failures to the client
+                message = json.dumps(
+                    {
+                        "type": "error",
+                        "error": {
+                            "type": "api_error",
+                            "message": f"[{self.provider.name}] stream aborted: {exc}",
+                        },
+                    }
+                )
+                await queue.put(f"event: error\ndata: {message}\n\n".encode())
+            finally:
+                await queue.put(None)
+                await response.aclose()
+
+        task = asyncio.create_task(pump())
+        interval = self.config.server.ping_interval
+        try:
+            while True:
+                try:
+                    chunk = await asyncio.wait_for(queue.get(), timeout=interval)
+                except asyncio.TimeoutError:
+                    yield PING_EVENT
+                    continue
+                if chunk is None:
+                    break
+                yield chunk
+        finally:
+            task.cancel()
+
+    # -------------------------------------------------------------- discovery
+
+    async def discover_models(self) -> list[ModelEntry]:
+        """Fetch a provider's own catalogue and re-key it under our namespace."""
+        headers = self.build_headers({})
+        response = await self.client.get(
+            self._url("/v1/models"), headers=headers, params={"limit": 1000}
+        )
+        response.raise_for_status()
+        data = response.json().get("data") or []
+
+        entries: list[ModelEntry] = []
+        for item in data:
+            upstream = item.get("id")
+            if not upstream:
+                continue
+            context = int(item.get("max_input_tokens") or 0)
+            if not context:
+                context = 1_000_000 if "[1m]" in upstream else 200_000
+            entries.append(
+                ModelEntry(
+                    public_id=make_public_id(self.provider.name, upstream, context),
+                    display_name=item.get("display_name") or upstream,
+                    provider=self.provider.name,
+                    upstream=upstream,
+                    context=context,
+                    max_tokens=item.get("max_tokens"),
+                )
+            )
+        return entries
+
+
+class Registry:
+    """Public model id -> ModelEntry, plus the provider clients."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.clients = {
+            name: ProviderClient(provider, config)
+            for name, provider in config.providers.items()
+        }
+        self.models: dict[str, ModelEntry] = {}
+        self.default_id: str | None = None
+
+    async def refresh(self) -> list[str]:
+        """(Re)build the catalogue. Returns human-readable warnings."""
+        warnings: list[str] = []
+        models: dict[str, ModelEntry] = {}
+
+        for entry in self.config.static_models():
+            models[entry.public_id] = entry
+
+        for name, client in self.clients.items():
+            if not client.provider.discover:
+                continue
+            try:
+                for entry in await client.discover_models():
+                    models[entry.public_id] = entry
+            except Exception as exc:
+                warnings.append(f"discovery failed for provider {name!r}: {exc}")
+
+        self.models = models
+        self.default_id = next(iter(models), None)
+        return warnings
+
+    def resolve(self, requested: Any) -> ModelEntry | None:
+        """Map a requested model name onto a catalogue entry.
+
+        Claude Code emits background/subagent requests whose model may not be
+        in our catalogue (for example a hard-coded haiku id). Returning 404 for
+        those makes those tasks fail silently and is very hard to debug, so we
+        fall back rather than reject.
+        """
+        if not isinstance(requested, str) or not requested.strip():
+            return self.models.get(self.default_id) if self.default_id else None
+
+        name = requested.strip()
+        if name in self.models:
+            return self.models[name]
+
+        lowered = name.lower()
+        for public_id, entry in self.models.items():
+            if public_id.lower() == lowered or entry.upstream.lower() == lowered:
+                return entry
+
+        # Suffix-insensitive match, so `...-max` and `...-max[1m]` are the same.
+        bare = lowered.replace("[1m]", "")
+        for public_id, entry in self.models.items():
+            if public_id.lower().replace("[1m]", "") == bare:
+                return entry
+
+        return self.models.get(self.default_id) if self.default_id else None
+
+    def client_for(self, entry: ModelEntry) -> ProviderClient:
+        return self.clients[entry.provider]
+
+    async def aclose(self) -> None:
+        for client in self.clients.values():
+            await client.aclose()

ccgw/sanitize.py

@@ -0,0 +1,185 @@
+"""Cross-provider conversation history sanitisation.
+
+Claude Code lets the user switch models mid-session with `/model`. When that
+happens it replays the *entire* history to the new backend without any
+reconciliation. Thinking blocks carry a `signature` that is bound to the model
+and credentials that produced them, so replaying them at a different provider
+fails with a 400 and can wedge the session permanently.
+
+Anthropic's own guidance for switching models is to strip `thinking` and
+`redacted_thinking` from prior assistant turns, so that is exactly what we do --
+unconditionally, on every request. This is stateless (no session bookkeeping,
+nothing to get stale across a gateway restart or `--resume`) and it is a no-op
+for backends that ignore thinking anyway.
+
+Two failure modes have to be avoided while stripping:
+
+* removing thinking blocks while leaving the top-level `thinking` request
+  parameter in place makes strict backends reply
+  "Expected `thinking` ... but found `tool_use`";
+* emptying a message's `content` array is itself a 400.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+THINKING_BLOCKS = {"thinking", "redacted_thinking"}
+# Server-side tool blocks are provider specific and never replayable elsewhere.
+SERVER_TOOL_BLOCKS = {"server_tool_use", "web_search_tool_result"}
+PLACEHOLDER = {"type": "text", "text": "[thinking]"}
+
+# Anthropic requires tool ids to match ^[a-zA-Z0-9_-]+$.
+_ILLEGAL_TOOL_ID = re.compile(r"[^a-zA-Z0-9_-]")
+
+
+def _normalise_tool_id(tool_id: str) -> str:
+    cleaned = _ILLEGAL_TOOL_ID.sub("_", str(tool_id))
+    # `srvtoolu_` ids belong to server-side tools and are rejected on replay.
+    if cleaned.startswith("srvtoolu_"):
+        cleaned = "toolu_" + cleaned[len("srvtoolu_"):]
+    return cleaned or "toolu_unknown"
+
+
+def _clean_assistant_content(content: Any) -> tuple[list[dict], bool]:
+    """Drop unreplayable blocks from one assistant message.
+
+    Returns the new block list and whether anything was removed.
+    """
+    if not isinstance(content, list):
+        return content, False
+
+    kept: list[dict] = []
+    removed = False
+    for block in content:
+        if not isinstance(block, dict):
+            kept.append(block)
+            continue
+        kind = block.get("type")
+        if kind in THINKING_BLOCKS or kind in SERVER_TOOL_BLOCKS:
+            removed = True
+            continue
+        # An empty text block is legal to emit but rejected on replay.
+        if kind == "text" and not str(block.get("text", "")).strip():
+            removed = True
+            continue
+        kept.append(block)
+
+    if not kept:
+        kept = [dict(PLACEHOLDER)]
+    return kept, removed
+
+
+def sanitize_messages(messages: Any) -> tuple[list[dict], bool]:
+    """Strip thinking blocks and normalise tool ids across the whole history."""
+    if not isinstance(messages, list):
+        return messages, False
+
+    stripped_any = False
+    id_map: dict[str, str] = {}
+    out: list[dict] = []
+
+    for message in messages:
+        if not isinstance(message, dict):
+            out.append(message)
+            continue
+        message = dict(message)
+        content = message.get("content")
+
+        if message.get("role") == "assistant":
+            content, removed = _clean_assistant_content(content)
+            stripped_any = stripped_any or removed
+
+        if isinstance(content, list):
+            rebuilt = []
+            for block in content:
+                if not isinstance(block, dict):
+                    rebuilt.append(block)
+                    continue
+                block = dict(block)
+                if block.get("type") == "tool_use" and "id" in block:
+                    original = str(block["id"])
+                    fixed = _normalise_tool_id(original)
+                    if fixed != original:
+                        id_map[original] = fixed
+                        block["id"] = fixed
+                elif block.get("type") == "tool_result" and "tool_use_id" in block:
+                    original = str(block["tool_use_id"])
+                    block["tool_use_id"] = id_map.get(
+                        original, _normalise_tool_id(original)
+                    )
+                rebuilt.append(block)
+            content = rebuilt
+
+        message["content"] = content
+        out.append(message)
+
+    return out, stripped_any
+
+
+def enforce_tool_pairing(messages: list[dict]) -> list[dict]:
+    """Synthesise placeholder results for tool_use blocks nobody answered.
+
+    A dangling tool_use is a 400 at every backend. This can happen when the
+    client aborted a turn, which is common when the user switches model
+    mid-stream.
+    """
+    if not isinstance(messages, list):
+        return messages
+
+    for index, message in enumerate(messages):
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        pending = [
+            block["id"]
+            for block in content
+            if isinstance(block, dict) and block.get("type") == "tool_use" and block.get("id")
+        ]
+        if not pending:
+            continue
+
+        nxt = messages[index + 1] if index + 1 < len(messages) else None
+        answered: set[str] = set()
+        if isinstance(nxt, dict) and nxt.get("role") == "user":
+            for block in nxt.get("content") or []:
+                if isinstance(block, dict) and block.get("type") == "tool_result":
+                    answered.add(str(block.get("tool_use_id")))
+
+        missing = [tool_id for tool_id in pending if tool_id not in answered]
+        if not missing:
+            continue
+
+        results = [
+            {
+                "type": "tool_result",
+                "tool_use_id": tool_id,
+                "content": "Tool call was interrupted.",
+                "is_error": True,
+            }
+            for tool_id in missing
+        ]
+        if isinstance(nxt, dict) and nxt.get("role") == "user" and isinstance(
+            nxt.get("content"), list
+        ):
+            nxt["content"] = results + nxt["content"]
+        else:
+            messages.insert(index + 1, {"role": "user", "content": results})
+
+    return messages
+
+
+def strip_cache_control(payload: Any) -> Any:
+    """Recursively remove `cache_control`, which most compat layers reject."""
+    if isinstance(payload, dict):
+        return {
+            key: strip_cache_control(value)
+            for key, value in payload.items()
+            if key != "cache_control"
+        }
+    if isinstance(payload, list):
+        return [strip_cache_control(item) for item in payload]
+    return payload

ccgw-0.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.5
+Name: ccgw
+Version: 0.1.0
+Summary: Local multi-provider Anthropic-protocol gateway for Claude Code: coconut, GLM and MiMo in one /model menu.
+Project-URL: Homepage, https://github.com/XuNeo/ccgw
+Project-URL: Repository, https://github.com/XuNeo/ccgw
+Project-URL: Issues, https://github.com/XuNeo/ccgw/issues
+Author: XuNeo
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,claude,claude-code,gateway,glm,llm,mimo,proxy
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx>=0.27
+Requires-Dist: uvicorn[standard]>=0.32
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cc-gateway
+
+A local multi-provider gateway that impersonates the Anthropic Messages API for
+Claude Code, so you can switch between models from different backends at any
+point in any session.
+
+It forwards the Anthropic dialect only. Every backend must expose an
+Anthropic-compatible endpoint; there is deliberately no OpenAI translation
+layer.
+
+## Providers
+
+| provider | endpoint | auth |
+| --- | --- | --- |
+| `coconut` | `http://127.0.0.1:8787` (local daemon) | `Bearer coconut` |
+| `glm` | `https://open.bigmodel.cn/api/anthropic` | `x-api-key`, `$GLM_API_KEY` |
+| `mimo` | `https://token-plan-cn.xiaomimimo.com/anthropic` | `x-api-key`, `$MIMO_API_KEY` |
+
+## Install
+
+Requires Python 3.11+ (`tomllib` is stdlib there).
+
+```bash
+uv tool install ccgw
+# or
+pipx install ccgw
+```
+
+## Run
+
+The gateway reads its provider registry from a `config.toml`, looked up in
+this order: `$CCGW_CONFIG`, `./config.toml`, `~/.config/ccgw/config.toml`.
+
+```bash
+export GLM_API_KEY=...      # never stored in this repo
+export MIMO_API_KEY=...
+ccgw                        # listens on 127.0.0.1:8788
+ccgw --port 9000            # or --config /path/to/config.toml
+```
+
+A source checkout can run the same entry point directly:
+
+```bash
+pip install -r requirements.txt
+python serve.py
+```
+
+Point Claude Code at it in `~/.claude/settings.json`:
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:8788",
+    "ANTHROPIC_AUTH_TOKEN": "ccgw",
+    "ANTHROPIC_API_KEY": "",
+    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
+  }
+}
+```
+
+Do **not** set `ANTHROPIC_DEFAULT_*_MODEL` or `ANTHROPIC_SMALL_FAST_MODEL`:
+the gateway serves every model from one catalogue, and pinning those variables
+would route background traffic around the router.
+
+## Model naming
+
+Public ids are generated as `claude-<provider>-<slug>` plus a `[1m]` suffix for
+models with a 1M context window. Both parts are load-bearing:
+
+* Claude Code's gateway discovery drops any id that does not contain `claude`
+  or `anthropic`, so the prefix is mandatory for a model to appear in `/model`.
+* Claude Code infers a 1M window from a `[1m]` substring, which is how the
+  gateway communicates window size. `/v1/models` cannot carry it: Claude Code's
+  parser keeps only `id` and `display_name`.
+
+The suffix is presentation only. It is stripped before the request goes
+upstream, because neither GLM nor MiMo accepts a `[1m]` model name on these
+endpoints (both reject it outright), even though their Coding Plan docs
+describe the suffix.
+
+## Behaviour worth knowing
+
+**History sanitisation.** Every request has `thinking` and `redacted_thinking`
+blocks stripped from the history, unconditionally. Thinking signatures are
+bound to the model and credentials that produced them, and Claude Code replays
+the full history verbatim when you switch models, so a stale signature is a 400
+that can wedge a session permanently. Stripping is stateless, matches
+Anthropic's own guidance for switching models, and is a no-op for backends that
+ignore thinking anyway. The top-level `thinking` parameter is removed in
+lockstep, since removing the blocks alone is itself a 400.
+
+**Tool repair.** Tool ids are normalised to `^[a-zA-Z0-9_-]+$` and dangling
+`tool_use` blocks get a synthetic error result, both of which are otherwise
+400s after an interrupted turn.
+
+**Errors.** Upstream failures are re-shaped into the Anthropic envelope but the
+upstream message text is preserved verbatim, because Claude Code matches on it
+to drive automatic capability downgrade and retry.
+
+**Streaming.** Upstream bytes are relayed unbuffered, with a `ping` injected
+every 15 seconds of silence to stay under Claude Code's 300 second stream
+watchdog.
+
+**Token counting.** `/v1/messages/count_tokens` is answered locally and never
+proxied; coconut does not implement it, and Claude Code falls back to its own
+estimate anyway.
+
+## License
+
+[MIT](LICENSE)

ccgw-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+ccgw/__init__.py,sha256=v6uccAOn1cqaanZHJ6rfNvcj6yDxpGaKywhSYmGDxIk,170
+ccgw/app.py,sha256=yon6DiMg8Y6sVM2-5GGIsfTh_JAcb6kRjglEmz4uzU0,6213
+ccgw/cli.py,sha256=CO7kMtQBOGL1bzIcjd28NsJBA4OGrV6x93o3iE8QFmI,1773
+ccgw/config.py,sha256=2ttGwCSmc3V_xVqm1SMp5faC1otEpv2OY4rExNu2ZAA,4431
+ccgw/errors.py,sha256=rEybYEk4ah6XYX-44RiEMWoR8GikMc1tD9_r70Jj7BM,2741
+ccgw/provider.py,sha256=XrnyvFJqZU6xG_Bpzlj5mcgsJRwKNMIovg30eawrtmw,12005
+ccgw/sanitize.py,sha256=swjHKnSmdoSziVuF4Uy4ZBsGpBMchv_HRXDlBDCOZdI,6692
+ccgw-0.1.0.dist-info/METADATA,sha256=_EO9-qQj5meNd2eYJ_Z7T8RULZcJc_BefE0iYYb_-20,5073
+ccgw-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+ccgw-0.1.0.dist-info/entry_points.txt,sha256=Hgvqs6iemro2SAjrbF2D1rixB736av7JTh8CWxJkcgU,39
+ccgw-0.1.0.dist-info/licenses/LICENSE,sha256=iaIFp8ODtIXtlsDf7Fz4vrhKokq7tbGuHdl7z1LZBfw,1062
+ccgw-0.1.0.dist-info/RECORD,,

ccgw-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ccgw-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ccgw = ccgw.cli:main

ccgw-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 XuNeo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.