@nick3/copilot-api 1.10.9 → 1.10.30

package/dist/config-XZv75uoU.js

@@ -0,0 +1,591 @@
+import { t as PATHS } from "./paths-Bpsb62LK.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 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:  
+- 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,
+		"gpt-5.5": gpt5CommentaryPrompt
+	},
+	smallModel: "gpt-5-mini",
+	accountAffinity: true,
+	useResponsesApiContextManagement: true,
+	modelReasoningEfforts: {
+		"gpt-5-mini": "low",
+		"gpt-5.3-codex": "xhigh",
+		"gpt-5.4-mini": "xhigh",
+		"gpt-5.4": "xhigh",
+		"gpt-5.5": "xhigh"
+	},
+	allowOriginalModelNamesForAliases: false,
+	modelMappings: {},
+	forceAgent: false,
+	compactUseSmallModel: true,
+	messageStartInputTokensFallback: false,
+	modelRefreshIntervalHours: 24,
+	sessionAffinityRetentionDays: 7,
+	useMessagesApi: true,
+	useResponsesApiWebSocket: true,
+	useResponsesApiWebSearch: true,
+	logLevel: "info",
+	devMode: {
+		enabled: false,
+		capture4xx: false,
+		capture5xx: false,
+		captureOther: false
+	},
+	quotaRefresh: DEFAULT_QUOTA_REFRESH_CONFIG
+};
+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 normalizeNonNegativeNumber(value) {
+	if (typeof value !== "number") return void 0;
+	if (!Number.isFinite(value)) return void 0;
+	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",
+	"info",
+	"debug"
+]);
+function normalizeLogLevel(value) {
+	if (typeof value !== "string") return void 0;
+	return LOG_LEVELS.has(value) ? value : void 0;
+}
+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 writeConfigToDisk(config) {
+	fs.mkdirSync(PATHS.APP_DIR, { recursive: true });
+	fs.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+function reloadConfig() {
+	return mergeConfigWithDefaults();
+}
+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 (normalizeNonNegativeNumber(config.modelRefreshIntervalHours) !== void 0) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			modelRefreshIntervalHours: defaultConfig.modelRefreshIntervalHours ?? 24
+		},
+		changed: true
+	};
+}
+function mergeDefaultSessionAffinityRetention(config) {
+	if (normalizeNonNegativeNumber(config.sessionAffinityRetentionDays) !== void 0) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			sessionAffinityRetentionDays: defaultConfig.sessionAffinityRetentionDays ?? 7
+		},
+		changed: true
+	};
+}
+function mergeDefaultLogLevel(config) {
+	if (normalizeLogLevel(config.logLevel) !== void 0) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			logLevel: defaultConfig.logLevel ?? "info"
+		},
+		changed: true
+	};
+}
+function mergeDefaultDevMode(config) {
+	const current = config.devMode;
+	if (current && typeof current.enabled === "boolean" && typeof current.capture4xx === "boolean" && typeof current.capture5xx === "boolean" && typeof current.captureOther === "boolean") return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			devMode: {
+				enabled: current?.enabled === true,
+				capture4xx: current?.capture4xx === true,
+				capture5xx: current?.capture5xx === true,
+				captureOther: current?.captureOther === true
+			}
+		},
+		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);
+		return {
+			mergedConfig: result.mergedConfig,
+			changed: acc.changed || result.changed
+		};
+	}, {
+		mergedConfig: config,
+		changed: false
+	});
+}
+function mergeConfigWithDefaults() {
+	const { mergedConfig, changed } = applyConfigMerges(readConfigFromDisk(), [
+		mergeDefaultAuth,
+		mergeDefaultConfig,
+		mergeDefaultAccountAffinity,
+		mergeDefaultModelRefreshInterval,
+		mergeDefaultSessionAffinityRetention,
+		mergeDefaultLogLevel,
+		mergeDefaultDevMode,
+		mergeDefaultQuotaRefresh
+	]);
+	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 ??= mergeDefaultConfig(readConfigFromDisk()).mergedConfig;
+	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 = normalizeAliasTarget(value);
+		return normalizedTarget ? { target: normalizedTarget } : 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 getModelMappings() {
+	const modelMappings = getConfig().modelMappings;
+	if (!modelMappings) return { ...defaultConfig.modelMappings };
+	const validMappings = {};
+	for (const [sourceModel, targetModel] of Object.entries(modelMappings)) {
+		if (!sourceModel || typeof targetModel !== "string" || targetModel.length === 0) continue;
+		validMappings[sourceModel] = targetModel;
+	}
+	return validMappings;
+}
+function resolveMappedModel(model) {
+	return getModelMappings()[model] ?? model;
+}
+function getSmallModel() {
+	const model = getConfig().smallModel ?? "gpt-5-mini";
+	if (isOriginalModelNameAllowedForTarget(model)) return model;
+	return getPreferredAliasForTarget(model) ?? model;
+}
+function getLogLevel() {
+	return normalizeLogLevel(getConfig().logLevel) ?? defaultConfig.logLevel ?? "info";
+}
+function isAccountAffinityEnabled() {
+	return getConfig().accountAffinity ?? true;
+}
+function getModelRefreshIntervalHours() {
+	return normalizeNonNegativeNumber(getConfig().modelRefreshIntervalHours) ?? defaultConfig.modelRefreshIntervalHours ?? 24;
+}
+function getModelRefreshIntervalMs() {
+	const hours = getModelRefreshIntervalHours();
+	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;
+}
+function getSessionAffinityRetentionMs() {
+	const days = getSessionAffinityRetentionDays();
+	if (!Number.isFinite(days) || days <= 0) return 0;
+	return days * 24 * 60 * 60 * 1e3;
+}
+function isMessageStartInputTokensFallbackEnabled() {
+	return getConfig().messageStartInputTokensFallback ?? false;
+}
+function shouldCompactUseSmallModel() {
+	return getConfig().compactUseSmallModel ?? true;
+}
+function isResponsesApiContextManagementEnabled() {
+	return getConfig().useResponsesApiContextManagement ?? true;
+}
+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 getDefaultProviderAuthType(providerType) {
+	return providerType === "anthropic" ? "x-api-key" : "authorization";
+}
+function resolveProviderAuthType(providerName, authType, providerType) {
+	const defaultAuthType = getDefaultProviderAuthType(providerType);
+	if (authType === void 0) return defaultAuthType;
+	if (authType === "x-api-key") return "x-api-key";
+	if (authType === "oauth2") {
+		if (providerName === "codex") return authType;
+		consola.warn(`Provider ${providerName} has authType 'oauth2', which is only supported by the builtin codex provider, falling back to ${defaultAuthType}`);
+		return defaultAuthType;
+	}
+	if (authType === "authorization") return authType;
+	consola.warn(`Provider ${providerName} has invalid authType '${authType}', falling back to ${defaultAuthType}`);
+	return defaultAuthType;
+}
+function isProviderApiKeyRequired(providerName, authType) {
+	return !(providerName === "codex" && authType === "oauth2");
+}
+function getRawProviderConfig(name) {
+	const providerName = name.trim();
+	if (!providerName) return null;
+	return getConfig().providers?.[providerName] ?? null;
+}
+function setProviderConfig(name, provider) {
+	const providerName = name.trim();
+	if (!providerName) throw new Error("Provider name must be a non-empty string");
+	if (isReservedProviderName(providerName)) throw new Error(`Provider ${providerName} is reserved and cannot be configured in config.providers`);
+	const editableConfig = readConfigFromDisk();
+	writeConfigToDisk({
+		...editableConfig,
+		providers: {
+			...editableConfig.providers,
+			[providerName]: provider
+		}
+	});
+	cachedConfig = reloadConfig();
+	return getRawProviderConfig(providerName) ?? provider;
+}
+function getProviderConfig(name) {
+	const providerName = name.trim();
+	if (!providerName) return null;
+	if (isReservedProviderName(providerName)) {
+		consola.warn(`Provider ${providerName} is reserved and cannot be configured in config.providers`);
+		return null;
+	}
+	const provider = getRawProviderConfig(providerName);
+	if (!provider) return null;
+	if (provider.enabled === false) return null;
+	const type = provider.type ?? "anthropic";
+	if (type !== "anthropic" && type !== "openai-compatible" && type !== "openai-responses") {
+		consola.warn(`Provider ${providerName} is ignored because type '${type}' is not supported`);
+		return null;
+	}
+	const baseUrl = normalizeProviderBaseUrl(provider.baseUrl ?? "");
+	const authType = resolveProviderAuthType(providerName, provider.authType, type);
+	const apiKey = (provider.apiKey ?? "").trim();
+	const missingFields = [...!baseUrl ? ["baseUrl"] : [], ...isProviderApiKeyRequired(providerName, authType) && !apiKey ? ["apiKey"] : []];
+	if (missingFields.length > 0) {
+		consola.warn(`Provider ${providerName} is enabled but missing ${missingFields.join(" or ")}`);
+		return null;
+	}
+	return {
+		name: providerName,
+		type,
+		baseUrl,
+		apiKey,
+		authType,
+		models: provider.models,
+		adjustInputTokens: provider.adjustInputTokens
+	};
+}
+function listEnabledProviders() {
+	const config = getConfig();
+	return Object.keys(config.providers ?? {}).filter((name) => getProviderConfig(name) !== null);
+}
+function isReservedProviderName(name) {
+	return name.trim() === "copilot";
+}
+function isMessagesApiEnabled() {
+	return getConfig().useMessagesApi ?? true;
+}
+function isResponsesApiWebSocketEnabled() {
+	return getConfig().useResponsesApiWebSocket ?? 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
+export { isResponsesApiWebSocketEnabled as C, resolveModelAlias as D, resolveMappedModel as E, setProviderConfig as O, isResponsesApiWebSearchEnabled as S, mergeConfigWithDefaults as T, isAccountAffinityEnabled as _, getConfig as a, isMessagesApiEnabled as b, getModelAliases as c, getProviderConfig as d, getQuotaRefreshConfig as f, getSmallModel as g, getSessionAffinityRetentionMs as h, getClaudeTokenMultiplier as i, shouldCompactUseSmallModel as k, getModelAliasesInfo as l, getReasoningEffortForModel as m, getAliasTargetSet as n, getExtraPromptForModel as o, getRawProviderConfig as p, getAnthropicApiKey as r, getLogLevel as s, PROVIDER_TYPE_ANTHROPIC as t, getModelRefreshIntervalMs as u, isForceAgentEnabled as v, listEnabledProviders as w, isResponsesApiContextManagementEnabled as x, isMessageStartInputTokensFallbackEnabled as y };
+
+//# sourceMappingURL=config-XZv75uoU.js.map