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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [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/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

@@ -997,6 +997,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 +1035,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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.1.5",
+	"version": "18.1.6",
 	"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.6",
+		"@oh-my-pi/pi-utils": "18.1.6"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.1.5",
+		"@oh-my-pi/pi-ai": "18.1.6",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

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>[],

package/src/provider-models/openai-compat.ts

@@ -110,6 +110,8 @@ export interface ModelsDevModel {
 	};
 	status?: string;
 	provider?: { npm?: string };
+	int?: number;
+	tps?: number;
 }
 
 function toModelName(value: unknown, fallback: string): string {
@@ -6518,6 +6520,8 @@ export function mapModelsDevToModels(
 				},
 				contextWindow: toPositiveNumber(m.limit?.context, desc.defaultContextWindow ?? null),
 				maxTokens: toPositiveNumber(m.limit?.output, desc.defaultMaxTokens ?? null),
+				...(m.int != null ? { int: m.int } : {}),
+				...(m.tps != null ? { tps: m.tps } : {}),
 				...(m.tool_call === false ? { supportsTools: false } : {}),
 				...(desc.compat && { compat: desc.compat }),
 				...(desc.headers && { headers: { ...desc.headers } }),

package/src/types.ts

@@ -1173,6 +1173,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.
@@ -1207,6 +1211,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>;
 }
 
 /**