ソースを参照

feat: use pi catalog metadata and filter models by api key group

Model capabilities were inferred from name regexes, which marked Gemini
models as non-reasoning, capped them at a 64K context, and left every
model with wrong output limits. Costs were also wrong because
`model_price` is 0 for token-billed models, so
`model_price ?? model_ratio` always produced a free input rate.

Resolve reasoning, input modes, context window, max tokens and thinking
levels from the Pi model catalog for the model's vendor. Fetch the
public catalog when the model cache is refreshed and re-apply the local
registry catalog at session start, so a degraded or offline refresh
still converges. Fall back to family defaults only for models the
catalog does not know.

Compute rates by parsing `billing_expr`, which is the authoritative
DuckCoding price and reflects its own markups. Exclude image, video and
classifier entries that are billed per request, and bump the cache
schema so stale inferred metadata is discarded.

The pricing endpoint lists every billing group, so the picker exposed
models that the API key could not call. Intersect with the
authenticated `/v1/models` result, cached for an hour keyed by a hash
of the API key and invalidated when the key changes. Explicit offline
mode keeps using the cached list.

Signed-off-by: greatbridf <[email protected]>
greatbridf 1 ヶ月 前
親
コミット
cf4e2ada9d
1 ファイル変更、544 行追加、69 行削除
  1. 544 69
      index.ts

+ 544 - 69
index.ts

@@ -8,38 +8,116 @@
  *   Set the DUCKCODING_API_KEY environment variable with your API key.
  *   Then use /model to select duckcoding/<model-id>.
  *
- * Models are fetched from DuckCoding's pricing endpoint and cached locally.
- * The cache is refreshed after seven days by default. Set
- * DUCKCODING_MODEL_CACHE_TTL_MS to override the cache lifetime.
+ * Model availability and rates come from DuckCoding's pricing endpoint.
+ * The authenticated `/v1/models` list narrows that catalog to the models the
+ * API key's billing group can actually use; the result is cached for an hour
+ * and revalidated on refresh. Capabilities and limits come from the Pi model
+ * catalog: the public catalog is fetched when the cache is refreshed, and Pi's
+ * local registry re-applies catalog metadata at session start so an offline or
+ * partial refresh still resolves correctly. The cache is refreshed after seven
+ * days by default. Set DUCKCODING_MODEL_CACHE_TTL_MS to override the cache
+ * lifetime.
  */
 
+import { createHash } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+
+type ChatModelConfig = Extract<ProviderModelConfig, { reasoning: boolean }>;
+
+type DuckCodingPricingModel = {
+	model_name?: string;
+	vendor_id?: number;
+	quota_type?: number;
+	supported_endpoint_types?: string[];
+	enable_groups?: string[];
+	model_price?: number;
+	model_ratio?: number;
+	completion_ratio?: number;
+	cache_ratio?: number;
+	create_cache_ratio?: number;
+	billing_expr?: string;
+};
 
 type DuckCodingPricingResponse = {
 	success?: boolean;
-	data?: Array<{
-		model_name?: string;
-		vendor_id?: number;
-		supported_endpoint_types?: string[];
-		enable_groups?: string[];
-		model_price?: number;
-		model_ratio?: number;
-		completion_ratio?: number;
-		cache_ratio?: number;
-		create_cache_ratio?: number;
-	}>;
+	vendors?: Array<{ id?: number; name?: string }>;
+	data?: DuckCodingPricingModel[];
 };
 
-const PRICING_URL = "https://www.duckcoding.ai/api/pricing";
-const DEFAULT_MODEL_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-const MODEL_CACHE_PATH = join(homedir(), ".cache", "pi-agent-duckcoding", "models.json");
+type DuckCodingModelsResponse = {
+	data?: Array<{ id?: string }>;
+};
+
+type CatalogModel = {
+	id?: string;
+	provider?: string;
+	type?: string;
+	reasoning?: boolean;
+	input?: string[];
+	contextWindow?: number;
+	maxTokens?: number;
+	thinkingLevelMap?: ChatModelConfig["thinkingLevelMap"];
+};
+
+type CatalogIndex = Map<string, Map<string, CatalogModel>>;
+
+type ModelSet = {
+	models: ChatModelConfig[];
+	/** DuckCoding model ID → Pi catalog provider ID (google, anthropic, …). */
+	vendorProviders: Map<string, string>;
+};
 
 type CachedModels = {
+	version: number;
 	fetchedAt: number;
-	models: ReturnType<typeof createModels>;
+	degraded?: boolean;
+	models: ChatModelConfig[];
+	vendorProviders: Record<string, string>;
+};
+
+type CachedAvailability = {
+	version: number;
+	keyHash: string;
+	checkedAt: number;
+	ids: string[];
+};
+
+const PRICING_URL = "https://www.duckcoding.ai/api/pricing";
+const MODELS_URL = "https://api.duckcoding.ai/v1/models";
+const CATALOG_BASE_URL = "https://pi.dev";
+const CATALOG_TIMEOUT_MS = 5_000;
+const CATALOG_TOTAL_BUDGET_MS = 12_000;
+const PRICING_TIMEOUT_MS = 15_000;
+const AVAILABILITY_TIMEOUT_MS = 6_000;
+const AVAILABILITY_TTL_MS = 60 * 60 * 1000;
+const AVAILABILITY_CACHE_VERSION = 1;
+const DEFAULT_MODEL_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+// Retry sooner when the Pi catalog could not be fetched and some limits fell
+// back to family defaults.
+const DEGRADED_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const CACHE_VERSION = 2;
+const MODEL_CACHE_DIR = join(homedir(), ".cache", "pi-agent-duckcoding");
+const MODEL_CACHE_PATH = join(MODEL_CACHE_DIR, "models.json");
+const AVAILABILITY_CACHE_PATH = join(MODEL_CACHE_DIR, "availability.json");
+
+/** DuckCoding vendor names mapped to Pi catalog provider IDs. */
+const VENDOR_CATALOG_PROVIDERS: Record<string, string> = {
+	gemini: "google",
+	anthropic: "anthropic",
+	openai: "openai",
+	grok: "xai",
+	deepseek: "deepseek",
+	zhipu: "zai",
+	"智谱": "zai",
+};
+
+type FamilyDefaults = {
+	reasoning: boolean;
+	contextWindow: number;
+	maxTokens: number;
 };
 
 function titleCaseModelName(modelName: string) {
@@ -49,105 +127,502 @@ function titleCaseModelName(modelName: string) {
 		.join(" ");
 }
 
-function inferReasoning(modelName: string) {
-	return /reasoner|thinking|o[34]|claude-sonnet|codex/i.test(modelName);
+/** Fallback limits for models missing from the Pi catalog. */
+function inferFamilyDefaults(modelName: string): FamilyDefaults {
+	if (/gemini-3|gemini-2\.5/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 1048576, maxTokens: 65536 };
+	}
+	if (/^claude/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 1000000, maxTokens: 128000 };
+	}
+	if (/^gpt-6|^gpt-5\.6/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 272000, maxTokens: 128000 };
+	}
+	if (/^gpt-5|^o[34]/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 400000, maxTokens: 128000 };
+	}
+	if (/^grok-[5-9]|^grok-4\.[5-9]/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 500000, maxTokens: 500000 };
+	}
+	if (/^grok-4/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 200000, maxTokens: 32000 };
+	}
+	if (/^deepseek/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 1000000, maxTokens: 384000 };
+	}
+	if (/^glm-5/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 1000000, maxTokens: 131072 };
+	}
+	if (/reasoner|thinking|codex/i.test(modelName)) {
+		return { reasoning: true, contextWindow: 400000, maxTokens: 128000 };
+	}
+	return { reasoning: false, contextWindow: 128000, maxTokens: 16384 };
 }
 
 function inferInputModes(endpoints: string[] = []) {
-	const input = ["text"];
-	if (endpoints.some((endpoint) => ["openai", "anthropic"].includes(endpoint))) {
+	const input: ChatModelConfig["input"] = ["text"];
+	if (endpoints.some((endpoint) => ["openai", "anthropic", "gemini"].includes(endpoint))) {
 		input.push("image");
 	}
 	return input;
 }
 
-function inferContextWindow(modelName: string) {
-	if (/gpt-5\./i.test(modelName) || /claude/i.test(modelName)) return 200000;
-	if (/gpt-4o|o4|codex|deepseek/i.test(modelName)) return 128000;
-	return 64000;
+function normalizeInput(input: string[] | undefined): ChatModelConfig["input"] {
+	const modes: ChatModelConfig["input"] = [];
+	for (const mode of input ?? []) {
+		if ((mode === "text" || mode === "image") && !modes.includes(mode)) modes.push(mode);
+	}
+	if (modes.length === 0) modes.push("text");
+	return modes;
+}
+
+function roundRate(value: number) {
+	return Number.isFinite(value) ? Number(value.toFixed(6)) : 0;
+}
+
+/**
+ * DuckCoding bills through a small expression language. The standard tier is
+ * listed first; `p`, `c`, `cr`, and `cc` are USD per million input, output,
+ * cache-read, and cache-write tokens.
+ */
+function parseBillingExpr(expr: string | undefined) {
+	if (!expr) return undefined;
+	const rate = (variable: string) => {
+		const match = expr.match(new RegExp(`(?:^|[^a-zA-Z0-9_])${variable}\\s*\\*\\s*([0-9]+(?:\\.[0-9]+)?)`));
+		return match ? roundRate(Number(match[1])) : 0;
+	};
+	return {
+		input: rate("p"),
+		output: rate("c"),
+		cacheRead: rate("cr"),
+		cacheWrite: rate("cc"),
+	};
+}
+
+function inferCost(model: DuckCodingPricingModel): ChatModelConfig["cost"] {
+	const parsed = parseBillingExpr(model.billing_expr);
+	if (parsed && (parsed.input || parsed.output || parsed.cacheRead || parsed.cacheWrite)) return parsed;
+
+	// Legacy fallback: `model_ratio` is a quota ratio, not USD per token.
+	const input = roundRate((model.model_ratio ?? 0) * 2);
+	return {
+		input,
+		output: roundRate(input * (model.completion_ratio ?? 0)),
+		cacheRead: roundRate(input * (model.cache_ratio ?? 0)),
+		cacheWrite: roundRate(input * (model.create_cache_ratio ?? 0)),
+	};
+}
+
+/** Exclude image, video, embedding, and classifier entries billed per request. */
+function isChatModel(model: DuckCodingPricingModel) {
+	if (!model.model_name) return false;
+	if (model.quota_type !== undefined && model.quota_type !== 0) return false;
+	if (!(model.supported_endpoint_types ?? []).some((endpoint) => endpoint === "openai" || endpoint === "anthropic")) {
+		return false;
+	}
+	return !/^jev-/i.test(model.model_name);
+}
+
+function vendorCatalogProvider(vendorId: number | undefined, vendors: Map<number, string>) {
+	if (vendorId === undefined) return undefined;
+	const name = vendors.get(vendorId)?.trim().toLowerCase();
+	return name ? VENDOR_CATALOG_PROVIDERS[name] : undefined;
+}
+
+function catalogIdCandidates(id: string) {
+	const candidates = [id];
+	const compactStripped = id.replace(/-openai-compact$/, "");
+	if (compactStripped !== id) candidates.push(compactStripped);
+	return candidates;
+}
+
+function findCatalogModel(catalogs: CatalogIndex, provider: string | undefined, modelName: string) {
+	if (!provider) return undefined;
+	const catalog = catalogs.get(provider);
+	if (!catalog) return undefined;
+	for (const candidate of catalogIdCandidates(modelName)) {
+		const entry = catalog.get(candidate);
+		if (entry) return entry;
+	}
+	return undefined;
+}
+
+function withCatalogMetadata(model: ChatModelConfig, catalog: CatalogModel | undefined) {
+	if (!catalog) return model;
+	return {
+		...model,
+		reasoning: catalog.reasoning ?? model.reasoning,
+		input: catalog.input ? normalizeInput(catalog.input) : model.input,
+		contextWindow: catalog.contextWindow ?? model.contextWindow,
+		maxTokens: catalog.maxTokens ?? model.maxTokens,
+		thinkingLevelMap: catalog.thinkingLevelMap ?? model.thinkingLevelMap,
+	};
+}
+
+function sameModelMetadata(a: ChatModelConfig, b: ChatModelConfig) {
+	return (
+		a.reasoning === b.reasoning &&
+		a.contextWindow === b.contextWindow &&
+		a.maxTokens === b.maxTokens &&
+		JSON.stringify(a.input) === JSON.stringify(b.input) &&
+		JSON.stringify(a.thinkingLevelMap ?? null) === JSON.stringify(b.thinkingLevelMap ?? null)
+	);
+}
+
+function applyCatalogMetadata(models: ChatModelConfig[], vendorProviders: Map<string, string>, catalogs: CatalogIndex) {
+	return models.map((model) =>
+		withCatalogMetadata(model, findCatalogModel(catalogs, vendorProviders.get(model.id), model.id)),
+	);
+}
+
+async function fetchCatalogProvider(provider: string, timeoutMs: number) {
+	const url = `${CATALOG_BASE_URL}/api/models/providers/${encodeURIComponent(provider)}?types=chat`;
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+		if (!response.ok) return undefined;
+		const payload = (await response.json()) as unknown;
+		const entries = Array.isArray(payload)
+			? payload
+			: typeof payload === "object" && payload !== null && Array.isArray((payload as { models?: unknown }).models)
+				? ((payload as { models: unknown[] }).models as unknown[])
+				: [];
+		const models = new Map<string, CatalogModel>();
+		for (const entry of entries) {
+			if (typeof entry !== "object" || entry === null) continue;
+			const model = entry as CatalogModel;
+			if (typeof model.id !== "string") continue;
+			if (model.type !== undefined && model.type !== "chat") continue;
+			models.set(model.id, model);
+		}
+		return models.size > 0 ? models : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function collectCatalogProviders(pricing: DuckCodingPricingResponse) {
+	const vendors = new Map<number, string>();
+	for (const vendor of pricing.vendors ?? []) {
+		if (vendor.id !== undefined && vendor.name) vendors.set(vendor.id, vendor.name);
+	}
+	const providers = new Set<string>();
+	for (const model of pricing.data ?? []) {
+		if (!isChatModel(model)) continue;
+		const provider = vendorCatalogProvider(model.vendor_id, vendors);
+		if (provider) providers.add(provider);
+	}
+	return [...providers];
 }
 
-function inferMaxTokens(modelName: string) {
-	if (/gpt-5\./i.test(modelName) || /claude/i.test(modelName)) return 8192;
-	return 16384;
+async function fetchCatalogs(pricing: DuckCodingPricingResponse) {
+	const providers = collectCatalogProviders(pricing);
+	const deadline = Date.now() + CATALOG_TOTAL_BUDGET_MS;
+	const catalogs: CatalogIndex = new Map();
+	const pending = new Set(providers);
+
+	// Keep catalog work bounded. A few quick parallel requests cover the normal
+	// case; failures are retried one at a time while the budget lasts, which is
+	// more reliable than hammering a proxy with a second parallel wave.
+	await Promise.all(
+		providers.map(async (provider) => {
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) return;
+			const models = await fetchCatalogProvider(provider, Math.min(CATALOG_TIMEOUT_MS, remaining));
+			if (models) {
+				catalogs.set(provider, models);
+				pending.delete(provider);
+			}
+		}),
+	);
+	for (const provider of [...pending]) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) break;
+		const models = await fetchCatalogProvider(provider, Math.min(CATALOG_TIMEOUT_MS, remaining));
+		if (models) {
+			catalogs.set(provider, models);
+			pending.delete(provider);
+		}
+	}
+	return { catalogs, degraded: pending.size > 0 };
 }
 
-function inferCost(model: { model_price?: number; model_ratio?: number; completion_ratio?: number; cache_ratio?: number; create_cache_ratio?: number }) {
-	const input = model.model_price ?? model.model_ratio ?? 0;
-	const output = model.completion_ratio ?? 0;
-	const cacheRead = model.cache_ratio ?? 0;
-	const cacheWrite = model.create_cache_ratio ?? 0;
-	return { input, output, cacheRead, cacheWrite };
+/** Build a catalog index from the models Pi already has registered locally. */
+function localCatalogIndex(models: readonly CatalogModel[]): CatalogIndex {
+	const catalogs: CatalogIndex = new Map();
+	for (const model of models) {
+		if (typeof model.id !== "string" || typeof model.provider !== "string") continue;
+		if (!Object.values(VENDOR_CATALOG_PROVIDERS).includes(model.provider)) continue;
+		const provider = model.provider;
+		let catalog = catalogs.get(provider);
+		if (!catalog) catalogs.set(provider, (catalog = new Map()));
+		catalog.set(model.id, model);
+	}
+	return catalogs;
 }
 
-function createModels(pricing: DuckCodingPricingResponse) {
-	return (pricing.data ?? [])
-		.filter((model) => model.model_name)
-		.filter((model) => (model.supported_endpoint_types ?? []).some((endpoint) => endpoint === "openai" || endpoint === "anthropic"))
-		.map((model) => ({
-			id: model.model_name!,
-			name: titleCaseModelName(model.model_name!),
-			reasoning: inferReasoning(model.model_name!),
-			input: inferInputModes(model.supported_endpoint_types),
-			cost: inferCost(model),
-			contextWindow: inferContextWindow(model.model_name!),
-			maxTokens: inferMaxTokens(model.model_name!),
-		}))
+function createModels(pricing: DuckCodingPricingResponse, catalogs: CatalogIndex): ModelSet {
+	const vendors = new Map<number, string>();
+	for (const vendor of pricing.vendors ?? []) {
+		if (vendor.id !== undefined && vendor.name) vendors.set(vendor.id, vendor.name);
+	}
+	const vendorProviders = new Map<string, string>();
+
+	const models = (pricing.data ?? [])
+		.filter(isChatModel)
+		.map((model): ChatModelConfig => {
+			const id = model.model_name!;
+			const provider = vendorCatalogProvider(model.vendor_id, vendors);
+			if (provider) vendorProviders.set(id, provider);
+			const fallback = inferFamilyDefaults(id);
+			return withCatalogMetadata(
+				{
+					id,
+					name: titleCaseModelName(id),
+					reasoning: fallback.reasoning,
+					input: inferInputModes(model.supported_endpoint_types),
+					cost: inferCost(model),
+					contextWindow: fallback.contextWindow,
+					maxTokens: fallback.maxTokens,
+				},
+				findCatalogModel(catalogs, provider, id),
+			);
+		})
 		.sort((a, b) => a.id.localeCompare(b.id));
+
+	return { models, vendorProviders };
 }
 
 async function readCachedModels() {
 	try {
 		const cached = JSON.parse(await readFile(MODEL_CACHE_PATH, "utf8")) as CachedModels;
-		if (Array.isArray(cached.models) && typeof cached.fetchedAt === "number") return cached;
+		if (
+			cached.version === CACHE_VERSION &&
+			Array.isArray(cached.models) &&
+			typeof cached.fetchedAt === "number" &&
+			typeof cached.vendorProviders === "object" &&
+			cached.vendorProviders !== null
+		) {
+			return cached;
+		}
 	} catch {
-		// A missing or invalid cache is treated as a cache miss.
+		// A missing, outdated, or invalid cache is treated as a cache miss.
 	}
 	return undefined;
 }
 
-async function writeCachedModels(models: CachedModels["models"]) {
-	const directory = join(homedir(), ".cache", "pi-agent-duckcoding");
+async function writeCachedModels(set: ModelSet, degraded: boolean) {
 	const temporaryPath = `${MODEL_CACHE_PATH}.tmp`;
-	await mkdir(directory, { recursive: true });
-	await writeFile(temporaryPath, JSON.stringify({ fetchedAt: Date.now(), models }, null, 2));
+	await mkdir(MODEL_CACHE_DIR, { recursive: true });
+	await writeFile(
+		temporaryPath,
+		JSON.stringify(
+			{
+				version: CACHE_VERSION,
+				fetchedAt: Date.now(),
+				degraded,
+				models: set.models,
+				vendorProviders: Object.fromEntries(set.vendorProviders),
+			},
+			null,
+			2,
+		),
+	);
 	await rename(temporaryPath, MODEL_CACHE_PATH);
 }
 
-async function getModels() {
+async function fetchPricing() {
+	const response = await fetch(PRICING_URL, { signal: AbortSignal.timeout(PRICING_TIMEOUT_MS) });
+	if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+	return (await response.json()) as DuckCodingPricingResponse;
+}
+
+/**
+ * The authenticated model list only contains models enabled for the API key's
+ * billing group. The pricing endpoint lists every group, so it over-advertises
+ * models that would fail with `model_not_found`.
+ */
+async function fetchAvailableModelIds(apiKey: string, signal: AbortSignal) {
+	try {
+		const response = await fetch(MODELS_URL, {
+			headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+			signal: AbortSignal.any([signal, AbortSignal.timeout(AVAILABILITY_TIMEOUT_MS)]),
+		});
+		if (!response.ok) return undefined;
+		const payload = (await response.json()) as DuckCodingModelsResponse;
+		const ids = new Set<string>();
+		for (const model of payload.data ?? []) {
+			if (typeof model.id === "string") ids.add(model.id);
+		}
+		return ids.size > 0 ? ids : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function hashApiKey(apiKey: string) {
+	return createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
+}
+
+async function readCachedAvailability() {
+	try {
+		const cached = JSON.parse(await readFile(AVAILABILITY_CACHE_PATH, "utf8")) as CachedAvailability;
+		if (
+			cached.version === AVAILABILITY_CACHE_VERSION &&
+			typeof cached.keyHash === "string" &&
+			typeof cached.checkedAt === "number" &&
+			Array.isArray(cached.ids)
+		) {
+			return cached;
+		}
+	} catch {
+		// A missing or invalid availability cache is treated as a cache miss.
+	}
+	return undefined;
+}
+
+async function writeCachedAvailability(keyHash: string, ids: Set<string>) {
+	const temporaryPath = `${AVAILABILITY_CACHE_PATH}.tmp`;
+	await mkdir(MODEL_CACHE_DIR, { recursive: true });
+	await writeFile(
+		temporaryPath,
+		JSON.stringify({
+			version: AVAILABILITY_CACHE_VERSION,
+			keyHash,
+			checkedAt: Date.now(),
+			ids: [...ids],
+		}),
+	);
+	await rename(temporaryPath, AVAILABILITY_CACHE_PATH);
+}
+
+async function getModels(): Promise<ModelSet> {
 	const cached = await readCachedModels();
 	const cacheTtl = Number(process.env.DUCKCODING_MODEL_CACHE_TTL_MS ?? DEFAULT_MODEL_CACHE_TTL_MS);
 	const ttl = Number.isFinite(cacheTtl) && cacheTtl >= 0 ? cacheTtl : DEFAULT_MODEL_CACHE_TTL_MS;
-	if (cached && Date.now() - cached.fetchedAt < ttl) return cached.models;
+	const effectiveTtl = cached?.degraded ? Math.min(ttl, DEGRADED_CACHE_TTL_MS) : ttl;
+	if (cached && Date.now() - cached.fetchedAt < effectiveTtl) {
+		return { models: cached.models, vendorProviders: new Map(Object.entries(cached.vendorProviders)) };
+	}
 
 	try {
-		const response = await fetch(PRICING_URL);
-		if (!response.ok) {
-			throw new Error(`${response.status} ${response.statusText}`);
-		}
-		const models = createModels((await response.json()) as DuckCodingPricingResponse);
-		if (models.length === 0) throw new Error("pricing response contained no compatible models");
+		const pricing = await fetchPricing();
+		const { catalogs, degraded } = await fetchCatalogs(pricing);
+		const set = createModels(pricing, catalogs);
+		if (set.models.length === 0) throw new Error("pricing response contained no compatible models");
 		try {
-			await writeCachedModels(models);
+			await writeCachedModels(set, degraded);
 		} catch {
 			// The freshly fetched list is still usable if the cache cannot be written.
 		}
-		return models;
+		return set;
 	} catch (error) {
-		if (cached) return cached.models;
+		if (cached) return { models: cached.models, vendorProviders: new Map(Object.entries(cached.vendorProviders)) };
 		throw new Error(`Failed to fetch DuckCoding pricing: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
 
-export default async function (pi: ExtensionAPI) {
-	const models = await getModels();
+type AvailabilityState = {
+	ids: Set<string> | undefined;
+	keyHash: string | undefined;
+	checkedAt: number | undefined;
+	load: Promise<void> | undefined;
+	inFlight: Promise<void> | undefined;
+};
+
+function registerDuckCoding(pi: ExtensionAPI, models: ChatModelConfig[], availability: AvailabilityState) {
+	const availableModels = () => {
+		if (!availability.ids) return models;
+		const filtered = models.filter((model) => availability.ids?.has(model.id));
+		// If the pricing catalog and the key's model list share nothing, keep the
+		// full list rather than presenting an empty provider.
+		return filtered.length > 0 ? filtered : models;
+	};
 
 	pi.registerProvider("duckcoding", {
 		name: "DuckCoding AI",
 		baseUrl: "https://api.duckcoding.ai/v1",
 		apiKey: "$DUCKCODING_API_KEY",
 		api: "openai-completions",
-		models,
+		models: availableModels(),
 		headers: {},
+		refreshModels: async (context) => {
+			const apiKey = context.credential?.type === "api_key" ? context.credential.key : undefined;
+			const keyHash = apiKey ? hashApiKey(apiKey) : undefined;
+
+			if (!availability.load) {
+				availability.load = (async () => {
+					const cached = await readCachedAvailability();
+					if (cached) {
+						availability.ids = new Set(cached.ids);
+						availability.keyHash = cached.keyHash;
+						availability.checkedAt = cached.checkedAt;
+					}
+				})();
+			}
+			await availability.load;
+
+			const cacheMatches = keyHash !== undefined && availability.keyHash === keyHash;
+			if (!cacheMatches) {
+				// Never apply a previous key's availability to a different credential.
+				availability.ids = undefined;
+				availability.checkedAt = undefined;
+			}
+
+			const stale = !availability.checkedAt || Date.now() - availability.checkedAt > AVAILABILITY_TTL_MS;
+			// Pi passes allowNetwork=false during normal startup, so honoring that
+			// flag here would leave dead models in the picker. This is a small,
+			// credential-scoped check with its own TTL cache; explicit offline mode
+			// still short-circuits it.
+			const canRefresh = apiKey !== undefined && keyHash !== undefined && !context.signal.aborted && !process.env.PI_OFFLINE;
+			if (stale && canRefresh) {
+				if (!availability.inFlight) {
+					availability.inFlight = (async () => {
+						try {
+							const ids = await fetchAvailableModelIds(apiKey!, context.signal);
+							if (ids) {
+								availability.ids = ids;
+								availability.keyHash = keyHash!;
+								availability.checkedAt = Date.now();
+								try {
+									await writeCachedAvailability(keyHash!, ids);
+								} catch {
+									// Availability still applies for this process.
+								}
+							}
+						} finally {
+							availability.inFlight = undefined;
+						}
+					})();
+				}
+				await availability.inFlight;
+			}
+
+			return availableModels();
+		},
+	});
+}
+
+export default async function (pi: ExtensionAPI) {
+	let { models, vendorProviders } = await getModels();
+	const availability: AvailabilityState = {
+		ids: undefined,
+		keyHash: undefined,
+		checkedAt: undefined,
+		load: undefined,
+		inFlight: undefined,
+	};
+	registerDuckCoding(pi, models, availability);
+
+	// Pi's local registry includes the bundled catalog for built-in providers.
+	// Prefer it at session start: it is offline-safe and repairs any model that
+	// used family defaults because the public catalog was unreachable.
+	pi.on("session_start", (_event, ctx) => {
+		const catalogs = localCatalogIndex(ctx.modelRegistry.getAll());
+		if (catalogs.size === 0) return;
+		const enriched = applyCatalogMetadata(models, vendorProviders, catalogs);
+		if (enriched.some((model, index) => !sameModelMetadata(model, models[index]))) {
+			models = enriched;
+			registerDuckCoding(pi, models, availability);
+		}
 	});
 }