xiaodcs-copilot-api-edge 2.3.9-edge.0

package/dist/config-SytZjLq8.js

@@ -0,0 +1,544 @@
+import consola from "consola";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+//#region src/lib/atomic-file.ts
+const TEMP_FILE_RANDOM_BYTES = 8;
+const fsyncDirectory = (directory) => {
+	if (process.platform === "win32") return;
+	let directoryFd;
+	try {
+		directoryFd = fs.openSync(directory, "r");
+		fs.fsyncSync(directoryFd);
+	} catch (error) {
+		console.warn(`Failed to fsync directory: ${directory}`, error);
+	} finally {
+		if (directoryFd !== void 0) try {
+			fs.closeSync(directoryFd);
+		} catch {}
+	}
+};
+function writeFileAtomically(filePath, content) {
+	const directory = path.dirname(filePath);
+	const tempPath = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomBytes(TEMP_FILE_RANDOM_BYTES).toString("hex")}.tmp`);
+	fs.mkdirSync(directory, { recursive: true });
+	let fileDescriptor;
+	let tempFileCreated = false;
+	try {
+		fileDescriptor = fs.openSync(tempPath, "wx", 384);
+		tempFileCreated = true;
+		fs.writeFileSync(fileDescriptor, content, "utf8");
+		fs.fsyncSync(fileDescriptor);
+		fs.closeSync(fileDescriptor);
+		fileDescriptor = void 0;
+		fs.renameSync(tempPath, filePath);
+		tempFileCreated = false;
+		fsyncDirectory(directory);
+	} catch (error) {
+		if (fileDescriptor !== void 0) try {
+			fs.closeSync(fileDescriptor);
+		} catch {}
+		if (tempFileCreated) try {
+			fs.rmSync(tempPath, { force: true });
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
+//#region src/lib/paths.ts
+const AUTH_APP = process.env.COPILOT_API_OAUTH_APP?.trim() || "";
+const ENTERPRISE_PREFIX = process.env.COPILOT_API_ENTERPRISE_URL ? "ent_" : "";
+const DEFAULT_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+const APP_DIR = process.env.COPILOT_API_HOME || DEFAULT_DIR;
+const PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH: path.join(APP_DIR, AUTH_APP, ENTERPRISE_PREFIX + "github_token"),
+	CODEX_CREDENTIAL_PATH: path.join(APP_DIR, "codex_credentials.json"),
+	CONFIG_PATH: path.join(APP_DIR, "config.json")
+};
+async function ensurePaths() {
+	await fs$1.mkdir(path.join(PATHS.APP_DIR, AUTH_APP), { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+	await ensureFile(PATHS.CONFIG_PATH);
+}
+async function ensureFile(filePath) {
+	try {
+		await fs$1.access(filePath, fs$1.constants.W_OK);
+	} catch {
+		await fs$1.writeFile(filePath, "");
+		await fs$1.chmod(filePath, 384);
+	}
+}
+//#endregion
+//#region src/lib/config-store.ts
+const defaultResponsesTransportConfig = {
+	headersTimeoutMsV2: 300 * 1e3,
+	streamInactivityTimeoutMs: 300 * 1e3,
+	websocketMaxBufferedBytes: 8 * 1024 * 1024,
+	websocketMaxBufferedMessages: 1024,
+	websocketOpenTimeoutMs: 3e4,
+	websocketPoolIdleTimeoutMs: 6e4
+};
+const SUPPORTED_PROVIDER_TYPES = [
+	"anthropic",
+	"openai-compatible",
+	"openai-responses"
+];
+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 modelResponsesApiCompactThresholds = {
+	"gpt-5.4": 272e3 * .8,
+	"gpt-5.5": 272e3 * .8
+};
+const defaultContextManagement = {
+	messages: true,
+	responses: false
+};
+const defaultConfig = {
+	auth: { apiKeys: [] },
+	providers: {},
+	modelMappings: {},
+	extraPrompts: { "gpt-5-mini": gpt5ExplorationPrompt },
+	smallModel: "gpt-5-mini",
+	contextManagement: defaultContextManagement,
+	modelResponsesApiCompactThresholds,
+	modelReasoningEfforts: { "gpt-5-mini": "low" },
+	useMessagesApi: true,
+	useResponsesApiCompactionRecovery: false,
+	useResponsesApiWebSocket: true,
+	responsesTransport: defaultResponsesTransportConfig,
+	useResponsesApiWebSearch: true,
+	alphaSearchCodexPriority: true,
+	alphaSearchModel: "gpt-5-mini",
+	messageApiWebSearchModel: "gpt-5-mini"
+};
+let cachedConfig = null;
+function normalizeAdminApiKey(adminApiKey) {
+	if (typeof adminApiKey !== "string") {
+		if (adminApiKey !== void 0) consola.warn("Invalid auth.adminApiKey config. Expected a non-empty string.");
+		return null;
+	}
+	const normalizedAdminApiKey = adminApiKey.trim();
+	if (!normalizedAdminApiKey) {
+		consola.warn("Invalid auth.adminApiKey config. Expected a non-empty string.");
+		return null;
+	}
+	return normalizedAdminApiKey;
+}
+function generateAdminApiKey() {
+	return randomBytes(32).toString("hex");
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+function ensureConfigFile() {
+	try {
+		fs.accessSync(PATHS.CONFIG_PATH, fs.constants.R_OK | fs.constants.W_OK);
+	} catch {
+		writeFileAtomically(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`);
+		try {
+			fs.chmodSync(PATHS.CONFIG_PATH, 384);
+		} catch {
+			return;
+		}
+	}
+}
+function readConfigFromDisk() {
+	ensureConfigFile();
+	const raw = fs.readFileSync(PATHS.CONFIG_PATH, "utf8");
+	if (!raw.trim()) {
+		writeFileAtomically(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`);
+		return defaultConfig;
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (error) {
+		const message = `Config file is not valid JSON: ${PATHS.CONFIG_PATH}. Refusing to start with the default config. Fix the JSON syntax or delete the file to regenerate a fresh config.`;
+		consola.error(message, error);
+		throw new Error(message, { cause: error });
+	}
+}
+function readEditableConfigFromDisk() {
+	try {
+		const raw = fs.readFileSync(PATHS.CONFIG_PATH, "utf8");
+		if (!raw.trim()) return {};
+		return JSON.parse(raw);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return {};
+		if (error instanceof SyntaxError) throw new Error(`Config file is not valid JSON: ${PATHS.CONFIG_PATH}`);
+		throw error;
+	}
+}
+function writeConfigToDisk(config) {
+	writeFileAtomically(PATHS.CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`);
+}
+function setConfiguredApiKeys(apiKeys) {
+	const normalizedKeys = apiKeys.map((key) => key.trim()).filter((key) => key.length > 0);
+	const uniqueKeys = [...new Set(normalizedKeys)];
+	const editableConfig = readEditableConfigFromDisk();
+	writeConfigToDisk({
+		...editableConfig,
+		auth: {
+			...editableConfig.auth,
+			apiKeys: uniqueKeys
+		}
+	});
+	reloadConfig();
+	return [...uniqueKeys];
+}
+function mergeDefaultConfig(config) {
+	const extraPrompts = config.extraPrompts ?? {};
+	const defaultExtraPrompts = defaultConfig.extraPrompts ?? {};
+	const responsesApiCompactThresholds = config.modelResponsesApiCompactThresholds ?? {};
+	const defaultResponsesApiCompactThresholds = defaultConfig.modelResponsesApiCompactThresholds ?? {};
+	const modelReasoningEfforts = config.modelReasoningEfforts ?? {};
+	const defaultModelReasoningEfforts = defaultConfig.modelReasoningEfforts ?? {};
+	const contextManagement = normalizeContextManagementConfig(config.contextManagement);
+	const responsesTransport = normalizeResponsesTransportConfig(config.responsesTransport);
+	const defaultContextManagementConfig = defaultConfig.contextManagement ?? {};
+	const missingExtraPromptModels = Object.keys(defaultExtraPrompts).filter((model) => !Object.hasOwn(extraPrompts, model));
+	const missingReasoningEffortModels = Object.keys(defaultModelReasoningEfforts).filter((model) => !Object.hasOwn(modelReasoningEfforts, model));
+	const missingResponsesApiCompactThresholdModels = Object.keys(defaultResponsesApiCompactThresholds).filter((model) => !Object.hasOwn(responsesApiCompactThresholds, model));
+	const missingContextManagementKeys = Object.keys(defaultContextManagementConfig).filter((key) => !Object.hasOwn(contextManagement, key));
+	const hasExtraPromptChanges = missingExtraPromptModels.length > 0;
+	const hasReasoningEffortChanges = missingReasoningEffortModels.length > 0;
+	const hasResponsesApiCompactThresholdChanges = missingResponsesApiCompactThresholdModels.length > 0;
+	const hasContextManagementChanges = missingContextManagementKeys.length > 0;
+	const hasResponsesTransportChanges = Object.entries(responsesTransport).some(([key, value]) => config.responsesTransport?.[key] !== value);
+	if (!hasExtraPromptChanges && !hasReasoningEffortChanges && !hasResponsesApiCompactThresholdChanges && !hasContextManagementChanges && !hasResponsesTransportChanges) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			contextManagement: {
+				...defaultContextManagementConfig,
+				...contextManagement
+			},
+			extraPrompts: {
+				...defaultExtraPrompts,
+				...extraPrompts
+			},
+			modelResponsesApiCompactThresholds: {
+				...defaultResponsesApiCompactThresholds,
+				...responsesApiCompactThresholds
+			},
+			modelReasoningEfforts: {
+				...defaultModelReasoningEfforts,
+				...modelReasoningEfforts
+			},
+			responsesTransport
+		},
+		changed: true
+	};
+}
+function normalizeContextManagementConfig(value) {
+	if (!value || typeof value !== "object") return {};
+	return {
+		...typeof value.messages === "boolean" ? { messages: value.messages } : {},
+		...typeof value.responses === "boolean" ? { responses: value.responses } : {}
+	};
+}
+function ensureAdminApiKey(config) {
+	const normalizedAdminApiKey = normalizeAdminApiKey(config.auth?.adminApiKey);
+	if (normalizedAdminApiKey) {
+		if (config.auth?.adminApiKey === normalizedAdminApiKey) return {
+			mergedConfig: config,
+			changed: false
+		};
+		return {
+			mergedConfig: {
+				...config,
+				auth: {
+					...config.auth,
+					adminApiKey: normalizedAdminApiKey
+				}
+			},
+			changed: true
+		};
+	}
+	const editableConfig = readEditableConfigFromDisk();
+	const { mergedConfig } = mergeDefaultConfig({
+		...editableConfig,
+		auth: {
+			...editableConfig.auth,
+			adminApiKey: generateAdminApiKey()
+		}
+	});
+	return {
+		mergedConfig,
+		changed: true
+	};
+}
+function mergeConfigWithDefaults() {
+	const { mergedConfig, changed } = mergeDefaultConfig(readConfigFromDisk());
+	const { mergedConfig: mergedConfigWithAdminApiKey, changed: adminApiKeyChanged } = ensureAdminApiKey(mergedConfig);
+	if (changed || adminApiKeyChanged) try {
+		writeConfigToDisk(mergedConfigWithAdminApiKey);
+	} catch (writeError) {
+		if (adminApiKeyChanged) throw writeError;
+		consola.warn("Failed to write merged default config to config file", writeError);
+	}
+	cachedConfig = mergedConfigWithAdminApiKey;
+	return mergedConfigWithAdminApiKey;
+}
+function getConfig() {
+	cachedConfig ??= mergeDefaultConfig(readConfigFromDisk()).mergedConfig;
+	return cachedConfig;
+}
+function reloadConfig() {
+	return mergeConfigWithDefaults();
+}
+function isMessagesApiEnabled() {
+	return getConfig().useMessagesApi ?? true;
+}
+function isResponsesApiWebSocketEnabled() {
+	return getConfig().useResponsesApiWebSocket ?? true;
+}
+function getResponsesTransportConfig() {
+	const { headersTimeoutMsV2, ...config } = normalizeResponsesTransportConfig(getConfig().responsesTransport);
+	return {
+		headersTimeoutMs: headersTimeoutMsV2,
+		...config
+	};
+}
+const normalizeResponsesTransportConfig = (configured) => ({
+	headersTimeoutMsV2: positiveIntegerOrDefault(configured?.headersTimeoutMsV2, defaultResponsesTransportConfig.headersTimeoutMsV2),
+	streamInactivityTimeoutMs: positiveIntegerOrDefault(configured?.streamInactivityTimeoutMs, defaultResponsesTransportConfig.streamInactivityTimeoutMs),
+	websocketMaxBufferedBytes: positiveIntegerOrDefault(configured?.websocketMaxBufferedBytes, defaultResponsesTransportConfig.websocketMaxBufferedBytes),
+	websocketMaxBufferedMessages: positiveIntegerOrDefault(configured?.websocketMaxBufferedMessages, defaultResponsesTransportConfig.websocketMaxBufferedMessages),
+	websocketOpenTimeoutMs: positiveIntegerOrDefault(configured?.websocketOpenTimeoutMs, defaultResponsesTransportConfig.websocketOpenTimeoutMs),
+	websocketPoolIdleTimeoutMs: positiveIntegerOrDefault(configured?.websocketPoolIdleTimeoutMs, defaultResponsesTransportConfig.websocketPoolIdleTimeoutMs)
+});
+const positiveIntegerOrDefault = (value, fallback) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const normalized = Math.floor(value);
+	return normalized > 0 ? normalized : fallback;
+};
+function isResponsesApiCompactionRecoveryEnabled() {
+	return getConfig().useResponsesApiCompactionRecovery ?? false;
+}
+function getAnthropicApiKey() {
+	return getConfig().anthropicApiKey ?? process.env.ANTHROPIC_API_KEY ?? void 0;
+}
+function isResponsesApiWebSearchEnabled() {
+	return getConfig().useResponsesApiWebSearch ?? true;
+}
+function isAlphaSearchCodexPriorityEnabled() {
+	return getConfig().alphaSearchCodexPriority ?? true;
+}
+function getAlphaSearchModel() {
+	return (getConfig().alphaSearchModel ?? "gpt-5-mini").trim() || void 0;
+}
+function getMessageApiWebSearchModel() {
+	const model = getConfig().messageApiWebSearchModel ?? "gpt-5-mini";
+	return model && model.trim().length > 0 ? model : void 0;
+}
+function getClaudeAutoModel() {
+	const model = getConfig().claudeAutoModel;
+	return model && model.trim().length > 0 ? model.trim() : void 0;
+}
+function getClaudeTokenMultiplier() {
+	return getConfig().claudeTokenMultiplier ?? 1.15;
+}
+//#endregion
+//#region src/lib/model-policy.ts
+const GPT_MODEL_PATTERN = /^gpt-(\d+)(?:\.(\d+))?/;
+function isGpt53OrAbove(model) {
+	const match = GPT_MODEL_PATTERN.exec(model);
+	if (!match) return false;
+	const majorVersion = Number.parseInt(match[1], 10);
+	if (majorVersion > 5) return true;
+	if (majorVersion !== 5) return false;
+	return (match[2] ? Number.parseInt(match[2], 10) : 0) >= 3;
+}
+function isGpt56OrAbove(model) {
+	const match = GPT_MODEL_PATTERN.exec(model);
+	if (!match) return false;
+	const majorVersion = Number.parseInt(match[1], 10);
+	if (majorVersion > 5) return true;
+	if (majorVersion !== 5) return false;
+	return (match[2] ? Number.parseInt(match[2], 10) : 0) >= 6;
+}
+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.`;
+function getExtraPromptForModel(model) {
+	const userPrompt = getConfig().extraPrompts?.[model];
+	if (userPrompt !== void 0) return userPrompt;
+	return isGpt53OrAbove(model) ? gpt5CommentaryPrompt : "";
+}
+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 validateModelMappings(modelMappings) {
+	const validatedMappings = {};
+	for (const [sourceModel, targetModel] of Object.entries(modelMappings)) {
+		if (!sourceModel || !targetModel) throw new Error("Each model mapping must use non-empty source and target values.");
+		validatedMappings[sourceModel] = targetModel;
+	}
+	return validatedMappings;
+}
+function setModelMappings(modelMappings) {
+	writeConfigToDisk({
+		...readEditableConfigFromDisk(),
+		modelMappings: validateModelMappings(modelMappings)
+	});
+	reloadConfig();
+	return getModelMappings();
+}
+function resolveMappedModel(model) {
+	return getModelMappings()[model] ?? model;
+}
+function getSmallModel() {
+	return getConfig().smallModel ?? "gpt-5-mini";
+}
+function isContextManagementEnabledForMessages() {
+	return getConfig().contextManagement?.messages ?? defaultContextManagement.messages;
+}
+function isContextManagementEnabledForResponses() {
+	return getConfig().contextManagement?.responses ?? defaultContextManagement.responses;
+}
+function getModelResponsesApiCompactThreshold(model) {
+	const threshold = getConfig().modelResponsesApiCompactThresholds?.[model];
+	if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold <= 0) return;
+	return threshold;
+}
+function getReasoningEffortForModel(model) {
+	const userEffort = getConfig().modelReasoningEfforts?.[model];
+	if (userEffort !== void 0) return userEffort;
+	return isGpt53OrAbove(model) ? "xhigh" : "high";
+}
+//#endregion
+//#region src/lib/provider-config.ts
+const OPENCODE_ANTHROPIC_MODEL_PATTERN = /^(?:qwen|minimax)/iu;
+const OPENCODE_RESPONSES_MODEL_PATTERN = /^(?:gpt|grok|muse-spark)(?:[-_.]|$)/iu;
+function normalizeProviderBaseUrl(url) {
+	return url.trim().replace(/\/+$/u, "");
+}
+function isSupportedProviderType(value) {
+	return SUPPORTED_PROVIDER_TYPES.includes(value);
+}
+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 = readEditableConfigFromDisk();
+	writeConfigToDisk({
+		...editableConfig,
+		providers: {
+			...editableConfig.providers,
+			[providerName]: provider
+		}
+	});
+	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 (!isSupportedProviderType(type)) {
+		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,
+		pricingCurrency: normalizePricingCurrency(provider.pricingCurrency),
+		models: provider.models
+	};
+}
+function resolveEffectiveProviderType(providerConfig, model) {
+	const modelConfig = providerConfig.models?.[model];
+	if (modelConfig?.type && isSupportedProviderType(modelConfig.type)) return modelConfig.type;
+	if (providerConfig.name === "opencode-go") {
+		if (OPENCODE_ANTHROPIC_MODEL_PATTERN.test(model)) return "anthropic";
+		if (OPENCODE_RESPONSES_MODEL_PATTERN.test(model)) return "openai-responses";
+	}
+	return providerConfig.type;
+}
+function normalizePricingCurrency(value) {
+	return value?.trim().toUpperCase() || void 0;
+}
+function listEnabledProviders() {
+	const config = getConfig();
+	return Object.keys(config.providers ?? {}).filter((name) => getProviderConfig(name) !== null);
+}
+function isReservedProviderName(name) {
+	return name.trim() === "copilot";
+}
+//#endregion
+export { isResponsesApiWebSearchEnabled as A, getClaudeTokenMultiplier as C, isAlphaSearchCodexPriorityEnabled as D, getResponsesTransportConfig as E, ensurePaths as F, mergeConfigWithDefaults as M, setConfiguredApiKeys as N, isMessagesApiEnabled as O, PATHS as P, getClaudeAutoModel as S, getMessageApiWebSearchModel as T, resolveMappedModel as _, normalizeProviderBaseUrl as a, getAlphaSearchModel as b, setProviderConfig as c, getModelResponsesApiCompactThreshold as d, getReasoningEffortForModel as f, isGpt56OrAbove as g, isContextManagementEnabledForResponses as h, listEnabledProviders as i, isResponsesApiWebSocketEnabled as j, isResponsesApiCompactionRecoveryEnabled as k, getExtraPromptForModel as l, isContextManagementEnabledForMessages as m, getRawProviderConfig as n, resolveEffectiveProviderType as o, getSmallModel as p, isSupportedProviderType as r, resolveProviderAuthType as s, getProviderConfig as t, getModelMappings as u, setModelMappings as v, getConfig as w, getAnthropicApiKey as x, SUPPORTED_PROVIDER_TYPES as y };

package/dist/debug-BFadhEB4.js

@@ -0,0 +1,90 @@
+import { P as PATHS, i as listEnabledProviders, n as getRawProviderConfig } from "./config-SytZjLq8.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+import fs from "node:fs/promises";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+//#region src/debug.ts
+async function getPackageVersion() {
+	try {
+		const packageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+		return JSON.parse(await fs.readFile(packageJsonPath)).version;
+	} catch {
+		return "unknown";
+	}
+}
+function getRuntimeInfo() {
+	const isBun = typeof Bun !== "undefined";
+	return {
+		name: isBun ? "bun" : "node",
+		version: isBun ? Bun.version : process.version.slice(1),
+		platform: os.platform(),
+		arch: os.arch()
+	};
+}
+async function checkFileExists(filePath) {
+	try {
+		if (!(await fs.stat(filePath)).isFile()) return false;
+		return (await fs.readFile(filePath, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function getDebugInfo() {
+	const [version, tokenExists] = await Promise.all([getPackageVersion(), checkFileExists(PATHS.GITHUB_TOKEN_PATH)]);
+	return {
+		providers: {
+			codexConfigured: getRawProviderConfig("codex") !== null,
+			enabled: listEnabledProviders()
+		},
+		version,
+		runtime: getRuntimeInfo(),
+		paths: {
+			APP_DIR: PATHS.APP_DIR,
+			CONFIG_PATH: PATHS.CONFIG_PATH,
+			GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH
+		},
+		tokenExists
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`copilot-api debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Providers:
+- enabled: ${info.providers.enabled.join(", ") || "none"}
+- codex configured: ${info.providers.codexConfigured ? "Yes" : "No"}
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- CONFIG_PATH: ${info.paths.CONFIG_PATH}
+- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
+
+GitHub token exists: ${info.tokenExists ? "Yes" : "No"}`);
+}
+function printDebugInfoJson(info) {
+	console.log(JSON.stringify(info, null, 2));
+}
+async function runDebug(options) {
+	const debugInfo = await getDebugInfo();
+	if (options.json) printDebugInfoJson(debugInfo);
+	else printDebugInfoPlain(debugInfo);
+}
+const debug = defineCommand({
+	meta: {
+		name: "debug",
+		description: "Print debug information about the application"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output debug information as JSON"
+	} },
+	run({ args }) {
+		return runDebug({ json: args.json });
+	}
+});
+//#endregion
+export { debug };

package/dist/electron-fetch-BRX-ug5E.js

@@ -0,0 +1,20 @@
+import { createRequire } from "node:module";
+import consola from "consola";
+//#region src/lib/electron-fetch.ts
+const require = createRequire(import.meta.url);
+function bindElectronFetch() {
+	if (!process.versions.electron) return false;
+	try {
+		const electronModule = require("electron");
+		const netFetch = electronModule.net?.fetch;
+		if (typeof netFetch !== "function") return false;
+		globalThis.fetch = netFetch.bind(electronModule.net);
+		consola.log("Successfully bound Electron's net.fetch to global fetch.");
+		return true;
+	} catch {
+		consola.log("Failed to bind Electron's net.fetch. Falling back to global fetch.");
+		return false;
+	}
+}
+//#endregion
+export { bindElectronFetch };

package/dist/fast-path-BoMnZCVC.js

@@ -0,0 +1,9 @@
+/**
+* Only a direct `copilot-api mcp` invocation takes the fast path. Global flags
+* before the subcommand (e.g. `--api-home`) or help flags after it route to
+* citty through the regular startup path. Any other trailing args after `mcp`
+* are ignored because the MCP server consumes no CLI options.
+*/
+const isMcpFastPath = (argv) => argv[2] === "mcp" && !argv.slice(3).some((argument) => argument === "-h" || argument === "--help");
+//#endregion
+export { isMcpFastPath as t };