@nick3/copilot-api 1.7.1 → 1.9.15

package/dist/{accounts-manager-Ca9IG0Fv.js → quota-refresh-scheduler-runtime-XD2fDa2K.js}

@@ -1,12 +1,11 @@
-import { O as accountFromState, _ as HTTPError, g as getCopilotUsage, j as consumeOutboundHeadersSnapshot, m as getGitHubUser, x as copilotModelsHeaders, y as copilotBaseUrl } from "./poll-access-token-c2IYJJHM.js";
-import { b as getCurrentIdentityEnvironment, c as isAccountEnabled, f as readLegacyToken, h as saveAccountToken, i as ensureAccountClientIdentity, l as listAccountsFromRegistry, o as hasLegacyToken, r as addAccountToRegistry, s as hasRegistry, u as loadAccountToken, v as buildIdentityKey, y as createAccountSessionId } from "./account-B4EBsn8H.js";
-import { t as PATHS } from "./paths-DGlr310R.js";
-import { t as getCopilotToken } from "./get-copilot-token-COIPGosP.js";
-import { c as getAdminDbUserVersion, i as getRequestOutboundStore, o as getAdminDb, s as getAdminDbPath } from "./request-outbound-qyTeXbzy.js";
+import { M as requestContext, O as accountFromState, _ as HTTPError, g as getCopilotUsage, j as consumeOutboundHeadersSnapshot, m as getGitHubUser, x as copilotModelsHeaders, y as copilotBaseUrl } from "./poll-access-token-CIPDXrcm.js";
+import { b as getCurrentIdentityEnvironment, c as isAccountEnabled, f as readLegacyToken, h as saveAccountToken, i as ensureAccountClientIdentity, l as listAccountsFromRegistry, o as hasLegacyToken, r as addAccountToRegistry, s as hasRegistry, u as loadAccountToken, v as buildIdentityKey, y as createAccountSessionId } from "./account-DjCbqJ2Q.js";
+import { t as PATHS } from "./paths-CclKwouX.js";
+import { t as getCopilotToken } from "./get-copilot-token-ZbmbVF0I.js";
+import { c as getAdminDbUserVersion, i as getRequestOutboundStore, o as getAdminDb, s as getAdminDbPath } from "./request-outbound-CxvpSkOn.js";
 import consola, { consola as consola$1 } from "consola";
 import fs from "node:fs/promises";
 import fs$1 from "node:fs";
-
 //#region src/lib/config.ts
 const PROVIDER_TYPE_ANTHROPIC = "anthropic";
 const gpt5ExplorationPrompt = `## Exploration and reading files
@@ -15,6 +14,14 @@ const gpt5ExplorationPrompt = `## Exploration and reading files
 - **multi_tool_use.parallel** Use multi_tool_use.parallel to parallelize tool calls and only this.
 - **Only make sequential calls if you truly cannot know the next file without seeing a result first.**
 - **Workflow:** (a) plan all needed reads → (b) issue one parallel batch → (c) analyze results → (d) repeat if new, unpredictable reads arise.`;
+const DEFAULT_QUOTA_REFRESH_CONFIG = {
+	enabled: true,
+	intervalMinutes: 360,
+	startupDelaySeconds: 60,
+	staggerMinSeconds: 2,
+	staggerMaxSeconds: 5
+};
+const MIN_QUOTA_REFRESH_INTERVAL_MINUTES = 30;
 const gpt5CommentaryPrompt = `# Working with the user
 
 You interact with the user through a terminal. You have 2 ways of communicating with the users:  
@@ -69,7 +76,8 @@ const defaultConfig = {
 		capture4xx: false,
 		capture5xx: false,
 		captureOther: false
-	}
+	},
+	quotaRefresh: DEFAULT_QUOTA_REFRESH_CONFIG
 };
 let cachedConfig = null;
 function isPlainObject(value) {
@@ -85,6 +93,23 @@ function normalizeNonNegativeNumber(value) {
 	if (value < 0) return void 0;
 	return value;
 }
+function normalizeQuotaRefreshIntervalMinutes(value) {
+	const minutes = normalizeNonNegativeNumber(value) ?? DEFAULT_QUOTA_REFRESH_CONFIG.intervalMinutes;
+	if (minutes > 0 && minutes < MIN_QUOTA_REFRESH_INTERVAL_MINUTES) return MIN_QUOTA_REFRESH_INTERVAL_MINUTES;
+	return minutes;
+}
+function normalizeQuotaRefreshConfig(value) {
+	const raw = isPlainObject(value) ? value : {};
+	const staggerMinSeconds = normalizeNonNegativeNumber(raw.staggerMinSeconds) ?? DEFAULT_QUOTA_REFRESH_CONFIG.staggerMinSeconds;
+	const rawStaggerMaxSeconds = normalizeNonNegativeNumber(raw.staggerMaxSeconds) ?? DEFAULT_QUOTA_REFRESH_CONFIG.staggerMaxSeconds;
+	return {
+		enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULT_QUOTA_REFRESH_CONFIG.enabled,
+		intervalMinutes: normalizeQuotaRefreshIntervalMinutes(raw.intervalMinutes),
+		startupDelaySeconds: normalizeNonNegativeNumber(raw.startupDelaySeconds) ?? DEFAULT_QUOTA_REFRESH_CONFIG.startupDelaySeconds,
+		staggerMinSeconds,
+		staggerMaxSeconds: Math.max(staggerMinSeconds, rawStaggerMaxSeconds)
+	};
+}
 const LOG_LEVELS = new Set([
 	"error",
 	"warn",
@@ -251,6 +276,20 @@ function mergeDefaultDevMode(config) {
 		changed: true
 	};
 }
+function mergeDefaultQuotaRefresh(config) {
+	const quotaRefresh = normalizeQuotaRefreshConfig(config.quotaRefresh);
+	if (JSON.stringify(config.quotaRefresh) === JSON.stringify(quotaRefresh)) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			quotaRefresh
+		},
+		changed: true
+	};
+}
 function applyConfigMerges(config, mergeFns) {
 	return mergeFns.reduce((acc, mergeFn) => {
 		const result = mergeFn(acc.mergedConfig);
@@ -271,7 +310,8 @@ function mergeConfigWithDefaults() {
 		mergeDefaultModelRefreshInterval,
 		mergeDefaultSessionAffinityRetention,
 		mergeDefaultLogLevel,
-		mergeDefaultDevMode
+		mergeDefaultDevMode,
+		mergeDefaultQuotaRefresh
 	]);
 	if (changed) try {
 		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
@@ -295,8 +335,8 @@ function normalizeAliasTarget(value) {
 }
 function normalizeAliasSpec(value) {
 	if (typeof value === "string") {
-		const normalizedTarget$1 = normalizeAliasTarget(value);
-		return normalizedTarget$1 ? { target: normalizedTarget$1 } : null;
+		const normalizedTarget = normalizeAliasTarget(value);
+		return normalizedTarget ? { target: normalizedTarget } : null;
 	}
 	if (!value || typeof value !== "object") return null;
 	const targetValue = value.target;
@@ -402,6 +442,9 @@ function getModelRefreshIntervalMs() {
 	if (!Number.isFinite(hours) || hours <= 0) return 0;
 	return hours * 60 * 60 * 1e3;
 }
+function getQuotaRefreshConfig() {
+	return normalizeQuotaRefreshConfig(getConfig().quotaRefresh);
+}
 function getSessionAffinityRetentionDays() {
 	return normalizeNonNegativeNumber(getConfig().sessionAffinityRetentionDays) ?? defaultConfig.sessionAffinityRetentionDays ?? 7;
 }
@@ -435,11 +478,15 @@ function isForceAgentEnabled() {
 function normalizeProviderBaseUrl(url) {
 	return url.trim().replace(/\/+$/u, "");
 }
-function resolveProviderAuthType(providerName, authType) {
-	if (authType === void 0 || authType === "x-api-key") return "x-api-key";
+function getDefaultProviderAuthType(providerType) {
+	return providerType === "openai-compatible" ? "authorization" : "x-api-key";
+}
+function resolveProviderAuthType(providerName, authType, providerType) {
+	if (authType === void 0) return getDefaultProviderAuthType(providerType);
+	if (authType === "x-api-key") return "x-api-key";
 	if (authType === "authorization") return authType;
-	consola.warn(`Provider ${providerName} has invalid authType '${authType}', ignoring provider`);
-	return null;
+	consola.warn(`Provider ${providerName} has invalid authType '${authType}', falling back to ${getDefaultProviderAuthType(providerType)}`);
+	return getDefaultProviderAuthType(providerType);
 }
 function getProviderConfig(name) {
 	const providerName = name.trim();
@@ -447,21 +494,21 @@ function getProviderConfig(name) {
 	const provider = getConfig().providers?.[providerName];
 	if (!provider) return null;
 	if (provider.enabled === false) return null;
-	if ((provider.type ?? PROVIDER_TYPE_ANTHROPIC) !== PROVIDER_TYPE_ANTHROPIC) {
-		consola.warn(`Provider ${providerName} is ignored because only anthropic type is supported`);
+	const type = provider.type ?? "anthropic";
+	if (type !== "anthropic" && type !== "openai-compatible") {
+		consola.warn(`Provider ${providerName} is ignored because type '${type}' is not supported`);
 		return null;
 	}
 	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? "");
 	const apiKey = (provider.apiKey ?? "").trim();
-	const authType = resolveProviderAuthType(providerName, provider.authType);
-	if (!authType) return null;
+	const authType = resolveProviderAuthType(providerName, provider.authType, type);
 	if (!baseUrl || !apiKey) {
 		consola.warn(`Provider ${providerName} is enabled but missing baseUrl or apiKey`);
 		return null;
 	}
 	return {
 		name: providerName,
-		type: PROVIDER_TYPE_ANTHROPIC,
+		type,
 		baseUrl,
 		apiKey,
 		authType,
@@ -481,7 +528,6 @@ function isResponsesApiWebSearchEnabled() {
 function getClaudeTokenMultiplier() {
 	return getConfig().claudeTokenMultiplier ?? 1.15;
 }
-
 //#endregion
 //#region src/lib/account-affinity.ts
 const DEFAULT_MAX_ENTRIES$1 = 1e4;
@@ -514,6 +560,31 @@ var AccountAffinityCache = class {
 		this.setMemory(key, accountId);
 		return accountId;
 	}
+	getMany(keys) {
+		const result = /* @__PURE__ */ new Map();
+		const missingKeys = new Array();
+		const now = Date.now();
+		for (const key of keys) {
+			if (result.has(key)) continue;
+			const entry = this.cache.get(key);
+			if (!entry) {
+				missingKeys.push(key);
+				continue;
+			}
+			if (now >= entry.expiresAt) {
+				this.cache.delete(key);
+				missingKeys.push(key);
+				continue;
+			}
+			result.set(key, entry.accountId);
+		}
+		if (missingKeys.length === 0) return result;
+		const persistentEntries = this.readPersistentEntries(missingKeys);
+		for (const [key, accountId] of persistentEntries) this.setMemory(key, accountId);
+		if (result.size === 0) return persistentEntries;
+		for (const [key, accountId] of persistentEntries) result.set(key, accountId);
+		return result;
+	}
 	/** Record a successful account mapping. Refreshes TTL and moves the entry to the newest position. */
 	set(key, accountId) {
 		this.setMemory(key, accountId);
@@ -538,7 +609,7 @@ var AccountAffinityCache = class {
 	get size() {
 		return this.cache.size;
 	}
-	getPersistentStore() {
+	getPersistentStore(options = {}) {
 		if (this.persistentStore) return this.persistentStore;
 		if (!this.persistentStoreProvider) return;
 		try {
@@ -546,7 +617,10 @@ var AccountAffinityCache = class {
 			if (store) this.persistentStore = store;
 			return store;
 		} catch (error) {
-			this.persistentStoreProvider = void 0;
+			if (options.throwOnProviderFailure) {
+				consola.error("Failed to resolve affinity persistence store:", error);
+				throw new Error("Affinity persistence store provider failed");
+			}
 			consola.warn("Failed to resolve affinity persistence store:", error);
 			return;
 		}
@@ -561,6 +635,27 @@ var AccountAffinityCache = class {
 			return;
 		}
 	}
+	readPersistentEntries(keys) {
+		const store = this.getPersistentStore({ throwOnProviderFailure: true });
+		if (!store) return /* @__PURE__ */ new Map();
+		if (store.getMany) try {
+			return store.getMany(keys);
+		} catch (error) {
+			consola.warn("Failed to batch-read affinity mappings from persistent store:", error);
+			throw new Error(`Affinity persistent store batch lookup failed for ${keys.length} keys`);
+		}
+		const result = /* @__PURE__ */ new Map();
+		const failedKeys = new Array();
+		for (const key of keys) try {
+			const accountId = store.get(key);
+			if (accountId) result.set(key, accountId);
+		} catch (error) {
+			failedKeys.push(key);
+			consola.warn("Failed to read affinity mapping from persistent store:", error);
+		}
+		if (failedKeys.length > 0) throw new Error(`Affinity persistent store lookup failed for ${failedKeys.length}/${keys.length} keys`);
+		return result;
+	}
 	writePersistentEntry(key, accountId) {
 		const store = this.getPersistentStore();
 		if (!store) return;
@@ -627,7 +722,6 @@ function isAffinityAccountUsable(accountId, accounts) {
 	if (account.failed) return void 0;
 	return account;
 }
-
 //#endregion
 //#region src/lib/dev-mode.ts
 function isDevModeEnabled() {
@@ -642,7 +736,6 @@ function isCapture5xxEnabled() {
 function isCaptureOtherEnabled() {
 	return getConfig().devMode?.captureOther === true;
 }
-
 //#endregion
 //#region src/services/copilot/copilot-fetch.ts
 const pendingCaptures = /* @__PURE__ */ new Map();
@@ -669,14 +762,14 @@ async function flushPendingCapture(requestId) {
 function snapshotHeaders(init) {
 	const headers = init.headers;
 	if (headers instanceof Headers) {
-		const out$1 = {};
-		for (const [key, value] of headers.entries()) out$1[key] = value;
-		return out$1;
+		const out = {};
+		for (const [key, value] of headers.entries()) out[key] = value;
+		return out;
 	}
 	if (Array.isArray(headers)) {
-		const out$1 = {};
-		for (const [key, value] of headers) out$1[key] = value;
-		return out$1;
+		const out = {};
+		for (const [key, value] of headers) out[key] = value;
+		return out;
 	}
 	const out = {};
 	for (const [key, value] of Object.entries(headers ?? {})) out[key] = value;
@@ -725,7 +818,7 @@ async function copilotFetch(input, init, ctx) {
 		headers: snapshotHeaders(init),
 		...snapshotBody(init)
 	};
-	const response = await fetch(input, init);
+	const response = await (ctx.fetchImpl ?? requestContext.getStore()?.fetchImpl ?? fetch)(input, init);
 	if (!(ctx.requestId !== void 0 && ctx.capturable !== false && shouldCaptureStatus(response.status))) return response;
 	const contentType = response.headers.get("content-type") ?? "";
 	const isSSE = contentType.includes("text/event-stream");
@@ -801,7 +894,6 @@ function persistNow({ requestSnapshot, status, responseBody, responseBodyKind, r
 		consola.debug("copilotFetch persist failed", error);
 	}
 }
-
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async (account, options) => {
@@ -826,7 +918,6 @@ const getModels = async (account, options) => {
 	} catch {}
 	return models;
 };
-
 //#endregion
 //#region src/lib/accounts-manager-auth.ts
 const takeAuthSnapshot = (account) => ({
@@ -895,7 +986,6 @@ const applyUnauthorizedIfCurrent = (account, snapshot, reason) => {
 	setAccountFailedState(account, reason);
 	return true;
 };
-
 //#endregion
 //#region src/lib/accounts-manager-quota.ts
 const getCostUnits = (model) => {
@@ -930,10 +1020,6 @@ const releasePremiumReservation = (account, reservation) => {
 	account.premiumReserved = Math.max(0, nextReserved);
 	if (reservations.size === 0) account.premiumReservations = void 0;
 };
-
-//#endregion
-//#region src/lib/stats-store.ts
-const DEFAULT_STATS_RETENTION_DAYS = 180;
 function toLocalDateString(ms) {
 	const d = new Date(ms);
 	return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
@@ -1082,7 +1168,7 @@ var StatsStore = class {
 		});
 		return this.mergeMetricsAndConsumption(dailyMetrics, byAccountMetrics, consumption);
 	}
-	cleanupStatsRetention(retentionDays = DEFAULT_STATS_RETENTION_DAYS) {
+	cleanupStatsRetention(retentionDays = 180) {
 		try {
 			const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
 			const cutoffDate = toLocalDateString(cutoffMs);
@@ -1151,7 +1237,6 @@ var StatsStore = class {
 		};
 	}
 };
-
 //#endregion
 //#region src/lib/request-history.ts
 const DEFAULT_RETENTION_DAYS = 35;
@@ -1299,6 +1384,8 @@ function buildInsertArgs(record) {
 		toDbNull(record.affinityKeyUsed),
 		toDbNull(record.affinityKeySource),
 		toDbNull(record.selectionReason),
+		toDbNull(record.responsesItemOwnerLookupKeysJson),
+		toDbNull(record.responsesItemOwnerRecordedKeysJson),
 		toDbNull(record.tokensInput),
 		toDbNull(record.tokensOutput),
 		toDbNull(record.tokensTotal),
@@ -1359,6 +1446,8 @@ var RequestHistoryStore = class {
 			"affinity_key_used",
 			"affinity_key_source",
 			"selection_reason",
+			"responses_item_owner_lookup_keys_json",
+			"responses_item_owner_recorded_keys_json",
 			"tokens_input",
 			"tokens_output",
 			"tokens_total",
@@ -1535,7 +1624,7 @@ var RequestHistoryStore = class {
 		} catch (error) {
 			consola.debug("Failed to cleanup request_log retention", error);
 		}
-		import("./request-outbound-DhI9-SrV.js").then((m) => m.getRequestOutboundStore().cleanupOrphans()).catch(() => {});
+		import("./request-outbound-Cy6huWjK.js").then((m) => m.getRequestOutboundStore().cleanupOrphans()).catch(() => {});
 	}
 	meta() {
 		return {
@@ -1627,15 +1716,18 @@ function extractResponsesUsageFromResult(result) {
 function getStatsStore() {
 	return getStatsStoreInstance();
 }
-
 //#endregion
 //#region src/lib/session-affinity-store.ts
 const DAY_MS = 1440 * 60 * 1e3;
 const DEFAULT_MAX_AGE_MS = 7 * DAY_MS;
 const CLEANUP_INTERVAL_MS = DAY_MS;
+const MAX_BATCH_KEYS = 500;
 const maybeUnref = (timer) => {
 	timer.unref();
 };
+function* chunks(values, size) {
+	for (let index = 0; index < values.length; index += size) yield values.slice(index, index + size);
+}
 var SessionAffinityStore = class {
 	db;
 	constructor(db) {
@@ -1657,6 +1749,65 @@ var SessionAffinityStore = class {
 		}
 		return row.account_id;
 	}
+	getMany(cacheKeys) {
+		const uniqueKeys = [...new Set(cacheKeys)].filter(Boolean);
+		const result = /* @__PURE__ */ new Map();
+		let chunkIndex = 0;
+		for (const keys of chunks(uniqueKeys, MAX_BATCH_KEYS)) {
+			try {
+				this.readManyChunk(keys, result);
+			} catch (error) {
+				consola.error("Failed to batch-read session affinity mappings", {
+					chunkIndex,
+					chunkKeyCount: keys.length,
+					error,
+					totalKeyCount: uniqueKeys.length
+				});
+				throw error;
+			}
+			chunkIndex += 1;
+		}
+		if (result.size === 0) return result;
+		const now = Date.now();
+		let touchChunkIndex = 0;
+		const touchedKeyCount = result.size;
+		for (const keys of chunks([...result.keys()], MAX_BATCH_KEYS)) {
+			try {
+				this.touchManyChunk(keys, now);
+			} catch (error) {
+				consola.warn("Failed to batch-update session affinity last_used_at_ms", {
+					chunkIndex: touchChunkIndex,
+					chunkKeyCount: keys.length,
+					error,
+					touchedKeyCount
+				});
+			}
+			touchChunkIndex += 1;
+		}
+		return result;
+	}
+	readManyChunk(cacheKeys, result) {
+		if (cacheKeys.length === 0) return;
+		const placeholders = cacheKeys.map(() => "?").join(", ");
+		const rows = this.db.query(`SELECT cache_key, account_id FROM session_affinity
+         WHERE cache_key IN (${placeholders});`).all(...cacheKeys);
+		for (const row of rows) {
+			if (!row.cache_key || !row.account_id) {
+				consola.error("Invalid session affinity row returned from database", {
+					hasAccountId: Boolean(row.account_id),
+					hasCacheKey: Boolean(row.cache_key)
+				});
+				throw new Error("Invalid session affinity row returned from database");
+			}
+			result.set(row.cache_key, row.account_id);
+		}
+	}
+	touchManyChunk(cacheKeys, now) {
+		if (cacheKeys.length === 0) return;
+		const placeholders = cacheKeys.map(() => "?").join(", ");
+		this.db.query(`UPDATE session_affinity SET last_used_at_ms = ?
+         WHERE cache_key IN (${placeholders});`).run(now, ...cacheKeys);
+	}
 	set(cacheKey, accountId) {
 		const now = Date.now();
 		try {
@@ -1724,7 +1875,6 @@ function applySharedSessionAffinityRetention(retentionMs = getSessionAffinityRet
 		consola.warn("Failed to apply session affinity retention:", error);
 	}
 }
-
 //#endregion
 //#region src/lib/session-ownership.ts
 const DEFAULT_MAX_ENTRIES = 1e4;
@@ -1770,7 +1920,6 @@ var SessionOwnershipCache = class {
 		this.cache.clear();
 	}
 };
-
 //#endregion
 //#region src/lib/accounts-manager.ts
 /** Quota cache TTL in milliseconds (45 seconds) for pre-request selection. */
@@ -1798,6 +1947,10 @@ function getInitialSelectionReason(cacheKey, rotationStart) {
 function preserveSubagentSelectionReason(initialSelectionReason, nextSelectionReason) {
 	return initialSelectionReason.startsWith("subagent_") ? initialSelectionReason : nextSelectionReason;
 }
+function normalizeCacheKeys(keys) {
+	if (!keys) return [];
+	return [...new Set(keys.map((key) => key.trim()).filter(Boolean))];
+}
 /** Manages multiple GitHub Copilot accounts at runtime. */
 var AccountsManager = class {
 	accounts = /* @__PURE__ */ new Map();
@@ -1873,6 +2026,12 @@ var AccountsManager = class {
 		this.modelsRefreshIntervalMs = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 0;
 		this.scheduleModelsRefresh();
 	}
+	getQuotaRefreshAccounts() {
+		return this.getOrderedEnabledAccounts().filter((account) => !this.isAccountFailed(account) && account.copilotToken !== void 0);
+	}
+	refreshAccountQuota(account) {
+		return this.refreshQuota(account);
+	}
 	computeTokenRefreshDelayMs(refreshInSeconds) {
 		const baseDelay = Math.max((refreshInSeconds - 60) * 1e3, 1e3);
 		const jitter = Math.floor(Math.random() * TOKEN_REFRESH_JITTER_MS);
@@ -2309,6 +2468,15 @@ var AccountsManager = class {
 	async selectAccountForRequest(candidates, context) {
 		if (candidates.length === 0) throw new Error("selectAccountForRequest requires at least one candidate");
 		const orderedAccounts = this.getOrderedEnabledAccounts();
+		const itemOwnerSelection = await this.selectPreferredResponsesItemOwner({
+			ownershipKeys: context?.responsesItemOwnershipKeys,
+			orderedAccounts,
+			candidates
+		});
+		if (itemOwnerSelection.result) {
+			this.attachConfirmOwnership(itemOwnerSelection.result, context?.ownershipWriteSessionId);
+			return itemOwnerSelection.result;
+		}
 		const ownerSelection = await this.selectPreferredSessionOwner({
 			lookupSessionId: context?.ownershipLookupSessionId,
 			orderedAccounts,
@@ -2389,6 +2557,12 @@ var AccountsManager = class {
 		if (!normalizedCacheKey) return;
 		this.affinityCache.delete(normalizedCacheKey);
 	}
+	recordResponsesItemOwnership(ownershipKeys, accountId) {
+		if (!this.accountAffinityEnabled) return;
+		const normalizedAccountId = accountId.trim();
+		if (!normalizedAccountId) return;
+		for (const key of normalizeCacheKeys(ownershipKeys)) this.affinityCache.set(key, normalizedAccountId);
+	}
 	attachConfirmOwnership(result, ownershipWriteSessionId) {
 		const rootSessionId = ownershipWriteSessionId?.trim();
 		if (!rootSessionId) return;
@@ -2398,6 +2572,52 @@ var AccountsManager = class {
 			this.sessionOwnership.set(rootSessionId, result.account.id);
 		};
 	}
+	async selectPreferredResponsesItemOwner(params) {
+		if (!this.accountAffinityEnabled) return {};
+		const { orderedAccounts, candidates } = params;
+		const ownershipKeys = normalizeCacheKeys(params.ownershipKeys);
+		if (ownershipKeys.length === 0) return {};
+		let ownershipMappings;
+		try {
+			ownershipMappings = this.affinityCache.getMany(ownershipKeys);
+		} catch (error) {
+			consola.warn("Failed to read Responses item owner mappings; falling back", {
+				error,
+				ownershipKeyCount: ownershipKeys.length
+			});
+			return {};
+		}
+		const accountIds = /* @__PURE__ */ new Map();
+		for (const key of ownershipKeys) {
+			const accountId = ownershipMappings.get(key);
+			if (!accountId) continue;
+			accountIds.set(accountId, key);
+			if (accountIds.size > 1) {
+				consola.warn("Conflicting Responses item owner mappings; falling back", {
+					accountIds: [...accountIds.keys()],
+					ownershipKeyCount: ownershipKeys.length
+				});
+				return {};
+			}
+		}
+		if (accountIds.size === 0) return {};
+		const [[accountId, ownerKey]] = [...accountIds];
+		const ownerResult = await this.tryAffinityAccount(accountId, orderedAccounts, candidates);
+		if (!ownerResult) {
+			if (this.isMissingOrDisabledAccount(accountId, orderedAccounts)) this.deleteResponsesItemOwnershipMappings(ownershipKeys, accountId);
+			return {};
+		}
+		ownerResult.affinityHit = true;
+		ownerResult.affinityCacheKey = ownerKey;
+		ownerResult.selectionReason = "responses_item_owner_hit";
+		return { result: ownerResult };
+	}
+	isMissingOrDisabledAccount(accountId, orderedAccounts) {
+		return !orderedAccounts.some((account) => account.id === accountId);
+	}
+	deleteResponsesItemOwnershipMappings(ownershipKeys, accountId) {
+		for (const key of ownershipKeys) if (this.affinityCache.get(key) === accountId) this.affinityCache.delete(key);
+	}
 	async selectPreferredSessionOwner(params) {
 		const { lookupSessionId, orderedAccounts, candidates } = params;
 		if (lookupSessionId === void 0) return {};
@@ -2463,13 +2683,13 @@ var AccountsManager = class {
 		if (scoredAccounts.length > 0) {
 			const scoredAccountsInSelectionOrder = this.shuffleWithinEqualRemainingBuckets(scoredAccounts).map(({ account }) => account);
 			const scoredAccountSet = new Set(scoredAccountsInSelectionOrder);
-			const unknownQuotaAccounts$1 = orderedAccounts.filter((account) => !scoredAccountSet.has(account) && !account.unlimited);
-			const unlimitedAccounts$1 = orderedAccounts.filter((account) => !scoredAccountSet.has(account) && account.unlimited);
+			const unknownQuotaAccounts = orderedAccounts.filter((account) => !scoredAccountSet.has(account) && !account.unlimited);
+			const unlimitedAccounts = orderedAccounts.filter((account) => !scoredAccountSet.has(account) && account.unlimited);
 			return {
 				accounts: [
 					...scoredAccountsInSelectionOrder,
-					...unknownQuotaAccounts$1,
-					...unlimitedAccounts$1
+					...unknownQuotaAccounts,
+					...unlimitedAccounts
 				],
 				premiumRemainingOrderedAccountIds: new Set(scoredAccountsInSelectionOrder.map((account) => account.id))
 			};
@@ -2868,7 +3088,170 @@ var AccountsManager = class {
 };
 /** Singleton instance of AccountsManager */
 const accountsManager = new AccountsManager({ persistentAffinityStore: getSharedSessionAffinityStore });
-
 //#endregion
-export { isMessageStartInputTokensFallbackEnabled as A, getModelAliasesInfo as C, getSmallModel as D, getReasoningEffortForModel as E, resolveModelAlias as F, shouldCompactUseSmallModel as I, isResponsesApiContextManagementModel as M, isResponsesApiWebSearchEnabled as N, isAccountAffinityEnabled as O, mergeConfigWithDefaults as P, getModelAliases as S, getProviderConfig as T, getAnthropicApiKey as _, getClientIpInfo as a, getExtraPromptForModel as b, normalizeChatCompletionsUsage as c, toLocalDateString as d, copilotFetch as f, getAliasTargetSet as g, PROVIDER_TYPE_ANTHROPIC as h, extractResponsesUsageFromStreamEvent as i, isMessagesApiEnabled as j, isForceAgentEnabled as k, normalizeEmbeddingsUsage as l, isDevModeEnabled as m, applySharedSessionAffinityRetention as n, getRequestHistoryStore as o, flushPendingCapture as p, extractResponsesUsageFromResult as r, getStatsStore as s, accountsManager as t, normalizeMessagesUsage as u, getClaudeTokenMultiplier as v, getModelRefreshIntervalMs as w, getLogLevel as x, getConfig as y };
-//# sourceMappingURL=accounts-manager-Ca9IG0Fv.js.map
+//#region src/lib/accounts-manager-quota-scheduler.ts
+const QUOTA_REFRESH_FRESHNESS_GUARD_MS = 300 * 1e3;
+const QUOTA_REFRESH_INTERVAL_JITTER_RATIO = .1;
+const defaultTimer = {
+	setTimer(callback, delayMs) {
+		return setTimeout(callback, delayMs);
+	},
+	clearTimer(handle) {
+		clearTimeout(handle);
+	}
+};
+function secondsToMs(seconds) {
+	return seconds * 1e3;
+}
+function minutesToMs(minutes) {
+	return minutes * 60 * 1e3;
+}
+function isSchedulingEnabled(config) {
+	return config.enabled && config.intervalMinutes > 0;
+}
+var QuotaRefreshScheduler = class {
+	config;
+	logger;
+	manager;
+	now;
+	random;
+	timer;
+	generation = 0;
+	pendingDelay;
+	roundTimer;
+	stopped = true;
+	constructor(options) {
+		this.config = options.config;
+		this.logger = options.logger ?? consola;
+		this.manager = options.manager;
+		this.now = options.now ?? Date.now;
+		this.random = options.random ?? Math.random;
+		this.timer = options.timer ?? defaultTimer;
+	}
+	start(config = this.config) {
+		this.config = config;
+		this.stop();
+		if (!isSchedulingEnabled(this.config)) return;
+		this.stopped = false;
+		this.scheduleRound(secondsToMs(this.config.startupDelaySeconds), this.generation);
+	}
+	stop() {
+		this.generation += 1;
+		this.stopped = true;
+		this.clearRoundTimer();
+		this.clearPendingDelay();
+	}
+	updateConfig(config) {
+		this.start(config);
+	}
+	isActiveGeneration(generation) {
+		return !this.stopped && this.generation === generation;
+	}
+	scheduleRound(delayMs, generation) {
+		this.clearRoundTimer();
+		const handle = this.timer.setTimer(() => {
+			if (this.roundTimer === handle) this.roundTimer = void 0;
+			if (this.isActiveGeneration(generation)) this.runRound(generation);
+		}, Math.max(0, delayMs));
+		this.roundTimer = handle;
+	}
+	scheduleNextRound(generation) {
+		if (!this.isActiveGeneration(generation) || !isSchedulingEnabled(this.config)) return;
+		const intervalMs = minutesToMs(this.config.intervalMinutes);
+		this.scheduleRound(this.withJitter(intervalMs), generation);
+	}
+	withJitter(intervalMs) {
+		const jitterMs = Math.floor(intervalMs * QUOTA_REFRESH_INTERVAL_JITTER_RATIO * (this.random() * 2 - 1));
+		return Math.max(0, intervalMs + jitterMs);
+	}
+	getStaggerDelayMs() {
+		const minMs = secondsToMs(this.config.staggerMinSeconds);
+		const maxMs = secondsToMs(this.config.staggerMaxSeconds);
+		if (maxMs <= minMs) return minMs;
+		return minMs + Math.floor(this.random() * (maxMs - minMs));
+	}
+	isFresh(account) {
+		if (account.lastQuotaFetch === void 0) return false;
+		return this.now() - account.lastQuotaFetch < QUOTA_REFRESH_FRESHNESS_GUARD_MS;
+	}
+	async schedulerDelay(delayMs) {
+		this.clearPendingDelay();
+		await new Promise((resolve) => {
+			const handle = this.timer.setTimer(() => {
+				if (this.pendingDelay?.handle === handle) this.pendingDelay = void 0;
+				resolve();
+			}, Math.max(0, delayMs));
+			this.pendingDelay = {
+				handle,
+				resolve
+			};
+		});
+	}
+	clearRoundTimer() {
+		if (this.roundTimer === void 0) return;
+		this.timer.clearTimer(this.roundTimer);
+		this.roundTimer = void 0;
+	}
+	clearPendingDelay() {
+		if (!this.pendingDelay) return;
+		const { handle, resolve } = this.pendingDelay;
+		this.pendingDelay = void 0;
+		this.timer.clearTimer(handle);
+		resolve();
+	}
+	async runRound(generation) {
+		try {
+			const accounts = this.manager.getQuotaRefreshAccounts();
+			for (const [index, account] of accounts.entries()) {
+				if (!this.isActiveGeneration(generation)) return;
+				if (this.isFresh(account)) continue;
+				try {
+					await this.manager.refreshAccountQuota(account);
+				} catch (error) {
+					if (this.isActiveGeneration(generation)) this.logger.debug("Background quota refresh failed", {
+						accountId: account.id,
+						error
+					});
+				}
+				if (!this.isActiveGeneration(generation)) return;
+				if (index < accounts.length - 1) {
+					await this.schedulerDelay(this.getStaggerDelayMs());
+					if (!this.isActiveGeneration(generation)) return;
+				}
+			}
+		} catch (error) {
+			if (this.isActiveGeneration(generation)) this.logger.error("Background quota refresh round failed", error);
+		} finally {
+			this.scheduleNextRound(generation);
+		}
+	}
+};
+//#endregion
+//#region src/lib/quota-refresh-scheduler-runtime.ts
+const quotaRefreshScheduler = new QuotaRefreshScheduler({
+	config: getQuotaRefreshConfig(),
+	manager: accountsManager
+});
+const registeredShutdownRuntimes = /* @__PURE__ */ new WeakSet();
+let isQuotaRefreshSchedulerStarted = false;
+function startQuotaRefreshSchedulerFromConfig() {
+	isQuotaRefreshSchedulerStarted = true;
+	quotaRefreshScheduler.start(getQuotaRefreshConfig());
+}
+function stopQuotaRefreshScheduler() {
+	isQuotaRefreshSchedulerStarted = false;
+	quotaRefreshScheduler.stop();
+}
+function registerQuotaRefreshSchedulerShutdownCleanup(runtime = process) {
+	if (registeredShutdownRuntimes.has(runtime)) return;
+	registeredShutdownRuntimes.add(runtime);
+	runtime.once("exit", () => stopQuotaRefreshScheduler());
+}
+function updateQuotaRefreshSchedulerFromConfig() {
+	if (!isQuotaRefreshSchedulerStarted) return;
+	quotaRefreshScheduler.updateConfig(getQuotaRefreshConfig());
+}
+//#endregion
+export { getReasoningEffortForModel as A, shouldCompactUseSmallModel as B, getConfig as C, getModelAliasesInfo as D, getModelAliases as E, isMessagesApiEnabled as F, isResponsesApiContextManagementModel as I, isResponsesApiWebSearchEnabled as L, isAccountAffinityEnabled as M, isForceAgentEnabled as N, getModelRefreshIntervalMs as O, isMessageStartInputTokensFallbackEnabled as P, mergeConfigWithDefaults as R, getClaudeTokenMultiplier as S, getLogLevel as T, flushPendingCapture as _, accountsManager as a, getAliasTargetSet as b, extractResponsesUsageFromStreamEvent as c, getStatsStore as d, normalizeChatCompletionsUsage as f, copilotFetch as g, toLocalDateString as h, updateQuotaRefreshSchedulerFromConfig as i, getSmallModel as j, getProviderConfig as k, getClientIpInfo as l, normalizeMessagesUsage as m, startQuotaRefreshSchedulerFromConfig as n, applySharedSessionAffinityRetention as o, normalizeEmbeddingsUsage as p, stopQuotaRefreshScheduler as r, extractResponsesUsageFromResult as s, registerQuotaRefreshSchedulerShutdownCleanup as t, getRequestHistoryStore as u, isDevModeEnabled as v, getExtraPromptForModel as w, getAnthropicApiKey as x, PROVIDER_TYPE_ANTHROPIC as y, resolveModelAlias as z };
+
+//# sourceMappingURL=quota-refresh-scheduler-runtime-XD2fDa2K.js.map