dsh-usage-state 0.4.4 → 0.4.6

package/lib/index.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { createHash } from "node:crypto";
 import z from "@deepseek-ai/schemastery";
 //#region src/shared/config.ts
 const DEFAULT_CONFIG = {
@@ -198,7 +199,7 @@ const HOST_HINTS = [
 	},
 	{
 		sourceId: "kimi",
-		pattern: /(^|\.)(api\.kimi\.com|api\.moonshot\.cn|moonshot\.cn)$/
+		pattern: /(^|\.)(api\.kimi\.(com|ai)|api\.moonshot\.(cn|ai)|moonshot\.cn)$/
 	},
 	{
 		sourceId: "opencode",
@@ -224,6 +225,111 @@ function suggestSourceId(providerId, baseUrl) {
 	return "sub2api";
 }
 //#endregion
+//#region src/shared/providers.ts
+/**
+* The scheme+host of a declared endpoint. A DSH provider profile's `baseURL` is an
+* *API* base (`https://api.z.ai/api/paas/v4`), while every adapter here appends its
+* own path to a bare origin, so only the origin is usable as our endpoint.
+*/
+function originOf(url) {
+	if (url === void 0) return void 0;
+	try {
+		const parsed = new URL(url.trim());
+		return parsed.origin === "null" ? void 0 : parsed.origin;
+	} catch {
+		return;
+	}
+}
+/** Kimi Code and Moonshot use distinct keys and billing endpoints. */
+function kimiMode(provider, endpoint) {
+	const origin = originOf(endpoint);
+	if (origin !== void 0) {
+		const host = new URL(origin).hostname;
+		if (host === "api.kimi.com" || host === "api.kimi.ai") return "coding-plan";
+		if (host === "api.moonshot.cn" || host === "api.moonshot.ai") return "api";
+	}
+	return /(?:^|[^a-z])kimi[-_ ]?(?:for[-_ ]?coding|coding|code)(?:$|[^a-z])/i.test(provider) ? "coding-plan" : "api";
+}
+function withTarget(resolution) {
+	if (resolution.sourceId === null || resolution.mode === null) return resolution;
+	return {
+		...resolution,
+		key: `${resolution.sourceId}:${resolution.mode}`
+	};
+}
+/**
+* Resolve one provider. `auto` picks the source the provider id (or its endpoint)
+* suggests and that source's primary mode, so a provider DSH already has a key
+* for starts working without touching the settings page.
+*/
+function resolveProvider(input) {
+	const entry = input.config.providers[input.provider];
+	const sourceId = entry?.sourceId ?? suggestSourceId(input.provider, input.endpointHint) ?? null;
+	const defaults = sourceId === null ? void 0 : input.config.sources[sourceId];
+	const declared = originOf(input.endpointHint);
+	const explicitBaseUrl = entry?.baseUrl ?? defaults?.baseUrl;
+	const baseUrl = explicitBaseUrl ?? declared;
+	const apiKeyRef = entry?.apiKeyRef ?? defaults?.apiKeyRef;
+	const base = {
+		provider: input.provider,
+		...baseUrl === void 0 ? {} : { baseUrl },
+		...explicitBaseUrl === void 0 ? {} : { baseUrlPinned: true },
+		...apiKeyRef === void 0 ? {} : { apiKeyRef }
+	};
+	if (entry?.mode === "hidden") return {
+		...base,
+		sourceId: null,
+		mode: null,
+		reason: "hidden"
+	};
+	if (sourceId === null) return {
+		...base,
+		sourceId: null,
+		mode: null,
+		reason: "unknown-source"
+	};
+	const source = input.catalog.find((candidate) => candidate.id === sourceId);
+	if (source === void 0) return {
+		...base,
+		sourceId,
+		mode: null,
+		reason: "unknown-source"
+	};
+	if (entry?.mode === "api" || entry?.mode === "coding-plan") {
+		if (!source.modes.includes(entry.mode)) return {
+			...base,
+			sourceId,
+			mode: null,
+			reason: "unsupported"
+		};
+		return withTarget({
+			...base,
+			sourceId,
+			mode: entry.mode,
+			reason: "configured"
+		});
+	}
+	if (source.requiresBaseUrl && baseUrl === void 0) return {
+		...base,
+		sourceId,
+		mode: null,
+		reason: "needs-endpoint"
+	};
+	const mode = sourceId === "kimi" ? kimiMode(input.provider, baseUrl) : source.modes[0];
+	if (mode === void 0 || !source.modes.includes(mode)) return {
+		...base,
+		sourceId,
+		mode: null,
+		reason: "unsupported"
+	};
+	return withTarget({
+		...base,
+		sourceId,
+		mode,
+		reason: "auto"
+	});
+}
+//#endregion
 //#region src/host/sources/normalize.ts
 /** Shared normalization helpers for provider payloads. */
 /** Numbers and numeric strings to a finite number; anything else is absent. */
@@ -309,10 +415,12 @@ function pickBalanceInfo(infos) {
 	for (const raw of infos) {
 		if (raw === null || typeof raw !== "object") continue;
 		const entry = raw;
+		const amount = toFiniteNumber(entry.total_balance);
+		if (amount === void 0) continue;
 		const granted = toFiniteNumber(entry.granted_balance);
 		const toppedUp = toFiniteNumber(entry.topped_up_balance);
 		entries.push({
-			amount: toFiniteNumber(entry.total_balance) ?? 0,
+			amount,
 			currency: typeof entry.currency === "string" ? entry.currency : "",
 			...granted === void 0 ? {} : { granted },
 			...toppedUp === void 0 ? {} : { toppedUp }
@@ -363,7 +471,9 @@ const KIMI_CLI_USER_AGENT = "KimiCLI/1.6";
 const WINDOW_RANK$2 = {
 	"5h": 0,
 	"1d": 1,
-	"7d": 2
+	"7d": 2,
+	month: 3,
+	"month-code": 4
 };
 function asRecord$4(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -375,35 +485,36 @@ function firstFinite(candidates) {
 	}
 }
 /**
-* Moonshot's balance is documented in cents by some sources and in yuan by others,
-* and there is no field that disambiguates the two. This mirrors the heuristic used
-* by the plugin this project replaces: amounts of 100 or more are read as cents.
-* Verified against a real key before trusting the absolute value.
+* Moonshot's official /v1/users/me/balance fields are already in yuan.
+* https://platform.kimi.com/docs/api/balance
+* Amount size never changes the unit; retain the existing two-decimal rounding.
 */
 function moonshotBalanceToYuan(value) {
-	const yuan = value >= 100 ? value / 100 : value;
-	return Math.round(yuan * 100) / 100;
+	return Math.round(value * 100) / 100;
 }
 /** Used percentage from an explicit used/limit pair, or by inverting remaining. */
 function percentFrom(record) {
 	const limit = toFiniteNumber(record.limit);
 	if (limit === void 0 || limit <= 0) return null;
 	const used = toFiniteNumber(record.used);
-	if (used !== void 0) return clampPercent(used / limit * 100);
+	if (used !== void 0 && used >= 0) return clampPercent(Math.min(1, used / limit) * 100);
 	const remaining = toFiniteNumber(record.remaining);
-	if (remaining !== void 0) return clampPercent((limit - remaining) / limit * 100);
+	if (remaining !== void 0 && remaining >= 0 && remaining <= limit) return clampPercent((limit - remaining) / limit * 100);
 	return null;
 }
 /** `{ duration: 5, timeUnit: 'hour' }` -> `5h`, and weekly variants -> `7d`. */
 function windowIdFrom(window) {
 	if (window === void 0) return void 0;
-	const unit = typeof window.timeUnit === "string" ? window.timeUnit.trim().toLowerCase() : "";
+	const unit = typeof window.timeUnit === "string" ? window.timeUnit.trim().toLowerCase().replace(/^time_unit_/, "") : "";
 	const duration = toFiniteNumber(window.duration);
 	if (unit === "" || duration === void 0 || duration <= 0) return void 0;
-	if (unit.startsWith("hour")) return `${duration}h`;
+	if (unit.startsWith("hour")) return duration % 24 === 0 ? `${duration / 24}d` : `${duration}h`;
 	if (unit.startsWith("day")) return duration === 7 ? "7d" : `${duration}d`;
 	if (unit.startsWith("week")) return duration === 1 ? "7d" : `${duration * 7}d`;
-	if (unit.startsWith("minute")) return `${duration}m`;
+	if (unit.startsWith("minute")) return windowIdFrom({
+		duration: duration / 60,
+		timeUnit: "hour"
+	});
 	if (unit.startsWith("month")) return "30d";
 	return `${duration}${unit.slice(0, 4)}`;
 }
@@ -413,6 +524,7 @@ function sortWindows$2(windows) {
 /** `GET /v1/users/me/balance` — pay-as-you-go wallet, CNY. */
 function parseMoonshotBalance(payload) {
 	const root = asRecord$4(payload);
+	rejectErrorEnvelope(root);
 	const nested = root === void 0 ? void 0 : asRecord$4(root.data);
 	const value = firstFinite([
 		root?.available_balance,
@@ -430,19 +542,44 @@ function parseMoonshotBalance(payload) {
 		windows: []
 	};
 }
+function rejectErrorEnvelope(root) {
+	if (root?.error != null || root?.status === false || root?.code !== void 0 && root.code !== 0 && root.code !== "0") throw new SourceError("parse", "Kimi response contains an API error");
+}
 /**
 * `GET /coding/v1/usages` — Kimi Code subscription. The top-level `usage` is the
-* weekly quota; `limits[]` carries the rolling windows (5h among them). Neither is
-* officially documented, so every field is optional here.
+* weekly quota in legacy responses; `limits[]` carries rolling windows. Current
+* official client reads ratio pools in `usages` (see docs/adapters.md).
 */
 function parseKimiCodeUsage(payload) {
 	const root = asRecord$4(payload);
 	if (root === void 0) throw new SourceError("parse", "Kimi Code usage response is not a JSON object");
+	rejectErrorEnvelope(root);
 	const found = /* @__PURE__ */ new Map();
+	const usages = asRecord$4(root.usages);
+	for (const [field, id] of [
+		["limit_5h", "5h"],
+		["limit_7d", "7d"],
+		["limit_month_total", "month"],
+		["limit_month_code", "month-code"]
+	]) {
+		const pool = asRecord$4(usages?.[field]);
+		const ratio = toFiniteNumber(pool?.used_ratio);
+		if (ratio === void 0 || ratio < 0) continue;
+		const usedPercent = clampPercent(Math.min(1, ratio) * 100);
+		const resetsAt = normalizeResetAt(pool?.reset_time);
+		found.set(id, resetsAt === void 0 ? {
+			id,
+			usedPercent
+		} : {
+			id,
+			usedPercent,
+			resetsAt
+		});
+	}
 	const usage = asRecord$4(root.usage);
 	if (usage !== void 0) {
 		const usedPercent = percentFrom(usage);
-		if (usedPercent !== null) {
+		if (usedPercent !== null && !found.has("7d")) {
 			const resetsAt = normalizeResetAt(usage.resetTime ?? usage.reset_at ?? usage.resetsAt);
 			found.set("7d", resetsAt === void 0 ? {
 				id: "7d",
@@ -500,7 +637,8 @@ const kimi = {
 	},
 	request(input) {
 		const codingPlan = input.mode === "coding-plan";
-		const base = normalizeBaseUrl(input.baseUrl) ?? (codingPlan ? KIMI_CODE_BASE_URL : MOONSHOT_BASE_URL);
+		const normalized = normalizeBaseUrl(input.baseUrl) ?? (codingPlan ? KIMI_CODE_BASE_URL : MOONSHOT_BASE_URL);
+		const base = codingPlan ? normalized.replace(/\/coding$/i, "") : normalized;
 		return {
 			url: codingPlan ? `${base}/coding/v1/usages` : `${base}/v1/users/me/balance`,
 			headers: {
@@ -1128,15 +1266,23 @@ function providerCredentialRefs(input) {
 	for (const [providerId, raw] of Object.entries(providers)) {
 		const profile = asRecord(raw);
 		if (profile === void 0) continue;
-		if (suggest(providerId, typeof profile.baseURL === "string" ? profile.baseURL : void 0) !== input.sourceId) continue;
+		const baseUrl = typeof profile.baseURL === "string" ? profile.baseURL : void 0;
+		if (suggest(providerId, baseUrl) !== input.sourceId) continue;
+		if (input.sourceId === "kimi" && input.mode !== void 0) {
+			const entry = input.config?.providers[providerId];
+			const choice = entry?.mode;
+			if (choice === "hidden") continue;
+			const endpoint = entry?.baseUrl ?? input.config?.sources.kimi?.baseUrl ?? baseUrl;
+			if ((choice === "api" || choice === "coding-plan" ? choice : kimiMode(providerId, endpoint)) !== input.mode) continue;
+		}
 		push(profile.apiKeyEnv);
 	}
 	return refs;
 }
 /**
 * The endpoint each configured DSH provider declares (`llm-pi-ai` profiles carry a
-* `baseURL`). Used only to sharpen the data-source suggestion for providers whose
-* id says nothing — e.g. a relay pointed at `open.bigmodel.cn` is a z.ai account.
+* `baseURL`). Its origin also supplies the account request endpoint, and a
+* sanitized origin is shared with the browser for consistent resolution.
 */
 function providerEndpointHints(piAiSettings) {
 	const providers = asRecord(asRecord(piAiSettings)?.providers);
@@ -1206,7 +1352,8 @@ async function fetchPayload(request, deps) {
 	try {
 		return await response.json();
 	} catch (error) {
-		throw new SourceError("parse", `invalid JSON: ${messageOf(error)}`);
+		if (error instanceof SyntaxError) throw new SourceError("parse", `invalid JSON: ${messageOf(error)}`);
+		throw new SourceError("network", messageOf(error));
 	}
 }
 /** Adapt `readUsage` to the shape `UsageStateStore` expects. */
@@ -1221,16 +1368,25 @@ function createTargetReader(deps) {
 }
 //#endregion
 //#region src/host/refresh.ts
-function toSnapshotError(error) {
-	if (error instanceof SourceError) return error.message === "" ? { kind: error.kind } : {
-		kind: error.kind,
-		detail: error.message
+function toSnapshotError(error, secret) {
+	const kind = error instanceof SourceError ? error.kind : "unknown";
+	if (!(error instanceof Error)) return { kind };
+	const message = secret === void 0 || secret === "" ? error.message : error.message.replaceAll(secret, "[redacted]");
+	return message === "" ? { kind } : {
+		kind,
+		detail: message
 	};
-	if (error instanceof Error) return error.message === "" ? { kind: "unknown" } : {
-		kind: "unknown",
-		detail: error.message
-	};
-	return { kind: "unknown" };
+}
+function targetSignature(target) {
+	return JSON.stringify(target === void 0 ? null : [
+		target.key,
+		target.sourceId,
+		target.mode,
+		target.baseUrl,
+		target.baseUrlPinned === true,
+		target.apiKeyRef,
+		target.preferredRefs
+	]);
 }
 /**
 * Holds the last known reading of every configured source and decides when to
@@ -1247,23 +1403,56 @@ var UsageStateStore = class {
 	deps;
 	readings = /* @__PURE__ */ new Map();
 	succeededAt = /* @__PURE__ */ new Map();
+	identities = /* @__PURE__ */ new Map();
+	generations = /* @__PURE__ */ new Map();
+	targetSignatures = /* @__PURE__ */ new Map();
 	inflight = /* @__PURE__ */ new Map();
 	turnEndCancel;
 	idleCancel;
+	idleIntervalMs;
+	stopped = false;
 	constructor(deps) {
 		this.deps = deps;
 	}
+	invalidate(key) {
+		this.generations.set(key, (this.generations.get(key) ?? 0) + 1);
+		this.identities.delete(key);
+		this.readings.delete(key);
+		this.succeededAt.delete(key);
+		this.inflight.delete(key);
+	}
+	currentTargets() {
+		const targets = this.deps.targets().map((target) => ({ ...target }));
+		const active = new Set(targets.map((target) => target.key));
+		for (const key of this.targetSignatures.keys()) {
+			if (active.has(key)) continue;
+			this.invalidate(key);
+			this.targetSignatures.delete(key);
+		}
+		for (const target of targets) {
+			const signature = targetSignature(target);
+			const previous = this.targetSignatures.get(target.key);
+			if (previous !== void 0 && previous !== signature) this.invalidate(target.key);
+			this.targetSignatures.set(target.key, signature);
+		}
+		return targets;
+	}
 	/** Everything known so far, keyed by target key. */
 	snapshots() {
+		if (this.stopped) return {};
+		this.currentTargets();
 		const result = {};
 		for (const [key, snapshot] of this.readings) result[key] = snapshot;
 		return result;
 	}
 	snapshot(key) {
+		if (this.stopped) return void 0;
+		this.currentTargets();
 		return this.readings.get(key);
 	}
 	/** Refresh every configured target; failures are captured, never thrown. */
 	async refreshAll() {
+		if (this.stopped) return;
 		await Promise.all(this.deps.targets().map((target) => this.refresh(target.key)));
 	}
 	/**
@@ -1271,45 +1460,83 @@ var UsageStateStore = class {
 	* not elapsed yet, unless `force` is set.
 	*/
 	async refresh(key, options = {}) {
-		const target = this.deps.targets().find((candidate) => candidate.key === key);
-		if (target === void 0) return this.fail({
-			key,
+		if (this.stopped) return {
 			sourceId: key.split(":")[0] ?? "",
-			mode: "api"
-		}, {
-			kind: "config",
-			detail: `unknown target ${key}`
-		}, this.readings.get(key));
-		const cached = this.readings.get(key);
-		const lastSuccess = this.succeededAt.get(key);
-		if (options.force !== true && cached !== void 0 && cached.error === void 0 && lastSuccess !== void 0 && this.deps.clock.now() - lastSuccess < this.deps.policy().minIntervalSeconds * 1e3) return cached;
-		const running = this.inflight.get(key);
-		if (running !== void 0) return running;
-		const promise = this.run(target).finally(() => {
-			this.inflight.delete(key);
-		});
-		this.inflight.set(key, promise);
-		return promise;
-	}
-	async run(target) {
-		const previous = this.readings.get(target.key);
+			mode: key.endsWith(":coding-plan") ? "coding-plan" : "api",
+			balances: [],
+			windows: [],
+			fetchedAt: this.deps.clock.now(),
+			error: {
+				kind: "config",
+				detail: "refresh stopped"
+			}
+		};
+		const target = this.currentTargets().find((candidate) => candidate.key === key);
+		if (target === void 0) return {
+			sourceId: key.split(":")[0] ?? "",
+			mode: key.endsWith(":coding-plan") ? "coding-plan" : "api",
+			balances: [],
+			windows: [],
+			fetchedAt: this.deps.clock.now(),
+			error: {
+				kind: "config",
+				detail: `unknown target ${key}`
+			}
+		};
+		const signature = targetSignature(target);
+		const generationAtLookup = this.generations.get(key) ?? 0;
 		const source = this.deps.findSource(target.sourceId);
 		if (source === void 0) return this.fail(target, {
 			kind: "config",
 			detail: `unknown source ${target.sourceId}`
-		}, previous);
+		}, this.readings.get(key));
 		let credential;
 		try {
 			credential = await this.deps.credentials.resolve(target);
 		} catch (error) {
-			return this.fail(target, toSnapshotError(error), previous);
+			if (this.stopped) return this.refresh(key, options);
+			if (signature !== targetSignature(this.currentTargets().find((candidate) => candidate.key === key)) || (this.generations.get(key) ?? 0) !== generationAtLookup) return this.refresh(key, options);
+			return this.fail(target, toSnapshotError(error), this.readings.get(key));
+		}
+		if (this.stopped) return this.refresh(key, options);
+		if (signature !== targetSignature(this.currentTargets().find((candidate) => candidate.key === key))) return this.refresh(key, options);
+		const identity = createHash("sha256").update(JSON.stringify([
+			target.sourceId,
+			target.mode,
+			credential?.baseUrl ?? target.baseUrl ?? source.defaultBaseUrl(target.mode),
+			credential?.baseUrlPinned === true || target.baseUrlPinned === true,
+			credential?.ref ?? target.apiKeyRef,
+			credential?.apiKey
+		])).digest("hex");
+		if ((this.generations.get(key) ?? 0) !== generationAtLookup && this.identities.get(key) !== identity) return this.refresh(key, options);
+		if (this.identities.get(key) !== identity) {
+			this.identities.set(key, identity);
+			this.generations.set(key, (this.generations.get(key) ?? 0) + 1);
+			this.readings.delete(key);
+			this.succeededAt.delete(key);
+			this.inflight.delete(key);
 		}
 		if (credential === void 0) return this.fail(target, {
 			kind: "config",
 			detail: "no credential configured"
-		}, previous);
+		}, this.readings.get(key));
+		const cached = this.readings.get(key);
+		const lastSuccess = this.succeededAt.get(key);
+		if (options.force !== true && cached !== void 0 && (options.onlyIfMissing === true || cached.error === void 0 && lastSuccess !== void 0 && this.deps.clock.now() - lastSuccess < this.deps.policy().minIntervalSeconds * 1e3)) return cached;
+		const running = this.inflight.get(key);
+		if (running !== void 0) return running;
+		const generation = this.generations.get(key) ?? 0;
+		const promise = this.run(target, credential, source, generation).finally(() => {
+			if (this.inflight.get(key) === promise) this.inflight.delete(key);
+		});
+		this.inflight.set(key, promise);
+		return promise;
+	}
+	async run(target, credential, source, generation) {
+		const previous = this.readings.get(target.key);
 		try {
 			const reading = await this.deps.read(target, credential, source);
+			if (this.generations.get(target.key) !== generation) return this.refresh(target.key);
 			const fetchedAt = this.deps.clock.now();
 			const snapshot = {
 				sourceId: target.sourceId,
@@ -1322,7 +1549,8 @@ var UsageStateStore = class {
 			this.succeededAt.set(target.key, fetchedAt);
 			return snapshot;
 		} catch (error) {
-			return this.fail(target, toSnapshotError(error), previous);
+			if (this.generations.get(target.key) !== generation) return this.refresh(target.key);
+			return this.fail(target, toSnapshotError(error, credential.apiKey), previous);
 		}
 	}
 	fail(target, error, previous) {
@@ -1353,10 +1581,22 @@ var UsageStateStore = class {
 		});
 		this.turnEndCancel = cancel;
 	}
+	/** Apply a live policy edit without leaving the previous idle timer running. */
+	reconfigure() {
+		if (this.stopped) return;
+		this.currentTargets();
+		if (this.idleCancel === void 0) return;
+		if (this.idleIntervalMs === this.deps.policy().intervalMinutes * 6e4) return;
+		this.idleCancel();
+		this.idleCancel = void 0;
+		this.start();
+	}
 	/** Start the idle fallback timer; returns a stop function. */
 	start() {
+		this.stopped = false;
 		if (this.idleCancel === void 0) {
 			const intervalMs = this.deps.policy().intervalMinutes * 6e4;
+			this.idleIntervalMs = intervalMs;
 			this.idleCancel = this.deps.clock.every(intervalMs, () => {
 				this.refreshAll();
 			});
@@ -1364,6 +1604,8 @@ var UsageStateStore = class {
 		return () => this.stop();
 	}
 	stop() {
+		this.stopped = true;
+		for (const key of this.targetSignatures.keys()) this.invalidate(key);
 		this.turnEndCancel?.();
 		this.turnEndCancel = void 0;
 		this.idleCancel?.();
@@ -1387,18 +1629,20 @@ var UsageStateService = class {
 		this.deps = deps;
 	}
 	/**
-	* Refresh what is due and report every reading. Forcing bypasses the minimum
-	* interval, so it is reserved for the explicit "refresh now" affordance.
+	* Initialize a missing account identity, otherwise report cached readings.
+	* The host owns periodic/turn refreshes; polling this method cannot shorten
+	* that cadence. Forcing is reserved for an explicit refresh.
 	*
 	* Settled rather than all: one unreachable provider must not blank the whole
 	* status line for the others.
 	*/
 	async getState(force) {
-		const options = force === true ? { force: true } : {};
+		const options = force === true ? { force: true } : { onlyIfMissing: true };
 		await Promise.allSettled(this.deps.targets().map((target) => this.deps.store.refresh(target.key, options)));
 		return {
 			sources: this.deps.catalog(),
 			snapshots: this.deps.store.snapshots(),
+			...this.deps.endpointHints === void 0 ? {} : { endpointHints: this.deps.endpointHints() },
 			checkedAt: this.deps.now()
 		};
 	}
@@ -1450,98 +1694,6 @@ function installUsageStateSettings(ctx, reference, onConfig) {
 	});
 }
 //#endregion
-//#region src/shared/providers.ts
-/**
-* The scheme+host of a declared endpoint. A DSH provider profile's `baseURL` is an
-* *API* base (`https://api.z.ai/api/paas/v4`), while every adapter here appends its
-* own path to a bare origin, so only the origin is usable as our endpoint.
-*/
-function originOf(url) {
-	if (url === void 0) return void 0;
-	try {
-		const parsed = new URL(url.trim());
-		return parsed.origin === "null" ? void 0 : parsed.origin;
-	} catch {
-		return;
-	}
-}
-function withTarget(resolution) {
-	if (resolution.sourceId === null || resolution.mode === null) return resolution;
-	return {
-		...resolution,
-		key: `${resolution.sourceId}:${resolution.mode}`
-	};
-}
-/**
-* Resolve one provider. `auto` picks the source the provider id (or its endpoint)
-* suggests and that source's primary mode, so a provider DSH already has a key
-* for starts working without touching the settings page.
-*/
-function resolveProvider(input) {
-	const entry = input.config.providers[input.provider];
-	const declared = originOf(input.endpointHint);
-	const baseUrl = entry?.baseUrl ?? declared;
-	const base = {
-		provider: input.provider,
-		...baseUrl === void 0 ? {} : { baseUrl },
-		...entry?.baseUrl === void 0 ? {} : { baseUrlPinned: true },
-		...entry?.apiKeyRef === void 0 ? {} : { apiKeyRef: entry.apiKeyRef }
-	};
-	if (entry?.mode === "hidden") return {
-		...base,
-		sourceId: null,
-		mode: null,
-		reason: "hidden"
-	};
-	const sourceId = entry?.sourceId ?? suggestSourceId(input.provider, input.endpointHint) ?? null;
-	if (sourceId === null) return {
-		...base,
-		sourceId: null,
-		mode: null,
-		reason: "unknown-source"
-	};
-	const source = input.catalog.find((candidate) => candidate.id === sourceId);
-	if (source === void 0) return {
-		...base,
-		sourceId,
-		mode: null,
-		reason: "unknown-source"
-	};
-	if (entry?.mode === "api" || entry?.mode === "coding-plan") {
-		if (!source.modes.includes(entry.mode)) return {
-			...base,
-			sourceId,
-			mode: null,
-			reason: "unsupported"
-		};
-		return withTarget({
-			...base,
-			sourceId,
-			mode: entry.mode,
-			reason: "configured"
-		});
-	}
-	if (source.requiresBaseUrl && baseUrl === void 0) return {
-		...base,
-		sourceId,
-		mode: null,
-		reason: "needs-endpoint"
-	};
-	const mode = source.modes[0];
-	if (mode === void 0) return {
-		...base,
-		sourceId,
-		mode: null,
-		reason: "unsupported"
-	};
-	return withTarget({
-		...base,
-		sourceId,
-		mode,
-		reason: "auto"
-	});
-}
-//#endregion
 //#region src/host/targets.ts
 function targetKey(sourceId, mode) {
 	return `${sourceId}:${mode}`;
@@ -1554,7 +1706,8 @@ function targetKey(sourceId, mode) {
 * line never shows the same account twice. Providers that are hidden, map to no
 * known source, or ask for a mode the source cannot serve are skipped silently.
 */
-function resolveTargets(config, options = {}) {
+function resolveTargets(rawConfig, options = {}) {
+	const config = normalizeConfig(rawConfig);
 	const sources = options.sources ?? ALL_SOURCES;
 	const catalog = toSourceCatalog(sources);
 	const targets = [];
@@ -1570,26 +1723,21 @@ function resolveTargets(config, options = {}) {
 			sourceId,
 			mode,
 			...endpoint?.baseUrl === void 0 ? {} : { baseUrl: endpoint.baseUrl },
-			...endpoint?.pinned === true ? { baseUrlPinned: true } : {}
+			...endpoint?.pinned === true ? { baseUrlPinned: true } : {},
+			...endpoint?.apiKeyRef === void 0 ? {} : { apiKeyRef: endpoint.apiKeyRef }
 		});
 	};
 	/**
-	* The live runtime's provider ids, when we have them. An empty list means "could
-	* not ask" (the `llm` service is missing on early ticks), not "nothing exists", so
-	* it must not suppress the configured entries.
+	* The live runtime's provider ids, when known. `undefined` means the host
+	* could not answer; an empty list is authoritative and stops stale targets.
 	*/
-	const live = options.providers !== void 0 && options.providers.length > 0 ? new Set(options.providers) : void 0;
+	const live = options.providers === void 0 ? void 0 : new Set(options.providers);
 	/**
 	* Whether a stored entry may still produce requests. The entry itself is kept — a
 	* provider that comes back keeps the mode the user chose for it — but a provider
 	* DSH no longer has must not keep an account being polled behind an invisible row.
 	*/
 	const pollable = (provider) => live === void 0 || live.has(provider);
-	for (const entry of config.models) {
-		if (entry.mode === "hidden" || entry.sourceId === null) continue;
-		if (!pollable(entry.provider)) continue;
-		push(entry.sourceId, entry.mode);
-	}
 	const providers = /* @__PURE__ */ new Set();
 	for (const provider of [...config.order, ...Object.keys(config.providers)]) if (pollable(provider)) providers.add(provider);
 	for (const provider of options.providers ?? []) providers.add(provider);
@@ -1602,7 +1750,8 @@ function resolveTargets(config, options = {}) {
 		});
 		if (resolution.sourceId !== null && resolution.mode !== null) push(resolution.sourceId, resolution.mode, {
 			...resolution.baseUrl === void 0 ? {} : { baseUrl: resolution.baseUrl },
-			...resolution.baseUrlPinned === true ? { pinned: true } : {}
+			...resolution.baseUrlPinned === true ? { pinned: true } : {},
+			...resolution.apiKeyRef === void 0 ? {} : { apiKeyRef: resolution.apiKeyRef }
 		});
 	}
 	return targets;
@@ -1716,8 +1865,10 @@ function createUsageState(ctx, deps = {}) {
 	const catalog = toSourceCatalog(ALL_SOURCES);
 	const lookup = createCredentialLookup(ctx, deps.credentialFallback ?? {});
 	let config = DEFAULT_CONFIG;
+	let reconfigure = () => {};
 	installUsageStateSettings(ctx, deps.config, (next) => {
 		config = next;
+		reconfigure();
 	});
 	/**
 	* The plugin's own configuration says nothing about which providers exist, so
@@ -1725,11 +1876,16 @@ function createUsageState(ctx, deps = {}) {
 	* provider nobody configured still resolves to its suggested source.
 	*/
 	const providerFacts = () => {
-		const llm = ctx.get("llm");
-		const ids = [];
+		let ids;
 		try {
-			for (const provider of llm?.listProviders?.() ?? []) if (typeof provider?.id === "string" && provider.id !== "") ids.push(provider.id);
-		} catch {}
+			const llm = ctx.get("llm");
+			if (typeof llm?.listProviders === "function") {
+				ids = [];
+				for (const provider of llm.listProviders()) if (typeof provider?.id === "string" && provider.id !== "") ids.push(provider.id);
+			}
+		} catch {
+			ids = void 0;
+		}
 		return {
 			ids,
 			hints: providerEndpointHints(readNamespace(ctx, "llm-pi-ai"))
@@ -1740,17 +1896,22 @@ function createUsageState(ctx, deps = {}) {
 		return resolveTargets(config, {
 			providers: ids,
 			endpointHints: hints
-		});
-	};
-	const optionsFor = (target) => {
-		const overrideRef = config.sources[target.sourceId]?.apiKeyRef;
-		return {
-			...overrideRef === void 0 ? {} : { overrideRef },
+		}).map((target) => ({
+			...target,
 			preferredRefs: providerCredentialRefs({
 				sourceId: target.sourceId,
+				mode: target.mode,
+				config,
 				deepseekSettings: readNamespace(ctx, "llm-deepseek"),
 				piAiSettings: readNamespace(ctx, "llm-pi-ai")
 			})
+		}));
+	};
+	const optionsFor = (target) => {
+		const overrideRef = target.apiKeyRef;
+		return {
+			...overrideRef === void 0 ? {} : { overrideRef },
+			preferredRefs: target.preferredRefs ?? []
 		};
 	};
 	const store = new UsageStateStore({
@@ -1767,21 +1928,24 @@ function createUsageState(ctx, deps = {}) {
 			if (source === void 0) return void 0;
 			const resolved = await resolveApiKey(source, target.mode, optionsFor(target), lookup);
 			if (resolved === void 0) return void 0;
-			const pinnedBaseUrl = config.sources[target.sourceId]?.baseUrl;
-			const baseUrl = pinnedBaseUrl ?? target.baseUrl;
-			if (baseUrl === void 0) return resolved;
+			if (target.baseUrl === void 0) return resolved;
 			return {
 				...resolved,
-				baseUrl,
-				...pinnedBaseUrl === void 0 ? {} : { baseUrlPinned: true }
+				baseUrl: target.baseUrl,
+				...target.baseUrlPinned === true ? { baseUrlPinned: true } : {}
 			};
 		} },
 		read: createTargetReader({ fetch: fetchImpl })
 	});
+	reconfigure = () => store.reconfigure();
 	const service = new UsageStateService({
 		store,
 		targets,
 		catalog: () => catalog,
+		endpointHints: () => Object.fromEntries(Object.entries(providerFacts().hints).flatMap(([provider, endpoint]) => {
+			const origin = originOf(endpoint);
+			return origin === void 0 ? [] : [[provider, origin]];
+		})),
 		describe: async (target) => {
 			const source = findSource(target.sourceId);
 			if (source === void 0) return {
@@ -1795,7 +1959,7 @@ function createUsageState(ctx, deps = {}) {
 	ctx.on("session/event", (...args) => {
 		if (isTurnEnd(args[1])) store.onTurnEnd();
 	});
-	store.start();
+	ctx.effect(() => store.start(), "dsh-usage-state: refresh scheduling");
 	return provideUsageState(ctx, service);
 }
 /**