dsh-agy 0.4.5 → 0.4.6

package/lib/{plugin-common-Dwa1K13O.mjs → plugin-common-BlGbNHxX.mjs}

@@ -1,10 +1,10 @@
-import { m as fetchAgyFirstOk, v as AgyAuthError, y as AgyPoolBlockedError } from "./constants-CmA9wXNe.mjs";
-import { a as probeFetch, o as proxiedFetch, t as accountFetch } from "./proxy-BbuQX5U9.mjs";
-import { C as isSessionAccumulationOverflow, S as describeFetchError, _ as persistMasterKey, b as classifyFetchError, f as migrateToAgyDir, g as loadMasterKey, h as deriveKey, m as createAesGcmCodec, p as MASTER_KEY_REF, r as AgySessionManager, s as resolveAntigravityVersion, t as JsonAccountStore, u as pickProbeProxyUrl, v as resolveDshHome, x as classifyHttpError, y as resolveMasterKeyCodec } from "./accounts-BOuz6_Sh.mjs";
+import { m as fetchAgyFirstOk, v as AgyAuthError, y as AgyPoolBlockedError } from "./constants-AdsD4sKh.mjs";
+import { a as probeFetch, o as proxiedFetch, t as accountFetch } from "./proxy-B7VnbAfO.mjs";
+import { C as isSessionAccumulationOverflow, S as describeFetchError, _ as persistMasterKey, b as classifyFetchError, f as migrateToAgyDir, g as loadMasterKey, h as deriveKey, m as createAesGcmCodec, p as MASTER_KEY_REF, r as AgySessionManager, s as resolveAntigravityVersion, t as JsonAccountStore, u as pickProbeProxyUrl, v as resolveDshHome, x as classifyHttpError, y as resolveMasterKeyCodec } from "./accounts-DtIsWCeF.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-Cq6PGO4b.mjs";
-import { n as parseAgySse, t as UnmappedFinishReasonError } from "./parse-D3InNyUx.mjs";
-import { i as resolveAgyModel, n as listAgyModels, t as catalogModelList } from "./models-CjB0rXtI.mjs";
+import { i as setThoughtSignature, r as resolveMultimodalFiles, t as toAgyRequestBody } from "./translate-vh3M5H_9.mjs";
+import { n as UnmappedFinishReasonError, r as parseAgySse, t as AgyStreamIdleTimeoutError } from "./parse-CeJc7cHo.mjs";
+import { i as resolveAgyModel, n as listAgyModels, t as catalogModelList } from "./models-D_54Ro5z.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";
@@ -231,7 +231,7 @@ var AgyAdapter = class extends LlmAdapter {
 			throw error;
 		}
 		if (!session) throw new LlmError("No agy account configured — run `dsh-agy login` to authenticate.", "NO_CREDENTIAL");
-		const multimodalFiles = await resolveMultimodalFiles(options);
+		const multimodalFiles = await resolveMultimodalFiles(options, { maxBytes: this.options.maxInlineBytes?.() });
 		holder.account = session.account;
 		this.options.noteRequestStarted?.(session.account);
 		const conversationAccount = ledgerAccountKey(session);
@@ -417,7 +417,25 @@ var AgyAdapter = class extends LlmAdapter {
 				}, attemptStartedAt);
 				return;
 			} catch (error) {
-				if (error instanceof DOMException && error.name === "AbortError") throw new LlmError("agy stream aborted", "ABORTED", { cause: error });
+				if (error instanceof DOMException && error.name === "AbortError") {
+					this.recordUsage(session, options.model, {
+						ok: false,
+						reason: "aborted",
+						usage
+					}, attemptStartedAt);
+					await response.body?.cancel().catch(() => {});
+					throw new LlmError("agy stream aborted", "ABORTED", { cause: error });
+				}
+				if (error instanceof AgyStreamIdleTimeoutError && !yieldedDirect) {
+					await this.options.reportFailure("network-error", session);
+					this.recordUsage(session, options.model, {
+						ok: false,
+						reason: "network-error",
+						usage
+					}, attemptStartedAt);
+					await response.body?.cancel().catch(() => {});
+					throw new LlmError(`${error.message} — nothing was delivered, retrying`, "TIMEOUT", { cause: error });
+				}
 				if (error instanceof UnmappedFinishReasonError && error.reason === "MALFORMED_FUNCTION_CALL" && !yieldedDirect && malformedAttempt < MAX_MALFORMED_RETRIES) {
 					this.recordUsage(session, options.model, {
 						ok: false,
@@ -653,6 +671,10 @@ var ModelVisibility = class ModelVisibility {
 		this.reload();
 	}
 };
+/** Whether `value` may be stored as a per-file inline cap: an integer MB in range. */
+function isValidMultimodalMb(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100;
+}
 //#endregion
 //#region src/thinking-types.ts
 /**
@@ -919,6 +941,238 @@ var ThinkingBudgetStore = class ThinkingBudgetStore {
 		return this.snapshot();
 	}
 };
+/** Environment override for the cap, in MB. */
+const MULTIMODAL_ENV_VAR = "DSH_AGY_MULTIMODAL_MAX_INLINE_MB";
+/**
+* Rebuild the document, keeping only fields that are set.
+*
+* ONE place builds a document, so `parse`/`snapshot`/`write` cannot disagree
+* about which fields exist: `thinking-budget.ts` spells its document out in each
+* of the three, and a field added to only two of them is silently dropped by the
+* third (that is why its `write` and `snapshot` both enumerate `claudeBudget`
+* and `tieredBudget` by hand). `undefined` is dropped rather than serialized as
+* `null`, so "unset" has exactly one on-disk form.
+*/
+function toDocument(doc) {
+	return {
+		version: 1,
+		...doc.maxInlineMb === void 0 ? {} : { maxInlineMb: doc.maxInlineMb }
+	};
+}
+/**
+* Keep the stored value only when it is usable (tolerates hand edits).
+*
+* Dropped rather than clamped: a clamped cap would silently inline files the
+* user asked to keep out, and the fallback — no stored value — is a valid state
+* that simply means the built-in default.
+*/
+function sanitizeMultimodalDocument(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return toDocument({ version: 1 });
+	const value = raw.maxInlineMb;
+	return toDocument({
+		version: 1,
+		...isValidMultimodalMb(value) ? { maxInlineMb: value } : {}
+	});
+}
+function parseMultimodalDocument(text) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch {
+		return toDocument({ version: 1 });
+	}
+	return sanitizeMultimodalDocument(raw);
+}
+/**
+* The env override, or undefined when unset or unusable.
+*
+* `DSH_AGY_*` rather than `AGY_*`: that prefix is this plugin's own runtime
+* knobs (`risk.ts`'s kill switch and fingerprint mode, `plugin-common.ts`'s
+* health-probe interval), while `AGY_CLIENT_ID`/`AGY_CLIENT_SECRET` are the
+* OAuth client-credential namespace — a knob that changes request behavior
+* belongs to the former.
+*
+* This is the codebase's first NUMERIC env knob, and it inherits `envFlag`'s
+* posture: anything not recognized yields the fallback (here "no override")
+* rather than throwing or warning, because the fallback chain (store, then
+* default) is always a valid state. Recognized means a plain decimal integer —
+* `30MB`, `1.5` and `1e2` are ignored rather than guessed at, so the value that
+* takes effect is the one written.
+*
+* Read per call, not cached at module load, so a test (or a process that sets it
+* late) sees the change without a restart.
+*/
+function envMaxInlineMb() {
+	const raw = process.env[MULTIMODAL_ENV_VAR];
+	if (raw === void 0) return void 0;
+	const trimmed = raw.trim();
+	if (!/^\d+$/.test(trimmed)) return void 0;
+	const value = Number(trimmed);
+	return isValidMultimodalMb(value) ? value : void 0;
+}
+/**
+* In-memory authoritative copy of the cap, backed by a JSON file.
+*
+* `maxInlineBytes` sits on the GENERATION HOT PATH (the adapter resolves the cap
+* for every request), so the cross-instance revalidation it needs is
+* rate-limited — the same window, shared with `thinking-budget.ts` rather than
+* re-declared: two settings read on one hot path should not drift into two
+* different staleness bounds. Writes go to the file immediately and bypass the
+* limit so a concurrent edit is never merged into a stale copy.
+*
+* No file lock: a settings write is atomic (tmp+rename) and the accepted loss is
+* one concurrent toggle, which is the same trade `thinking-budget.ts` makes.
+*/
+var MultimodalConfigStore = class MultimodalConfigStore {
+	file;
+	revalidateIntervalMs;
+	doc;
+	/** Raw text this instance last read or wrote; see `reloadNow`. */
+	raw;
+	/** When `reloadNow` last ran, for the hot-path throttle. */
+	checkedAt;
+	constructor(options = {}) {
+		this.file = options.file ?? migrateToAgyDir("agy-multimodal.json").file;
+		this.revalidateIntervalMs = options.revalidateIntervalMs ?? 1e3;
+		const initial = this.readWithRaw();
+		this.doc = initial.doc;
+		this.raw = initial.raw;
+		this.checkedAt = Date.now();
+	}
+	/** Path of the backing file. */
+	get path() {
+		return this.file;
+	}
+	static serialize(doc) {
+		return JSON.stringify(doc, null, 2) + "\n";
+	}
+	/**
+	* Read the document together with the raw text it came from.
+	*
+	* Content, not mtime: two writers can land in the same filesystem timestamp
+	* tick (Windows resolves it coarsely enough to have failed CI in this repo),
+	* and a missed change is exactly the bug this check exists to prevent. A
+	* missing or unreadable file means "nothing configured" — and must NOT create
+	* it, because a settings read runs in processes that never write.
+	*/
+	readWithRaw() {
+		try {
+			const raw = readFileSync(this.file, "utf8");
+			return {
+				doc: parseMultimodalDocument(raw),
+				raw
+			};
+		} catch {
+			return {
+				doc: toDocument({ version: 1 }),
+				raw: ""
+			};
+		}
+	}
+	/**
+	* Re-read the file if another writer changed it.
+	*
+	* Unconditional — callers on the hot path use `reloadIfChanged` instead.
+	*/
+	reloadNow() {
+		let current;
+		try {
+			current = readFileSync(this.file, "utf8");
+		} catch {
+			current = "";
+		}
+		this.checkedAt = Date.now();
+		if (current === this.raw) return;
+		const fresh = this.readWithRaw();
+		this.doc = fresh.doc;
+		this.raw = fresh.raw;
+	}
+	/**
+	* Hot-path revalidation: `reloadNow`, rate-limited.
+	*
+	* Without the limit every generation pays a blocking `readFileSync` plus a
+	* UTF-8 decode for a value that changes only when a user saves the settings
+	* card, so the worst case here is that a change takes up to
+	* `revalidateIntervalMs` to reach an already-running adapter — the right trade
+	* for a setting, and not right for the write path, which is why `write` calls
+	* `reloadNow` directly.
+	*/
+	reloadIfChanged() {
+		if (Date.now() - this.checkedAt < this.revalidateIntervalMs) return;
+		this.reloadNow();
+	}
+	/**
+	* Write the whole document atomically.
+	*
+	* Always re-reads first, so a concurrent edit by the OTHER instance in this
+	* process (main plugin + web entry) is merged rather than overwritten: the
+	* caller passes a mutation, not a full replacement built from a stale copy.
+	*/
+	write(mutate) {
+		this.reloadNow();
+		const next = toDocument(this.doc);
+		mutate(next);
+		const text = MultimodalConfigStore.serialize(next);
+		mkdirSync(dirname(this.file), { recursive: true });
+		const tmp = `${this.file}.tmp`;
+		writeFileSync(tmp, text, { mode: 384 });
+		renameSync(tmp, this.file);
+		this.doc = next;
+		this.raw = text;
+	}
+	/** The STORED cap in MB, or undefined when nothing is stored. */
+	maxInlineMb() {
+		this.reloadIfChanged();
+		return this.doc.maxInlineMb;
+	}
+	/**
+	* The cap actually in force: env overrides the stored value, which overrides
+	* the built-in default.
+	*
+	* The env var is read HERE rather than at construction so the override is
+	* live for a long-running process and flippable in a test.
+	*/
+	effectiveMaxInlineMb() {
+		const fromEnv = envMaxInlineMb();
+		if (fromEnv !== void 0) return {
+			value: fromEnv,
+			source: "env"
+		};
+		const stored = this.maxInlineMb();
+		if (stored !== void 0) return {
+			value: stored,
+			source: "stored"
+		};
+		return {
+			value: 20,
+			source: "default"
+		};
+	}
+	/** The effective cap in bytes, as the multimodal resolver wants it. */
+	maxInlineBytes() {
+		return this.effectiveMaxInlineMb().value * 1024 * 1024;
+	}
+	/**
+	* The settings state: the stored value (null when unset) plus which source is
+	* effective. See `MultimodalView` for why the two are separate fields.
+	*/
+	snapshot() {
+		return {
+			value: this.maxInlineMb() ?? null,
+			source: this.effectiveMaxInlineMb().source,
+			max: 100
+		};
+	}
+	/** Replace the cap, or clear it when `value` is undefined. */
+	setMaxInlineMb(value) {
+		if (value !== void 0 && !isValidMultimodalMb(value)) throw new Error(`multimodal inline cap must be an integer in [1, 100] MB`);
+		this.write((doc) => {
+			if (value === void 0) delete doc.maxInlineMb;
+			else doc.maxInlineMb = value;
+		});
+		return this.snapshot();
+	}
+};
 //#endregion
 //#region src/usage-types.ts
 /** Zeroed counters, for accumulation. */
@@ -1686,6 +1940,7 @@ async function buildAgyRuntime(ctx) {
 	});
 	const modelVisibility = new ModelVisibility();
 	const thinkingBudget = new ThinkingBudgetStore();
+	const multimodalConfig = new MultimodalConfigStore();
 	let invalidateModelCache = () => {};
 	const sessions = new AgySessionManager({
 		store,
@@ -1709,6 +1964,7 @@ async function buildAgyRuntime(ctx) {
 		thinkingBudgetFor: (level) => thinkingBudget.budgetFor(level),
 		claudeBudgetFor: () => thinkingBudget.claudeBudget(),
 		tieredBudgetFor: () => thinkingBudget.tieredBudget(),
+		maxInlineBytes: () => multimodalConfig.maxInlineBytes(),
 		recordUsage: (record) => {
 			stats.record({
 				...record,
@@ -1731,10 +1987,11 @@ async function buildAgyRuntime(ctx) {
 		stats,
 		recentStore,
 		modelVisibility,
-		thinkingBudget
+		thinkingBudget,
+		multimodalConfig
 	};
 }
 //#endregion
 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-Dwa1K13O.mjs.map
+//# sourceMappingURL=plugin-common-BlGbNHxX.mjs.map