@trazum/core 2.4.2 → 2.5.0

package/dist/pricing.js

@@ -30,9 +30,9 @@
 export const PROVIDER_REVIEWED = Object.freeze({
     /*
      * platform.claude.com/docs/en/about-claude/pricing, the models overview and
-     * each model's own page, read 2026-10-10. Every existing row matched; five
-     * models were added and one (Claude Haiku 5.5) deliberately was not, see the
-     * comment above its would-be place in MODELS.
+     * each model's own page, read 2026-10-10. Every existing row matched and
+     * five models were added. Claude Haiku 5.5 waited for per-request pricing,
+     * because it bills by prompt length, and was added with it on 2026-10-11.
      */
     anthropic: '2026-10-10',
     /*
@@ -46,34 +46,56 @@ export const PROVIDER_REVIEWED = Object.freeze({
      * and priority. The standard one is the catalogue's, identified by the other
      * three being its multiples (0.5x, 0.5x, 2x) rather than by trusting the
      * order they appear in.
+     *
+     * Re-read 2026-10-11 with the prompt-caching guide, the GPT-5 model page and
+     * the deprecations page. GPT-5, mini and nano matched to the cent. Their
+     * dated snapshots (`gpt-5-2025-08-07` and the mini and nano ones), which is
+     * the id a usage log usually carries, shut down on 2026-12-11 and are now
+     * declared as aliases. The current generation (gpt-6-astra, gpt-6.1-sol,
+     * gpt-6-sol, gpt-6-luna and gpt-5.6 sol, terra and luna) waited for
+     * per-request pricing, since each doubles its rates for prompts over 272K
+     * tokens, and was added with it the same day, from each model's own page.
+     */
+    openai: '2026-10-11',
+    /*
+     * ai.google.dev/gemini-api/docs/pricing, docs/caching and the model pages,
+     * read 2026-10-10. Every price matched; what changed is how caching starts
+     * and what it costs on the old models. Implicit caching is on by default
+     * for every Gemini 2.5 and newer model, so `caching` is 'automatic' across
+     * the board; the minimums moved to 4,096 on 3.6 and 3.8 Flash and 2,048 on
+     * 2.5 Flash; and the 2.5 models read the cache at 10% of input today, not
+     * the 25% this table carried. Gemini 3.8 Flash was added, and Gemini 3.1
+     * Pro Preview on 2026-10-11 with per-request pricing, which its prompts
+     * over 200k need. 2.5 Pro's own long-context rate is named in its note.
      */
-    openai: '2026-08-31',
-    /* ai.google.dev/gemini-api/docs/pricing, read 2026-08-28. */
-    google: '2026-08-28',
+    google: '2026-10-10',
     /*
-     * platform.kimi.ai/docs/pricing/chat (platform.moonshot.ai 301s there),
-     * read 2026-09-12. The page prices kimi-k3, kimi-k2.6, kimi-k2.7-code and
-     * its highspeed variant; `kimi-k2`, the one id this table carries, is no
-     * longer on it. Its price is kept because calls in somebody's log really
-     * happened at it, and it is not marked retired because that is recorded
-     * from the provider's own refusal to a request, which needs a key this
-     * repository does not hold. The newer models are not added: the page states
-     * no context window for any of them, and a context window this table did
-     * not read is a number it would be inventing.
+     * platform.kimi.ai/docs/pricing/chat, models and pricing/batch, read
+     * 2026-10-11 in their Markdown form; the HTML renders its tables in the
+     * browser, which is why the review of 2026-09-12 found no context window
+     * and added nothing. Kimi K3, K2.7 Code (and its high-speed variant) and
+     * K2.6 are priced now. `kimi-k2` was discontinued on 2026-05-25 by the
+     * provider's own notice, so it stays priced and is no longer recommended.
      */
-    moonshot: '2026-09-12',
-    /* api-docs.deepseek.com/quick_start/pricing, read 2026-08-28. */
-    deepseek: '2026-08-28',
+    moonshot: '2026-10-11',
     /*
-     * docs.x.ai/docs/models, read 2026-09-12. The page prices grok-4.6, 4.5,
-     * 4.3 and the 4.20 family, each at two rates split at 200k prompt tokens;
-     * `grok-4`, the one id this table carries, is no longer on it. Kept and not
-     * marked retired, for the reasons given for kimi-k2 above. The newer models
-     * are not added: this table has no way to express a price that changes at
-     * 200k prompt tokens, and pricing a 300k-token call at the under-200k rate
-     * would understate it by half while looking exact.
+     * api-docs.deepseek.com/quick_start/pricing read 2026-10-10, and the
+     * 2026-09-10 announcement (api-docs.deepseek.com/news/news260910) read
+     * 2026-10-11 for the instant: "New pricing takes effect at 04:00 UTC on
+     * Sept 10, 2026." V4 Flash was retired that day and its id now bills at
+     * the new deepseek-flash price, so the old price lives in its `history`.
+     * V4 Pro matched the page unchanged.
      */
-    xai: '2026-09-12',
+    deepseek: '2026-10-10',
+    /*
+     * docs.x.ai/developers/models, each model's page and the 2026-05-15
+     * retirement notice, read 2026-10-11 in their Markdown form. Grok 4.7, 4.6,
+     * 4.5, 4.3, the 4.20 family and Build 0.1 are priced, each with the rate a
+     * request pays once its prompt reaches 200k tokens, which per-request
+     * pricing can now express. `grok-4` was retired on 2026-05-15 and its calls
+     * have billed at Grok 4.3's prices since, so it carries both periods.
+     */
+    xai: '2026-10-11',
     /*
      * `mistral.ai/pricing`, read 2026-08-28 — by a human, because the page
      * renders its table in the browser and serves a fetch only an FAQ example
@@ -84,7 +106,18 @@ export const PROVIDER_REVIEWED = Object.freeze({
      * servable is not the same as checking, and moving the date then would have
      * said it was.
      */
-    mistral: '2026-08-28',
+    /*
+     * Re-read 2026-10-11 from mistral.ai/cloud/inference/ and the model cards
+     * at mistral.ai/news/mistral-3/, /mistral-small-4/ and
+     * /vibe-remote-agents-mistral-medium-3-5/, which carry the prices in their
+     * markup (`data-prices`) and bind the `-latest` ids. Every price matched.
+     * What changed is caching: the inference page offers "Cached input tokens
+     * -90% on input token", and every one of the three cards marks its input
+     * price as carrying the cache discount. This table said Mistral had no
+     * prompt caching at all. docs.mistral.ai, where a minimum or a mechanism
+     * would be, is not reachable from here, so neither is claimed.
+     */
+    mistral: '2026-10-11',
 });
 /**
  * The catalogue's age is its oldest provider's, because a reader asking how
@@ -121,7 +154,13 @@ export const COST_MULTIPLIERS = {
  */
 /** Memoised for the same reason as `effectivePricing`: once per record. */
 const multipliersMemo = new WeakMap();
-export function multipliersFor(model) {
+export function multipliersFor(model, on) {
+    // A dated question about a repriced model asks the period in force then.
+    if (on !== undefined && model.history !== undefined) {
+        const period = pricedAt(model, on);
+        if (period !== model)
+            return multipliersFor(period);
+    }
     const cached = multipliersMemo.get(model);
     if (cached !== undefined)
         return cached;
@@ -135,6 +174,45 @@ export function multipliersFor(model) {
     multipliersMemo.set(model, result);
     return result;
 }
+/** Five minutes and an hour: Anthropic's two cache entries, and the default. */
+const ANTHROPIC_TTL = Object.freeze({ writeMs: 5 * 60_000, longerMs: 60 * 60_000 });
+/** How long a model's cache entries live. See `ModelPricing.cacheTtl`. */
+export function cacheTtlOf(model) {
+    return model.cacheTtl ?? ANTHROPIC_TTL;
+}
+/**
+ * Mistral discounts cached input by 90% and publishes nothing else about it
+ * that can be read from here: not how caching starts, not a minimum, not a
+ * write price. Its usage reports no write tokens, so the write ratio of 1 is
+ * never multiplied by anything; it is there so the default (Anthropic's 1.25)
+ * cannot be.
+ */
+/** What the GPT-5 family's three rows share, from OpenAI's guide and deprecations page, read 2026-10-11. */
+/** xAI's long-context band: a request whose prompt reaches 200,000 tokens, at the published higher rates. */
+const GROK_LONG = (inputPerMTok, outputPerMTok) => ({
+    id: 'from-200k',
+    when: { kind: 'input-tokens-at-least', tokens: 200_000 },
+    inputPerMTok,
+    outputPerMTok,
+});
+/**
+ * Said on every row that caches but whose provider publishes no minimum
+ * prefix. The bill still prices its cache reads and writes, which are
+ * published; what goes quiet is the advice that needs the minimum to promise
+ * a saving, and the reader is told why rather than handed a number from
+ * nowhere. The catalogue tests hold a null minimum on a caching model to
+ * carrying this sentence, so a forgotten minimum cannot pass as a deliberate one.
+ */
+const NO_PUBLISHED_CACHE_MINIMUM = 'Caches automatically, but no minimum prefix length is published, so no caching advice is given for it.';
+/** OpenAI's GPT-5.6 and later: one cache entry, living at least 30 minutes. */
+const OPENAI_CACHE_TTL = Object.freeze({ writeMs: 30 * 60_000, longerMs: null });
+const OPENAI_CURRENT_NOTE = 'Priced per request by prompt length: over 272,000 input tokens, 2x input and cache and 1.5x output for'
+    + ' the whole request. Cache writes cost 1.25x input and an entry lives at least 30 minutes.';
+const OPENAI_GPT5_NOTE = 'Caching is automatic, with no cache_control to set. OpenAI says the minimum for models before GPT-5.6 varies by'
+    + ' request settings, so 1,024 here is the nearest published floor. The 2025-08-07 snapshot shuts down on'
+    + ' 2026-12-11; OpenAI names the gpt-5.6 models as replacements.';
+const MISTRAL_CACHE_NOTE = 'Cached input costs 10% of the input price (mistral.ai/cloud/inference, read 2026-10-11). How caching starts and'
+    + ' its minimum are not published anywhere Trazum can read, so no caching advice is given for it.';
 export const MODELS = [
     {
         /*
@@ -329,18 +407,44 @@ export const MODELS = [
         capability: 'mid',
         tier: 'sonnet',
     },
-    /*
-     * Claude Haiku 5.5 is not here, on purpose, and its calls are an unpriced
-     * gap that names it. The pricing page (read 2026-10-10) prices it by prompt
-     * length: $0.10/$0.50 up to 100,000 tokens and $0.50/$2.50 above, where the
-     * length counts cache reads and writes and each request is priced on its
-     * own. A tier can say that, but nothing that prices a usage log passes one
-     * request's prompt length to `effectivePricing`: records are summed per
-     * workload, model and day before they are priced. Added today, every Haiku
-     * 5.5 call would fall to the undecided ceiling, five times the price most of
-     * them paid. It goes in with the change that prices tiered models per
-     * request, not before.
-     */
+    {
+        /*
+         * The pricing page, the models overview and the prompt-caching page, read
+         * 2026-10-10. Priced by prompt length, per request: $0.10/$0.50 for a
+         * prompt up to 100,000 tokens and $0.50/$2.50 over it, where the length
+         * counts every input token the request carried, cache reads and writes
+         * included, and "each request is priced on its own". Caching is the same
+         * ratio in both bands (hits $0.01 and $0.05, writes $0.125/$0.20 and
+         * $0.625/$1), and so is batch ($0.05/$0.25, $0.25/$1.25). 1M context,
+         * 128K output, a 512-token cache minimum.
+         *
+         * It waited for the change that prices a log per request. A record that
+         * is one call carries its own prompt; a row out of a usage report sums
+         * requests, and is billed at the over-100,000 rate unless its whole
+         * prompt total is under the line, with the cheaper figure printed beside
+         * it. See `PromptSize`.
+         */
+        id: 'claude-haiku-5-5',
+        provider: 'anthropic',
+        displayName: 'Claude Haiku 5.5',
+        inputPerMTok: 0.1,
+        outputPerMTok: 0.5,
+        contextWindow: 1_000_000,
+        cacheMinTokens: 512,
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 2, batch: 0.5 },
+        tiers: [
+            {
+                id: 'over-100k',
+                when: { kind: 'input-tokens-above', tokens: 100_000 },
+                inputPerMTok: 0.5,
+                outputPerMTok: 2.5,
+            },
+        ],
+        capability: 'small',
+        tier: 'haiku',
+        notes: 'Priced per request by prompt length: $0.10/$0.50 up to 100,000 input tokens, cache reads'
+            + ' and writes included, and $0.50/$2.50 over it.',
+    },
     {
         id: 'claude-haiku-4-5',
         // The dated form is the canonical API id and is what a real usage log
@@ -360,13 +464,199 @@ export const MODELS = [
     // ------------------------------------------------------------------------
     // OpenAI
     //
-    // Caching is AUTOMATIC above 1,024 tokens — there is no cache_control to set,
-    // and a cached read costs about half the input price rather than a tenth. The
-    // reordering advice is identical (a prefix is a prefix), the marker advice is
-    // not, which is why `caching` and `multipliers` exist at all.
+    // Caching is AUTOMATIC, with no cache_control to set, and a cached read costs
+    // a tenth of input on these three ($0.125 against $1.25). The reordering
+    // advice is identical (a prefix is a prefix), the marker advice is not, which
+    // is why `caching` and `multipliers` exist at all. The 1,024 minimum is the
+    // one OpenAI publishes for GPT-5.6 and later; for these older models its
+    // guide says the minimum "varies by request settings", so it is the nearest
+    // published floor, not a promise, and each row's note says so.
+    // ------------------------------------------------------------------------
+    // GPT-5.6 and later: OpenAI's current generation.
+    //
+    // The pricing page and each model's page, read 2026-10-10 and 2026-10-11,
+    // and the prompt-caching guide. Three things set them apart from GPT-5:
+    //
+    // - **A long-context band, per request.** "Prompts with more than 272K input
+    //   tokens are priced at 2x input and cache rates and 1.5x output for the
+    //   full request." 272,000, the GPT-5 era's own input limit; a tier.
+    // - **Cache writes are billed**, at 1.25x the uncached input rate, and the
+    //   usage object reports them (`cache_write_tokens`). Reads are 10% of input,
+    //   5% on GPT-6.1 Sol.
+    // - **An entry lives at least 30 minutes** after its last write or read, and
+    //   there is no longer one to buy: `cacheTtl`.
+    //
+    // Caching is implicit by default (a breakpoint at the end of the latest
+    // eligible message) from a 1,024-token minimum. Batch and Flex are half
+    // price; Fast, Ultrafast and regional processing are other service tiers
+    // and are not priced here. Every model: 1,050,000 context, 922,000 input at
+    // most, 128,000 output.
+    // ------------------------------------------------------------------------
+    {
+        id: 'gpt-6-astra',
+        provider: 'openai',
+        displayName: 'GPT-6 Astra',
+        inputPerMTok: 10,
+        outputPerMTok: 50,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 20,
+                outputPerMTok: 75,
+            },
+        ],
+        capability: 'frontier',
+        tier: 'frontier',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-6.1-sol',
+        provider: 'openai',
+        displayName: 'GPT-6.1 Sol',
+        inputPerMTok: 2,
+        outputPerMTok: 10,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.05, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 4,
+                outputPerMTok: 15,
+            },
+        ],
+        capability: 'large',
+        tier: 'opus',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-6-sol',
+        provider: 'openai',
+        displayName: 'GPT-6 Sol',
+        inputPerMTok: 2,
+        outputPerMTok: 10,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 4,
+                outputPerMTok: 15,
+            },
+        ],
+        capability: 'large',
+        tier: 'opus',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-6-luna',
+        provider: 'openai',
+        displayName: 'GPT-6 Luna',
+        inputPerMTok: 0.1,
+        outputPerMTok: 0.5,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 0.2,
+                outputPerMTok: 0.75,
+            },
+        ],
+        capability: 'small',
+        tier: 'haiku',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-5.6-sol',
+        provider: 'openai',
+        displayName: 'GPT-5.6 Sol',
+        inputPerMTok: 4,
+        outputPerMTok: 20,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 8,
+                outputPerMTok: 30,
+            },
+        ],
+        capability: 'large',
+        tier: 'opus',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-5.6-terra',
+        provider: 'openai',
+        displayName: 'GPT-5.6 Terra',
+        inputPerMTok: 2,
+        outputPerMTok: 12,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 4,
+                outputPerMTok: 18,
+            },
+        ],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: OPENAI_CURRENT_NOTE,
+    },
+    {
+        id: 'gpt-5.6-luna',
+        provider: 'openai',
+        displayName: 'GPT-5.6 Luna',
+        inputPerMTok: 0.2,
+        outputPerMTok: 1.2,
+        contextWindow: 1_050_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1.25, cacheWrite1h: 1.25, batch: 0.5 },
+        cacheTtl: OPENAI_CACHE_TTL,
+        tiers: [
+            {
+                id: 'over-272k',
+                when: { kind: 'input-tokens-above', tokens: 272_000 },
+                inputPerMTok: 0.4,
+                outputPerMTok: 1.8,
+            },
+        ],
+        capability: 'small',
+        tier: 'haiku',
+        notes: OPENAI_CURRENT_NOTE,
+    },
     // ------------------------------------------------------------------------
     {
         id: 'gpt-5',
+        aliases: ['gpt-5-2025-08-07'],
         provider: 'openai',
         displayName: 'GPT-5',
         inputPerMTok: 1.25,
@@ -377,10 +667,11 @@ export const MODELS = [
         multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'frontier',
         tier: 'frontier',
-        notes: 'Caching is automatic above 1,024 tokens; there is no cache_control to set.',
+        notes: OPENAI_GPT5_NOTE,
     },
     {
         id: 'gpt-5-mini',
+        aliases: ['gpt-5-mini-2025-08-07'],
         provider: 'openai',
         displayName: 'GPT-5 mini',
         inputPerMTok: 0.25,
@@ -391,9 +682,11 @@ export const MODELS = [
         multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'mid',
         tier: 'sonnet',
+        notes: OPENAI_GPT5_NOTE,
     },
     {
         id: 'gpt-5-nano',
+        aliases: ['gpt-5-nano-2025-08-07'],
         provider: 'openai',
         displayName: 'GPT-5 nano',
         inputPerMTok: 0.05,
@@ -404,6 +697,7 @@ export const MODELS = [
         multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'small',
         tier: 'haiku',
+        notes: OPENAI_GPT5_NOTE,
     },
     // ------------------------------------------------------------------------
     // Google
@@ -416,8 +710,9 @@ export const MODELS = [
         outputPerMTok: 10,
         contextWindow: 1_048_576,
         cacheMinTokens: 2048,
-        caching: 'explicit',
-        multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
+        caching: 'automatic',
+        /* $0.125 cached against $1.25 input for prompts up to 200k, read 2026-10-10. */
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         /* Refused on 2026-08-28: still in `GET /v1beta/models`, and a 404 to a request. */
         retired: {
             on: '2026-08-28',
@@ -425,7 +720,9 @@ export const MODELS = [
         },
         capability: 'large',
         tier: 'opus',
-        notes: 'Context caching is billed for storage per hour as well as per read.',
+        notes: 'Prompts over 200k tokens are billed $2.50 in and $15.00 out; this row prices every prompt at the up-to-200k rate,'
+            + ' because no log Trazum prices says how long each prompt was. Implicit caching is automatic; explicit caching is'
+            + ' also billed for storage per hour.',
     },
     {
         id: 'gemini-2.5-flash',
@@ -434,9 +731,10 @@ export const MODELS = [
         inputPerMTok: 0.3,
         outputPerMTok: 2.5,
         contextWindow: 1_048_576,
-        cacheMinTokens: 1024,
-        caching: 'explicit',
-        multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
+        cacheMinTokens: 2048,
+        caching: 'automatic',
+        /* $0.03 cached against $0.30 input (text), read 2026-10-10. */
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         /* Refused on 2026-08-28: still in `GET /v1beta/models`, and a 404 to a request. */
         retired: {
             on: '2026-08-28',
@@ -447,9 +745,10 @@ export const MODELS = [
     },
     {
         /*
-         * Google's own error message names this as the replacement for the two
-         * retired 2.5 models, and ai.google.dev/gemini-api/docs/pricing carries the
-         * rates, read 2026-08-28.
+         * Google's own error message names this as the replacement for the retired
+         * 2.5 Flash (the 2.5 Pro refusal names 3.1 Pro Preview), and
+         * ai.google.dev/gemini-api/docs/pricing carries the rates, read 2026-08-28
+         * and again on 2026-10-10.
          *
          * The introductory price has a published end date and a published successor,
          * which is exactly what `promo` is for and is the shape the catalogue nearly
@@ -463,8 +762,8 @@ export const MODELS = [
         outputPerMTok: 7.5,
         promo: { inputPerMTok: 0.75, outputPerMTok: 3.75, until: '2026-12-31' },
         contextWindow: 1_048_576,
-        cacheMinTokens: 1024,
-        caching: 'explicit',
+        cacheMinTokens: 4096,
+        caching: 'automatic',
         /*
          * $0.075 against $0.75 inside the introductory window, and $0.15 against
          * $1.50 after it: Google scales the cache price with the headline one, so
@@ -474,12 +773,143 @@ export const MODELS = [
         multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'mid',
         tier: 'sonnet',
-        notes: 'Context caching is billed for storage per hour as well as per read:'
+        notes: 'Implicit caching is automatic above 4,096 tokens. Explicit caching is also billed for storage:'
             + ' $0.50 per 1M tokens per hour through 2026-12-31, $1.00 after.',
     },
+    {
+        /*
+         * Gemini 3.8 Flash, from ai.google.dev/gemini-api/docs/pricing, its model
+         * page and docs/caching, read 2026-10-10. The same rates and the same
+         * introductory window as 3.6 Flash, published as one table each: $0.75
+         * and $3.75 through 2026-12-31, $1.50 and $7.50 from 2027-01-01, and the
+         * cache price scales with them ($0.075, then $0.15).
+         */
+        id: 'gemini-3.8-flash',
+        provider: 'google',
+        displayName: 'Gemini 3.8 Flash',
+        inputPerMTok: 1.5,
+        outputPerMTok: 7.5,
+        promo: { inputPerMTok: 0.75, outputPerMTok: 3.75, until: '2026-12-31' },
+        contextWindow: 1_048_576,
+        cacheMinTokens: 4096,
+        caching: 'automatic',
+        /* $0.075 / $0.75 = 0.1 (and $0.15 / $1.50); batch $0.375 / $0.75 = 0.5 (and $1.875 / $3.75). */
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: 'Implicit caching is automatic above 4,096 tokens. Explicit caching is also billed for storage:'
+            + ' $0.50 per 1M tokens per hour through 2026-12-31, $1.00 after.',
+    },
+    {
+        /*
+         * The pricing page, the model page and the caching page, read 2026-10-10
+         * and 2026-10-11. The model Google's own refusal of 2.5 Pro names as its
+         * replacement, and the second model here priced by prompt length: $2/$12
+         * for a prompt up to 200,000 tokens and $4/$18 over it, the cache at
+         * $0.20 and $0.40 (10% in both bands), batch $1/$6 and $2/$9 (half in
+         * both). 1,048,576 tokens in, 65,536 out, implicit caching from 4,096.
+         * The `-customtools` endpoint is "same as Gemini 3.1 Pro Preview pricing".
+         *
+         * A preview, and priced because a log carries it: Google's 2.5 Pro
+         * refusal sends every caller here.
+         */
+        id: 'gemini-3.1-pro-preview',
+        aliases: ['gemini-3.1-pro-preview-customtools'],
+        provider: 'google',
+        displayName: 'Gemini 3.1 Pro Preview',
+        inputPerMTok: 2,
+        outputPerMTok: 12,
+        contextWindow: 1_048_576,
+        cacheMinTokens: 4096,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
+        tiers: [
+            {
+                id: 'over-200k',
+                when: { kind: 'input-tokens-above', tokens: 200_000 },
+                inputPerMTok: 4,
+                outputPerMTok: 18,
+            },
+        ],
+        capability: 'large',
+        tier: 'opus',
+        notes: 'Priced per request by prompt length: $2/$12 up to 200,000 input tokens and $4/$18 over it.'
+            + ' Implicit caching is automatic above 4,096 tokens; explicit caching is also billed for storage,'
+            + ' $4.50 per 1M tokens per hour.',
+    },
     // ------------------------------------------------------------------------
     // Moonshot
     // ------------------------------------------------------------------------
+    /*
+     * platform.kimi.ai/docs/pricing/chat, models and pricing/batch, read in
+     * their Markdown form on 2026-10-11 (the HTML renders its tables in the
+     * browser, which is why the September review saw no context windows). K3
+     * bills cache writes as their own line, by TTL, like Anthropic: $3.00 for a
+     * 5-minute entry and $6.00 for an hour against a $3.00 input, and reads at
+     * $0.30. The K2 series bills no write, and reads at its own hit price. Batch
+     * is 60% of standard on K2.7 Code and K2.6 and not offered on K3 or the
+     * high-speed K2.7. No cache minimum is published for any of them.
+     */
+    {
+        id: 'kimi-k3',
+        provider: 'moonshot',
+        displayName: 'Kimi K3',
+        inputPerMTok: 3,
+        outputPerMTok: 15,
+        contextWindow: 1_048_576,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 2, batch: null },
+        capability: 'frontier',
+        tier: 'frontier',
+        notes: 'Cache writes are billed as their own line: 1x input for a 5-minute entry, 2x for an hour.'
+            + ` No batch API for this model. ${NO_PUBLISHED_CACHE_MINIMUM}`,
+    },
+    {
+        id: 'kimi-k2.7-code',
+        provider: 'moonshot',
+        displayName: 'Kimi K2.7 Code',
+        inputPerMTok: 0.95,
+        outputPerMTok: 4,
+        contextWindow: 262_144,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        /* $0.19 on a hit against $0.95; batch $0.57 / $2.40, 60%. */
+        multipliers: { cacheRead: 0.2, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.6 },
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'kimi-k2.7-code-highspeed',
+        provider: 'moonshot',
+        displayName: 'Kimi K2.7 Code (high speed)',
+        inputPerMTok: 1.9,
+        outputPerMTok: 8,
+        contextWindow: 262_144,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        /* $0.38 on a hit against $1.90; no batch API for this variant. */
+        multipliers: { cacheRead: 0.2, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'kimi-k2.6',
+        provider: 'moonshot',
+        displayName: 'Kimi K2.6',
+        inputPerMTok: 0.95,
+        outputPerMTok: 4,
+        contextWindow: 262_144,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        /* $0.16 on a hit against $0.95, written as the ratio so the product is the page's figure. */
+        multipliers: { cacheRead: 0.16 / 0.95, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.6 },
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
     {
         id: 'kimi-k2',
         provider: 'moonshot',
@@ -487,13 +917,22 @@ export const MODELS = [
         inputPerMTok: 0.6,
         outputPerMTok: 2.5,
         contextWindow: 256_000,
-        cacheMinTokens: 1024,
+        cacheMinTokens: null,
         caching: 'automatic',
         multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        /*
+         * Discontinued: "The kimi-k2 series models were officially discontinued
+         * on May 25, 2026" (the provider's model list, read 2026-10-11). Kept at
+         * its last published price, because calls in somebody's log really
+         * happened at it, and never offered as somewhere to move. Not `retired`,
+         * which records the provider refusing a request, and no key was here to
+         * send one.
+         */
+        recommendable: false,
         capability: 'mid',
         tier: 'sonnet',
-        notes: 'No batch API: the batch advisory stays quiet rather than offering a discount you cannot buy.'
-            + ' Not on the provider\'s pricing page as of 2026-09-12, which lists kimi-k3 and kimi-k2.6 instead; the price is the last one published for it.',
+        notes: 'Discontinued by Moonshot on 2026-05-25; priced at the last rate it published. No batch API.'
+            + ` ${NO_PUBLISHED_CACHE_MINIMUM}`,
     },
     // ------------------------------------------------------------------------
     // DeepSeek
@@ -518,34 +957,95 @@ export const MODELS = [
     },
     {
         /*
-         * DeepSeek V4 Flash, from api-docs.deepseek.com/quick_start/pricing, read
-         * 2026-08-28. It replaced `deepseek-v3`, which the API now refuses.
+         * DeepSeek V4 Flash, retired on 2026-09-10. The pricing page (read
+         * 2026-10-10) says the id "is still accepted ... served by the
+         * DeepSeek-V4.1-Flash model and billed at the Flash price", so from
+         * 04:00 UTC that day it carries deepseek-flash's rates. Before that
+         * instant it billed at its own, read off the same page on 2026-08-28:
+         * $0.22/$0.66 off-peak, double at peak, $0.007 a cache hit.
          *
          * The base rate is off-peak because off-peak is the common case: peak is
          * 01:00-04:00 and 06:00-10:00 UTC on weekdays, which is 35 hours of 168.
-         * The peak tier is exactly double, published as such.
+         * The peak tier is exactly double, published as such. Clock pricing began
+         * at 16:00 UTC on 2026-08-16; the flat price before it is on no page this
+         * table can read, so calls before then are priced as the first period.
+         *
+         * Not recommendable: a legacy id DeepSeek routes "temporarily". Without
+         * this, a tie on price would offer it ahead of deepseek-flash.
          */
         id: 'deepseek-v4-flash',
         provider: 'deepseek',
         displayName: 'DeepSeek V4 Flash',
-        inputPerMTok: 0.22,
-        outputPerMTok: 0.66,
+        recommendable: false,
+        inputPerMTok: 0.15,
+        outputPerMTok: 0.6,
         tiers: [
             {
                 id: 'peak',
                 when: { kind: 'utc-hours', hours: [1, 2, 3, 6, 7, 8, 9], weekdaysOnly: true },
-                inputPerMTok: 0.44,
-                outputPerMTok: 1.32,
+                inputPerMTok: 0.3,
+                outputPerMTok: 1.2,
+            },
+        ],
+        history: [
+            {
+                until: '2026-09-10T04:00:00Z',
+                inputPerMTok: 0.22,
+                outputPerMTok: 0.66,
+                tiers: [
+                    {
+                        id: 'peak',
+                        when: { kind: 'utc-hours', hours: [1, 2, 3, 6, 7, 8, 9], weekdaysOnly: true },
+                        inputPerMTok: 0.44,
+                        outputPerMTok: 1.32,
+                    },
+                ],
+                /* $0.007 cache hit against $0.22 input off-peak. */
+                multipliers: { cacheRead: 0.0318, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
             },
         ],
         contextWindow: 1_000_000,
         cacheMinTokens: 1024,
         caching: 'automatic',
-        /* $0.007 cache hit against $0.22 input off-peak. */
-        multipliers: { cacheRead: 0.0318, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        /* $0.003 cache hit against $0.15 input off-peak, $0.006 against $0.30 at peak. */
+        multipliers: { cacheRead: 0.02, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
         capability: 'mid',
         tier: 'sonnet',
-        notes: 'Maximum output 384K tokens.',
+        notes: 'Retired 2026-09-10: the id is still accepted, served by V4.1 Flash and billed at the deepseek-flash price.'
+            + ' Maximum output 384K tokens. Peak excludes Chinese public holidays, which this table cannot express.',
+    },
+    {
+        /*
+         * DeepSeek V4.1 Flash, from api-docs.deepseek.com/quick_start/pricing,
+         * read 2026-10-10. Released 2026-09-10; its price took effect at 04:00
+         * UTC that day. Off-peak is the base and peak is exactly double, as
+         * published; the cache hit is 2% of input at both ($0.003 and $0.006).
+         *
+         * The cache minimum is carried from deepseek-v4-flash: DeepSeek's pages
+         * publish none for this generation, and 1,024 is the figure the earlier
+         * row was reviewed with.
+         */
+        id: 'deepseek-flash',
+        provider: 'deepseek',
+        displayName: 'DeepSeek V4.1 Flash',
+        inputPerMTok: 0.15,
+        outputPerMTok: 0.6,
+        tiers: [
+            {
+                id: 'peak',
+                when: { kind: 'utc-hours', hours: [1, 2, 3, 6, 7, 8, 9], weekdaysOnly: true },
+                inputPerMTok: 0.3,
+                outputPerMTok: 1.2,
+            },
+        ],
+        contextWindow: 1_000_000,
+        cacheMinTokens: 1024,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.02, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: 'Maximum output 384K tokens. Peak excludes Chinese public holidays, which this table cannot express:'
+            + ' on a weekday holiday it charges peak where DeepSeek charges off-peak.',
     },
     {
         /* Same page, same clock. Pro is three times Flash at both ends. */
@@ -574,19 +1074,174 @@ export const MODELS = [
     // ------------------------------------------------------------------------
     // xAI
     // ------------------------------------------------------------------------
+    /*
+     * docs.x.ai/developers/models and each model's page, read in their
+     * Markdown form on 2026-10-11. Every text model has two rates: "requests
+     * whose prompt reaches 200k tokens are billed at the higher rate for all
+     * tokens in the request", which is a size tier at 200,000 inclusive and is
+     * priced per request. Cached input scales with the band; writes are not
+     * billed; batch is a 20% discount where the model's page offers it at all.
+     * No cache minimum is published. Aliases are the stable family names the
+     * pages list, never the `-latest` names, which move.
+     */
+    {
+        id: 'grok-4.7',
+        provider: 'xai',
+        displayName: 'Grok 4.7',
+        inputPerMTok: 2,
+        outputPerMTok: 6,
+        contextWindow: 500_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        tiers: [GROK_LONG(4, 12)],
+        capability: 'frontier',
+        tier: 'frontier',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-4.6',
+        provider: 'xai',
+        displayName: 'Grok 4.6',
+        inputPerMTok: 2,
+        outputPerMTok: 6,
+        contextWindow: 500_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        tiers: [GROK_LONG(4, 12)],
+        capability: 'large',
+        tier: 'opus',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-4.5',
+        provider: 'xai',
+        displayName: 'Grok 4.5',
+        inputPerMTok: 2,
+        outputPerMTok: 6,
+        contextWindow: 500_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        /* $0.30 cached against $2.00. */
+        multipliers: { cacheRead: 0.15, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        tiers: [GROK_LONG(4, 12)],
+        capability: 'large',
+        tier: 'opus',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-4.3',
+        provider: 'xai',
+        displayName: 'Grok 4.3',
+        inputPerMTok: 1.25,
+        outputPerMTok: 2.5,
+        contextWindow: 1_000_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        /* $0.20 cached against $1.25; batch 20% off. */
+        multipliers: { cacheRead: 0.16, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.8 },
+        tiers: [GROK_LONG(2.5, 5)],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-4.20-0309-reasoning',
+        aliases: ['grok-4.20', 'grok-4.20-reasoning', 'grok-4.20-0309'],
+        provider: 'xai',
+        displayName: 'Grok 4.20 (reasoning)',
+        inputPerMTok: 1.25,
+        outputPerMTok: 2.5,
+        contextWindow: 1_000_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.16, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.8 },
+        tiers: [GROK_LONG(2.5, 5)],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
     {
+        id: 'grok-4.20-0309-non-reasoning',
+        aliases: ['grok-4.20-non-reasoning'],
+        provider: 'xai',
+        displayName: 'Grok 4.20 (non-reasoning)',
+        inputPerMTok: 1.25,
+        outputPerMTok: 2.5,
+        contextWindow: 1_000_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.16, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.8 },
+        tiers: [GROK_LONG(2.5, 5)],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-4.20-multi-agent-0309',
+        aliases: ['grok-4.20-multi-agent'],
+        provider: 'xai',
+        displayName: 'Grok 4.20 Multi-Agent',
+        inputPerMTok: 1.25,
+        outputPerMTok: 2.5,
+        contextWindow: 1_000_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.16, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.8 },
+        tiers: [GROK_LONG(2.5, 5)],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        id: 'grok-build-0.1',
+        provider: 'xai',
+        displayName: 'Grok Build 0.1',
+        inputPerMTok: 1,
+        outputPerMTok: 2,
+        contextWindow: 256_000,
+        cacheMinTokens: null,
+        caching: 'automatic',
+        multipliers: { cacheRead: 0.2, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        tiers: [GROK_LONG(2, 4)],
+        capability: 'mid',
+        tier: 'sonnet',
+        notes: NO_PUBLISHED_CACHE_MINIMUM,
+    },
+    {
+        /*
+         * Retired on 2026-05-15 at 12:00 PT (19:00 UTC), and billed since at
+         * Grok 4.3's prices: "requests to the retired model slugs above will
+         * automatically redirect to grok-4.3 ... you will be billed at grok-4.3
+         * pricing" (xAI's retirement notice, read 2026-10-11). So the id has two
+         * periods, and a log that spans the date is billed both ways, at the
+         * instant xAI gave. `grok-4-0709` is the dated id the notice names.
+         */
         id: 'grok-4',
+        aliases: ['grok-4-0709'],
         provider: 'xai',
         displayName: 'Grok 4',
-        inputPerMTok: 3,
-        outputPerMTok: 15,
+        inputPerMTok: 1.25,
+        outputPerMTok: 2.5,
         contextWindow: 256_000,
-        cacheMinTokens: 1024,
+        cacheMinTokens: null,
         caching: 'automatic',
-        multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        multipliers: { cacheRead: 0.16, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+        tiers: [GROK_LONG(2.5, 5)],
+        history: [
+            {
+                until: '2026-05-15T19:00:00Z',
+                inputPerMTok: 3,
+                outputPerMTok: 15,
+                multipliers: { cacheRead: 0.25, cacheWrite5m: 1, cacheWrite1h: 1, batch: null },
+            },
+        ],
+        recommendable: false,
         capability: 'large',
         tier: 'opus',
-        notes: 'Not on the provider\'s model page as of 2026-09-12, which lists grok-4.6 and later instead; the price is the last one published for it.',
+        notes: 'Retired by xAI on 2026-05-15 and redirected to Grok 4.3, whose price it bills at from then;'
+            + ` $3/$15 before. ${NO_PUBLISHED_CACHE_MINIMUM}`,
     },
     // ------------------------------------------------------------------------
     // Mistral
@@ -634,12 +1289,12 @@ export const MODELS = [
         inputPerMTok: 0.5,
         outputPerMTok: 1.5,
         contextWindow: 262_144,
-        cacheMinTokens: 0,
-        caching: 'none',
-        multipliers: { batch: 0.5 },
+        cacheMinTokens: null,
+        caching: 'unknown',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'large',
         tier: 'opus',
-        notes: 'No prompt caching: reordering still helps readability but saves nothing here.',
+        notes: MISTRAL_CACHE_NOTE,
     },
     {
         /*
@@ -662,11 +1317,12 @@ export const MODELS = [
         inputPerMTok: 1.5,
         outputPerMTok: 7.5,
         contextWindow: 262_144,
-        cacheMinTokens: 0,
-        caching: 'none',
-        multipliers: { batch: 0.5 },
+        cacheMinTokens: null,
+        caching: 'unknown',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'mid',
         tier: 'sonnet',
+        notes: MISTRAL_CACHE_NOTE,
     },
     {
         /* Same page, same day. `mistral-small-2603` is what the API reports. */
@@ -677,11 +1333,12 @@ export const MODELS = [
         inputPerMTok: 0.15,
         outputPerMTok: 0.6,
         contextWindow: 262_144,
-        cacheMinTokens: 0,
-        caching: 'none',
-        multipliers: { batch: 0.5 },
+        cacheMinTokens: null,
+        caching: 'unknown',
+        multipliers: { cacheRead: 0.1, cacheWrite5m: 1, cacheWrite1h: 1, batch: 0.5 },
         capability: 'small',
         tier: 'haiku',
+        notes: MISTRAL_CACHE_NOTE,
     },
 ];
 export const DEFAULT_MODEL = 'claude-opus-5';
@@ -772,6 +1429,41 @@ export function listModels() {
     return [...MODELS];
 }
 const pricingMemo = new WeakMap();
+/**
+ * The row as it stood at `on`: itself when the current price applies, or a
+ * frozen copy carrying the period's rates, tiers and ratios. Built once per
+ * period, so a log of a million calls does not build a million rows.
+ */
+const periodMemo = new WeakMap();
+function pricedAt(model, on) {
+    const history = model.history;
+    if (history === undefined || history.length === 0)
+        return model;
+    let periods = periodMemo.get(model);
+    if (periods === undefined) {
+        periods = history.map((period) => {
+            const { history: _history, promo: _promo, tiers: _tiers, multipliers: _multipliers, ...rest } = model;
+            const row = Object.freeze({
+                ...rest,
+                inputPerMTok: period.inputPerMTok,
+                outputPerMTok: period.outputPerMTok,
+                ...(period.tiers !== undefined ? { tiers: period.tiers } : {}),
+                ...(period.multipliers !== undefined
+                    ? { multipliers: period.multipliers }
+                    : model.multipliers !== undefined
+                        ? { multipliers: model.multipliers }
+                        : {}),
+            });
+            return { untilMs: new Date(period.until).getTime(), row };
+        });
+        periodMemo.set(model, periods);
+    }
+    const at = on.getTime();
+    for (const period of periods)
+        if (at < period.untilMs)
+            return period.row;
+    return model;
+}
 /** The two unconditional answers for one model, parsed once. */
 function cache(model) {
     const entry = {
@@ -801,16 +1493,20 @@ function cache(model) {
  * because "this does not apply" and "nobody said" lead to different reports and
  * collapsing them is the oldest mistake in this repository.
  */
-function holds(when, on, inputTokens) {
+function holds(when, on, size) {
     if (when.kind === 'utc-hours') {
         const day = on.getUTCDay();
         if (when.weekdaysOnly && (day === 0 || day === 6))
             return false;
         return when.hours.includes(on.getUTCHours());
     }
-    if (inputTokens === undefined)
-        return null;
-    return inputTokens > when.tokens;
+    const over = (tokens) => when.kind === 'input-tokens-at-least' ? tokens >= when.tokens : tokens > when.tokens;
+    if (size.inputTokens !== undefined)
+        return over(size.inputTokens);
+    // A whole row under the line puts every request in it under the line.
+    if (size.inputTokensAtMost !== undefined && !over(size.inputTokensAtMost))
+        return false;
+    return null;
 }
 /**
  * What one call is billed at, and what decided it.
@@ -829,6 +1525,12 @@ function holds(when, on, inputTokens) {
  * `pricing.test.js` fails a tiered model whose report drops it.
  */
 export function effectivePricing(model, on = new Date(), context = {}) {
+    /* A call before a published price change is priced as it was billed then. */
+    if (model.history !== undefined) {
+        const period = pricedAt(model, on);
+        if (period !== model)
+            return effectivePricing(period, on, context);
+    }
     const memo = pricingMemo.get(model) ?? cache(model);
     /**
      * Tiers first, and a promotion never runs on top of one.
@@ -841,7 +1543,7 @@ export function effectivePricing(model, on = new Date(), context = {}) {
     if (model.tiers !== undefined && model.tiers.length > 0) {
         const undecided = [];
         for (const tier of model.tiers) {
-            const verdict = holds(tier.when, on, context.inputTokens);
+            const verdict = holds(tier.when, on, context);
             if (verdict === true) {
                 return {
                     inputPerMTok: tier.inputPerMTok,
@@ -861,6 +1563,11 @@ export function effectivePricing(model, on = new Date(), context = {}) {
         }
         /* The dearest candidate, so the figure is a ceiling rather than a wish. */
         const dearest = undecided.reduce((worst, tier) => tier.inputPerMTok > worst.inputPerMTok ? tier : worst);
+        /*
+         * And the cheapest, which is the base: every undecided condition might not
+         * hold, and a tier is never below the base (`pricing-tiers.test.js`).
+         */
+        const floor = { inputPerMTok: model.inputPerMTok, outputPerMTok: model.outputPerMTok };
         const ceiling = dearest.inputPerMTok > model.inputPerMTok
             ? {
                 inputPerMTok: dearest.inputPerMTok,
@@ -879,7 +1586,10 @@ export function effectivePricing(model, on = new Date(), context = {}) {
             tier: {
                 applied: ceiling.applied,
                 decided: false,
-                because: `${describe(dearest.when)}, and the token count was not given`,
+                because: context.inputTokensAtMost !== undefined
+                    ? `${describe(dearest.when)}, and this row sums requests without giving any one prompt's length`
+                    : `${describe(dearest.when)}, and the token count was not given`,
+                floor,
             },
         };
     }
@@ -892,6 +1602,9 @@ function describe(when) {
     if (when.kind === 'input-tokens-above') {
         return `prompts over ${when.tokens.toLocaleString('en-US')} input tokens`;
     }
+    if (when.kind === 'input-tokens-at-least') {
+        return `prompts of ${when.tokens.toLocaleString('en-US')} input tokens or more`;
+    }
     const windows = [];
     let start = null;
     const sorted = [...when.hours].sort((a, b) => a - b);