llmshim 0.2.3__tar.gz → 0.3.1__tar.gz

{llmshim-0.2.3 → llmshim-0.3.1}/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What is llmshim
 
-A pure Rust LLM API translation layer. Takes OpenAI-format JSON requests, translates them to provider-native formats (and back), with zero infrastructure requirements. Supports OpenAI (Responses API), Anthropic, Google Gemini, and xAI. Includes an interactive CLI chat with streaming, reasoning, and mid-conversation model switching.
+A pure Rust LLM API translation layer. Takes OpenAI-format JSON requests, translates them to provider-native formats (and back), with zero infrastructure requirements. Supports OpenAI (Responses API), Anthropic, Google Gemini, xAI, OpenRouter (an OpenAI Chat Completions-compatible aggregator), and self-hosted **vLLM** / **SGLang** servers (OpenAI Chat Completions-compatible, local or remote). Includes an interactive CLI chat with streaming, reasoning, and mid-conversation model switching.
 
 **Published on crates.io as `llmshim`** — https://crates.io/crates/llmshim
 
@@ -16,6 +16,8 @@ This is a public crate on crates.io. Do NOT make breaking changes to `pub` items
 - **Anthropic:** `claude-opus-5`, `claude-opus-4-8`, `claude-sonnet-5`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-sonnet-4-6`, `claude-haiku-4-5-20251001`
 - **Gemini:** `gemini-3.5-flash`, `gemini-3.1-pro-preview`, `gemini-3-flash-preview`
 - **xAI:** `grok-4.5`, `grok-4.3`, `grok-4.20-multi-agent-beta-0309`, `grok-4.20-beta-0309-reasoning`, `grok-4.20-beta-0309-non-reasoning`
+- **OpenRouter:** not enumerated (huge/dynamic catalog) — any `openrouter/<vendor>/<model>` slug routes through, e.g. `openrouter/anthropic/claude-sonnet-4.5`.
+- **vLLM / SGLang:** not enumerated (self-hosted) — any `vllm/<served-model>` or `sglang/<served-model>` routes through to the configured server, e.g. `sglang/Qwen/Qwen3.6-35B-A3B-FP8`.
 
 ## Build & Test
 
@@ -30,13 +32,17 @@ cargo run                                            # interactive CLI chat
 cargo run --features proxy -- proxy                  # proxy server on :3000
 ```
 
-API keys: `~/.llmshim/config.toml` (via `llmshim configure`) or env vars `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`. Precedence: env vars > config file.
+API keys: `~/.llmshim/config.toml` (via `llmshim configure`) or env vars `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `XAI_API_KEY`, `OPENROUTER_API_KEY`. Precedence: env vars > config file. Self-hosted servers are configured by **base URL** instead of a key: `VLLM_BASE_URL` / `SGLANG_BASE_URL` (each with an optional `VLLM_API_KEY` / `SGLANG_API_KEY`); the provider registers only when its base URL is set. Local vs remote is just the URL value.
 
 ## Architecture
 
 ### Value-based transforms, no canonical struct
 
-Requests flow as `serde_json::Value`. Each provider's transform takes raw JSON and maps only what it understands. Provider-specific features use `x-anthropic`, `x-gemini` namespaces.
+Requests flow as `serde_json::Value`. Each provider's transform takes raw JSON and maps only what it understands. Provider-specific features use `x-anthropic`, `x-gemini`, `x-openrouter`, `x-vllm`, `x-sglang` namespaces.
+
+**Self-hosted passthrough providers (vLLM / SGLang).** `src/providers/openai_compat.rs` is one generic OpenAI Chat Completions passthrough backing both `vllm` and `sglang` (`OpenAiCompatible::new(name, base_url, api_key: Option)`, registered per env base URL). Two things differ from the hosted providers: the **base URL is configuration** (local `http://localhost:8000/v1` vs remote `https://host/v1`), and **auth is optional** (self-hosted servers are unauthenticated unless launched with `--api-key`, so the `Authorization` header is sent only when a key is set). Passthrough transforms; `reasoning`/`reasoning_content` normalized to `reasoning_content` (vLLM is migrating the field name); `reasoning_effort` forwarded as-is (honored per-model, not clamped); server-specific params go under `x-<name>` (`chat_template_kwargs`, `separate_reasoning`, `guided_json`, `top_k`, …). Note: reasoning/tool parsing are **launch-time server flags** (`--reasoning-parser`, `--tool-call-parser`), so a request only gets that behavior if the server was started for it — llmshim can't enable it per request.
+
+**OpenRouter is the one passthrough provider.** Every other provider translates the OpenAI-format input *away* to a native dialect; OpenRouter (`src/providers/openrouter.rs`) *is* OpenAI Chat Completions, so its transforms are near-identity — messages, tools, vision (`image_url`), and `response_format` are forwarded unchanged; `reasoning_effort` maps 1:1 to OpenRouter's `reasoning:{effort}` (its effort vocabulary is a superset, so no clamping); `message.reasoning` is normalized to `reasoning_content` on responses. OpenRouter models are **not enumerated** in `src/models.rs` (the catalog is huge and dynamic) — any `openrouter/<vendor>/<model>` slug routes through. `x-openrouter` carries OpenRouter-only controls (`provider`, `models`, `transforms`, `route`, native `reasoning`; plus `http_referer`/`x_title` which become headers). The `middle-out` transform is disabled by default for faithful passthrough. Uses `image_url` (Chat Completions) vision via `vision::to_openai_chat`.
 
 ### Request flow
 
@@ -54,7 +60,7 @@ Every provider implements: `transform_request`, `transform_response`, `transform
 
 ### Router (`src/router.rs`)
 
-Parses `"provider/model"` strings. Auto-infers provider from prefix (`gpt*`/`o*` → openai, `claude*` → anthropic, `gemini*` → gemini, `grok*` → xai). Supports aliases. `Router::from_env()` reads API key env vars.
+Parses `"provider/model"` strings by splitting on the **first** `/` only, so an OpenRouter slug's internal slash survives (`openrouter/anthropic/claude-sonnet-4.5` → provider `openrouter`, model `anthropic/claude-sonnet-4.5`). Auto-infers provider from prefix (`gpt*`/`o*` → openai, `claude*` → anthropic, `gemini*` → gemini, `grok*` → xai); **OpenRouter, vLLM, and SGLang have no prefix inference** — their slugs collide with everyone's, so address them explicitly (`openrouter/…`, `vllm/…`, `sglang/…`); the first-slash split also preserves HF-style served-model slugs (`vllm/meta-llama/Llama-3.1-8B-Instruct`). Supports aliases. `Router::from_env()` reads API-key env vars, plus `VLLM_BASE_URL` / `SGLANG_BASE_URL` (+ optional `*_API_KEY`) for the self-hosted providers.
 
 ### HTTP Client (`src/client.rs`)
 
@@ -90,6 +96,8 @@ llmshim accepts tools in OpenAI Chat Completions format (nested `function` objec
 - **OpenAI (Responses API):** Tool definitions flattened from `{"type": "function", "function": {"name": ..., "parameters": ...}}` to `{"type": "function", "name": ..., "parameters": ...}`. Assistant messages with `tool_calls` → `function_call` items. `role: "tool"` messages → `function_call_output` items. Streaming function call events (`response.output_item.added`, `response.function_call_arguments.delta`) translated to Chat Completions chunk format.
 - **Anthropic:** Tools translated to `{"name": ..., "description": ..., "input_schema": ...}` format. Tool results translated to Anthropic's `tool_result` content blocks.
 - **xAI:** Same flat format as OpenAI Responses API — `translate_tools()` flattens nested format.
+- **OpenRouter:** No translation — it accepts the Chat Completions nested `{"type":"function","function":{…}}` format directly, so `tools`/`tool_choice`/`tool_calls` pass through unchanged.
+- **vLLM / SGLang:** Same as OpenRouter — Chat Completions nested tool format passes through unchanged (the server must be launched with `--tool-call-parser` / `--enable-auto-tool-choice` for tool calls to be parsed).
 - **Gemini:** Tools wrapped in `functionDeclarations`. Tool results translated to `functionResponse` format.
 
 ### CLI (`src/main.rs`)

{llmshim-0.2.3 → llmshim-0.3.1}/Cargo.lock

@@ -958,7 +958,7 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "llmshim"
-version = "0.2.3"
+version = "0.3.1"
 dependencies = [
  "async-stream",
  "async-trait",

{llmshim-0.2.3 → llmshim-0.3.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim"
-version = "0.2.3"
+version = "0.3.1"
 edition = "2021"
 description = "Blazing fast LLM API translation layer in pure Rust"
 license = "MIT OR Apache-2.0"

{llmshim-0.2.3 → llmshim-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llmshim
-Version: 0.2.3
+Version: 0.3.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{llmshim-0.2.3 → llmshim-0.3.1}/README.md

@@ -1,6 +1,6 @@
 # llmshim
 
-A blazing-fast LLM API translation layer written in **pure Rust**. One request format, every provider — OpenAI, Anthropic, Google Gemini, and xAI.
+A blazing-fast LLM API translation layer written in **pure Rust**. One request format, every provider — OpenAI, Anthropic, Google Gemini, xAI, OpenRouter, and self-hosted vLLM / SGLang.
 
 Send an OpenAI-style request, pick any model, and llmshim translates it to that provider's native API (and translates the response back). Switch providers by changing one string.
 
@@ -47,8 +47,27 @@ export OPENAI_API_KEY=sk-...
 export ANTHROPIC_API_KEY=sk-ant-...
 export GEMINI_API_KEY=AIza...
 export XAI_API_KEY=xai-...
+export OPENROUTER_API_KEY=sk-or-...
 ```
 
+Reach any model through [OpenRouter](https://openrouter.ai) by addressing it as
+`openrouter/<vendor>/<model>` (e.g. `openrouter/anthropic/claude-sonnet-4.5`).
+OpenRouter is OpenAI Chat Completions-compatible, so tools, vision, streaming,
+and `reasoning_effort` all pass through; OpenRouter-only controls (provider
+routing, model fallbacks, transforms) go under an `x-openrouter` key.
+
+Point at a **self-hosted vLLM or SGLang** server (local or remote) by setting its
+base URL — no key needed unless the server was launched with one:
+
+```bash
+export SGLANG_BASE_URL=http://localhost:30000/v1   # or https://your-host/v1
+export VLLM_BASE_URL=http://localhost:8000/v1
+```
+
+Then address the served model as `sglang/<served-model>` or `vllm/<served-model>`
+(e.g. `sglang/Qwen/Qwen3.6-35B-A3B-FP8`). Server-specific knobs go under
+`x-vllm` / `x-sglang`.
+
 Or persist them to the config file (used by all three surfaces):
 
 ```bash

{llmshim-0.2.3 → llmshim-0.3.1}/docs/src/reference/configuration.md

@@ -12,6 +12,9 @@ set. Therefore **environment variables take precedence over the file**.
 | Anthropic | `ANTHROPIC_API_KEY` | `keys.anthropic` |
 | Google Gemini | `GEMINI_API_KEY` | `keys.gemini` |
 | xAI | `XAI_API_KEY` | `keys.xai` |
+| OpenRouter | `OPENROUTER_API_KEY` | `keys.openrouter` |
+| vLLM (self-hosted) | `VLLM_BASE_URL` (+ optional `VLLM_API_KEY`) | — (env only) |
+| SGLang (self-hosted) | `SGLANG_BASE_URL` (+ optional `SGLANG_API_KEY`) | — (env only) |
 
 The config file shape is:
 

{llmshim-0.2.3 → llmshim-0.3.1}/docs/src/reference/models.md

@@ -119,6 +119,15 @@ provider with `arbitrary-model-id` unchanged. A bare, unregistered model name
 works only when its prefix identifies a provider (`gpt`, `o1`, `o3`, `o4`,
 `claude`, `gemini`, or `grok`).
 
+**OpenRouter** is intentionally not enumerated above — its catalog is large and
+dynamic. Any `openrouter/<vendor>/<model>` slug routes through (e.g.
+`openrouter/anthropic/claude-sonnet-4.5`, `openrouter/meta-llama/llama-3.1-70b-instruct:nitro`);
+the slug's internal slash and `:variant` suffix are preserved. Because its
+slugs collide with other providers' prefixes, OpenRouter has no bare-model
+inference — always address it explicitly as `openrouter/…`.
+
+**Self-hosted vLLM / SGLang** are likewise not enumerated. Set `VLLM_BASE_URL` or `SGLANG_BASE_URL` (with an optional `*_API_KEY`) and address the served model as `vllm/<served-model>` or `sglang/<served-model>` — e.g. `sglang/Qwen/Qwen3.6-35B-A3B-FP8`. Local vs remote is just the base-URL value.
+
 Rust applications can also define one-level Router aliases with
 `Router::alias`. Those aliases are not part of the static registry and are not
 configured by the stock CLI or proxy. See [Models and the Router](../concepts/routing.md).

{llmshim-0.2.3 → llmshim-0.3.1}/docs/src/reference/providers.md

@@ -9,6 +9,9 @@ different native API and translates only the fields that API understands.
 | Anthropic | Messages API | `claude*` | `x-anthropic` |
 | Google Gemini | `generateContent` / `streamGenerateContent` | `gemini*` | `x-gemini` |
 | xAI | Responses API | `grok*` | none |
+| OpenRouter | Chat Completions (aggregator) | none — address as `openrouter/<vendor>/<model>` | `x-openrouter` |
+| vLLM | Chat Completions (self-hosted, `VLLM_BASE_URL`) | none — address as `vllm/<served-model>` | `x-vllm` |
+| SGLang | Chat Completions (self-hosted, `SGLANG_BASE_URL`) | none — address as `sglang/<served-model>` | `x-sglang` |
 
 An explicit address such as `anthropic/claude-sonnet-5` avoids inference.
 The named provider must be registered in the Router—that normally means its
@@ -22,6 +25,8 @@ API key is configured.
 | Anthropic | Messages become Anthropic content blocks; tools use `input_schema`, `tool_use`, and `tool_result` | `max_tokens` defaults to 8192 when absent; supported models receive the 1M-context beta by default; `x-anthropic.extra_betas` appends beta headers and `disable_1m_context` suppresses that automatic header |
 | Gemini | Messages become `contents`; tools use `functionDeclarations`, `functionCall`, and `functionResponse` | Base64 images become `inline_data`, but a remote image URL becomes a text placeholder because Gemini cannot consume it directly; `x-gemini.thinkingConfig` replaces mapped thinking configuration |
 | xAI | System/developer text becomes Responses `instructions`; tools are flattened like OpenAI Responses | Unified reasoning becomes `reasoning: {effort}` where the model accepts it; grok-4.20 reasoning is encoded in the model name; there is no `x-xai` namespace |
+| OpenRouter | Passthrough — messages, tools, `image_url` vision, and `response_format` are already Chat Completions and forwarded unchanged | `reasoning_effort` maps 1:1 to OpenRouter's `reasoning:{effort}` (superset vocabulary, no clamping); `message.reasoning` is normalized to `reasoning_content`; the `middle-out` transform is disabled by default; `x-openrouter` carries `provider`/`models`/`transforms`/`route`/native `reasoning` (and `http_referer`/`x_title` headers) |
+| vLLM / SGLang | Passthrough to a self-hosted server — configured by base URL (local or remote), auth optional | `reasoning`/`reasoning_content` normalized to `reasoning_content`; `reasoning_effort` forwarded (honored per-model); server-specific params (`chat_template_kwargs`, `guided_json`, `top_k`, `separate_reasoning`, …) go under `x-vllm`/`x-sglang`. Reasoning/tool parsing depend on the server's launch flags (`--reasoning-parser`, `--tool-call-parser`) |
 
 OpenAI and xAI do not receive `temperature`, `top_p`, `top_k`, or `stop` from
 the portable top-level request. Anthropic and Gemini do. This is the

{llmshim-0.2.3 → llmshim-0.3.1}/docs/src/reference/request-fields.md

@@ -29,6 +29,8 @@ renamed or reshaped for the selected provider; unsupported controls are omitted.
 | `x-openai` | object | Native passthrough | Fields copied to an OpenAI Responses request |
 | `x-anthropic` | object | Native passthrough/control | Anthropic body fields plus `extra_betas` and `disable_1m_context` controls |
 | `x-gemini` | object | Native passthrough | Gemini body fields; `thinkingConfig` goes under `generationConfig` |
+| `x-openrouter` | object | Native passthrough/control | OpenRouter body fields (`provider`, `models`, `transforms`, `route`, native `reasoning`); `http_referer`/`x_title` become request headers |
+| `x-vllm` / `x-sglang` | object | Native passthrough | Server-specific body params for a self-hosted vLLM/SGLang server (`chat_template_kwargs`, `separate_reasoning`, `guided_json`, `top_k`, `min_p`, …) |
 
 There is no `x-xai` namespace. OpenAI additionally recognizes `store`,
 `prompt_cache_key`, `prompt_cache_retention`, `safety_identifier`, and `speed`.

{llmshim-0.2.3 → llmshim-0.3.1}/src/config.rs

@@ -25,6 +25,8 @@ pub struct Keys {
     pub anthropic: Option<String>,
     pub gemini: Option<String>,
     pub xai: Option<String>,
+    #[serde(default)]
+    pub openrouter: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -93,6 +95,7 @@ pub fn apply_to_env(config: &Config) {
         ("ANTHROPIC_API_KEY", &config.keys.anthropic),
         ("GEMINI_API_KEY", &config.keys.gemini),
         ("XAI_API_KEY", &config.keys.xai),
+        ("OPENROUTER_API_KEY", &config.keys.openrouter),
     ];
     for (env_key, value) in mappings {
         if std::env::var(env_key).is_err() {

{llmshim-0.2.3 → llmshim-0.3.1}/src/main.rs

@@ -504,6 +504,11 @@ fn cmd_configure() {
         cfg.keys.xai = Some(xai);
     }
 
+    let openrouter = config_prompt("OpenRouter API Key", cfg.keys.openrouter.as_deref());
+    if !openrouter.is_empty() {
+        cfg.keys.openrouter = Some(openrouter);
+    }
+
     let host = config_prompt_plain("Proxy host", &cfg.proxy.host);
     if !host.is_empty() {
         cfg.proxy.host = host;
@@ -535,6 +540,7 @@ fn cmd_set(key: &str, value: &str) {
         "anthropic" => cfg.keys.anthropic = Some(value.to_string()),
         "gemini" => cfg.keys.gemini = Some(value.to_string()),
         "xai" => cfg.keys.xai = Some(value.to_string()),
+        "openrouter" => cfg.keys.openrouter = Some(value.to_string()),
         "proxy.host" => cfg.proxy.host = value.to_string(),
         "proxy.port" => {
             cfg.proxy.port = value.parse().unwrap_or_else(|_| {
@@ -544,7 +550,7 @@ fn cmd_set(key: &str, value: &str) {
         }
         _ => {
             eprintln!(
-                "Unknown key: {}. Valid: openai, anthropic, gemini, xai, proxy.host, proxy.port",
+                "Unknown key: {}. Valid: openai, anthropic, gemini, xai, openrouter, proxy.host, proxy.port",
                 key
             );
             std::process::exit(1);
@@ -574,6 +580,7 @@ fn cmd_get(key: &str) {
         "anthropic" => cfg.keys.anthropic.as_deref().map(mask_key),
         "gemini" => cfg.keys.gemini.as_deref().map(mask_key),
         "xai" => cfg.keys.xai.as_deref().map(mask_key),
+        "openrouter" => cfg.keys.openrouter.as_deref().map(mask_key),
         "proxy.host" => Some(cfg.proxy.host.clone()),
         "proxy.port" => Some(cfg.proxy.port.to_string()),
         _ => {
@@ -593,6 +600,7 @@ fn cmd_list() {
         ("anthropic", &cfg.keys.anthropic),
         ("gemini", &cfg.keys.gemini),
         ("xai", &cfg.keys.xai),
+        ("openrouter", &cfg.keys.openrouter),
     ] {
         let display = match value {
             Some(v) if !v.is_empty() => mask_key(v),

{llmshim-0.2.3 → llmshim-0.3.1}/src/providers/mod.rs

@@ -1,4 +1,6 @@
 pub mod anthropic;
 pub mod gemini;
 pub mod openai;
+pub mod openai_compat;
+pub mod openrouter;
 pub mod xai;

llmshim-0.3.1/src/providers/openai_compat.rs

@@ -0,0 +1,196 @@
+use crate::error::{Result, ShimError};
+use crate::provider::{Provider, ProviderRequest};
+use crate::vision;
+use serde_json::{json, Value};
+
+/// A generic OpenAI Chat Completions-compatible provider for **self-hosted**
+/// inference servers — vLLM and SGLang. Like OpenRouter it's a passthrough
+/// (messages, tools, `image_url` vision, and `response_format` are already in
+/// the target shape), but two things differ from a hosted aggregator:
+///
+/// - **The base URL is configuration**, not a constant — that's what "local vs
+///   remote" means (`http://localhost:8000/v1` vs `https://host/v1`).
+/// - **Auth is optional** — these servers accept unauthenticated requests unless
+///   launched with `--api-key`, so the `Authorization` header is sent only when
+///   a key is configured.
+///
+/// `name` (e.g. `"vllm"` / `"sglang"`) is both the provider key and the
+/// extension namespace: server-specific params (`chat_template_kwargs`,
+/// `separate_reasoning`, `guided_json`, `top_k`, …) go under `x-<name>`.
+pub struct OpenAiCompatible {
+    pub name: String,
+    pub base_url: String,
+    pub api_key: Option<String>,
+}
+
+impl OpenAiCompatible {
+    pub fn new(
+        name: impl Into<String>,
+        base_url: impl Into<String>,
+        api_key: Option<String>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            base_url: base_url.into(),
+            api_key,
+        }
+    }
+}
+
+/// Strip llmshim-normalized / foreign-provider fields and normalize content
+/// blocks to Chat Completions form. Messages, `tool_calls`, and `role: "tool"`
+/// stay in Chat Completions shape (the target format).
+fn sanitize_messages(messages: &[Value]) -> Vec<Value> {
+    messages
+        .iter()
+        .map(|msg| {
+            let mut out = msg.clone();
+            if let Some(obj) = out.as_object_mut() {
+                obj.remove("reasoning_content"); // regenerated server-side; don't echo back
+                obj.remove("reasoning_signature"); // opaque Anthropic token — never forward
+                obj.remove("redacted_reasoning_content"); // opaque Anthropic token — never forward
+                obj.remove("annotations");
+                obj.remove("refusal");
+            }
+            if let Some(content) = out.get("content").cloned() {
+                if content.is_array() {
+                    let translated =
+                        vision::translate_content_blocks(&content, vision::to_openai_chat);
+                    out["content"] = vision::text_blocks_to_chat(&translated);
+                }
+            }
+            out
+        })
+        .collect()
+}
+
+/// Copy OpenRouter/vLLM/SGLang's `reasoning` field into llmshim's
+/// `reasoning_content` convention if the latter isn't already present. (vLLM is
+/// migrating `reasoning_content` → `reasoning`; SGLang uses `reasoning_content`.)
+fn normalize_reasoning(obj: &mut serde_json::Map<String, Value>) {
+    if obj.contains_key("reasoning_content") {
+        return;
+    }
+    if let Some(r) = obj
+        .get("reasoning")
+        .and_then(|r| r.as_str())
+        .filter(|s| !s.is_empty())
+        .map(str::to_string)
+    {
+        obj.insert("reasoning_content".to_string(), json!(r));
+    }
+}
+
+impl Provider for OpenAiCompatible {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn transform_request(&self, model: &str, request: &Value) -> Result<ProviderRequest> {
+        let obj = request.as_object().ok_or(ShimError::MissingModel)?;
+        let messages = obj
+            .get("messages")
+            .and_then(|m| m.as_array())
+            .ok_or(ShimError::MissingModel)?;
+
+        let mut body = json!({
+            "model": model,
+            "messages": sanitize_messages(messages),
+        });
+        let body_obj = body.as_object_mut().unwrap();
+
+        // Standard Chat Completions params (plus reasoning_effort, which vLLM and
+        // some SGLang models honor natively) — forwarded unchanged.
+        for key in [
+            "max_tokens",
+            "max_completion_tokens",
+            "temperature",
+            "top_p",
+            "frequency_penalty",
+            "presence_penalty",
+            "stop",
+            "seed",
+            "stream",
+            "stream_options",
+            "tools",
+            "tool_choice",
+            "parallel_tool_calls",
+            "response_format",
+            "logprobs",
+            "top_logprobs",
+            "n",
+            "reasoning_effort",
+        ] {
+            if let Some(v) = obj.get(key) {
+                body_obj.insert(key.to_string(), v.clone());
+            }
+        }
+
+        // x-<name> namespace: server-specific params (sampling knobs like top_k /
+        // min_p, guided_json / regex / ebnf, chat_template_kwargs,
+        // separate_reasoning, …) are copied straight into the body.
+        let ns = format!("x-{}", self.name);
+        if let Some(ext) = obj.get(&ns).and_then(|e| e.as_object()) {
+            for (k, v) in ext {
+                body_obj.insert(k.clone(), v.clone());
+            }
+        }
+
+        let mut headers = vec![("Content-Type".to_string(), "application/json".to_string())];
+        // Auth is optional — self-hosted servers are unauthenticated unless
+        // launched with --api-key.
+        if let Some(key) = &self.api_key {
+            if !key.is_empty() {
+                headers.push(("Authorization".to_string(), format!("Bearer {key}")));
+            }
+        }
+
+        let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
+        Ok(ProviderRequest { url, headers, body })
+    }
+
+    fn transform_response(&self, _model: &str, mut response: Value) -> Result<Value> {
+        if let Some(err) = response.get("error") {
+            if !err.is_null() {
+                let message = err
+                    .get("message")
+                    .and_then(|m| m.as_str())
+                    .unwrap_or("unknown error")
+                    .to_string();
+                let status = err.get("code").and_then(|c| c.as_u64()).unwrap_or(400) as u16;
+                return Err(ShimError::ProviderError {
+                    status,
+                    body: message,
+                });
+            }
+        }
+
+        // Already Chat Completions-shaped. Normalize the reasoning field name.
+        if let Some(choices) = response.get_mut("choices").and_then(|c| c.as_array_mut()) {
+            for choice in choices {
+                if let Some(msg) = choice.get_mut("message").and_then(|m| m.as_object_mut()) {
+                    normalize_reasoning(msg);
+                }
+            }
+        }
+
+        Ok(response)
+    }
+
+    fn transform_stream_chunk(&self, _model: &str, chunk: &str) -> Result<Option<String>> {
+        let mut parsed: Value = match serde_json::from_str(chunk) {
+            Ok(v) => v,
+            Err(_) => return Ok(None),
+        };
+
+        if let Some(choices) = parsed.get_mut("choices").and_then(|c| c.as_array_mut()) {
+            for choice in choices {
+                if let Some(delta) = choice.get_mut("delta").and_then(|d| d.as_object_mut()) {
+                    normalize_reasoning(delta);
+                }
+            }
+        }
+
+        Ok(Some(serde_json::to_string(&parsed)?))
+    }
+}