@mzwing/pi-model-info 0.1.0 → 0.1.1

package/README.md

@@ -23,8 +23,9 @@ This extension looks each model up in two catalogs and fills the gaps at runtime
 ## What it does not do
 
 It never creates providers, never discovers models, never changes `id` / `provider` / `baseUrl` /
-`api` / auth / transport, and never writes to any of your files. Remove it and Pi goes back to
-exactly what it did before.
+`api` / auth / transport, and never writes to any of your files. Where it wraps a provider it
+delegates that provider's own auth, transport and refresh behaviour untouched. Remove it and Pi
+goes back to exactly what it did before.
 
 ## Install
 
@@ -39,6 +40,26 @@ Then opt a provider in — nothing happens until you do:
 { "providers": { "my-relay": {} } }
 ```
 
+## Staying current
+
+Model lists move. Pi refreshes every built-in provider's catalog from pi.dev on a four-hour clock
+and again the moment you open `/model`, and a discovery extension may refetch its own list. A
+completion that was snapshotted once does not survive any of that, so it is applied in whichever of
+three ways claims the least:
+
+| What Pi already holds for the provider                 | How it is completed                                             | How current the list stays                                            |
+| ------------------------------------------------------ | --------------------------------------------------------------- | --------------------------------------------------------------------- |
+| Nothing else registered, and it refreshes its own list | the provider object is wrapped; `getModels()` completes on read | live — a model that appears mid-session is completed on first read    |
+| A sibling extension registered `refreshModels`         | that hook is wrapped, so each refresh returns a completed list  | live — `/model` renders the completion in the refresh that fetched it |
+| Anything else                                          | the list is snapshotted and re-registered                       | fixed for the session, re-checked on each agent turn                  |
+
+`/model-info` names which one is in force, per provider.
+
+Only the third row can freeze a dynamic list, and it is the only one that warns. It is reached when
+something else owns the provider's registration slot — Pi merges every extension registration for a
+provider into one entry, and taking that entry over would take the sibling's `apiKey` with it — or
+when models.json defines the provider's `models[]`, which Pi rebuilds above anything underneath.
+
 ## Pairing with a discovery extension
 
 If your provider's models come from something like
@@ -49,9 +70,10 @@ completes _what they are_.**
 
 Ordering is guaranteed, not lucky. Discovery extensions register from inside their factory, which
 Pi flushes before any session event; this extension registers from `session_start`, strictly
-after. It only ever sends the `models` key, so Pi's merge preserves the sibling's `baseUrl`,
-`api`, and `apiKey` — and it never calls `unregisterProvider` on a registration carrying keys it
-did not write, because that call would take those credentials with it.
+after. It only ever sends `models` — plus, for a sibling that refreshes, a wrapper around that
+sibling's own `refreshModels` — so Pi's merge preserves its `baseUrl`, `api`, and `apiKey`, and it
+never calls `unregisterProvider` on a registration carrying keys it did not write, because that
+call would take those credentials with it.
 
 Where the sibling already supplied a real value and the catalogs cannot resolve the model, its
 value is kept byte-for-byte. Where you prefer its numbers even when a catalog does resolve, set
@@ -101,17 +123,17 @@ Global at `~/.pi/agent/extensions/pi-model-info/config.json`, per-project at
 
 ### Per provider
 
-| Key                   | Default   | Meaning                                                                            |
-| --------------------- | --------- | ---------------------------------------------------------------------------------- |
-| `catalogProvider`     | —         | Scope lookups to one catalog provider, e.g. `openrouter`.                          |
-| `costMultiplier`      | `1`       | Relay markup, applied to catalog pricing only — never to a rule's explicit `0`.    |
-| `costPolicy`          | `catalog` | `zero` to force free, `keep` to leave pricing alone.                               |
-| `contextWindowPolicy` | `catalog` | `min` never raises the limit past what Pi already had; `keep` leaves limits alone. |
-| `capabilityPolicy`    | `catalog` | `widen` only ever adds a capability; `keep` leaves them alone.                     |
-| `useCatalogName`      | `false`   | Rename models to their catalog names.                                              |
-| `mapThinkingLevels`   | `false`   | Derive a thinking-level map from models.dev. pi.dev's real map is always used.     |
-| `allowDynamic`        | `false`   | Suppress the warning for a provider that refreshes its own model list.             |
-| `models`              | —         | Per-model gates: `alias`, `override`, `skip`, `prefixes`, `suffixes`.              |
+| Key                   | Default   | Meaning                                                                               |
+| --------------------- | --------- | ------------------------------------------------------------------------------------- |
+| `catalogProvider`     | —         | Scope lookups to one catalog provider, e.g. `openrouter`.                             |
+| `costMultiplier`      | `1`       | Relay markup, applied to catalog pricing only — never to a rule's explicit `0`.       |
+| `costPolicy`          | `catalog` | `zero` to force free, `keep` to leave pricing alone.                                  |
+| `contextWindowPolicy` | `catalog` | `min` never raises the limit past what Pi already had; `keep` leaves limits alone.    |
+| `capabilityPolicy`    | `catalog` | `widen` only ever adds a capability; `keep` leaves them alone.                        |
+| `useCatalogName`      | `false`   | Rename models to their catalog names.                                                 |
+| `mapThinkingLevels`   | `false`   | Derive a thinking-level map from models.dev. pi.dev's real map is always used.        |
+| `allowDynamic`        | `false`   | Suppress the warning when a refreshing provider can only be completed by replacement. |
+| `models`              | —         | Per-model gates: `alias`, `override`, `skip`, `prefixes`, `suffixes`.                 |
 
 `contextWindowPolicy: "min"` and `capabilityPolicy: "keep"` exist because inflating a limit or
 promoting a capability the relay does not actually support turns into a failed request rather
@@ -176,9 +198,10 @@ cost:       $0/$0 per Mtok   from rule 'free-dash'
 
 ## Limits
 
-- Completing a provider replaces its model list, so a provider that discovers models
-  _dynamically_ has that list frozen for the session. This extension warns when it sees one and
-  re-reads the list every session; a mid-session change is picked up on the next agent turn.
+- A provider whose registration slot is already taken, or whose `models[]` models.json spells out,
+  can only be completed by replacement, which fixes its list for the session. It warns when it sees
+  one; a mid-session change is picked up on the next agent turn. See
+  [Staying current](#staying-current).
 - If two extensions complete the same provider, the last one to register wins.
 - With no cache and no network, nothing is applied at all rather than partially.
 

package/dist/index.js

@@ -863,6 +863,12 @@ var CatalogStore = class {
 //#endregion
 //#region src/command.ts
 const COMPLETION_LIMIT = 50;
+/** How current each provider's list stays — the one thing you cannot tell from the counts. */
+const STRATEGY_NOTE = {
+	native: "list re-read live",
+	decorate: "list re-read on refresh",
+	replace: "list fixed for this session"
+};
 function splitReference(reference) {
 	const separator = reference.indexOf("/");
 	return separator > 0 ? {
@@ -896,7 +902,8 @@ function formatSummary(reports, catalog, issues, now) {
 			continue;
 		}
 		const counts = countByKind(report.models);
-		lines.push(`${report.provider}: ${counts.resolved} completed, ${counts.ambiguous} ambiguous, ${counts.unresolved} unresolved (${report.models.length} models)`);
+		const note = report.strategy === void 0 ? "" : ` · ${STRATEGY_NOTE[report.strategy]}`;
+		lines.push(`${report.provider}: ${counts.resolved} completed, ${counts.ambiguous} ambiguous, ${counts.unresolved} unresolved (${report.models.length} models)${note}`);
 	}
 	if (catalog === void 0) lines.push("", "catalogs: not loaded yet");
 	else {
@@ -1055,8 +1062,7 @@ function readUserAuthoredFields(agentDir, readFile = defaultRead) {
 		const models = /* @__PURE__ */ new Map();
 		for (const definition of provider["models"]) {
 			if (!isRecord(definition) || typeof definition["id"] !== "string") continue;
-			const fields = new Set(Object.keys(definition).filter((key) => TRACKED_FIELDS.has(key)));
-			if (fields.size > 0) models.set(definition["id"], fields);
+			models.set(definition["id"], new Set(Object.keys(definition).filter((key) => TRACKED_FIELDS.has(key))));
 		}
 		if (models.size > 0) authored.set(providerId, models);
 	}
@@ -1448,137 +1454,220 @@ function resolveModel(input) {
 	};
 }
 
+//#endregion
+//#region src/complete.ts
+/** The single completion pass, shared by every strategy so they cannot drift apart. */
+function completeModel(snapshot, context) {
+	const resolution = resolveModel({
+		index: context.catalog.index,
+		provider: context.provider,
+		prefixRules: context.config.prefixRules,
+		suffixRules: context.config.suffixRules,
+		modelId: snapshot.id
+	});
+	const merged = mergeMetadata({
+		snapshot,
+		provider: context.provider,
+		resolution,
+		gate: context.provider.models.get(snapshot.id),
+		userAuthored: context.authored?.get(snapshot.id)
+	});
+	return {
+		model: merged.model,
+		report: {
+			id: snapshot.id,
+			resolution,
+			provenance: merged.provenance,
+			issues: merged.issues,
+			model: merged.model
+		}
+	};
+}
+
+//#endregion
+//#region src/native-wrap.ts
+/**
+* Registered globally so a `/reload` — which hands us a fresh module instance — still recognises
+* our own wrapper and unwraps to the provider underneath instead of completing a completion.
+*/
+const WRAPPED = Symbol.for("@mzwing/pi-model-info.wrapped-provider");
+function isOurWrapper(provider) {
+	return provider !== void 0 && WRAPPED in provider;
+}
+function unwrapProvider(provider) {
+	return provider[WRAPPED] ?? provider;
+}
+/**
+* A provider whose `getModels()` completes the list underneath on every read.
+*
+* This is what keeps a built-in provider reactive: Pi's own dynamic providers keep their list in a
+* closure that `refreshModels()` rewrites, so reading it late — rather than snapshotting it once and
+* registering a replacement list — is what lets `/model`, the four-hourly pi.dev catalog refresh and
+* anything else that refreshes show newly discovered models already completed.
+*
+* The wrapper is a spread of the provider it wraps, which is safe only because we never wrap a
+* third-party native registration: Pi's own providers are closures over their state, never `this`.
+*/
+var NativeWrap = class {
+	pristine;
+	provider;
+	deps;
+	cache = /* @__PURE__ */ new WeakMap();
+	constructor(pristine, deps) {
+		this.pristine = pristine;
+		this.deps = deps;
+		const wrapper = {
+			...pristine,
+			[WRAPPED]: pristine,
+			getModels: () => this.completeAll()
+		};
+		this.provider = wrapper;
+	}
+	/** Drops the per-model cache; call whenever the catalog or the resolved config changes. */
+	invalidate() {
+		this.cache = /* @__PURE__ */ new WeakMap();
+	}
+	completeAll() {
+		const base = this.pristine.getModels();
+		const context = this.deps.context();
+		if (context === void 0) return base;
+		try {
+			const reports = [];
+			const models = base.map((model) => {
+				let completed = this.cache.get(model);
+				if (completed === void 0) {
+					const completion = completeModel(model, context);
+					completed = {
+						model: {
+							...model,
+							...completion.model
+						},
+						report: completion.report
+					};
+					this.cache.set(model, completed);
+				}
+				reports.push(completed.report);
+				return completed.model;
+			});
+			this.deps.onReports(reports);
+			return models;
+		} catch (error) {
+			this.deps.warn(`completing '${this.pristine.id}' failed: ${error instanceof Error ? error.message : String(error)}`);
+			return base;
+		}
+	}
+};
+
 //#endregion
 //#region src/provider-apply.ts
+/** Global, like the provider marker: a `/reload` must not let us decorate our own decorator. */
+const DECORATED = Symbol.for("@mzwing/pi-model-info.refresh-decorator");
 var ProviderApplier = class {
-	snapshots = /* @__PURE__ */ new Map();
+	tracked = /* @__PURE__ */ new Map();
 	skipped = /* @__PURE__ */ new Map();
 	reports = /* @__PURE__ */ new Map();
 	lastRegistered = /* @__PURE__ */ new Map();
+	/** Outlives `capture`, so a `/reload` reuses one wrapper per provider instead of nesting them. */
+	wraps = /* @__PURE__ */ new Map();
+	/** Provider to the catalog fingerprint it was last registered with, to skip a no-op re-register. */
+	appliedCatalog = /* @__PURE__ */ new Map();
 	warn;
+	applied;
 	constructor(deps = {}) {
 		this.warn = deps.warn ?? (() => {});
 	}
 	/**
-	* Must run before the first registration of the session: afterwards `getProvider(id).getModels()`
-	* returns our own list, and re-deriving from it would fold every previous pass into the next one.
+	* Chooses a strategy per provider, and for the two registration strategies takes the list as Pi
+	* has it now: afterwards `getProvider(id).getModels()` returns our own, and re-deriving from it
+	* would fold every previous pass into the next one.
 	*/
-	capture(registry, config) {
-		this.snapshots.clear();
+	capture(registry, config, authored) {
+		this.tracked.clear();
 		this.skipped.clear();
 		this.reports.clear();
+		this.appliedCatalog.clear();
 		for (const provider of config.providers.values()) {
 			const live = registry.getProvider(provider.id);
 			if (live === void 0) {
 				this.skip(provider.id, "not present in Pi; check the provider id");
 				continue;
 			}
-			if (registry.getRegisteredNativeProvider(provider.id) !== void 0) {
+			const native = registry.getRegisteredNativeProvider(provider.id);
+			if (native !== void 0 && !isOurWrapper(native)) {
 				this.skip(provider.id, "another extension registered a native provider for this id");
 				continue;
 			}
-			const snapshot = [...live.getModels()];
+			const pristine = native === void 0 ? live : unwrapProvider(native);
+			const registered = registry.getRegisteredProviderConfig(provider.id);
+			if (registered === void 0 && pristine.refreshModels !== void 0 && !authored.has(provider.id)) {
+				this.trackNative(provider, pristine);
+				continue;
+			}
+			const snapshot = [...pristine.getModels()];
 			if (snapshot.length === 0) {
 				this.skip(provider.id, "no models to complete");
 				continue;
 			}
-			if (live.refreshModels !== void 0 && !provider.allowDynamic) this.warn(`provider '${provider.id}' refreshes its model list dynamically; completing it freezes newly discovered models until the next session`);
-			this.snapshots.set(provider.id, snapshot);
-			this.reports.set(provider.id, {
-				provider: provider.id,
-				status: "pending",
-				reason: void 0,
-				models: []
-			});
+			const sibling = undecorate(registered?.refreshModels);
+			if (sibling !== void 0) {
+				this.track(provider, "decorate", snapshot, {
+					refresh: this.decorate(provider.id, sibling),
+					api: registered?.api,
+					baseUrl: registered?.baseUrl
+				});
+				continue;
+			}
+			if (pristine.refreshModels !== void 0 && !provider.allowDynamic) this.warn(`provider '${provider.id}' refreshes its model list dynamically, but ${registered === void 0 ? "models.json defines models for it" : "another extension owns its registration"}, so completing it freezes newly discovered models until the next session`);
+			this.track(provider, "replace", snapshot, {});
 		}
 	}
 	apply(pi, config, catalog, userAuthored) {
 		if (catalog.status === "unavailable") return;
-		for (const [providerId, snapshot] of this.snapshots) {
-			const provider = config.providers.get(providerId);
-			if (provider !== void 0) this.applyProvider(pi, provider, snapshot, config, catalog, userAuthored);
-		}
-	}
-	applyProvider(pi, provider, snapshots, config, catalog, userAuthored) {
-		const authored = userAuthored.get(provider.id);
-		const models = [];
-		const reports = [];
-		for (const snapshot of snapshots) {
-			const resolution = resolveModel({
-				index: catalog.index,
-				provider,
-				prefixRules: config.prefixRules,
-				suffixRules: config.suffixRules,
-				modelId: snapshot.id
-			});
-			const merged = mergeMetadata({
-				snapshot,
-				provider,
-				resolution,
-				gate: provider.models.get(snapshot.id),
-				userAuthored: authored?.get(snapshot.id)
-			});
-			models.push(merged.model);
-			reports.push({
-				id: snapshot.id,
-				resolution,
-				provenance: merged.provenance,
-				issues: merged.issues,
-				model: merged.model
-			});
-		}
-		try {
-			pi.registerProvider(provider.id, { models });
-			this.lastRegistered.set(provider.id, models);
-			this.reports.set(provider.id, {
-				provider: provider.id,
-				status: "applied",
-				reason: void 0,
-				models: reports
-			});
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			this.warn(`failed to complete provider '${provider.id}': ${message}`);
-			this.reports.set(provider.id, {
-				provider: provider.id,
-				status: "failed",
-				reason: message,
-				models: reports
-			});
-		}
+		this.applied = {
+			config,
+			catalog,
+			authored: userAuthored
+		};
+		for (const [providerId, tracked] of this.tracked) if (tracked.strategy === "native") this.applyNative(pi, providerId);
+		else this.applyRegistration(pi, providerId, tracked);
 	}
 	/**
-	* Cheap id-set comparison against the live list. Ordering already guarantees a discovery extension
-	* registers before our first pass, so this only catches a third party changing the list mid-session.
+	* Cheap id-set comparison against the live list, for the strategies that snapshot one. `native`
+	* re-reads on every access and `decorate` completes inside the refresh, so neither can drift.
 	*/
 	reconcile(registry) {
 		let drifted = false;
-		for (const providerId of this.snapshots.keys()) {
+		for (const [providerId, tracked] of this.tracked) {
+			if (tracked.strategy === "native") continue;
 			const live = registry.getProvider(providerId);
 			if (live === void 0) continue;
 			const liveModels = [...live.getModels()];
 			const registered = this.lastRegistered.get(providerId);
 			if (liveModels.length === 0 || registered !== void 0 && sameIds(liveModels, registered)) continue;
-			this.snapshots.set(providerId, liveModels);
+			tracked.snapshot = liveModels;
 			drifted = true;
 		}
 		return drifted;
 	}
 	/**
-	* `extensionProviders` outlives a `/reload` while our in-memory state does not, so a registration
-	* for a provider that is no longer opted in would linger and could make a later recompose delete
-	* the provider outright.
+	* Registrations outlive a `/reload` while our in-memory state does not, so one left behind for a
+	* provider that is no longer opted in would linger and could make a later recompose delete the
+	* provider outright.
 	*/
 	releaseStale(pi, registry, config) {
+		for (const providerId of [...this.wraps.keys()]) {
+			if (config.providers.has(providerId)) continue;
+			if (!isOurWrapper(registry.getRegisteredNativeProvider(providerId))) {
+				this.wraps.delete(providerId);
+				continue;
+			}
+			if (registry.getRegisteredProviderConfig(providerId) !== void 0) continue;
+			this.release(pi, providerId);
+		}
 		for (const [providerId, models] of this.lastRegistered) {
 			if (config.providers.has(providerId)) continue;
 			if (!isSolelyOurRegistration(registry.getRegisteredProviderConfig(providerId), models)) continue;
-			try {
-				pi.unregisterProvider(providerId);
-				this.lastRegistered.delete(providerId);
-			} catch (error) {
-				this.warn(`failed to release provider '${providerId}': ${error instanceof Error ? error.message : String(error)}`);
-			}
+			this.release(pi, providerId);
 		}
 	}
 	getReports() {
@@ -1591,11 +1680,190 @@ var ProviderApplier = class {
 		});
 		return reports.sort((a, b) => a.provider.localeCompare(b.provider));
 	}
+	track(provider, strategy, snapshot, extra) {
+		this.tracked.set(provider.id, {
+			provider,
+			strategy,
+			snapshot,
+			refresh: extra.refresh,
+			api: extra.api,
+			baseUrl: extra.baseUrl
+		});
+		this.reports.set(provider.id, {
+			provider: provider.id,
+			status: "pending",
+			strategy,
+			reason: void 0,
+			models: []
+		});
+	}
+	trackNative(provider, pristine) {
+		this.track(provider, "native", [], {});
+		if (this.wraps.get(provider.id)?.pristine === pristine) return;
+		this.wraps.set(provider.id, new NativeWrap(pristine, {
+			context: () => this.nativeContext(provider.id),
+			onReports: (reports) => {
+				this.recordNative(provider.id, reports);
+			},
+			warn: this.warn
+		}));
+	}
+	/** `undefined` keeps a wrapper inert: it hands back the list underneath, uncompleted. */
+	nativeContext(providerId) {
+		const applied = this.applied;
+		const tracked = this.tracked.get(providerId);
+		if (applied === void 0 || tracked?.strategy !== "native") return;
+		return {
+			config: applied.config,
+			provider: tracked.provider,
+			catalog: applied.catalog,
+			authored: applied.authored.get(providerId)
+		};
+	}
+	recordNative(providerId, models) {
+		if (this.tracked.get(providerId)?.strategy !== "native") return;
+		this.reports.set(providerId, {
+			provider: providerId,
+			status: "applied",
+			strategy: "native",
+			reason: void 0,
+			models
+		});
+	}
+	applyNative(pi, providerId) {
+		const wrap = this.wraps.get(providerId);
+		const applied = this.applied;
+		if (wrap === void 0 || applied === void 0) return;
+		const fingerprint = catalogFingerprint(applied.catalog);
+		if (this.appliedCatalog.get(providerId) === fingerprint) return;
+		wrap.invalidate();
+		try {
+			pi.registerProvider(wrap.provider);
+			this.appliedCatalog.set(providerId, fingerprint);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.warn(`failed to complete provider '${providerId}': ${message}`);
+			this.reports.set(providerId, {
+				provider: providerId,
+				status: "failed",
+				strategy: "native",
+				reason: message,
+				models: []
+			});
+		}
+	}
+	applyRegistration(pi, providerId, tracked) {
+		const completed = this.complete(tracked, tracked.snapshot);
+		if (completed === void 0) return;
+		try {
+			const config = tracked.refresh === void 0 ? { models: completed.models } : {
+				models: completed.models,
+				refreshModels: tracked.refresh
+			};
+			pi.registerProvider(providerId, config);
+			this.lastRegistered.set(providerId, completed.models);
+			this.reports.set(providerId, {
+				provider: providerId,
+				status: "applied",
+				strategy: tracked.strategy,
+				reason: void 0,
+				models: completed.reports
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.warn(`failed to complete provider '${providerId}': ${message}`);
+			this.reports.set(providerId, {
+				provider: providerId,
+				status: "failed",
+				strategy: tracked.strategy,
+				reason: message,
+				models: completed.reports
+			});
+		}
+	}
+	/**
+	* Wraps a sibling's own hook so the completion runs inside Pi's refresh: what the sibling returns
+	* is the clean upstream list, and what we return is what `/model` renders once the refresh lands.
+	*/
+	decorate(providerId, original) {
+		const decorator = async (context) => {
+			const fresh = await original(context);
+			const tracked = this.tracked.get(providerId);
+			if (tracked === void 0 || !Array.isArray(fresh) || fresh.length === 0) return fresh;
+			const snapshot = fresh.map((definition) => toSnapshot(definition, tracked.api, tracked.baseUrl)).filter((model) => model !== void 0);
+			const completed = this.complete(tracked, snapshot);
+			if (completed === void 0) return fresh;
+			tracked.snapshot = snapshot;
+			const byId = new Map(completed.models.map((model) => [model.id, model]));
+			const models = fresh.map((definition) => byId.get(definition.id) ?? definition);
+			this.lastRegistered.set(providerId, models);
+			this.reports.set(providerId, {
+				provider: providerId,
+				status: "applied",
+				strategy: "decorate",
+				reason: void 0,
+				models: completed.reports
+			});
+			return models;
+		};
+		const marked = decorator;
+		marked[DECORATED] = original;
+		return marked;
+	}
+	/** `undefined` until a catalog is loaded. */
+	complete(tracked, snapshots) {
+		const applied = this.applied;
+		if (applied === void 0) return;
+		const context = {
+			config: applied.config,
+			provider: tracked.provider,
+			catalog: applied.catalog,
+			authored: applied.authored.get(tracked.provider.id)
+		};
+		const models = [];
+		const reports = [];
+		for (const snapshot of snapshots) {
+			const completion = completeModel(snapshot, context);
+			models.push(completion.model);
+			reports.push(completion.report);
+		}
+		return {
+			models,
+			reports
+		};
+	}
+	release(pi, providerId) {
+		try {
+			pi.unregisterProvider(providerId);
+			this.lastRegistered.delete(providerId);
+			this.wraps.delete(providerId);
+			this.appliedCatalog.delete(providerId);
+		} catch (error) {
+			this.warn(`failed to release provider '${providerId}': ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
 	skip(providerId, reason) {
 		this.skipped.set(providerId, reason);
 		this.warn(`skipping provider '${providerId}': ${reason}`);
 	}
 };
+function catalogFingerprint(catalog) {
+	return catalog.sources.map((source) => `${source.source}@${source.fetchedAt ?? 0}#${source.entryCount}`).join("|");
+}
+function undecorate(refresh) {
+	return refresh === void 0 ? void 0 : refresh[DECORATED] ?? refresh;
+}
+/** A registration definition may lean on the provider for `api` and `baseUrl`; a snapshot may not. */
+function toSnapshot(definition, api, baseUrl) {
+	const resolvedApi = definition.api ?? api;
+	const resolvedBaseUrl = definition.baseUrl ?? baseUrl;
+	if (resolvedApi === void 0 || resolvedBaseUrl === void 0) return;
+	return {
+		...definition,
+		api: resolvedApi,
+		baseUrl: resolvedBaseUrl
+	};
+}
 function sameIds(live, registered) {
 	if (live.length !== registered.length) return false;
 	const ids = new Set(registered.map((model) => model.id));
@@ -1634,13 +1902,13 @@ function createModelInfoExtension(pi, dependencies = {}) {
 	let session;
 	let isIdle = () => true;
 	function applyCatalog(snapshot) {
-		catalog = snapshot;
 		if (config === void 0) return;
 		if (config.applyOnIdleOnly && !isIdle()) {
 			pending = snapshot;
 			return;
 		}
 		pending = void 0;
+		catalog = snapshot;
 		applier.apply(pi, config, snapshot, userAuthored);
 	}
 	async function run(signal) {
@@ -1674,8 +1942,8 @@ function createModelInfoExtension(pi, dependencies = {}) {
 		if (config === void 0) return;
 		applier.releaseStale(pi, context.modelRegistry, config);
 		if (config.providers.size === 0) return;
-		applier.capture(context.modelRegistry, config);
 		userAuthored = readUserAuthored(agentDir);
+		applier.capture(context.modelRegistry, config, userAuthored);
 		start();
 	});
 	pi.on("before_agent_start", (_event, context) => {
@@ -1684,7 +1952,10 @@ function createModelInfoExtension(pi, dependencies = {}) {
 		if (applier.reconcile(registry)) applier.apply(pi, config, catalog, userAuthored);
 	});
 	pi.on("turn_end", () => {
-		if (pending !== void 0 && config !== void 0) applier.apply(pi, config, pending, userAuthored);
+		if (pending !== void 0 && config !== void 0) {
+			catalog = pending;
+			applier.apply(pi, config, pending, userAuthored);
+		}
 		pending = void 0;
 	});
 	pi.on("session_shutdown", () => {