@mzwing/pi-model-info 0.1.0

package/dist/index.js

@@ -0,0 +1,1715 @@
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import process from "node:process";
+import { z } from "zod";
+
+//#region src/config.ts
+const EXTENSION_ID = "pi-model-info";
+const COMMAND_NAME = "model-info";
+const DEFAULT_SOURCES = ["pi.dev", "models.dev"];
+const DEFAULT_CACHE_TTL_MS = 864e5;
+const DEFAULT_TIMEOUT_MS = 15e3;
+const DEFAULT_MAX_BYTES = 16777216;
+const FREE_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+/** Suffix variants every relay uses. Disable individually with `enabled: false`. */
+const BUILTIN_RULES = [{
+	id: "free-dash",
+	kind: "suffix",
+	value: "-free",
+	override: { cost: FREE_COST }
+}, {
+	id: "free-colon",
+	kind: "suffix",
+	value: ":free",
+	override: { cost: FREE_COST }
+}];
+const thinkingValue = z.union([z.string(), z.null()]).optional();
+const thinkingLevelMapSchema = z.strictObject({
+	off: thinkingValue,
+	minimal: thinkingValue,
+	low: thinkingValue,
+	medium: thinkingValue,
+	high: thinkingValue,
+	xhigh: thinkingValue,
+	max: thinkingValue
+});
+const costTierSchema = z.strictObject({
+	input: z.number().min(0),
+	output: z.number().min(0),
+	cacheRead: z.number().min(0),
+	cacheWrite: z.number().min(0),
+	inputTokensAbove: z.number().int().positive()
+});
+const metadataOverrideSchema = z.strictObject({
+	name: z.string().trim().min(1).optional(),
+	reasoning: z.boolean().optional(),
+	input: z.array(z.enum(["text", "image"])).min(1).optional(),
+	cost: z.strictObject({
+		input: z.number().min(0).optional(),
+		output: z.number().min(0).optional(),
+		cacheRead: z.number().min(0).optional(),
+		cacheWrite: z.number().min(0).optional(),
+		tiers: z.array(costTierSchema).optional()
+	}).optional(),
+	contextWindow: z.number().int().positive().optional(),
+	maxTokens: z.number().int().positive().optional(),
+	thinkingLevelMap: thinkingLevelMapSchema.optional(),
+	compat: z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value), { message: "compat must be an object" }).optional()
+});
+const affixRuleSchema = z.strictObject({
+	id: z.string().trim().min(1),
+	kind: z.enum(["prefix", "suffix"]),
+	value: z.string().min(1),
+	enabled: z.boolean().optional(),
+	override: metadataOverrideSchema.optional()
+});
+const modelGateSchema = z.strictObject({
+	prefixes: z.array(z.string().trim().min(1)).optional(),
+	suffixes: z.array(z.string().trim().min(1)).optional(),
+	alias: z.string().trim().min(1).optional(),
+	override: metadataOverrideSchema.optional(),
+	skip: z.boolean().optional()
+});
+const providerOptInSchema = z.strictObject({
+	catalogProvider: z.string().trim().min(1).optional(),
+	costMultiplier: z.number().min(0).optional(),
+	costPolicy: z.enum([
+		"catalog",
+		"zero",
+		"keep"
+	]).optional(),
+	contextWindowPolicy: z.enum([
+		"catalog",
+		"min",
+		"keep"
+	]).optional(),
+	capabilityPolicy: z.enum([
+		"catalog",
+		"widen",
+		"keep"
+	]).optional(),
+	useCatalogName: z.boolean().optional(),
+	mapThinkingLevels: z.boolean().optional(),
+	allowDynamic: z.boolean().optional(),
+	models: z.record(z.string().trim().min(1), modelGateSchema).optional()
+});
+const configFileShape = {
+	$schema: z.string().min(1).optional(),
+	providers: z.record(z.string().trim().min(1), providerOptInSchema).optional(),
+	aliases: z.record(z.string().trim().min(1), z.string().trim().min(1)).optional(),
+	models: z.record(z.string().trim().min(1), modelGateSchema).optional(),
+	rules: z.array(affixRuleSchema).optional(),
+	builtinRules: z.boolean().optional(),
+	sources: z.array(z.enum(["pi.dev", "models.dev"])).min(1).optional(),
+	network: z.strictObject({
+		enabled: z.boolean().optional(),
+		timeoutMs: z.number().int().positive().max(12e4).optional(),
+		maxBytes: z.number().int().positive().optional()
+	}).optional(),
+	cache: z.strictObject({
+		ttlMs: z.number().int().min(0).optional(),
+		dir: z.string().trim().min(1).optional()
+	}).optional(),
+	applyOnIdleOnly: z.boolean().optional()
+};
+const configFileSchema = z.strictObject(configFileShape);
+const modelInfoConfigSchema = z.strictObject({
+	...configFileShape,
+	providers: z.record(z.string().trim().min(1), providerOptInSchema).default({})
+}).superRefine((config, context) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, rule] of (config.rules ?? []).entries()) {
+		if (seen.has(rule.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate rule id '${rule.id}'`,
+			path: [
+				"rules",
+				index,
+				"id"
+			]
+		});
+		seen.add(rule.id);
+	}
+	if (config.sources && new Set(config.sources).size !== config.sources.length) context.addIssue({
+		code: "custom",
+		message: "sources must not repeat a value",
+		path: ["sources"]
+	});
+});
+function defaultModelInfoAgentDir() {
+	return process.env["PI_CODING_AGENT_DIR"] ?? join(homedir(), ".pi", "agent");
+}
+function getModelInfoConfigPaths(cwd, agentDir = defaultModelInfoAgentDir()) {
+	return {
+		globalPath: join(agentDir, "extensions", EXTENSION_ID, "config.json"),
+		projectPath: join(cwd, ".pi", "extensions", EXTENSION_ID, "config.json")
+	};
+}
+/** Reads a config file, reporting a missing one as `undefined` rather than an error. */
+function readConfigFile(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+		throw error;
+	}
+}
+function formatZodIssue(error) {
+	return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "(root)"}: ${issue.message}`).join("; ");
+}
+/** Returns `undefined` on failure, having recorded why; an absent file reads as an empty scope. */
+function readScope(path, readFile, issues) {
+	let source;
+	try {
+		source = readFile(path);
+	} catch (error) {
+		issues.push({
+			sourcePath: path,
+			message: error instanceof Error ? error.message : String(error)
+		});
+		return;
+	}
+	if (source === void 0) return {};
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch (error) {
+		issues.push({
+			sourcePath: path,
+			message: `invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return;
+	}
+	const parsed = configFileSchema.safeParse(value);
+	if (!parsed.success) {
+		issues.push({
+			sourcePath: path,
+			message: formatZodIssue(parsed.error)
+		});
+		return;
+	}
+	return parsed.data;
+}
+function loadModelInfoConfig(options) {
+	const { globalPath, projectPath } = getModelInfoConfigPaths(options.cwd, options.agentDir);
+	const readFile = options.readFile ?? readConfigFile;
+	const issues = [];
+	const globalConfig = readScope(globalPath, readFile, issues);
+	const projectConfig = readScope(projectPath, readFile, issues);
+	if (globalConfig === void 0 || projectConfig === void 0) return {
+		config: void 0,
+		issues,
+		globalPath,
+		projectPath
+	};
+	const merged = modelInfoConfigSchema.safeParse({
+		...globalConfig,
+		...projectConfig
+	});
+	if (!merged.success) {
+		issues.push({
+			sourcePath: projectPath,
+			message: formatZodIssue(merged.error)
+		});
+		return {
+			config: void 0,
+			issues,
+			globalPath,
+			projectPath
+		};
+	}
+	return {
+		config: merged.data,
+		issues,
+		globalPath,
+		projectPath
+	};
+}
+/**
+* Model ids routinely contain `/`, so a flat `"provider/model"` key is only unambiguous because
+* provider ids are known: split at the FIRST separator and require the head to be an opted-in one.
+*/
+function splitFlatKey(key, providers) {
+	const separator = key.indexOf("/");
+	if (separator <= 0 || separator === key.length - 1) return;
+	const provider = providers.get(key.slice(0, separator));
+	return provider === void 0 ? void 0 : [provider, key.slice(separator + 1)];
+}
+function orderRules(rules) {
+	return rules.map((rule, ordinal) => ({
+		rule,
+		ordinal
+	})).sort((a, b) => b.rule.value.length - a.rule.value.length || a.ordinal - b.ordinal).map((entry) => entry.rule);
+}
+/** The flat `models` and `aliases` sugar, as `[section, key, gate]` in the order they are folded in. */
+function flatGates(config) {
+	return [...Object.entries(config.models ?? {}).map(([key, gate]) => [
+		"models",
+		key,
+		gate
+	]), ...Object.entries(config.aliases ?? {}).map(([key, alias]) => [
+		"aliases",
+		key,
+		{ alias }
+	])];
+}
+/**
+* Materialises defaults, folds the flat sugar into per-provider gates, and orders the affix rules.
+* Problems here are reported, not fatal: an unusable entry is dropped and the rest still applies.
+*/
+function resolveModelInfoConfig(config, sourcePath) {
+	const issues = [];
+	const providers = /* @__PURE__ */ new Map();
+	for (const [id, optIn] of Object.entries(config.providers)) providers.set(id, {
+		id,
+		catalogProvider: optIn.catalogProvider,
+		costMultiplier: optIn.costMultiplier ?? 1,
+		costPolicy: optIn.costPolicy ?? "catalog",
+		contextWindowPolicy: optIn.contextWindowPolicy ?? "catalog",
+		capabilityPolicy: optIn.capabilityPolicy ?? "catalog",
+		useCatalogName: optIn.useCatalogName ?? false,
+		mapThinkingLevels: optIn.mapThinkingLevels ?? false,
+		allowDynamic: optIn.allowDynamic ?? false,
+		models: new Map(Object.entries(optIn.models ?? {}))
+	});
+	for (const [section, key, gate] of flatGates(config)) {
+		const split = splitFlatKey(key, providers);
+		if (split === void 0) {
+			issues.push({
+				sourcePath,
+				message: `${section}['${key}'] does not start with an opted-in provider id`
+			});
+			continue;
+		}
+		const [provider, modelId] = split;
+		provider.models.set(modelId, {
+			...provider.models.get(modelId),
+			...gate
+		});
+	}
+	const declared = [...config.rules ?? [], ...config.builtinRules === false ? [] : BUILTIN_RULES];
+	const enabled = declared.filter((rule) => rule.enabled !== false);
+	const ruleIds = new Set(declared.map((rule) => rule.id));
+	for (const provider of providers.values()) for (const [modelId, gate] of provider.models) {
+		const known = (id) => {
+			if (ruleIds.has(id)) return true;
+			issues.push({
+				sourcePath,
+				message: `providers['${provider.id}'].models['${modelId}'] references unknown rule '${id}'`
+			});
+			return false;
+		};
+		const prefixes = gate.prefixes?.filter(known);
+		const suffixes = gate.suffixes?.filter(known);
+		provider.models.set(modelId, {
+			...gate,
+			...prefixes === void 0 ? {} : { prefixes },
+			...suffixes === void 0 ? {} : { suffixes }
+		});
+	}
+	return {
+		config: {
+			providers,
+			prefixRules: orderRules(enabled.filter((rule) => rule.kind === "prefix")),
+			suffixRules: orderRules(enabled.filter((rule) => rule.kind === "suffix")),
+			sources: config.sources ?? DEFAULT_SOURCES,
+			network: {
+				enabled: config.network?.enabled ?? true,
+				timeoutMs: config.network?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+				maxBytes: config.network?.maxBytes ?? DEFAULT_MAX_BYTES
+			},
+			cache: {
+				ttlMs: config.cache?.ttlMs ?? DEFAULT_CACHE_TTL_MS,
+				dir: config.cache?.dir
+			},
+			applyOnIdleOnly: config.applyOnIdleOnly ?? true
+		},
+		issues
+	};
+}
+
+//#endregion
+//#region src/cache.ts
+const CACHE_VERSION = 1;
+const FILE_NAMES = {
+	"pi.dev": "pi-dev.json",
+	"models.dev": "models-dev.json"
+};
+const defaultFileSystem = {
+	readFile(path) {
+		try {
+			return readFileSync(path, "utf8");
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+			throw error;
+		}
+	},
+	writeFile(path, data) {
+		writeFileSync(path, data, "utf8");
+	},
+	rename(from, to) {
+		renameSync(from, to);
+	},
+	mkdir(path) {
+		mkdirSync(path, { recursive: true });
+	},
+	unlink(path) {
+		unlinkSync(path);
+	}
+};
+function toNormalizedSource(envelope) {
+	return {
+		source: envelope.source,
+		entries: envelope.entries,
+		vendors: new Map(envelope.vendors)
+	};
+}
+var CatalogCache = class {
+	dir;
+	fileSystem;
+	constructor(options = {}) {
+		const agentDir = options.agentDir ?? defaultModelInfoAgentDir();
+		this.dir = options.dir ?? join(agentDir, "extensions", "pi-model-info", "cache");
+		this.fileSystem = options.fileSystem ?? defaultFileSystem;
+	}
+	/**
+	* A corrupt or half-written envelope reads as absent and is left on disk: the next successful
+	* fetch replaces it, and until then a copy another machine can still read is not worth destroying.
+	*/
+	read(source) {
+		let raw;
+		try {
+			raw = this.fileSystem.readFile(this.path(source));
+		} catch {
+			return;
+		}
+		if (raw === void 0) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (typeof parsed !== "object" || parsed === null) return;
+		const envelope = parsed;
+		return envelope.version === 1 && envelope.source === source && Array.isArray(envelope.entries) && Array.isArray(envelope.vendors) && typeof envelope.fetchedAt === "number" && envelope.entries.length === envelope.entryCount ? envelope : void 0;
+	}
+	write(envelope) {
+		const path = this.path(envelope.source);
+		const temporary = `${path}.tmp`;
+		try {
+			this.fileSystem.mkdir(dirname(path));
+			this.fileSystem.writeFile(temporary, `${JSON.stringify(envelope)}\n`);
+			this.fileSystem.rename(temporary, path);
+		} catch (error) {
+			try {
+				this.fileSystem.unlink(temporary);
+			} catch {}
+			throw error;
+		}
+	}
+	path(source) {
+		return join(this.dir, FILE_NAMES[source]);
+	}
+};
+
+//#endregion
+//#region src/compact.ts
+/** Drops undefined values, so `exactOptionalPropertyTypes` sees omission rather than an undefined slot. */
+function compact(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0));
+}
+
+//#endregion
+//#region src/types.ts
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+
+//#endregion
+//#region src/catalog-sources.ts
+const PI_DEV_URL = "https://pi.dev/api/models";
+const MODELS_DEV_URL = "https://models.dev/models.json";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Remote JSON delivers `__proto__` and friends as ordinary own keys; dropping them keeps them out of index keys. */
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function entriesOf(value) {
+	if (!isRecord$1(value)) return [];
+	return Object.entries(value).filter(([key]) => !FORBIDDEN_KEYS.has(key));
+}
+function positiveInt(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function nonNegative(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function text(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function flag(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function bareId(id) {
+	const separator = id.indexOf("/");
+	return separator > 0 && separator < id.length - 1 ? id.slice(separator + 1) : id;
+}
+function vendorOf(id) {
+	const separator = id.indexOf("/");
+	return separator > 0 && separator < id.length - 1 ? id.slice(0, separator) : void 0;
+}
+/** Pi accepts only `text` and `image`; absent modalities mean "unknown", not "text only". */
+function toModelInput(modalities) {
+	if (!isRecord$1(modalities) || !Array.isArray(modalities["input"])) return;
+	const declared = new Set(modalities["input"].filter((value) => typeof value === "string"));
+	const input = ["text"];
+	if (declared.has("image")) input.push("image");
+	return input;
+}
+function toCost(raw) {
+	if (!isRecord$1(raw)) return;
+	const input = nonNegative(raw["input"]);
+	const output = nonNegative(raw["output"]);
+	if (input === void 0 || output === void 0) return;
+	return compact({
+		input,
+		output,
+		cacheRead: nonNegative(raw["cacheRead"] ?? raw["cache_read"]) ?? 0,
+		cacheWrite: nonNegative(raw["cacheWrite"] ?? raw["cache_write"]) ?? 0,
+		tiers: toTiers(raw)
+	});
+}
+function toTier(raw, fallbackThreshold) {
+	if (!isRecord$1(raw)) return;
+	const input = nonNegative(raw["input"]);
+	const output = nonNegative(raw["output"]);
+	const above = positiveInt(raw["inputTokensAbove"]) ?? (isRecord$1(raw["tier"]) ? positiveInt(raw["tier"]["size"]) : void 0) ?? fallbackThreshold;
+	if (input === void 0 || output === void 0 || above === void 0) return;
+	return {
+		input,
+		output,
+		cacheRead: nonNegative(raw["cacheRead"] ?? raw["cache_read"]) ?? 0,
+		cacheWrite: nonNegative(raw["cacheWrite"] ?? raw["cache_write"]) ?? 0,
+		inputTokensAbove: above
+	};
+}
+function toTiers(raw) {
+	if (Array.isArray(raw["tiers"])) {
+		const tiers = [];
+		for (const entry of raw["tiers"]) {
+			const tier = toTier(entry);
+			if (tier !== void 0) tiers.push(tier);
+		}
+		return tiers.length > 0 ? tiers : void 0;
+	}
+	const legacy = toTier(raw["context_over_200k"], 2e5);
+	return legacy === void 0 ? void 0 : [legacy];
+}
+function toThinkingLevelMap(raw) {
+	if (!isRecord$1(raw)) return;
+	const map = {};
+	let mapped = false;
+	for (const level of THINKING_LEVELS) {
+		const value = raw[level];
+		if (typeof value === "string" || value === null) {
+			map[level] = value;
+			mapped = true;
+		}
+	}
+	return mapped ? map : void 0;
+}
+/**
+* models.dev describes reasoning as options rather than a level map. Only the `effort` form maps to
+* the strings Pi sends; `toggle` and `budget_tokens` carry no level names, and inventing one is a
+* 400 on every turn.
+*/
+function reasoningOptionsToThinkingLevelMap(raw) {
+	if (!Array.isArray(raw)) return;
+	const effort = raw.find((option) => isRecord$1(option) && option["type"] === "effort" && Array.isArray(option["values"]));
+	if (effort === void 0) return;
+	const values = new Set(effort["values"].filter((value) => typeof value === "string"));
+	const map = {};
+	let mapped = false;
+	for (const level of THINKING_LEVELS) {
+		const name = level === "off" ? "none" : level;
+		if (values.has(name)) {
+			map[level] = name;
+			mapped = true;
+		}
+	}
+	return mapped ? map : void 0;
+}
+/** `{ providerId: { modelId: Model } }`, already in Pi's own shape. */
+function normalizePiDev(payload) {
+	const entries = [];
+	for (const [providerId, models] of entriesOf(payload)) for (const [modelId, raw] of entriesOf(models)) {
+		if (!isRecord$1(raw)) continue;
+		const id = text(raw["id"]) ?? modelId;
+		const input = Array.isArray(raw["input"]) ? raw["input"].filter((value) => value === "text" || value === "image") : void 0;
+		entries.push(compact({
+			source: "pi.dev",
+			sourceProvider: providerId,
+			sourceId: id,
+			canonicalId: `${providerId}/${id}`,
+			api: text(raw["api"]),
+			metadata: compact({
+				name: text(raw["name"]),
+				reasoning: flag(raw["reasoning"]),
+				input: input === void 0 || input.length === 0 ? void 0 : input,
+				cost: toCost(raw["cost"]),
+				contextWindow: positiveInt(raw["contextWindow"]),
+				maxTokens: positiveInt(raw["maxTokens"]),
+				thinkingLevelMap: toThinkingLevelMap(raw["thinkingLevelMap"]),
+				compat: isRecord$1(raw["compat"]) ? raw["compat"] : void 0
+			})
+		}));
+	}
+	return {
+		source: "pi.dev",
+		entries,
+		vendors: /* @__PURE__ */ new Map()
+	};
+}
+/** `{ "vendor/model": metadata }` — provider-agnostic, and carries no pricing. */
+function normalizeModelsDev(payload) {
+	const entries = [];
+	const vendors = /* @__PURE__ */ new Map();
+	for (const [key, raw] of entriesOf(payload)) {
+		if (!isRecord$1(raw)) continue;
+		const canonicalId = text(raw["id"]) ?? key;
+		const vendor = vendorOf(canonicalId);
+		const bare = bareId(canonicalId);
+		if (vendor !== void 0) vendors.set(bare.toLowerCase(), vendor);
+		const limit = isRecord$1(raw["limit"]) ? raw["limit"] : void 0;
+		entries.push({
+			source: "models.dev",
+			sourceProvider: vendor,
+			sourceId: bare,
+			canonicalId,
+			metadata: compact({
+				name: text(raw["name"]),
+				reasoning: flag(raw["reasoning"]),
+				input: toModelInput(raw["modalities"]),
+				contextWindow: limit === void 0 ? void 0 : positiveInt(limit["context"]),
+				maxTokens: limit === void 0 ? void 0 : positiveInt(limit["output"]),
+				thinkingLevelMap: reasoningOptionsToThinkingLevelMap(raw["reasoning_options"])
+			})
+		});
+	}
+	return {
+		source: "models.dev",
+		entries,
+		vendors
+	};
+}
+
+//#endregion
+//#region src/catalog-index.ts
+/** NUL cannot appear in a provider or model id, so the composite key is unambiguous. */
+const SCOPE_SEPARATOR = String.fromCharCode(0);
+function scopedKey(provider, id) {
+	return `${provider.toLowerCase()}${SCOPE_SEPARATOR}${id.toLowerCase()}`;
+}
+function push(map, key, entry) {
+	const bucket = map.get(key);
+	if (bucket === void 0) map.set(key, [entry]);
+	else bucket.push(entry);
+}
+/** Inserts in source-priority order, so every bucket is ranked and the resolver never sorts by source. */
+function buildCatalogIndex(sources, order) {
+	const rank = new Map(order.map((source, position) => [source, position]));
+	const ordered = sources.filter((source) => rank.has(source.source)).sort((a, b) => (rank.get(a.source) ?? 0) - (rank.get(b.source) ?? 0));
+	const scoped = /* @__PURE__ */ new Map();
+	const exact = /* @__PURE__ */ new Map();
+	const bare = /* @__PURE__ */ new Map();
+	const vendors = /* @__PURE__ */ new Map();
+	for (const source of ordered) {
+		for (const [key, vendor] of source.vendors) if (!vendors.has(key)) vendors.set(key, vendor);
+		for (const entry of source.entries) {
+			const short = bareId(entry.sourceId);
+			if (entry.sourceProvider !== void 0) {
+				push(scoped, scopedKey(entry.sourceProvider, entry.sourceId), entry);
+				if (short !== entry.sourceId) push(scoped, scopedKey(entry.sourceProvider, short), entry);
+			}
+			push(exact, entry.sourceId.toLowerCase(), entry);
+			if (entry.canonicalId !== entry.sourceId) push(exact, entry.canonicalId.toLowerCase(), entry);
+			push(bare, short.toLowerCase(), entry);
+		}
+	}
+	return {
+		scoped,
+		exact,
+		bare,
+		vendors
+	};
+}
+
+//#endregion
+//#region src/fetcher.ts
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Reads through the stream so an oversized payload is abandoned rather than buffered whole. */
+async function readCapped(response, maxBytes) {
+	const body = response.body;
+	if (body === null) return "";
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	let size = 0;
+	try {
+		for (;;) {
+			const chunk = await reader.read();
+			if (chunk.done) break;
+			size += chunk.value.byteLength;
+			if (size > maxBytes) throw new Error(`response exceeded ${maxBytes} bytes`);
+			chunks.push(decoder.decode(chunk.value, { stream: true }));
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	chunks.push(decoder.decode());
+	return chunks.join("");
+}
+const catalogFetcher = { async get(request, signal) {
+	let url;
+	try {
+		url = new URL(request.url);
+	} catch (error) {
+		return {
+			status: "error",
+			message: `invalid url: ${describe(error)}`
+		};
+	}
+	if (url.protocol !== "https:") return {
+		status: "error",
+		message: `refusing non-https catalog url '${request.url}'`
+	};
+	const headers = new Headers({ accept: "application/json" });
+	if (request.etag !== void 0) headers.set("if-none-match", request.etag);
+	if (request.lastModified !== void 0) headers.set("if-modified-since", request.lastModified);
+	try {
+		const response = await fetch(url, {
+			headers,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(request.timeoutMs)])
+		});
+		if (response.status === 304) {
+			await response.body?.cancel();
+			return { status: "not-modified" };
+		}
+		if (!response.ok) {
+			await response.body?.cancel();
+			return {
+				status: "error",
+				message: `HTTP ${response.status}`
+			};
+		}
+		const text = await readCapped(response, request.maxBytes);
+		if (text.length === 0) return {
+			status: "error",
+			message: "empty response"
+		};
+		return {
+			status: "ok",
+			body: JSON.parse(text),
+			etag: response.headers.get("etag") ?? void 0,
+			lastModified: response.headers.get("last-modified") ?? void 0
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			message: describe(error)
+		};
+	}
+} };
+
+//#endregion
+//#region src/catalog.ts
+const SOURCES = {
+	"pi.dev": {
+		url: PI_DEV_URL,
+		normalize: normalizePiDev
+	},
+	"models.dev": {
+		url: MODELS_DEV_URL,
+		normalize: normalizeModelsDev
+	}
+};
+var CatalogStore = class {
+	cache;
+	fetcher;
+	now;
+	random;
+	errors = /* @__PURE__ */ new Map();
+	constructor(deps = {}) {
+		this.cache = deps.cache ?? new CatalogCache();
+		this.fetcher = deps.fetcher ?? catalogFetcher;
+		this.now = deps.now ?? (() => Date.now());
+		this.random = deps.random ?? Math.random;
+	}
+	/** Cache only. Safe to call before any network work has happened. */
+	load(config) {
+		const loaded = /* @__PURE__ */ new Map();
+		for (const source of config.sources) {
+			const cached = this.cache.read(source);
+			if (cached !== void 0) loaded.set(source, cached);
+		}
+		return this.snapshot(config, loaded);
+	}
+	async refresh(config, signal, force = false) {
+		const loaded = /* @__PURE__ */ new Map();
+		for (const source of config.sources) {
+			const envelope = await this.refreshOne(config, source, signal, force);
+			if (envelope !== void 0) loaded.set(source, envelope);
+			if (signal.aborted) break;
+		}
+		return this.snapshot(config, loaded);
+	}
+	async refreshOne(config, source, signal, force) {
+		const descriptor = SOURCES[source];
+		const cached = this.cache.read(source);
+		const ttl = config.cache.ttlMs * (.9 + this.random() * .2);
+		if (!force && cached !== void 0 && this.now() - cached.fetchedAt < ttl) {
+			this.errors.delete(source);
+			return cached;
+		}
+		if (!config.network.enabled || signal.aborted) return cached;
+		const outcome = await this.fetcher.get({
+			url: descriptor.url,
+			etag: cached?.etag,
+			lastModified: cached?.lastModified,
+			timeoutMs: config.network.timeoutMs,
+			maxBytes: config.network.maxBytes
+		}, signal);
+		if (outcome.status === "not-modified") {
+			if (cached === void 0) {
+				this.errors.set(source, "304 with no cached copy");
+				return;
+			}
+			const renewed = {
+				...cached,
+				fetchedAt: this.now()
+			};
+			this.persist(source, renewed);
+			this.errors.delete(source);
+			return renewed;
+		}
+		if (outcome.status === "error") {
+			this.errors.set(source, outcome.message);
+			return cached;
+		}
+		const normalized = descriptor.normalize(outcome.body);
+		if (normalized.entries.length === 0) {
+			this.errors.set(source, "catalog contained no usable models");
+			return cached;
+		}
+		const envelope = {
+			version: 1,
+			source,
+			etag: outcome.etag,
+			lastModified: outcome.lastModified,
+			fetchedAt: this.now(),
+			entryCount: normalized.entries.length,
+			entries: normalized.entries,
+			vendors: [...normalized.vendors]
+		};
+		this.persist(source, envelope);
+		this.errors.delete(source);
+		return envelope;
+	}
+	persist(source, envelope) {
+		try {
+			this.cache.write(envelope);
+		} catch (error) {
+			this.errors.set(source, `cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	snapshot(config, loaded) {
+		const sources = config.sources.map((source) => {
+			const envelope = loaded.get(source);
+			return {
+				source,
+				fetchedAt: envelope?.fetchedAt,
+				entryCount: envelope?.entries.length ?? 0,
+				lastError: this.errors.get(source)
+			};
+		});
+		const normalized = config.sources.map((source) => loaded.get(source)).filter((envelope) => envelope !== void 0).map(toNormalizedSource);
+		return {
+			index: buildCatalogIndex(normalized, config.sources),
+			status: normalized.some((source) => source.entries.length > 0) ? "ready" : "unavailable",
+			sources
+		};
+	}
+};
+
+//#endregion
+//#region src/command.ts
+const COMPLETION_LIMIT = 50;
+function splitReference(reference) {
+	const separator = reference.indexOf("/");
+	return separator > 0 ? {
+		providerId: reference.slice(0, separator),
+		modelId: reference.slice(separator + 1)
+	} : {
+		providerId: void 0,
+		modelId: reference
+	};
+}
+function age(now, fetchedAt) {
+	if (fetchedAt === void 0) return "never fetched";
+	const minutes = Math.max(0, Math.round((now - fetchedAt) / 6e4));
+	return minutes < 60 ? `${minutes}m ago` : `${Math.round(minutes / 60)}h ago`;
+}
+function countByKind(models) {
+	const counts = {
+		resolved: 0,
+		ambiguous: 0,
+		unresolved: 0
+	};
+	for (const model of models) counts[model.resolution.kind] += 1;
+	return counts;
+}
+function formatSummary(reports, catalog, issues, now) {
+	const lines = [];
+	if (reports.length === 0) lines.push("No providers opted in. Add one under \"providers\" in the config to complete its models.");
+	for (const report of reports) {
+		if (report.status === "skipped" || report.status === "failed") {
+			lines.push(`${report.provider}: ${report.status} — ${report.reason ?? "no reason given"}`);
+			continue;
+		}
+		const counts = countByKind(report.models);
+		lines.push(`${report.provider}: ${counts.resolved} completed, ${counts.ambiguous} ambiguous, ${counts.unresolved} unresolved (${report.models.length} models)`);
+	}
+	if (catalog === void 0) lines.push("", "catalogs: not loaded yet");
+	else {
+		lines.push("", catalog.status === "ready" ? "catalogs:" : "catalogs: unavailable — nothing was applied");
+		for (const source of catalog.sources) {
+			const error = source.lastError === void 0 ? "" : ` — ${source.lastError}`;
+			lines.push(`  ${source.source}: ${source.entryCount} entries, ${age(now, source.fetchedAt)}${error}`);
+		}
+	}
+	if (issues.length > 0) {
+		lines.push("", "config issues:");
+		for (const issue of issues) lines.push(`  ${issue.sourcePath}: ${issue.message}`);
+	}
+	return lines.join("\n");
+}
+function formatDetail(reports, reference, effective) {
+	const { providerId, modelId } = splitReference(reference);
+	const matches = reports.flatMap((report) => report.models.filter((model) => model.id === modelId && (providerId === void 0 || report.provider === providerId)).map((model) => ({
+		report,
+		model
+	})));
+	const first = matches[0];
+	if (first === void 0) return `No completed model matches '${reference}'. Run /${COMMAND_NAME} to see what is covered.`;
+	const { report, model } = first;
+	const lines = [`requested:  ${report.provider}/${model.id}`];
+	if (model.resolution.kind === "resolved") {
+		const { entry, matchKind, prefixRule, suffixRule } = model.resolution;
+		lines.push(`canonical:  ${entry.canonicalId}  (${entry.source})`);
+		lines.push(`match:      ${matchKind}`);
+		const rules = [prefixRule?.id, suffixRule?.id].filter((id) => id !== void 0);
+		if (rules.length > 0) lines.push(`rule:       ${rules.join(", ")}`);
+	} else if (model.resolution.kind === "ambiguous") {
+		lines.push("match:      ambiguous — nothing was applied");
+		lines.push("candidates:");
+		for (const candidate of model.resolution.candidates) lines.push(`  ${candidate.canonicalId}  (${candidate.source})`);
+		lines.push("Add an alias for this model to choose one.");
+	} else lines.push(`match:      unresolved (${model.resolution.reason})`);
+	const source = (field) => {
+		const origin = model.provenance.get(field);
+		return origin === void 0 || origin === "existing" ? "" : `   from ${origin}`;
+	};
+	lines.push("");
+	lines.push(`context:    ${model.model.contextWindow}${source("contextWindow")}`);
+	lines.push(`maxTokens:  ${model.model.maxTokens}${source("maxTokens")}`);
+	lines.push(`reasoning:  ${model.model.reasoning}${source("reasoning")}`);
+	lines.push(`input:      ${model.model.input.join(", ")}${source("input")}`);
+	lines.push(`cost:       $${model.model.cost.input}/$${model.model.cost.output} per Mtok${source("cost")}`);
+	if (effective !== void 0 && diverges(effective, model)) {
+		lines.push("");
+		lines.push("Pi is using different values (models.json modelOverrides win over this extension):");
+		lines.push(`  context: ${effective.contextWindow}   maxTokens: ${effective.maxTokens}`);
+		lines.push(`  reasoning: ${effective.reasoning}   cost: $${effective.cost.input}/$${effective.cost.output}`);
+	}
+	if (model.issues.length > 0) {
+		lines.push("");
+		for (const issue of model.issues) lines.push(`note: ${issue}`);
+	}
+	if (matches.length > 1) {
+		lines.push("");
+		lines.push(`'${modelId}' also exists on: ${matches.slice(1).map((match) => match.report.provider).join(", ")}`);
+	}
+	return lines.join("\n");
+}
+function diverges(effective, report) {
+	return effective.contextWindow !== report.model.contextWindow || effective.maxTokens !== report.model.maxTokens || effective.reasoning !== report.model.reasoning || effective.cost.input !== report.model.cost.input || effective.cost.output !== report.model.cost.output;
+}
+/** Runs on every keystroke, so it stays a prefix filter over an already-built list. */
+function buildCompletions(reports, prefix) {
+	const needle = prefix.trim().toLowerCase();
+	const items = [];
+	if ("refresh".startsWith(needle)) items.push({
+		value: "refresh",
+		label: "refresh",
+		description: "Re-check the catalogs now"
+	});
+	for (const report of reports) for (const model of report.models) {
+		const value = `${report.provider}/${model.id}`;
+		if (needle.length === 0 || value.toLowerCase().includes(needle)) items.push({
+			value,
+			label: value,
+			description: model.resolution.kind
+		});
+		if (items.length >= COMPLETION_LIMIT) return items;
+	}
+	return items.length > 0 ? items : null;
+}
+function registerModelInfoCommand(pi, controller) {
+	try {
+		pi.registerCommand(COMMAND_NAME, {
+			description: "Inspect the model metadata pi-model-info resolved for your third-party providers",
+			getArgumentCompletions(prefix) {
+				return buildCompletions(controller.getReports(), prefix);
+			},
+			async handler(args, ctx) {
+				const argument = args.trim();
+				if (argument === "refresh") await controller.refresh();
+				if (argument === "refresh" || argument.length === 0) {
+					const summary = formatSummary(controller.getReports(), controller.getCatalog(), controller.getIssues(), Date.now());
+					ctx.ui.notify(summary, "info");
+					return;
+				}
+				const { providerId, modelId } = splitReference(argument);
+				const effective = providerId === void 0 ? void 0 : controller.getEffectiveModel(providerId, modelId);
+				ctx.ui.notify(formatDetail(controller.getReports(), argument, effective), "info");
+			}
+		});
+	} catch (error) {
+		console.warn(`[pi-model-info] could not register /${COMMAND_NAME}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+//#endregion
+//#region src/models-json.ts
+/** Only fields this extension would otherwise overwrite are worth tracking. */
+const TRACKED_FIELDS = /* @__PURE__ */ new Set([
+	"name",
+	"reasoning",
+	"input",
+	"cost",
+	"contextWindow",
+	"maxTokens",
+	"thinkingLevelMap"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function defaultRead(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return;
+	}
+}
+/**
+* Answers what the registry cannot: whether a value was hand-written or is Pi's placeholder.
+* Without it, a user who wrote `contextWindow: 200000` would silently get the catalog's number.
+*/
+function readUserAuthoredFields(agentDir, readFile = defaultRead) {
+	const authored = /* @__PURE__ */ new Map();
+	let raw;
+	try {
+		raw = readFile(join(agentDir, "models.json"));
+	} catch {
+		return authored;
+	}
+	if (raw === void 0) return authored;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return authored;
+	}
+	if (!isRecord(parsed) || !isRecord(parsed["providers"])) return authored;
+	for (const [providerId, provider] of Object.entries(parsed["providers"])) {
+		if (!isRecord(provider) || !Array.isArray(provider["models"])) continue;
+		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);
+		}
+		if (models.size > 0) authored.set(providerId, models);
+	}
+	return authored;
+}
+
+//#endregion
+//#region src/merge.ts
+const OVERRIDE_FIELDS = [
+	"name",
+	"reasoning",
+	"input",
+	"cost",
+	"contextWindow",
+	"maxTokens",
+	"thinkingLevelMap",
+	"compat"
+];
+function isOverrideField(field) {
+	return OVERRIDE_FIELDS.includes(field);
+}
+function mergeCost(base, incoming) {
+	return compact({
+		input: incoming.input ?? base.input,
+		output: incoming.output ?? base.output,
+		cacheRead: incoming.cacheRead ?? base.cacheRead,
+		cacheWrite: incoming.cacheWrite ?? base.cacheWrite,
+		tiers: incoming.tiers ?? base.tiers
+	});
+}
+function unionInput(a, b) {
+	const combined = /* @__PURE__ */ new Set([...a, ...b]);
+	const input = ["text"];
+	if (combined.has("image")) input.push("image");
+	return input;
+}
+/** A relay's markup applies to catalog pricing only, never to a rule's explicit `0`. */
+function scaleCost(cost, multiplier) {
+	if (multiplier === 1) return cost;
+	const scale = (value) => value === void 0 ? void 0 : value * multiplier;
+	return compact({
+		input: scale(cost.input),
+		output: scale(cost.output),
+		cacheRead: scale(cost.cacheRead),
+		cacheWrite: scale(cost.cacheWrite),
+		tiers: cost.tiers?.map((tier) => ({
+			input: tier.input * multiplier,
+			output: tier.output * multiplier,
+			cacheRead: tier.cacheRead * multiplier,
+			cacheWrite: tier.cacheWrite * multiplier,
+			inputTokensAbove: tier.inputTokensAbove
+		}))
+	});
+}
+/**
+* Cost, limits and capabilities all come from the single winning entry. Only fields the winner's
+* source schema cannot express are backfilled, and only from a same-provider pi.dev donor.
+*/
+function catalogLayer(match, provider, snapshot) {
+	const { entry, donor } = match;
+	const metadata = entry.metadata;
+	const ownMap = entry.source === "pi.dev" || provider.mapThinkingLevels ? metadata.thinkingLevelMap : void 0;
+	const layer = {};
+	if (provider.useCatalogName && metadata.name !== void 0) layer.name = metadata.name;
+	if (provider.capabilityPolicy !== "keep") {
+		if (metadata.reasoning !== void 0) layer.reasoning = provider.capabilityPolicy === "widen" ? snapshot.reasoning || metadata.reasoning : metadata.reasoning;
+		if (metadata.input !== void 0) layer.input = provider.capabilityPolicy === "widen" ? unionInput(snapshot.input, metadata.input) : metadata.input;
+	}
+	if (provider.contextWindowPolicy !== "keep") {
+		if (metadata.contextWindow !== void 0) layer.contextWindow = provider.contextWindowPolicy === "min" ? Math.min(metadata.contextWindow, snapshot.contextWindow) : metadata.contextWindow;
+		if (metadata.maxTokens !== void 0) layer.maxTokens = provider.contextWindowPolicy === "min" ? Math.min(metadata.maxTokens, snapshot.maxTokens) : metadata.maxTokens;
+	}
+	if (provider.costPolicy === "zero") layer.cost = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0
+	};
+	else if (provider.costPolicy === "catalog" && metadata.cost !== void 0) layer.cost = scaleCost(metadata.cost, provider.costMultiplier);
+	const thinkingLevelMap = ownMap ?? donor?.metadata.thinkingLevelMap;
+	if (thinkingLevelMap !== void 0) layer.thinkingLevelMap = thinkingLevelMap;
+	const compat = (entry.api === snapshot.api ? metadata.compat : void 0) ?? (donor?.api === snapshot.api ? donor.metadata.compat : void 0);
+	if (compat !== void 0) layer.compat = compat;
+	return layer;
+}
+/** Drops slots that are present but undefined; omission already means "provider default". */
+function compactThinkingLevelMap(map) {
+	if (map === void 0) return;
+	const compacted = {};
+	let kept = false;
+	for (const level of THINKING_LEVELS) {
+		const value = map[level];
+		if (value !== void 0) {
+			compacted[level] = value;
+			kept = true;
+		}
+	}
+	return kept ? compacted : void 0;
+}
+function applyLayer(draft, label, override, provenance) {
+	for (const field of OVERRIDE_FIELDS) if (override[field] !== void 0) provenance.set(field, label);
+	if (override.name !== void 0) draft.name = override.name;
+	if (override.reasoning !== void 0) draft.reasoning = override.reasoning;
+	if (override.input !== void 0) draft.input = override.input;
+	if (override.cost !== void 0) draft.cost = mergeCost(draft.cost, override.cost);
+	if (override.contextWindow !== void 0) draft.contextWindow = override.contextWindow;
+	if (override.maxTokens !== void 0) draft.maxTokens = override.maxTokens;
+	if (override.thinkingLevelMap !== void 0) draft.thinkingLevelMap = {
+		...draft.thinkingLevelMap,
+		...override.thinkingLevelMap
+	};
+	if (override.compat !== void 0) draft.compat = override.compat;
+}
+/**
+* Automatic values never overwrite what the user hand-wrote in models.json; an explicit override
+* layered later is a different matter, being equally deliberate.
+*/
+function dropAuthored(layer, authored, provenance) {
+	for (const field of authored) if (isOverrideField(field)) {
+		delete layer[field];
+		provenance.set(field, "models.json");
+	}
+}
+function isPositiveInt(value) {
+	return Number.isInteger(value) && value > 0;
+}
+function costIsValid(cost) {
+	return [
+		cost.input,
+		cost.output,
+		cost.cacheRead,
+		cost.cacheWrite,
+		...(cost.tiers ?? []).flatMap((tier) => [
+			tier.input,
+			tier.output,
+			tier.cacheRead,
+			tier.cacheWrite
+		])
+	].every((value) => Number.isFinite(value) && value >= 0);
+}
+function mergeMetadata(input) {
+	const { snapshot, provider, resolution, gate } = input;
+	const issues = [];
+	const provenance = new Map(OVERRIDE_FIELDS.map((field) => [field, "existing"]));
+	const draft = {
+		name: snapshot.name,
+		reasoning: snapshot.reasoning,
+		input: [...snapshot.input],
+		cost: snapshot.cost,
+		contextWindow: snapshot.contextWindow,
+		maxTokens: snapshot.maxTokens,
+		thinkingLevelMap: snapshot.thinkingLevelMap,
+		compat: snapshot.compat
+	};
+	if (resolution.kind === "resolved") {
+		const layer = catalogLayer(resolution, provider, snapshot);
+		if (input.userAuthored !== void 0) dropAuthored(layer, input.userAuthored, provenance);
+		applyLayer(draft, resolution.entry.source, layer, provenance);
+		for (const rule of [resolution.prefixRule, resolution.suffixRule]) if (rule?.override !== void 0) applyLayer(draft, `rule '${rule.id}'`, rule.override, provenance);
+	}
+	if (gate?.override !== void 0) applyLayer(draft, "model override", gate.override, provenance);
+	if (!isPositiveInt(draft.contextWindow)) {
+		issues.push(`invalid contextWindow ${draft.contextWindow}; kept ${snapshot.contextWindow}`);
+		draft.contextWindow = snapshot.contextWindow;
+		provenance.set("contextWindow", "existing");
+	}
+	if (!isPositiveInt(draft.maxTokens)) {
+		issues.push(`invalid maxTokens ${draft.maxTokens}; kept ${snapshot.maxTokens}`);
+		draft.maxTokens = snapshot.maxTokens;
+		provenance.set("maxTokens", "existing");
+	}
+	if (draft.maxTokens > draft.contextWindow) draft.maxTokens = draft.contextWindow;
+	if (!costIsValid(draft.cost)) {
+		issues.push("invalid cost; kept the existing rates");
+		draft.cost = snapshot.cost;
+		provenance.set("cost", "existing");
+	}
+	if (draft.input.length === 0) {
+		draft.input = [...snapshot.input];
+		provenance.set("input", "existing");
+	}
+	return {
+		model: compact({
+			id: snapshot.id,
+			name: draft.name,
+			api: snapshot.api,
+			baseUrl: snapshot.baseUrl,
+			reasoning: draft.reasoning,
+			input: draft.input,
+			cost: draft.cost,
+			contextWindow: draft.contextWindow,
+			maxTokens: draft.maxTokens,
+			thinkingLevelMap: compactThinkingLevelMap(draft.thinkingLevelMap),
+			compat: draft.compat,
+			headers: snapshot.headers,
+			samplingParams: snapshot.samplingParams
+		}),
+		issues,
+		provenance
+	};
+}
+
+//#endregion
+//#region src/resolver.ts
+/**
+* Vendor qualification is a key form rather than an affix rule: relays overwhelmingly use
+* `vendor/model` ids, and spending the one-prefix budget on that would leave nothing for a real
+* prefix. The vendor-scoped form deliberately precedes the unscoped one, whose bare-id fallback can
+* return several providers — an explicit `anthropic/…` should settle that outright.
+*/
+function keyForms(provider, id) {
+	const forms = [];
+	const vendor = vendorOf(id);
+	const rest = bareId(id);
+	if (provider.catalogProvider !== void 0) {
+		forms.push({
+			scope: provider.catalogProvider,
+			id,
+			vendorScoped: false,
+			vendor
+		});
+		if (vendor !== void 0) forms.push({
+			scope: provider.catalogProvider,
+			id: rest,
+			vendorScoped: false,
+			vendor
+		});
+	}
+	forms.push({
+		scope: provider.id,
+		id,
+		vendorScoped: false,
+		vendor
+	});
+	if (vendor !== void 0) forms.push({
+		scope: vendor,
+		id: rest,
+		vendorScoped: true,
+		vendor
+	});
+	forms.push({
+		scope: void 0,
+		id,
+		vendorScoped: false,
+		vendor
+	});
+	return forms;
+}
+function candidatesFor(index, form) {
+	if (form.scope !== void 0) return {
+		entries: index.scoped.get(scopedKey(form.scope, form.id)) ?? [],
+		viaBare: false
+	};
+	const exact = index.exact.get(form.id.toLowerCase());
+	if (exact !== void 0 && exact.length > 0) return {
+		entries: exact,
+		viaBare: false
+	};
+	return {
+		entries: index.bare.get(bareId(form.id).toLowerCase()) ?? [],
+		viaBare: true
+	};
+}
+/**
+* The tie-break selects a PROVIDER; insertion order (already source-ranked) then selects the entry.
+* Splicing fields from two providers would be incoherent — the same bare id genuinely differs in
+* price and limits between them.
+*/
+function select(found, index, provider, form) {
+	const candidates = found.entries;
+	if (candidates.length === 0) return;
+	const groups = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const key = (candidate.sourceProvider ?? "").toLowerCase();
+		const bucket = groups.get(key);
+		if (bucket === void 0) groups.set(key, [candidate]);
+		else bucket.push(candidate);
+	}
+	let group = groups.size === 1 ? [...groups.values()][0] : void 0;
+	if (group === void 0) {
+		const tiers = [
+			provider.catalogProvider,
+			provider.id,
+			index.vendors.get(bareId(form.id).toLowerCase())
+		];
+		for (const tier of tiers) {
+			const match = tier === void 0 ? void 0 : groups.get(tier.toLowerCase());
+			if (match !== void 0) {
+				group = match;
+				break;
+			}
+		}
+	}
+	if (group === void 0) return { ambiguous: candidates };
+	const winner = group[0];
+	if (winner === void 0) return;
+	return { hit: {
+		entry: winner,
+		donor: group.find((entry) => entry !== winner && entry.source === "pi.dev"),
+		viaVendorSplit: form.vendorScoped || found.viaBare && form.vendor !== void 0
+	} };
+}
+function lookup(index, provider, id) {
+	for (const form of keyForms(provider, id)) {
+		const outcome = select(candidatesFor(index, form), index, provider, form);
+		if (outcome !== void 0) return outcome;
+	}
+}
+function matched(hit, matchKind, prefixRule, suffixRule) {
+	return {
+		kind: "resolved",
+		entry: hit.entry,
+		donor: hit.donor,
+		matchKind,
+		prefixRule,
+		suffixRule
+	};
+}
+/** Removes at most one prefix and one suffix; a no-op or empty residual is not a match. */
+function strip(id, prefix, suffix) {
+	let out = id;
+	if (prefix !== void 0) {
+		if (!out.startsWith(prefix.value)) return;
+		out = out.slice(prefix.value.length);
+	}
+	if (suffix !== void 0) {
+		if (!out.endsWith(suffix.value)) return;
+		out = out.slice(0, out.length - suffix.value.length);
+	}
+	return out.length === 0 || out === id ? void 0 : out;
+}
+/** unset = every rule · `[]` = none · `['id']` = only those. */
+function gateRules(allowed, rules) {
+	if (allowed === void 0) return rules;
+	const ids = new Set(allowed);
+	return rules.filter((rule) => ids.has(rule.id));
+}
+/**
+* Single strips before double strips, so `x-preview-free` does not lose `-preview` when only `-free`
+* was needed. Rules arrive longest-value-first, so a broad `-free` cannot shadow `-preview-free`.
+*/
+function combinations(prefixes, suffixes) {
+	const combos = [];
+	for (const suffix of suffixes) combos.push([void 0, suffix]);
+	for (const prefix of prefixes) combos.push([prefix, void 0]);
+	for (const prefix of prefixes) for (const suffix of suffixes) combos.push([prefix, suffix]);
+	return combos;
+}
+function resolveModel(input) {
+	const { index, provider, modelId } = input;
+	const gate = provider.models.get(modelId);
+	if (gate?.skip === true) return {
+		kind: "unresolved",
+		reason: "skipped"
+	};
+	if (gate?.alias !== void 0) {
+		const outcome = lookup(index, provider, gate.alias);
+		if (outcome === void 0) return {
+			kind: "unresolved",
+			reason: "alias-miss"
+		};
+		return "ambiguous" in outcome ? {
+			kind: "ambiguous",
+			candidates: outcome.ambiguous
+		} : matched(outcome.hit, "alias");
+	}
+	const direct = lookup(index, provider, modelId);
+	if (direct !== void 0) {
+		if ("ambiguous" in direct) return {
+			kind: "ambiguous",
+			candidates: direct.ambiguous
+		};
+		return matched(direct.hit, direct.hit.viaVendorSplit ? "vendor-qualified" : "exact");
+	}
+	const combos = combinations(gateRules(gate?.prefixes, input.prefixRules), gateRules(gate?.suffixes, input.suffixRules));
+	for (const [prefix, suffix] of combos) {
+		const stripped = strip(modelId, prefix, suffix);
+		if (stripped === void 0) continue;
+		const outcome = lookup(index, provider, stripped);
+		if (outcome === void 0) continue;
+		return "ambiguous" in outcome ? {
+			kind: "ambiguous",
+			candidates: outcome.ambiguous
+		} : matched(outcome.hit, "stripped", prefix, suffix);
+	}
+	return {
+		kind: "unresolved",
+		reason: (input.prefixRules.length > 0 || input.suffixRules.length > 0) && combos.length === 0 ? "rules-disabled" : "no-match"
+	};
+}
+
+//#endregion
+//#region src/provider-apply.ts
+var ProviderApplier = class {
+	snapshots = /* @__PURE__ */ new Map();
+	skipped = /* @__PURE__ */ new Map();
+	reports = /* @__PURE__ */ new Map();
+	lastRegistered = /* @__PURE__ */ new Map();
+	warn;
+	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.
+	*/
+	capture(registry, config) {
+		this.snapshots.clear();
+		this.skipped.clear();
+		this.reports.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) {
+				this.skip(provider.id, "another extension registered a native provider for this id");
+				continue;
+			}
+			const snapshot = [...live.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: []
+			});
+		}
+	}
+	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
+			});
+		}
+	}
+	/**
+	* 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.
+	*/
+	reconcile(registry) {
+		let drifted = false;
+		for (const providerId of this.snapshots.keys()) {
+			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);
+			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.
+	*/
+	releaseStale(pi, registry, config) {
+		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)}`);
+			}
+		}
+	}
+	getReports() {
+		const reports = [...this.reports.values()];
+		for (const [provider, reason] of this.skipped) reports.push({
+			provider,
+			status: "skipped",
+			reason,
+			models: []
+		});
+		return reports.sort((a, b) => a.provider.localeCompare(b.provider));
+	}
+	skip(providerId, reason) {
+		this.skipped.set(providerId, reason);
+		this.warn(`skipping provider '${providerId}': ${reason}`);
+	}
+};
+function sameIds(live, registered) {
+	if (live.length !== registered.length) return false;
+	const ids = new Set(registered.map((model) => model.id));
+	return live.every((model) => ids.has(model.id));
+}
+function isSolelyOurRegistration(stored, models) {
+	if (stored === void 0) return false;
+	const keys = Object.keys(stored);
+	return keys.length === 1 && keys[0] === "models" && stored.models === models;
+}
+
+//#endregion
+//#region src/extension.ts
+function defaultWarn(message) {
+	console.warn(`[${EXTENSION_ID}] ${message}`);
+}
+function createModelInfoExtension(pi, dependencies = {}) {
+	const warn = dependencies.warn ?? defaultWarn;
+	const agentDir = dependencies.agentDir ?? defaultModelInfoAgentDir();
+	const loadConfig = dependencies.loadConfig ?? ((cwd, dir) => loadModelInfoConfig({
+		cwd,
+		agentDir: dir
+	}));
+	const readUserAuthored = dependencies.readUserAuthored ?? ((dir) => readUserAuthoredFields(dir));
+	const schedule = dependencies.schedule ?? ((task) => {
+		setTimeout(task, 0);
+	});
+	const store = dependencies.catalogStore ?? new CatalogStore();
+	const applier = dependencies.applier ?? new ProviderApplier({ warn });
+	let config;
+	let issues = [];
+	let registry;
+	let userAuthored = /* @__PURE__ */ new Map();
+	let catalog;
+	let pending;
+	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;
+		applier.apply(pi, config, snapshot, userAuthored);
+	}
+	async function run(signal) {
+		if (config === void 0) return;
+		applyCatalog(store.load(config));
+		if (signal.aborted) return;
+		const refreshed = await store.refresh(config, signal);
+		if (!signal.aborted) applyCatalog(refreshed);
+	}
+	function start() {
+		const controller = new AbortController();
+		session = controller;
+		schedule(() => {
+			run(controller.signal).catch((error) => {
+				warn(`catalog refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		});
+	}
+	pi.on("session_start", (_event, context) => {
+		session?.abort();
+		session = void 0;
+		pending = void 0;
+		catalog = void 0;
+		registry = context.modelRegistry;
+		isIdle = () => context.isIdle();
+		const loaded = loadConfig(context.cwd, agentDir);
+		const resolved = loaded.config === void 0 ? void 0 : resolveModelInfoConfig(loaded.config, loaded.globalPath);
+		issues = [...loaded.issues, ...resolved?.issues ?? []];
+		for (const issue of issues) warn(`config issue at ${issue.sourcePath}: ${issue.message}`);
+		config = resolved?.config;
+		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);
+		start();
+	});
+	pi.on("before_agent_start", (_event, context) => {
+		if (config === void 0 || catalog === void 0 || registry === void 0) return;
+		isIdle = () => context.isIdle();
+		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);
+		pending = void 0;
+	});
+	pi.on("session_shutdown", () => {
+		session?.abort();
+		session = void 0;
+		pending = void 0;
+	});
+	registerModelInfoCommand(pi, {
+		getReports: () => applier.getReports(),
+		getCatalog: () => catalog,
+		getIssues: () => issues,
+		getEffectiveModel: (providerId, modelId) => registry?.find(providerId, modelId),
+		refresh: async () => {
+			if (config === void 0) return;
+			applyCatalog(await store.refresh(config, new AbortController().signal, true));
+		}
+	});
+}
+
+//#endregion
+//#region src/index.ts
+function modelInfoExtension(pi) {
+	createModelInfoExtension(pi);
+}
+
+//#endregion
+export { modelInfoExtension as default };
+//# sourceMappingURL=index.js.map