dsh-agy 0.4.4 → 0.4.6

package/lib/{plugin-common-CKTYXxSc.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-DW-BL9c3.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-BR1kuCaz.mjs";
-import { n as parseAgySse, t as UnmappedFinishReasonError } from "./parse-38V1zT1B.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";
@@ -29,6 +29,22 @@ function collectImageRefs(options) {
 const UPSTREAM_ERROR_CODE = "UPSTREAM";
 /** First-class DSH retryable code: the default retry policy honors SERVER (5xx), not UPSTREAM. */
 const SERVER_ERROR_CODE = "SERVER";
+/** Abort-aware delay helper for transient stream retries. */
+async function sleepWithSignal(ms, signal) {
+	if (signal?.aborted) throw new DOMException("aborted", "AbortError");
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new DOMException("aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (!signal) return;
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 /** Stable ledger key for an account: email when present, else the generated id. */
 function ledgerAccountKey(session) {
 	return session.account.email ?? session.account.id;
@@ -215,12 +231,10 @@ 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);
-		/** Wall-clock origin for this attempt's latency figures. */
-		const startedAt = Date.now();
 		const routing = {
 			proxyUrl: session.account.proxy,
 			streaming: true
@@ -235,8 +249,11 @@ var AgyAdapter = class extends LlmAdapter {
 		* names a fresh upstream session and recovers the conversation. This is not
 		* an account fault, so it does not go through `reportFailure`: the account
 		* stays healthy and only the derived id changes.
+		*
+		* `attemptStartedAt` is the clock of the outer attempt that owns this send,
+		* so a transport failure is billed to that attempt rather than to the call.
 		*/
-		const sendAttempt = async () => {
+		const sendAttempt = async (attemptStartedAt) => {
 			for (let attempt = 0;; attempt++) {
 				const generation = conversationKey !== void 0 && conversationAccount !== void 0 ? currentSessionGeneration(conversationAccount, conversationKey) : 0;
 				const requestId = generateAntigravityRequestId();
@@ -264,7 +281,7 @@ var AgyAdapter = class extends LlmAdapter {
 					this.recordUsage(session, options.model, {
 						ok: false,
 						reason: "network-error"
-					}, startedAt);
+					}, attemptStartedAt);
 					throw new LlmError(classified.message ?? "agy fetch failed", "TRANSPORT", { cause: error });
 				}
 				if (response.ok) return { response };
@@ -279,74 +296,171 @@ var AgyAdapter = class extends LlmAdapter {
 				};
 			}
 		};
-		const { response, bodyText } = await sendAttempt();
-		if (!response.ok) {
-			const classified = classifyHttpError(response.status, response.headers, bodyText);
-			await this.options.reportFailure(classified.kind, session, {
-				retryAfterMs: classified.retryAfterMs,
-				status: response.status,
-				rateLimitCategory: classified.rateLimitCategory,
-				resetTime: classified.resetTime,
-				model: options.model,
-				verificationUrl: classified.verificationUrl
-			});
-			this.recordUsage(session, options.model, {
-				ok: false,
-				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);
-				throw new LlmError(`agy rate-limited (${response.status}): ${classified.message ?? ""}`, "RATE_LIMIT", {
+		/**
+		* Maximum internal retries when the upstream ends a stream with
+		* `MALFORMED_FUNCTION_CALL` before any user-facing text chunks have been
+		* yielded to DSH. Gemini models occasionally glitch on tool-call JSON syntax;
+		* re-sampling cleanly recovers the turn without crashing the conversation.
+		*
+		* This deliberately generalises the `sendAttempt` accumulation-wall resend
+		* into the stream path: the invariant that one DSH call is one provider
+		* attempt now has this second, documented exception (see AGENTS.md, "the
+		* adapter does not silent-retry"). Both exceptions share the same shape —
+		* the account is healthy and the request was accepted — and neither goes
+		* through `reportFailure`, so the pool sees nothing.
+		*/
+		const MAX_MALFORMED_RETRIES = 3;
+		for (let malformedAttempt = 0;; malformedAttempt++) {
+			const attemptStartedAt = Date.now();
+			const { response, bodyText } = await sendAttempt(attemptStartedAt);
+			if (!response.ok) {
+				const classified = classifyHttpError(response.status, response.headers, bodyText);
+				await this.options.reportFailure(classified.kind, session, {
+					retryAfterMs: classified.retryAfterMs,
+					status: response.status,
+					rateLimitCategory: classified.rateLimitCategory,
+					resetTime: classified.resetTime,
+					model: options.model,
+					verificationUrl: classified.verificationUrl
+				});
+				this.recordUsage(session, options.model, {
+					ok: false,
+					rateLimited: classified.kind === "rate-limit",
+					reason: classified.kind
+				}, attemptStartedAt);
+				if (classified.kind === "rate-limit") {
+					if (classified.rateLimitCategory === "quota_exhausted") throw new LlmError(`agy daily quota exhausted (${response.status}): ${classified.message ?? ""}`, QUOTA_EXCEEDED_CODE);
+					throw new LlmError(`agy rate-limited (${response.status}): ${classified.message ?? ""}`, "RATE_LIMIT", {
+						providerRetryAfterMs: classified.retryAfterMs ?? void 0,
+						requestId: ProviderRequestId(generateAntigravityRequestId())
+					});
+				}
+				if (classified.kind === "verification-required") {
+					const appeal = classified.verificationUrl ? ` Verify at: ${classified.verificationUrl}` : "";
+					throw new LlmError(`agy account needs verification (${response.status}): ${classified.message ?? ""}${appeal}`, "RATE_LIMIT", { requestId: ProviderRequestId(generateAntigravityRequestId()) });
+				}
+				if (classified.kind === "auth-failure") throw new LlmError(`agy authentication failed (${response.status}) — run \`dsh-agy login\``, "INVALID_CREDENTIAL");
+				if (classified.status !== void 0 && classified.status >= 500) throw new LlmError(`agy upstream error (${response.status}): ${classified.message ?? ""}`, SERVER_ERROR_CODE, {
 					providerRetryAfterMs: classified.retryAfterMs ?? void 0,
 					requestId: ProviderRequestId(generateAntigravityRequestId())
 				});
+				throw new LlmError(`agy upstream error (${response.status}): ${classified.message ?? ""}`, UPSTREAM_ERROR_CODE);
 			}
-			if (classified.kind === "verification-required") {
-				const appeal = classified.verificationUrl ? ` Verify at: ${classified.verificationUrl}` : "";
-				throw new LlmError(`agy account needs verification (${response.status}): ${classified.message ?? ""}${appeal}`, "RATE_LIMIT", { requestId: ProviderRequestId(generateAntigravityRequestId()) });
-			}
-			if (classified.kind === "auth-failure") throw new LlmError(`agy authentication failed (${response.status}) — run \`dsh-agy login\``, "INVALID_CREDENTIAL");
-			if (classified.status !== void 0 && classified.status >= 500) throw new LlmError(`agy upstream error (${response.status}): ${classified.message ?? ""}`, SERVER_ERROR_CODE, {
-				providerRetryAfterMs: classified.retryAfterMs ?? void 0,
-				requestId: ProviderRequestId(generateAntigravityRequestId())
-			});
-			throw new LlmError(`agy upstream error (${response.status}): ${classified.message ?? ""}`, UPSTREAM_ERROR_CODE);
-		}
-		if (!response.body) throw new LlmError("agy stream returned no body", UPSTREAM_ERROR_CODE);
-		try {
+			if (!response.body) throw new LlmError("agy stream returned no body", UPSTREAM_ERROR_CODE);
+			const bufferedChunks = [];
+			/**
+			* Thought signatures observed during this attempt, held back with the
+			* chunks that carried them. `onToolSignature` fires as soon as the parser
+			* sees a signature, i.e. BEFORE the attempt is known to be keepable, so
+			* caching eagerly would let a discarded attempt write the process-global
+			* signature cache (keyed by `toolCallId` — and issue #99 records those ids
+			* colliding across distant turns, which would poison the very retry it
+			* triggered).
+			*/
+			const pendingSignatures = [];
+			let yieldedDirect = false;
 			let usage;
 			let ttftMs;
-			for await (const chunk of parseAgySse(response.body, {
-				signal: options.signal,
-				onToolSignature: (toolCallId, signature) => {
-					setThoughtSignature(toolCallId, signature);
+			/**
+			* Persist the signatures observed so far.
+			*
+			* Called at every point where the chunks that carried them have been
+			* handed off — never on the discard path, so a thrown-away attempt leaves
+			* no trace. The hand-off is the only sound anchor: a `functionCall` can
+			* arrive AFTER the first `text-delta` (text-then-tool is a common shape),
+			* so anchoring at stream end would drop the signature of an already
+			* delivered call the moment the stream dies mid-body, silently degrading
+			* the next round to the sentinel.
+			*/
+			const commitSignatures = () => {
+				for (const [toolCallId, signature] of pendingSignatures) setThoughtSignature(toolCallId, signature);
+				pendingSignatures.length = 0;
+			};
+			/** Hand the held chunks to the consumer. */
+			const drainBuffer = () => {
+				const drained = bufferedChunks.slice();
+				bufferedChunks.length = 0;
+				return drained;
+			};
+			try {
+				for await (const chunk of parseAgySse(response.body, {
+					signal: options.signal,
+					onToolSignature: (toolCallId, signature) => {
+						pendingSignatures.push([toolCallId, signature]);
+					}
+				})) {
+					if (chunk.type === "usage") usage = {
+						input: chunk.usage.inputTokens,
+						output: chunk.usage.outputTokens,
+						cacheRead: chunk.usage.cacheReadTokens ?? 0,
+						cacheWrite: chunk.usage.cacheWriteTokens ?? 0
+					};
+					if (yieldedDirect) {
+						if (pendingSignatures.length !== 0) commitSignatures();
+						yield chunk;
+					} else if (chunk.type === "text-delta") {
+						yieldedDirect = true;
+						commitSignatures();
+						ttftMs = Date.now() - attemptStartedAt;
+						for (const buffered of drainBuffer()) yield buffered;
+						yield chunk;
+					} else bufferedChunks.push(chunk);
 				}
-			})) {
-				if (chunk.type === "usage") usage = {
-					input: chunk.usage.inputTokens,
-					output: chunk.usage.outputTokens,
-					cacheRead: chunk.usage.cacheReadTokens ?? 0,
-					cacheWrite: chunk.usage.cacheWriteTokens ?? 0
-				};
-				else if (ttftMs === void 0 && (chunk.type === "text-delta" || chunk.type === "reasoning-delta")) ttftMs = Date.now() - startedAt;
-				yield chunk;
+				if (ttftMs === void 0) ttftMs = Date.now() - attemptStartedAt;
+				commitSignatures();
+				for (const buffered of drainBuffer()) yield buffered;
+				await this.options.markSuccess?.(session);
+				this.recordUsage(session, options.model, {
+					ok: true,
+					usage,
+					ttftMs
+				}, attemptStartedAt);
+				return;
+			} catch (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,
+						reason: "request-error",
+						usage
+					}, attemptStartedAt);
+					await response.body?.cancel().catch(() => {});
+					try {
+						await sleepWithSignal(200 * (malformedAttempt + 1), options.signal);
+					} catch (sleepError) {
+						if (sleepError instanceof DOMException && sleepError.name === "AbortError") throw new LlmError("agy stream aborted", "ABORTED", { cause: sleepError });
+						throw sleepError;
+					}
+					continue;
+				}
+				const unmappedFinish = error instanceof UnmappedFinishReasonError;
+				await this.options.reportFailure(unmappedFinish ? "request-error" : "network-error", session);
+				this.recordUsage(session, options.model, {
+					ok: false,
+					reason: unmappedFinish ? "request-error" : "network-error",
+					usage
+				}, attemptStartedAt);
+				await response.body?.cancel().catch(() => {});
+				throw new LlmError(error instanceof Error ? describeFetchError(error) : "agy stream parse failed", UPSTREAM_ERROR_CODE, { cause: error });
 			}
-			await this.options.markSuccess?.(session);
-			this.recordUsage(session, options.model, {
-				ok: true,
-				usage,
-				ttftMs
-			}, startedAt);
-		} catch (error) {
-			if (error instanceof DOMException && error.name === "AbortError") throw new LlmError("agy stream aborted", "ABORTED", { cause: error });
-			const unmappedFinish = error instanceof UnmappedFinishReasonError;
-			await this.options.reportFailure(unmappedFinish ? "request-error" : "network-error", session);
-			this.recordUsage(session, options.model, {
-				ok: false,
-				reason: unmappedFinish ? "request-error" : "network-error"
-			}, startedAt);
-			throw new LlmError(error instanceof Error ? describeFetchError(error) : "agy stream parse failed", UPSTREAM_ERROR_CODE, { cause: error });
 		}
 	}
 	/**
@@ -557,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
 /**
@@ -823,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. */
@@ -1590,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,
@@ -1613,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,
@@ -1635,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-CKTYXxSc.mjs.map
+//# sourceMappingURL=plugin-common-BlGbNHxX.mjs.map