@gajae-code/coding-agent 0.11.1 → 0.11.2

package/src/session/agent-storage.ts

@@ -37,6 +37,8 @@ const instances = new Map<string, AgentStorage>();
 export class AgentStorage {
 	#db: Database;
 	#authStore: AuthCredentialStore;
+	#dbPath: string;
+	#closed = false;
 
 	#listSettingsStmt: Statement;
 	#upsertModelUsageStmt: Statement;
@@ -44,6 +46,7 @@ export class AgentStorage {
 	#modelUsageCache: string[] | null = null;
 
 	private constructor(dbPath: string) {
+		this.#dbPath = dbPath;
 		this.#ensureDir(dbPath);
 		try {
 			this.#db = new Database(dbPath);
@@ -431,6 +434,21 @@ FROM model_usage_legacy
 		this.#authStore.cleanExpiredCache();
 	}
 
+	/**
+	 * Release prepared statements and the shared SQLite handle.
+	 *
+	 * AgentStorage instances are cached by path, so closing also evicts this
+	 * instance and allows a later open() to create a fresh handle.
+	 */
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#listSettingsStmt.finalize();
+		this.#upsertModelUsageStmt.finalize();
+		this.#listModelUsageStmt.finalize();
+		this.#authStore.close();
+		if (instances.get(this.#dbPath) === this) instances.delete(this.#dbPath);
+	}
 	/**
 	 * Ensures the parent directory for the database file exists.
 	 * @param dbPath - Path to the database file

package/src/session/cache-economics.ts

@@ -128,18 +128,32 @@ export function computeCacheMissCostSummary(
 		return undefined;
 	if (usage.input <= 0 && cacheWriteCostUsd <= 0) return undefined;
 	if (!hasMaterialEvidence(usage, [inputCostUsd, cacheReadCostUsd, cacheWriteCostUsd])) return undefined;
-	if (inputCostUsd <= 0 && cacheWriteCostUsd <= 0) return undefined;
+	const hasAllZeroModelPrices =
+		basis.kind === "current-model-estimate" &&
+		basis.pricing.input === 0 &&
+		basis.pricing.cacheRead === 0 &&
+		basis.pricing.cacheWrite === 0;
+	if (inputCostUsd <= 0 && cacheWriteCostUsd <= 0 && !hasAllZeroModelPrices) return undefined;
 
 	const totalReusableInput = usage.input + usage.cacheRead;
 	const cacheHitRate = totalReusableInput > 0 ? usage.cacheRead / totalReusableInput : undefined;
-	const missPremiumUsd =
+	const inputMissPremiumUsd =
 		basis.kind === "current-model-estimate" &&
 		positiveFinite(basis.pricing.input) &&
 		positiveFinite(basis.pricing.cacheRead) &&
 		basis.pricing.input > basis.pricing.cacheRead &&
 		usage.input > 0
 			? ((basis.pricing.input - basis.pricing.cacheRead) * usage.input) / TOKENS_PER_MILLION
-			: undefined;
+			: 0;
+	const cacheWritePremiumUsd =
+		basis.kind === "current-model-estimate" &&
+		positiveFinite(basis.pricing.cacheWrite) &&
+		positiveFinite(basis.pricing.cacheRead) &&
+		basis.pricing.cacheWrite > basis.pricing.cacheRead &&
+		usage.cacheWrite > 0
+			? ((basis.pricing.cacheWrite - basis.pricing.cacheRead) * usage.cacheWrite) / TOKENS_PER_MILLION
+			: 0;
+	const missPremiumUsd = inputMissPremiumUsd + cacheWritePremiumUsd;
 
 	return {
 		inputTokens: usage.input,
@@ -179,14 +193,17 @@ export function buildCacheBehaviorWarning(
 	usage: Usage | undefined,
 	model: { cost: CacheEconomicsModelCost } | undefined | null,
 ): CacheBehaviorWarning | undefined {
-	const summary = model
-		? computeCacheMissCostSummary(usage, { kind: "current-model-estimate", pricing: model.cost })
-		: undefined;
+	if (!model) return undefined;
+	const summary = computeCacheMissCostSummary(usage, {
+		kind: "current-model-estimate",
+		pricing: model.cost,
+	});
 	if (!summary) return undefined;
+	const tokenOnlyPricing = model.cost.input === 0 && model.cost.cacheRead === 0 && model.cost.cacheWrite === 0;
 	if (
 		summary.inputTokens >= LARGE_INPUT_TOKENS &&
 		(summary.cacheHitRate === undefined || summary.cacheHitRate < 0.25) &&
-		summary.inputCostUsd >= EXPENSIVE_MISS_COST_USD
+		(tokenOnlyPricing || summary.inputCostUsd >= EXPENSIVE_MISS_COST_USD)
 	) {
 		// Attribute by observable cache activity rather than asserting a cause (#2020).
 		const noCacheActivity = summary.cacheReadTokens <= 0 && summary.cacheWriteTokens <= 0;
@@ -228,7 +245,7 @@ export function buildCacheBehaviorWarning(
 	}
 	if (
 		summary.cacheWriteTokens >= LARGE_CACHE_WRITE_TOKENS &&
-		summary.cacheWriteCostUsd >= EXPENSIVE_MISS_COST_USD &&
+		(tokenOnlyPricing || summary.cacheWriteCostUsd >= EXPENSIVE_MISS_COST_USD) &&
 		// Only claim reuse is insufficient when reads actually fail to cover the
 		// writes; a large write that is being read back is healthy, not a spike.
 		summary.cacheReadTokens < summary.cacheWriteTokens

package/src/session/fallback-chain-controller.ts

@@ -1,4 +1,4 @@
-export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "other";
+import type { FallbackTriggerClass } from "@gajae-code/ai/utils/fallback-transport";
 
 /** Immutable configured fallback intent. Transient attempt state never belongs here. */
 export interface ConfiguredFallbackChain {
@@ -27,7 +27,9 @@ export class FallbackChainController {
 	activeIndex = 0;
 	attemptsUsed = 0;
 	tried: FallbackFailure[] = [];
+
 	#attemptStarted = false;
+	#totalAttemptsUsed = 0;
 	skips: Array<{ selector: string; reason: string }> = [];
 	exhaustedForTurn = false;
 
@@ -40,6 +42,10 @@ export class FallbackChainController {
 		if (this.chain.entries.length === 0) this.exhaustedForTurn = true;
 	}
 
+	get totalAttemptsUsed(): number {
+		return this.#totalAttemptsUsed;
+	}
+
 	currentSelector(): string | undefined {
 		return this.chain.entries[this.activeIndex];
 	}
@@ -53,13 +59,28 @@ export class FallbackChainController {
 	/** Charge an upstream request at its concrete transport boundary. */
 	onAttemptStarted(): void {
 		if (!this.currentSelector() || this.exhaustedForTurn) return;
+		if (this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length) {
+			this.activeIndex = this.chain.entries.length;
+			this.exhaustedForTurn = true;
+			return;
+		}
 		this.attemptsUsed += 1;
+		this.#totalAttemptsUsed += 1;
 		this.#attemptStarted = true;
 	}
 
-	/** Start a logically new request without losing its sticky selected entry. */
+	/** Remove the current started request from fallback-policy accounting without erasing prior failures. */
+	discardStartedAttempt(): void {
+		if (!this.#attemptStarted) return;
+		this.attemptsUsed = Math.max(0, this.attemptsUsed - 1);
+		this.#totalAttemptsUsed = Math.max(0, this.#totalAttemptsUsed - 1);
+		this.#attemptStarted = false;
+	}
+
+	/** Start a logically new request with a fresh fallback-chain budget. */
 	resetAttemptBudget(): void {
 		this.attemptsUsed = 0;
+		this.#totalAttemptsUsed = 0;
 		this.tried = [];
 		this.#attemptStarted = false;
 	}
@@ -69,6 +90,7 @@ export class FallbackChainController {
 		this.activeIndex = Math.min(Math.max(0, activeIndex), this.chain.entries.length);
 		this.skips = [...skips];
 		this.attemptsUsed = 0;
+		this.#totalAttemptsUsed = 0;
 		this.#attemptStarted = false;
 		this.exhaustedForTurn = this.activeIndex >= this.chain.entries.length;
 	}
@@ -76,9 +98,17 @@ export class FallbackChainController {
 	onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult {
 		const selector = this.currentSelector();
 		if (!selector || this.exhaustedForTurn) return "exhausted";
-		if (!this.#attemptStarted) this.attemptsUsed += 1;
+		if (!this.#attemptStarted) {
+			this.attemptsUsed += 1;
+			this.#totalAttemptsUsed += 1;
+		}
 		this.#attemptStarted = false;
 		this.tried.push({ selector, triggerClass, reason });
+		if (this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length) {
+			this.activeIndex = this.chain.entries.length;
+			this.exhaustedForTurn = true;
+			return "exhausted";
+		}
 		if (this.attemptsUsed < this.maxAttempts) return "retry";
 		return this.advance() ? "advance" : "exhausted";
 	}
@@ -95,6 +125,25 @@ export class FallbackChainController {
 		return true;
 	}
 
+	/**
+	 * Restore the entry that just advanced when credential rotation permits a retry.
+	 * The chain-wide budget and failure history remain charged.
+	 */
+	restorePreviousEntryForRetry(): boolean {
+		if (
+			this.activeIndex === 0 ||
+			this.exhaustedForTurn ||
+			this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length
+		) {
+			return false;
+		}
+		this.activeIndex -= 1;
+		this.attemptsUsed = 0;
+		this.exhaustedForTurn = false;
+		this.#attemptStarted = false;
+		return true;
+	}
+
 	isExhausted(): boolean {
 		return this.exhaustedForTurn;
 	}
@@ -106,6 +155,7 @@ export class FallbackChainController {
 	resetSticky(): void {
 		this.activeIndex = 0;
 		this.attemptsUsed = 0;
+		this.#totalAttemptsUsed = 0;
 		this.tried = [];
 		this.skips = [];
 		this.exhaustedForTurn = this.chain.entries.length === 0;