llmshim 0.2.3__tar.gz → 0.3.0__tar.gz

{llmshim-0.2.3 → llmshim-0.3.0}/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, and OpenRouter (an OpenAI Chat Completions-compatible aggregator). 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,7 @@ 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`.
 
 ## Build & Test
 
@@ -30,13 +31,15 @@ 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.
 
 ## 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` namespaces.
+
+**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 +57,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 has no prefix inference** — its slugs collide with everyone's, so it must be addressed explicitly as `openrouter/…`. Supports aliases. `Router::from_env()` reads API key env vars.
 
 ### HTTP Client (`src/client.rs`)
 
@@ -90,6 +93,7 @@ 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.
 - **Gemini:** Tools wrapped in `functionDeclarations`. Tool results translated to `functionResponse` format.
 
 ### CLI (`src/main.rs`)

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim"
-version = "0.2.3"
+version = "0.3.0"
 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.0}/PKG-INFO

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

{llmshim-0.2.3 → llmshim-0.3.0}/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, and OpenRouter.
 
 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,15 @@ 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.
+
 Or persist them to the config file (used by all three surfaces):
 
 ```bash

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

@@ -12,6 +12,7 @@ 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` |
 
 The config file shape is:
 

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

@@ -119,6 +119,13 @@ 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/…`.
+
 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.0}/docs/src/reference/providers.md

@@ -9,6 +9,7 @@ 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` |
 
 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 +23,7 @@ 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) |
 
 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.0}/docs/src/reference/request-fields.md

@@ -29,6 +29,7 @@ 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 |
 
 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.0}/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.0}/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.0}/src/providers/mod.rs

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

llmshim-0.3.0/src/providers/openrouter.rs

@@ -0,0 +1,283 @@
+use crate::error::{Result, ShimError};
+use crate::provider::{Provider, ProviderRequest};
+use crate::vision;
+use serde_json::{json, Value};
+
+/// OpenRouter (https://openrouter.ai) — an OpenAI Chat Completions-compatible
+/// aggregator. Unlike the other providers, which translate *away* from Chat
+/// Completions to a native dialect, OpenRouter *is* Chat Completions, so this is
+/// a near-passthrough: messages, tools, vision, and `response_format` are
+/// already in the target shape and are forwarded unchanged. Model slugs
+/// (`vendor/model`, e.g. `anthropic/claude-sonnet-4.5`) contain a slash and
+/// arrive here intact because the router splits only on the first `/`.
+pub struct OpenRouter {
+    pub api_key: String,
+    pub base_url: String,
+}
+
+impl OpenRouter {
+    pub fn new(api_key: String) -> Self {
+        Self {
+            api_key,
+            base_url: "https://openrouter.ai/api/v1".to_string(),
+        }
+    }
+
+    pub fn with_base_url(mut self, url: String) -> Self {
+        self.base_url = url;
+        self
+    }
+}
+
+/// OpenRouter's reasoning-effort vocabulary is a superset of the unified one, so
+/// the mapping is 1:1 (no per-model clamp — OpenRouter enforces the underlying
+/// model's limits itself). `reasoning_mode: "pro"` bumps one tier, mirroring the
+/// other providers; explicit `none` always wins.
+fn normalize_openrouter_effort(effort: &str, pro: bool) -> &'static str {
+    let base = match effort {
+        "none" => "none",
+        "minimal" => "minimal",
+        "low" => "low",
+        "medium" => "medium",
+        "high" => "high",
+        "xhigh" => "xhigh",
+        "max" => "max",
+        _ => "medium",
+    };
+    if !pro {
+        return base;
+    }
+    match base {
+        "none" => "none",
+        "minimal" => "low",
+        "low" => "medium",
+        "medium" => "high",
+        "high" => "xhigh",
+        _ => "max", // xhigh, max
+    }
+}
+
+/// Sanitize messages for OpenRouter (OpenAI Chat Completions native). Strip
+/// llmshim-normalized / foreign-provider fields so multi-model conversations
+/// don't leak them, and normalize vision blocks to OpenAI form. Messages,
+/// `tool_calls`, and `role: "tool"` all stay in Chat Completions shape.
+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"); // llmshim-normalized; OpenRouter uses reasoning_details
+                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() {
+                    // Normalize any image format to Chat Completions `image_url`,
+                    // and any Responses-style `input_text` back to `text`.
+                    let translated =
+                        vision::translate_content_blocks(&content, vision::to_openai_chat);
+                    out["content"] = normalize_text_blocks_to_chat(&translated);
+                }
+            }
+            out
+        })
+        .collect()
+}
+
+/// Convert Responses-style `input_text` blocks back to Chat Completions `text`.
+/// (llmshim's canonical input already uses `text`; this only matters when a
+/// caller mixes in Responses-format blocks.)
+fn normalize_text_blocks_to_chat(content: &Value) -> Value {
+    match content {
+        Value::Array(blocks) => Value::Array(
+            blocks
+                .iter()
+                .map(|b| {
+                    if b.get("type").and_then(|t| t.as_str()) == Some("input_text") {
+                        let mut out = b.clone();
+                        out["type"] = json!("text");
+                        out
+                    } else {
+                        b.clone()
+                    }
+                })
+                .collect(),
+        ),
+        _ => content.clone(),
+    }
+}
+
+impl Provider for OpenRouter {
+    fn name(&self) -> &str {
+        "openrouter"
+    }
+
+    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 — forwarded unchanged (OpenRouter is
+        // the target format, so tools/response_format need no translation).
+        for key in [
+            "max_tokens",
+            "max_completion_tokens",
+            "temperature",
+            "top_p",
+            "top_k",
+            "frequency_penalty",
+            "presence_penalty",
+            "stop",
+            "seed",
+            "stream",
+            "stream_options",
+            "tools",
+            "tool_choice",
+            "parallel_tool_calls",
+            "response_format",
+            "logprobs",
+            "top_logprobs",
+            "n",
+        ] {
+            if let Some(v) = obj.get(key) {
+                body_obj.insert(key.to_string(), v.clone());
+            }
+        }
+
+        // Unified reasoning -> OpenRouter `reasoning: {effort}`. A native
+        // `x-openrouter.reasoning` object takes precedence and is copied below.
+        let has_native_reasoning = obj
+            .get("x-openrouter")
+            .and_then(|x| x.get("reasoning"))
+            .is_some();
+        if !has_native_reasoning {
+            if let Some(effort) = obj.get("reasoning_effort").and_then(|e| e.as_str()) {
+                let pro = obj.get("reasoning_mode").and_then(|m| m.as_str()) == Some("pro");
+                let effort = normalize_openrouter_effort(effort, pro);
+                body_obj.insert("reasoning".to_string(), json!({ "effort": effort }));
+            }
+        }
+
+        let mut headers = vec![
+            (
+                "Authorization".to_string(),
+                format!("Bearer {}", self.api_key),
+            ),
+            ("Content-Type".to_string(), "application/json".to_string()),
+        ];
+
+        // x-openrouter namespace: OpenRouter-only controls. Body params
+        // (provider, models, transforms, route, reasoning) are copied into the
+        // body; the two attribution headers are copied to headers, not the body.
+        if let Some(ext) = obj.get("x-openrouter").and_then(|e| e.as_object()) {
+            for (k, v) in ext {
+                match k.as_str() {
+                    "http_referer" | "HTTP-Referer" => {
+                        if let Some(s) = v.as_str() {
+                            headers.push(("HTTP-Referer".to_string(), s.to_string()));
+                        }
+                    }
+                    "x_title" | "X-Title" => {
+                        if let Some(s) = v.as_str() {
+                            headers.push(("X-Title".to_string(), s.to_string()));
+                        }
+                    }
+                    _ => {
+                        body_obj.insert(k.clone(), v.clone());
+                    }
+                }
+            }
+        }
+
+        // OpenRouter enables the `middle-out` transform by default, which
+        // silently drops middle messages to fit the context window. For a
+        // faithful passthrough we disable it; callers opt back in via
+        // `x-openrouter.transforms`.
+        if !body_obj.contains_key("transforms") {
+            body_obj.insert("transforms".to_string(), json!([]));
+        }
+
+        let url = format!("{}/chat/completions", self.base_url);
+        Ok(ProviderRequest { url, headers, body })
+    }
+
+    fn transform_response(&self, _model: &str, mut response: Value) -> Result<Value> {
+        // Non-stream errors usually surface via HTTP status, but a body-level
+        // `error` object can also appear — turn it into a ProviderError.
+        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,
+                });
+            }
+        }
+
+        // The response is already Chat Completions-shaped. Normalize OpenRouter's
+        // `message.reasoning` into llmshim's `reasoning_content` convention.
+        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()) {
+                    if !msg.contains_key("reasoning_content") {
+                        if let Some(r) = msg
+                            .get("reasoning")
+                            .and_then(|r| r.as_str())
+                            .filter(|s| !s.is_empty())
+                            .map(str::to_string)
+                        {
+                            msg.insert("reasoning_content".to_string(), json!(r));
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(response)
+    }
+
+    fn transform_stream_chunk(&self, _model: &str, chunk: &str) -> Result<Option<String>> {
+        // OpenRouter's SSE chunks are OpenAI-delta shaped. Parse, normalize the
+        // reasoning delta, and forward. Unparseable payloads (e.g. stray
+        // keepalive text) are skipped. `data: [DONE]` and `:`-comment keepalives
+        // are already handled by the client's SSE reader.
+        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()) {
+                    if !delta.contains_key("reasoning_content") {
+                        if let Some(r) = delta
+                            .get("reasoning")
+                            .and_then(|r| r.as_str())
+                            .map(str::to_string)
+                        {
+                            delta.insert("reasoning_content".to_string(), json!(r));
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(Some(serde_json::to_string(&parsed)?))
+    }
+}

{llmshim-0.2.3 → llmshim-0.3.0}/src/router.rs

@@ -3,6 +3,7 @@ use crate::provider::Provider;
 use crate::providers::anthropic::Anthropic;
 use crate::providers::gemini::Gemini;
 use crate::providers::openai::OpenAi;
+use crate::providers::openrouter::OpenRouter;
 use crate::providers::xai::Xai;
 use std::collections::HashMap;
 
@@ -93,6 +94,9 @@ impl Router {
         if let Ok(key) = std::env::var("XAI_API_KEY") {
             router = router.register("xai", Box::new(Xai::new(key)));
         }
+        if let Ok(key) = std::env::var("OPENROUTER_API_KEY") {
+            router = router.register("openrouter", Box::new(OpenRouter::new(key)));
+        }
 
         router
     }

{llmshim-0.2.3 → llmshim-0.3.0}/src/vision.rs

@@ -167,6 +167,50 @@ pub fn to_openai(block: &Value) -> Option<Value> {
     }
 }
 
+/// Translate an image block to OpenAI **Chat Completions** format
+/// (`{"type":"image_url","image_url":{"url":...}}`) — the shape OpenAI-compatible
+/// aggregators like OpenRouter expect. (`to_openai` targets the Responses API's
+/// `input_image` string form instead.)
+pub fn to_openai_chat(block: &Value) -> Option<Value> {
+    let block_type = block.get("type").and_then(|t| t.as_str())?;
+
+    match block_type {
+        // Already Chat Completions format.
+        "image_url" => Some(block.clone()),
+
+        // OpenAI Responses API `input_image` (image_url is a bare string).
+        "input_image" => {
+            let url = block.get("image_url").and_then(|u| u.as_str())?;
+            Some(json!({ "type": "image_url", "image_url": { "url": url } }))
+        }
+
+        // Anthropic format → Chat Completions.
+        "image" => {
+            let source = block.get("source")?;
+            match source.get("type").and_then(|t| t.as_str())? {
+                "base64" => {
+                    let media_type = source
+                        .get("media_type")
+                        .and_then(|m| m.as_str())
+                        .unwrap_or("image/jpeg");
+                    let data = source.get("data").and_then(|d| d.as_str()).unwrap_or("");
+                    Some(json!({
+                        "type": "image_url",
+                        "image_url": { "url": format!("data:{};base64,{}", media_type, data) }
+                    }))
+                }
+                "url" => {
+                    let url = source.get("url").and_then(|u| u.as_str())?;
+                    Some(json!({ "type": "image_url", "image_url": { "url": url } }))
+                }
+                _ => None,
+            }
+        }
+
+        _ => None,
+    }
+}
+
 /// Translate all content blocks in a message's content array.
 /// If content is a string, returns it unchanged.
 /// If content is an array, translates image blocks using the given translator.