dsh-agy 0.3.2 → 0.4.1

package/lib/index.mjs

@@ -1,5 +1,5 @@
-import { i as isAgyDisabled } from "./accounts-CKWybAfc.mjs";
-import { t as createAgyRuntime } from "./plugin-common-B5dyfnMH.mjs";
+import { i as isAgyDisabled } from "./accounts-BjdDqUq1.mjs";
+import { t as createAgyRuntime } from "./plugin-common-B7OSfnyl.mjs";
 //#region src/index.ts
 const name = "dsh-agy";
 const inject = ["llm"];

package/lib/{plugin-common-B5dyfnMH.mjs → plugin-common-B7OSfnyl.mjs}

@@ -1,14 +1,14 @@
 import { m as fetchAgyFirstOk, v as AgyAuthError, y as AgyPoolBlockedError } from "./constants-BpyRirvk.mjs";
 import { a as probeFetch, o as proxiedFetch, t as accountFetch } from "./proxy-DfaL73mL.mjs";
-import { _ as resolveMasterKeyCodec, b as describeFetchError, d as MASTER_KEY_REF, f as createAesGcmCodec, g as resolveDshHome, h as persistMasterKey, m as loadMasterKey, p as deriveKey, r as AgySessionManager, s as resolveAntigravityVersion, t as JsonAccountStore, u as pickProbeProxyUrl, v as classifyFetchError, x as isSessionAccumulationOverflow, y as classifyHttpError } from "./accounts-CKWybAfc.mjs";
+import { S as isSessionAccumulationOverflow, _ as resolveDshHome, b as classifyHttpError, d as migrateToAgyDir, f as MASTER_KEY_REF, g as persistMasterKey, h as loadMasterKey, m as deriveKey, p as createAesGcmCodec, r as AgySessionManager, s as resolveAntigravityVersion, t as JsonAccountStore, u as pickProbeProxyUrl, v as resolveMasterKeyCodec, x as describeFetchError, y as classifyFetchError } from "./accounts-BjdDqUq1.mjs";
 import { i as generateAntigravityRequestId, n as currentSessionGeneration, r as deriveAntigravitySessionId, t as bumpSessionGeneration } from "./identity-Ci8EGc1F.mjs";
-import { i as setThoughtSignature, r as resolveMultimodalFiles, t as toAgyRequestBody } from "./translate-BQu8HLvB.mjs";
+import { i as setThoughtSignature, r as resolveMultimodalFiles, t as toAgyRequestBody } from "./translate-YhGDUuVa.mjs";
 import { t as parseAgySse } from "./parse-Bs4rPkHA.mjs";
 import { i as resolveAgyModel, n as listAgyModels, t as catalogModelList } from "./models-Qn0-sh6X.mjs";
 import { randomBytes } from "node:crypto";
 import { LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE } from "@deepseek-ai/dsh-llm";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import lockfile from "proper-lockfile";
 //#region src/adapter/adapter.ts
 /**
@@ -69,6 +69,8 @@ function buildRequestHeaders(session) {
 }
 var AgyAdapter = class extends LlmAdapter {
 	options;
+	cachedModels = null;
+	inFlightModels = null;
 	constructor(options) {
 		super();
 		this.options = options;
@@ -93,20 +95,54 @@ var AgyAdapter = class extends LlmAdapter {
 	/**
 	* The complete catalog, ignoring the user's hidden set.
 	*
+	* Cached in memory for `MODEL_LIST_CACHE_TTL_MS` with in-flight deduplication.
+	* DSH 0.2.0-rc.1 calls `listModels` on every model and effort selection via
+	* `requireModel`; without caching, each click paid a multi-second round-trip to
+	* Google's `fetchAvailableModels` through the proxy, showing a loading spinner
+	* on every interaction.
+	*
 	* The settings page lists models through this rather than `listModels`: if it
 	* read the filtered list, a hidden model would vanish from the page along
 	* with the switch that hides it, leaving no way to turn it back on without
 	* hand-editing the file.
 	*/
-	async listAllModels() {
-		try {
-			const session = await this.options.getSession();
-			const routing = { proxyUrl: session?.account.proxy };
-			return await listAgyModels(session?.auth.access, session?.account.projectId, accountFetch(routing));
-		} catch (error) {
-			if (error instanceof AgyPoolBlockedError || error instanceof AgyAuthError) return catalogModelList();
-			throw error;
-		}
+	async listAllModels(force = false) {
+		const now = Date.now();
+		if (!force && this.cachedModels && now - this.cachedModels.at < 6e5) return this.cachedModels.models;
+		if (this.inFlightModels) return this.inFlightModels;
+		const task = (async () => {
+			try {
+				const session = await this.options.getSession();
+				const routing = { proxyUrl: session?.account.proxy };
+				const models = await listAgyModels(session?.auth.access, session?.account.projectId, accountFetch(routing));
+				this.cachedModels = {
+					models,
+					at: Date.now()
+				};
+				return models;
+			} catch (error) {
+				if (error instanceof AgyPoolBlockedError || error instanceof AgyAuthError) return catalogModelList();
+				if (this.cachedModels) return this.cachedModels.models;
+				throw error;
+			} finally {
+				this.inFlightModels = null;
+			}
+		})();
+		this.inFlightModels = task;
+		return task;
+	}
+	/**
+	* Drop the cached model list.
+	*
+	* Model discovery is account-scoped (what `fetchAvailableModels` reports and
+	* which proxy it rides depend on the account), but the cache is deliberately
+	* keyed to NO account: a keyed read would have to call `getSession()` on
+	* every hit, and that call can probe quota or refresh a token — the network
+	* cost this cache exists to remove. Every event that can switch the account
+	* discovery rides (activation, rotation) therefore drops the cache instead.
+	*/
+	invalidateModelCache() {
+		this.cachedModels = null;
 	}
 	async resolveModel(provider, model) {
 		return resolveAgyModel(provider, model);
@@ -225,7 +261,10 @@ var AgyAdapter = class extends LlmAdapter {
 				} catch (error) {
 					const classified = classifyFetchError(error, { proxyUrl: session.account.proxy });
 					await this.options.reportFailure(classified.kind, session);
-					this.recordUsage(session, options.model, { ok: false }, startedAt);
+					this.recordUsage(session, options.model, {
+						ok: false,
+						reason: "network-error"
+					}, startedAt);
 					throw new LlmError(classified.message ?? "agy fetch failed", "TRANSPORT", { cause: error });
 				}
 				if (response.ok) return { response };
@@ -253,7 +292,8 @@ var AgyAdapter = class extends LlmAdapter {
 			});
 			this.recordUsage(session, options.model, {
 				ok: false,
-				rateLimited: classified.kind === "rate-limit"
+				rateLimited: classified.kind === "rate-limit",
+				reason: classified.kind
 			}, startedAt);
 			if (classified.kind === "rate-limit") {
 				if (classified.rateLimitCategory === "quota_exhausted") throw new LlmError(`agy daily quota exhausted (${response.status}): ${classified.message ?? ""}`, QUOTA_EXCEEDED_CODE);
@@ -301,7 +341,10 @@ var AgyAdapter = class extends LlmAdapter {
 		} catch (error) {
 			if (error instanceof DOMException && error.name === "AbortError") throw new LlmError("agy stream aborted", "ABORTED", { cause: error });
 			await this.options.reportFailure("network-error", session);
-			this.recordUsage(session, options.model, { ok: false }, startedAt);
+			this.recordUsage(session, options.model, {
+				ok: false,
+				reason: "network-error"
+			}, startedAt);
 			throw new LlmError(error instanceof Error ? describeFetchError(error) : "agy stream parse failed", UPSTREAM_ERROR_CODE, { cause: error });
 		}
 	}
@@ -320,6 +363,7 @@ var AgyAdapter = class extends LlmAdapter {
 				...model === void 0 ? {} : { model },
 				ok: result.ok,
 				...result.rateLimited === true ? { rateLimited: true } : {},
+				...result.reason === void 0 ? {} : { reason: result.reason },
 				...result.usage === void 0 ? {} : { usage: result.usage },
 				...result.ttftMs === void 0 ? {} : { ttftMs: result.ttftMs },
 				latencyMs: Math.max(0, Date.now() - startedAt)
@@ -381,7 +425,7 @@ var ModelVisibility = class ModelVisibility {
 	/** Reusable frozen empty set, so the common "nothing disabled" read allocates nothing. */
 	sets = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
-		this.file = options.file ?? join(resolveDshHome(), "agy-models.json");
+		this.file = options.file ?? migrateToAgyDir("agy-models.json").file;
 		const initial = this.readWithRaw();
 		this.disabled = initial.disabled;
 		this.raw = initial.raw;
@@ -615,7 +659,7 @@ var ThinkingBudgetStore = class ThinkingBudgetStore {
 	/** When `reloadNow` last ran, for the hot-path throttle. */
 	checkedAt;
 	constructor(options = {}) {
-		this.file = options.file ?? join(resolveDshHome(), "agy-thinking.json");
+		this.file = options.file ?? migrateToAgyDir("agy-thinking.json").file;
 		this.revalidateIntervalMs = options.revalidateIntervalMs ?? 1e3;
 		const initial = this.readWithRaw();
 		this.doc = initial.doc;
@@ -1050,6 +1094,7 @@ var UsageStats = class {
 	flushIntervalMs;
 	maxPending;
 	onFlushError;
+	persistRecent;
 	/** This process's un-flushed records. */
 	pending = [];
 	timer;
@@ -1060,13 +1105,14 @@ var UsageStats = class {
 	*/
 	flushFailedSince;
 	constructor(options = {}) {
-		this.file = options.file ?? join(resolveDshHome(), "agy-stats.json");
+		this.file = options.file ?? migrateToAgyDir("agy-stats.json").file;
 		this.lock = options.lock ?? properStatsLock;
 		this.now = options.now ?? (() => Date.now());
 		this.flushEvery = options.flushEvery ?? 50;
 		this.flushIntervalMs = options.flushIntervalMs ?? 5e3;
 		this.maxPending = options.maxPending ?? 500;
 		this.onFlushError = options.onFlushError;
+		this.persistRecent = options.persistRecent;
 	}
 	/** Path of the backing file. */
 	get path() {
@@ -1101,6 +1147,7 @@ var UsageStats = class {
 	}
 	/** Record one request. Hot path: no I/O. */
 	record(record) {
+		this.noteRecent(record);
 		this.pending.push(record);
 		if (this.maxPending > 0 && this.pending.length > this.maxPending) this.pending.splice(0, this.pending.length - this.maxPending);
 		if (this.flushFailedSince === void 0 && this.flushEvery > 0 && this.pending.length >= this.flushEvery) {
@@ -1109,6 +1156,51 @@ var UsageStats = class {
 		}
 		this.armTimer();
 	}
+	/**
+	* The in-memory recent-activity ring, persisted by an injected
+	* `RecentActivityStore` when one is supplied.
+	*
+	* The ring itself stays in-memory and I/O-free — `noteRecent` only flattens —
+	* while the OPTIONAL `persistRecent` seam hands each flattened record to
+	* `recent-store.ts`, which owns the file, the triggers, the lock, and the
+	* failure story. When no store is injected (tests, the CLI) the ring behaves
+	* exactly as before: per-process, never persisted.
+	*
+	* An earlier revision recorded why persistence was rejected outright (file
+	* growth, a versioned migration, a wider stored surface); `recent-store.ts`
+	* answers each — a bounded list in its own file, no version field, emails
+	* and model ids only — which is what turned this from a bad idea into a
+	* spec.
+	*/
+	recent = [];
+	noteRecent(record) {
+		const entry = {
+			at: this.now(),
+			account: record.account ?? null,
+			model: record.model ?? null,
+			kind: record.poolEvent === true ? "rotation" : record.source,
+			ok: record.ok === true,
+			rateLimited: record.rateLimited === true,
+			latencyMs: record.latencyMs ?? null,
+			ttftMs: record.ttftMs ?? null,
+			output: record.usage?.output ?? null,
+			reason: record.ok === true ? null : record.reason ?? null
+		};
+		this.recent.push(entry);
+		if (this.recent.length > 200) this.recent.splice(0, this.recent.length - 200);
+		try {
+			this.persistRecent?.(entry);
+		} catch {}
+	}
+	/**
+	* Newest-first copy of the ring, for the `pool.recent` RPC.
+	*
+	* A copy, not the live array: the RPC layer may hold it across awaits while
+	* `record()` keeps pushing.
+	*/
+	recentRequests() {
+		return [...this.recent].reverse();
+	}
 	armTimer() {
 		if (this.timer !== void 0 || this.flushIntervalMs <= 0) return;
 		this.timer = setTimeout(() => {
@@ -1193,6 +1285,204 @@ var UsageStats = class {
 		return this.flushFailedSince !== void 0;
 	}
 };
+/** Capture-key dedupe: the fields two processes writing the same capture share. */
+function captureKey(entry) {
+	return `${entry.at}|${entry.account ?? ""}|${entry.model ?? ""}|${entry.kind}|${entry.output ?? ""}`;
+}
+/**
+* Coerce one parsed JSON value into a `RecentActivity`, or null when it is not
+* one. No version field: a record this build cannot parse is dropped, which
+* for a bounded diagnostics list is the whole migration story.
+*/
+function parseRecentActivity(raw) {
+	if (typeof raw !== "object" || raw === null) return null;
+	const r = raw;
+	const kinds = [
+		"chat",
+		"cli",
+		"verify",
+		"test",
+		"rotation"
+	];
+	if (typeof r.at !== "number" || !Number.isFinite(r.at)) return null;
+	if (!kinds.includes(r.kind)) return null;
+	if (typeof r.ok !== "boolean") return null;
+	const nullableString = (v) => typeof v === "string" && v.length > 0 ? v : null;
+	const nullableNumber = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : null;
+	return {
+		at: r.at,
+		account: nullableString(r.account),
+		model: nullableString(r.model),
+		kind: r.kind,
+		ok: r.ok,
+		rateLimited: r.rateLimited === true,
+		latencyMs: nullableNumber(r.latencyMs),
+		ttftMs: nullableNumber(r.ttftMs),
+		output: nullableNumber(r.output),
+		reason: nullableString(r.reason)
+	};
+}
+/** Merge one batch into an on-disk list (pure; the caller owns the lock and the write). */
+function mergeRecentEntries(onDisk, batch, cap = 200) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of [...onDisk, ...batch]) byKey.set(captureKey(entry), entry);
+	return [...byKey.values()].sort((a, b) => a.at - b.at).slice(-cap);
+}
+const properRecentLock = { withLock(file, fn) {
+	const release = lockfile.lockSync(file, {
+		stale: 8e3,
+		update: 4e3,
+		realpath: false
+	});
+	try {
+		return fn();
+	} finally {
+		release();
+	}
+} };
+/**
+* Persists the recent-activity ring across processes and restarts.
+*
+* The plugin constructs it BEFORE any record can arrive, seeds the in-memory
+* ring from the file, and hands it to `UsageStats` as the persistence half;
+* `record()` in `UsageStats` stays I/O-free — it appends to this store's
+* pending list, and flushing happens on the triggers above.
+*/
+var RecentActivityStore = class {
+	file;
+	lock;
+	now;
+	flushEvery;
+	flushIntervalMs;
+	onFlushError;
+	/** The seeded ring plus this process's un-flushed captures. */
+	entries = [];
+	pending = [];
+	timer;
+	flushFailedSince;
+	lastFlushError;
+	constructor(options = {}) {
+		this.file = options.file ?? migrateToAgyDir("agy-recent.json").file;
+		this.lock = options.lock ?? properRecentLock;
+		this.now = options.now ?? (() => Date.now());
+		this.flushEvery = options.flushEvery ?? 25;
+		this.flushIntervalMs = options.flushIntervalMs ?? 3e4;
+		this.onFlushError = options.onFlushError;
+		try {
+			const parsed = JSON.parse(readFileSync(this.file, "utf8"));
+			if (Array.isArray(parsed)) {
+				for (const raw of parsed) {
+					const entry = parseRecentActivity(raw);
+					if (entry) this.entries.push(entry);
+				}
+				if (this.entries.length > 200) this.entries.splice(0, this.entries.length - 200);
+			}
+		} catch {}
+	}
+	/** Path of the backing file. */
+	get path() {
+		return this.file;
+	}
+	/** Whether the ring is currently failing to persist (a run of failures). */
+	get flushFailing() {
+		return this.flushFailedSince !== void 0;
+	}
+	/** Number of records awaiting flush. */
+	get pendingCount() {
+		return this.pending.length;
+	}
+	/**
+	* Capture one flattened record and the I/O-free hot-path append.
+	*
+	* `UsageStats.record()` calls this after folding into its own ring; keeping
+	* the write-behind state HERE (not in UsageStats) is what lets the file have
+	* its own triggers, its own lock, and its own failure story without widening
+	* the ledger's.
+	*/
+	capture(entry) {
+		this.entries.push(entry);
+		if (this.entries.length > 200) this.entries.splice(0, this.entries.length - 200);
+		this.pending.push(entry);
+		if (this.flushEvery > 0 && this.pending.length >= this.flushEvery) {
+			this.flush();
+			return;
+		}
+		this.armTimer();
+	}
+	/**
+	* Newest-first copy of the ring, for the `pool.recent` RPC: the seeded
+	* history plus everything this process captured since boot.
+	*/
+	recentRequests() {
+		return [...this.entries].reverse();
+	}
+	armTimer() {
+		if (this.timer !== void 0 || this.flushIntervalMs <= 0) return;
+		this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.flush();
+		}, this.flushIntervalMs);
+		this.timer.unref?.();
+	}
+	/**
+	* Merge pending captures into the persisted file.
+	*
+	* Same merge discipline as the ledger: re-read under the lock, merge by
+	* capture key (two processes replaying the same window must not duplicate
+	* rows), sort by time, cap. A failed flush puts the batch back — a
+	* diagnostics ring never breaks a generation — and reports once per run.
+	*/
+	flush() {
+		if (this.timer !== void 0) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		const batch = this.pending;
+		if (batch.length === 0) return;
+		this.pending = [];
+		const now = this.now();
+		try {
+			if (!existsSync(this.file)) {
+				mkdirSync(dirname(this.file), { recursive: true });
+				writeFileSync(this.file, "[]\n", { mode: 384 });
+			}
+			this.lock.withLock(this.file, () => {
+				const onDisk = [];
+				try {
+					const parsed = JSON.parse(readFileSync(this.file, "utf8"));
+					if (Array.isArray(parsed)) for (const raw of parsed) {
+						const entry = parseRecentActivity(raw);
+						if (entry) onDisk.push(entry);
+					}
+				} catch {}
+				const merged = mergeRecentEntries(onDisk, batch);
+				const tmp = `${this.file}.tmp`;
+				writeFileSync(tmp, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+				renameSync(tmp, this.file);
+			});
+			this.lastFlushError = void 0;
+			this.flushFailedSince = void 0;
+		} catch (error) {
+			this.pending = [...batch, ...this.pending];
+			this.lastFlushError = error;
+			if (this.flushFailedSince === void 0) {
+				this.flushFailedSince = now;
+				try {
+					this.onFlushError?.(error);
+				} catch {}
+			}
+			this.armTimer();
+		}
+	}
+	/** Flush if anything is pending; called on process exit. */
+	flushSync() {
+		this.flush();
+	}
+	/** The most recent flush failure, if any (diagnostics). */
+	get flushError() {
+		return this.lastFlushError;
+	}
+};
 //#endregion
 //#region src/plugin-common.ts
 /**
@@ -1255,24 +1545,58 @@ async function warmVersionCache(store) {
 	} catch {}
 	await resolveAntigravityVersion(fetchImpl).catch(() => {});
 }
-/** Build the store, session manager, and adapter for one plugin entry. */
+/**
+* The process-wide runtime promise, shared by both entry points.
+*
+* Splitting it was a real defect, not a stylistic one: the ledger FILE merges
+* across instances, so counters looked fine, but every in-memory surface is
+* per instance — the web entry's ring and in-flight map could never see the
+* main plugin's chat traffic (same process, two rings), and `account.activate`
+* cleared affinity pins on the WRONG session manager while the serving one
+* kept its stale pin. Both entries call this in one process; one memo here is
+* what makes that "shared runtime" claim true. Separate profiles are separate
+* processes, so the memo never bridges compositions.
+*/
+let sharedRuntime;
+/** Build (once per process) and return the runtime both entries share. */
 async function createAgyRuntime(ctx) {
+	if (sharedRuntime === void 0) sharedRuntime = buildAgyRuntime(ctx).catch((error) => {
+		sharedRuntime = void 0;
+		throw error;
+	});
+	return sharedRuntime;
+}
+async function buildAgyRuntime(ctx) {
 	const { codec } = await resolveCodec(ctx);
 	const dshHome = resolveDshHome();
+	const accountsMigrated = migrateToAgyDir("agy-accounts.json", dshHome);
+	if (accountsMigrated.skew) ctx.logger.warn("[dsh-agy] legacy data file detected next to the agy folder — an older dsh-agy process may still be writing the pre-0.5 layout; its writes will not be seen until every dsh surface is restarted");
 	const store = new JsonAccountStore({
-		file: `${dshHome}/agy-accounts.json`,
+		file: accountsMigrated.file,
 		codec
 	});
 	warmVersionCache(store);
-	const stats = new UsageStats({ onFlushError: (error) => {
-		ctx.logger.warn(`[dsh-agy] usage ledger could not be written (${stats.path}): ${error instanceof Error ? error.message : String(error)} — counts are buffered and will retry`);
+	const recentStore = new RecentActivityStore({ onFlushError: (error) => {
+		ctx.logger.warn(`[dsh-agy] recent-activity file could not be written (${recentStore.path}): ${error instanceof Error ? error.message : String(error)} — entries are buffered and will retry`);
 	} });
+	const stats = new UsageStats({
+		persistRecent: (entry) => {
+			recentStore.capture(entry);
+		},
+		onFlushError: (error) => {
+			ctx.logger.warn(`[dsh-agy] usage ledger could not be written (${stats.path}): ${error instanceof Error ? error.message : String(error)} — counts are buffered and will retry`);
+		}
+	});
 	const modelVisibility = new ModelVisibility();
 	const thinkingBudget = new ThinkingBudgetStore();
+	let invalidateModelCache = () => {};
 	const sessions = new AgySessionManager({
 		store,
 		recordUsage: (record) => {
 			stats.record(record);
+		},
+		onRotate: () => {
+			invalidateModelCache();
 		}
 	});
 	const healthIntervalMs = Number(process.env.DSH_AGY_HEALTH_INTERVAL_MS ?? 0);
@@ -1295,19 +1619,25 @@ async function createAgyRuntime(ctx) {
 			});
 		}
 	});
+	invalidateModelCache = () => {
+		adapter.invalidateModelCache();
+	};
+	adapter.listAllModels().catch(() => {});
 	process.once("exit", () => {
 		stats.flushSync();
+		recentStore.flushSync();
 	});
 	return {
 		store,
 		sessions,
 		adapter,
 		stats,
+		recentStore,
 		modelVisibility,
 		thinkingBudget
 	};
 }
 //#endregion
-export { THINKING_BUDGET_MAX as a, CLAUDE_BUDGET_MIN as i, foldWindowBreakdown as n, CLAUDE_BUDGET_MAX as r, createAgyRuntime as t };
+export { CLAUDE_BUDGET_MIN as a, CLAUDE_BUDGET_MAX as i, dayKey as n, THINKING_BUDGET_MAX as o, foldWindowBreakdown as r, createAgyRuntime as t };
 
-//# sourceMappingURL=plugin-common-B5dyfnMH.mjs.map
+//# sourceMappingURL=plugin-common-B7OSfnyl.mjs.map