slash-tokens 1.6.6 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [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 measured framing: Nebius 16 per request + 7 per extra message (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, and a conservative allowance for Anthropic and Google. Live check 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*
+
+One very large request (about 1 MB of text) no longer skews every count after it.
+
+Solo $20 mailbox, 10% waived. Team $39 for the data.
+
+### Fixed
+- **A single request over ~1.04 MB of text no longer skews every later estimate in the same process.** Input was written into WASM memory from byte 4096, so a big one ran over the module's stack and lookup tables (at 1 MiB), and later estimates came out wrong — a 14-token prompt read as 28. Input now starts above them (byte 1,114,112). Estimates for inputs under the threshold are unchanged (checked against 1.6.6 on the 29-sample corpus and five models). Older versions are affected too (any version that writes input at byte 4096, including 1.6.6).
+- **The test suite now passes file by file.** `preflight.test.ts` failed when run alone: on a tiny prompt the routed model's cost rounds to the same 6-decimal value as the original's. It passed in the full suite only because the bug above had already inflated the counts. The test now checks a lower list price, and strictly lower cost on a prompt big enough to show it.
+
+No Team/Solo price change. No routing or pricing change.
+
 ## [1.6.6] — The Fixed Deal Edition
 
 *2026-10-07*

package/README.md

@@ -7,69 +7,69 @@
 [![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.0 — 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.6 — The Fixed Deal Edition
+```js
+import { hire } from 'slash-tokens'
 
-`--version` / `--help` answer, and today's models price correctly.
+const agent = hire({ budget: 0.50, floor: 2 })  // $0.50 to spend; nothing below a mid-tier model
 
-Solo $20 mailbox, 10% waived. Team $39 for the data.
+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, quotes add what each provider bills on top of your text, and CI fails if either comes in under the real number.
 
-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',
+};