llmshim 0.7.2__tar.gz → 0.8.1__tar.gz

{llmshim-0.7.2 → llmshim-0.8.1}/.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
       - name: Check formatting
         run: cargo fmt --all --check
       - name: Clippy
-        run: cargo clippy --workspace --features proxy -- -D warnings
+        run: cargo clippy --workspace --all-targets --features proxy -- -D warnings
       - name: Unit tests
         env:
           LLMSHIM_CATALOG_OFFLINE: '1'

{llmshim-0.7.2 → llmshim-0.8.1}/CLAUDE.md

@@ -16,7 +16,7 @@ This is a public crate on crates.io. Do NOT make breaking changes to `pub` items
 - **ChatGPT subscription (OAuth):** only `chatgpt/gpt-6-astra`, `chatgpt/gpt-5.6-sol`, `chatgpt/gpt-5.6-terra`, and `chatgpt/gpt-5.6-luna`. `CHATGPT_MODELS` in `src/models.rs` is shared by discovery, CLI selection, and validation; older/unlisted models fail before authentication or network calls.
 - **Anthropic:** `claude-fable-5-1`, `claude-opus-5`, `claude-sonnet-5`, `claude-haiku-4-5-20251001`
 - **Gemini:** `gemini-3.8-flash`, `gemini-3.5-flash-lite`
-- **xAI:** `grok-4.6`
+- **xAI:** `grok-4.7`
 - **OpenRouter:** not enumerated (huge/dynamic catalog) — any `openrouter/<vendor>/<model>` slug routes through, e.g. `openrouter/anthropic/claude-sonnet-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`.
 
@@ -73,6 +73,17 @@ for whichever stream chunk carries usage; `log.rs`, `proxy::types::Usage`, both
 native facades and the four bundled clients carry it through as a nullable
 field. `null` means unknown, not free.
 
+`ModelInfo.context_cost_tiers` adds context-dependent standard rates without
+changing the public `Cost` struct. `cost_for_input_tokens` includes cached input
+in tier selection; `src/cost.rs` applies the resulting rates to the whole
+response. Local per-field prices outrank lower-source tier rates. Builtin
+launch metadata lives in `crates/llmshim-catalog/data/verified.json`, separate
+from the unmodified models.dev snapshot. Grok 4.7 live regression tests are in
+`tests/integration_grok_4_7.rs`; they use an ephemeral proxy port, configured
+keys, and billed API calls. `none` clamps to `low`; named tool choice must be
+flat on the Responses wire. Preserve encrypted reasoning on both normal and
+streaming tool round trips.
+
 `src/gateway/quota.rs` adds a per-identity dollar cap beside the RPM/TPM
 buckets: `budget_usd` + `budget_window_secs` on an `Identity`, checked before
 dispatch and charged after (cost is only knowable once a response exists, so
@@ -321,15 +332,15 @@ accounts exercise enforcement too. The provider handles incompatible
 thinking on a switch to older models; do not infer signatures from text.
 
 `tests/unit_fable.rs` pins these rules. Live checks for Fable 5, Fable 5.1,
-Opus 5, Gemini 3.8 Flash, and Grok 4.6:
+Opus 5, Gemini 3.8 Flash, and Grok 4.7:
 
 ```bash
 cargo test --features proxy --test integration_current_models -- --ignored --nocapture
 ```
 
 The live tests consume API usage and are ignored during offline preflight.
-Gemini 3.8 Flash and Opus 5 already had catalog/adapter support; Grok 4.6 is
-the verified xAI model ID. Keep the ChatGPT four-model allowlist independent.
+Gemini 3.8 Flash and Opus 5 already had catalog/adapter support; Grok 4.7 is
+the current xAI model ID (verified live 2026-09-21); retain Grok 4.6 for explicit routing. Keep the ChatGPT four-model allowlist independent.
 
 Two knobs work across every provider: `reasoning_effort` (`none|low|medium|high|xhigh|max`) and `reasoning_mode` (`standard|pro`). A third, `reasoning_summary` (`auto|none`), controls reasoning-text visibility → Anthropic `thinking.display` (`auto`→`summarized`, the default when `reasoning_effort` is present so newer models like Sonnet 5 / Opus 4.7-4.8 return reasoning text instead of the API-default `omitted`; `none`→`omitted` for lower latency). Applies to both the adaptive and pre-4.6 enabled thinking builders; a caller-supplied `thinking` block bypasses it. Each provider transform maps them to its native dialect, **clamping to the nearest tier the target model accepts** (all boundaries verified live — e.g. `max` is native on OpenAI gpt-5.6 and GPT-6 Astra; Anthropic 4.6 rejects `xhigh` but has `max`; Gemini's enum tops out at `high`; xAI grok-4.20 models reject any reasoning param). `mode: "pro"` is native on OpenAI gpt-5.6/-pro models (`reasoning.mode`), emulated as a one-tier effort bump elsewhere; explicit `none` always wins. Native passthrough (`x-openai.reasoning`, `x-anthropic.thinking`, `x-gemini.thinkingConfig`) bypasses the mapping entirely and always takes precedence. **Full per-provider mapping tables: `docs/src/guides/reasoning.md`** — update it and the pinning tests in `tests/unit_*.rs` together whenever a mapping changes.
 

{llmshim-0.7.2 → llmshim-0.8.1}/Cargo.lock

@@ -1180,7 +1180,7 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "llmshim"
-version = "0.7.2"
+version = "0.8.1"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -1215,7 +1215,7 @@ dependencies = [
 
 [[package]]
 name = "llmshim-catalog"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "chrono",
  "dirs",

{llmshim-0.7.2 → llmshim-0.8.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim"
-version = "0.7.2"
+version = "0.8.1"
 edition = "2021"
 description = "Blazing fast LLM API translation layer in pure Rust"
 license = "MIT OR Apache-2.0"
@@ -24,7 +24,7 @@ gateway-redis = ["gateway", "redis-coordination"]
 redis-coordination = ["proxy", "dep:redis"]
 
 [dependencies]
-llmshim-catalog = { version = "0.1.0", path = "crates/llmshim-catalog" }
+llmshim-catalog = { version = "0.1.1", path = "crates/llmshim-catalog" }
 tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "http2", "gzip", "brotli", "zstd", "deflate"] }
 serde = { version = "1", features = ["derive"] }

{llmshim-0.7.2 → llmshim-0.8.1}/PKG-INFO

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

{llmshim-0.7.2 → llmshim-0.8.1}/README.md

@@ -100,6 +100,18 @@ 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`.
 
+A server that also serves `/v1/responses` (SGLang does) can be spoken to on
+that wire with `SGLANG_WIRE=responses` (or `VLLM_WIRE=responses`). Reasoning
+then comes back as an item with its own id rather than bare `reasoning_content`,
+and is replayed as that item. Replay is gated on a known model family on every
+wire, and the public catalog does not know a served model: declare it once in
+`.llmshim/models.toml` —
+
+```toml
+[models."sglang/<served-model>"]
+family = "qwen"
+```
+
 Or persist them to the config file (used by all three surfaces):
 
 ```bash
@@ -461,7 +473,7 @@ Standard library only. Full docs: [`clients/ruby/README.md`](clients/ruby/README
 | **OpenAI** | `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna` | Yes (summaries) |
 | **Anthropic** | `claude-fable-5-1`, `claude-opus-5`, `claude-sonnet-5`, `claude-haiku-4-5-20251001` | Yes (thinking summaries) |
 | **Google Gemini** | `gemini-3.8-flash`, `gemini-3.5-flash-lite` | Yes (thought summaries) |
-| **xAI** | `grok-4.6` | No (hidden) |
+| **xAI** | `grok-4.7` | No (hidden) |
 
 The CLI and server advertise these current tiers. ChatGPT subscription access
 uses the same four OpenAI models under `chatgpt/`. OpenRouter and self-hosted

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim-catalog"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Offline-first model metadata with verified defaults, models.dev, and local overrides"
 license = "MIT OR Apache-2.0"

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/README.md

@@ -18,9 +18,31 @@ input/output modalities, knowledge/release dates, and field-level sources.
 Missing data remains unknown. A date given only as a month is not turned into
 an invented day. Unknown family keys remain absent and must not authorize replay.
 
+`ModelInfo::cost_for_input_tokens(total)` selects context-dependent rates from
+`context_cost_tiers`; `cost` remains the base rates. The total includes cached
+input. A tier applies to the entire request strictly above its threshold, with
+missing rates inherited from the preceding tier. Models.dev `cost.tiers` entries
+whose type is `context` are imported. Local policy can set
+`context_cost_tiers = []` to disable inherited tiers, or use:
+
+```toml
+[[models."xai/grok-4.7".context_cost_tiers]]
+above_input_tokens = 200000
+[models."xai/grok-4.7".context_cost_tiers.cost]
+input = 4.0
+cache_read = 1.0
+output = 12.0
+```
+
+The strongest source replaces the tier list as a whole. Higher-priority base
+price overrides still win per field over lower-priority tier rates. Provider
+discovery cannot supply either base prices or tiers.
+
 The compiled `builtin` module retains the small verified discovery table,
 historical metadata, and the separate ChatGPT subscription allowlist. Catalog
 coverage does not authorize or configure an API route or a subscription model.
+`data/verified.json` supplies sourced launch metadata independently of the
+models.dev snapshot. It does not add models to the curated discovery list.
 
 ## Layers and policy
 

llmshim-0.8.1/crates/llmshim-catalog/data/README.md

@@ -0,0 +1,26 @@
+`models.dev.json` is the unmodified response downloaded from
+https://models.dev/api.json on 2026-09-16. It is third-party data under the MIT
+license in `LICENSE.models.dev`. No credentials, local overrides, provider
+account discovery, or private fixtures belong in this directory.
+
+The refresh workflow replaces only this public snapshot. Tests validate its
+structure and minimum coverage before proposing an update. The builtin table
+continues to win conflicts for the fields it asserts.
+
+`verified.json` contains separate verified builtin assertions, checked on
+2026-09-21. It is maintained here, not copied into the models.dev artifact:
+
+- Native Grok 4.7 capabilities, reasoning efforts, dates, and standard token
+  prices: https://docs.x.ai/developers/grok-4-7 and
+  https://docs.x.ai/developers/release-notes (including Grok 4.6 context pricing).
+- Grok 4.7 streaming, image input, structured output, named tool selection,
+  and encrypted-reasoning round trips: `tests/integration_grok_4_7.rs` in the
+  parent repository, verified against the live xAI Responses API.
+- OpenRouter's Grok 4.7 identity, capabilities, limits and standard endpoint
+  prices: https://openrouter.ai/api/v1/models/x-ai/grok-4.7/endpoints . Priority
+  endpoint rates are different; the catalog entries describe standard rates.
+  The `:nitro` entry supplies replay metadata without a fixed price because
+  standard and priority endpoints can compete for that route.
+
+No public `grok-4.7-fast` API route is asserted. Its launch availability is
+limited to Cursor and Grok Build.

llmshim-0.8.1/crates/llmshim-catalog/data/verified.json

@@ -0,0 +1,43 @@
+{
+  "xai/grok-4.7": {
+    "name": "Grok 4.7",
+    "family": "grok",
+    "limit": {"context": 500000},
+    "release_date": "2026-09-21",
+    "modalities": {"input": ["text", "image"], "output": ["text"]},
+    "reasoning_options": [{"type": "effort", "values": ["low", "medium", "high", "xhigh"]}],
+    "streaming": true,
+    "forced_tool_choice": true,
+    "cost": {"input": 2, "cache_read": 0.5, "output": 6},
+    "context_cost_tiers": [{"above_input_tokens": 200000, "cost": {"input": 4, "cache_read": 1, "output": 12}}]
+  },
+  "xai/grok-4.6": {
+    "cost": {"input": 2, "cache_read": 0.5, "output": 6},
+    "context_cost_tiers": [{"above_input_tokens": 200000, "cost": {"input": 4, "cache_read": 1, "output": 12}}]
+  },
+  "openrouter/x-ai/grok-4.7:nitro": {
+    "name": "Grok 4.7 (Nitro)",
+    "family": "grok",
+    "limit": {"context": 500000, "output": 450000},
+    "modalities": {"input": ["text", "image", "file"], "output": ["text"]},
+    "reasoning_options": [{"type": "effort", "values": ["low", "medium", "high", "xhigh"]}],
+    "reasoning": true,
+    "tool_call": true,
+    "structured_output": true,
+    "forced_tool_choice": true
+  },
+  "openrouter/x-ai/grok-4.7": {
+    "name": "Grok 4.7",
+    "family": "grok",
+    "limit": {"context": 500000, "output": 450000},
+    "release_date": "2026-09-21",
+    "modalities": {"input": ["text", "image", "file"], "output": ["text"]},
+    "reasoning_options": [{"type": "effort", "values": ["low", "medium", "high", "xhigh"]}],
+    "reasoning": true,
+    "tool_call": true,
+    "structured_output": true,
+    "forced_tool_choice": true,
+    "cost": {"input": 1.6, "cache_read": 0.4, "output": 4.8},
+    "context_cost_tiers": [{"above_input_tokens": 200000, "cost": {"input": 3.2, "cache_read": 0.8, "output": 9.6}}]
+  }
+}

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/src/builtin.rs

@@ -261,11 +261,11 @@ pub const MODELS: &[BuiltinModelInfo] = &[
         capabilities: CAPS_STD,
     },
     BuiltinModelInfo {
-        id: "xai/grok-4.6",
+        id: "xai/grok-4.7",
         provider: "xai",
         family: Some(ModelFamily::Grok),
-        name: "grok-4.6",
-        label: "Grok 4.6",
+        name: "grok-4.7",
+        label: "Grok 4.7",
         context_window_tokens: Some(500_000),
         max_output_tokens: None,
         capabilities: CAPS_XAI,
@@ -279,6 +279,16 @@ pub const MODELS: &[BuiltinModelInfo] = &[
 /// Historical metadata remains available to explicit `spec()` lookups without
 /// appearing in discovery or model pickers. Routing is provider-owned.
 const LEGACY_MODELS: &[BuiltinModelInfo] = &[
+    BuiltinModelInfo {
+        id: "xai/grok-4.6",
+        provider: "xai",
+        family: Some(ModelFamily::Grok),
+        name: "grok-4.6",
+        label: "Grok 4.6",
+        context_window_tokens: Some(500_000),
+        max_output_tokens: None,
+        capabilities: CAPS_XAI,
+    },
     BuiltinModelInfo {
         id: "openai/gpt-5.5",
         provider: "openai",

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/src/lib.rs

@@ -165,6 +165,20 @@ impl Catalog {
             model.source = CatalogSource::Builtin;
             self.merge_model(model);
         }
+        // Verified launch-day metadata is separate from the unmodified
+        // models.dev snapshot and does not expand curated discovery.
+        let entries: Value = serde_json::from_str(include_str!("../data/verified.json"))
+            .expect("validated builtin metadata");
+        for (id, value) in entries.as_object().expect("builtin metadata object") {
+            let (provider, name) = id.split_once('/').expect("qualified builtin id");
+            self.merge_model(parse::model_from_value(
+                provider,
+                name,
+                value,
+                CatalogSource::Builtin,
+                None,
+            ));
+        }
     }
 
     pub fn merge_models_dev(
@@ -235,6 +249,9 @@ impl Catalog {
                     ))?;
                 let mut model =
                     parse::model_from_value(provider, name, v, CatalogSource::Local, None);
+                if v.get("context_cost_tiers").is_some() && model.context_cost_tiers.is_none() {
+                    return Err(CatalogError::Invalid("invalid context_cost_tiers"));
+                }
                 if let Some(label) = v["label"].as_str() {
                     model.label = label.into();
                 }

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/src/merge.rs

@@ -1,6 +1,6 @@
 use crate::{CatalogSource, Cost, ModelInfo, Support};
 
-fn rank(source: CatalogSource) -> u8 {
+pub(crate) fn rank(source: CatalogSource) -> u8 {
     match source {
         CatalogSource::ModelsDev => 1,
         CatalogSource::Builtin => 2,
@@ -76,6 +76,7 @@ pub(crate) fn merge(target: &mut ModelInfo, incoming: &ModelInfo) {
         }
     }
     if source != CatalogSource::ProviderApi {
+        field!(context_cost_tiers, incoming.context_cost_tiers.is_some());
         if let Some(cost) = incoming.cost {
             let mut merged = target.cost.unwrap_or_default();
             for (key, value, slot) in [

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/src/parse.rs

@@ -1,5 +1,6 @@
 use crate::{
-    CatalogError, CatalogSource, Cost, ModelCapabilities, ModelFamily, ModelInfo, Support,
+    CatalogError, CatalogSource, ContextCostTier, Cost, ModelCapabilities, ModelFamily, ModelInfo,
+    Support,
 };
 use chrono::{DateTime, NaiveDate, Utc};
 use serde_json::Value;
@@ -77,6 +78,24 @@ pub(crate) fn model_from_value(
         };
     }
     m.cost = cost(&v["cost"]);
+    m.context_cost_tiers = if let Some(tiers) = v.get("context_cost_tiers") {
+        serde_json::from_value(tiers.clone()).ok()
+    } else {
+        v["cost"]["tiers"].as_array().map(|tiers| {
+            tiers
+                .iter()
+                .filter_map(|tier| {
+                    if tier["tier"]["type"] != "context" {
+                        return None;
+                    }
+                    Some(ContextCostTier {
+                        above_input_tokens: tier["tier"]["size"].as_u64()?,
+                        cost: cost(tier)?,
+                    })
+                })
+                .collect()
+        })
+    };
     m.reasoning_options = v["reasoning_options"]
         .as_array()
         .into_iter()

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/src/types.rs

@@ -81,6 +81,14 @@ pub struct Cost {
     pub cache_write: Option<f64>,
 }
 
+/// Rates for the entire request when total input (including cached input)
+/// exceeds `above_input_tokens`. Missing rates inherit the previous tier.
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct ContextCostTier {
+    pub above_input_tokens: u64,
+    pub cost: Cost,
+}
+
 /// Media types are strings so new catalog modalities survive without a release.
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
 #[serde(default)]
@@ -123,6 +131,9 @@ pub struct ModelInfo {
     pub capabilities: crate::ModelCapabilities,
     pub family: Option<ModelFamily>,
     pub cost: Option<Cost>,
+    /// None means unspecified; an explicit empty list disables inherited tiers.
+    #[serde(default)]
+    pub context_cost_tiers: Option<Vec<ContextCostTier>>,
     pub reasoning_options: Vec<ReasoningOption>,
     pub modalities: Modalities,
     pub knowledge_cutoff: Option<NaiveDate>,
@@ -148,6 +159,7 @@ impl ModelInfo {
             capabilities: crate::ModelCapabilities::unknown(),
             family: None,
             cost: None,
+            context_cost_tiers: None,
             reasoning_options: Vec::new(),
             modalities: Modalities::default(),
             knowledge_cutoff: None,
@@ -158,4 +170,48 @@ impl ModelInfo {
             field_sources: BTreeMap::new(),
         }
     }
+
+    /// Resolve context-dependent rates without changing the base `Cost` API.
+    /// Higher-priority per-field base overrides also override lower-priority
+    /// tier rates. Tier lists are replaced atomically by a stronger source.
+    pub fn cost_for_input_tokens(&self, input_tokens: u64) -> Option<Cost> {
+        let mut cost = self.cost?;
+        let mut tiers: Vec<_> = self
+            .context_cost_tiers
+            .as_deref()
+            .unwrap_or_default()
+            .iter()
+            .filter(|t| input_tokens > t.above_input_tokens)
+            .collect();
+        tiers.sort_by_key(|t| t.above_input_tokens);
+        let tier_source = self
+            .field_sources
+            .get("context_cost_tiers")
+            .copied()
+            .unwrap_or(self.source);
+        for tier in tiers {
+            for (key, rate, slot) in [
+                ("cost.input", tier.cost.input, &mut cost.input),
+                ("cost.output", tier.cost.output, &mut cost.output),
+                (
+                    "cost.cache_read",
+                    tier.cost.cache_read,
+                    &mut cost.cache_read,
+                ),
+                (
+                    "cost.cache_write",
+                    tier.cost.cache_write,
+                    &mut cost.cache_write,
+                ),
+            ] {
+                let base_source = self.field_sources.get(key).copied().unwrap_or(self.source);
+                if rate.is_some_and(|n| n.is_finite() && n >= 0.0)
+                    && crate::merge::rank(tier_source) >= crate::merge::rank(base_source)
+                {
+                    *slot = rate;
+                }
+            }
+        }
+        Some(cost)
+    }
 }

{llmshim-0.7.2 → llmshim-0.8.1}/crates/llmshim-catalog/tests/catalog.rs

@@ -8,6 +8,107 @@ fn feed(value: serde_json::Value) -> String {
     json!({"test": {"models": {"m": value}}}).to_string()
 }
 
+#[test]
+fn grok_4_7_is_available_offline_and_4_6_remains_explicit() {
+    let c = Catalog::vendored();
+    for id in ["xai/grok-4.7", "openrouter/x-ai/grok-4.7"] {
+        let m = c.resolve(id).unwrap();
+        assert_eq!(m.family, Some(ModelFamily::Grok));
+        assert_eq!(m.context_window_tokens, Some(500_000));
+        assert_eq!(m.reasoning_options.len(), 1);
+        assert_eq!(m.field_sources["family"], CatalogSource::Builtin);
+        assert!(
+            m.cost_for_input_tokens(200_001).unwrap().input.unwrap()
+                > m.cost.unwrap().input.unwrap()
+        );
+    }
+    assert_eq!(c.resolve("grok-4.7").unwrap().id, "xai/grok-4.7");
+    assert!(llmshim_catalog::builtin::spec("grok-4.6").is_some());
+    assert!(!llmshim_catalog::builtin::MODELS
+        .iter()
+        .any(|m| m.id == "xai/grok-4.6"));
+    assert_eq!(
+        llmshim_catalog::builtin::spec("grok-4.7")
+            .unwrap()
+            .max_output_tokens,
+        None
+    );
+}
+
+#[test]
+fn context_price_tiers_select_by_full_input_and_inherit_missing_rates() {
+    let mut c = Catalog::empty();
+    c.merge_models_dev(
+        &feed(
+            json!({"cost":{"input":2,"output":6,"cache_read":0.5,"tiers":[
+                {"tier":{"type":"context","size":400000},"output":18},
+                {"tier":{"type":"context","size":200000},"input":4,"output":12,"cache_read":1}
+            ]}}),
+        ),
+        None,
+    )
+    .unwrap();
+    let m = c.resolve("test/m").unwrap();
+    assert_eq!(m.cost_for_input_tokens(200_000), m.cost);
+    let long = m.cost_for_input_tokens(200_001).unwrap();
+    assert_eq!(
+        (long.input, long.output, long.cache_read),
+        (Some(4.0), Some(12.0), Some(1.0))
+    );
+    let longer = m.cost_for_input_tokens(400_001).unwrap();
+    assert_eq!((longer.input, longer.output), (Some(4.0), Some(18.0)));
+    let restored: ModelInfo = serde_json::from_value(serde_json::to_value(m).unwrap()).unwrap();
+    assert_eq!(restored.cost_for_input_tokens(400_001), Some(longer));
+}
+
+#[test]
+fn tier_policy_preserves_local_prices_and_ignores_provider_billing() {
+    let mut c = Catalog::vendored();
+    c.merge_local_toml("[models.\"xai/grok-4.7\".cost]\ninput=0.25")
+        .unwrap();
+    c.merge_provider_models(
+        "xai",
+        &json!({"data":[{"id":"grok-4.7","cost":{"input":999},"context_cost_tiers":[]}]}),
+        Utc::now(),
+    )
+    .unwrap();
+    let m = c.resolve("xai/grok-4.7").unwrap();
+    let long = m.cost_for_input_tokens(300_000).unwrap();
+    assert_eq!(long.input, Some(0.25));
+    assert_eq!(long.output, Some(12.0));
+    c.merge_local_toml("[models.\"xai/grok-4.7\"]\ncontext_cost_tiers=[]")
+        .unwrap();
+    c.merge_builtins();
+    assert_eq!(
+        c.resolve("xai/grok-4.7")
+            .unwrap()
+            .cost_for_input_tokens(300_000)
+            .unwrap()
+            .output,
+        Some(6.0)
+    );
+    assert!(c
+        .merge_local_toml("[models.\"xai/grok-4.7\"]\ncontext_cost_tiers=\"bad\"")
+        .is_err());
+}
+
+#[test]
+fn launch_metadata_wins_over_stale_community_data_in_either_order() {
+    for builtins_first in [true, false] {
+        let mut c = Catalog::empty();
+        if builtins_first {
+            c.merge_builtins();
+        }
+        c.merge_models_dev(&json!({"xai":{"models":{"grok-4.7":{"family":"gpt","cost":{"input":99},"context_cost_tiers":[]}}}}).to_string(),None).unwrap();
+        if !builtins_first {
+            c.merge_builtins();
+        }
+        let m = c.resolve("xai/grok-4.7").unwrap();
+        assert_eq!(m.family, Some(ModelFamily::Grok));
+        assert_eq!(m.cost_for_input_tokens(300_000).unwrap().input, Some(4.0));
+    }
+}
+
 #[test]
 fn absent_fields_are_unknown_and_zero_is_a_real_price() {
     let mut catalog = Catalog::empty();

{llmshim-0.7.2 → llmshim-0.8.1}/docs/src/guides/caching.md

@@ -59,12 +59,15 @@ Anthropic's `input_tokens` excludes the cache read, while the OpenAI Responses,
 Chat Completions and Gemini prompt totals include it. llmshim resolves the
 disagreement at the transport boundary so one counter means one thing.
 
-`cost_usd` is the USD charged for the response: uncached input, output, cache
+`cost_usd` estimates standard token charges: uncached input, output, cache
 reads and cache writes each at their own catalog rate, so a cached prompt is
 never billed twice. **`null` means the catalog carries no price for the model —
 it never means free.** A model priced for input but not for the cache reads a
-response actually used also yields `null`, rather than a partial sum that would
-read as a complete one.
+response actually used charges that class at the model's highest published
+rate, yielding a conservative estimate. Context tiers include cached input
+when choosing the rate and apply to the entire request. For native Grok 4.7,
+rates double above 200,000 input tokens. Provider tool fees, regional premiums,
+and priority endpoint surcharges are not included in these catalog estimates.
 
 `ProviderRequest::can_continue_from` compares endpoint, credential headers,
 settings and the full prior input prefix. `include`, `store`, `reasoning`, tool

{llmshim-0.7.2 → llmshim-0.8.1}/docs/src/guides/reasoning.md

@@ -193,7 +193,7 @@ Native `x-chatgpt.reasoning` overrides the unified mapping.
 
 xAI receives the nested native shape `reasoning: {effort}`:
 
-| unified | Grok 4.6 |
+| unified | Grok 4.7 |
 |---|---|
 | `none` | **`low`** |
 | `low` | `low` |
@@ -202,7 +202,18 @@ xAI receives the nested native shape `reasoning: {effort}`:
 | `xhigh` | `xhigh` |
 | `max` | **`xhigh`** |
 
-Grok 4.6 cannot disable reasoning, so `none` clamps to `low`.
+Grok 4.7 cannot disable reasoning, so `none` clamps to `low`.
+
+Grok 4.7 always returns encrypted reasoning on Responses. llmshim preserves
+the opaque payload and its provenance in `message.reasoning`, requests
+`store: false`, and replays compatible payloads unchanged on subsequent turns.
+Persist the full assistant message, including tool wire IDs and reasoning;
+storing only its text loses this context. Decoding does not modify
+`origin.model` or determine routing.
+
+The adapter translates named tool selection to the Responses shape
+`{"type":"function","name":"lookup"}`. Callers may continue to send the
+Chat Completions shape with `function.name`.
 
 ## Mode mapping: `reasoning_mode: "pro"`
 
@@ -212,7 +223,7 @@ Grok 4.6 cannot disable reasoning, so `none` clamps to `low`.
 | OpenAI GPT-6 Astra | One-tier effort bump (`low → medium → high → xhigh`); explicit `max` stays `max` |
 | Anthropic | One-tier effort bump (`low → medium → high → xhigh → max`) |
 | Gemini | One-tier bump within its four-rung enum, capped at `high` |
-| xAI Grok 4.6 | One-tier bump, capped at `xhigh` |
+| xAI Grok 4.7 | One-tier bump, capped at `xhigh` |
 
 Rules that hold across providers:
 

{llmshim-0.7.2 → llmshim-0.8.1}/docs/src/reference/models.md

@@ -73,7 +73,31 @@ are stable releases only. Credentials determine which providers are listed.
 
 | ID | Display name |
 |---|---|
-| `xai/grok-4.6` | Grok 4.6 |
+| `xai/grok-4.7` | Grok 4.7 |
+
+Grok 4.7 accepts text and images with a 500,000-token context window.
+Reasoning supports `low`, `medium`, `high` (the upstream default), and `xhigh`;
+llmshim maps `none` to `low` and `max` to `xhigh`. Explicit `xai/grok-4.6`
+requests remain supported, but discovery advertises 4.7.
+
+Native xAI standard rates, USD per million tokens:
+
+| Total input tokens, including cached input | Input | Cached input | Output |
+|---|---:|---:|---:|
+| Up to 200,000 | $2 | $0.50 | $6 |
+| Over 200,000 | $4 | $1 | $12 |
+
+The higher tier applies to the whole request. These are native xAI rates;
+OpenRouter has its own prices. See the [release notes](https://docs.x.ai/developers/release-notes).
+Grok 4.7 Fast is available in Cursor/Grok Build, not as a public xAI API model.
+
+For OpenRouter, use `openrouter/x-ai/grok-4.7`. You can append `:nitro` and set
+`x-openrouter.provider.zdr = true` together. Nitro prioritizes throughput and
+allows priority endpoints, whose rates can be higher. On `/v1/chat`, put
+`x-openrouter` inside `provider_config`. These routing options do not enforce
+ZDR on an llmshim fallback to a different provider.
+The Nitro route has replay metadata but no fixed catalog price; its
+`cost_usd` remains `null` unless local policy supplies rates.
 
 ### ChatGPT subscription
 

{llmshim-0.7.2 → llmshim-0.8.1}/docs/src/reference/providers.md

@@ -11,8 +11,8 @@ different native API and translates only the fields that API understands.
 | 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` |
+| vLLM | Chat Completions (self-hosted, `VLLM_BASE_URL`); Responses API with `VLLM_WIRE=responses` | none — address as `vllm/<served-model>` | `x-vllm` |
+| SGLang | Chat Completions (self-hosted, `SGLANG_BASE_URL`); Responses API with `SGLANG_WIRE=responses` | 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