sidekick-shared 0.24.5 → 0.26.0

package/dist/modelCatalog.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModelAlias = exports.registerModelAlias = exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION = void 0;
+exports.exportResolvedModelCatalog = exportResolvedModelCatalog;
+exports.importResolvedModelCatalog = importResolvedModelCatalog;
+const modelContext_1 = require("./modelContext");
+const modelInfo_1 = require("./modelInfo");
+const modelAliases_1 = require("./modelAliases");
+Object.defineProperty(exports, "registerModelAlias", { enumerable: true, get: function () { return modelAliases_1.registerModelAlias; } });
+Object.defineProperty(exports, "resolveModelAlias", { enumerable: true, get: function () { return modelAliases_1.resolveModelAlias; } });
+exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION = 1;
+function normalizedIds(ids) {
+    if (ids) {
+        return Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    }
+    const aliases = (0, modelAliases_1._getModelAliases)();
+    return Array.from(new Set([
+        ...(0, modelContext_1._getModelContextIds)(),
+        ...(0, modelInfo_1._getModelPricingIds)(),
+        ...Object.keys(aliases),
+        ...Object.values(aliases),
+    ])).sort();
+}
+/**
+ * Export an entirely serializable catalog suitable for IPC to another JS realm.
+ * Each entry records published, observed, and tier-effective context windows,
+ * plus pricing match provenance (including prefix inheritance).
+ */
+function exportResolvedModelCatalog(ids) {
+    const models = {};
+    const selectedIds = normalizedIds(ids);
+    for (const id of selectedIds) {
+        const canonicalId = (0, modelAliases_1.resolveModelAlias)(id);
+        models[id] = {
+            id,
+            canonicalId,
+            contextWindow: (0, modelContext_1.resolveModelContextWindow)(id),
+            pricing: (0, modelInfo_1.resolveModelPricing)(id),
+        };
+    }
+    const selectedCanonicalIds = new Set(Object.values(models).flatMap(({ id, canonicalId }) => [id, canonicalId]));
+    const aliases = Object.fromEntries(Object.entries((0, modelAliases_1._getModelAliases)()).filter(([alias, canonicalId]) => selectedCanonicalIds.has(alias) || selectedCanonicalIds.has(canonicalId)));
+    return { schemaVersion: exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, models, aliases };
+}
+/**
+ * Hydrate exact model resolutions exported by another bundle realm.
+ * Invalid entries are skipped and reported; import never partially mutates an
+ * entry or throws for malformed IPC data.
+ */
+function importResolvedModelCatalog(snapshot) {
+    const diagnostics = [];
+    if (!isRecord(snapshot) || snapshot.schemaVersion !== exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION) {
+        return { imported: 0, diagnostics: ['unsupported resolved model catalog snapshot'] };
+    }
+    const aliases = isStringRecord(snapshot.aliases) ? snapshot.aliases : {};
+    (0, modelAliases_1._importModelAliases)(aliases);
+    const contexts = {};
+    const prices = {};
+    const models = isRecord(snapshot.models) ? snapshot.models : {};
+    let imported = 0;
+    for (const [key, rawEntry] of Object.entries(models)) {
+        if (!isResolvedEntry(rawEntry)) {
+            diagnostics.push(`ignored invalid model catalog entry: ${key}`);
+            continue;
+        }
+        const entry = rawEntry;
+        const normalizedKey = key.trim().toLowerCase();
+        const canonicalId = entry.canonicalId.trim().toLowerCase();
+        const context = cloneContext(entry.contextWindow, entry.id, canonicalId);
+        const pricing = clonePricing(entry.pricing, entry.id, canonicalId);
+        // Unresolved facets are not importable facts: pinning a 'default' window
+        // or 'none' pricing would outrank data the importing realm can resolve
+        // (or later learn) on its own.
+        const contextResolved = context.provenance.source !== 'default';
+        const pricingResolved = pricing.provenance.source !== 'none';
+        if (!contextResolved && !pricingResolved) {
+            diagnostics.push(`skipped unresolved model catalog entry: ${key}`);
+            continue;
+        }
+        for (const id of new Set([normalizedKey, entry.id.trim().toLowerCase(), canonicalId])) {
+            if (!id)
+                continue;
+            if (contextResolved)
+                contexts[id] = context;
+            if (pricingResolved)
+                prices[id] = pricing;
+        }
+        imported++;
+    }
+    (0, modelContext_1._setImportedResolvedContextWindows)(contexts);
+    (0, modelInfo_1._setImportedResolvedPricing)(prices);
+    return { imported, diagnostics };
+}
+function cloneContext(value, modelId, canonicalModelId) {
+    return {
+        ...value,
+        modelId,
+        canonicalModelId,
+        provenance: { ...value.provenance },
+    };
+}
+function clonePricing(value, modelId, canonicalModelId) {
+    return {
+        ...value,
+        modelId,
+        canonicalModelId,
+        pricing: value.pricing ? { ...value.pricing } : null,
+        provenance: { ...value.provenance },
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((item) => typeof item === 'string');
+}
+function validPricing(value) {
+    if (!isRecord(value))
+        return false;
+    return [
+        value.inputCostPerMillion,
+        value.outputCostPerMillion,
+        value.cacheWriteCostPerMillion,
+        value.cacheReadCostPerMillion,
+    ].every((item) => typeof item === 'number' && Number.isFinite(item) && item >= 0);
+}
+function isResolvedEntry(value) {
+    if (!isRecord(value) || typeof value.id !== 'string' || typeof value.canonicalId !== 'string') {
+        return false;
+    }
+    const context = value.contextWindow;
+    const pricing = value.pricing;
+    if (!isRecord(context) || !isRecord(pricing))
+        return false;
+    if (typeof context.tierEffective !== 'number' ||
+        !Number.isFinite(context.tierEffective) ||
+        context.tierEffective <= 0 ||
+        (context.published !== null && typeof context.published !== 'number') ||
+        (context.observed !== null && typeof context.observed !== 'number') ||
+        !isRecord(context.provenance) ||
+        !isRecord(pricing.provenance)) {
+        return false;
+    }
+    return pricing.pricing === null || validPricing(pricing.pricing);
+}

package/dist/modelContext.d.ts

@@ -9,13 +9,19 @@
  *      model, persisted across runs by `observedContextWindows.ts`. Reflects the
  *      effective window for this account/tier, which can be well below the
  *      model's published maximum.
- *   3. Catalog overrides — `max_input_tokens` from the LiteLLM catalog, hydrated
+ *   3. Imported resolutions — exact entries hydrated from another realm via
+ *      `importResolvedModelCatalog()`. Below local observed data (a window this
+ *      realm saw first-hand is fresher than a transferred snapshot), above the
+ *      catalog.
+ *   4. Catalog overrides — `max_input_tokens` from the LiteLLM catalog, hydrated
  *      by `pricingCatalog.ts`. Keeps new models correct without a code change.
- *   4. The static table below — offline baseline of last resort.
+ *   5. The static table below — offline baseline of last resort.
  *
  * Within that order, match quality comes first: every layer is tried for an
  * exact hit before any layer is tried for a prefix hit. See
- * `getModelContextWindowSize`.
+ * `getModelContextWindowSize`. The raw (alias) id is tried before its
+ * canonical target at every step, so registering an alias never orphans data
+ * recorded under the alias itself.
  *
  * Layers 2 and 3 are pushed in by Node-only modules through the `_set*` hooks,
  * so this file stays browser-safe (no node:fs, no fetch) and can be bundled for
@@ -23,6 +29,21 @@
  */
 /** Default context window size when model is unknown. */
 export declare const DEFAULT_CONTEXT_WINDOW = 200000;
+export type ModelContextWindowSource = 'explicit-1m' | 'imported' | 'observed' | 'catalog' | 'static' | 'default';
+export type ModelCatalogMatch = 'exact' | 'prefix' | 'default';
+export interface ModelContextWindowProvenance {
+    source: ModelContextWindowSource;
+    match: ModelCatalogMatch;
+    matchedModelId?: string;
+}
+export interface ResolvedModelContextWindow {
+    modelId: string;
+    canonicalModelId: string;
+    published: number | null;
+    observed: number | null;
+    tierEffective: number;
+    provenance: ModelContextWindowProvenance;
+}
 /**
  * Internal: replace the observed-context-window map. Called by
  * `observedContextWindows.ts` on load and on each newly observed value.
@@ -43,6 +64,18 @@ export declare function _setCatalogContextWindows(overrides: Record<string, numb
 export declare function _getCatalogContextWindows(): Record<string, number>;
 /** Internal: clear catalog overrides (used by tests and when disabling hydration). */
 export declare function _clearCatalogContextWindows(): void;
+/**
+ * Internal: hydrate exact, already-resolved context data from another realm.
+ * Merges so successive partial imports accumulate (aliases already merge);
+ * use `_clearImportedResolvedContextWindows` to reset.
+ */
+export declare function _setImportedResolvedContextWindows(values: Record<string, ResolvedModelContextWindow>): void;
+/** Internal test hook. */
+export declare function _clearImportedResolvedContextWindows(): void;
+/** Internal: list every ID known to the context resolver. */
+export declare function _getModelContextIds(): string[];
+/** Resolve published, observed, and tier-effective context windows with provenance. */
+export declare function resolveModelContextWindow(modelId?: string): ResolvedModelContextWindow;
 /**
  * Returns the context window size for a model ID.
  *

package/dist/modelContext.js

@@ -10,13 +10,19 @@
  *      model, persisted across runs by `observedContextWindows.ts`. Reflects the
  *      effective window for this account/tier, which can be well below the
  *      model's published maximum.
- *   3. Catalog overrides — `max_input_tokens` from the LiteLLM catalog, hydrated
+ *   3. Imported resolutions — exact entries hydrated from another realm via
+ *      `importResolvedModelCatalog()`. Below local observed data (a window this
+ *      realm saw first-hand is fresher than a transferred snapshot), above the
+ *      catalog.
+ *   4. Catalog overrides — `max_input_tokens` from the LiteLLM catalog, hydrated
  *      by `pricingCatalog.ts`. Keeps new models correct without a code change.
- *   4. The static table below — offline baseline of last resort.
+ *   5. The static table below — offline baseline of last resort.
  *
  * Within that order, match quality comes first: every layer is tried for an
  * exact hit before any layer is tried for a prefix hit. See
- * `getModelContextWindowSize`.
+ * `getModelContextWindowSize`. The raw (alias) id is tried before its
+ * canonical target at every step, so registering an alias never orphans data
+ * recorded under the alias itself.
  *
  * Layers 2 and 3 are pushed in by Node-only modules through the `_set*` hooks,
  * so this file stays browser-safe (no node:fs, no fetch) and can be bundled for
@@ -30,7 +36,12 @@ exports._clearObservedContextWindows = _clearObservedContextWindows;
 exports._setCatalogContextWindows = _setCatalogContextWindows;
 exports._getCatalogContextWindows = _getCatalogContextWindows;
 exports._clearCatalogContextWindows = _clearCatalogContextWindows;
+exports._setImportedResolvedContextWindows = _setImportedResolvedContextWindows;
+exports._clearImportedResolvedContextWindows = _clearImportedResolvedContextWindows;
+exports._getModelContextIds = _getModelContextIds;
+exports.resolveModelContextWindow = resolveModelContextWindow;
 exports.getModelContextWindowSize = getModelContextWindowSize;
+const modelAliases_1 = require("./modelAliases");
 /** Known model context window sizes (in tokens). */
 const MODEL_CONTEXT_SIZES = {
     // Claude — native 1M context (Fable 5, Opus 4.6+, Sonnet 4.6+)
@@ -92,6 +103,7 @@ let observedTable = {};
 let observedSortedKeys = [];
 let catalogTable = {};
 let catalogSortedKeys = [];
+let importedTable = {};
 function sortKeysLongestFirst(table) {
     return Object.keys(table).sort((a, b) => b.length - a.length);
 }
@@ -145,20 +157,109 @@ function _clearCatalogContextWindows() {
     catalogTable = {};
     catalogSortedKeys = [];
 }
+/**
+ * Internal: hydrate exact, already-resolved context data from another realm.
+ * Merges so successive partial imports accumulate (aliases already merge);
+ * use `_clearImportedResolvedContextWindows` to reset.
+ */
+function _setImportedResolvedContextWindows(values) {
+    importedTable = { ...importedTable, ...values };
+}
+/** Internal test hook. */
+function _clearImportedResolvedContextWindows() {
+    importedTable = {};
+}
+/** Internal: list every ID known to the context resolver. */
+function _getModelContextIds() {
+    return Array.from(new Set([
+        ...Object.keys(MODEL_CONTEXT_SIZES),
+        ...Object.keys(catalogTable),
+        ...Object.keys(observedTable),
+        ...Object.keys(importedTable),
+    ]));
+}
 // ── Lookup ──
 /** Exact match against one table. */
 function exactWindow(table, modelId) {
     const hit = table[modelId];
     return hit === undefined ? null : hit;
 }
-/** Longest-prefix match against one table. */
-function prefixWindow(table, sortedKeys, modelId) {
+function exactWindowMatch(table, modelId) {
+    const exact = exactWindow(table, modelId);
+    return exact === null ? null : { value: exact, match: 'exact', matchedModelId: modelId };
+}
+function prefixWindowMatch(table, sortedKeys, modelId) {
     for (const key of sortedKeys) {
-        if (modelId.startsWith(key))
-            return table[key];
+        if (modelId !== key && modelId.startsWith(key)) {
+            return { value: table[key], match: 'prefix', matchedModelId: key };
+        }
     }
     return null;
 }
+/** Resolve published, observed, and tier-effective context windows with provenance. */
+function resolveModelContextWindow(modelId) {
+    const rawModelId = modelId ?? '';
+    const stripped = rawModelId
+        .replace(/\[1m\]/gi, '')
+        .trim()
+        .toLowerCase();
+    const canonicalModelId = (0, modelAliases_1.resolveModelAlias)(stripped);
+    if (/\[1m\]/i.test(rawModelId) || /\[1m\]/i.test(canonicalModelId)) {
+        return {
+            modelId: rawModelId,
+            canonicalModelId: canonicalModelId.replace(/\[1m\]/gi, ''),
+            published: 1_000_000,
+            observed: null,
+            tierEffective: 1_000_000,
+            provenance: { source: 'explicit-1m', match: 'exact', matchedModelId: canonicalModelId },
+        };
+    }
+    // The raw id is tried before its alias target at every step: data recorded
+    // for the alias id itself is more specific than the canonical fallback.
+    const candidateIds = stripped === canonicalModelId ? [canonicalModelId] : [stripped, canonicalModelId];
+    const firstMatch = (lookup) => {
+        for (const id of candidateIds) {
+            const hit = lookup(id);
+            if (hit)
+                return hit;
+        }
+        return null;
+    };
+    const observedExact = firstMatch((id) => exactWindowMatch(observedTable, id));
+    // Imported resolutions rank below local observed data: a window this realm
+    // saw first-hand is fresher than a snapshot transferred from another realm.
+    if (!observedExact) {
+        const imported = importedTable[stripped] ?? importedTable[canonicalModelId];
+        if (imported) {
+            return { ...imported, modelId: rawModelId, canonicalModelId };
+        }
+    }
+    const catalogExact = firstMatch((id) => exactWindowMatch(catalogTable, id));
+    const staticExact = firstMatch((id) => exactWindowMatch(MODEL_CONTEXT_SIZES, id));
+    const observedPrefix = firstMatch((id) => prefixWindowMatch(observedTable, observedSortedKeys, id));
+    const catalogPrefix = firstMatch((id) => prefixWindowMatch(catalogTable, catalogSortedKeys, id));
+    const staticPrefix = firstMatch((id) => prefixWindowMatch(MODEL_CONTEXT_SIZES, SORTED_KEYS, id));
+    const published = catalogExact ?? staticExact ?? catalogPrefix ?? staticPrefix;
+    const effective = observedExact ?? catalogExact ?? staticExact ?? observedPrefix ?? catalogPrefix ?? staticPrefix;
+    return {
+        modelId: rawModelId,
+        canonicalModelId,
+        published: published?.value ?? null,
+        observed: (observedExact ?? observedPrefix)?.value ?? null,
+        tierEffective: effective?.value ?? exports.DEFAULT_CONTEXT_WINDOW,
+        provenance: effective
+            ? {
+                source: effective === observedExact || effective === observedPrefix
+                    ? 'observed'
+                    : effective === catalogExact || effective === catalogPrefix
+                        ? 'catalog'
+                        : 'static',
+                match: effective.match,
+                matchedModelId: effective.matchedModelId,
+            }
+            : { source: 'default', match: 'default' },
+    };
+}
 /**
  * Returns the context window size for a model ID.
  *
@@ -180,31 +281,5 @@ function prefixWindow(table, sortedKeys, modelId) {
  * of the static table's exact 1M.
  */
 function getModelContextWindowSize(modelId) {
-    if (!modelId)
-        return exports.DEFAULT_CONTEXT_WINDOW;
-    // Claude Code tags the 1M-context variant with a "[1m]" suffix on the
-    // model ID. If we see it, honor it regardless of the base family.
-    if (/\[1m\]/i.test(modelId))
-        return 1_000_000;
-    // Strip the suffix if present, so the normal lookup still succeeds when
-    // a caller passes e.g. "claude-opus-5[1m]" and we've already handled it.
-    // Trim/lowercase so padded or mixed-case IDs match the lowercase table keys.
-    const normalized = modelId
-        .replace(/\[1m\]/gi, '')
-        .trim()
-        .toLowerCase();
-    // Pass 1 — exact matches, most-trusted layer first.
-    const exact = exactWindow(observedTable, normalized) ??
-        exactWindow(catalogTable, normalized) ??
-        exactWindow(MODEL_CONTEXT_SIZES, normalized);
-    if (exact !== null)
-        return exact;
-    // Pass 2 — longest-prefix matches, same layer order. Resolves versioned IDs
-    // that no layer spells out, e.g. "claude-opus-4-6-20250414".
-    const prefix = prefixWindow(observedTable, observedSortedKeys, normalized) ??
-        prefixWindow(catalogTable, catalogSortedKeys, normalized) ??
-        prefixWindow(MODEL_CONTEXT_SIZES, SORTED_KEYS, normalized);
-    if (prefix !== null)
-        return prefix;
-    return exports.DEFAULT_CONTEXT_WINDOW;
+    return resolveModelContextWindow(modelId).tierEffective;
 }

package/dist/modelInfo.d.ts

@@ -17,6 +17,8 @@
  *
  * @module modelInfo
  */
+import type { ModelProviderId } from './providerIds';
+export { MODEL_PROVIDER_IDS } from './providerIds';
 /** Pricing information for a model. All costs are per million tokens in USD. */
 export interface ModelPricing {
     inputCostPerMillion: number;
@@ -24,6 +26,21 @@ export interface ModelPricing {
     cacheWriteCostPerMillion: number;
     cacheReadCostPerMillion: number;
 }
+export type ModelPricingSource = 'imported' | 'catalog' | 'static' | 'none';
+export type ModelPricingMatch = 'exact' | 'prefix' | 'none';
+export interface ModelPricingProvenance {
+    source: ModelPricingSource;
+    match: ModelPricingMatch;
+    matchedModelId?: string;
+    /** True when the price was inherited from a shorter model-ID prefix. */
+    inheritedByPrefix: boolean;
+}
+export interface ResolvedModelPricing {
+    modelId: string;
+    canonicalModelId: string;
+    pricing: ModelPricing | null;
+    provenance: ModelPricingProvenance;
+}
 /**
  * Token usage for the legacy cost calculation contract.
  * @deprecated Use NormalizedUsage and calculateNormalizedUsageCost. This shape
@@ -42,7 +59,7 @@ export interface CostTokenUsage {
     reasoningTokens?: number;
 }
 /** Provider that hosts a model. "unknown" means we couldn't classify it. */
-export type ModelProvider = 'anthropic' | 'openai' | 'google' | 'unknown';
+export type ModelProvider = ModelProviderId;
 /** Structured result of parsing a raw model ID. */
 export interface ParsedModelId {
     provider: ModelProvider;
@@ -93,6 +110,16 @@ export declare function _setPricingOverrides(overrides: Record<string, ModelPric
 export declare function _getPricingOverrides(): Record<string, ModelPricing>;
 /** Internal: clear overrides (used by tests and when disabling hydration). */
 export declare function _clearPricingOverrides(): void;
+/**
+ * Internal: hydrate exact pricing resolutions exported by another realm.
+ * Merges so successive partial imports accumulate (aliases already merge);
+ * use `_clearImportedResolvedPricing` to reset.
+ */
+export declare function _setImportedResolvedPricing(values: Record<string, ResolvedModelPricing>): void;
+/** Internal test hook. */
+export declare function _clearImportedResolvedPricing(): void;
+/** Internal: list every ID known to the pricing resolver. */
+export declare function _getModelPricingIds(): string[];
 /**
  * Parses a model ID into {provider, family, version}.
  *
@@ -103,6 +130,8 @@ export declare function _clearPricingOverrides(): void;
  * Returns null for anything else — callers should treat that as "unknown model".
  */
 export declare function parseModelId(modelId: string): ParsedModelId | null;
+/** Resolve pricing and disclose whether the result was inherited by prefix. */
+export declare function resolveModelPricing(modelId: string): ResolvedModelPricing;
 /**
  * Gets pricing for a model ID.
  *

package/dist/modelInfo.js

@@ -19,10 +19,15 @@
  * @module modelInfo
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PROVIDER_IDS = void 0;
 exports._setPricingOverrides = _setPricingOverrides;
 exports._getPricingOverrides = _getPricingOverrides;
 exports._clearPricingOverrides = _clearPricingOverrides;
+exports._setImportedResolvedPricing = _setImportedResolvedPricing;
+exports._clearImportedResolvedPricing = _clearImportedResolvedPricing;
+exports._getModelPricingIds = _getModelPricingIds;
 exports.parseModelId = parseModelId;
+exports.resolveModelPricing = resolveModelPricing;
 exports.getModelPricing = getModelPricing;
 exports.getModelInfo = getModelInfo;
 exports.calculateCostWithPricing = calculateCostWithPricing;
@@ -35,6 +40,9 @@ exports.compareModelIds = compareModelIds;
 exports.sortModelIds = sortModelIds;
 exports.formatCost = formatCost;
 const modelContext_1 = require("./modelContext");
+const modelAliases_1 = require("./modelAliases");
+var providerIds_1 = require("./providerIds");
+Object.defineProperty(exports, "MODEL_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.MODEL_PROVIDER_IDS; } });
 // ── Static Pricing Table ──
 /**
  * Static baseline pricing. Keys are model-ID prefixes; lookup uses
@@ -412,6 +420,7 @@ const STATIC_SORTED_KEYS = Object.keys(PRICING_TABLE).sort((a, b) => b.length -
 // ── Override Table (populated at runtime by pricingCatalog) ──
 let overrideTable = {};
 let overrideSortedKeys = [];
+let importedTable = {};
 /**
  * Internal: replace the runtime override map. Called by `pricingCatalog.ts`
  * after a successful LiteLLM hydration. Not part of the stable public API,
@@ -419,7 +428,7 @@ let overrideSortedKeys = [];
  * creating a circular import.
  */
 function _setPricingOverrides(overrides) {
-    overrideTable = { ...overrides };
+    overrideTable = Object.fromEntries(Object.entries(overrides).map(([key, value]) => [key.trim().toLowerCase(), { ...value }]));
     overrideSortedKeys = Object.keys(overrideTable).sort((a, b) => b.length - a.length);
 }
 /** Internal: snapshot current overrides (test + diagnostics). */
@@ -431,6 +440,26 @@ function _clearPricingOverrides() {
     overrideTable = {};
     overrideSortedKeys = [];
 }
+/**
+ * Internal: hydrate exact pricing resolutions exported by another realm.
+ * Merges so successive partial imports accumulate (aliases already merge);
+ * use `_clearImportedResolvedPricing` to reset.
+ */
+function _setImportedResolvedPricing(values) {
+    importedTable = { ...importedTable, ...values };
+}
+/** Internal test hook. */
+function _clearImportedResolvedPricing() {
+    importedTable = {};
+}
+/** Internal: list every ID known to the pricing resolver. */
+function _getModelPricingIds() {
+    return Array.from(new Set([
+        ...Object.keys(PRICING_TABLE),
+        ...Object.keys(overrideTable),
+        ...Object.keys(importedTable),
+    ]));
+}
 // ── 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
@@ -454,10 +483,7 @@ const GEMINI_RE = /^gemini-([0-9][0-9.A-Za-z-]*)/i;
 function parseModelId(modelId) {
     if (!modelId)
         return null;
-    const normalized = modelId
-        .replace(/\[1m\]/gi, '')
-        .trim()
-        .toLowerCase();
+    const normalized = (0, modelAliases_1.resolveModelAlias)(modelId.replace(/\[1m\]/gi, ''));
     const claude = normalized.match(CLAUDE_RE);
     if (claude) {
         return {
@@ -490,27 +516,96 @@ function parseModelId(modelId) {
     return null;
 }
 // ── Pricing Lookup ──
-/** Find the longest key in `keys` that is a prefix of `modelId`, or null. */
+/** Find the longest shorter key in `keys` that is a prefix of `modelId`, or null. */
 function findLongestPrefix(keys, modelId) {
     for (const key of keys) {
-        if (modelId === key || modelId.startsWith(key))
+        if (modelId !== key && modelId.startsWith(key))
             return key;
     }
     return null;
 }
-/** Override-then-static lookup, exact then longest-prefix at each stage. */
-function lookupPricing(modelId) {
-    if (overrideTable[modelId])
-        return overrideTable[modelId];
-    const overridePrefix = findLongestPrefix(overrideSortedKeys, modelId);
-    if (overridePrefix)
-        return overrideTable[overridePrefix];
-    if (PRICING_TABLE[modelId])
-        return PRICING_TABLE[modelId];
-    const staticPrefix = findLongestPrefix(STATIC_SORTED_KEYS, modelId);
-    if (staticPrefix)
-        return PRICING_TABLE[staticPrefix];
-    return null;
+/** Resolve pricing and disclose whether the result was inherited by prefix. */
+function resolveModelPricing(modelId) {
+    const stripped = modelId.replace(/\[1m\]/gi, '');
+    const rawId = stripped.trim().toLowerCase();
+    const canonicalModelId = (0, modelAliases_1.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];
+    if (imported)
+        return { ...imported, modelId, canonicalModelId };
+    for (const id of candidateIds) {
+        const exactOverride = overrideTable[id];
+        if (exactOverride) {
+            return {
+                modelId,
+                canonicalModelId,
+                pricing: exactOverride,
+                provenance: {
+                    source: 'catalog',
+                    match: 'exact',
+                    matchedModelId: id,
+                    inheritedByPrefix: false,
+                },
+            };
+        }
+    }
+    for (const id of candidateIds) {
+        const exactStatic = PRICING_TABLE[id];
+        if (exactStatic) {
+            return {
+                modelId,
+                canonicalModelId,
+                pricing: exactStatic,
+                provenance: {
+                    source: 'static',
+                    match: 'exact',
+                    matchedModelId: id,
+                    inheritedByPrefix: false,
+                },
+            };
+        }
+    }
+    for (const id of candidateIds) {
+        const overridePrefix = findLongestPrefix(overrideSortedKeys, id);
+        if (overridePrefix) {
+            return {
+                modelId,
+                canonicalModelId,
+                pricing: overrideTable[overridePrefix],
+                provenance: {
+                    source: 'catalog',
+                    match: 'prefix',
+                    matchedModelId: overridePrefix,
+                    inheritedByPrefix: true,
+                },
+            };
+        }
+    }
+    for (const id of candidateIds) {
+        const staticPrefix = findLongestPrefix(STATIC_SORTED_KEYS, id);
+        if (staticPrefix) {
+            return {
+                modelId,
+                canonicalModelId,
+                pricing: PRICING_TABLE[staticPrefix],
+                provenance: {
+                    source: 'static',
+                    match: 'prefix',
+                    matchedModelId: staticPrefix,
+                    inheritedByPrefix: true,
+                },
+            };
+        }
+    }
+    return {
+        modelId,
+        canonicalModelId,
+        pricing: null,
+        provenance: { source: 'none', match: 'none', inheritedByPrefix: false },
+    };
 }
 /**
  * Gets pricing for a model ID.
@@ -530,12 +625,7 @@ function lookupPricing(modelId) {
 function getModelPricing(modelId) {
     if (!modelId)
         return null;
-    const stripped = modelId.replace(/\[1m\]/gi, '');
-    const direct = lookupPricing(stripped);
-    if (direct)
-        return direct;
-    const normalized = stripped.trim().toLowerCase();
-    return normalized === stripped ? null : lookupPricing(normalized);
+    return resolveModelPricing(modelId).pricing;
 }
 /**
  * Returns comprehensive metadata for a model ID.