@molecule/api-resource-ai-models 1.1.0 → 1.2.0

package/README.md

@@ -3,7 +3,7 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-08-12T22:38:26.212Z
+Generated: 2026-08-13T22:10:11.926Z
 -->
 
 # @molecule/api-resource-ai-models
@@ -260,6 +260,57 @@ interface ModelDefinition {
     windows: { startMinuteUtc: number; endMinuteUtc: number }[]
     multiplier: number
   }
+  /**
+   * A price change the provider has ANNOUNCED with a dated effective instant,
+   * staged ahead of time. Until `effectiveFrom` the model bills at the base
+   * rates above; from that instant on, these rates replace them.
+   *
+   * This exists because the freshness gate can only ever see prices that are
+   * ALREADY live: it diffs the catalog against models.dev's *current* rates, so
+   * a change announced today and effective in three days is invisible to it
+   * until after it lands — and the cron runs every 8h, so the catalog would
+   * under-meter for up to a third of a day at whatever the new rate is. Landing
+   * the new numbers early is not an option either: that over-bills every turn
+   * until the switch (the exact mistake the removed DeepSeek peak windows made
+   * for weeks against the free-tier default model). Staging with a timestamp is
+   * the only form that is correct on BOTH sides of the instant, and it needs no
+   * one awake at the switch.
+   *
+   * Applies to the BASE rates only — a `regionPricing` entry is a different
+   * host's rate card (a US re-host does not reprice because the native provider
+   * did) and is never touched by a scheduled change.
+   *
+   * `peakPricing` here, when declared, replaces the model's peak windows from
+   * the same instant; when omitted, the model's existing windows carry through
+   * unchanged. To schedule the END of peak pricing, declare an explicit
+   * `{ windows: [], multiplier: 1 }`.
+   *
+   * Resolution is `effectiveBaseRates()` / `effectivePeakPricing()`, and every
+   * consumer reaches it through `modelRegionRates()` / `priceMultiplierAt()` /
+   * the `withEffectivePricing()` projection the list handler serves — so a
+   * scheduled change lands everywhere at once with no follow-up edit. Once the
+   * instant has passed, fold the rates into the base fields and delete this
+   * (the freshness gate now verifies them against models.dev normally).
+   */
+  scheduledPricing?: {
+    /** ISO-8601 UTC instant the new rates take effect. */
+    effectiveFrom: string
+    /** Input price per million *uncached* tokens in USD, from `effectiveFrom`. */
+    inputPricePerMTok: number
+    /** Output price per million tokens in USD, from `effectiveFrom`. */
+    outputPricePerMTok: number
+    /** Prompt-cache *read* price per million tokens in USD, from `effectiveFrom`. */
+    cacheReadPricePerMTok: number
+    /** Prompt-cache *write* price per million tokens in USD, from `effectiveFrom`. */
+    cacheWritePricePerMTok: number
+    /** Peak-hour pricing from `effectiveFrom` (omitted → existing windows carry through). */
+    peakPricing?: {
+      windows: { startMinuteUtc: number; endMinuteUtc: number }[]
+      multiplier: number
+    }
+    /** Where the change was announced, for the re-verify pass after it lands. */
+    source?: string
+  }
   /**
    * Fast-mode ("priority speed") pricing — the per-MTok rates billed when a
    * request runs with the provider's fast/priority tier (e.g. Anthropic's
@@ -431,6 +482,25 @@ type EffortLevel = string
 
 ### Functions
 
+#### `effectiveBaseRates(modelDef, at)`
+
+A model's BASE token rates in effect at a given instant — the staged
+{@link ModelDefinition.scheduledPricing} rates once their `effectiveFrom` has
+passed, else the base fields.
+
+These are the native provider's rates. A `regionPricing` override is a
+different host's rate card and is resolved separately by
+{@link modelRegionRates}.
+
+```typescript
+function effectiveBaseRates(modelDef: ModelDefinition, at?: Date): ModelTokenRates
+```
+
+- `modelDef` — The model definition.
+- `at` — The instant to price at (defaults to now).
+
+**Returns:** The base rates in effect at that instant.
+
 #### `effectiveModelRegion(modelDef, requested)`
 
 Resolve a model's effective processing region: the requested region when the
@@ -448,6 +518,25 @@ function effectiveModelRegion(modelDef: ModelDefinition | undefined, requested?:
 
 **Returns:** The effective region code.
 
+#### `effectivePeakPricing(modelDef, at)`
+
+A model's peak-hour pricing in effect at a given instant: the staged
+{@link ModelDefinition.scheduledPricing} `peakPricing` once its
+`effectiveFrom` has passed (when that entry declares one — an omitted one
+leaves the existing windows in force), else the model's own `peakPricing`.
+
+```typescript
+function effectivePeakPricing(
+  modelDef: ModelDefinition,
+  at?: Date,
+): { windows: { startMinuteUtc: number; endMinuteUtc: number }[]; multiplier: number } | undefined
+```
+
+- `modelDef` — The model definition.
+- `at` — The instant to evaluate (defaults to now).
+
+**Returns:** The peak-pricing config in effect, or `undefined` when none is.
+
 #### `getAvailableModels(availableProviders)`
 
 Get models that are currently usable — filtered to only providers that are available.
@@ -527,41 +616,58 @@ function list(_req: MoleculeRequest, res: MoleculeResponse): Promise<void>
 - `_req` — The request object (unused).
 - `res` — The response object.
 
-#### `modelRegionRates(modelDef, requested)`
+#### `modelRegionRates(modelDef, requested, at)`
 
 The token rates for a model in a given processing region: the model's
 {@link ModelDefinition.regionPricing} override for the region when one
-exists, else the base rates (the native provider's list prices). Omitted
-cache fields in an override fall back to the override's input price (hosts
-with no cache discount / no write premium). The region is resolved via
-{@link effectiveModelRegion}, so callers may pass the raw user choice.
+exists, else the base rates in effect at `at` (the native provider's list
+prices, including any staged {@link ModelDefinition.scheduledPricing} change
+that has landed). Omitted cache fields in an override fall back to the
+override's input price (hosts with no cache discount / no write premium). The
+region is resolved via {@link effectiveModelRegion}, so callers may pass the
+raw user choice.
+
+`at` defaults to NOW rather than being required, so an existing caller cannot
+keep billing a superseded rate by omitting it — metering should still pass
+each request's own timestamp, the same way it must for
+{@link priceMultiplierAt}.
 
 ```typescript
-function modelRegionRates(modelDef: ModelDefinition, requested?: string): ModelTokenRates
+function modelRegionRates(modelDef: ModelDefinition, requested?: string, at?: Date): ModelTokenRates
 ```
 
 - `modelDef` — The model definition.
 - `requested` — The user's per-model region choice, if any.
+- `at` — The instant to price at (defaults to now).
 
 **Returns:** The region-effective rates.
 
-#### `priceMultiplierAt(modelDef, at)`
+#### `priceMultiplierAt(modelDef, at, region)`
 
-The price multiplier in effect for a model at a given instant.
+The price multiplier in effect for a model at a given instant, in a region.
 
 Consults the model's {@link ModelDefinition.peakPricing} windows (UTC,
 half-open, may wrap midnight). Metering MUST call this with each request's
 own timestamp so peak-hour usage bills at the provider's real rate — pricing
 everything at the flat rate silently under-meters peak traffic.
 
+Peak windows belong to the NATIVE provider, so they apply only where the base
+rates do. A region with a {@link ModelDefinition.regionPricing} override is a
+different host billing its own complete rate card, including whether it has
+time-of-day pricing at all — and re-hosts generally do not. Applying the
+native provider's surcharge on top of a re-host's flat rates would over-bill
+every turn in its windows (DeepSeek's 2× Beijing-hours pricing charged
+against DeepInfra, which has no peak pricing).
+
 ```typescript
-function priceMultiplierAt(modelDef: ModelDefinition | undefined, at: Date): number
+function priceMultiplierAt(modelDef: ModelDefinition | undefined, at: Date, region?: string): number
 ```
 
 - `modelDef` — The model definition (or undefined).
 - `at` — The instant the request was made.
+- `region` — The user's per-model region choice, if any (omitted → the model's default region).
 
-**Returns:** The multiplier (`1` outside peak windows or when none are declared).
+**Returns:** The multiplier (`1` outside peak windows, when none are declared, or in a region that prices off its own override).
 
 #### `resolveSelectableModelId(id)`
 
@@ -579,6 +685,27 @@ function resolveSelectableModelId(id: string): string | undefined
 
 **Returns:** The selectable successor's id, the id itself when it is already selectable, or `undefined` for an unknown or `disabled` model (nothing to forward to).
 
+#### `withEffectivePricing(modelDef, at)`
+
+A model projected onto the pricing in effect at a given instant: the staged
+{@link ModelDefinition.scheduledPricing} rates folded into the base fields
+(and its peak windows into `peakPricing`) once effective, with the staged
+entry stripped.
+
+This is what the `GET /ai/models` handler serves, so a client renders the
+rates that are actually billing right now without needing to resolve a
+schedule against its own clock — the server's clock is the only one that
+decides when a price change lands.
+
+```typescript
+function withEffectivePricing(modelDef: ModelDefinition, at?: Date): ModelDefinition
+```
+
+- `modelDef` — The model definition.
+- `at` — The instant to project at (defaults to now).
+
+**Returns:** The model with effective pricing and no `scheduledPricing`.
+
 ### Constants
 
 #### `MODEL_IDS`
@@ -650,15 +777,24 @@ Sources (verified 2026-07-28; OpenAI re-verified 2026-07-31 after the
   2026-07-21 $1.50/$7.50 supersedes 3.5-flash as the agentic flagship;
   gemini-3.1-pro-preview still the pro tier — "3.5 Pro" has NOT shipped as
   of 2026-07-28 despite the coming-soon badge; do not add until it has an id)
+  (re-verified 2026-08-13: gemini-3.7-flash "New Stable" — supersedes
+  3.6-flash as the flash flagship at the SAME list price ($1.50/$7.50, cache
+  read $0.15), with a launch promo ($0.75/$3.75, cache read $0.075) through
+  2026-12-31 billed here at list; specs from /docs/models/gemini-3.7-flash:
+  1M ctx / 65,536 out, thinking low|medium|high (no minimal), vision, tools,
+  caching, search grounding, code execution, url context)
 - xAI: https://docs.x.ai/developers/models + /developers/grok-4-5
   (grok-4.5 flagship 2026-07-08: $2/$6, 500K ctx, ≥200K prompts bill 2× —
   not modeled; reasoning_effort low|medium|high default high, image input;
   grok-4.3 still served at $1.25/$2.50 with the bigger 1M window;
   grok-code-fast-1 no longer listed — retires 2026-08-15)
-- DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (unchanged V4
-  Pro/Flash pricing; legacy deepseek-chat/-reasoner ids fully retired
-  2026-07-24 — never in this catalog; the announced peak-hour 2× surcharge is
-  still NOT active as of 2026-07-28, see the entries)
+- DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (verified
+  2026-08-14; legacy deepseek-chat/-reasoner ids fully retired 2026-07-24 —
+  never in this catalog. V4-Pro GA on 2026-08-13 came with a price RISE
+  effective 2026-08-16T16:00Z plus the long-announced peak-hour 2×: both
+  entries carry it as `scheduledPricing`, so today's rates bill until that
+  instant and the new ones after. Re-verify weekday-vs-daily peak windows and
+  the CN/US region default once it lands — see the entries.)
 - Moonshot: https://platform.kimi.ai/docs/models + DeepInfra's model API for
   the US re-host (kimi-k3 flagship 2026-07-16
   — 2.8T MoE, 1M ctx, $3/$15 — NOT added: thinking is forced-on with

package/dist/handlers/list.d.ts

@@ -5,7 +5,14 @@
  * bonded under the `'ai'` category AND are selectable — neither `disabled` (a
  * model the provider retired) nor superseded by a newer generation of the same
  * family, so the picker offers exactly one generation per family. Both kinds
- * stay priceable via `getModel`. No further projection is applied — every
+ * stay priceable via `getModel`.
+ *
+ * The one projection applied is `withEffectivePricing`: a model carrying a
+ * staged `scheduledPricing` change is served at whichever rates are billing at
+ * request time, with the schedule stripped. The server's clock decides when an
+ * announced price change lands, so a client never renders a rate that is not
+ * yet in force (nor keeps rendering one that has been superseded), and no
+ * client needs to know that scheduled pricing exists. Every other
  * `ModelDefinition` field is fine to expose to authenticated clients today.
  *
  * Secure-by-default: this handler enforces authentication IN the handler

package/dist/handlers/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAM/E;;;;;;;;;;;GAWG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CActF"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAM/E;;;;;;;;;;;GAWG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBtF"}

package/dist/handlers/list.js

@@ -5,7 +5,14 @@
  * bonded under the `'ai'` category AND are selectable — neither `disabled` (a
  * model the provider retired) nor superseded by a newer generation of the same
  * family, so the picker offers exactly one generation per family. Both kinds
- * stay priceable via `getModel`. No further projection is applied — every
+ * stay priceable via `getModel`.
+ *
+ * The one projection applied is `withEffectivePricing`: a model carrying a
+ * staged `scheduledPricing` change is served at whichever rates are billing at
+ * request time, with the schedule stripped. The server's clock decides when an
+ * announced price change lands, so a client never renders a rate that is not
+ * yet in force (nor keeps rendering one that has been superseded), and no
+ * client needs to know that scheduled pricing exists. Every other
  * `ModelDefinition` field is fine to expose to authenticated clients today.
  *
  * Secure-by-default: this handler enforces authentication IN the handler
@@ -20,7 +27,7 @@
  */
 import { getAll } from '@molecule/api-bond';
 import { t } from '@molecule/api-i18n';
-import { isSelectableModel } from '../lookup.js';
+import { isSelectableModel, withEffectivePricing } from '../lookup.js';
 import { MODELS } from '../models.js';
 /**
  * Returns models whose `provider` has a bond registered under the `'ai'`
@@ -44,7 +51,8 @@ export async function list(_req, res) {
         return;
     }
     const bondedProviders = new Set(getAll('ai').keys());
-    const models = MODELS.filter((m) => bondedProviders.has(m.provider) && isSelectableModel(m));
-    const response = { models: [...models] };
+    const now = new Date();
+    const models = MODELS.filter((m) => bondedProviders.has(m.provider) && isSelectableModel(m)).map((m) => withEffectivePricing(m, now));
+    const response = { models };
     res.json(response);
 }

package/dist/lookup.d.ts

@@ -67,18 +67,70 @@ export declare function getModelsByProvider(provider: AIProviderID): readonly Mo
  */
 export declare function getAvailableModels(availableProviders: ReadonlySet<AIProviderID> | readonly AIProviderID[]): readonly ModelDefinition[];
 /**
- * The price multiplier in effect for a model at a given instant.
+ * A model's BASE token rates in effect at a given instant — the staged
+ * {@link ModelDefinition.scheduledPricing} rates once their `effectiveFrom` has
+ * passed, else the base fields.
+ *
+ * These are the native provider's rates. A `regionPricing` override is a
+ * different host's rate card and is resolved separately by
+ * {@link modelRegionRates}.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to price at (defaults to now).
+ * @returns The base rates in effect at that instant.
+ */
+export declare function effectiveBaseRates(modelDef: ModelDefinition, at?: Date): ModelTokenRates;
+/**
+ * A model's peak-hour pricing in effect at a given instant: the staged
+ * {@link ModelDefinition.scheduledPricing} `peakPricing` once its
+ * `effectiveFrom` has passed (when that entry declares one — an omitted one
+ * leaves the existing windows in force), else the model's own `peakPricing`.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to evaluate (defaults to now).
+ * @returns The peak-pricing config in effect, or `undefined` when none is.
+ */
+export declare function effectivePeakPricing(modelDef: ModelDefinition, at?: Date): ModelDefinition['peakPricing'];
+/**
+ * A model projected onto the pricing in effect at a given instant: the staged
+ * {@link ModelDefinition.scheduledPricing} rates folded into the base fields
+ * (and its peak windows into `peakPricing`) once effective, with the staged
+ * entry stripped.
+ *
+ * This is what the `GET /ai/models` handler serves, so a client renders the
+ * rates that are actually billing right now without needing to resolve a
+ * schedule against its own clock — the server's clock is the only one that
+ * decides when a price change lands.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to project at (defaults to now).
+ * @returns The model with effective pricing and no `scheduledPricing`.
+ */
+export declare function withEffectivePricing(modelDef: ModelDefinition, at?: Date): ModelDefinition;
+/**
+ * The price multiplier in effect for a model at a given instant, in a region.
  *
  * Consults the model's {@link ModelDefinition.peakPricing} windows (UTC,
  * half-open, may wrap midnight). Metering MUST call this with each request's
  * own timestamp so peak-hour usage bills at the provider's real rate — pricing
  * everything at the flat rate silently under-meters peak traffic.
  *
+ * Peak windows belong to the NATIVE provider, so they apply only where the base
+ * rates do. A region with a {@link ModelDefinition.regionPricing} override is a
+ * different host billing its own complete rate card, including whether it has
+ * time-of-day pricing at all — and re-hosts generally do not. Applying the
+ * native provider's surcharge on top of a re-host's flat rates would over-bill
+ * every turn in its windows (DeepSeek's 2× Beijing-hours pricing charged
+ * against DeepInfra, which has no peak pricing).
+ *
  * @param modelDef - The model definition (or undefined).
  * @param at - The instant the request was made.
- * @returns The multiplier (`1` outside peak windows or when none are declared).
+ * @param region - The user's per-model region choice, if any (omitted → the
+ *   model's default region).
+ * @returns The multiplier (`1` outside peak windows, when none are declared, or
+ *   in a region that prices off its own override).
  */
-export declare function priceMultiplierAt(modelDef: ModelDefinition | undefined, at: Date): number;
+export declare function priceMultiplierAt(modelDef: ModelDefinition | undefined, at: Date, region?: string): number;
 /**
  * Resolve a model's effective processing region: the requested region when the
  * model's {@link ModelDefinition.regions} list offers it, else the model's
@@ -105,14 +157,22 @@ export interface ModelTokenRates {
 /**
  * The token rates for a model in a given processing region: the model's
  * {@link ModelDefinition.regionPricing} override for the region when one
- * exists, else the base rates (the native provider's list prices). Omitted
- * cache fields in an override fall back to the override's input price (hosts
- * with no cache discount / no write premium). The region is resolved via
- * {@link effectiveModelRegion}, so callers may pass the raw user choice.
+ * exists, else the base rates in effect at `at` (the native provider's list
+ * prices, including any staged {@link ModelDefinition.scheduledPricing} change
+ * that has landed). Omitted cache fields in an override fall back to the
+ * override's input price (hosts with no cache discount / no write premium). The
+ * region is resolved via {@link effectiveModelRegion}, so callers may pass the
+ * raw user choice.
+ *
+ * `at` defaults to NOW rather than being required, so an existing caller cannot
+ * keep billing a superseded rate by omitting it — metering should still pass
+ * each request's own timestamp, the same way it must for
+ * {@link priceMultiplierAt}.
  *
  * @param modelDef - The model definition.
  * @param requested - The user's per-model region choice, if any.
+ * @param at - The instant to price at (defaults to now).
  * @returns The region-effective rates.
  */
-export declare function modelRegionRates(modelDef: ModelDefinition, requested?: string): ModelTokenRates;
+export declare function modelRegionRates(modelDef: ModelDefinition, requested?: string, at?: Date): ModelTokenRates;
 //# sourceMappingURL=lookup.d.ts.map

package/dist/lookup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../src/lookup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE/D;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,cAAc,CAAC,GACxD,OAAO,CAET;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASvE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,MAAM,CAEzC,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,eAAe,EAAE,CAEtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,kBAAkB,EAAE,WAAW,CAAC,YAAY,CAAC,GAAG,SAAS,YAAY,EAAE,GACtE,SAAS,eAAe,EAAE,CAI5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAYzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAGR;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAA;IACzB,8CAA8C;IAC9C,kBAAkB,EAAE,MAAM,CAAA;IAC1B,yDAAyD;IACzD,qBAAqB,EAAE,MAAM,CAAA;IAC7B,0DAA0D;IAC1D,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,eAAe,CAiB/F"}
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../src/lookup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE/D;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,cAAc,CAAC,GACxD,OAAO,CAET;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASvE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,WAAW,CAAC,MAAM,CAEzC,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,eAAe,EAAE,CAEtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,kBAAkB,EAAE,WAAW,CAAC,YAAY,CAAC,GAAG,SAAS,YAAY,EAAE,GACtE,SAAS,eAAe,EAAE,CAI5B;AAoBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,eAAe,EACzB,EAAE,GAAE,IAAiB,GACpB,eAAe,CAgBjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,EAAE,GAAE,IAAiB,GACpB,eAAe,CAAC,aAAa,CAAC,CAMhC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,EAAE,GAAE,IAAiB,GACpB,eAAe,CASjB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,EAAE,EAAE,IAAI,EACR,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAcR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAGR;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAA;IACzB,8CAA8C;IAC9C,kBAAkB,EAAE,MAAM,CAAA;IAC1B,yDAAyD;IACzD,qBAAqB,EAAE,MAAM,CAAA;IAC7B,0DAA0D;IAC1D,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,EACzB,SAAS,CAAC,EAAE,MAAM,EAClB,EAAE,GAAE,IAAiB,GACpB,eAAe,CAYjB"}

package/dist/lookup.js

@@ -86,19 +86,126 @@ export function getAvailableModels(availableProviders) {
     return MODELS.filter((m) => providerSet.has(m.provider) && isSelectableModel(m));
 }
 /**
- * The price multiplier in effect for a model at a given instant.
+ * Whether a model's staged {@link ModelDefinition.scheduledPricing} change has
+ * taken effect at a given instant.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to evaluate.
+ * @returns `true` once `at` is at or past the scheduled `effectiveFrom`.
+ */
+function scheduledPricingApplies(modelDef, at) {
+    const scheduled = modelDef.scheduledPricing;
+    if (!scheduled)
+        return false;
+    const effectiveFrom = Date.parse(scheduled.effectiveFrom);
+    // An unparseable date must never silently reprice a model. Ignoring the
+    // staged entry keeps the current, verified rates in force.
+    if (Number.isNaN(effectiveFrom))
+        return false;
+    return at.getTime() >= effectiveFrom;
+}
+/**
+ * A model's BASE token rates in effect at a given instant — the staged
+ * {@link ModelDefinition.scheduledPricing} rates once their `effectiveFrom` has
+ * passed, else the base fields.
+ *
+ * These are the native provider's rates. A `regionPricing` override is a
+ * different host's rate card and is resolved separately by
+ * {@link modelRegionRates}.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to price at (defaults to now).
+ * @returns The base rates in effect at that instant.
+ */
+export function effectiveBaseRates(modelDef, at = new Date()) {
+    const scheduled = modelDef.scheduledPricing;
+    if (scheduled && scheduledPricingApplies(modelDef, at)) {
+        return {
+            inputPricePerMTok: scheduled.inputPricePerMTok,
+            outputPricePerMTok: scheduled.outputPricePerMTok,
+            cacheReadPricePerMTok: scheduled.cacheReadPricePerMTok,
+            cacheWritePricePerMTok: scheduled.cacheWritePricePerMTok,
+        };
+    }
+    return {
+        inputPricePerMTok: modelDef.inputPricePerMTok,
+        outputPricePerMTok: modelDef.outputPricePerMTok,
+        cacheReadPricePerMTok: modelDef.cacheReadPricePerMTok,
+        cacheWritePricePerMTok: modelDef.cacheWritePricePerMTok,
+    };
+}
+/**
+ * A model's peak-hour pricing in effect at a given instant: the staged
+ * {@link ModelDefinition.scheduledPricing} `peakPricing` once its
+ * `effectiveFrom` has passed (when that entry declares one — an omitted one
+ * leaves the existing windows in force), else the model's own `peakPricing`.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to evaluate (defaults to now).
+ * @returns The peak-pricing config in effect, or `undefined` when none is.
+ */
+export function effectivePeakPricing(modelDef, at = new Date()) {
+    const scheduled = modelDef.scheduledPricing;
+    if (scheduled?.peakPricing && scheduledPricingApplies(modelDef, at)) {
+        return scheduled.peakPricing;
+    }
+    return modelDef.peakPricing;
+}
+/**
+ * A model projected onto the pricing in effect at a given instant: the staged
+ * {@link ModelDefinition.scheduledPricing} rates folded into the base fields
+ * (and its peak windows into `peakPricing`) once effective, with the staged
+ * entry stripped.
+ *
+ * This is what the `GET /ai/models` handler serves, so a client renders the
+ * rates that are actually billing right now without needing to resolve a
+ * schedule against its own clock — the server's clock is the only one that
+ * decides when a price change lands.
+ *
+ * @param modelDef - The model definition.
+ * @param at - The instant to project at (defaults to now).
+ * @returns The model with effective pricing and no `scheduledPricing`.
+ */
+export function withEffectivePricing(modelDef, at = new Date()) {
+    if (!modelDef.scheduledPricing)
+        return modelDef;
+    const { scheduledPricing: _scheduledPricing, ...rest } = modelDef;
+    const peakPricing = effectivePeakPricing(modelDef, at);
+    return {
+        ...rest,
+        ...effectiveBaseRates(modelDef, at),
+        ...(peakPricing ? { peakPricing } : {}),
+    };
+}
+/**
+ * The price multiplier in effect for a model at a given instant, in a region.
  *
  * Consults the model's {@link ModelDefinition.peakPricing} windows (UTC,
  * half-open, may wrap midnight). Metering MUST call this with each request's
  * own timestamp so peak-hour usage bills at the provider's real rate — pricing
  * everything at the flat rate silently under-meters peak traffic.
  *
+ * Peak windows belong to the NATIVE provider, so they apply only where the base
+ * rates do. A region with a {@link ModelDefinition.regionPricing} override is a
+ * different host billing its own complete rate card, including whether it has
+ * time-of-day pricing at all — and re-hosts generally do not. Applying the
+ * native provider's surcharge on top of a re-host's flat rates would over-bill
+ * every turn in its windows (DeepSeek's 2× Beijing-hours pricing charged
+ * against DeepInfra, which has no peak pricing).
+ *
  * @param modelDef - The model definition (or undefined).
  * @param at - The instant the request was made.
- * @returns The multiplier (`1` outside peak windows or when none are declared).
+ * @param region - The user's per-model region choice, if any (omitted → the
+ *   model's default region).
+ * @returns The multiplier (`1` outside peak windows, when none are declared, or
+ *   in a region that prices off its own override).
  */
-export function priceMultiplierAt(modelDef, at) {
-    const peak = modelDef?.peakPricing;
+export function priceMultiplierAt(modelDef, at, region) {
+    if (!modelDef)
+        return 1;
+    if (modelDef.regionPricing?.[effectiveModelRegion(modelDef, region)])
+        return 1;
+    const peak = effectivePeakPricing(modelDef, at);
     if (!peak || peak.windows.length === 0)
         return 1;
     const minute = at.getUTCHours() * 60 + at.getUTCMinutes();
@@ -129,25 +236,28 @@ export function effectiveModelRegion(modelDef, requested) {
 /**
  * The token rates for a model in a given processing region: the model's
  * {@link ModelDefinition.regionPricing} override for the region when one
- * exists, else the base rates (the native provider's list prices). Omitted
- * cache fields in an override fall back to the override's input price (hosts
- * with no cache discount / no write premium). The region is resolved via
- * {@link effectiveModelRegion}, so callers may pass the raw user choice.
+ * exists, else the base rates in effect at `at` (the native provider's list
+ * prices, including any staged {@link ModelDefinition.scheduledPricing} change
+ * that has landed). Omitted cache fields in an override fall back to the
+ * override's input price (hosts with no cache discount / no write premium). The
+ * region is resolved via {@link effectiveModelRegion}, so callers may pass the
+ * raw user choice.
+ *
+ * `at` defaults to NOW rather than being required, so an existing caller cannot
+ * keep billing a superseded rate by omitting it — metering should still pass
+ * each request's own timestamp, the same way it must for
+ * {@link priceMultiplierAt}.
  *
  * @param modelDef - The model definition.
  * @param requested - The user's per-model region choice, if any.
+ * @param at - The instant to price at (defaults to now).
  * @returns The region-effective rates.
  */
-export function modelRegionRates(modelDef, requested) {
+export function modelRegionRates(modelDef, requested, at = new Date()) {
     const region = effectiveModelRegion(modelDef, requested);
     const override = modelDef.regionPricing?.[region];
     if (!override) {
-        return {
-            inputPricePerMTok: modelDef.inputPricePerMTok,
-            outputPricePerMTok: modelDef.outputPricePerMTok,
-            cacheReadPricePerMTok: modelDef.cacheReadPricePerMTok,
-            cacheWritePricePerMTok: modelDef.cacheWritePricePerMTok,
-        };
+        return effectiveBaseRates(modelDef, at);
     }
     return {
         inputPricePerMTok: override.inputPricePerMTok,

package/dist/models.d.ts

@@ -61,15 +61,24 @@ import type { ModelDefinition } from './types.js';
  *   2026-07-21 $1.50/$7.50 supersedes 3.5-flash as the agentic flagship;
  *   gemini-3.1-pro-preview still the pro tier — "3.5 Pro" has NOT shipped as
  *   of 2026-07-28 despite the coming-soon badge; do not add until it has an id)
+ *   (re-verified 2026-08-13: gemini-3.7-flash "New Stable" — supersedes
+ *   3.6-flash as the flash flagship at the SAME list price ($1.50/$7.50, cache
+ *   read $0.15), with a launch promo ($0.75/$3.75, cache read $0.075) through
+ *   2026-12-31 billed here at list; specs from /docs/models/gemini-3.7-flash:
+ *   1M ctx / 65,536 out, thinking low|medium|high (no minimal), vision, tools,
+ *   caching, search grounding, code execution, url context)
  * - xAI: https://docs.x.ai/developers/models + /developers/grok-4-5
  *   (grok-4.5 flagship 2026-07-08: $2/$6, 500K ctx, ≥200K prompts bill 2× —
  *   not modeled; reasoning_effort low|medium|high default high, image input;
  *   grok-4.3 still served at $1.25/$2.50 with the bigger 1M window;
  *   grok-code-fast-1 no longer listed — retires 2026-08-15)
- * - DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (unchanged V4
- *   Pro/Flash pricing; legacy deepseek-chat/-reasoner ids fully retired
- *   2026-07-24 — never in this catalog; the announced peak-hour 2× surcharge is
- *   still NOT active as of 2026-07-28, see the entries)
+ * - DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (verified
+ *   2026-08-14; legacy deepseek-chat/-reasoner ids fully retired 2026-07-24 —
+ *   never in this catalog. V4-Pro GA on 2026-08-13 came with a price RISE
+ *   effective 2026-08-16T16:00Z plus the long-announced peak-hour 2×: both
+ *   entries carry it as `scheduledPricing`, so today's rates bill until that
+ *   instant and the new ones after. Re-verify weekday-vs-daily peak windows and
+ *   the CN/US region default once it lands — see the entries.)
  * - Moonshot: https://platform.kimi.ai/docs/models + DeepInfra's model API for
  *   the US re-host (kimi-k3 flagship 2026-07-16
  *   — 2.8T MoE, 1M ctx, $3/$15 — NOT added: thinking is forced-on with

package/dist/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,eAAO,MAAM,MAAM,EAAE,SAAS,eAAe,EAqxCnC,CAAA"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,eAAO,MAAM,MAAM,EAAE,SAAS,eAAe,EA+5CnC,CAAA"}

package/dist/models.js

@@ -60,15 +60,24 @@
  *   2026-07-21 $1.50/$7.50 supersedes 3.5-flash as the agentic flagship;
  *   gemini-3.1-pro-preview still the pro tier — "3.5 Pro" has NOT shipped as
  *   of 2026-07-28 despite the coming-soon badge; do not add until it has an id)
+ *   (re-verified 2026-08-13: gemini-3.7-flash "New Stable" — supersedes
+ *   3.6-flash as the flash flagship at the SAME list price ($1.50/$7.50, cache
+ *   read $0.15), with a launch promo ($0.75/$3.75, cache read $0.075) through
+ *   2026-12-31 billed here at list; specs from /docs/models/gemini-3.7-flash:
+ *   1M ctx / 65,536 out, thinking low|medium|high (no minimal), vision, tools,
+ *   caching, search grounding, code execution, url context)
  * - xAI: https://docs.x.ai/developers/models + /developers/grok-4-5
  *   (grok-4.5 flagship 2026-07-08: $2/$6, 500K ctx, ≥200K prompts bill 2× —
  *   not modeled; reasoning_effort low|medium|high default high, image input;
  *   grok-4.3 still served at $1.25/$2.50 with the bigger 1M window;
  *   grok-code-fast-1 no longer listed — retires 2026-08-15)
- * - DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (unchanged V4
- *   Pro/Flash pricing; legacy deepseek-chat/-reasoner ids fully retired
- *   2026-07-24 — never in this catalog; the announced peak-hour 2× surcharge is
- *   still NOT active as of 2026-07-28, see the entries)
+ * - DeepSeek: https://api-docs.deepseek.com/quick_start/pricing (verified
+ *   2026-08-14; legacy deepseek-chat/-reasoner ids fully retired 2026-07-24 —
+ *   never in this catalog. V4-Pro GA on 2026-08-13 came with a price RISE
+ *   effective 2026-08-16T16:00Z plus the long-announced peak-hour 2×: both
+ *   entries carry it as `scheduledPricing`, so today's rates bill until that
+ *   instant and the new ones after. Re-verify weekday-vs-daily peak windows and
+ *   the CN/US region default once it lands — see the entries.)
  * - Moonshot: https://platform.kimi.ai/docs/models + DeepInfra's model API for
  *   the US re-host (kimi-k3 flagship 2026-07-16
  *   — 2.8T MoE, 1M ctx, $3/$15 — NOT added: thinking is forced-on with
@@ -572,11 +581,46 @@ export const MODELS = [
     // replace outright: the google bond has never been implemented/wired, so no
     // historical usage can reference the old ids.
     // ---------------------------------------------------------------------------
+    {
+        id: 'gemini-3.7-flash',
+        provider: 'google',
+        label: 'Gemini 3.7 Flash',
+        description: 'Google agentic flagship — complex coding & multi-step execution',
+        // Verified against /docs/models/gemini-3.7-flash (2026-08-13).
+        contextWindow: 1_048_576,
+        maxOutputTokens: 65_536,
+        supportsThinking: true,
+        thinkingBudgetTokens: 10_000,
+        thinkingConfigurable: true,
+        // thinking_level low|medium|high — minimal NOT supported on this model.
+        supportedEffortLevels: ['low', 'medium', 'high'],
+        defaultEffortLevel: 'medium',
+        supportsVision: true,
+        supportsPromptCaching: true,
+        supportsTools: true,
+        webSearchToolType: 'google_search',
+        codeExecutionToolType: 'code_execution',
+        webFetchToolType: 'url_context',
+        // "New Stable" 2026-08-13. LIST price $1.50/$7.50 — same as 3.6-flash.
+        // Google runs a launch promo ($0.75/$3.75, cache read $0.075) through
+        // 2026-12-31; billed here at standard list so metering never under-charges
+        // (same policy as claude-sonnet-5's intro pricing — see the matching
+        // KNOWN_DIVERGENCES entry in scripts/check-model-freshness.mjs, expiring
+        // 2026-12-31).
+        inputPricePerMTok: 1.5,
+        outputPricePerMTok: 7.5,
+        // Gemini context cache: read $0.15/M (0.1× input), no write premium
+        // (storage billed separately per hour — not modeled).
+        cacheReadPricePerMTok: 0.15,
+        cacheWritePricePerMTok: 1.5,
+        // Not on Google's docs — models.dev reports 2026-03 (lead, not authority).
+        knowledgeCutoff: '2026-03-01',
+    },
     {
         id: 'gemini-3.6-flash',
         provider: 'google',
         label: 'Gemini 3.6 Flash',
-        description: 'Google agentic flagship — frontier intelligence + grounding',
+        description: 'Previous Google agentic flagship — frontier intelligence + grounding',
         // Window/output not on the pricing page — carried over from 3.5-flash;
         // re-verify against /docs/models.
         contextWindow: 1_048_576,
@@ -603,6 +647,11 @@ export const MODELS = [
         cacheWritePricePerMTok: 1.5,
         // Not published — best-effort estimate.
         knowledgeCutoff: '2026-01-01',
+        // Superseded by gemini-3.7-flash (2026-08-13) — same flash tier, same list
+        // price; Google's own models page now calls 3.6 "previous-generation".
+        // Still served upstream, so it stays priceable.
+        deprecatedAt: '2026-08-13',
+        supersededBy: 'gemini-3.7-flash',
     },
     {
         id: 'gemini-3.5-flash',
@@ -632,10 +681,12 @@ export const MODELS = [
         cacheReadPricePerMTok: 0.15,
         cacheWritePricePerMTok: 1.5,
         knowledgeCutoff: '2025-01-01',
-        // Superseded by gemini-3.6-flash (2026-07-21) — same flash tier, same input
-        // price, cheaper output. Still served upstream, so it stays priceable.
+        // Superseded within the flash tier (first by 3.6-flash on 2026-07-21, now
+        // pointed one hop to gemini-3.7-flash — supersededBy must target a
+        // SELECTABLE model, never a chain). Still served upstream, so it stays
+        // priceable.
         deprecatedAt: '2026-07-21',
-        supersededBy: 'gemini-3.6-flash',
+        supersededBy: 'gemini-3.7-flash',
     },
     {
         id: 'gemini-3.1-pro-preview',
@@ -835,20 +886,44 @@ export const MODELS = [
     // DeepSeek
     // Verified: https://api-docs.deepseek.com/quick_start/pricing
     //           https://api-docs.deepseek.com/guides/thinking_mode
-    //           https://api-docs.deepseek.com/updates/ (2026-07-31)
+    //           https://api-docs.deepseek.com/updates/ (2026-08-14)
+    // 2026-08-13: V4-Pro GA — and with it the price rise that the "coming soon"
+    // note below had been waiting on. It is STAGED, not applied: both models
+    // carry `scheduledPricing` effective 2026-08-16T16:00Z, so the catalog bills
+    // today's verified rates until that instant and the new ones after it, with
+    // nobody landing an edit at 16:00 UTC on a Sunday. The new card is
+    // off-peak/peak (peak = exactly 2× off-peak), so it maps onto base rates +
+    // `peakPricing` multiplier 2 — which is why the peak windows removed below
+    // come back here rather than as flat rates.
+    //   pro   off-peak 0.66 / 1.98, cache hit 0.022  (peak 1.32 / 3.96 / 0.044)
+    //   flash off-peak 0.22 / 0.66, cache hit 0.007  (peak 0.44 / 1.32 / 0.014)
+    // Cache HITS are the real move — pro 0.003625 → 0.022 (6.1×) off-peak, 0.044
+    // (12.1×) at peak — and agentic input is ~94% cache hits, so effective input
+    // cost rises far more than the list prices suggest. Both are free-tier models
+    // (flash is `freeTier`, pro is the free-tier planner) on the CN default.
+    // TWO things to re-verify once it lands (2026-08-17):
+    //   1. WEEKDAYS OR DAILY. The rate card says only "Peak hours are 01:00 -
+    //      04:00 and 06:00 - 10:00 UTC (all other hours are off-peak)" with no
+    //      day qualifier, so the windows below are DAILY per the provider's own
+    //      doc; press coverage described them as weekday-only. `peakPricing` has
+    //      no day-of-week concept, so if it is weekday-only this over-bills every
+    //      weekend peak window and needs the field extended, not the numbers
+    //      nudged.
+    //   2. THE CN-VS-US DEFAULT. `regions: ['cn', 'us']` defaults to CN on an
+    //      owner decision (2026-08-01) taken when CN ran ~5.7× cheaper on real
+    //      traffic. Post-change DeepInfra's US flash rates (0.08/0.18/0.016) are
+    //      BELOW CN's new off-peak on both input and output — CN wins only on
+    //      cache reads. Re-derive against measured cache-hit ratios before
+    //      leaving the default where it is.
     // 2026-07-31: DeepSeek-V4-Flash OFFICIAL API launched in public beta — the
     // SAME `deepseek-v4-flash` id now serves the re-post-trained 0731 build
     // (same architecture/size; much stronger agent benchmarks — beats
-    // V4-Pro-Preview on Terminal Bench 2.1 / DeepSWE). No pricing/limit/
-    // capability changes. V4-Pro official release "coming soon" — re-verify
-    // pricing THEN (the announced peak-hour 2× was tied to the V4 official
-    // rollout and is still not on the rate card).
+    // V4-Pro-Preview on Terminal Bench 2.1 / DeepSWE).
     // OpenAI/Anthropic-compatible API; text/code only (no vision); 1M context,
     // 384K max output, automatic context (prompt) caching with ABSOLUTE cache-hit
     // prices (~1/50–1/120 of miss — not the old 0.1× rule). Launch discount made
-    // PERMANENT 2026-05-23 (Pro $1.74/$3.48 → $0.435/$0.87). Peak-hour 2×
-    // pricing announced for the mid-Jul 2026 "V4 official" release — re-verify
-    // then. Thinking now defaults ENABLED upstream and supports tool calling
+    // PERMANENT 2026-05-23 (Pro $1.74/$3.48 → $0.435/$0.87), and ENDED by the
+    // 2026-08-16 rise above. Thinking now defaults ENABLED upstream and supports tool calling
     // (reasoning_effort: high|max), BUT tool loops in thinking mode must replay
     // assistant reasoning_content on every subsequent request (400 on omission).
     // The bond explicitly sends thinking:{type:"disabled"} — Synthase runs
@@ -874,28 +949,49 @@ export const MODELS = [
         // DeepSeek automatic context cache: absolute cache-hit price ($/M).
         cacheReadPricePerMTok: 0.003625,
         cacheWritePricePerMTok: 0.435,
-        // Native-China DEFAULT (owner decision 2026-08-01): the US re-host
-        // (DeepInfra) bills ~3× list and ~28× cache reads, and agentic input is
-        // ~94% cache hits, so US processing ran ~5.7× native on real traffic.
-        // Users opt into US per model via the picker's region control.
+        // Native-China DEFAULT (owner decision 2026-08-01, re-derived 2026-08-14):
+        // the US re-host (DeepInfra) bills ~3× list and ~28× cache reads, and
+        // agentic input is ~94% cache hits, so US processing ran ~5.7× native on
+        // real traffic. The 2026-08-16 rise narrows that to ~2.3× — still decisive,
+        // so Pro stays CN while Flash flipped to US (see its note). Users opt into
+        // US per model via the picker's region control.
         regions: ['cn', 'us'],
-        // The free tier PLANS with this model on the cheap native host (it is the
-        // molecule-dev FREE_TIER_MODELS.plan), so CN is free-tier selectable; the
-        // ~3× US re-host stays paid-only (free users switch to Flash for US).
-        freeTierRegions: ['cn'],
+        // No freeTierRegions: the free tier stopped planning with this model on
+        // 2026-08-14 (minimax-m3 took over — cheaper, and it beat this model on the
+        // selection self-test). The carve-out only ever existed to keep the free
+        // tier's OWN plan default usable, and `freeTierAllows` checks
+        // `FREE_TIER_MODELS[mode] === modelId` before it looks at regions, so
+        // leaving it here would widen nothing — it would just claim a free-tier
+        // relationship that no longer exists.
         // US = DeepInfra, verified 2026-08-01 via api.deepinfra.com/models/
         // deepseek-ai/DeepSeek-V4-Pro. No cache-write premium (omitted → region
         // input rate).
         regionPricing: {
             us: { inputPricePerMTok: 1.3, outputPricePerMTok: 2.6, cacheReadPricePerMTok: 0.1 },
         },
-        // The announced peak-hour 2× surcharge (Beijing business hours) is STILL
-        // NOT ACTIVE as of 2026-07-28 — the official rate card lists a single flat
-        // rate, and no switch-over date is published. The pre-wired windows were
-        // REMOVED: they had been over-billing every peak-window turn 2× for weeks
-        // (this is the free-tier default model, so that directly shrank free
-        // users' allowances). Re-add via `peakPricing` the day DeepSeek's rate
-        // card actually shows the surcharge.
+        // The peak-hour 2× surcharge is now ON the rate card with a dated switch
+        // (2026-08-13 announcement, effective 2026-08-16T16:00Z) — so it is staged
+        // below rather than live. The previously pre-wired windows had been REMOVED
+        // for over-billing every peak-window turn 2× for weeks against a rate card
+        // that showed a single flat rate; staging is what keeps this from repeating
+        // in the other direction. Peak = 01:00-04:00 and 06:00-10:00 UTC (Beijing
+        // business hours), which is 2× the off-peak rates exactly.
+        scheduledPricing: {
+            effectiveFrom: '2026-08-16T16:00:00Z',
+            inputPricePerMTok: 0.66,
+            outputPricePerMTok: 1.98,
+            cacheReadPricePerMTok: 0.022,
+            // DeepSeek charges no cache-write premium — write bills at input.
+            cacheWritePricePerMTok: 0.66,
+            peakPricing: {
+                windows: [
+                    { startMinuteUtc: 60, endMinuteUtc: 240 },
+                    { startMinuteUtc: 360, endMinuteUtc: 600 },
+                ],
+                multiplier: 2,
+            },
+            source: 'https://api-docs.deepseek.com/quick_start/pricing/',
+        },
         // Not published by DeepSeek — best-effort estimate.
         knowledgeCutoff: '2025-07-01',
     },
@@ -923,10 +1019,19 @@ export const MODELS = [
         // DeepSeek automatic context cache: absolute cache-hit price ($/M).
         cacheReadPricePerMTok: 0.0028,
         cacheWritePricePerMTok: 0.14,
-        // Native-China default, matching deepseek-v4-pro (see its note) — even
-        // though Flash's US list price is BELOW native, its cache reads are 6.4×,
-        // and the plan/execute pair defaults to one region deliberately.
-        regions: ['cn', 'us'],
+        // US (DeepInfra) DEFAULT as of 2026-08-16 — flipped from CN when DeepSeek's
+        // rise landed (owner decision 2026-08-14). CN was cheaper on real traffic
+        // only because of its cache reads; the rise takes those from $0.0028 to
+        // $0.007 (peak $0.014) against DeepInfra's flat $0.016, which is no longer
+        // enough to carry the 1.6-3.1x it now loses on fresh input and output. On
+        // the agentic mix this model actually serves (~94% cache hits) US is
+        // cheaper at EVERY hour: 0.114c/turn flat vs 0.152c off-peak and 0.303c at
+        // peak. It is also flat-rate, so free-tier cost stops varying by Beijing
+        // business hours. Re-derive if the cache-hit ratio drops much below ~90%,
+        // where CN's cheaper reads start winning again. This deliberately splits
+        // the plan/execute pair across regions — Pro stays CN because its US
+        // re-host is ~2.3x its own native rate even after the rise.
+        regions: ['us', 'cn'],
         // US = DeepInfra, verified 2026-08-13 against the id the bond actually
         // sends: `deepseek-ai/DeepSeek-V4-Flash-0731`, the official release that
         // supersedes the preview weights still served under the un-dated id
@@ -935,7 +1040,23 @@ export const MODELS = [
         regionPricing: {
             us: { inputPricePerMTok: 0.08, outputPricePerMTok: 0.18, cacheReadPricePerMTok: 0.016 },
         },
-        // Peak-hour surcharge NOT active (see deepseek-v4-pro) — windows removed.
+        // Peak-hour surcharge staged, not live (see deepseek-v4-pro).
+        scheduledPricing: {
+            effectiveFrom: '2026-08-16T16:00:00Z',
+            inputPricePerMTok: 0.22,
+            outputPricePerMTok: 0.66,
+            cacheReadPricePerMTok: 0.007,
+            // DeepSeek charges no cache-write premium — write bills at input.
+            cacheWritePricePerMTok: 0.22,
+            peakPricing: {
+                windows: [
+                    { startMinuteUtc: 60, endMinuteUtc: 240 },
+                    { startMinuteUtc: 360, endMinuteUtc: 600 },
+                ],
+                multiplier: 2,
+            },
+            source: 'https://api-docs.deepseek.com/quick_start/pricing/',
+        },
         // Not published by DeepSeek — best-effort estimate.
         knowledgeCutoff: '2025-07-01',
     },
@@ -1137,8 +1258,21 @@ export const MODELS = [
         // US default. DeepInfra list matches native; only the cache write differs
         // (no premium → region input rate). Verified 2026-08-01.
         regions: ['us', 'cn'],
+        // The free tier PLANS with this model (molecule-dev FREE_TIER_MODELS.plan,
+        // 2026-08-14), so its default US region must be free-tier selectable. It
+        // took over from deepseek-v4-pro@cn: measured on the real starting-point
+        // selection it scored 8/8 against Pro's 7/8 — including the case Pro failed
+        // — at 1.28c/plan-turn flat versus Pro's 2.62c off-peak and 5.24c inside
+        // DeepSeek's Beijing-hours windows, and it adds vision, which Pro (text
+        // only) could not offer discovery. CN is NOT listed: it is dearer than US
+        // here, so free planning stays on the cheaper host.
+        freeTierRegions: ['us'],
         regionPricing: {
-            us: { inputPricePerMTok: 0.3, outputPricePerMTok: 1.2, cacheReadPricePerMTok: 0.06 },
+            // Verified 2026-08-14 against api.deepinfra.com/models/MiniMaxAI/MiniMax-M3
+            // (cache read = 0.2 × input). Was 0.3/1.2/0.06 — DeepInfra had repriced
+            // and nothing noticed, because the freshness gate's re-host check only
+            // covered deepseek and moonshot until this date.
+            us: { inputPricePerMTok: 0.28, outputPricePerMTok: 1.1, cacheReadPricePerMTok: 0.056 },
         },
         // From the official HF chat template ("Knowledge cutoff: January 2026").
         knowledgeCutoff: '2026-01-01',
@@ -1245,6 +1379,14 @@ export const MODELS = [
         cacheReadPricePerMTok: 0.4,
         cacheWritePricePerMTok: 2,
         regions: ['us', 'cn'],
+        // US = DeepInfra (Qwen/Qwen3.8-Max), verified 2026-08-14 against
+        // api.deepinfra.com/models/ (cache read = 0.1248 x input). ABSENT until then:
+        // every US turn was metered at Alibaba's native rates while running on
+        // DeepInfra, and the model 404'd outright because the bond's modelMap had
+        // never been updated past qwen3.7-max.
+        regionPricing: {
+            us: { inputPricePerMTok: 1.65, outputPricePerMTok: 4.951, cacheReadPricePerMTok: 0.206 },
+        },
         // Not published by Alibaba — best-effort estimate.
         knowledgeCutoff: '2026-04-01',
     },
@@ -1274,6 +1416,11 @@ export const MODELS = [
         // US default. DeepInfra bills identical rates (no regionPricing needed).
         // Verified 2026-08-01.
         regions: ['us', 'cn'],
+        // US = DeepInfra, verified 2026-08-14 (cache read = 0.2 x input). Superseded,
+        // but still priceable for historical usage, so its region rates must be real.
+        regionPricing: {
+            us: { inputPricePerMTok: 2.5, outputPricePerMTok: 7.5, cacheReadPricePerMTok: 0.5 },
+        },
         // Not published by Alibaba — best-effort estimate.
         knowledgeCutoff: '2026-01-01',
         // Superseded by qwen3.8-max (GA 2026-08-03): same tier and mechanism, and

package/dist/types.d.ts

@@ -232,6 +232,60 @@ export interface ModelDefinition {
         }[];
         multiplier: number;
     };
+    /**
+     * A price change the provider has ANNOUNCED with a dated effective instant,
+     * staged ahead of time. Until `effectiveFrom` the model bills at the base
+     * rates above; from that instant on, these rates replace them.
+     *
+     * This exists because the freshness gate can only ever see prices that are
+     * ALREADY live: it diffs the catalog against models.dev's *current* rates, so
+     * a change announced today and effective in three days is invisible to it
+     * until after it lands — and the cron runs every 8h, so the catalog would
+     * under-meter for up to a third of a day at whatever the new rate is. Landing
+     * the new numbers early is not an option either: that over-bills every turn
+     * until the switch (the exact mistake the removed DeepSeek peak windows made
+     * for weeks against the free-tier default model). Staging with a timestamp is
+     * the only form that is correct on BOTH sides of the instant, and it needs no
+     * one awake at the switch.
+     *
+     * Applies to the BASE rates only — a `regionPricing` entry is a different
+     * host's rate card (a US re-host does not reprice because the native provider
+     * did) and is never touched by a scheduled change.
+     *
+     * `peakPricing` here, when declared, replaces the model's peak windows from
+     * the same instant; when omitted, the model's existing windows carry through
+     * unchanged. To schedule the END of peak pricing, declare an explicit
+     * `{ windows: [], multiplier: 1 }`.
+     *
+     * Resolution is `effectiveBaseRates()` / `effectivePeakPricing()`, and every
+     * consumer reaches it through `modelRegionRates()` / `priceMultiplierAt()` /
+     * the `withEffectivePricing()` projection the list handler serves — so a
+     * scheduled change lands everywhere at once with no follow-up edit. Once the
+     * instant has passed, fold the rates into the base fields and delete this
+     * (the freshness gate now verifies them against models.dev normally).
+     */
+    scheduledPricing?: {
+        /** ISO-8601 UTC instant the new rates take effect. */
+        effectiveFrom: string;
+        /** Input price per million *uncached* tokens in USD, from `effectiveFrom`. */
+        inputPricePerMTok: number;
+        /** Output price per million tokens in USD, from `effectiveFrom`. */
+        outputPricePerMTok: number;
+        /** Prompt-cache *read* price per million tokens in USD, from `effectiveFrom`. */
+        cacheReadPricePerMTok: number;
+        /** Prompt-cache *write* price per million tokens in USD, from `effectiveFrom`. */
+        cacheWritePricePerMTok: number;
+        /** Peak-hour pricing from `effectiveFrom` (omitted → existing windows carry through). */
+        peakPricing?: {
+            windows: {
+                startMinuteUtc: number;
+                endMinuteUtc: number;
+            }[];
+            multiplier: number;
+        };
+        /** Where the change was announced, for the re-verify pass after it lands. */
+        source?: string;
+    };
     /**
      * Fast-mode ("priority speed") pricing — the per-MTok rates billed when a
      * request runs with the provider's fast/priority tier (e.g. Anthropic's

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-resource-ai-models",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "AI model catalog — server-side source of truth plus an authentication-gated discovery endpoint",
   "type": "module",
   "main": "dist/index.js",