@trazum/core 2.4.3 → 2.5.1

package/src/pricing.ts

@@ -32,9 +32,9 @@ import type { ModelPricing, PricingTier, TierCondition } from './types.js';
 export const PROVIDER_REVIEWED: Readonly<Record<string, string>> = 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',
   /*
@@ -54,9 +54,9 @@ export const PROVIDER_REVIEWED: Readonly<Record<string, string>> = Object.freeze
    * 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) is on the same
-   * page and not added: every one of them doubles its rates for prompts over
-   * 272K tokens, a per-request condition no log Trazum prices passes yet.
+   * 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',
   /*
@@ -66,24 +66,20 @@ export const PROVIDER_REVIEWED: Readonly<Record<string, string>> = Object.freeze
    * 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. Gemini 3.1 Pro
-   * Preview and 2.5 Pro's prompts over 200k are priced by prompt length per
-   * request, which nothing that prices a log passes yet, so the first is left
-   * out and the second's tier is named in its note rather than guessed.
+   * 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.
    */
   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',
+  moonshot: '2026-10-11',
   /*
    * api-docs.deepseek.com/quick_start/pricing read 2026-10-10, and the
    * 2026-09-10 announcement (api-docs.deepseek.com/news/news260910) read
@@ -94,15 +90,14 @@ export const PROVIDER_REVIEWED: Readonly<Record<string, string>> = Object.freeze
    */
   deepseek: '2026-10-10',
   /*
-   * 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.
+   * 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-09-12',
+  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
@@ -194,6 +189,14 @@ export function multipliersFor(model: ModelPricing, on?: Date): {
   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: ModelPricing): { writeMs: number; longerMs: number | null } {
+  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
@@ -202,6 +205,32 @@ export function multipliersFor(model: ModelPricing, on?: Date): {
  * 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: number, outputPerMTok: number): PricingTier => ({
+  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'
@@ -408,18 +437,45 @@ export const MODELS: ModelPricing[] = [
     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
@@ -447,6 +503,189 @@ export const MODELS: ModelPricing[] = [
   // 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',
@@ -601,10 +840,119 @@ export const MODELS: ModelPricing[] = [
       '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',
@@ -612,14 +960,23 @@ export const MODELS: ModelPricing[] = [
     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.',
+      'Discontinued by Moonshot on 2026-05-25; priced at the last rate it published. No batch API.'
+      + ` ${NO_PUBLISHED_CACHE_MINIMUM}`,
   },
 
   // ------------------------------------------------------------------------
@@ -766,20 +1123,175 @@ export const MODELS: ModelPricing[] = [
   // ------------------------------------------------------------------------
   // 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.',
+      '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}`,
   },
 
   // ------------------------------------------------------------------------
@@ -1035,7 +1547,38 @@ interface Rates {
   inputPerMTok: number;
   outputPerMTok: number;
   promoApplied: boolean;
-  tier: { applied: string | null; decided: boolean; because: string } | null;
+  tier: {
+    applied: string | null;
+    decided: boolean;
+    because: string;
+    /**
+     * The cheapest rate the undecided condition allows, present only when it
+     * was not decided. The figure above is the ceiling and stays the one
+     * billed; this is the other end, so a report can say how wide the
+     * uncertainty is instead of only that there is some.
+     */
+    floor?: { inputPerMTok: number; outputPerMTok: number };
+  } | null;
+}
+
+/**
+ * What is known about the size of the prompt being priced.
+ *
+ * `inputTokens` is one request's prompt, every input token it carried, cache
+ * reads and writes included, and decides a size tier outright.
+ *
+ * `inputTokensAtMost` is a bound, for a row that sums requests: a usage
+ * report's hourly or daily bucket, an export's per-day line. No single
+ * request in it can be larger than the whole row, so a row whose total is at
+ * or under a threshold proves every request in it was under, and that decides
+ * the tier. A row over the threshold proves nothing about any one request,
+ * and the tier stays undecided. The bound is never treated as a size: a day of
+ * 2,000 short prompts sums past 100,000 tokens without a single request
+ * getting near it.
+ */
+export interface PromptSize {
+  inputTokens?: number;
+  inputTokensAtMost?: number;
 }
 
 const pricingMemo = new WeakMap<
@@ -1111,18 +1654,18 @@ function cache(model: ModelPricing): {
  * 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: TierCondition,
-  on: Date,
-  inputTokens: number | undefined,
-): boolean | null {
+function holds(when: TierCondition, on: Date, size: PromptSize): boolean | null {
   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: number): boolean =>
+    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;
 }
 
 /**
@@ -1144,7 +1687,7 @@ function holds(
 export function effectivePricing(
   model: ModelPricing,
   on: Date = new Date(),
-  context: { inputTokens?: number } = {},
+  context: PromptSize = {},
 ): Rates {
   /* A call before a published price change is priced as it was billed then. */
   if (model.history !== undefined) {
@@ -1164,7 +1707,7 @@ export function effectivePricing(
   if (model.tiers !== undefined && model.tiers.length > 0) {
     const undecided: PricingTier[] = [];
     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,
@@ -1187,6 +1730,11 @@ export function effectivePricing(
     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
         ? {
@@ -1206,7 +1754,11 @@ export function effectivePricing(
       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,
       },
     };
   }
@@ -1220,6 +1772,9 @@ function describe(when: TierCondition): string {
   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);