sidekick-shared 0.28.3 → 0.29.1

package/dist/esm/modelInfo.js

@@ -14,12 +14,18 @@
  *   baseline without requiring a redeploy when vendor prices change.
  * - Longest-prefix matching handles variants like `claude-opus-4.5-20250514`
  *   against a key like `claude-opus-4.5`. Same pattern used in modelContext.ts.
+ * - A consumer layer (`registerModelPricing`) sits beside the catalog and
+ *   imported layers and survives their resets.
+ * - Every table-derived value is computed lazily, so a tree-shaken bundle that
+ *   only uses the parsing/display helpers does not retain the pricing table.
  *
  * @module modelInfo
  */
 import { getModelContextWindowSize } from './modelContext';
 import { resolveModelAlias } from './modelAliases';
+import { ownValue } from './ownKey';
 export { MODEL_PROVIDER_IDS } from './providerIds';
+export { formatCost } from './formatting';
 // ── Static Pricing Table ──
 /**
  * Static baseline pricing. Keys are model-ID prefixes; lookup uses
@@ -621,21 +627,38 @@ const PRICING_TABLE = {
         cacheReadCostPerMillion: 7.5,
     },
 };
-/** Static-table keys sorted longest-first so longest-prefix wins. */
-const STATIC_SORTED_KEYS = Object.keys(PRICING_TABLE).sort((a, b) => b.length - a.length);
+/**
+ * Static-table keys sorted longest-first so longest-prefix wins. Computed on
+ * first lookup rather than at module load: a top-level call would keep the
+ * whole table alive in tree-shaken bundles that never price anything.
+ */
+let staticSortedKeys = null;
+function getStaticSortedKeys() {
+    if (!staticSortedKeys) {
+        staticSortedKeys = Object.keys(PRICING_TABLE).sort((a, b) => b.length - a.length);
+    }
+    return staticSortedKeys;
+}
 // ── Override Table (populated at runtime by pricingCatalog) ──
 let overrideTable = {};
 let overrideSortedKeys = [];
+let overrideBasis = null;
 let importedTable = {};
 /**
  * Internal: replace the runtime override map. Called by `pricingCatalog.ts`
  * after a successful LiteLLM hydration. Not part of the stable public API,
  * but exported so the Node-only catalog module can wire itself in without
  * creating a circular import.
+ *
+ * `basis` records how the map was obtained for `getPricingCatalogInfo()`;
+ * omitted, a non-empty map reports as `litellm` with no `fetchedAt`. Every
+ * call replaces the previous basis.
  */
-export function _setPricingOverrides(overrides) {
+export function _setPricingOverrides(overrides, basis) {
     overrideTable = Object.fromEntries(Object.entries(overrides).map(([key, value]) => [key.trim().toLowerCase(), { ...value }]));
     overrideSortedKeys = Object.keys(overrideTable).sort((a, b) => b.length - a.length);
+    overrideBasis = basis ? { ...basis } : null;
+    invalidatePricingDigest();
 }
 /** Internal: snapshot current overrides (test + diagnostics). */
 export function _getPricingOverrides() {
@@ -645,6 +668,8 @@ export function _getPricingOverrides() {
 export function _clearPricingOverrides() {
     overrideTable = {};
     overrideSortedKeys = [];
+    overrideBasis = null;
+    invalidatePricingDigest();
 }
 /**
  * Internal: hydrate exact pricing resolutions exported by another realm.
@@ -653,10 +678,210 @@ export function _clearPricingOverrides() {
  */
 export function _setImportedResolvedPricing(values) {
     importedTable = { ...importedTable, ...values };
+    invalidatePricingDigest();
 }
 /** Internal test hook. */
 export function _clearImportedResolvedPricing() {
     importedTable = {};
+    invalidatePricingDigest();
+}
+// A Map (created on first registration) so keys such as `__proto__` stay data.
+let registeredTable = null;
+function isValidModelPricing(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const pricing = value;
+    return [
+        pricing.inputCostPerMillion,
+        pricing.outputCostPerMillion,
+        pricing.cacheWriteCostPerMillion,
+        pricing.cacheReadCostPerMillion,
+    ].every((item) => typeof item === 'number' && Number.isFinite(item) && item >= 0);
+}
+/**
+ * Register consumer pricing for model ids, e.g. negotiated or private-deployment
+ * rates. This layer is separate from the runtime catalog and imported layers:
+ * `_setPricingOverrides`, `hydratePricingCatalog`, and
+ * `importResolvedModelCatalog` never reset it; only
+ * `clearRegisteredModelPricing` does.
+ *
+ * Keys are trimmed, lowercased, and stripped of `[1m]`, like the other tables.
+ * Matching is exact, never by prefix, against the looked-up id, its registered
+ * alias target, and its `canonicalModelId()` form — so a `claude-opus-5-5`
+ * entry also answers `claude-opus-5-5-20261001` and
+ * `us.anthropic.claude-opus-5-5-20261001-v1:0`.
+ *
+ * Successive calls merge; re-registering a key replaces its price and mode.
+ * Entries whose four rates are not all finite, nonnegative numbers are
+ * skipped. Results carry `provenance.source: 'registered'`.
+ *
+ * Registered entries are realm-local configuration and are kept out of
+ * cross-realm snapshots: they are not listed by the catalog id enumeration,
+ * and `resolveModelPricing(id, { includeRegistered: false })` is the
+ * resolution a snapshot should carry. An exported price would otherwise be
+ * pinned as an exact import in the other realm and outlive
+ * `clearRegisteredModelPricing` there. Register in each realm instead.
+ */
+export function registerModelPricing(entries, options) {
+    const onlyIfMissing = options?.onlyIfMissing === true;
+    let changed = false;
+    for (const [key, value] of Object.entries(entries ?? {})) {
+        const id = key
+            .replace(/\[1m\]/gi, '')
+            .trim()
+            .toLowerCase();
+        if (!id || !isValidModelPricing(value))
+            continue;
+        registeredTable ??= new Map();
+        registeredTable.set(id, {
+            pricing: {
+                inputCostPerMillion: value.inputCostPerMillion,
+                outputCostPerMillion: value.outputCostPerMillion,
+                cacheWriteCostPerMillion: value.cacheWriteCostPerMillion,
+                cacheReadCostPerMillion: value.cacheReadCostPerMillion,
+            },
+            onlyIfMissing,
+        });
+        changed = true;
+    }
+    if (changed)
+        invalidatePricingDigest();
+}
+/** Remove every entry added by `registerModelPricing`. */
+export function clearRegisteredModelPricing() {
+    if (registeredTable && registeredTable.size > 0)
+        invalidatePricingDigest();
+    registeredTable = null;
+}
+function findRegisteredPricing(rawId, aliasId) {
+    if (!registeredTable || registeredTable.size === 0)
+        return null;
+    const canonical = canonicalModelId(rawId);
+    for (const id of [rawId, aliasId, canonical, resolveModelAlias(canonical)]) {
+        const entry = registeredTable.get(id);
+        if (entry)
+            return { id, entry };
+    }
+    return null;
+}
+// ── Pricing Basis ──
+let pricingDigestMemo = null;
+function invalidatePricingDigest() {
+    pricingDigestMemo = null;
+}
+/** JSON with object keys sorted at every level; `undefined` members are dropped. */
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value) ?? 'null';
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const record = value;
+    const keys = Object.keys(record)
+        .filter((key) => record[key] !== undefined)
+        .sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+/**
+ * 64-bit FNV-1a over the UTF-8 bytes of `text`, as 16 lowercase hex digits.
+ * Uses four 16-bit limbs so it runs on plain numbers in every JS runtime.
+ */
+function fnv1a64Hex(text) {
+    // Offset basis 0xcbf29ce484222325, least significant limb first.
+    let h0 = 0x2325;
+    let h1 = 0x8422;
+    let h2 = 0x9ce4;
+    let h3 = 0xcbf2;
+    const mix = (byte) => {
+        h0 ^= byte;
+        // Multiply by the FNV prime 0x100000001b3 = 2^40 + 0x1b3, mod 2^64.
+        const t0 = h0 * 0x1b3;
+        const t1 = h1 * 0x1b3 + (t0 >>> 16);
+        const t2 = h2 * 0x1b3 + (h0 << 8) + (t1 >>> 16);
+        const t3 = h3 * 0x1b3 + (h1 << 8) + (t2 >>> 16);
+        h0 = t0 & 0xffff;
+        h1 = t1 & 0xffff;
+        h2 = t2 & 0xffff;
+        h3 = t3 & 0xffff;
+    };
+    for (let i = 0; i < text.length; i++) {
+        let code = text.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdfff) {
+            const low = code <= 0xdbff && i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+                i++;
+            }
+            else {
+                // A lone surrogate encodes as U+FFFD, as TextEncoder does.
+                code = 0xfffd;
+            }
+        }
+        if (code < 0x80) {
+            mix(code);
+        }
+        else if (code < 0x800) {
+            mix(0xc0 | (code >> 6));
+            mix(0x80 | (code & 0x3f));
+        }
+        else if (code < 0x10000) {
+            mix(0xe0 | (code >> 12));
+            mix(0x80 | ((code >> 6) & 0x3f));
+            mix(0x80 | (code & 0x3f));
+        }
+        else {
+            mix(0xf0 | (code >> 18));
+            mix(0x80 | ((code >> 12) & 0x3f));
+            mix(0x80 | ((code >> 6) & 0x3f));
+            mix(0x80 | (code & 0x3f));
+        }
+    }
+    return [h3, h2, h1, h0].map((limb) => limb.toString(16).padStart(4, '0')).join('');
+}
+function getPricingDigest() {
+    if (pricingDigestMemo === null) {
+        const imported = {};
+        for (const [id, entry] of Object.entries(importedTable)) {
+            imported[id] = { pricing: entry.pricing, provenance: entry.provenance };
+        }
+        const registered = {};
+        for (const [id, entry] of registeredTable ?? []) {
+            registered[id] = { pricing: entry.pricing, onlyIfMissing: entry.onlyIfMissing };
+        }
+        const payload = canonicalJson({
+            v: 1,
+            static: PRICING_TABLE,
+            catalog: overrideTable,
+            imported,
+            registered,
+        });
+        pricingDigestMemo = `fnv1a64:${fnv1a64Hex(payload)}`;
+    }
+    return pricingDigestMemo;
+}
+/**
+ * Describe the pricing basis behind current cost estimates: which layer the
+ * prices come from, when the catalog was fetched, and a digest that changes
+ * whenever any active price changes. Pure and cheap after the first call (the
+ * digest is memoized until a table changes).
+ */
+export function getPricingCatalogInfo() {
+    const catalogEntries = overrideSortedKeys.length;
+    let source = 'static';
+    if (catalogEntries > 0) {
+        source = overrideBasis?.source ?? 'litellm';
+    }
+    else if (Object.keys(importedTable).length > 0) {
+        source = 'imported';
+    }
+    const fetchedAt = catalogEntries > 0 ? overrideBasis?.fetchedAt : undefined;
+    return {
+        source,
+        ...(fetchedAt ? { fetchedAt } : {}),
+        digest: getPricingDigest(),
+        catalogEntries,
+        registeredEntries: registeredTable?.size ?? 0,
+    };
 }
 /** Internal: list every ID known to the pricing resolver. */
 export function _getModelPricingIds() {
@@ -666,6 +891,86 @@ export function _getModelPricingIds() {
         ...Object.keys(importedTable),
     ]));
 }
+// ── Model ID Canonicalization ──
+// Bedrock: optional cross-region prefix (`us.`, `eu.`, `apac.`, `global.`, …)
+// then the vendor segment, e.g. `us.anthropic.claude-opus-5-5-20261001-v1:0`.
+const BEDROCK_ANTHROPIC_RE = /^(?:[a-z]{2,6}(?:-[a-z]{2,4})?\.)?anthropic\./;
+// Bedrock revision tag (`-v1:0`, `-v1`), only after a version or date digit so
+// legacy names such as `claude-v2:1` and `claude-instant-v1` keep theirs.
+const BEDROCK_REVISION_RE = /([0-9])-v[0-9]+(?::[0-9]+)?$/;
+const VERTEX_VERSION_RE = /@(?:[0-9]{8}|latest)$/;
+const LATEST_SUFFIX_RE = /-latest$/;
+const DASHED_DATE_SUFFIX_RE = /-[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+const COMPACT_DATE_SUFFIX_RE = /-[0-9]{8}$/;
+/**
+ * Reduce a model id to the bare model name it denotes, for grouping and
+ * matching across hosts and snapshots.
+ *
+ * Trims and lowercases, then removes: `[1m]`; every leading `segment/`
+ * provider or region prefix (`azure/us/gpt-6.1-terra` → `gpt-6.1-terra`);
+ * Bedrock forms (`us.anthropic.claude-opus-5-5-20261001-v1:0` →
+ * `claude-opus-5-5`, also `eu.`/`apac.`/`global.` and bare `anthropic.`);
+ * Vertex `@YYYYMMDD`; trailing `-YYYYMMDD` and `-YYYY-MM-DD` dates; `-latest`.
+ * Meaningful suffixes (`-mini`, `-codex`, `-sol`, `-terra`, `-high`, …) stay.
+ *
+ * Pure and syntactic: registered aliases are not applied (see
+ * `resolveModelAlias`). Pricing lookups do not use this to reach other
+ * models' prices — dated snapshots and deployments can bill differently — only
+ * to match `registerModelPricing` entries.
+ */
+export function canonicalModelId(id) {
+    let value = String(id ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/\[1m\]/g, '')
+        .trim();
+    const slash = value.lastIndexOf('/');
+    if (slash >= 0 && slash < value.length - 1)
+        value = value.slice(slash + 1);
+    const bedrock = BEDROCK_ANTHROPIC_RE.exec(value);
+    if (bedrock && value.length > bedrock[0].length) {
+        value = value.slice(bedrock[0].length).replace(BEDROCK_REVISION_RE, '$1');
+    }
+    // Suffixes can stack (`-20250101-latest`), so strip until nothing changes.
+    for (;;) {
+        const next = value
+            .replace(VERTEX_VERSION_RE, '')
+            .replace(LATEST_SUFFIX_RE, '')
+            .replace(DASHED_DATE_SUFFIX_RE, '')
+            .replace(COMPACT_DATE_SUFFIX_RE, '');
+        if (next === value || !next)
+            break;
+        value = next;
+    }
+    return value;
+}
+// Names an agent CLI re-points at a different concrete model over time.
+// An object literal rather than a Set keeps it free for tree-shaking.
+const MOVING_MODEL_ALIASES = {
+    default: true,
+    auto: true,
+    latest: true,
+    sonnet: true,
+    opus: true,
+    haiku: true,
+    fable: true,
+    opusplan: true,
+};
+/**
+ * True for model names an agent CLI resolves to a different concrete model
+ * over time (`default`, `auto`, `latest`, `sonnet`, `opus`, `haiku`, `fable`,
+ * and Claude Code's `opusplan`), so a recorded value names a moving target
+ * rather than a model. Case-insensitive, trimmed, and `[1m]`-tolerant
+ * (`sonnet[1m]`). Dated or versioned ids are never moving aliases.
+ */
+export function isMovingModelAlias(id) {
+    const value = String(id ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/\[1m\]/g, '')
+        .trim();
+    return Object.prototype.hasOwnProperty.call(MOVING_MODEL_ALIASES, value);
+}
 // ── Model ID Parsing ──
 // Anthropic writes the minor version with a hyphen in modern IDs
 // (`claude-sonnet-4-6-20260321`) and a dot in older ones
@@ -677,6 +982,14 @@ const LEGACY_CLAUDE_RE = /^claude-([0-9]+(?:[-.][0-9]+)?)-(haiku|sonnet|opus)(?:
 const GPT_RE = /^gpt-([0-9][0-9.A-Za-z-]*)/i;
 const O_SERIES_RE = /^o([0-9]+)(-mini|-pro)?/i;
 const GEMINI_RE = /^gemini-([0-9][0-9.A-Za-z-]*)/i;
+// GPT tier names, read from the parsed version (`6.1-sol`, `6-luna-2026-01-01`).
+const GPT_TIER_VARIANT_RE = /^[0-9]+(?:\.[0-9]+)*-(astra|sol|terra|luna)(?=-|$)/;
+const GPT_TIER_VARIANT_RANK = {
+    astra: 0,
+    sol: 1,
+    terra: 2,
+    luna: 3,
+};
 /**
  * Parses a model ID into {provider, family, version}.
  *
@@ -708,7 +1021,13 @@ export function parseModelId(modelId) {
     }
     const gpt = normalized.match(GPT_RE);
     if (gpt) {
-        return { provider: 'openai', family: 'gpt', version: gpt[1] };
+        const version = gpt[1];
+        const variant = GPT_TIER_VARIANT_RE.exec(version)?.[1];
+        // The key is only present when set, so untiered results stay deep-equal
+        // to what earlier releases returned.
+        return variant
+            ? { provider: 'openai', family: 'gpt', version, variant }
+            : { provider: 'openai', family: 'gpt', version };
     }
     const oSeries = normalized.match(O_SERIES_RE);
     if (oSeries) {
@@ -730,24 +1049,45 @@ function findLongestPrefix(keys, modelId) {
     }
     return null;
 }
-/** Resolve pricing and disclose whether the result was inherited by prefix. */
-export function resolveModelPricing(modelId) {
+/**
+ * Resolve pricing and disclose which layer answered and whether the result was
+ * inherited by prefix.
+ *
+ * Order: registered entries (default mode); exact imported, catalog, and
+ * static matches; registered `onlyIfMissing` entries; catalog then static
+ * prefix matches; unpriced.
+ */
+export function resolveModelPricing(modelId, options) {
     const stripped = modelId.replace(/\[1m\]/gi, '');
     const rawId = stripped.trim().toLowerCase();
-    const canonicalModelId = resolveModelAlias(stripped);
+    const aliasId = resolveModelAlias(stripped);
     // The raw id is tried before its alias target at every step: pricing
     // recorded for the alias id itself is more specific than the canonical
     // fallback, so registering an alias never orphans it.
-    const candidateIds = rawId === canonicalModelId ? [canonicalModelId] : [rawId, canonicalModelId];
-    const imported = importedTable[rawId] ?? importedTable[canonicalModelId];
+    const candidateIds = rawId === aliasId ? [aliasId] : [rawId, aliasId];
+    const registered = options?.includeRegistered === false ? null : findRegisteredPricing(rawId, aliasId);
+    const registeredResult = (match) => ({
+        modelId,
+        canonicalModelId: aliasId,
+        pricing: { ...match.entry.pricing },
+        provenance: {
+            source: 'registered',
+            match: 'exact',
+            matchedModelId: match.id,
+            inheritedByPrefix: false,
+        },
+    });
+    if (registered && !registered.entry.onlyIfMissing)
+        return registeredResult(registered);
+    const imported = ownValue(importedTable, rawId) ?? ownValue(importedTable, aliasId);
     if (imported)
-        return { ...imported, modelId, canonicalModelId };
+        return { ...imported, modelId, canonicalModelId: aliasId };
     for (const id of candidateIds) {
-        const exactOverride = overrideTable[id];
+        const exactOverride = ownValue(overrideTable, id);
         if (exactOverride) {
             return {
                 modelId,
-                canonicalModelId,
+                canonicalModelId: aliasId,
                 pricing: exactOverride,
                 provenance: {
                     source: 'catalog',
@@ -759,11 +1099,11 @@ export function resolveModelPricing(modelId) {
         }
     }
     for (const id of candidateIds) {
-        const exactStatic = PRICING_TABLE[id];
+        const exactStatic = ownValue(PRICING_TABLE, id);
         if (exactStatic) {
             return {
                 modelId,
-                canonicalModelId,
+                canonicalModelId: aliasId,
                 pricing: exactStatic,
                 provenance: {
                     source: 'static',
@@ -774,12 +1114,15 @@ export function resolveModelPricing(modelId) {
             };
         }
     }
+    // A gap-filling registration answers once no layer has an exact price.
+    if (registered)
+        return registeredResult(registered);
     for (const id of candidateIds) {
         const overridePrefix = findLongestPrefix(overrideSortedKeys, id);
         if (overridePrefix) {
             return {
                 modelId,
-                canonicalModelId,
+                canonicalModelId: aliasId,
                 pricing: overrideTable[overridePrefix],
                 provenance: {
                     source: 'catalog',
@@ -791,11 +1134,11 @@ export function resolveModelPricing(modelId) {
         }
     }
     for (const id of candidateIds) {
-        const staticPrefix = findLongestPrefix(STATIC_SORTED_KEYS, id);
+        const staticPrefix = findLongestPrefix(getStaticSortedKeys(), id);
         if (staticPrefix) {
             return {
                 modelId,
-                canonicalModelId,
+                canonicalModelId: aliasId,
                 pricing: PRICING_TABLE[staticPrefix],
                 provenance: {
                     source: 'static',
@@ -808,7 +1151,7 @@ export function resolveModelPricing(modelId) {
     }
     return {
         modelId,
-        canonicalModelId,
+        canonicalModelId: aliasId,
         pricing: null,
         provenance: { source: 'none', match: 'none', inheritedByPrefix: false },
     };
@@ -816,9 +1159,11 @@ export function resolveModelPricing(modelId) {
 /**
  * Gets pricing for a model ID.
  *
- * Lookup order:
- *   1. Runtime override map (from LiteLLM catalog hydration).
- *   2. Static PRICING_TABLE.
+ * Lookup order (see `resolveModelPricing` for provenance):
+ *   1. Registered entries (`registerModelPricing`), exact matches only.
+ *   2. Imported resolutions, then the runtime override map (from LiteLLM
+ *      catalog hydration), then the static PRICING_TABLE — exact before prefix,
+ *      with gap-filling registered entries between the two.
  *   3. `null` — unknown model. Callers MUST handle this.
  *
  * The ID is first looked up verbatim (minus the "[1m]" suffix) — override
@@ -910,22 +1255,47 @@ export function mergeCostSources(a, b) {
     };
     return rank[a] >= rank[b] ? a : b;
 }
-// ── Display ──
-function normalizeModelId(modelId) {
-    return modelId
-        .trim()
-        .toLowerCase()
-        .replace(/^[a-z]+\//, '')
-        .replace(/-\d{8}$/, '')
-        .replace(/-latest$/, '')
-        .replace(/\[1m\]/gi, '');
+/**
+ * Map the provenance `calculateNormalizedUsageCost` reports to the display
+ * cost source: provider-reported costs are `reported`, costs computed from
+ * explicit or catalog pricing are `estimated`, and unpriced stays `unpriced`.
+ */
+export function costSourceFromPricingProvenance(provenance) {
+    switch (provenance) {
+        case 'provider-reported':
+            return 'reported';
+        case 'explicit-pricing':
+        case 'model-catalog':
+            return 'estimated';
+        default:
+            return 'unpriced';
+    }
+}
+/**
+ * Merge the cost sources of a rollup's components, least certain winning (as
+ * `mergeCostSources`). Components without a `source` have not been seen yet
+ * and are ignored, and an `unpriced` component that contributed no tokens
+ * does not taint the total. Returns `undefined` when nothing counted.
+ */
+export function mergeCostComponents(components) {
+    let merged;
+    for (const component of components) {
+        const source = component?.source;
+        if (!source)
+            continue;
+        if (source === 'unpriced' && !(component.tokens > 0))
+            continue;
+        merged = merged ? mergeCostSources(merged, source) : source;
+    }
+    return merged;
 }
+// ── Display ──
 /**
  * Short display label for model IDs. Keeps historical Claude family labels
  * compact while normalizing common OpenAI labels.
  */
 export function shortModelName(modelId) {
-    const normalized = normalizeModelId(modelId);
+    const normalized = canonicalModelId(modelId);
     const parsed = parseModelId(normalized);
     if (normalized.includes('codex'))
         return 'Codex';
@@ -964,7 +1334,7 @@ function versionRank(version) {
  */
 export function getModelDisplayInfo(modelId) {
     const parsed = parseModelId(modelId);
-    const normalized = normalizeModelId(modelId);
+    const normalized = canonicalModelId(modelId);
     let rank = 1_000;
     if (parsed?.provider === 'anthropic') {
         rank = (CLAUDE_FAMILY_RANK[parsed.family] ?? 9) * 100 + versionRank(parsed.version);
@@ -990,29 +1360,37 @@ export function getModelDisplayInfo(modelId) {
         rank,
     };
 }
-/** Compare two model IDs using shared provider/family ranking rules. */
+/**
+ * Order two GPT tier variants of the same family and numeric version
+ * (astra > sol > terra > luna); 0 for every other pair.
+ */
+function compareTierVariants(a, b) {
+    const left = parseModelId(a);
+    const right = parseModelId(b);
+    if (!left?.variant || !right?.variant)
+        return 0;
+    if (left.provider !== right.provider || left.family !== right.family)
+        return 0;
+    if (versionRank(left.version) !== versionRank(right.version))
+        return 0;
+    return ((GPT_TIER_VARIANT_RANK[left.variant] ?? Number.MAX_SAFE_INTEGER) -
+        (GPT_TIER_VARIANT_RANK[right.variant] ?? Number.MAX_SAFE_INTEGER));
+}
+/**
+ * Compare two model IDs using shared provider/family ranking rules. Within a
+ * family and numeric version, GPT tiers rank astra > sol > terra > luna.
+ */
 export function compareModelIds(a, b) {
     const left = getModelDisplayInfo(a);
     const right = getModelDisplayInfo(b);
     if (left.rank !== right.rank)
         return left.rank - right.rank;
+    const variantOrder = compareTierVariants(a, b);
+    if (variantOrder !== 0)
+        return variantOrder;
     return a.localeCompare(b);
 }
 /** Return a sorted copy of model IDs using shared provider/family ranking rules. */
 export function sortModelIds(modelIds) {
     return [...modelIds].sort(compareModelIds);
 }
-/**
- * Formats a USD cost as a currency string.
- *
- * - `null` / `undefined` → `"—"` (honest "pricing unavailable").
- * - `< $0.01` → 4 decimals, so sub-cent costs are still visible.
- * - otherwise → 2 decimals.
- */
-export function formatCost(cost) {
-    if (cost === null || cost === undefined)
-        return '—';
-    if (cost < 0.01)
-        return `$${cost.toFixed(4)}`;
-    return `$${cost.toFixed(2)}`;
-}

package/dist/esm/node.js

@@ -8,7 +8,8 @@
 export { hydratePricingCatalog, normalizeLiteLlmCatalog, normalizeLiteLlmContextWindows, LITELLM_CATALOG_URL, } from './pricingCatalog';
 export { loadObservedContextWindows, recordObservedContextWindow, getObservedContextWindowPath, } from './observedContextWindows';
 export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
-export { collectPromptHistory, isPromptHistorySessionSettled, parsePromptHistoryCursor, } from './promptHistory';
+export { collectPromptHistory, isPromptHistorySessionSettled, parsePromptHistoryCursor, PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES, } from './promptHistory';
+export { findToolCallOrigins } from './toolCallOrigins';
 export { collectSessionPromptHistory } from './sessionPromptHistory';
 export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
 export { computeSessionFileStats, firstUserPrompt, providerContextSizeFn, readSessionFileStats, } from './sessionStats';
@@ -35,7 +36,12 @@ export { CONFIG_DIR_ENV_VAR, getConfigDir, getConfigDirOverride, getDefaultConfi
 export { encodeWorkspacePath as encodeClaudeWorkspacePath, getSessionDirectory as getClaudeSessionDirectory, } from './parsers/sessionPathResolver';
 // Provider homes the CLIs read for this process
 export { getLiveClaudeHome, getDefaultClaudeHome, isDefaultClaudeHome, getClaudeProjectsDir, } from './claudePaths';
-export { getSystemCodexHome, getCodexMonitoringHomes, resolveSidekickCodexHome, getCodexExecutionEnv, getCodexSessionsDirs, CODEX_SESSIONS_SUBDIR, CODEX_ARCHIVED_SESSIONS_SUBDIR, } from './codexPaths';
+export { getSystemCodexHome, getCodexMonitoringHomes, resolveSidekickCodexHome, getCodexExecutionEnv, getCodexSessionsDirs, getCodexCredentialStoreMode, forceFileCredentialStore, CODEX_SESSIONS_SUBDIR, CODEX_ARCHIVED_SESSIONS_SUBDIR, } from './codexPaths';
+export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCodexAuthIdentity, readLastRefresh as readCodexLastRefresh, readAccessTokenExpiry as readCodexAccessTokenExpiry, identitiesMatch as codexIdentitiesMatch, codexRefreshFingerprint, compareCodexAuthFreshness, } from './codexAuth';
+export { atomicWriteJson, atomicWriteJsonSync } from './writers/atomic';
+export { parseClaudeAuthStatus, parseCodexLoginStatus } from './authStatus';
+export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { getPricingCatalogInfo, registerModelPricing, clearRegisteredModelPricing, } from './modelInfo';
 export { fetchProviderServiceStatus } from './providerServiceStatus';
 // Tool categories across providers
 export { classifyTool, TOOL_CATEGORIES } from './toolCategory';
@@ -43,4 +49,4 @@ export { classifyTool, TOOL_CATEGORIES } from './toolCategory';
 export { resolveWorkspaceRoots } from './workspaceRoots';
 export { discoverWorktreeSiblings, resolveWorktreeMainRepo } from './parsers/sessionPathResolver';
 // Bounded JSONL tail reader
-export { createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, } from './watchers/jsonlTail';
+export { captureJsonlCheckpoint, createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, JSONL_TAIL_CHECKPOINT_VERSION, JsonlTailSymlinkError, verifyJsonlCheckpoint, } from './watchers/jsonlTail';

package/dist/esm/observedContextWindows.js

@@ -32,6 +32,7 @@
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { _setObservedContextWindows, _getObservedContextWindows } from './modelContext';
+import { setOwnValue } from './ownKey';
 import { getConfigDir } from './paths';
 import { updateJsonStoreAtomic } from './writers/atomic';
 // ── Constants ──
@@ -80,7 +81,7 @@ function toOverrideMap(store, now = Date.now()) {
         const observedAt = typeof entry.observedAt === 'string' ? Date.parse(entry.observedAt) : NaN;
         if (Number.isFinite(observedAt) && now - observedAt > OBSERVED_CONTEXT_WINDOW_TTL_MS)
             continue;
-        out[modelId] = window;
+        setOwnValue(out, modelId, window);
     }
     return out;
 }