@nick3/copilot-api 1.5.6 → 1.6.0

package/dist/accounts-manager-BE-Dq5Wn.js

@@ -1,1494 +0,0 @@
-import { _ as HTTPError, g as getCopilotUsage, m as getGitHubUser, p as getModels } from "./poll-access-token-DFooFWhY.js";
-import { _ as buildIdentityKey, c as listAccountsFromRegistry, d as readLegacyToken, i as ensureAccountClientIdentity, l as loadAccountToken, m as saveAccountToken, o as hasLegacyToken, r as addAccountToRegistry, s as hasRegistry, v as createAccountSessionId, y as getCurrentIdentityEnvironment } from "./account-AacnHem5.js";
-import { t as PATHS } from "./paths-DGlr310R.js";
-import { t as getCopilotToken } from "./get-copilot-token-cha9rQwA.js";
-import consola from "consola";
-import fs from "node:fs";
-
-//#region src/lib/config.ts
-const PROVIDER_TYPE_ANTHROPIC = "anthropic";
-const gpt5ExplorationPrompt = `## Exploration and reading files
-- **Think first.** Before any tool call, decide ALL files/resources you will need.
-- **Batch everything.** If you need multiple files (even from different places), read them together.
-- **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 gpt5CommentaryPrompt = `# Working with the user
-
-You interact with the user through a terminal. You have 2 ways of communicating with the users:  
-- Share intermediary updates in \`commentary\` channel.  
-- After you have completed all your work, send a message to the \`final\` channel.  
-
-## Intermediary updates
-
-- Intermediary updates go to the \`commentary\` channel.
-- User updates are short updates while you are working, they are NOT final answers.
-- You use 1-2 sentence user updates to communicate progress and new information to the user as you are doing work.
-- Do not begin responses with conversational interjections or meta commentary. Avoid openers such as acknowledgements (“Done —”, “Got it”, “Great question, ”) or framing phrases.
-- You provide user updates frequently, every 20s.
-- Before exploring or doing substantial work, you start with a user update acknowledging the request and explaining your first step. You should include your understanding of the user request and explain what you will do. Avoid commenting on the request or using starters such as "Got it -" or "Understood -" etc.
-- When exploring, e.g. searching, reading files, you provide user updates as you go, every 20s, explaining what context you are gathering and what you've learned. Vary your sentence structure when providing these updates to avoid sounding repetitive - in particular, don't start each sentence the same way.
-- After you have sufficient context, and the work is substantial, you provide a longer plan (this is the only user update that may be longer than 2 sentences and can contain formatting).
-- Before performing file edits of any kind, you provide updates explaining what edits you are making.
-- As you are thinking, you very frequently provide updates even if not taking any actions, informing the user of your progress. You interrupt your thinking and send multiple updates in a row if thinking for more than 100 words.
-- Tone of your updates MUST match your personality.`;
-const defaultConfig = {
-	auth: { apiKeys: [] },
-	providers: {},
-	extraPrompts: {
-		"gpt-5-mini": gpt5ExplorationPrompt,
-		"gpt-5.3-codex": gpt5CommentaryPrompt,
-		"gpt-5.4-mini": gpt5CommentaryPrompt,
-		"gpt-5.4": gpt5CommentaryPrompt
-	},
-	smallModel: "gpt-5-mini",
-	accountAffinity: true,
-	responsesApiContextManagementModels: [],
-	modelReasoningEfforts: {
-		"gpt-5-mini": "low",
-		"gpt-5.3-codex": "xhigh",
-		"gpt-5.4-mini": "xhigh",
-		"gpt-5.4": "xhigh"
-	},
-	allowOriginalModelNamesForAliases: false,
-	useFunctionApplyPatch: true,
-	forceAgent: false,
-	compactUseSmallModel: true,
-	messageStartInputTokensFallback: false,
-	modelRefreshIntervalHours: 24,
-	useMessagesApi: true,
-	useResponsesApiWebSearch: true
-};
-let cachedConfig = null;
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeAuthApiKeys(value) {
-	if (!Array.isArray(value)) return [];
-	return [...new Set(value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0))];
-}
-function normalizeModelRefreshIntervalHours(value) {
-	if (typeof value !== "number") return void 0;
-	if (!Number.isFinite(value)) return void 0;
-	if (value < 0) return void 0;
-	return value;
-}
-function ensureConfigFile() {
-	try {
-		fs.accessSync(PATHS.CONFIG_PATH, fs.constants.R_OK);
-		return;
-	} catch {}
-	try {
-		fs.mkdirSync(PATHS.APP_DIR, { recursive: true });
-		fs.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
-		try {
-			fs.chmodSync(PATHS.CONFIG_PATH, 384);
-		} catch {}
-	} catch {}
-}
-function readConfigFromDisk() {
-	ensureConfigFile();
-	try {
-		const raw = fs.readFileSync(PATHS.CONFIG_PATH, "utf8");
-		if (!raw.trim()) {
-			fs.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
-			return defaultConfig;
-		}
-		return JSON.parse(raw);
-	} catch (error) {
-		consola.error("Failed to read config file, using default config", error);
-		return defaultConfig;
-	}
-}
-function mergeDefaultConfig(config) {
-	const extraPrompts = config.extraPrompts ?? {};
-	const defaultExtraPrompts = defaultConfig.extraPrompts ?? {};
-	const modelReasoningEfforts = config.modelReasoningEfforts ?? {};
-	const defaultModelReasoningEfforts = defaultConfig.modelReasoningEfforts ?? {};
-	const hasForceAgent = typeof config.forceAgent === "boolean";
-	const defaultForceAgent = defaultConfig.forceAgent ?? false;
-	const missingExtraPromptModels = Object.keys(defaultExtraPrompts).filter((model) => !Object.hasOwn(extraPrompts, model));
-	const missingReasoningEffortModels = Object.keys(defaultModelReasoningEfforts).filter((model) => !Object.hasOwn(modelReasoningEfforts, model));
-	const hasExtraPromptChanges = missingExtraPromptModels.length > 0;
-	const hasReasoningEffortChanges = missingReasoningEffortModels.length > 0;
-	if (!hasExtraPromptChanges && !hasReasoningEffortChanges && !!hasForceAgent) return {
-		mergedConfig: config,
-		changed: false
-	};
-	return {
-		mergedConfig: {
-			...config,
-			extraPrompts: {
-				...defaultExtraPrompts,
-				...extraPrompts
-			},
-			modelReasoningEfforts: {
-				...defaultModelReasoningEfforts,
-				...modelReasoningEfforts
-			},
-			forceAgent: hasForceAgent ? config.forceAgent : defaultForceAgent
-		},
-		changed: true
-	};
-}
-function mergeDefaultAuth(config) {
-	const authConfig = isPlainObject(config.auth) ? config.auth : void 0;
-	const nextAuth = { apiKeys: normalizeAuthApiKeys(Array.isArray(authConfig?.apiKeys) ? authConfig.apiKeys : void 0) };
-	if (authConfig && JSON.stringify(authConfig) === JSON.stringify(nextAuth)) return {
-		mergedConfig: config,
-		changed: false
-	};
-	return {
-		mergedConfig: {
-			...config,
-			auth: nextAuth
-		},
-		changed: true
-	};
-}
-function mergeDefaultAccountAffinity(config) {
-	const raw = config;
-	const hasOld = typeof raw.freeModelLoadBalancing === "boolean";
-	const hasNew = typeof config.accountAffinity === "boolean";
-	if (hasOld) {
-		const next = { ...config };
-		if (!hasNew) next.accountAffinity = raw.freeModelLoadBalancing;
-		delete next.freeModelLoadBalancing;
-		return {
-			mergedConfig: next,
-			changed: true
-		};
-	}
-	if (hasNew) return {
-		mergedConfig: config,
-		changed: false
-	};
-	return {
-		mergedConfig: {
-			...config,
-			accountAffinity: defaultConfig.accountAffinity ?? true
-		},
-		changed: true
-	};
-}
-function mergeDefaultModelRefreshInterval(config) {
-	if (normalizeModelRefreshIntervalHours(config.modelRefreshIntervalHours) !== void 0) return {
-		mergedConfig: config,
-		changed: false
-	};
-	return {
-		mergedConfig: {
-			...config,
-			modelRefreshIntervalHours: defaultConfig.modelRefreshIntervalHours ?? 24
-		},
-		changed: true
-	};
-}
-function applyConfigMerges(config, mergeFns) {
-	return mergeFns.reduce((acc, mergeFn) => {
-		const result = mergeFn(acc.mergedConfig);
-		return {
-			mergedConfig: result.mergedConfig,
-			changed: acc.changed || result.changed
-		};
-	}, {
-		mergedConfig: config,
-		changed: false
-	});
-}
-function mergeConfigWithDefaults() {
-	const { mergedConfig, changed } = applyConfigMerges(readConfigFromDisk(), [
-		mergeDefaultAuth,
-		mergeDefaultConfig,
-		mergeDefaultAccountAffinity,
-		mergeDefaultModelRefreshInterval
-	]);
-	if (changed) try {
-		fs.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
-	} catch (writeError) {
-		consola.warn("Failed to write merged config defaults", writeError);
-	}
-	cachedConfig = mergedConfig;
-	return mergedConfig;
-}
-function getConfig() {
-	cachedConfig ??= readConfigFromDisk();
-	return cachedConfig;
-}
-function normalizeAliasKey(value) {
-	const trimmed = value.trim().toLowerCase();
-	return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeAliasTarget(value) {
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeAliasSpec(value) {
-	if (typeof value === "string") {
-		const normalizedTarget$1 = normalizeAliasTarget(value);
-		return normalizedTarget$1 ? { target: normalizedTarget$1 } : null;
-	}
-	if (!value || typeof value !== "object") return null;
-	const targetValue = value.target;
-	if (typeof targetValue !== "string") return null;
-	const normalizedTarget = normalizeAliasTarget(targetValue);
-	if (!normalizedTarget) return null;
-	const allowOriginalValue = value.allowOriginal;
-	return {
-		target: normalizedTarget,
-		allowOriginal: typeof allowOriginalValue === "boolean" ? allowOriginalValue : void 0
-	};
-}
-function getModelAliasesInfo() {
-	const raw = getConfig().modelAliases ?? {};
-	const normalized = {};
-	for (const [alias, rawSpec] of Object.entries(raw)) {
-		const normalizedAlias = normalizeAliasKey(alias);
-		const normalizedSpec = normalizeAliasSpec(rawSpec);
-		if (!normalizedAlias || !normalizedSpec) continue;
-		if (!Object.hasOwn(normalized, normalizedAlias)) normalized[normalizedAlias] = normalizedSpec;
-	}
-	return normalized;
-}
-function getModelAliases() {
-	const info = getModelAliasesInfo();
-	const normalized = {};
-	for (const [alias, spec] of Object.entries(info)) normalized[alias] = spec.target;
-	return normalized;
-}
-function resolveModelAlias(modelId) {
-	const normalized = normalizeAliasKey(modelId);
-	if (!normalized) return modelId;
-	return getModelAliases()[normalized] ?? modelId;
-}
-function isOriginalModelNameAllowedForAliases() {
-	return getConfig().allowOriginalModelNamesForAliases ?? false;
-}
-function getAliasTargetSet() {
-	const aliases = getModelAliasesInfo();
-	const allowOriginalDefault = isOriginalModelNameAllowedForAliases();
-	const targetAllowMap = /* @__PURE__ */ new Map();
-	for (const { target, allowOriginal } of Object.values(aliases)) {
-		const normalizedTarget = target.toLowerCase();
-		const effectiveAllow = allowOriginal ?? allowOriginalDefault;
-		const currentAllow = targetAllowMap.get(normalizedTarget);
-		if (currentAllow === true) continue;
-		if (effectiveAllow) targetAllowMap.set(normalizedTarget, true);
-		else if (currentAllow === void 0) targetAllowMap.set(normalizedTarget, false);
-	}
-	const blockedTargets = /* @__PURE__ */ new Set();
-	for (const [target, allowed] of targetAllowMap.entries()) if (!allowed) blockedTargets.add(target);
-	return blockedTargets;
-}
-function isOriginalModelNameAllowedForTarget(modelId) {
-	const normalized = normalizeAliasKey(modelId);
-	if (!normalized) return true;
-	return !getAliasTargetSet().has(normalized);
-}
-function getPreferredAliasForTarget(modelId) {
-	return getAliasKeysForTarget(modelId, getModelAliases())[0] ?? null;
-}
-function getAliasKeysForTarget(target, aliases) {
-	const normalizedTarget = target.toLowerCase();
-	return Object.entries(aliases).filter(([, model]) => model.toLowerCase() === normalizedTarget).map(([alias]) => alias).sort();
-}
-function getAliasFallbackValue(record, modelId, aliases) {
-	if (!record) return void 0;
-	const aliasKeys = getAliasKeysForTarget(modelId, aliases);
-	if (aliasKeys.length === 0) return void 0;
-	const recordByAlias = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(record)) {
-		const normalized = normalizeAliasKey(key);
-		if (normalized) recordByAlias.set(normalized, value);
-	}
-	for (const alias of aliasKeys) {
-		const value = recordByAlias.get(alias);
-		if (value !== void 0) return value;
-	}
-}
-function getExtraPromptForModel(model) {
-	const config = getConfig();
-	const direct = config.extraPrompts?.[model];
-	if (direct !== void 0) return direct;
-	const aliases = getModelAliases();
-	return getAliasFallbackValue(config.extraPrompts, model, aliases) ?? "";
-}
-function getSmallModel() {
-	const model = getConfig().smallModel ?? "gpt-5-mini";
-	if (isOriginalModelNameAllowedForTarget(model)) return model;
-	return getPreferredAliasForTarget(model) ?? model;
-}
-function isAccountAffinityEnabled() {
-	return getConfig().accountAffinity ?? true;
-}
-function getModelRefreshIntervalHours() {
-	return normalizeModelRefreshIntervalHours(getConfig().modelRefreshIntervalHours) ?? defaultConfig.modelRefreshIntervalHours ?? 24;
-}
-function getModelRefreshIntervalMs() {
-	const hours = getModelRefreshIntervalHours();
-	if (!Number.isFinite(hours) || hours <= 0) return 0;
-	return hours * 60 * 60 * 1e3;
-}
-function isMessageStartInputTokensFallbackEnabled() {
-	return getConfig().messageStartInputTokensFallback ?? false;
-}
-function shouldCompactUseSmallModel() {
-	return getConfig().compactUseSmallModel ?? true;
-}
-function getResponsesApiContextManagementModels() {
-	return getConfig().responsesApiContextManagementModels ?? defaultConfig.responsesApiContextManagementModels ?? [];
-}
-function isResponsesApiContextManagementModel(model) {
-	return getResponsesApiContextManagementModels().includes(model);
-}
-function getReasoningEffortForModel(model) {
-	const config = getConfig();
-	const direct = config.modelReasoningEfforts?.[model];
-	if (direct !== void 0) return direct;
-	const aliases = getModelAliases();
-	return getAliasFallbackValue(config.modelReasoningEfforts, model, aliases) ?? "high";
-}
-function isForceAgentEnabled() {
-	return getConfig().forceAgent ?? false;
-}
-function normalizeProviderBaseUrl(url) {
-	return url.trim().replace(/\/+$/u, "");
-}
-function resolveProviderAuthType(providerName, authType) {
-	if (authType === void 0 || 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;
-}
-function getProviderConfig(name) {
-	const providerName = name.trim();
-	if (!providerName) return null;
-	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`);
-		return null;
-	}
-	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? "");
-	const apiKey = (provider.apiKey ?? "").trim();
-	const authType = resolveProviderAuthType(providerName, provider.authType);
-	if (!authType) return null;
-	if (!baseUrl || !apiKey) {
-		consola.warn(`Provider ${providerName} is enabled but missing baseUrl or apiKey`);
-		return null;
-	}
-	return {
-		name: providerName,
-		type: PROVIDER_TYPE_ANTHROPIC,
-		baseUrl,
-		apiKey,
-		authType,
-		models: provider.models,
-		adjustInputTokens: provider.adjustInputTokens
-	};
-}
-function isMessagesApiEnabled() {
-	return getConfig().useMessagesApi ?? true;
-}
-function getAnthropicApiKey() {
-	return getConfig().anthropicApiKey ?? process.env.ANTHROPIC_API_KEY ?? void 0;
-}
-function isResponsesApiWebSearchEnabled() {
-	return getConfig().useResponsesApiWebSearch ?? true;
-}
-function getClaudeTokenMultiplier() {
-	return getConfig().claudeTokenMultiplier ?? 1.15;
-}
-
-//#endregion
-//#region src/lib/account-affinity.ts
-const DEFAULT_MAX_ENTRIES = 1e4;
-const DEFAULT_TTL_MS = 3600 * 1e3;
-/**
-* In-memory LRU cache with TTL for account affinity mappings.
-*
-* Uses Map insertion order for LRU eviction: accessed/updated entries are
-* deleted and re-inserted so they move to the "newest" end.
-*/
-var AccountAffinityCache = class {
-	cache = /* @__PURE__ */ new Map();
-	maxEntries;
-	ttlMs;
-	constructor(maxEntries = DEFAULT_MAX_ENTRIES, ttlMs = DEFAULT_TTL_MS) {
-		this.maxEntries = maxEntries;
-		this.ttlMs = ttlMs;
-	}
-	/** Look up the preferred account ID for a cache key. Returns undefined if not found or expired. */
-	get(key) {
-		const entry = this.cache.get(key);
-		if (!entry) return;
-		if (Date.now() >= entry.expiresAt) {
-			this.cache.delete(key);
-			return;
-		}
-		return entry.accountId;
-	}
-	/** Record a successful account mapping. Refreshes TTL and moves the entry to the newest position. */
-	set(key, accountId) {
-		this.cache.delete(key);
-		while (this.cache.size >= this.maxEntries) {
-			const oldest = this.cache.keys().next();
-			if (oldest.done) break;
-			this.cache.delete(oldest.value);
-		}
-		this.cache.set(key, {
-			accountId,
-			expiresAt: Date.now() + this.ttlMs
-		});
-	}
-	/** Remove a specific entry. */
-	delete(key) {
-		return this.cache.delete(key);
-	}
-	/** Remove all entries. */
-	clear() {
-		this.cache.clear();
-	}
-	/** Current number of entries (including potentially expired ones). */
-	get size() {
-		return this.cache.size;
-	}
-};
-/**
-* Extract the affinity key from the request context.
-* Uses the upstream request ID which is deterministic for the same user message.
-*/
-function extractAffinityKey(context) {
-	return context.requestId?.trim() || void 0;
-}
-/**
-* Build the full cache key by combining the affinity key with the model ID.
-* This prevents cross-model pollution (same session requesting different models
-* can be routed to different accounts).
-*/
-function buildAffinityCacheKey(affinityKey, modelId) {
-	return `${affinityKey}:${modelId}`;
-}
-/**
-* Check whether an account is a valid affinity candidate.
-* An account is valid if it is not failed and is present in the provided
-* runtime list.
-*/
-function isAffinityAccountUsable(accountId, accounts) {
-	const account = accounts.find((a) => a.id === accountId);
-	if (!account) return void 0;
-	if (account.failed) return void 0;
-	return account;
-}
-
-//#endregion
-//#region src/lib/accounts-manager-auth.ts
-const takeAuthSnapshot = (account) => ({
-	githubToken: account.githubToken,
-	accountType: account.accountType
-});
-const isAuthSnapshotCurrent = (account, snapshot) => account.githubToken === snapshot.githubToken && account.accountType === snapshot.accountType;
-const isSameAuthSnapshot = (a, b) => {
-	if (!a) return false;
-	return a.githubToken === b.githubToken && a.accountType === b.accountType;
-};
-const toAccountContextFromSnapshot = (account, snapshot, copilotToken) => ({
-	accountLogin: account.accountLogin,
-	githubToken: snapshot.githubToken,
-	copilotToken,
-	...account.copilotApiUrl !== void 0 ? { copilotApiUrl: account.copilotApiUrl } : {},
-	accountType: snapshot.accountType,
-	vsCodeVersion: account.vsCodeVersion,
-	clientDeviceId: account.clientDeviceId,
-	clientMachineId: account.clientMachineId,
-	clientSessionId: account.clientSessionId
-});
-const applyCopilotTokenIfCurrent = (account, snapshot, copilotToken) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	account.copilotToken = copilotToken;
-	return true;
-};
-const applyModelsIfCurrent = (account, snapshot, models) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	account.models = models;
-	return true;
-};
-const applyTokenRefreshSuccessIfCurrent = (account, snapshot, token) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	account.copilotToken = token;
-	account.failed = false;
-	account.failureReason = void 0;
-	return true;
-};
-const applyTokenRefreshFailureIfCurrent = (account, snapshot, error) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	account.failed = true;
-	account.failureReason = String(error);
-	return true;
-};
-const applyQuotaRefreshSuccessIfCurrent = (account, snapshot, result) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	const { premium, copilotApiUrl } = result;
-	account.premiumEntitlement = premium.entitlement;
-	account.premiumRemaining = premium.remaining;
-	account.unlimited = premium.unlimited;
-	account.overagePermitted = premium.overage_permitted;
-	if (copilotApiUrl) account.copilotApiUrl = copilotApiUrl;
-	account.lastQuotaFetch = Date.now();
-	account.failed = false;
-	account.failureReason = void 0;
-	return true;
-};
-const setAccountFailedState = (account, reason) => {
-	account.failed = true;
-	account.failureReason = reason;
-	consola.warn(`Account ${account.id} marked as failed: ${reason}`);
-};
-const applyUnauthorizedIfCurrent = (account, snapshot, reason) => {
-	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
-	setAccountFailedState(account, reason);
-	return true;
-};
-
-//#endregion
-//#region src/lib/accounts-manager-quota.ts
-const getCostUnits = (model) => {
-	const billing = model.billing;
-	if (!billing) return 0;
-	if (billing.is_premium !== true) return 0;
-	const multiplier = billing.multiplier;
-	if (typeof multiplier !== "number" || !Number.isFinite(multiplier) || multiplier <= 0) return 1;
-	return multiplier;
-};
-const getEffectivePremiumRemaining = (account) => {
-	if (account.premiumRemaining === void 0) return;
-	const reserved = account.premiumReserved ?? 0;
-	return account.premiumRemaining - reserved;
-};
-const reservePremiumUnits = (account, units) => {
-	if (units <= 0) return;
-	const id = Symbol("quotaReservation");
-	if (!account.premiumReservations) account.premiumReservations = /* @__PURE__ */ new Map();
-	account.premiumReservations.set(id, units);
-	account.premiumReserved = (account.premiumReserved ?? 0) + units;
-	return { id };
-};
-const releasePremiumReservation = (account, reservation) => {
-	if (!reservation) return;
-	const reservations = account.premiumReservations;
-	if (!reservations) return;
-	const reservedUnits = reservations.get(reservation.id);
-	if (reservedUnits === void 0) return;
-	reservations.delete(reservation.id);
-	const nextReserved = (account.premiumReserved ?? 0) - reservedUnits;
-	account.premiumReserved = Math.max(0, nextReserved);
-	if (reservations.size === 0) account.premiumReservations = void 0;
-};
-
-//#endregion
-//#region src/lib/accounts-manager.ts
-/** Quota cache TTL in milliseconds (45 seconds) for pre-request selection. */
-const QUOTA_CACHE_TTL = 45 * 1e3;
-/** Debounce delay for registry reload in milliseconds */
-const RELOAD_DEBOUNCE_MS = 500;
-/** Registry watcher restart initial delay in milliseconds */
-const WATCHER_RESTART_INITIAL_DELAY_MS = 1e3;
-/** Registry watcher restart max delay in milliseconds */
-const WATCHER_RESTART_MAX_DELAY_MS = 60 * 1e3;
-/** Session refresh base interval in milliseconds. */
-const SESSION_REFRESH_BASE_MS = 3600 * 1e3;
-/** Session refresh jitter window in milliseconds. */
-const SESSION_REFRESH_JITTER_MS = 1200 * 1e3;
-/** Minimum delay between account initializations in milliseconds. */
-const INIT_STAGGER_MIN_MS = 2e3;
-/** Maximum delay between account initializations in milliseconds. */
-const INIT_STAGGER_MAX_MS = 5e3;
-/** Random jitter window added to token refresh delay in milliseconds. */
-const TOKEN_REFRESH_JITTER_MS = 3e4;
-/** Manages multiple GitHub Copilot accounts at runtime. */
-var AccountsManager = class {
-	accounts = /* @__PURE__ */ new Map();
-	accountOrder = [];
-	temporaryAccount;
-	vsCodeVersion;
-	accountAffinityEnabled = true;
-	affinityCache = new AccountAffinityCache();
-	loadBalanceCursor = 0;
-	quotaRefreshSnapshotByAccount = /* @__PURE__ */ new WeakMap();
-	modelsRefreshSnapshotByAccount = /* @__PURE__ */ new WeakMap();
-	tokenRefreshEnabledAccounts = /* @__PURE__ */ new WeakSet();
-	modelsRefreshTimer;
-	modelsRefreshIntervalMs = 0;
-	registryWatcher;
-	reloadDebounceTimer;
-	registryWatcherRestartTimer;
-	registryWatcherRestartDelayMs = WATCHER_RESTART_INITIAL_DELAY_MS;
-	isReloading = false;
-	currentReloadPromise;
-	/** Initialize accounts manager (load registry, migrate legacy token). */
-	async initialize(vsCodeVersion) {
-		this.vsCodeVersion = vsCodeVersion;
-		const hasReg = await hasRegistry();
-		const hasLegacy = await hasLegacyToken();
-		if (!hasReg && hasLegacy) await this.migrateLegacyToken();
-		const accountMetas = await listAccountsFromRegistry();
-		for (const meta of accountMetas) {
-			const token = await loadAccountToken(meta.id);
-			if (!token) {
-				consola.warn(`No token found for account ${meta.id}, skipping`);
-				continue;
-			}
-			const runtime = {
-				...meta,
-				accountLogin: meta.id,
-				githubToken: token,
-				vsCodeVersion: this.vsCodeVersion
-			};
-			this.accounts.set(meta.id, runtime);
-			this.accountOrder.push(meta.id);
-		}
-		let isFirstAccount = true;
-		for (const account of this.accounts.values()) {
-			if (!isFirstAccount) {
-				const staggerDelay = INIT_STAGGER_MIN_MS + Math.floor(Math.random() * (INIT_STAGGER_MAX_MS - INIT_STAGGER_MIN_MS));
-				consola.debug(`Staggering initialization of account ${account.id} by ${staggerDelay}ms`);
-				await new Promise((resolve) => setTimeout(resolve, staggerDelay));
-			}
-			isFirstAccount = false;
-			try {
-				await this.initializeAccount(account);
-			} catch (error) {
-				consola.error(`Failed to initialize account ${account.id}:`, error);
-				account.failed = true;
-				account.failureReason = String(error);
-			}
-		}
-		consola.info(`Loaded ${this.accounts.size} account(s)`);
-		this.startRegistryWatcher();
-	}
-	setAccountAffinityEnabled(enabled) {
-		this.accountAffinityEnabled = enabled;
-		if (!enabled) this.affinityCache.clear();
-	}
-	setModelsRefreshIntervalMs(intervalMs) {
-		this.modelsRefreshIntervalMs = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 0;
-		this.scheduleModelsRefresh();
-	}
-	computeTokenRefreshDelayMs(refreshInSeconds) {
-		const baseDelay = Math.max((refreshInSeconds - 60) * 1e3, 1e3);
-		const jitter = Math.floor(Math.random() * TOKEN_REFRESH_JITTER_MS);
-		const maxSafeDelay = Math.max(refreshInSeconds * 1e3 - 1e3, 1e3);
-		return Math.min(baseDelay + jitter, maxSafeDelay);
-	}
-	computeSessionRefreshDelayMs() {
-		return SESSION_REFRESH_BASE_MS + Math.floor(Math.random() * SESSION_REFRESH_JITTER_MS);
-	}
-	resolveAccountLogin(account) {
-		return account.accountLogin ?? account.id;
-	}
-	commitAccountIdentity(account, { identityKey, login, deviceId, machineId }) {
-		account.accountLogin = login;
-		account.identityKey = identityKey;
-		account.clientDeviceId = deviceId;
-		account.clientMachineId = machineId;
-	}
-	async applyAccountIdentity(account) {
-		const login = this.resolveAccountLogin(account);
-		const { oauthApp, enterpriseDomain } = getCurrentIdentityEnvironment();
-		const identityKey = buildIdentityKey({
-			login,
-			oauthApp,
-			enterpriseDomain
-		});
-		const identity = await ensureAccountClientIdentity({
-			login,
-			oauthApp,
-			enterpriseDomain
-		});
-		this.commitAccountIdentity(account, {
-			identityKey,
-			login,
-			deviceId: identity.deviceId,
-			machineId: identity.machineId
-		});
-		if (!account.clientSessionId) {
-			account.clientSessionId = createAccountSessionId();
-			consola.debug(`Generated VSCode session ID for account ${account.id}: ${account.clientSessionId}`);
-		}
-		this.startSessionRefresh(account);
-	}
-	shouldContinueTokenRefresh(account, snapshot) {
-		return this.tokenRefreshEnabledAccounts.has(account) && isAuthSnapshotCurrent(account, snapshot);
-	}
-	async runTokenRefreshTick(account, snapshot, refreshInSeconds) {
-		if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
-		try {
-			const { token, refresh_in } = await getCopilotToken(toAccountContextFromSnapshot(account, snapshot));
-			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
-			if (!applyTokenRefreshSuccessIfCurrent(account, snapshot, token)) return;
-			consola.debug(`Refreshed token for account ${account.id}`);
-			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
-			this.startTokenRefresh(account, refresh_in);
-		} catch (error) {
-			consola.error(`Failed to refresh token for ${account.id}:`, error);
-			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
-			applyTokenRefreshFailureIfCurrent(account, snapshot, error);
-			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
-			this.startTokenRefresh(account, refreshInSeconds);
-		}
-	}
-	finalizeQuotaRefreshPromise(account, promise) {
-		if (account.quotaRefreshPromise !== promise) return;
-		account.isRefreshingQuota = false;
-		account.quotaRefreshPromise = void 0;
-		this.quotaRefreshSnapshotByAccount.delete(account);
-	}
-	/** Initialize a single account. */
-	async initializeAccount(account) {
-		await this.applyAccountIdentity(account);
-		const snapshot = takeAuthSnapshot(account);
-		try {
-			const { token, refresh_in } = await getCopilotToken(toAccountContextFromSnapshot(account, snapshot));
-			if (!applyCopilotTokenIfCurrent(account, snapshot, token)) return;
-			await this.refreshQuota(account);
-			this.startTokenRefresh(account, refresh_in);
-			if (!applyModelsIfCurrent(account, snapshot, await getModels(toAccountContextFromSnapshot(account, snapshot, token)))) return;
-			account.lastModelsFetch = Date.now();
-			consola.debug(`Account ${account.id} initialized`);
-		} catch (error) {
-			if (!isAuthSnapshotCurrent(account, snapshot)) return;
-			throw error;
-		}
-	}
-	/** Migrate legacy github_token to the new multi-account system. */
-	async migrateLegacyToken() {
-		const token = await readLegacyToken();
-		if (!token) return;
-		try {
-			const id = (await getGitHubUser({
-				githubToken: token,
-				accountType: "individual"
-			})).login;
-			await saveAccountToken(id, token);
-			await addAccountToRegistry({
-				id,
-				accountType: "individual",
-				addedAt: Date.now()
-			});
-			consola.info(`Migrated legacy token to account: ${id}`);
-		} catch (error) {
-			consola.error("Failed to migrate legacy token:", error);
-		}
-	}
-	/** Start token refresh timer for an account. */
-	startTokenRefresh(account, refreshInSeconds) {
-		this.stopTokenRefresh(account);
-		this.tokenRefreshEnabledAccounts.add(account);
-		const snapshot = takeAuthSnapshot(account);
-		const delayMs = this.computeTokenRefreshDelayMs(refreshInSeconds);
-		account.refreshTimer = setTimeout(() => {
-			this.runTokenRefreshTick(account, snapshot, refreshInSeconds);
-		}, delayMs);
-	}
-	/** Stop token refresh timer for an account. */
-	stopTokenRefresh(account) {
-		this.tokenRefreshEnabledAccounts.delete(account);
-		if (account.refreshTimer) {
-			clearTimeout(account.refreshTimer);
-			account.refreshTimer = void 0;
-		}
-	}
-	/** Stop all token refresh timers. */
-	stopAllTokenRefresh() {
-		for (const account of this.accounts.values()) this.stopTokenRefresh(account);
-		if (this.temporaryAccount) this.stopTokenRefresh(this.temporaryAccount);
-	}
-	startSessionRefresh(account) {
-		this.stopSessionRefresh(account);
-		const delayMs = this.computeSessionRefreshDelayMs();
-		consola.debug(`Scheduling next VSCode session ID refresh for ${account.id} in ${Math.round(delayMs / 1e3)} seconds`);
-		account.sessionRefreshTimer = setTimeout(() => {
-			try {
-				account.clientSessionId = createAccountSessionId();
-				consola.debug(`Refreshed VSCode session ID for account ${account.id}: ${account.clientSessionId}`);
-			} catch (error) {
-				consola.error(`Failed to refresh VSCode session ID for ${account.id}, rescheduling...`, error);
-			} finally {
-				this.startSessionRefresh(account);
-			}
-		}, delayMs);
-	}
-	stopSessionRefresh(account) {
-		if (account.sessionRefreshTimer) {
-			clearTimeout(account.sessionRefreshTimer);
-			account.sessionRefreshTimer = void 0;
-		}
-	}
-	stopAllSessionRefresh() {
-		for (const account of this.accounts.values()) this.stopSessionRefresh(account);
-		if (this.temporaryAccount) this.stopSessionRefresh(this.temporaryAccount);
-	}
-	scheduleModelsRefresh() {
-		this.stopModelsRefresh();
-		if (!this.modelsRefreshIntervalMs || this.modelsRefreshIntervalMs <= 0) return;
-		this.modelsRefreshTimer = setTimeout(() => {
-			this.runModelsRefreshTick();
-		}, this.modelsRefreshIntervalMs);
-	}
-	stopModelsRefresh() {
-		if (this.modelsRefreshTimer) {
-			clearTimeout(this.modelsRefreshTimer);
-			this.modelsRefreshTimer = void 0;
-		}
-	}
-	async runModelsRefreshTick() {
-		try {
-			await this.refreshAllModels();
-		} catch (error) {
-			consola.error("Failed to refresh models:", error);
-		} finally {
-			this.scheduleModelsRefresh();
-		}
-	}
-	finalizeModelsRefreshPromise(account, promise) {
-		if (account.modelsRefreshPromise !== promise) return;
-		account.isRefreshingModels = false;
-		account.modelsRefreshPromise = void 0;
-		this.modelsRefreshSnapshotByAccount.delete(account);
-	}
-	async refreshModels(account) {
-		if (!account.copilotToken) {
-			consola.debug(`Skip model refresh for ${account.id}: missing Copilot token`);
-			return;
-		}
-		const snapshot = takeAuthSnapshot(account);
-		if (account.modelsRefreshPromise) {
-			if (isSameAuthSnapshot(this.modelsRefreshSnapshotByAccount.get(account), snapshot)) {
-				await account.modelsRefreshPromise;
-				return;
-			}
-		}
-		account.isRefreshingModels = true;
-		const ctx = toAccountContextFromSnapshot(account, snapshot, account.copilotToken);
-		const promise = (async () => {
-			try {
-				if (applyModelsIfCurrent(account, snapshot, await getModels(ctx))) account.lastModelsFetch = Date.now();
-			} catch (error) {
-				if (error instanceof HTTPError && error.response.status === 401) {
-					applyUnauthorizedIfCurrent(account, snapshot, "Unauthorized (401)");
-					return;
-				}
-				consola.error(`Failed to refresh models for ${account.id}:`, error);
-			}
-		})();
-		account.modelsRefreshPromise = promise;
-		this.modelsRefreshSnapshotByAccount.set(account, snapshot);
-		promise.finally(() => {
-			this.finalizeModelsRefreshPromise(account, promise);
-		});
-		await promise;
-	}
-	async refreshAllModels() {
-		const accounts = [];
-		if (this.temporaryAccount) accounts.push(this.temporaryAccount);
-		for (const id of this.accountOrder) {
-			const account = this.accounts.get(id);
-			if (account) accounts.push(account);
-		}
-		if (accounts.length === 0) return;
-		await Promise.allSettled(accounts.map((account) => this.refreshModels(account)));
-	}
-	/** Refresh quota information for an account. */
-	async refreshQuota(account) {
-		const snapshot = takeAuthSnapshot(account);
-		if (account.quotaRefreshPromise) {
-			if (isSameAuthSnapshot(this.quotaRefreshSnapshotByAccount.get(account), snapshot)) {
-				await account.quotaRefreshPromise;
-				return;
-			}
-		}
-		account.isRefreshingQuota = true;
-		const ctx = toAccountContextFromSnapshot(account, snapshot);
-		const promise = (async () => {
-			try {
-				const usage = await getCopilotUsage(ctx);
-				const premium = usage.quota_snapshots.premium_interactions;
-				applyQuotaRefreshSuccessIfCurrent(account, snapshot, {
-					premium,
-					copilotApiUrl: usage.endpoints.api
-				});
-			} catch (error) {
-				if (error instanceof HTTPError && error.response.status === 401) {
-					applyUnauthorizedIfCurrent(account, snapshot, "Unauthorized (401)");
-					return;
-				}
-				consola.error(`Failed to refresh quota for ${account.id}:`, error);
-			}
-		})();
-		account.quotaRefreshPromise = promise;
-		this.quotaRefreshSnapshotByAccount.set(account, snapshot);
-		promise.finally(() => {
-			this.finalizeQuotaRefreshPromise(account, promise);
-		});
-		await promise;
-	}
-	/** Check if quota cache is expired. */
-	isQuotaCacheExpired(account) {
-		if (!account.lastQuotaFetch) return true;
-		return Date.now() - account.lastQuotaFetch > QUOTA_CACHE_TTL;
-	}
-	isAccountFailed(account) {
-		return account.failed === true;
-	}
-	useOverageFallback(fallback) {
-		const reservation = reservePremiumUnits(fallback.account, fallback.costUnits);
-		return {
-			ok: true,
-			account: fallback.account,
-			selectedModel: fallback.model,
-			endpoint: fallback.endpoint,
-			costUnits: fallback.costUnits,
-			reservation
-		};
-	}
-	isModelSupportedForEndpoint(model, endpoint) {
-		if (endpoint === "/responses") return model.supported_endpoints?.includes(endpoint) ?? false;
-		const supported = model.supported_endpoints;
-		if (!supported) return true;
-		return supported.includes(endpoint);
-	}
-	pickSupportedCandidate(account, candidates) {
-		const models = account.models?.data;
-		if (!models) return null;
-		for (const candidate of candidates) {
-			const model = models.find((m) => m.id === candidate.modelId);
-			if (!model) continue;
-			if (!this.isModelSupportedForEndpoint(model, candidate.endpoint)) continue;
-			return {
-				candidate,
-				model
-			};
-		}
-		return null;
-	}
-	async selectAccountForCandidates(orderedAccounts, candidates) {
-		if (orderedAccounts.length === 0) return {
-			ok: false,
-			reason: "NO_ACCOUNTS"
-		};
-		let supportedCandidateFound = false;
-		let overageFallback;
-		for (const account of orderedAccounts) {
-			if (this.isAccountFailed(account)) continue;
-			const supported = this.pickSupportedCandidate(account, candidates);
-			if (!supported) continue;
-			supportedCandidateFound = true;
-			const { candidate, model } = supported;
-			const costUnits = getCostUnits(model);
-			if (costUnits <= 0) return {
-				ok: true,
-				account,
-				selectedModel: model,
-				endpoint: candidate.endpoint,
-				costUnits
-			};
-			if (!account.unlimited && this.isQuotaCacheExpired(account)) await this.refreshQuota(account);
-			if (this.isAccountFailed(account)) continue;
-			if (account.unlimited) return {
-				ok: true,
-				account,
-				selectedModel: model,
-				endpoint: candidate.endpoint,
-				costUnits
-			};
-			const effectiveRemaining = getEffectivePremiumRemaining(account);
-			if (effectiveRemaining !== void 0 && effectiveRemaining < costUnits) {
-				if (account.overagePermitted && !overageFallback) overageFallback = {
-					account,
-					model,
-					endpoint: candidate.endpoint,
-					costUnits
-				};
-				continue;
-			}
-			const reservation = reservePremiumUnits(account, costUnits);
-			return {
-				ok: true,
-				account,
-				selectedModel: model,
-				endpoint: candidate.endpoint,
-				costUnits,
-				reservation
-			};
-		}
-		if (!supportedCandidateFound) return {
-			ok: false,
-			reason: "MODEL_NOT_SUPPORTED"
-		};
-		return overageFallback ? this.useOverageFallback(overageFallback) : {
-			ok: false,
-			reason: "NO_QUOTA"
-		};
-	}
-	/**
-	* Try to use a preferred (affinity) account for the request.
-	* Returns a successful selection if the account is usable; null otherwise.
-	*/
-	async tryAffinityAccount(preferredAccountId, orderedAccounts, candidates) {
-		const account = isAffinityAccountUsable(preferredAccountId, orderedAccounts);
-		if (!account) return null;
-		const supported = this.pickSupportedCandidate(account, candidates) ?? this.pickAliasFallbackCandidate(account, candidates);
-		if (!supported) return null;
-		return this.validateAffinityQuota(account, supported);
-	}
-	/**
-	* Resolve model aliases and try to pick a supported candidate.
-	* Returns null if no alias differs or the account doesn't support the alias.
-	*/
-	pickAliasFallbackCandidate(account, candidates) {
-		const aliasCandidates = candidates.map((candidate) => {
-			const modelId = resolveModelAlias(candidate.modelId);
-			if (modelId === candidate.modelId) return candidate;
-			return {
-				...candidate,
-				modelId
-			};
-		});
-		if (!aliasCandidates.some((candidate, index) => candidate.modelId !== candidates[index].modelId)) return null;
-		return this.pickSupportedCandidate(account, aliasCandidates);
-	}
-	/**
-	* Validate quota for an affinity candidate. Free models pass immediately;
-	* premium models go through quota refresh / reservation.
-	*/
-	async validateAffinityQuota(account, supported) {
-		const { candidate, model } = supported;
-		const costUnits = getCostUnits(model);
-		if (costUnits <= 0) return {
-			ok: true,
-			account,
-			selectedModel: model,
-			endpoint: candidate.endpoint,
-			costUnits
-		};
-		if (!account.unlimited && this.isQuotaCacheExpired(account)) await this.refreshQuota(account);
-		if (this.isAccountFailed(account)) return null;
-		if (account.unlimited) return {
-			ok: true,
-			account,
-			selectedModel: model,
-			endpoint: candidate.endpoint,
-			costUnits
-		};
-		const effectiveRemaining = getEffectivePremiumRemaining(account);
-		if (effectiveRemaining !== void 0 && effectiveRemaining < costUnits) return null;
-		const reservation = reservePremiumUnits(account, costUnits);
-		return {
-			ok: true,
-			account,
-			selectedModel: model,
-			endpoint: candidate.endpoint,
-			costUnits,
-			reservation
-		};
-	}
-	/**
-	* Select an available account for a specific request (model + endpoint).
-	* When account affinity is enabled, routes to the previously successful account
-	* for the same affinity key + model combination.
-	* Uses reservation to avoid oversubscribing premium quota under concurrency.
-	*/
-	async selectAccountForRequest(candidates, affinityContext) {
-		if (candidates.length === 0) throw new Error("selectAccountForRequest requires at least one candidate");
-		const orderedAccounts = [...this.temporaryAccount ? [this.temporaryAccount] : [], ...this.accountOrder.map((id) => this.accounts.get(id)).filter((account) => account !== void 0)];
-		const affinityKey = this.accountAffinityEnabled && affinityContext ? extractAffinityKey(affinityContext) : void 0;
-		const modelKey = candidates[0].modelId;
-		const cacheKey = affinityKey ? buildAffinityCacheKey(affinityKey, modelKey) : void 0;
-		if (cacheKey) {
-			const preferredId = this.affinityCache.get(cacheKey);
-			if (preferredId) {
-				const affinityResult = await this.tryAffinityAccount(preferredId, orderedAccounts, candidates);
-				if (affinityResult) {
-					affinityResult.affinityHit = true;
-					affinityResult.affinityCacheKey = cacheKey;
-					affinityResult.confirmAffinity = () => {
-						if (!this.accountAffinityEnabled) return;
-						this.affinityCache.set(cacheKey, affinityResult.account.id);
-					};
-					return affinityResult;
-				}
-			}
-		}
-		const accountsForSelection = this.accountAffinityEnabled && orderedAccounts.length > 1 ? this.rotateAccounts(orderedAccounts) : orderedAccounts;
-		const result = await this.selectWithAliasFallback(accountsForSelection, candidates);
-		if (result.ok) this.loadBalanceCursor++;
-		if (result.ok && cacheKey) {
-			const successResult = result;
-			successResult.confirmAffinity = () => {
-				if (!this.accountAffinityEnabled) return;
-				this.affinityCache.set(cacheKey, successResult.account.id);
-			};
-		}
-		return result;
-	}
-	/**
-	* Rotate the accounts array by the current load-balance cursor for round-robin distribution.
-	* This ensures cache-miss requests are spread across accounts instead of always hitting the first.
-	*/
-	rotateAccounts(accounts) {
-		const start = this.loadBalanceCursor % accounts.length;
-		if (start === 0) return accounts;
-		return [...accounts.slice(start), ...accounts.slice(0, start)];
-	}
-	/**
-	* Normal account selection with alias fallback.
-	* Extracted to keep selectAccountForRequest readable after adding affinity logic.
-	*/
-	async selectWithAliasFallback(orderedAccounts, candidates) {
-		const primary = await this.selectAccountForCandidates(orderedAccounts, candidates);
-		if (primary.ok || primary.reason !== "MODEL_NOT_SUPPORTED") return primary;
-		const aliasCandidates = candidates.map((candidate) => {
-			const modelId = resolveModelAlias(candidate.modelId);
-			if (modelId === candidate.modelId) return candidate;
-			return {
-				...candidate,
-				modelId
-			};
-		});
-		if (!aliasCandidates.some((candidate, index) => candidate.modelId !== candidates[index].modelId)) return primary;
-		return this.selectAccountForCandidates(orderedAccounts, aliasCandidates);
-	}
-	/**
-	* Finalize quota after a request completes.
-	* This releases any in-flight reservation and refreshes the actual quota from the API.
-	*/
-	async finalizeQuota(account, reservation) {
-		releasePremiumReservation(account, reservation);
-		try {
-			await this.refreshQuota(account);
-		} catch (error) {
-			consola.debug(`Failed to finalize quota for ${account.id}:`, error);
-		}
-	}
-	/**
-	* Mark an account as failed.
-	*/
-	markAccountFailed(id, reason) {
-		const account = this.accounts.get(id);
-		if (account) {
-			setAccountFailedState(account, reason);
-			return;
-		}
-		if (this.temporaryAccount && this.temporaryAccount.id === id) setAccountFailedState(this.temporaryAccount, reason);
-	}
-	/**
-	* Get status of all accounts.
-	*/
-	getAccountStatus() {
-		const statuses = [];
-		if (this.temporaryAccount) statuses.push({
-			id: "(temporary)",
-			entitlement: this.temporaryAccount.premiumEntitlement,
-			remaining: this.temporaryAccount.premiumRemaining,
-			unlimited: this.temporaryAccount.unlimited,
-			overagePermitted: this.temporaryAccount.overagePermitted,
-			failed: this.temporaryAccount.failed,
-			failureReason: this.temporaryAccount.failureReason
-		});
-		for (const id of this.accountOrder) {
-			const account = this.accounts.get(id);
-			if (account) statuses.push({
-				id: account.id,
-				entitlement: account.premiumEntitlement,
-				remaining: account.premiumRemaining,
-				unlimited: account.unlimited,
-				overagePermitted: account.overagePermitted,
-				failed: account.failed,
-				failureReason: account.failureReason
-			});
-		}
-		return statuses;
-	}
-	/**
-	* Set a temporary account from a GitHub token (--github-token).
-	* This account takes priority over registered accounts.
-	*/
-	async setTemporaryAccount(githubToken, accountType) {
-		const user = await getGitHubUser({
-			githubToken,
-			accountType
-		});
-		if (this.temporaryAccount) {
-			this.stopTokenRefresh(this.temporaryAccount);
-			this.stopSessionRefresh(this.temporaryAccount);
-		}
-		const runtime = {
-			id: "(temporary)",
-			accountLogin: user.login,
-			accountType,
-			addedAt: Date.now(),
-			githubToken,
-			vsCodeVersion: this.vsCodeVersion
-		};
-		try {
-			await this.initializeAccount(runtime);
-			this.temporaryAccount = runtime;
-			consola.info("Temporary account initialized");
-		} catch (error) {
-			consola.error("Failed to initialize temporary account:", error);
-			throw error;
-		}
-	}
-	/**
-	* Check if any accounts are available.
-	*/
-	hasAccounts() {
-		return this.accounts.size > 0 || this.temporaryAccount !== void 0;
-	}
-	/**
-	* Get the first available account's models.
-	* Used for caching models in legacy compatibility mode.
-	*/
-	getFirstAccountModels() {
-		if (this.temporaryAccount?.models) return this.temporaryAccount.models;
-		for (const id of this.accountOrder) {
-			const account = this.accounts.get(id);
-			if (account?.models) return account.models;
-		}
-	}
-	/**
-	* Get account context by index.
-	* Index 0 is the temporary account (if exists), otherwise the first registered account.
-	* Returns null if index is out of bounds.
-	*/
-	getAccountContextByIndex(index) {
-		const allAccounts = [];
-		if (this.temporaryAccount) allAccounts.push(this.temporaryAccount);
-		for (const id of this.accountOrder) {
-			const account = this.accounts.get(id);
-			if (account) allAccounts.push(account);
-		}
-		if (index < 0 || index >= allAccounts.length) return null;
-		return this.toAccountContext(allAccounts[index]);
-	}
-	/**
-	* Get the total number of accounts (including temporary).
-	*/
-	getAccountCount() {
-		return (this.temporaryAccount ? 1 : 0) + this.accountOrder.length;
-	}
-	/**
-	* Convert AccountRuntime to AccountContext for service calls.
-	*/
-	toAccountContext(account) {
-		return {
-			accountLogin: account.accountLogin,
-			githubToken: account.githubToken,
-			copilotToken: account.copilotToken,
-			...account.copilotApiUrl !== void 0 ? { copilotApiUrl: account.copilotApiUrl } : {},
-			accountType: account.accountType,
-			vsCodeVersion: account.vsCodeVersion,
-			clientDeviceId: account.clientDeviceId,
-			clientMachineId: account.clientMachineId,
-			clientSessionId: account.clientSessionId
-		};
-	}
-	/**
-	* Start watching the registry file for changes.
-	* Enables hot reload of accounts when the file is modified.
-	*/
-	startRegistryWatcher() {
-		this.stopRegistryWatcher();
-		try {
-			this.registryWatcher = fs.watch(PATHS.ACCOUNTS_REGISTRY_PATH, (eventType) => {
-				if (eventType === "change") this.scheduleReload();
-			});
-			this.registryWatcherRestartDelayMs = WATCHER_RESTART_INITIAL_DELAY_MS;
-			if (this.registryWatcherRestartTimer) {
-				clearTimeout(this.registryWatcherRestartTimer);
-				this.registryWatcherRestartTimer = void 0;
-			}
-			this.registryWatcher.on("error", (error) => {
-				consola.debug("Registry watcher error:", error);
-				const delayMs = this.registryWatcherRestartDelayMs;
-				this.registryWatcherRestartDelayMs = Math.min(this.registryWatcherRestartDelayMs * 2, WATCHER_RESTART_MAX_DELAY_MS);
-				this.stopRegistryWatcher();
-				this.registryWatcherRestartTimer = setTimeout(() => {
-					this.registryWatcherRestartTimer = void 0;
-					this.startRegistryWatcher();
-				}, delayMs);
-				consola.debug(`Restarting registry watcher in ${delayMs}ms`);
-			});
-			consola.debug("Started registry file watcher");
-		} catch (error) {
-			consola.warn("Failed to start registry watcher:", error);
-		}
-	}
-	/**
-	* Immediately reload the registry, bypassing the debounce delay.
-	* If a reload is already running, waits for it to complete and then
-	* runs another reload to ensure the latest changes are captured.
-	*/
-	async reloadRegistryNow() {
-		if (this.reloadDebounceTimer) {
-			clearTimeout(this.reloadDebounceTimer);
-			this.reloadDebounceTimer = void 0;
-		}
-		if (this.currentReloadPromise) await this.currentReloadPromise;
-		await this.reloadRegistry();
-	}
-	/**
-	* Schedule a registry reload with debouncing.
-	*/
-	scheduleReload() {
-		if (this.reloadDebounceTimer) clearTimeout(this.reloadDebounceTimer);
-		this.reloadDebounceTimer = setTimeout(() => {
-			this.reloadRegistry();
-		}, RELOAD_DEBOUNCE_MS);
-	}
-	/**
-	* Reload the registry and perform incremental updates.
-	* Adds new accounts, removes deleted ones, and reinitializes existing accounts
-	* when token/accountType changes.
-	*/
-	async reloadRegistry() {
-		if (this.isReloading) return;
-		this.isReloading = true;
-		this.currentReloadPromise = (async () => {
-			try {
-				const newMetas = await listAccountsFromRegistry();
-				const newIds = new Set(newMetas.map((m) => m.id));
-				const currentIds = new Set(this.accountOrder);
-				const added = [];
-				const removed = [];
-				const updated = [];
-				this.removeDeletedAccounts(currentIds, newIds, removed);
-				for (const meta of newMetas) if (!currentIds.has(meta.id)) await this.addNewAccount(meta, added);
-				await this.reinitializeUpdatedAccounts(newMetas, currentIds, updated);
-				this.accountOrder = newMetas.map((m) => m.id).filter((id) => this.accounts.has(id));
-				this.loadBalanceCursor = 0;
-				this.logRegistryReloadChanges(added, removed, updated);
-			} catch (error) {
-				consola.error("Failed to reload registry:", error);
-				this.shutdown();
-				process.exit(1);
-			} finally {
-				this.isReloading = false;
-				this.currentReloadPromise = void 0;
-			}
-		})();
-		await this.currentReloadPromise;
-	}
-	removeDeletedAccounts(currentIds, newIds, removed) {
-		for (const id of currentIds) if (!newIds.has(id)) {
-			const account = this.accounts.get(id);
-			if (!account) continue;
-			this.stopTokenRefresh(account);
-			this.stopSessionRefresh(account);
-			this.accounts.delete(id);
-			removed.push(id);
-		}
-	}
-	async reinitializeUpdatedAccounts(newMetas, currentIds, updated) {
-		for (const meta of newMetas) {
-			if (!currentIds.has(meta.id)) continue;
-			const account = this.accounts.get(meta.id);
-			if (!account) continue;
-			const token = await loadAccountToken(meta.id);
-			if (!token) {
-				consola.warn(`No token found for account ${meta.id}, skipping update`);
-				continue;
-			}
-			const accountTypeChanged = account.accountType !== meta.accountType;
-			const tokenChanged = account.githubToken !== token;
-			const addedAtChanged = account.addedAt !== meta.addedAt;
-			if (accountTypeChanged) account.accountType = meta.accountType;
-			if (addedAtChanged) account.addedAt = meta.addedAt;
-			account.accountLogin = meta.id;
-			if (tokenChanged) account.githubToken = token;
-			if (!accountTypeChanged && !tokenChanged) continue;
-			try {
-				await this.initializeAccount(account);
-				updated.push(meta.id);
-			} catch (error) {
-				consola.error(`Failed to reinitialize account ${meta.id} after update:`, error);
-				account.failed = true;
-				account.failureReason = String(error);
-				updated.push(`${meta.id} (failed)`);
-			}
-		}
-	}
-	logRegistryReloadChanges(added, removed, updated) {
-		if (added.length === 0 && removed.length === 0 && updated.length === 0) return;
-		const changes = [];
-		if (added.length > 0) changes.push(`added: ${added.join(", ")}`);
-		if (removed.length > 0) changes.push(`removed: ${removed.join(", ")}`);
-		if (updated.length > 0) changes.push(`updated: ${updated.join(", ")}`);
-		consola.info(`Registry reloaded (${changes.join("; ")}). Total: ${this.accounts.size} account(s)`);
-	}
-	/**
-	* Helper to add a new account during reload.
-	*/
-	async addNewAccount(meta, added) {
-		const token = await loadAccountToken(meta.id);
-		if (!token) {
-			consola.warn(`No token found for new account ${meta.id}, skipping`);
-			return;
-		}
-		const runtime = {
-			...meta,
-			accountLogin: meta.id,
-			githubToken: token,
-			vsCodeVersion: this.vsCodeVersion
-		};
-		try {
-			await this.initializeAccount(runtime);
-			this.accounts.set(meta.id, runtime);
-			added.push(meta.id);
-		} catch (error) {
-			consola.error(`Failed to initialize new account ${meta.id}:`, error);
-			runtime.failed = true;
-			runtime.failureReason = String(error);
-			this.accounts.set(meta.id, runtime);
-			added.push(`${meta.id} (failed)`);
-		}
-	}
-	/**
-	* Stop the registry file watcher.
-	*/
-	stopRegistryWatcher() {
-		if (this.reloadDebounceTimer) {
-			clearTimeout(this.reloadDebounceTimer);
-			this.reloadDebounceTimer = void 0;
-		}
-		if (this.registryWatcherRestartTimer) {
-			clearTimeout(this.registryWatcherRestartTimer);
-			this.registryWatcherRestartTimer = void 0;
-		}
-		if (this.registryWatcher) {
-			this.registryWatcher.close();
-			this.registryWatcher = void 0;
-		}
-	}
-	/**
-	* Shutdown the manager and clean up resources.
-	*/
-	shutdown() {
-		this.stopRegistryWatcher();
-		this.stopAllTokenRefresh();
-		this.stopAllSessionRefresh();
-		this.stopModelsRefresh();
-		this.affinityCache.clear();
-		this.loadBalanceCursor = 0;
-		this.accounts.clear();
-		this.accountOrder = [];
-		this.temporaryAccount = void 0;
-	}
-};
-/** Singleton instance of AccountsManager */
-const accountsManager = new AccountsManager();
-
-//#endregion
-export { isMessagesApiEnabled as _, getClaudeTokenMultiplier as a, mergeConfigWithDefaults as b, getModelAliases as c, getProviderConfig as d, getReasoningEffortForModel as f, isMessageStartInputTokensFallbackEnabled as g, isForceAgentEnabled as h, getAnthropicApiKey as i, getModelAliasesInfo as l, isAccountAffinityEnabled as m, PROVIDER_TYPE_ANTHROPIC as n, getConfig as o, getSmallModel as p, getAliasTargetSet as r, getExtraPromptForModel as s, accountsManager as t, getModelRefreshIntervalMs as u, isResponsesApiContextManagementModel as v, shouldCompactUseSmallModel as x, isResponsesApiWebSearchEnabled as y };
-//# sourceMappingURL=accounts-manager-BE-Dq5Wn.js.map