feat: add vLLM as alternative inference backend (#1281)

Adds vLLM (high-throughput OpenAI-compatible inference server) as a
selectable backend alongside the existing Ollama and vllm-mlx backends.
vLLM's continuous batching gives 3-10x throughput for agentic workloads.

Changes:
- config.py: add `vllm` to timmy_model_backend Literal; add vllm_url /
  vllm_model settings (VLLM_URL / VLLM_MODEL env vars)
- cascade.py: add vllm provider type with _check_provider_available
  (hits /health) and _call_vllm (OpenAI-compatible completions)
- providers.yaml: add disabled-by-default vllm-local provider (priority 3,
  port 8001); bump OpenAI/Anthropic backup priorities to 4/5
- health.py: add _check_vllm/_check_vllm_sync with 30-second TTL cache;
  /health and /health/sovereignty reflect vLLM status when it is the
  active backend
- docker-compose.yml: add vllm service behind 'vllm' profile (GPU
  passthrough commented-out template included); add vllm-cache volume
- CLAUDE.md: add vLLM row to Service Fallback Matrix
- tests: 26 new unit tests covering availability checks, _call_vllm,
  providers.yaml validation, config options, and health helpers

Graceful fallback: if vLLM is unavailable the cascade router automatically
falls back to Ollama. The app never crashes.

Fixes #1281

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/infrastructure/router/cascade.py

@@ -331,6 +331,22 @@ class CascadeRouter:
                 logger.debug("vllm-mlx provider check error: %s", exc)
                 return False
 
+        elif provider.type == "vllm":
+            # Check if standard vLLM server is running (OpenAI-compatible API)
+            if requests is None:
+                return True
+            try:
+                base_url = provider.base_url or provider.url or settings.vllm_url
+                # Strip /v1 suffix — health endpoint is at the server root
+                server_root = base_url.rstrip("/")
+                if server_root.endswith("/v1"):
+                    server_root = server_root[:-3]
+                response = requests.get(f"{server_root}/health", timeout=5)
+                return response.status_code == 200
+            except Exception as exc:
+                logger.debug("vllm provider check error: %s", exc)
+                return False
+
         elif provider.type in ("openai", "anthropic", "grok"):
             # Check if API key is set
             return provider.api_key is not None and provider.api_key != ""
@@ -793,6 +809,14 @@ class CascadeRouter:
                 temperature=temperature,
                 max_tokens=max_tokens,
             )
+        elif provider.type == "vllm":
+            result = await self._call_vllm(
+                provider=provider,
+                messages=messages,
+                model=model or provider.get_default_model(),
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
         else:
             raise ValueError(f"Unknown provider type: {provider.type}")
 
@@ -1031,6 +1055,49 @@ class CascadeRouter:
             "model": response.model,
         }
 
+    async def _call_vllm(
+        self,
+        provider: Provider,
+        messages: list[dict],
+        model: str,
+        temperature: float,
+        max_tokens: int | None,
+    ) -> dict:
+        """Call a standard vLLM server via its OpenAI-compatible API.
+
+        vLLM exposes the same /v1/chat/completions endpoint as OpenAI.
+        No API key is required for local deployments.
+
+        Default URL comes from settings.vllm_url (VLLM_URL env var).
+        """
+        import openai
+
+        base_url = provider.base_url or provider.url or settings.vllm_url
+        # Ensure the base_url ends with /v1 as expected by the OpenAI client
+        if not base_url.rstrip("/").endswith("/v1"):
+            base_url = base_url.rstrip("/") + "/v1"
+
+        client = openai.AsyncOpenAI(
+            api_key=provider.api_key or "no-key-required",
+            base_url=base_url,
+            timeout=self.config.timeout_seconds,
+        )
+
+        kwargs: dict = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+        }
+        if max_tokens:
+            kwargs["max_tokens"] = max_tokens
+
+        response = await client.chat.completions.create(**kwargs)
+
+        return {
+            "content": response.choices[0].message.content,
+            "model": response.model,
+        }
+
     def _record_success(self, provider: Provider, latency_ms: float) -> None:
         """Record a successful request."""
         provider.metrics.total_requests += 1