@eddyskywalker/dsh-chatgpt-subscription 0.16.0 → 0.17.0

package/lib/index.js

@@ -9812,14 +9812,80 @@ const OMITTED_IMAGE_TEXT$4 = "[image omitted to keep the request within its imag
 * instruction, the conversation text, and the tool declarations.
 */
 const MAX_REQUEST_IMAGE_BYTES$4 = 12 * 1024 * 1024;
+/**
+* Longest edge, in pixels, one image of this request may keep.
+*
+* CHOICE: 1024 px matches the long edge the other scaled routes send, and it is
+* what makes the scaling in {@link resolveRequestImages} effective rather than
+* nominal: the target is computed from the stored image's own dimensions, so the
+* same image yields the same request bytes in every later turn and the prefix
+* Google's implicit cache matches stays byte-stable.
+*
+* The budget stays Antigravity's own 12 MB. The 1.5 MB in
+* host/common/request-images.ts is Kimi's, and that file warns in the same
+* breath that importing one route's number into another refuses the other
+* route's own legal images; Google accepts a request of up to 20 MB.
+*/
+const REQUEST_IMAGE_MAX_EDGE$1 = 1024;
+/**
+* Encoded-byte target for one downscaled request version.
+*
+* 256 KiB of raw bytes is about 350 KiB of base64, so twenty of them still fit
+* the 12 MB budget with room left for the system instruction, the conversation
+* text, and the tool declarations that share the body. The harness keeps its
+* smallest output when no quality level meets the target.
+*/
+const REQUEST_IMAGE_VERSION_MAX_BYTES$2 = 256 * 1024;
+/**
+* Request-version target for one stored image whose long edge is over the
+* ceiling, or undefined when it already fits and is sent as stored.
+*
+* A reference without usable dimensions is sent as stored: there is no basis for
+* choosing a target, and the budget fallback in
+* {@link offloadOldestRequestImages} still applies to it.
+*/
+function requestImageTarget$1(ref, edge = REQUEST_IMAGE_MAX_EDGE$1) {
+	const { width, height } = ref;
+	if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) return void 0;
+	if (Math.max(width, height) <= edge) return void 0;
+	return width >= height ? {
+		width: edge,
+		height: Math.max(1, Math.round(edge * height / width)),
+		maxBytes: REQUEST_IMAGE_VERSION_MAX_BYTES$2
+	} : {
+		width: Math.max(1, Math.round(edge * width / height)),
+		height: edge,
+		maxBytes: REQUEST_IMAGE_VERSION_MAX_BYTES$2
+	};
+}
 /** Base64 length of raw image bytes, including padding. */
 function base64Length$4(bytes) {
 	return Math.ceil(bytes / 3) * 4;
 }
-/** Request payload one inline image block occupies, when it can be measured. */
+/**
+* Base64 payload one image block will actually contribute to the wire, or
+* undefined when it contributes none.
+*
+* This is the length of what is SENT, which is not the length of what is
+* STORED. An image whose long edge is over {@link REQUEST_IMAGE_MAX_EDGE} is
+* sent as its downscaled request version (see {@link resolveRequestImages}), so
+* measuring `attachment.bytes` counts a 5 MB screenshot as 5 MB when it reaches
+* the wire as a few hundred kilobytes. That over-count is not harmless: it makes
+* {@link offloadOldestRequestImages} replace an image with placeholder text that
+* would have fitted once scaled, and every replacement rewrites the prefix
+* Google's implicit cache matches.
+*
+* The exact size is only known once the attachment service has derived the
+* version, which happens after this budget runs, so an image with a scale target
+* is measured at its target ceiling. An image without one travels as stored, and
+* there the stored size is exact.
+*/
 function requestImageBytes$3(block) {
 	const attachment = attachmentOf$5(block);
-	if (attachment) return base64Length$4(attachment.bytes);
+	if (attachment) {
+		const target = requestImageTarget$1(attachment);
+		return target ? base64Length$4(Math.min(attachment.bytes, target.maxBytes)) : base64Length$4(attachment.bytes);
+	}
 	const inline = asString$17(block.data) || asString$17(block.base64);
 	return inline ? inline.length : void 0;
 }
@@ -9841,6 +9907,12 @@ function collectRequestImageBytes$3(content, lengths) {
 * order them, and the placeholder tells the model the image is missing instead
 * of letting it answer as though the picture were simply blank.
 *
+* Each occurrence is measured at the size it will actually be sent at, so an
+* image that only fits after scaling is not replaced (see
+* {@link requestImageBytes}). Replacing an image is the LAST resort: it rewrites
+* the retained prefix and costs the next turn its whole implicit cache hit, so
+* it is worth keeping the image count stable for as long as the bytes allow.
+*
 * @param options - the request about to be built; durable history stays untouched.
 * @returns the original options when they already fit, otherwise shallow copies.
 */
@@ -9890,6 +9962,17 @@ function offloadOldestRequestImages$4(options) {
 * model a text marker, because a turn that silently loses its image is far
 * harder to diagnose than one that says so.
 *
+* WHY SCALE INSTEAD OF DROP. `offloadOldestRequestImages` has to replace an
+* image with placeholder text once the request exceeds
+* {@link MAX_REQUEST_IMAGE_BYTES}, and the count it replaces grows with every
+* image added afterwards. Each change rewrites the retained prefix, so Google's
+* implicit cache misses again on the very next turn. An image whose long edge is
+* over {@link REQUEST_IMAGE_MAX_EDGE} is therefore sent as the harness's
+* downscaled request version, which keeps the image COUNT steady and with it the
+* prefix. The stored image and durable history do not change, and an image that
+* already fits is sent byte-for-byte as stored. The drop path stays as the last
+* resort for a request that is over budget even after scaling.
+*
 * @param options - the exact request about to be built.
 * @param attachments - durable attachment store; absent when the host wired none.
 * @param signal - cancellation, forwarded to every attachment read.
@@ -9906,6 +9989,16 @@ async function resolveRequestImages$4(options, attachments, signal) {
 			return;
 		}
 		try {
+			const target = requestImageTarget$1(ref);
+			if (target !== void 0) {
+				const version = await attachments.readImageRequest(ref, target, signal);
+				resolved.set(attachmentId, Math.max(version.width, version.height) > 1024 ? { kind: "unavailable" } : {
+					kind: "inline",
+					mediaType: version.mediaType,
+					data: Buffer.from(version.data).toString("base64")
+				});
+				return;
+			}
 			const stored = await attachments.readImage(ref, signal);
 			resolved.set(attachmentId, {
 				kind: "inline",
@@ -10012,7 +10105,54 @@ function replayPart(part) {
 	if (typeof copy.text === "string") copy.text = sanitizeText$5(copy.text);
 	return copy;
 }
-/** Claude requires a signature on each thinking block, not a separate SSE part. */
+/**
+* Whether one part is nothing but visible text.
+*
+* A part carrying any second key keeps its own boundary. A signature, an opaque
+* provider field, `thought: true`, and a tool call all make the boundary around
+* them meaningful, and Google's implicit cache matches a byte-stable prefix, so
+* none of them may be crossed by a merge.
+*/
+function isPureTextPart(part) {
+	return part !== void 0 && typeof part.text === "string" && Object.keys(part).length === 1;
+}
+/**
+* Collapse each run of adjacent pure-text parts into a single part.
+*
+* SSE transport chunks are not semantic content blocks. One answer arrives as
+* hundreds of text deltas, and replaying each delta as its own part adds one
+* part per delta to the request prefix on every later turn of the conversation.
+* Antigravity relies on Google's implicit cache, which matches a byte-stable
+* prefix: the moment the prefix gains a part the previous request did not have,
+* everything after it misses. The Claude route lost 68.84% cache hits to exactly
+* that growth before its deltas were merged; the Gemini route sends the same
+* deltas and needs the same treatment.
+*
+* Merging is restricted to pure text, so signed, opaque, thinking, and tool
+* parts keep their boundaries exactly where the model produced them.
+*
+* @param parts - replay parts in model order; the input is never mutated.
+* @returns parts with every adjacent pure-text run merged into its first member.
+*/
+function mergeAdjacentTextParts(parts) {
+	const merged = [];
+	for (const part of parts) {
+		const previous = merged[merged.length - 1];
+		if (isPureTextPart(part) && isPureTextPart(previous)) {
+			previous.text = String(previous.text) + part.text;
+			continue;
+		}
+		merged.push({ ...part });
+	}
+	return merged;
+}
+/**
+* Claude requires a signature on each thinking block, not a separate SSE part.
+*
+* The thinking/signature pairing below is Claude's wire contract alone: Vertex
+* Anthropic rejects a thinking block without its signature, while Gemini has no
+* such rule and must receive the thinking parts the model actually produced.
+*/
 function claudeReplayParts(parts) {
 	const result = [];
 	let pending = "";
@@ -10040,14 +10180,9 @@ function claudeReplayParts(parts) {
 			continue;
 		}
 		pending = "";
-		if (part.thought !== true) {
-			const previous = result[result.length - 1];
-			const pureText = (value) => value !== void 0 && typeof value.text === "string" && Object.keys(value).length === 1;
-			if (pureText(part) && pureText(previous)) previous.text = String(previous.text) + part.text;
-			else result.push({ ...part });
-		}
+		if (part.thought !== true) result.push({ ...part });
 	}
-	return result;
+	return mergeAdjacentTextParts(result);
 }
 function assistantParts(message, model, runtimeModel, toolCalls) {
 	const parts = [];
@@ -10096,7 +10231,7 @@ function assistantParts(message, model, runtimeModel, toolCalls) {
 			parts.push(...originalParts.filter((part) => !part.functionCall).map(replayPart));
 		}
 	}
-	return runtimeModel.startsWith("claude-") ? claudeReplayParts(parts) : parts;
+	return runtimeModel.startsWith("claude-") ? claudeReplayParts(parts) : mergeAdjacentTextParts(parts);
 }
 function pushToolResult(contents, result, toolCalls, model, runtimeModel, images = NO_RESOLVED_IMAGES$5) {
 	const toolCallId = String(result.toolCallId || "");
@@ -10444,14 +10579,276 @@ function closeStream$5(state) {
 	return out;
 }
 //#endregion
+//#region src/host/antigravity/cache-stats.ts
+const EMPTY_TOTALS = {
+	requests: 0,
+	cachedTokens: 0,
+	freshTokens: 0
+};
+const totalsByScope = /* @__PURE__ */ new Map();
+const prefixesBySession = /* @__PURE__ */ new Map();
+const pendingBySession = /* @__PURE__ */ new Map();
+const missBySession = /* @__PURE__ */ new Map();
+/** When each session last SENT a request, for the idle reading a miss reports. */
+const requestAtBySession = /* @__PURE__ */ new Map();
+/**
+* Sessions the process is willing to remember before evicting the oldest.
+*
+* DSH runs several sessions and subagents through one host, but not hundreds at
+* once: eviction only begins once a host has served that many, and it drops the
+* least recently written key, which is a stale session by then. A purely
+* advisory feature must not be a leak.
+*/
+const MAX_TRACKED_SCOPES = 256;
+/**
+* Bucket key for a request that names no session.
+*
+* A one-shot request — a probe, a test, a caller that never had a conversation —
+* is still counted, but kept apart from every real session so it can never
+* inflate, or be mistaken for, one of their ratios.
+*/
+const UNSCOPED_KEY = "";
+/** The session a request belongs to, or the unscoped bucket when it names none. */
+function sessionScopeKey(sessionId) {
+	return typeof sessionId === "string" && sessionId.trim() !== "" ? sessionId.trim() : UNSCOPED_KEY;
+}
+/**
+* Composite key separating one session's numbers from another's, and one
+* account's share of a session from another's.
+*
+* The account is part of the key because the pool can answer the same session
+* from different accounts, and each of those probably keeps its own cache
+* server-side. A shared entry would blend a cold account's misses into a warm
+* account's ratio, leaving a number that means nothing.
+*
+* That each account is its own cache namespace is INFERRED, not measured: no
+* account-scoped cache metric exists, and an account-scoped read is unobservable
+* from here. Splitting by account is the conservative reading of that assumption
+* — if it is wrong the two entries are merely reported apart, whereas merging
+* them would silently average a claim this line cannot check.
+*/
+function statsScopeKey(sessionId, accountId) {
+	const session = sessionScopeKey(sessionId);
+	if (session === UNSCOPED_KEY) return UNSCOPED_KEY;
+	return accountId === void 0 || accountId === "" ? session : `${session} ${accountId}`;
+}
+/** Write a key, evicting the oldest entry once the bound is reached. */
+function rememberScoped$1(store, key, value) {
+	store.delete(key);
+	store.set(key, value);
+	if (store.size <= MAX_TRACKED_SCOPES) return;
+	const oldest = store.keys().next();
+	if (oldest.done !== true) store.delete(oldest.value);
+}
+/**
+* A short, stable fingerprint of one prefix segment.
+*
+* Hashed rather than stored verbatim: these strings are the whole conversation
+* on a long turn, and a 32-bit FNV-1a keeps the diagnostic dependency-free.
+* Collisions only ever cost a missed attribution, never a wrong request.
+*/
+function fingerprint$1(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
+/**
+* One value's canonical text, with object keys in a fixed order.
+*
+* Key order is an artifact of how a value was assembled, not of what it means:
+* hashing `JSON.stringify` output verbatim would report a drift whenever two
+* structurally equal requests happened to build their objects in a different
+* order, and a reader cannot tell that false positive from a real one.
+*/
+function stableSerialize(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableSerialize).join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`).join(",")}}`;
+}
+/** Hash one segment, or null when the request does not carry it at all. */
+function segmentHash(value) {
+	return value === void 0 ? null : fingerprint$1(stableSerialize(value));
+}
+/** The `request` object of a serialized Antigravity body, when it has one. */
+function requestSegment(body) {
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const request = parsed.request;
+		return typeof request === "object" && request !== null ? request : void 0;
+	} catch {
+		return;
+	}
+}
+/** Which segment changed, or that there was nothing to compare against. */
+function driftCause(previous, current) {
+	if (previous === void 0) return "new-session";
+	if (previous.sessionId !== current.sessionId) return "session-id";
+	if (previous.contents !== current.contents) return "contents";
+	if (previous.systemInstruction !== current.systemInstruction) return "systemInstruction";
+	if (previous.tools !== current.tools) return "tools";
+	return "none";
+}
+/**
+* Fingerprint the prefix of a request about to be sent, and attribute whatever
+* changed since this session's previous request.
+*
+* Called once per turn, before the request goes out, so the answer describes the
+* prefix the service will actually see. The reason is remembered for the session
+* as well, so the route can publish the attribution beside the ratio it explains.
+*
+* @param body - The serialized request body, exactly as it will be sent.
+* @param sessionId - Conversation the request belongs to, when it has one.
+* @returns The change attributed to this request.
+*/
+function recordCacheRequest(body, sessionId) {
+	const scope = sessionScopeKey(sessionId);
+	const request = requestSegment(body);
+	const snapshot = {
+		sessionId: typeof sessionId === "string" ? sessionId : "",
+		contents: segmentHash(request?.contents),
+		systemInstruction: segmentHash(request?.systemInstruction),
+		tools: segmentHash(request?.tools)
+	};
+	const previous = prefixesBySession.get(scope);
+	rememberScoped$1(prefixesBySession, scope, snapshot);
+	const cause = driftCause(previous, snapshot);
+	const previousRequestAt = requestAtBySession.get(scope);
+	rememberScoped$1(requestAtBySession, scope, Date.now());
+	const idleMs = previousRequestAt === void 0 ? void 0 : Math.max(0, Date.now() - previousRequestAt);
+	rememberScoped$1(pendingBySession, scope, {
+		cause,
+		...idleMs === void 0 ? {} : { idleMs }
+	});
+	return cause;
+}
+/** A token count worth recording, or undefined when it is not a count at all. */
+function usableCount(value) {
+	return Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/**
+* Add one request's reported counts to its session's totals.
+*
+* The scope carries the account as well as the session, because a pooled line
+* can answer one conversation from several accounts and each of those keeps its
+* own cache server-side: one account's cold misses must not be averaged into
+* another's warm hits.
+*
+* @param sample - Token counts the response reported.
+* @param sessionId - Conversation the request belonged to.
+* @param accountId - Pooled account that served it, when the pool is in use.
+*/
+function recordCacheUsage(sample, sessionId, accountId) {
+	const cached = usableCount(sample.cachedTokens);
+	const fresh = usableCount(sample.freshTokens);
+	if (cached === void 0 || fresh === void 0) return;
+	const scope = statsScopeKey(sessionId, accountId);
+	const previous = totalsByScope.get(scope) ?? EMPTY_TOTALS;
+	rememberScoped$1(totalsByScope, scope, {
+		requests: previous.requests + 1,
+		cachedTokens: previous.cachedTokens + cached,
+		freshTokens: previous.freshTokens + fresh
+	});
+	const session = sessionScopeKey(sessionId);
+	const pending = pendingBySession.get(session);
+	if (cached !== 0 || pending === void 0) return;
+	rememberScoped$1(missBySession, session, {
+		cause: pending.cause,
+		...pending.idleMs === void 0 ? {} : { idleMs: pending.idleMs },
+		at: Date.now()
+	});
+}
+/** Add one scope's totals into an accumulator. */
+function accumulate$1(totals, stats) {
+	totals.requests += stats.requests;
+	totals.cachedTokens += stats.cachedTokens;
+	totals.freshTokens += stats.freshTokens;
+}
+/**
+* Sum the scopes one question covers.
+*
+* The three cases are not a convenience: naming an account answers "is this
+* account's cache warm", naming only a session answers "how is this
+* conversation doing overall", and naming neither answers "how is this install
+* doing". Summing the stored scopes rather than keeping a second running total
+* means the aggregate can never drift out of step with the parts it summarises.
+*/
+function sumTotals(sessionId, accountId) {
+	const totals = { ...EMPTY_TOTALS };
+	if (sessionId === void 0) for (const stats of totalsByScope.values()) accumulate$1(totals, stats);
+	else if (accountId !== void 0) accumulate$1(totals, totalsByScope.get(statsScopeKey(sessionId, accountId)) ?? EMPTY_TOTALS);
+	else {
+		const scope = sessionScopeKey(sessionId);
+		const prefix = scope + " ";
+		for (const [key, stats] of totalsByScope) if (key === scope || key.startsWith(prefix)) accumulate$1(totals, stats);
+	}
+	return totals;
+}
+/** The most recent miss for the requested scope, when one was recorded. */
+function missFor(sessionId) {
+	if (sessionId === void 0) {
+		let latest;
+		for (const record of missBySession.values()) if (latest === void 0 || record.at >= latest.at) latest = record;
+		return latest;
+	}
+	return missBySession.get(sessionScopeKey(sessionId));
+}
+/**
+* Cache totals for one account's share of a session, one whole session, or every
+* tracked session.
+*
+* A missing session is not an error: the settings card has no conversation in
+* hand, and the process aggregate is the honest answer there.
+*/
+function getCacheStats$1(sessionId, accountId) {
+	const totals = sumTotals(sessionId, accountId);
+	const prompt = totals.cachedTokens + totals.freshTokens;
+	const miss = missFor(sessionId);
+	return {
+		...totals,
+		hitRatio: prompt === 0 ? null : totals.cachedTokens / prompt,
+		...miss === void 0 ? {} : { lastMiss: miss }
+	};
+}
+//#endregion
 //#region src/host/antigravity/account-pool.ts
 function poolPath() {
 	return path.join(dshHomeDir(), "storages", "antigravity-pool.json");
 }
+/**
+* The rotation strategy this line defaults to, and the reader for it.
+*
+* Sticky rather than the shared core's sequential default, because the account a
+* request is served by may also decide which server-side prefix cache it can
+* reach: each account is a separate quota domain, and an account that changes mid
+* conversation plausibly lands on a cache the previous one had not warmed, so the
+* next turn may reprocess a prefix that was already paid for. Holding the account
+* that served the previous request is the cheap way to not find out the hard way,
+* and a request that is rate limited still falls through to another account.
+*
+* That account identity selects a cache namespace is INFERRED, not measured.
+* Nothing here observes an account-scoped cache metric, no live capture has been
+* taken, and docs/antigravity-claude-cache-audit.md records the upstream position
+* — on-wire session affinity still needs transport diagnostics — against a run
+* that had a single account, so cross-account behaviour was never exercised.
+* The default stands as a design assumption until one of those is done.
+*
+* Only the DEFAULT differs. An explicit stored choice is returned unchanged, and
+* a pool file written before this change carries an explicit 'sequential' — so
+* upgrading does not silently move an existing user onto a different strategy.
+* The shared core keeps its own sequential default for every other line.
+*/
+function poolRotationStrategy(value) {
+	return value === "sequential" || value === "round-robin" || value === "sticky" ? value : "sticky";
+}
 function parseAntigravityPoolData(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Antigravity pool payload is invalid");
 	const record = value;
-	const strategy = normalizeRotationStrategy(record.rotationStrategy);
+	const strategy = poolRotationStrategy(record.rotationStrategy);
 	const activeAccountId = typeof record.activeAccountId === "string" ? record.activeAccountId : void 0;
 	const rawAccounts = Array.isArray(record.accounts) ? record.accounts : [];
 	const accounts = [];
@@ -10680,6 +11077,25 @@ function resolveDefaultReasoningEffort$4(efforts, configuredEffort) {
 	if (efforts.includes("low")) return ReasoningEffortId("low");
 	if (efforts.length > 0) return ReasoningEffortId(efforts[0]);
 }
+/**
+* Land one stream chunk's usage on its session's cache totals.
+*
+* The adapter is the only place that still knows the request's session and the
+* account that served it by the time the terminal chunk arrives: usage is
+* emitted from the mapper's stream state, which carries neither. Chunks of every
+* other type pass through untouched, and the mapper is left alone.
+*
+* The mapper counts cached and fresh prompt tokens separately
+* (`cacheReadTokens` / `inputTokens`), which is exactly the split these totals
+* are built from, so the numbers here are the ones the harness already reported.
+*/
+function recordUsageChunk(chunk, sessionId, accountId) {
+	if (chunk.type !== "usage") return;
+	recordCacheUsage({
+		cachedTokens: chunk.usage.cacheReadTokens ?? 0,
+		freshTokens: chunk.usage.inputTokens ?? 0
+	}, sessionId, accountId);
+}
 var AntigravityAdapter = class extends LlmAdapter {
 	store;
 	modelSettings;
@@ -10793,6 +11209,8 @@ var AntigravityAdapter = class extends LlmAdapter {
 		let recoveredMissingThinkingSignature = false;
 		const triedAccountIds = /* @__PURE__ */ new Set();
 		let response;
+		let statsSessionId = options.sessionId === void 0 ? void 0 : String(options.sessionId);
+		let statsAccountId;
 		while (true) {
 			let eff;
 			try {
@@ -10813,6 +11231,9 @@ var AntigravityAdapter = class extends LlmAdapter {
 			triedAccountIds.add(account.id);
 			for (const runtimeModel of candidates) {
 				const body = JSON.stringify(buildRequest$2(requestOptions, model, projectId, runtimeModel, effort, images));
+				recordCacheRequest(body, requestOptions.sessionId);
+				statsSessionId = requestOptions.sessionId === void 0 ? void 0 : String(requestOptions.sessionId);
+				statsAccountId = account.id;
 				const headers = {
 					...antigravityHeaders(token),
 					...model.id.startsWith("claude-") ? { "anthropic-beta": "interleaved-thinking-2025-05-14" } : {}
@@ -10903,16 +11324,25 @@ var AntigravityAdapter = class extends LlmAdapter {
 					const trimmed = line.trim();
 					if (!trimmed) continue;
 					const chunks = processStreamLine$2(trimmed, state);
-					for (const chunk of chunks) yield chunk;
+					for (const chunk of chunks) {
+						recordUsageChunk(chunk, statsSessionId, statsAccountId);
+						yield chunk;
+					}
 					if (state.finished) return;
 				}
 			}
 			buffer += decoder.decode();
 			if (buffer.trim()) {
 				const chunks = processStreamLine$2(buffer.trim(), state);
-				for (const chunk of chunks) yield chunk;
+				for (const chunk of chunks) {
+					recordUsageChunk(chunk, statsSessionId, statsAccountId);
+					yield chunk;
+				}
+			}
+			for (const chunk of closeStream$5(state)) {
+				recordUsageChunk(chunk, statsSessionId, statsAccountId);
+				yield chunk;
 			}
-			for (const chunk of closeStream$5(state)) yield chunk;
 		} finally {
 			reader.cancel().catch(() => void 0);
 		}
@@ -11004,7 +11434,7 @@ async function readRequestJson$7(request) {
 		request.on("error", reject);
 	});
 }
-async function getAntigravityWebStatus(store, modelSettings, preferences, accountPool = new AccountPoolStore(void 0, void 0, store)) {
+async function getAntigravityWebStatus(store, modelSettings, preferences, accountPool = new AccountPoolStore(void 0, void 0, store), sessionId) {
 	const credentials = await store.read();
 	const settings = preferences ? preferences.status() : await modelSettings.read();
 	const quota = getCachedQuota();
@@ -11035,16 +11465,32 @@ async function getAntigravityWebStatus(store, modelSettings, preferences, accoun
 		defaultReasoningEffort: settings.defaultReasoningEffort || null,
 		accounts,
 		activeAccountId: poolData?.activeAccountId || activeAccount?.id,
-		rotationStrategy: poolData?.rotationStrategy || "sequential"
+		rotationStrategy: poolData?.rotationStrategy || poolRotationStrategy(void 0),
+		cache: cacheStatsOrNull$1(sessionId)
 	};
 }
+/**
+* Rolling cache totals for one session, or null while nothing has reported usage.
+*
+* The session is a query parameter because the numbers are per session: a host
+* running several conversations at once cannot present one merged hit ratio as
+* if it described any of them. With no session named the route still answers
+* with the process aggregate, which is the right answer for a settings card
+* that is not showing a specific conversation.
+*/
+function cacheStatsOrNull$1(sessionId) {
+	const stats = getCacheStats$1(sessionId);
+	if (stats.requests === 0) return null;
+	return stats;
+}
 function registerAntigravityRoutes(ctx, store, modelSettings, preferences, fetchFn = fetch, accountPool = new AccountPoolStore(void 0, void 0, store)) {
 	const quotaRefresh = new QuotaRefresh();
 	return ctx.webServer.register({
 		kind: "prefix",
 		path: "/antigravity/api",
 		handler: async (request, response) => {
-			const path = new URL(request.url || "/", "http://dsh.local").pathname.replace(/^\/antigravity\/api\/?/, "");
+			const url = new URL(request.url || "/", "http://dsh.local");
+			const path = url.pathname.replace(/^\/antigravity\/api\/?/, "");
 			try {
 				if (path === "status" || path === "") {
 					if (request.method !== "GET") return sendMethodNotAllowed$6(response);
@@ -11059,7 +11505,7 @@ function registerAntigravityRoutes(ctx, store, modelSettings, preferences, fetch
 					return sendJson$8(response, 200, {
 						ok: true,
 						value: {
-							...await getAntigravityWebStatus(store, modelSettings, preferences, accountPool),
+							...await getAntigravityWebStatus(store, modelSettings, preferences, accountPool, url.searchParams.get("sessionId") ?? void 0),
 							quotaRefreshing: quotaRefresh.refreshing
 						}
 					});

package/lib/types/client/antigravity/AntigravitySection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AntigravitySection.d.ts","sourceRoot":"","sources":["../../../../src/client/antigravity/AntigravitySection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmD,MAAM,OAAO,CAAA;AAgBvE,UAAU,KAAK;IACb,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;IAC1B,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;CAChC;AAED,wBAAgB,kBAAkB,CAAC,EAAE,aAAa,EAAE,kBAAkB,EAAE,EAAE,KAAK,GAAG,KAAK,CAAC,YAAY,CAwfnG"}
+{"version":3,"file":"AntigravitySection.d.ts","sourceRoot":"","sources":["../../../../src/client/antigravity/AntigravitySection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmD,MAAM,OAAO,CAAA;AAiBvE,UAAU,KAAK;IACb,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;IAC1B,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;CAChC;AAwBD,wBAAgB,kBAAkB,CAAC,EAAE,aAAa,EAAE,kBAAkB,EAAE,EAAE,KAAK,GAAG,KAAK,CAAC,YAAY,CAyiBnG"}