slash-tokens 1.6.7 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [1.7.1] — The Hired Agent Edition
+
+*2026-10-10*
+
+The scan counts each real LLM request once.
+
+No change to `quote()`, `decide()`, `reconcile()`, `hire()`, `/auto` or prices.
+
+### Fixed
+- **The scan (`npx slash-tokens`) counts each LLM request once.** It counted every import, client constructor and request line as its own call site, so one `client.messages.create(...)` behind `import Anthropic` and `new Anthropic()` was reported as two sites (and the request itself wasn't matched unless the client variable was named `anthropic`). The monthly estimate is per site, so it came out inflated: a two-request sample project read 4 sites and $35.77/mo in 1.7.0, and reads 2 sites and $17.89/mo now. A request is now one site; a file that only imports or builds a client counts once. Requests on any client variable are matched (`.messages.create(`, `.chat.completions.create(`, `.responses.create(`, `generateText(` …), in Python too.
+- **The scan no longer counts look-alike calls.** Matching any client variable made `.messages.create(` also catch Twilio's SMS API and `.invoke(` catch Tauri / Electron IPC. A request now counts only in a file that uses that SDK (an import or a client: `import anthropic`, `from openai import`, `new Anthropic()`, `AsyncOpenAI()` …), unless the call names the provider itself (`fetch` to an AI API URL, `x.ai/api`, `cohere.chat`). Python Gemini (`generate_content`) is matched too.
+- The scan's footnote reads "1 call site uses an assumed price" (was "use").
+
+### Docs
+- **Accuracy claims now say what was measured.** Request framing is measured on Nebius only; xAI comes from the Grok bench, OpenAI from its tiktoken cookbook, Anthropic and Google are allowances. The npm README's accuracy line, the root README's accuracy gate (GPT-5.x, not all GPT; GPT-6 takes the conservative default) and the `quote()` / `FRAMING` doc comments now say so. The 1.7.0 entry below called all framing "measured" and its live check didn't name Nebius; both are corrected in place.
+- **`TEST-NOTES.md` is current.** It was the v1.4.0 plan: retired models, and a "preflightRoute agrees with /auto" invariant that has been false by design since 1.6.6 (`/auto` is frozen at its 1.6.5 targets). It now maps each invariant to the test that holds it and lists what isn't tested yet. Two of its invariants had no test and now do: `preflightRoute()` never picks a model the prompt doesn't fit, and `intercept.ts` uses the shared `PROVIDER_MODELS`. The `preflightRoute()` tie-break comment now matches the code (lower list price, not list order).
+
+## [1.7.0] — The Hired Agent Edition
+
+*2026-10-08*
+
+Quote the job, book the right model, prove it with a receipt.
+
+New: `quote()`, `decide()`, `reconcile()`, `hire().run()`, `slash-tokens quote`, and NVIDIA Nemotron on Nebius. `/auto` routing is unchanged. No price change.
+
+### Added
+- **`quote(task)`** prices a job before it runs: input tokens (calibrated, never under-reports), an output band (`minOutputTokens`–`maxOutputTokens`, default 0–4,096 and the quote says when it assumed the ceiling), a low–high USD cost, whether input plus max output fits the context window, and the date the price was checked. Accepts a string or chat messages; real API IDs are accepted.
+- **`decide(task, { budget, floor })`** returns `go`, `downgrade` or `block`. Candidates are the requested model and its same-provider siblings at or above the quality floor; the cheapest one that fits and stays within budget (on the high end) wins. The default floor is the requested model's own tier, so nothing is swapped for a smaller line unless you allow it. A substitute always costs less than the requested model; it respects `init({ route: false })` and `init({ models })` like `preflightRoute()`.
+- **`reconcile(quote, usage, { baseline, feeRate, waived })`** writes the receipt after a call: estimated vs actual tokens and cost (from the provider's own `usage`, OpenAI-style or Anthropic-style), `underReported` (the estimate counted fewer input tokens than were billed — Slash should never do this), whether the cost stayed within the quote, what was saved against a baseline model, and the agent's fee (10% of measured savings by default, shown and waived by default, never charged on a loss). Cached input is priced at the full input rate, so a cached call's cost is an upper bound.
+- **`hire({ budget, baseline, floor, feeRate, waived }).run(job)`**: the agent you hire. Each job is quoted, booked on the cheapest model the policy allows (or blocked), run through your own `call(model, input)`, and reconciled into a receipt. The budget covers all jobs: each one may spend only what earlier jobs left. Blocked jobs never call the model. `agent.spent`, `agent.remaining`, `agent.receipts`.
+- **`slash-tokens quote --model M [--file F | --text T | stdin] [--max-output N] [--min-output N] [--budget USD] [--floor 1-4] [--json]`** prints the quote and the decision (`--json` for pipelines). Exit 0 for go, downgrade and block (read `action`); 1 for bad input.
+- **Quotes include each provider's request framing.** A provider bills the chat template and system preamble on top of your content. Content-only counting quoted 12 input tokens for a real Nebius call billed 23. `quote()` now adds framing: Nebius 16 per request + 7 per extra message, measured (real Token Factory calls, recorded in `bench/results-nemotron-requests.json`), xAI's 193-token system preamble (the Grok bench baseline), OpenAI's 3-per-message rule (its tiktoken cookbook), and a conservative allowance for Anthropic and Google. Two live Nebius calls after the fix: 4% and 8% over the bill, never under. `tests/request-framing.test.ts` holds every recorded bill. `preflight()` stays a content-only go/no-go.
+- **`reconcile()` reads Nebius cache hits** (`prompt_cache_hit_tokens`).
+- **npm metadata:** description now says what 1.7.0 does; keywords add nemotron, nvidia, nebius, agent, cost.
+- **The catalog** (`CATALOG`): one source for every model's prices, context, provider, capability tier (1 small · 2 mid · 3 flagship · 4 frontier — the vendor's own line position, compared within one provider only) and `asOf` date. `MODELS` is now derived from it, with the same keys, order and fields.
+- **NVIDIA Nemotron on Nebius Token Factory:** Nemotron 3 Ultra ($1.00/$3.00, 1,048,576 context), 3 Super ($0.30/$0.90, 262,144), 3 Nano ($0.06/$0.24, 262,144) and 3.5 Lightning ($0.06/$0.24, 1,048,576), in a `Nebius` provider group. Prices and context windows are what the Token Factory API reports (`/v1/models?verbose=true`, 2026-10-08). Its four API IDs (`nvidia/Nemotron-3-Ultra-550b-a55b`, `nvidia/nemotron-3-super-120b-a12b`, `nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B`, `nvidia/Nemotron-3_5-Lightning`) resolve to catalog keys. Token counts use the Nemotron factor below.
+
+- **Nemotron calibration: 1.30**, measured against the real Nemotron tokenizer (Hugging Face, run locally; the four models share it). The worst case on the 29-sample corpus (a large JSON API response) needs ≥ 1.208; 1.30 leaves 7.6% headroom. Nemotron previously took the unknown-model default (2.05), 70% above what even the worst sample needs. `npm run bench:nemotron` reproduces it; `bench/REPORT-nemotron.md`.
+- **Accuracy gate in CI** (`tests/accuracy-gate.test.ts`): every calibrated estimate must be at least the provider's real count on all 29 corpus samples, for the Claude, Gemini, Grok and Nemotron families (recorded bench results) and GPT-5.x (o200k_base, computed in the test). A change that breaks "never under-report" now fails CI.
+- **Price-freshness alarm** (`npm run check:freshness`, weekly `freshness.yml`): fails when any catalog price is more than 30 days old, or an announced price change (`priceUntil`, e.g. Gemini 3.6–3.8 Flash on 2026-12-31) is within 14 days. Runs even when mcpaas.live is down.
+
+### Changed
+- `preflight()` options (the cross-provider analysis) now include the Nemotron models, so the cheapest option can be a Nemotron model. `preflightRoute()` is unchanged: same-provider only.
+- **`slash-tokens/auto` stays frozen at its 1.6.5 routing targets.** 1.6.6 said /auto would start routing to the newer models in 1.7.0; we've decided against changing where live production calls go inside a feature release. The newer models are priced and recognised in /auto events, and `preflightRoute()` and `decide()` use them. Moving /auto's targets will be its own release, announced first.
+- Root README: the `report()` example now uses the real `action` values (`'prevented' | 'routed' | 'pass'`).
+
 ## [1.6.7] — The Fixed Deal Edition
 
 *2026-10-08*

package/README.md

@@ -7,71 +7,71 @@
 [![license](https://img.shields.io/npm/l/slash-tokens?style=flat)](./LICENSE)
 [![⭐ Star on GitHub](https://img.shields.io/badge/%E2%AD%90_Star-black?logo=github&logoColor=white)](https://github.com/Wolfe-Jam/slash-tokens)
 
-Token Optimization for Context Engineers.
-For anyone building with LLMs. 4.8 KB WASM. Sub-millisecond. Zero dependencies.
+**Know what an LLM call will cost before you make it, and prove what you saved after.**
+4.8 KB WASM · sub-millisecond · zero dependencies · Claude, GPT, Grok, Gemini, Nemotron.
 
-Know the cost before the call leaves your machine.
+## v1.7.1 — The Hired Agent Edition
 
-Models change. Windows grow. Slash adapts — you keep building.
-Cheaper tokens haven't shrunk the bill — usage has.
+Quote the job, book the right model, prove it with a receipt.
 
-## v1.6.7 — The Fixed Deal Edition
+New in 1.7.1: the scan counts each real LLM request once.
 
-One very large request (about 1 MB of text) no longer skews every count after it.
+```js
+import { hire } from 'slash-tokens'
 
-Solo $20 mailbox, 10% waived. Team $39 for the data.
+const agent = hire({ budget: 0.50, floor: 2 })  // $0.50 to spend; nothing below a mid-tier model
 
-New in 1.6.7: a single request over ~1 MB of text used to overwrite the token counter's lookup tables, so every later count in that process came out wrong; prompts now go above them. Counts for normal prompts are unchanged.
+const { decision, receipt } = await agent.run({
+  input: prompt,
+  model: 'nemotron-3-ultra',
+  maxOutputTokens: 2000,
+  call: (model, input) => yourClient(model, input),  // returns { output, usage }
+})
 
-New in 1.6.6: Claude Opus 5.5 / Sonnet 5.5 / Fable 5.1, Grok 4.7, GPT-6 (Astra, Sol, Luna), Gemini 3.6–3.8 Flash and 3.1 Flash-Lite, priced as of 2026-10-07. Real API IDs (`claude-opus-4-7`) work in `preflight()`. `preflightRoute()` now finds GPT-6 Luna and Gemini 3.1 Flash-Lite as the cheapest same-provider options.
+decision.action  // 'downgrade': nemotron-3-super does the job for less
+receipt.saved    // dollars saved against the model you asked for
+```
 
-**Free forever is bunx** — no account. A one-person account is email → key, **$20 on the house**. We show the savings. We don't charge. 10% is the model, waived. Team is **$39 for the data** (`$390`/year).
+- **Quote:** `quote()` prices a job before it runs, low to high.
+- **Decide:** `decide()` goes, downgrades or blocks, within your budget and quality floor. Same provider, never a pricier model.
+- **Prove:** `reconcile()` checks the quote against what the provider billed.
+- **Hire:** `hire()` does all three for every job, inside one budget. Its cut, 10% of measured savings, is on every receipt, waived.
 
-```bash
-bunx slash-tokens
-# or: npx --yes slash-tokens
-```
+Counts are calibrated against each provider's real tokenizer; models not benchmarked yet (GPT-6) get a conservative default. Quotes add what the provider bills on top of your text, measured on Nebius and a conservative allowance elsewhere. CI fails if a count comes in under the real one, or a quote under a real Nebius bill.
 
-Run it in a project that already calls an LLM. An empty folder prints that nothing was found, then tells you to run it in an app — that's normal. `--version` / `--help` print and exit (they do not scan). Pin proof: `slash-tokens --version` or `npm view slash-tokens version`.
+## Install
 
 ```bash
 npm install slash-tokens
 ```
 
-```js
-import { preflight, preflightRoute } from 'slash-tokens'
-
-// Analysis — cheaper alternatives across all providers. Not a route.
-const check = preflight(prompt, 'claude-opus-5')
-check.tokens
-check.cost
-check.fits
-check.options
+## From the terminal
 
-// Routing decision — same-provider only, matches the Slash proxy
-const route = preflightRoute(prompt, 'claude-opus-5')
-// { model: 'claude-haiku', cost, salvaged, salvagePercent } or null
+```bash
+npx slash-tokens   # find the LLM calls in this project and what they cost a month
+echo "Fix the bug" | npx slash-tokens quote --model nemotron-3-ultra --floor 1
 ```
 
-Or one line — every LLM call checked pre-call:
+## Check every call, automatically
 
 ```js
 import 'slash-tokens/auto'
 ```
 
-Intercepts `fetch()` to Anthropic, OpenAI, xAI, and Google. Estimates before the call leaves your machine. Same-provider cheaper swap if one fits.
-
-## See it work
+Checks each request to Anthropic, OpenAI, xAI and Google before it leaves your machine, and swaps in a cheaper model from the same provider when one fits.
 
-A live chat with every call through the gate: [live demo](https://slash-nextjs-wofejams-projects.vercel.app)
+## Per-call checks
 
-Then `bunx slash-tokens`, [get a key](https://mcpaas.live/slash/setup) ($20 on the house), or [Team — $39 for the data](https://slashtokens.com).
+```js
+import { preflight, preflightRoute } from 'slash-tokens'
 
-## Dashboard
+const check = preflight(prompt, 'claude-opus-5')       // tokens, cost, fits, cheaper options (all providers)
+const route = preflightRoute(prompt, 'claude-opus-5')  // the cheapest same-provider model that fits, or null
+```
 
-Track savings across all your apps. One-person key (email, $20 on the house) at [mcpaas.live/slash/setup](https://mcpaas.live/slash/setup)
+## Pricing
 
-Full docs, examples, and model pricing at **[GitHub](https://github.com/Wolfe-Jam/slash-tokens)**
+The library and CLI are free, no account needed. A one-person key is $20 on the house: we show the savings and don't charge. Team is $39/month for the data. [Live demo](https://slash-nextjs-wofejams-projects.vercel.app) · [Get a key](https://mcpaas.live/slash/setup) · [slashtokens.com](https://slashtokens.com) · [Full docs](https://github.com/Wolfe-Jam/slash-tokens)
 
 ## License
 

package/dist/agent.d.ts

@@ -0,0 +1,50 @@
+import { type Task, type Decision, type Message } from './quote.js';
+import { type Receipt, type Usage } from './receipt.js';
+import type { Tier } from './catalog.js';
+export interface HireOptions {
+    /** Total USD the agent may spend across every job it runs. No budget = no limit. */
+    budget?: number;
+    /** Model the savings are measured against. Default: the model each job asks for. */
+    baseline?: string;
+    /** Lowest tier a substitute may have. Default: each job's requested tier. */
+    floor?: Tier;
+    /** The agent's cut of measured savings. Default 0.10. */
+    feeRate?: number;
+    /** Fee shown on the receipt but not charged. Default true. */
+    waived?: boolean;
+}
+/**
+ * What the agent calls to do the work: your provider client. `model` is the
+ * booked catalog key (e.g. `nemotron-3.5-lightning`); map it to your
+ * provider's API ID. Return the output and the provider's `usage` object.
+ */
+export type CallModel = (model: string, input: string | Message[]) => Promise<{
+    output: string;
+    usage: Usage;
+}>;
+export interface Job extends Task {
+    call: CallModel;
+}
+export interface RunResult {
+    decision: Decision;
+    /** The model's output; undefined when blocked. */
+    output?: string;
+    /** Estimate vs actual, saved vs baseline, fee; undefined when blocked. */
+    receipt?: Receipt;
+}
+export interface Agent {
+    /** Quote → decide → book → run → reconcile → receipt. */
+    run(job: Job): Promise<RunResult>;
+    /** USD spent so far (actual cost, from receipts). */
+    readonly spent: number;
+    /** USD left in the budget (Infinity with no budget). */
+    readonly remaining: number;
+    readonly receipts: readonly Receipt[];
+}
+/**
+ * Hire Slash for a run of jobs. Each job is quoted, booked on the cheapest
+ * model the policy allows (or blocked), run through your `call`, and
+ * reconciled against the provider's own usage. The budget covers all jobs:
+ * each one may spend only what earlier jobs left.
+ */
+export declare function hire(opts?: HireOptions): Agent;

package/dist/agent.js

@@ -0,0 +1,36 @@
+import { decide } from './quote.js';
+import { reconcile } from './receipt.js';
+/**
+ * Hire Slash for a run of jobs. Each job is quoted, booked on the cheapest
+ * model the policy allows (or blocked), run through your `call`, and
+ * reconciled against the provider's own usage. The budget covers all jobs:
+ * each one may spend only what earlier jobs left.
+ */
+export function hire(opts = {}) {
+    const receipts = [];
+    let spent = 0;
+    const budget = opts.budget ?? Infinity;
+    return {
+        get spent() { return spent; },
+        get remaining() { return Math.max(budget - spent, 0); },
+        get receipts() { return receipts; },
+        async run(job) {
+            const { call, ...task } = job;
+            const policy = { floor: opts.floor };
+            if (budget !== Infinity)
+                policy.budget = Math.max(budget - spent, 0);
+            const decision = decide(task, policy);
+            if (decision.action === 'block' || !decision.chosen)
+                return { decision };
+            const { output, usage } = await call(decision.chosen.model, task.input);
+            const receipt = reconcile(decision.chosen, usage, {
+                baseline: opts.baseline ?? decision.requested.model,
+                feeRate: opts.feeRate,
+                waived: opts.waived,
+            });
+            spent = Math.round((spent + receipt.actual.cost) * 1000000) / 1000000;
+            receipts.push(receipt);
+            return { decision, output, receipt };
+        },
+    };
+}

package/dist/catalog.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The catalog — one source for every priced model.
+ *
+ * Each entry carries its prices (USD per million tokens), context window,
+ * provider, capability tier and the date the price was checked. `MODELS`
+ * (models.ts) and the quote / decide policy (quote.ts) both read from here.
+ *
+ * Tiers are the vendor's own line position, not a benchmark:
+ *   4 frontier — the vendor's top line above its flagship (Fable/Mythos, GPT-6 Astra)
+ *   3 flagship — Opus, Sol, Grok 4.5+, Gemini Pro, Nemotron Ultra, GPT-5.4
+ *   2 mid      — Sonnet, Terra, Grok 4.3, Gemini Flash, Nemotron Super, GPT-5.4 mini
+ *   1 small    — Haiku, Luna, Flash-Lite, GPT-5.4 nano, Nemotron Nano / Lightning
+ * A quality floor compares tiers within one provider only; tiers never rank
+ * one vendor's model against another's.
+ */
+export type Tier = 1 | 2 | 3 | 4;
+export declare const TIER_NAMES: Record<Tier, string>;
+export interface CatalogEntry {
+    provider: string;
+    tier: Tier;
+    /** Date the price was checked against the provider's own pricing page. */
+    asOf: string;
+    /** Last day this price holds, when the provider has announced a change. */
+    priceUntil?: string;
+    input: number;
+    output: number;
+    context: number;
+    longContextThreshold?: number;
+    longContextInput?: number;
+    longContextOutput?: number;
+}
+export declare const CATALOG: Record<string, CatalogEntry>;
+/**
+ * Real API IDs that don't follow the table's naming → table keys.
+ * Lowercased; canonicalModel() lowercases before looking here. The Nebius IDs
+ * are the ones Token Factory lists (GET /v1/models, 2026-10-08).
+ */
+export declare const API_ALIASES: Record<string, string>;

package/dist/catalog.js

@@ -0,0 +1,143 @@
+/**
+ * The catalog — one source for every priced model.
+ *
+ * Each entry carries its prices (USD per million tokens), context window,
+ * provider, capability tier and the date the price was checked. `MODELS`
+ * (models.ts) and the quote / decide policy (quote.ts) both read from here.
+ *
+ * Tiers are the vendor's own line position, not a benchmark:
+ *   4 frontier — the vendor's top line above its flagship (Fable/Mythos, GPT-6 Astra)
+ *   3 flagship — Opus, Sol, Grok 4.5+, Gemini Pro, Nemotron Ultra, GPT-5.4
+ *   2 mid      — Sonnet, Terra, Grok 4.3, Gemini Flash, Nemotron Super, GPT-5.4 mini
+ *   1 small    — Haiku, Luna, Flash-Lite, GPT-5.4 nano, Nemotron Nano / Lightning
+ * A quality floor compares tiers within one provider only; tiers never rank
+ * one vendor's model against another's.
+ */
+export const TIER_NAMES = {
+    4: 'frontier',
+    3: 'flagship',
+    2: 'mid',
+    1: 'small',
+};
+const OPUS = { input: 5.00, output: 25.00, context: 1000000 };
+const OPUS_55 = { input: 4.00, output: 20.00, context: 1000000 };
+const FABLE = { input: 10.00, output: 50.00, context: 1000000 };
+const SONNET_4X = { input: 3.00, output: 15.00, context: 1000000 };
+const SONNET = { input: 2.00, output: 10.00, context: 1000000 };
+const HAIKU = { input: 1.00, output: 5.00, context: 200000 };
+const GROK_46 = {
+    input: 2.00, output: 6.00, context: 500000,
+    longContextThreshold: 200000, longContextInput: 4.00, longContextOutput: 12.00,
+};
+const GROK_43 = {
+    input: 1.25, output: 2.50, context: 1000000,
+    longContextThreshold: 200000, longContextInput: 2.50, longContextOutput: 5.00,
+};
+const GEMINI_PRO = {
+    input: 2.00, output: 12.00, context: 1000000,
+    longContextThreshold: 200000, longContextInput: 4.00, longContextOutput: 18.00,
+};
+const GEMINI_FLASH = { input: 0.30, output: 2.50, context: 1000000 };
+// Gemini 3.6–3.8 Flash: launch price through 2026-12-31; Google lists $1.50/$7.50
+// from 2027-01-01. priceUntil makes the freshness check fail before then.
+const GEMINI_FLASH_3X = { input: 0.75, output: 3.75, context: 1000000, priceUntil: '2026-12-31' };
+const GEMINI_35_FLASH = { input: 1.50, output: 9.00, context: 1000000 };
+const GEMINI_31_FLASH_LITE = { input: 0.25, output: 1.50, context: 1000000 };
+const GROK_BUILD = {
+    input: 1.00, output: 2.00, context: 256000,
+    longContextThreshold: 200000, longContextInput: 2.00, longContextOutput: 4.00,
+};
+const GPT_6_ASTRA = { input: 10.00, output: 50.00, context: 1050000 };
+const GPT_6_SOL = { input: 2.00, output: 10.00, context: 1050000 };
+const GPT_6_LUNA = { input: 0.10, output: 0.50, context: 1050000 };
+const GPT_SOL = { input: 4.00, output: 20.00, context: 1050000 };
+const GPT_TERRA = { input: 2.00, output: 12.00, context: 1050000 };
+const GPT_LUNA = { input: 0.20, output: 1.20, context: 1050000 };
+const GPT_54 = { input: 2.50, output: 15.00, context: 1000000 };
+const GPT_54_MINI = { input: 0.75, output: 4.50, context: 128000 };
+const GPT_54_NANO = { input: 0.20, output: 1.25, context: 128000 };
+// NVIDIA Nemotron on Nebius Token Factory. Prices and context windows are
+// exactly what the API reports (GET /v1/models?verbose=true, 2026-10-08).
+const NEMOTRON_ULTRA = { input: 1.00, output: 3.00, context: 1048576 };
+const NEMOTRON_SUPER = { input: 0.30, output: 0.90, context: 262144 };
+const NEMOTRON_NANO = { input: 0.06, output: 0.24, context: 262144 };
+const NEMOTRON_LIGHTNING = { input: 0.06, output: 0.24, context: 1048576 };
+// Prices as of 2026-10-07 — first-party pages:
+//   platform.claude.com/docs/en/about-claude/pricing
+//   developers.openai.com/api/docs/models
+//   docs.x.ai/developers/models
+//   ai.google.dev/gemini-api/docs/pricing
+const ASOF = '2026-10-07';
+// Nemotron: read from the Token Factory API (see above).
+const ASOF_NEBIUS = '2026-10-08';
+function e(provider, tier, price) {
+    return { provider, tier, asOf: provider === 'Nebius' ? ASOF_NEBIUS : ASOF, ...price };
+}
+// Order is kept from the 1.6.6 MODELS table (new entries appended), so
+// preflight()'s option ordering for equal costs doesn't move.
+export const CATALOG = {
+    // Anthropic — live names + generic aliases (same rates)
+    'claude-fable-5.1': e('Anthropic', 4, FABLE),
+    'claude-fable-5': e('Anthropic', 4, FABLE),
+    'claude-mythos-5.1': e('Anthropic', 4, FABLE),
+    'claude-mythos-5': e('Anthropic', 4, FABLE),
+    'claude-opus-5.5': e('Anthropic', 3, OPUS_55),
+    'claude-opus-5': e('Anthropic', 3, OPUS),
+    'claude-opus-4.8': e('Anthropic', 3, OPUS),
+    'claude-opus': e('Anthropic', 3, OPUS),
+    'claude-opus-4.7': e('Anthropic', 3, OPUS),
+    'claude-opus-4.6': e('Anthropic', 3, OPUS),
+    'claude-opus-4.5': e('Anthropic', 3, OPUS),
+    'claude-sonnet-5.5': e('Anthropic', 2, SONNET),
+    'claude-sonnet-5': e('Anthropic', 2, SONNET),
+    'claude-sonnet': e('Anthropic', 2, SONNET),
+    'claude-sonnet-4.6': e('Anthropic', 2, SONNET_4X),
+    'claude-sonnet-4.5': e('Anthropic', 2, SONNET_4X),
+    'claude-haiku-4.5': e('Anthropic', 1, HAIKU),
+    'claude-haiku': e('Anthropic', 1, HAIKU),
+    // xAI — flagship 4.6, cheap same-provider 4.3. 4.20 / fast are aliases.
+    'grok-4.7': e('xAI', 3, GROK_46),
+    'grok-4.6': e('xAI', 3, GROK_46),
+    'grok-4.5': e('xAI', 3, GROK_46),
+    'grok-build-0.1': e('xAI', 2, GROK_BUILD),
+    'grok-4.3': e('xAI', 2, GROK_43),
+    'grok-4.20': e('xAI', 2, GROK_43),
+    'grok-4-1-fast': e('xAI', 2, GROK_43),
+    // Google
+    'gemini-3.1-pro': e('Google', 3, GEMINI_PRO),
+    'gemini-3.1-pro-preview': e('Google', 3, GEMINI_PRO),
+    'gemini-3.8-flash': e('Google', 2, GEMINI_FLASH_3X),
+    'gemini-3.7-flash': e('Google', 2, GEMINI_FLASH_3X),
+    'gemini-3.6-flash': e('Google', 2, GEMINI_FLASH_3X),
+    'gemini-3.5-flash': e('Google', 2, GEMINI_35_FLASH),
+    'gemini-3.1-flash-lite': e('Google', 1, GEMINI_31_FLASH_LITE),
+    'gemini-3.5-flash-lite': e('Google', 1, GEMINI_FLASH),
+    'gemini-2.5-flash': e('Google', 2, GEMINI_FLASH),
+    // OpenAI — live 5.6 ladder + GPT-6. 5.4 family kept as aliases (old prices).
+    'gpt-6-astra': e('OpenAI', 4, GPT_6_ASTRA),
+    'gpt-6.1-sol': e('OpenAI', 3, GPT_6_SOL),
+    'gpt-6-sol': e('OpenAI', 3, GPT_6_SOL),
+    'gpt-6-luna': e('OpenAI', 1, GPT_6_LUNA),
+    'gpt-5.6-sol': e('OpenAI', 3, GPT_SOL),
+    'gpt-5.6-terra': e('OpenAI', 2, GPT_TERRA),
+    'gpt-5.6-luna': e('OpenAI', 1, GPT_LUNA),
+    'gpt-5.4': e('OpenAI', 3, GPT_54),
+    'gpt-5.4-mini': e('OpenAI', 2, GPT_54_MINI),
+    'gpt-5.4-nano': e('OpenAI', 1, GPT_54_NANO),
+    // NVIDIA Nemotron, served and billed by Nebius Token Factory
+    'nemotron-3-ultra': e('Nebius', 3, NEMOTRON_ULTRA),
+    'nemotron-3-super': e('Nebius', 2, NEMOTRON_SUPER),
+    'nemotron-3-nano': e('Nebius', 1, NEMOTRON_NANO),
+    'nemotron-3.5-lightning': e('Nebius', 1, NEMOTRON_LIGHTNING),
+};
+/**
+ * Real API IDs that don't follow the table's naming → table keys.
+ * Lowercased; canonicalModel() lowercases before looking here. The Nebius IDs
+ * are the ones Token Factory lists (GET /v1/models, 2026-10-08).
+ */
+export const API_ALIASES = {
+    'nvidia/nemotron-3-ultra-550b-a55b': 'nemotron-3-ultra',
+    'nvidia/nemotron-3-super-120b-a12b': 'nemotron-3-super',
+    'nvidia/nemotron-3_5-lightning': 'nemotron-3.5-lightning',
+    'nvidia/nvidia-nemotron-3-nano-30b-a3b': 'nemotron-3-nano',
+};