@oh-my-pi/pi-catalog 18.1.5 → 18.1.8

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.1.8] - 2026-09-03
+
+### Added
+
+- Added GPT-6 Astra to the OpenAI Codex model catalog, including support for configuration updates and requests using the freeform `apply_patch` tool.
+
+### Fixed
+
+- Fixed `omp models refresh` so revoked ChatGPT account tokens no longer prevent the remaining OpenAI Codex models from being discovered.
+
+## [18.1.6] - 2026-09-03
+
+### Added
+
+- Added catalog-delivered model intelligence scores and estimated output throughput to help compare model capabilities and performance.
+
+### Changed
+
+- Improved model search and selection so configured roles, provider preferences, and recent usage are prioritized while browsing and filtering models.
+
 ## [18.1.5] - 2026-09-03
 
 ### Added

package/dist/types/discovery/codex.d.ts

@@ -26,6 +26,13 @@ export interface CodexModelDiscoveryOptions {
 export interface CodexModelDiscoveryResult {
     models: ModelSpec<"openai-codex-responses">[];
     etag?: string;
+    /**
+     * Set when the backend rejected the credential itself (401/403, e.g.
+     * `token_revoked`); `models` is empty. A definitive per-account denial,
+     * unlike the `null` result for transport/parse failures, so multi-account
+     * discovery can skip the account instead of aborting.
+     */
+    rejectedStatus?: 401 | 403;
 }
 /**
  * Fetches model metadata from Codex backend and normalizes it for pi model management.

package/dist/types/identity/metrics.d.ts

@@ -0,0 +1,28 @@
+import type { Api, Model } from "../types.js";
+/** Catalog-delivered intelligence score and output speed for one model. */
+export interface CatalogMetrics {
+    int?: number;
+    tps?: number;
+}
+/** The catalog metrics a model carries, or undefined when it reports none. A zero speed is "unmeasured", not a score. */
+export declare function catalogMetricsOf(model: Model<Api>): CatalogMetrics | undefined;
+/**
+ * Index of catalog metrics over every scored model seen so far. Built once per
+ * discovery cycle by the model registry and per provider by the model manager;
+ * `add` accumulates across providers so a proxy id resolves against any host's
+ * scored row.
+ */
+export declare class CatalogMetricsIndex {
+    #private;
+    constructor(models?: Iterable<Model<Api>>);
+    get isEmpty(): boolean;
+    /** Record the metrics of every scored model; later rows fill fields earlier rows left unset. */
+    add(models: Iterable<Model<Api>>): void;
+    /** Metrics for `model` by exact id, else by dialect-normalized id when the classified identities agree. */
+    resolve(model: Model<Api>): CatalogMetrics | undefined;
+}
+/**
+ * Fill each model's `int`/`tps` from `index`. Returns the input array when no
+ * model changed so callers can keep identity-based caches.
+ */
+export declare function applyCatalogMetrics<TApi extends Api>(models: Model<TApi>[], index: CatalogMetricsIndex): Model<TApi>[];

package/dist/types/identity/reference.d.ts

@@ -9,6 +9,13 @@ export declare function isZeroCostXaiOAuthReference(candidate: Model<Api>): bool
  * Pure: callers are responsible for memoizing the result.
  */
 export declare function buildModelReferenceIndex(models: Iterable<Model<Api>>): ModelReferenceIndex;
+/**
+ * Expand a proxied/affixed model id into the ids it may be catalogued under,
+ * least-stripped first: bracket affixes, model-like segments, `:cloud`,
+ * namespace prefix, `:`→`-`, lowercase, and declared trailing markers.
+ * Shared by reference recovery and catalog-metric matching (`./metrics`).
+ */
+export declare function getReferenceCandidateIds(modelId: string): string[];
 /**
  * Inherit bundled reference thinking only for same-provider matches. Wire routing
  * (`effortRouting`) is provider-specific; cross-provider inheritance can rewrite

package/dist/types/provider-models/openai-compat.d.ts

@@ -31,6 +31,8 @@ export interface ModelsDevModel {
     provider?: {
         npm?: string;
     };
+    int?: number;
+    tps?: number;
 }
 /**
  * Fetches the models.dev catalog via catalog.stencil.so, which serves a

package/dist/types/types.d.ts

@@ -700,6 +700,13 @@ export interface ResolvedOpenAIResponsesCompat extends ResolvedOpenAISharedCompa
      * transport; earlier ids reject the value.
      */
     supportsAllTurnsReasoningContext: boolean;
+    /**
+     * Whether a `configuration_update` input item may change `reasoning.effort`
+     * mid-conversation while the request-level effort stays byte-stable for
+     * prompt caching. Rule-owned: GPT-6 Astra only; every other model rejects
+     * the item type with 400.
+     */
+    supportsConfigurationUpdate: boolean;
     /** Inject the `# Juice: 0 !important` developer item when reasoning is forced off (gpt-5.6+). */
     requiresReasoningOffJuiceInstruction: boolean;
     /**
@@ -997,6 +1004,10 @@ export interface Model<TApi extends Api = Api> {
     isRecommended?: boolean;
     /** Canonical thinking capability metadata for this model. */
     thinking?: ThinkingConfig;
+    /** Intelligence score delivered by the model catalog. */
+    int?: number | null;
+    /** Catalog-estimated output speed in tokens per second. */
+    tps?: number | null;
     /**
      * Fully-resolved compatibility record, materialized once by `buildModel`.
      * Protocol handlers read fields; they never detect, resolve, or allocate.
@@ -1031,6 +1042,12 @@ export interface Model<TApi extends Api = Api> {
     guardrailVersion?: string;
     /** Bedrock guardrail trace verbosity. */
     guardrailTrace?: "enabled" | "disabled" | "enabled_full";
+    /**
+     * Bedrock invocation-log tags attached to every Converse request for this
+     * model. Set from `providers.<provider>.requestMetadata`; the Bedrock
+     * transport reads it directly and validates it against AWS's limits.
+     */
+    requestMetadata?: Record<string, string>;
 }
 /**
  * A model as authored by configs, bundled catalogs, and discovery — the input

package/dist/types/wire/codex.d.ts

@@ -4,8 +4,12 @@
 export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 /**
  * Pinned OpenAI Codex client version (corresponds to @openai/codex package version).
+ *
+ * The backend version-gates model availability against this value on both
+ * `/models?client_version=` and `/responses` (`gpt-6-astra` requires ≥ 0.153.0);
+ * an older pin silently hides newer SKUs from discovery.
  */
-export declare const CODEX_CLIENT_VERSION = "0.144.1";
+export declare const CODEX_CLIENT_VERSION = "0.153.0";
 export declare const OPENAI_HEADERS: {
     readonly BETA: "OpenAI-Beta";
     /** Codex feature-negotiation header; values identify opt-in wire protocols. */
@@ -28,18 +32,32 @@ export declare const OPENAI_HEADERS: {
     readonly ATTESTATION: "x-oai-attestation";
     /** Client-declared data residency for region-pinned enterprise workspaces. */
     readonly RESIDENCY: "x-openai-internal-codex-residency";
+    /**
+     * Model routing hint (codex-rs `X_CODEX_ROUTING_HINT_HEADER`): `model=<slug>`
+     * or `model=<slug>;tier=<service_tier>`; sent on every ChatGPT-OAuth
+     * Responses, compaction, and WebSocket handshake request. Built by
+     * {@link codexRoutingHint}.
+     */
+    readonly ROUTING_HINT: "x-codex-routing-hint";
 };
 export declare const OPENAI_HEADER_VALUES: {
     readonly BETA_RESPONSES: "responses=experimental";
     readonly BETA_RESPONSES_WEBSOCKETS_V2: "responses_websockets=2026-02-06";
     readonly REMOTE_COMPACTION_V2: "remote_compaction_v2";
-    readonly ORIGINATOR_CODEX: "pi";
+    readonly ORIGINATOR_CODEX: "omp";
 };
 export declare const URL_PATHS: {
     readonly RESPONSES: "/responses";
     readonly CODEX_RESPONSES: "/codex/responses";
 };
 export declare const JWT_CLAIM_PATH: "https://api.openai.com/auth";
+/**
+ * Build the `x-codex-routing-hint` value for a request (codex-rs
+ * `build_routing_hint_header`): the requested model slug plus the explicit
+ * service tier when one is set. Callers set it only on ChatGPT-OAuth requests
+ * to the Codex backend; API-key OpenAI traffic never carries it.
+ */
+export declare function codexRoutingHint(model: string, serviceTier: string | null | undefined): string;
 /**
  * Extract account ID from a Codex JWT access token.
  * Returns undefined if the token is not a valid Codex JWT.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.1.5",
+	"version": "18.1.8",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,12 +35,12 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.5",
-		"@oh-my-pi/pi-utils": "18.1.5"
+		"@oh-my-pi/omptype": "18.1.8",
+		"@oh-my-pi/pi-utils": "18.1.8"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.1.5",
+		"@oh-my-pi/pi-ai": "18.1.8",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/compat/axes.ts

@@ -128,6 +128,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"strict-responses-pairing": wire("strictResponsesPairing", ["openai-responses"]),
 	"requires-reasoning-off-juice-instruction": wire("requiresReasoningOffJuiceInstruction", ["openai-responses"]),
 	"supports-all-turns-reasoning-context": wire("supportsAllTurnsReasoningContext", ["openai-responses"]),
+	"supports-configuration-update": wire("supportsConfigurationUpdate", ["openai-responses"]),
 	"strip-deepseek-special-tokens": wire("stripDeepseekSpecialTokens", OAI),
 	"stream-markup-healing-pattern": wire("streamMarkupHealingPattern", OAI, "scalar", [
 		"kimi",

package/src/compat/resolve.ts

@@ -714,6 +714,7 @@ function resolveOpenAIResponsesPolicy(
 		supportsImageDetailOriginal: !isXaiHost && !modelMatchesHost(hostModel, "githubCopilot"),
 		supportsReasoningSummary: !isXaiHost,
 		supportsAllTurnsReasoningContext: false,
+		supportsConfigurationUpdate: false,
 		requiresReasoningOffJuiceInstruction: false,
 		stripImageInput: false,
 		thinkingLoopGuard: undefined,
@@ -815,6 +816,7 @@ function pickResponsesOnly(compat: ResolvedOpenAIResponsesCompat): ResponsesOnly
 		supportsImageDetailOriginal: compat.supportsImageDetailOriginal,
 		supportsObfuscationOptOut: compat.supportsObfuscationOptOut,
 		supportsAllTurnsReasoningContext: compat.supportsAllTurnsReasoningContext,
+		supportsConfigurationUpdate: compat.supportsConfigurationUpdate,
 		officialEndpoint: compat.officialEndpoint,
 		harmonyLeakMitigation: compat.harmonyLeakMitigation,
 		cacheControlFormat: compat.cacheControlFormat,

package/src/compat/rules/auth/openai-codex.kdl

@@ -8,7 +8,7 @@ auth "openai-codex" {
 		authorize-params {
 			id_token_add_organizations "true"
 			codex_cli_simplified_flow "true"
-			originator "pi"
+			originator "omp"
 		}
 		instructions "A browser window should open. Complete login to finish."
 		// OpenAI only allowlists this exact URI; a busy port must fail rather than fall back.

package/src/compat/rules/classes/openai.kdl

@@ -30,6 +30,12 @@ class "openai" {
 		thinking-efforts "low" "medium" "high" "xhigh" "max"
 		requires-reasoning-off-juice-instruction #true
 	}
+	// GPT-6 Astra changes reasoning effort mid-conversation through a
+	// `configuration_update` input item so the request-level effort (and the
+	// cached prompt prefix) stays put; every other SKU 400s on the item type.
+	models "gpt-6-astra" {
+		supports-configuration-update #true
+	}
 	// Codex SKUs: the advertised 400K figure includes the output budget; the
 	// true prompt window is 272K. Spark budgets are its own family's.
 	family "codex" {

package/src/compat/rules/providers/openai-codex.kdl

@@ -69,9 +69,9 @@ provider "openai-codex" {
 				}
 			}
 		}
-		// First-party GPT-5 Responses SKUs support the freeform apply_patch
+		// First-party GPT-5/GPT-6 Responses SKUs support the freeform apply_patch
 		// custom tool with a Lark grammar.
-		revision ">=5 <6" {
+		revision ">=5 <7" {
 			apply-patch-tool-type "freeform"
 		}
 	}

package/src/compat/rules/providers/openai.kdl

@@ -40,7 +40,7 @@ provider "openai" {
 				reasoning-disable-mode "none-effort"
 			}
 		}
-		revision ">=5 <6" {
+		revision ">=5 <7" {
 			apply-patch-tool-type "freeform"
 		}
 	}

package/src/compat/rules.json

@@ -6226,6 +6226,19 @@
 			{
 				"source": "classes/openai.kdl:36",
 				"class": "openai",
+				"models": [
+					{
+						"kind": "exact",
+						"value": "gpt-6-astra"
+					}
+				],
+				"wire": {
+					"supportsConfigurationUpdate": true
+				}
+			},
+			{
+				"source": "classes/openai.kdl:42",
+				"class": "openai",
 				"family": "codex",
 				"revision": [
 					{
@@ -10650,7 +10663,7 @@
 					},
 					{
 						"op": "<",
-						"revision": "6.0.0"
+						"revision": "7.0.0"
 					}
 				],
 				"catalog": {
@@ -10955,7 +10968,7 @@
 					},
 					{
 						"op": "<",
-						"revision": "6.0.0"
+						"revision": "7.0.0"
 					}
 				],
 				"catalog": {
@@ -14919,7 +14932,7 @@
 					"authorizeParams": {
 						"id_token_add_organizations": "true",
 						"codex_cli_simplified_flow": "true",
-						"originator": "pi"
+						"originator": "omp"
 					},
 					"clientId": {
 						"value": "app_EMoamEEZ73f0CkXaXp7hrann"

package/src/discovery/codex.ts

@@ -110,6 +110,13 @@ export interface CodexModelDiscoveryOptions {
 export interface CodexModelDiscoveryResult {
 	models: ModelSpec<"openai-codex-responses">[];
 	etag?: string;
+	/**
+	 * Set when the backend rejected the credential itself (401/403, e.g.
+	 * `token_revoked`); `models` is empty. A definitive per-account denial,
+	 * unlike the `null` result for transport/parse failures, so multi-account
+	 * discovery can skip the account instead of aborting.
+	 */
+	rejectedStatus?: 401 | 403;
 }
 
 /**
@@ -139,6 +146,9 @@ export async function fetchCodexModels(options: CodexModelDiscoveryOptions): Pro
 			continue;
 		}
 
+		if (response.status === 401 || response.status === 403) {
+			return { models: [], rejectedStatus: response.status };
+		}
 		if (!response.ok) {
 			continue;
 		}

package/src/identity/metrics.ts

@@ -0,0 +1,165 @@
+/**
+ * Catalog metric lookup (intelligence / speed scores) across provider id
+ * dialects. The shared catalog scores a model once under its vendor id
+ * (`claude-fable-5-1`); hosts re-spell it (`anthropic/claude-fable-5.1`,
+ * `global.anthropic.claude-fable-5-1`, `claude-fable-5-1-high`, `k3`), so an
+ * index keyed by exact id leaves most of the picker blank.
+ *
+ * Resolution order, first hit wins:
+ * 1. exact lowercased id;
+ * 2. candidate ids derived from the wire id (namespace and dotted vendor/region
+ *    prefixes, bracket affixes, date/`vN:0` suffixes, declared markers, the
+ *    taxonomy logical id) compared on a dot/colon-folded bare name, accepted
+ *    only when the classified identities agree.
+ *
+ * Identity alone (class/family/revision) is deliberately not a key: it
+ * conflates `gpt-5.5` with `gpt-5.5-pro` and every Llama with the one that
+ * happens to be scored.
+ */
+import type { ModelIdentity } from "../compat/types";
+import type { Api, Model } from "../types";
+import { bareModelId } from "./id";
+import { getReferenceCandidateIds } from "./reference";
+
+/** Catalog-delivered intelligence score and output speed for one model. */
+export interface CatalogMetrics {
+	int?: number;
+	tps?: number;
+}
+
+interface ScoredEntry extends CatalogMetrics {
+	identity: ModelIdentity;
+}
+
+/** Trailing tokens Bedrock-style ids append without changing the model: `-v1:0`, `-v2`, `:0`, `-20251001`, `-2026-04-23`. */
+const STRIPPABLE_SUFFIX_PATTERN = /(?:-v\d+(?::\d+)?|:\d+|-\d{2,})$/;
+/** Leading alphabetic dotted namespaces: `global.anthropic.`, `us-gov.`, `openai.`. */
+const DOTTED_PREFIX_PATTERN = /^[a-z][a-z-]*\./;
+
+function canonicalKey(id: string): string {
+	return bareModelId(id).toLowerCase().replace(/[.:]/g, "-");
+}
+
+/** Whether two classified identities may describe the same scored model. Unset ranks on either side are not evidence. */
+function identitiesAgree(left: ModelIdentity, right: ModelIdentity): boolean {
+	if (left.class !== right.class || left.class === "unknown") return false;
+	if (left.family !== undefined && right.family !== undefined && left.family !== right.family) return false;
+	if (left.revision !== undefined && right.revision !== undefined && left.revision !== right.revision) return false;
+	if (left.effort !== undefined && right.effort !== undefined && left.effort !== right.effort) return false;
+	return (left.thinkingVariant ?? false) === (right.thinkingVariant ?? false);
+}
+
+/** The catalog metrics a model carries, or undefined when it reports none. A zero speed is "unmeasured", not a score. */
+export function catalogMetricsOf(model: Model<Api>): CatalogMetrics | undefined {
+	const int = model.int != null && Number.isFinite(model.int) ? model.int : undefined;
+	const tps = model.tps != null && Number.isFinite(model.tps) && model.tps > 0 ? model.tps : undefined;
+	if (int === undefined && tps === undefined) return undefined;
+	return { ...(int !== undefined ? { int } : {}), ...(tps !== undefined ? { tps } : {}) };
+}
+
+// Wire ids form a bounded set (bundled + discovered), so no eviction is needed.
+const candidateCache = new Map<string, string[]>();
+
+/** Candidate ids for `modelId`, least-stripped first, each already canonical-keyed. */
+function metricCandidateKeys(modelId: string): string[] {
+	const cached = candidateCache.get(modelId);
+	if (cached) return cached;
+	const keys: string[] = [];
+	const seen = new Set<string>();
+	const queue = getReferenceCandidateIds(modelId);
+	for (let index = 0; index < queue.length; index++) {
+		const candidate = queue[index].toLowerCase();
+		const key = canonicalKey(candidate);
+		if (!seen.has(key)) {
+			seen.add(key);
+			keys.push(key);
+		}
+		const bare = bareModelId(candidate);
+		const withoutPrefix = bare.replace(DOTTED_PREFIX_PATTERN, "");
+		if (withoutPrefix !== bare && withoutPrefix.length > 0) queue.push(withoutPrefix);
+		const withoutSuffix = bare.replace(STRIPPABLE_SUFFIX_PATTERN, "");
+		if (withoutSuffix !== bare && withoutSuffix.length > 0) queue.push(withoutSuffix);
+	}
+	candidateCache.set(modelId, keys);
+	return keys;
+}
+
+/**
+ * Index of catalog metrics over every scored model seen so far. Built once per
+ * discovery cycle by the model registry and per provider by the model manager;
+ * `add` accumulates across providers so a proxy id resolves against any host's
+ * scored row.
+ */
+export class CatalogMetricsIndex {
+	#exact = new Map<string, CatalogMetrics>();
+	#canonical = new Map<string, ScoredEntry>();
+
+	constructor(models?: Iterable<Model<Api>>) {
+		if (models) this.add(models);
+	}
+
+	get isEmpty(): boolean {
+		return this.#exact.size === 0;
+	}
+
+	/** Record the metrics of every scored model; later rows fill fields earlier rows left unset. */
+	add(models: Iterable<Model<Api>>): void {
+		for (const model of models) {
+			const metrics = catalogMetricsOf(model);
+			if (!metrics) continue;
+			const exactKey = model.id.toLowerCase();
+			const existing = this.#exact.get(exactKey);
+			this.#exact.set(exactKey, existing ? { ...metrics, ...existing } : metrics);
+
+			const canonical = canonicalKey(model.id);
+			const scored = this.#canonical.get(canonical);
+			if (!scored) this.#canonical.set(canonical, { ...metrics, identity: model.identity });
+			else if (scored.int === undefined || scored.tps === undefined) {
+				this.#canonical.set(canonical, { ...metrics, ...scored });
+			}
+		}
+	}
+
+	/** Metrics for `model` by exact id, else by dialect-normalized id when the classified identities agree. */
+	resolve(model: Model<Api>): CatalogMetrics | undefined {
+		const exact = this.#exact.get(model.id.toLowerCase());
+		if (exact) return exact;
+		const identity = model.identity;
+		const ids = identity.logicalId ? [model.id, identity.logicalId] : [model.id];
+		for (const id of ids) {
+			for (const key of metricCandidateKeys(id)) {
+				const scored = this.#canonical.get(key);
+				if (scored && identitiesAgree(identity, scored.identity)) return scored;
+			}
+		}
+		return undefined;
+	}
+}
+
+/**
+ * Fill each model's `int`/`tps` from `index`. Returns the input array when no
+ * model changed so callers can keep identity-based caches.
+ */
+export function applyCatalogMetrics<TApi extends Api>(
+	models: Model<TApi>[],
+	index: CatalogMetricsIndex,
+): Model<TApi>[] {
+	if (index.isEmpty) return models;
+	let changed: Model<TApi>[] | undefined;
+	for (let position = 0; position < models.length; position++) {
+		const model = models[position];
+		if (model.int != null && model.tps != null) continue;
+		const metrics = index.resolve(model);
+		if (!metrics) continue;
+		const int = metrics.int ?? model.int;
+		const tps = metrics.tps ?? model.tps;
+		if (int === model.int && tps === model.tps) continue;
+		changed ??= [...models];
+		changed[position] = {
+			...model,
+			...(int != null ? { int } : {}),
+			...(tps != null ? { tps } : {}),
+		};
+	}
+	return changed ?? models;
+}

package/src/identity/reference.ts

@@ -119,7 +119,13 @@ function stripReferenceTrailingMarker(candidate: string): string | undefined {
 	return suffixLength > 0 && suffixLength < candidate.length ? candidate.slice(0, -suffixLength) : undefined;
 }
 
-function getReferenceCandidateIds(modelId: string): string[] {
+/**
+ * Expand a proxied/affixed model id into the ids it may be catalogued under,
+ * least-stripped first: bracket affixes, model-like segments, `:cloud`,
+ * namespace prefix, `:`→`-`, lowercase, and declared trailing markers.
+ * Shared by reference recovery and catalog-metric matching (`./metrics`).
+ */
+export function getReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
 	const queue = [modelId];
 	for (let index = 0; index < queue.length; index += 1) {

package/src/model-manager.ts

@@ -1,5 +1,6 @@
 import { buildModel } from "./build";
 import { collapseBuiltVariants } from "./compat/collapse";
+import { applyCatalogMetrics, CatalogMetricsIndex } from "./identity/metrics";
 import { readModelCache, writeModelCache } from "./model-cache";
 import { type GeneratedProvider, getBundledModels } from "./models";
 import type { Api, Model, ModelCost, ModelSpec, Provider, TokenCost } from "./types";
@@ -257,7 +258,7 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 			? restoredCache.models.filter(model => !additiveStaticModelIds.has(model.id))
 			: restoredCache.models;
 		const cachedModels = additiveStaticModelIds
-			? mergeDynamicModels(staticModels, cacheContribution)
+			? mergeCatalogMetrics(mergeDynamicModels(staticModels, cacheContribution), restoredCache.models)
 			: restoredCache.models;
 		const source: ModelResolutionSource = cacheContribution.length > 0 ? "cache" : "bundled";
 		return {
@@ -312,7 +313,11 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		: modelsDevFetchSucceeded;
 	const mergedWithCache = mergeDynamicModels(staticModels, cacheModels);
 	const mergedWithModelsDev = mergeDynamicModels(mergedWithCache, modelsDevModels);
-	const mergedModels = mergeDynamicModels(mergedWithModelsDev, dynamicModels);
+	const catalogMetricsSource = modelsDevFetchSucceeded ? normalizedModelsDevModels : preparedCacheModels;
+	const mergedWithCatalogMetrics = additiveStaticModelIds
+		? mergeCatalogMetrics(mergedWithModelsDev, catalogMetricsSource)
+		: mergedWithModelsDev;
+	const mergedModels = mergeDynamicModels(mergedWithCatalogMetrics, dynamicModels);
 	const models = collapseBuiltVariants(
 		authoritativeDynamicFetchSucceeded ? retainModelIds(mergedModels, dynamicModels) : mergedModels,
 	);
@@ -467,6 +472,14 @@ function prepareCacheModelsForStaticMismatch<TApi extends Api>(
 	return sanitizedModels;
 }
 
+function mergeCatalogMetrics<TApi extends Api>(
+	models: Model<TApi>[],
+	catalogModels: readonly Model<TApi>[],
+): Model<TApi>[] {
+	if (models.length === 0 || catalogModels.length === 0) return models;
+	return applyCatalogMetrics(models, new CatalogMetricsIndex(catalogModels));
+}
+
 function mergeDynamicModels<TApi extends Api>(
 	baseModels: readonly Model<TApi>[],
 	dynamicModels: readonly Model<TApi>[],