@jeffreycao/copilot-api 1.10.9 → 1.10.11

package/dist/token-BVXHiYEl.js

@@ -0,0 +1,1875 @@
+import { p as isResponsesApiWebSocketEnabled, s as getRawProviderConfig, v as setProviderConfig, y as PATHS } from "./config-ztdkLu9o.js";
+import consola from "consola";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import fs, { readFile } from "node:fs/promises";
+import { networkInterfaces } from "node:os";
+import path from "node:path";
+import { Agent, ProxyAgent, WebSocket, setGlobalDispatcher } from "undici";
+import { getProxyForUrl } from "proxy-from-env";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { exec } from "node:child_process";
+//#region src/lib/codex-rate-limit.ts
+const codexRateLimitScopes = ["primary", "secondary"];
+const formatCodexRateLimitResetAt = (resetAt) => {
+	const date = /* @__PURE__ */ new Date(resetAt * 1e3);
+	return Number.isNaN(date.getTime()) ? String(resetAt) : date.toLocaleString();
+};
+const logCodexRateLimitsEvent = (event) => {
+	if (!event || typeof event !== "object") return;
+	const eventRecord = event;
+	if (eventRecord.type !== "codex.rate_limits") return;
+	const rateLimits = eventRecord.rate_limits;
+	if (!rateLimits || typeof rateLimits !== "object") return;
+	const planType = typeof eventRecord.plan_type === "string" ? eventRecord.plan_type : null;
+	const rateLimitRecord = rateLimits;
+	const allowed = typeof rateLimitRecord.allowed === "boolean" ? rateLimitRecord.allowed : null;
+	const limitReached = typeof rateLimitRecord.limit_reached === "boolean" ? rateLimitRecord.limit_reached : null;
+	for (const scope of codexRateLimitScopes) {
+		const window = rateLimitRecord[scope];
+		if (!isCodexRateLimitWindow(window)) continue;
+		const summary = [];
+		if (allowed !== null) summary.push(`allowed=${allowed}`);
+		if (limitReached !== null) summary.push(`limit_reached=${limitReached}`);
+		summary.push(`used=${window.used_percent}%`, `reset_at=${formatCodexRateLimitResetAt(window.reset_at)}`);
+		const label = planType ? `Codex ${scope} rate limit (${planType})` : `Codex ${scope} rate limit`;
+		consola.log(`${label}: ${summary.join(", ")}`);
+	}
+};
+const isCodexRateLimitWindow = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.reset_after_seconds === "number" && typeof record.reset_at === "number" && typeof record.used_percent === "number" && typeof record.window_minutes === "number";
+};
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	accountType: "individual",
+	manualApprove: false,
+	rateLimitWait: false,
+	showToken: false,
+	verbose: false,
+	vsCodeDeviceId: randomUUID()
+};
+//#endregion
+//#region src/lib/proxy.ts
+let proxyEnvDispatcher;
+function getProxyEnvDispatcher() {
+	return proxyEnvDispatcher;
+}
+function initProxyFromEnv() {
+	try {
+		const direct = new Agent();
+		const proxies = /* @__PURE__ */ new Map();
+		proxyEnvDispatcher = {
+			dispatch(options, handler) {
+				try {
+					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
+					const raw = getProxyForUrl(origin.toString());
+					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
+					if (!proxyUrl) {
+						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+						return direct.dispatch(options, handler);
+					}
+					let agent = proxies.get(proxyUrl);
+					if (!agent) {
+						agent = new ProxyAgent(proxyUrl);
+						proxies.set(proxyUrl, agent);
+					}
+					let label = proxyUrl;
+					try {
+						const u = new URL(proxyUrl);
+						label = `${u.protocol}//${u.host}`;
+					} catch {}
+					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
+					return agent.dispatch(options, handler);
+				} catch {
+					return direct.dispatch(options, handler);
+				}
+			},
+			close() {
+				return direct.close();
+			},
+			destroy() {
+				return direct.destroy();
+			}
+		};
+		if (typeof Bun !== "undefined") {
+			consola.debug("WebSocket proxy configured from environment (per-URL)");
+			return;
+		}
+		setGlobalDispatcher(proxyEnvDispatcher);
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
+	}
+}
+//#endregion
+//#region src/services/responses-websocket.ts
+const DEFAULT_WEBSOCKET_IDLE_TIMEOUT_MS = 6e4;
+const websocketPool = /* @__PURE__ */ new Map();
+const websocketActiveRequests = /* @__PURE__ */ new Map();
+const createWebSocketUrl = (url) => {
+	const websocketUrl = new URL(url);
+	if (websocketUrl.protocol === "https:") websocketUrl.protocol = "wss:";
+	else if (websocketUrl.protocol === "http:") websocketUrl.protocol = "ws:";
+	return websocketUrl.toString();
+};
+const createPooledWebSocketStream = (request, options) => runPooledWebSocketRequest(request, options);
+const runPooledWebSocketRequest = async function* (request, options) {
+	const { entry, pooled } = getPooledWebSocketRequestTarget(request, options);
+	const release = acquirePooledWebSocketEntry(request.poolKey, entry, pooled, options);
+	try {
+		const websocket = await getReadyPooledWebSocket(request.poolKey, entry, pooled, options);
+		websocket.send(JSON.stringify(request.payload));
+		for await (const data of createWebSocketMessageStream(websocket, options)) {
+			const chunk = options.createChunk(data);
+			yield chunk;
+			if (options.isTerminalChunk(chunk)) return;
+		}
+		removePooledWebSocketEntry(request.poolKey, entry);
+		throw new Error(options.terminalChunkMissingMessage);
+	} catch (error) {
+		removePooledWebSocketEntry(request.poolKey, entry);
+		throw toError(error);
+	} finally {
+		release();
+	}
+};
+const getPooledWebSocketRequestTarget = (request, options) => {
+	if (getPooledWebSocketActiveRequestCount(request.poolKey) > 0) return {
+		entry: createPooledWebSocketEntry(request, options),
+		pooled: false
+	};
+	const existing = websocketPool.get(request.poolKey);
+	if (existing && !existing.closed) {
+		clearPooledWebSocketIdleTimer(existing);
+		return {
+			entry: existing,
+			pooled: true
+		};
+	}
+	const entry = createPooledWebSocketEntry(request, options);
+	websocketPool.set(request.poolKey, entry);
+	return {
+		entry,
+		pooled: true
+	};
+};
+const createPooledWebSocketEntry = (request, options) => {
+	const entry = {
+		closed: false,
+		idleTimer: null,
+		requestCount: 0,
+		websocketPromise: openWebSocket({
+			headers: request.headers,
+			openErrorMessage: options.openErrorMessage,
+			url: request.url
+		})
+	};
+	entry.websocketPromise.then((websocket) => {
+		websocket.addEventListener("close", () => {
+			removePooledWebSocketEntry(request.poolKey, entry);
+		});
+		websocket.addEventListener("error", () => {
+			removePooledWebSocketEntry(request.poolKey, entry);
+		});
+	}).catch(() => {
+		removePooledWebSocketEntry(request.poolKey, entry);
+	});
+	return entry;
+};
+const acquirePooledWebSocketEntry = (poolKey, entry, pooled, options) => {
+	clearPooledWebSocketIdleTimer(entry);
+	incrementPooledWebSocketActiveRequestCount(poolKey);
+	entry.requestCount += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		entry.requestCount -= 1;
+		decrementPooledWebSocketActiveRequestCount(poolKey);
+		if (entry.closed || entry.requestCount > 0) return;
+		if (pooled && websocketPool.get(poolKey) === entry) {
+			schedulePooledWebSocketIdleClose(poolKey, entry, options);
+			return;
+		}
+		removePooledWebSocketEntry(poolKey, entry);
+	};
+};
+const getReadyPooledWebSocket = async (poolKey, entry, pooled, options) => {
+	const unavailableErrorMessage = options?.unavailableErrorMessage ?? "Websocket connection became unavailable before the request started";
+	if (entry.closed) throw new Error(unavailableErrorMessage);
+	const websocket = await entry.websocketPromise;
+	if (entry.closed || pooled && websocketPool.get(poolKey) !== entry) throw new Error(unavailableErrorMessage);
+	if (websocket.readyState !== WebSocket.OPEN) {
+		removePooledWebSocketEntry(poolKey, entry);
+		throw new Error(unavailableErrorMessage);
+	}
+	return websocket;
+};
+const schedulePooledWebSocketIdleClose = (poolKey, entry, options) => {
+	clearPooledWebSocketIdleTimer(entry);
+	entry.idleTimer = setTimeout(() => {
+		removePooledWebSocketEntry(poolKey, entry);
+	}, options.idleTimeoutMs ?? DEFAULT_WEBSOCKET_IDLE_TIMEOUT_MS);
+	unrefTimer(entry.idleTimer);
+};
+const clearPooledWebSocketIdleTimer = (entry) => {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+		entry.idleTimer = null;
+	}
+};
+const getPooledWebSocketActiveRequestCount = (poolKey) => websocketActiveRequests.get(poolKey) ?? 0;
+const incrementPooledWebSocketActiveRequestCount = (poolKey) => {
+	websocketActiveRequests.set(poolKey, getPooledWebSocketActiveRequestCount(poolKey) + 1);
+};
+const decrementPooledWebSocketActiveRequestCount = (poolKey) => {
+	const nextCount = getPooledWebSocketActiveRequestCount(poolKey) - 1;
+	if (nextCount <= 0) {
+		websocketActiveRequests.delete(poolKey);
+		return;
+	}
+	websocketActiveRequests.set(poolKey, nextCount);
+};
+const removePooledWebSocketEntry = (poolKey, entry) => {
+	if (websocketPool.get(poolKey) === entry) websocketPool.delete(poolKey);
+	if (entry.closed) return;
+	entry.closed = true;
+	clearPooledWebSocketIdleTimer(entry);
+	entry.websocketPromise.then(closeWebSocket).catch(() => {});
+};
+const unrefTimer = (timer) => {
+	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
+};
+const createWebSocketError = (message, event) => {
+	const reason = event?.error ?? event?.message;
+	if (reason === void 0 || reason === "") return new Error(message);
+	const cause = toError(reason);
+	return new Error(`${message}: ${cause.message}`, { cause });
+};
+const openWebSocket = async ({ headers, openErrorMessage, url }) => await new Promise((resolve, reject) => {
+	const dispatcher = getProxyEnvDispatcher();
+	const websocket = new WebSocket(url, dispatcher ? {
+		dispatcher,
+		headers
+	} : { headers });
+	const cleanup = () => {
+		websocket.removeEventListener("open", onOpen);
+		websocket.removeEventListener("error", onError);
+	};
+	const onOpen = () => {
+		cleanup();
+		resolve(websocket);
+	};
+	const onError = (event) => {
+		cleanup();
+		reject(createWebSocketError(openErrorMessage, event));
+	};
+	websocket.addEventListener("open", onOpen);
+	websocket.addEventListener("error", onError);
+});
+const createWebSocketMessageStream = async function* (websocket, options) {
+	const queue = [];
+	let closed = false;
+	let error = null;
+	let notify = null;
+	const wake = () => {
+		notify?.();
+		notify = null;
+	};
+	const onMessage = (event) => {
+		queue.push(normalizeWebSocketMessageData(event.data));
+		wake();
+	};
+	const onClose = () => {
+		closed = true;
+		wake();
+	};
+	const onError = (event) => {
+		error = createWebSocketError(options.streamErrorMessage, event);
+		wake();
+	};
+	websocket.addEventListener("message", onMessage);
+	websocket.addEventListener("close", onClose);
+	websocket.addEventListener("error", onError);
+	try {
+		while (true) {
+			const item = queue.shift();
+			if (item) {
+				yield await item;
+				continue;
+			}
+			if (error) throw toError(error);
+			if (closed) break;
+			await new Promise((resolve) => {
+				notify = resolve;
+			});
+		}
+	} finally {
+		websocket.removeEventListener("message", onMessage);
+		websocket.removeEventListener("close", onClose);
+		websocket.removeEventListener("error", onError);
+	}
+};
+const normalizeWebSocketMessageData = async (data) => {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) {
+		const view = data;
+		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+	}
+	if (isTextReadable(data)) return await data.text();
+	return String(data);
+};
+const isTextReadable = (value) => {
+	if (!value || typeof value !== "object" || !("text" in value)) return false;
+	return typeof value.text === "function";
+};
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	return new Error(String(value));
+};
+const closeWebSocket = (websocket) => {
+	if (websocket.readyState === WebSocket.CONNECTING || websocket.readyState === WebSocket.OPEN) websocket.close();
+};
+//#endregion
+//#region src/lib/request-context.ts
+const TRACE_ID_MAX_LENGTH = 64;
+const TRACE_ID_PATTERN = /^\w[\w.-]*$/;
+const asyncLocalStorage = new AsyncLocalStorage();
+const requestContext = {
+	getStore: () => asyncLocalStorage.getStore(),
+	run: (context, callback) => asyncLocalStorage.run(context, callback)
+};
+function generateTraceId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function resolveTraceId(traceId) {
+	const candidate = traceId?.trim();
+	if (!candidate || candidate.length > TRACE_ID_MAX_LENGTH || !TRACE_ID_PATTERN.test(candidate)) return generateTraceId();
+	return candidate;
+}
+//#endregion
+//#region src/services/codex/create-responses.ts
+const CODEX_API_BASE_URL = "https://chatgpt.com/backend-api";
+const STRIPPED_CODEX_REQUEST_HEADERS = new Set([
+	"authorization",
+	"connection",
+	"content-length",
+	"host",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"x-api-key"
+]);
+const STRIPPED_CODEX_WEBSOCKET_HEADERS = new Set(["accept", "content-type"]);
+const CODEX_RESPONSE_STATUSES = new Set([
+	"completed",
+	"incomplete",
+	"failed",
+	"cancelled",
+	"queued",
+	"in_progress"
+]);
+const requireCodexAuthContext = () => {
+	const accessToken = state.codexAccessToken;
+	const accountId = state.codexAccountId;
+	if (!accessToken) throw new Error("Codex access token is not loaded");
+	if (!accountId) throw new Error("Codex account id is not loaded");
+	return {
+		accessToken,
+		accountId
+	};
+};
+function resolveCodexResponsesUrl(baseUrl = CODEX_API_BASE_URL) {
+	const normalized = baseUrl.trim().replace(/\/+$/, "");
+	if (!normalized) return `${CODEX_API_BASE_URL}/codex/responses`;
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+function buildCodexResponsesHeaders(requestHeaders, options = {}) {
+	const { accessToken, accountId } = requireCodexAuthContext();
+	const headers = new Headers();
+	for (const [headerName, headerValue] of requestHeaders) {
+		const headerNameLower = headerName.toLowerCase();
+		if (STRIPPED_CODEX_REQUEST_HEADERS.has(headerNameLower)) continue;
+		headers.set(headerName, headerValue);
+	}
+	if (!headers.has("accept")) headers.set("accept", options.stream ? "text/event-stream" : "application/json");
+	headers.set("authorization", `Bearer ${accessToken}`);
+	headers.set("chatgpt-account-id", accountId);
+	if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	if (!headers.has("OpenAI-Beta")) headers.set("OpenAI-Beta", "responses=experimental");
+	if (!headers.has("originator")) headers.set("originator", "copilot-api");
+	if (!headers.has("user-agent")) headers.set("user-agent", "copilot-api");
+	if (headers.get("user-agent")?.startsWith("opencode")) {
+		headers.set("originator", "opencode");
+		const sessionId = requestContext.getStore()?.sessionAffinity;
+		if (sessionId) headers.set("session_id", sessionId);
+	}
+	return headers;
+}
+function resolveCodexResponsesTransport(transport) {
+	return transport ?? (isResponsesApiWebSocketEnabled() ? "websocket" : "http");
+}
+function buildCodexResponsesWebSocketHeaders(requestHeaders) {
+	const headers = buildCodexResponsesHeaders(requestHeaders);
+	for (const headerName of STRIPPED_CODEX_WEBSOCKET_HEADERS) headers.delete(headerName);
+	return Object.fromEntries(headers);
+}
+function buildCodexResponsesWebSocketPayload(payload) {
+	const websocketPayload = {
+		...payload,
+		type: "response.create"
+	};
+	delete websocketPayload.stream;
+	return websocketPayload;
+}
+function buildCodexResponsesWebSocketUrl(baseUrl = CODEX_API_BASE_URL) {
+	return createWebSocketUrl(resolveCodexResponsesUrl(baseUrl));
+}
+function prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl = CODEX_API_BASE_URL) {
+	const headers = buildCodexResponsesWebSocketHeaders(requestHeaders);
+	return {
+		headers,
+		payload: buildCodexResponsesWebSocketPayload(payload),
+		poolKey: buildCodexResponsesWebSocketPoolKey(payload, headers, baseUrl),
+		url: buildCodexResponsesWebSocketUrl(baseUrl)
+	};
+}
+async function forwardCodexResponses(payload, requestHeaders, baseUrl = CODEX_API_BASE_URL, options = {}) {
+	const normalizedPayload = {
+		...payload,
+		store: false,
+		temperature: void 0,
+		top_p: void 0,
+		max_output_tokens: void 0,
+		metadata: void 0
+	};
+	if (normalizedPayload.stream && resolveCodexResponsesTransport(options.transport) === "websocket") return await forwardCodexResponsesOverWebSocket(normalizedPayload, requestHeaders, baseUrl);
+	return await fetch(resolveCodexResponsesUrl(baseUrl), {
+		method: "POST",
+		headers: buildCodexResponsesHeaders(requestHeaders, { stream: normalizedPayload.stream }),
+		body: JSON.stringify(normalizedPayload)
+	});
+}
+const buildCodexResponsesWebSocketPoolKey = (payload, headers, baseUrl) => {
+	const authFingerprint = createHash("sha256").update(`${state.codexAccessToken ?? "missing-token"}:${state.codexAccountId ?? "missing-account"}`).digest("hex").slice(0, 16);
+	const headerFingerprint = createHash("sha256").update(JSON.stringify(Object.entries(headers).sort(([left], [right]) => left.localeCompare(right)))).digest("hex").slice(0, 16);
+	return [
+		"codex",
+		resolveCodexResponsesUrl(baseUrl),
+		payload.model,
+		authFingerprint,
+		headerFingerprint
+	].map(encodePoolKeyPart).join("|");
+};
+const forwardCodexResponsesOverWebSocket = async (payload, requestHeaders, baseUrl) => {
+	const stream = createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl));
+	if (payload.stream) return createCodexResponsesWebSocketProxyResponse(stream);
+	const response = await consumeCodexResponsesWebSocketStream(stream);
+	return new Response(JSON.stringify(response), {
+		headers: { "content-type": "application/json; charset=utf-8" },
+		status: 200
+	});
+};
+const createCodexResponsesWebSocketStream = (request) => createPooledWebSocketStream(request, {
+	createChunk: createCodexResponsesWebSocketStreamChunk,
+	isTerminalChunk: isTerminalCodexResponsesWebSocketChunk,
+	openErrorMessage: "Failed to create codex responses websocket",
+	streamErrorMessage: "Codex responses websocket stream error",
+	terminalChunkMissingMessage: "Codex responses websocket ended without a terminal response"
+});
+const createCodexResponsesWebSocketStreamChunk = (data) => {
+	if (data === "[DONE]") return { data };
+	try {
+		const parsed = JSON.parse(data);
+		return {
+			data: JSON.stringify(parsed),
+			event: typeof parsed.type === "string" ? parsed.type : void 0,
+			id: typeof parsed.id === "string" ? parsed.id : void 0
+		};
+	} catch {
+		return { data };
+	}
+};
+const isTerminalCodexResponsesWebSocketChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return false;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		return parsed.type === "response.completed" || parsed.type === "response.done" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
+	} catch {
+		return false;
+	}
+};
+const consumeCodexResponsesWebSocketStream = async (stream) => {
+	for await (const chunk of stream) {
+		if (!chunk.data || chunk.data === "[DONE]") continue;
+		const event = JSON.parse(chunk.data);
+		if (event.type === "error") throw new Error(typeof event.message === "string" ? event.message : "Codex responses websocket returned an error event");
+		if ((event.type === "response.completed" || event.type === "response.done") && event.response) return event.response;
+		if ((event.type === "response.failed" || event.type === "response.incomplete") && event.response) return event.response;
+	}
+	throw new Error("Codex responses websocket ended without a terminal response");
+};
+const createCodexResponsesWebSocketProxyResponse = (stream) => {
+	return new Response(createServerSentEventStream(normalizeCodexResponsesWebSocketStream(stream)), {
+		headers: {
+			"cache-control": "no-cache",
+			"content-type": "text/event-stream; charset=utf-8"
+		},
+		status: 200
+	});
+};
+const createStandardizedCodexResponsesEventStream = (source) => {
+	return createServerSentEventStream(normalizeCodexResponsesStandardStream(source));
+};
+const normalizeCodexResponsesWebSocketStream = async function* (stream) {
+	for await (const chunk of stream) yield normalizeCodexResponsesProxyChunk(chunk);
+};
+const normalizeCodexResponsesStandardStream = async function* (stream) {
+	for await (const chunk of stream) yield normalizeCodexResponsesStandardChunk(chunk);
+};
+const normalizeCodexResponsesProxyChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return chunk;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		if (parsed.type !== "response.completed") return chunk;
+		return {
+			...chunk,
+			data: JSON.stringify({
+				...parsed,
+				type: "response.done"
+			}),
+			event: "response.done"
+		};
+	} catch {
+		return chunk;
+	}
+};
+const normalizeCodexResponsesStandardChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return chunk;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		logCodexRateLimitsEvent(parsed);
+		const normalized = normalizeCodexResponsesEvent(parsed);
+		if (!normalized) return chunk;
+		return {
+			...chunk,
+			data: JSON.stringify(normalized),
+			event: normalized.type
+		};
+	} catch {
+		return chunk;
+	}
+};
+const createServerSentEventStream = (source) => {
+	const encoder = new TextEncoder();
+	const iterator = source[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async cancel() {
+			await iterator.return?.();
+		},
+		async pull(controller) {
+			try {
+				const result = await iterator.next();
+				if (result.done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(encoder.encode(serializeServerSentEvent(result.value)));
+			} catch (error) {
+				controller.enqueue(encoder.encode(serializeServerSentEvent(createResponsesErrorServerSentEventChunk(getErrorMessage(error)))));
+				controller.close();
+			}
+		}
+	});
+};
+const createResponsesErrorServerSentEventChunk = (message) => {
+	const errorEvent = {
+		code: null,
+		message,
+		param: null,
+		sequence_number: 0,
+		type: "error"
+	};
+	return {
+		data: JSON.stringify(errorEvent),
+		event: errorEvent.type
+	};
+};
+const serializeServerSentEvent = (chunk) => {
+	const lines = [];
+	if (chunk.id) lines.push(`id: ${chunk.id}`);
+	if (chunk.event) lines.push(`event: ${chunk.event}`);
+	if (chunk.data !== void 0) for (const line of String(chunk.data).split(/\r?\n/u)) lines.push(`data: ${line}`);
+	return `${lines.join("\n")}\n\n`;
+};
+const getErrorMessage = (error) => {
+	if (error instanceof Error && error.message) return error.message;
+	return String(error);
+};
+const encodePoolKeyPart = (value) => encodeURIComponent(value);
+function normalizeCodexResponseStatus(status) {
+	return typeof status === "string" && CODEX_RESPONSE_STATUSES.has(status) ? status : void 0;
+}
+function normalizeCodexResponseRecord(eventRecord) {
+	const response = eventRecord.response;
+	if (!response || typeof response !== "object") return eventRecord;
+	const normalizedStatus = normalizeCodexResponseStatus(response.status);
+	if (!normalizedStatus) return eventRecord;
+	return {
+		...eventRecord,
+		response: {
+			...response,
+			status: normalizedStatus
+		}
+	};
+}
+function normalizeCodexResponsesEvent(event) {
+	if (!event || typeof event !== "object") return null;
+	const eventRecord = normalizeCodexResponseRecord(event);
+	const type = eventRecord.type;
+	if (typeof type !== "string") return null;
+	if (type === "response.done") return {
+		...eventRecord,
+		type: "response.completed"
+	};
+	return eventRecord;
+}
+//#endregion
+//#region src/lib/oauth/codex.ts
+const CALLBACK_HOST = "127.0.0.1";
+const CALLBACK_PORT = 1455;
+const CALLBACK_PATH = "/auth/callback";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
+const TOKEN_URL = "https://auth.openai.com/oauth/token";
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+const SCOPE = "openid profile email offline_access";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const REFRESH_BUFFER_MS = 6e4;
+function base64UrlEncode(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+async function generatePkce() {
+	const verifierBytes = new Uint8Array(32);
+	crypto.getRandomValues(verifierBytes);
+	const verifier = base64UrlEncode(verifierBytes);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+	return {
+		verifier,
+		challenge: base64UrlEncode(new Uint8Array(hashBuffer))
+	};
+}
+function createState() {
+	return randomBytes(16).toString("hex");
+}
+function parseAuthorizationInput(input) {
+	const value = input.trim();
+	if (!value) return {};
+	try {
+		const url = new URL(value);
+		return {
+			code: url.searchParams.get("code") ?? void 0,
+			state: url.searchParams.get("state") ?? void 0
+		};
+	} catch {}
+	if (value.includes("#")) {
+		const [code, state] = value.split("#", 2);
+		return {
+			code,
+			state
+		};
+	}
+	if (value.includes("code=")) {
+		const params = new URLSearchParams(value);
+		return {
+			code: params.get("code") ?? void 0,
+			state: params.get("state") ?? void 0
+		};
+	}
+	return { code: value };
+}
+function decodeJwt(accessToken) {
+	try {
+		const payload = accessToken.split(".")[1];
+		if (!payload) return null;
+		return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+	} catch {
+		return null;
+	}
+}
+function getAccountId(accessToken) {
+	const payload = decodeJwt(accessToken);
+	if (!payload) return null;
+	const authPayload = payload[JWT_CLAIM_PATH];
+	if (!authPayload || typeof authPayload !== "object") return null;
+	const accountId = authPayload.chatgpt_account_id;
+	return typeof accountId === "string" && accountId ? accountId : null;
+}
+function renderOAuthPage(options) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(options.title)}</title>
+  <style>
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      background: #09090b;
+      color: #fafafa;
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      text-align: center;
+    }
+    main {
+      max-width: 560px;
+    }
+    h1 {
+      margin: 0 0 12px;
+      font-size: 28px;
+      line-height: 1.15;
+    }
+    p {
+      margin: 0;
+      color: #a1a1aa;
+      line-height: 1.6;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>${escapeHtml(options.heading)}</h1>
+    <p>${escapeHtml(options.message)}</p>
+  </main>
+</body>
+</html>`;
+}
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function renderOAuthSuccessPage(message) {
+	return renderOAuthPage({
+		title: "Authentication successful",
+		heading: "Authentication successful",
+		message
+	});
+}
+function renderOAuthErrorPage(message) {
+	return renderOAuthPage({
+		title: "Authentication failed",
+		heading: "Authentication failed",
+		message
+	});
+}
+async function exchangeAuthorizationCode(code, verifier) {
+	const response = await fetch(TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "authorization_code",
+			client_id: CLIENT_ID,
+			code,
+			code_verifier: verifier,
+			redirect_uri: REDIRECT_URI
+		})
+	});
+	if (!response.ok) {
+		const details = await response.text().catch(() => "");
+		throw new Error(`Codex token exchange failed (${response.status}): ${details || response.statusText}`);
+	}
+	const payload = await response.json();
+	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError(`Codex token exchange response missing fields: ${JSON.stringify(payload)}`);
+	return {
+		accessToken: payload.access_token,
+		refreshToken: payload.refresh_token,
+		expiresAt: Date.now() + payload.expires_in * 1e3
+	};
+}
+async function refreshAccessToken(refreshToken) {
+	const response = await fetch(TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID
+		})
+	});
+	if (!response.ok) {
+		const details = await response.text().catch(() => "");
+		throw new Error(`Codex token refresh failed (${response.status}): ${details || response.statusText}`);
+	}
+	const payload = await response.json();
+	if (typeof payload.access_token !== "string" || typeof payload.refresh_token !== "string" || typeof payload.expires_in !== "number") throw new TypeError(`Codex token refresh response missing fields: ${JSON.stringify(payload)}`);
+	return {
+		accessToken: payload.access_token,
+		refreshToken: payload.refresh_token,
+		expiresAt: Date.now() + payload.expires_in * 1e3
+	};
+}
+async function createAuthorizationFlow() {
+	const { verifier, challenge } = await generatePkce();
+	const state = createState();
+	const url = new URL(AUTHORIZE_URL);
+	url.searchParams.set("response_type", "code");
+	url.searchParams.set("client_id", CLIENT_ID);
+	url.searchParams.set("redirect_uri", REDIRECT_URI);
+	url.searchParams.set("scope", SCOPE);
+	url.searchParams.set("code_challenge", challenge);
+	url.searchParams.set("code_challenge_method", "S256");
+	url.searchParams.set("state", state);
+	url.searchParams.set("id_token_add_organizations", "true");
+	url.searchParams.set("codex_cli_simplified_flow", "true");
+	url.searchParams.set("originator", "copilot-api");
+	return {
+		verifier,
+		state,
+		url: url.toString()
+	};
+}
+async function waitForAuthorizationCode(state) {
+	let resolveCode;
+	const waitForCode = new Promise((resolve) => {
+		resolveCode = resolve;
+	});
+	const server = createServer((request, response) => {
+		try {
+			const url = new URL(request.url || "", "http://localhost");
+			if (url.pathname !== CALLBACK_PATH) {
+				response.statusCode = 404;
+				response.setHeader("Content-Type", "text/html; charset=utf-8");
+				response.end(renderOAuthErrorPage("Callback route not found."));
+				return;
+			}
+			if (url.searchParams.get("state") !== state) {
+				response.statusCode = 400;
+				response.setHeader("Content-Type", "text/html; charset=utf-8");
+				response.end(renderOAuthErrorPage("State mismatch."));
+				return;
+			}
+			const code = url.searchParams.get("code");
+			if (!code) {
+				response.statusCode = 400;
+				response.setHeader("Content-Type", "text/html; charset=utf-8");
+				response.end(renderOAuthErrorPage("Missing authorization code."));
+				return;
+			}
+			response.statusCode = 200;
+			response.setHeader("Content-Type", "text/html; charset=utf-8");
+			response.end(renderOAuthSuccessPage("OpenAI Codex authentication completed. You can close this window."));
+			resolveCode?.(code);
+		} catch {
+			response.statusCode = 500;
+			response.setHeader("Content-Type", "text/html; charset=utf-8");
+			response.end(renderOAuthErrorPage("Internal error while processing OAuth callback."));
+		}
+	});
+	try {
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+	} catch {
+		return null;
+	}
+	try {
+		return await waitForCode;
+	} finally {
+		await new Promise((resolve, reject) => {
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		}).catch(() => void 0);
+	}
+}
+async function loginCodex(options) {
+	const { verifier, state, url } = await createAuthorizationFlow();
+	options.onAuth({
+		url,
+		instructions: "Please complete the login in the browser. If the browser does not automatically redirect, please paste the callback URL or code back to the terminal."
+	});
+	options.onProgress?.("Waiting for Codex OAuth callback");
+	let code = await waitForAuthorizationCode(state);
+	if (!code) {
+		const parsed = parseAuthorizationInput(await options.onPrompt("Paste the authorization code or full redirect URL:"));
+		if (parsed.state && parsed.state !== state) throw new Error("Codex OAuth state mismatch");
+		code = parsed.code ?? null;
+	}
+	if (!code) throw new Error("Missing Codex authorization code");
+	const tokenResult = await exchangeAuthorizationCode(code, verifier);
+	const accountId = getAccountId(tokenResult.accessToken);
+	if (!accountId) throw new Error("Failed to extract Codex account id from access token");
+	return {
+		accessToken: tokenResult.accessToken,
+		refreshToken: tokenResult.refreshToken,
+		expiresAt: tokenResult.expiresAt,
+		accountId
+	};
+}
+async function refreshCodexCredentials(credentials) {
+	const tokenResult = await refreshAccessToken(credentials.refreshToken);
+	const accountId = getAccountId(tokenResult.accessToken);
+	if (!accountId) throw new Error("Failed to extract Codex account id from access token");
+	return {
+		accessToken: tokenResult.accessToken,
+		refreshToken: tokenResult.refreshToken,
+		expiresAt: tokenResult.expiresAt,
+		accountId
+	};
+}
+function isCodexCredentialsExpired(credentials, now = Date.now()) {
+	return credentials.expiresAt <= now + REFRESH_BUFFER_MS;
+}
+const compactSystemPromptStarts = ["You are a helpful AI assistant tasked with summarizing conversations", "You are an anchored context summarization assistant for coding sessions."];
+const compactTextOnlyGuard = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";
+const compactSummaryPromptStart = "Your task is to create a detailed summary of the conversation so far";
+const compactAutoContinuePromptStarts = [
+	"This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.",
+	"Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.",
+	"The previous request exceeded the provider's size limit due to large media attachments. The conversation was compacted and media files were removed from context."
+];
+const compactMessageSections = ["Pending Tasks:", "Current Work:"];
+//#endregion
+//#region src/lib/opencode.ts
+const execAsync = (command) => {
+	return new Promise((resolve, reject) => {
+		exec(command, (error, stdout) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(stdout);
+		});
+	});
+};
+let opencodeVersionCache;
+const getGlobalNpmRoot = async () => {
+	return (await execAsync("npm root -g")).trim();
+};
+async function resolveOpencodeVersion() {
+	try {
+		const npmRootPath = await getGlobalNpmRoot();
+		const packageJson = await readFile(path.join(npmRootPath, "opencode-ai", "package.json"), "utf8");
+		const { version } = JSON.parse(packageJson);
+		opencodeVersionCache = version;
+	} catch (error) {
+		consola.warn(`Failed to resolve opencode version`, error);
+	}
+}
+const initOpencodeVersion = () => {
+	if (process.env.COPILOT_API_OAUTH_APP?.trim() !== "opencode") return Promise.resolve();
+	return resolveOpencodeVersion();
+};
+const getCachedOpencodeVersion = () => {
+	return opencodeVersionCache;
+};
+//#endregion
+//#region src/lib/api-config.ts
+const isOpencodeOauthApp = () => {
+	return process.env.COPILOT_API_OAUTH_APP?.trim() === "opencode";
+};
+const normalizeDomain = (input) => {
+	return input.trim().replace(/^https?:\/\//u, "").replace(/\/+$/u, "");
+};
+const getEnterpriseDomain = () => {
+	const raw = (process.env.COPILOT_API_ENTERPRISE_URL ?? "").trim();
+	if (!raw) return null;
+	return normalizeDomain(raw) || null;
+};
+const getGitHubBaseUrl = () => {
+	const resolvedDomain = getEnterpriseDomain();
+	return resolvedDomain ? `https://${resolvedDomain}` : GITHUB_BASE_URL;
+};
+const getGitHubApiBaseUrl = () => {
+	const resolvedDomain = getEnterpriseDomain();
+	return resolvedDomain ? `https://api.${resolvedDomain}` : GITHUB_API_BASE_URL;
+};
+const getOpencodeOauthHeaders = () => {
+	return {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+		"User-Agent": getOpencodeVersion()
+	};
+};
+const getOpencodeLLMHeaders = () => {
+	return {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+		"User-Agent": OPENCODE_LLM_USER_AGENT
+	};
+};
+const normalizeOpencodeUserAgent = (userAgent) => {
+	const candidate = userAgent.trim();
+	const opencodeProduct = candidate.match(/^opencode\/[^\s,]+/u)?.[0];
+	if (!opencodeProduct || candidate.includes(`, ${opencodeProduct}`)) return candidate;
+	return `${candidate}, ${opencodeProduct}`;
+};
+const getOauthUrls = () => {
+	const githubBaseUrl = getGitHubBaseUrl();
+	return {
+		deviceCodeUrl: `${githubBaseUrl}/login/device/code`,
+		accessTokenUrl: `${githubBaseUrl}/login/oauth/access_token`
+	};
+};
+const getOauthAppConfig = () => {
+	if (isOpencodeOauthApp()) return {
+		clientId: OPENCODE_GITHUB_CLIENT_ID,
+		headers: getOpencodeOauthHeaders(),
+		scope: GITHUB_APP_SCOPES
+	};
+	return {
+		clientId: GITHUB_CLIENT_ID,
+		headers: standardHeaders(),
+		scope: GITHUB_APP_SCOPES
+	};
+};
+const prepareForCompact = (headers, compactType) => {
+	if (compactType) {
+		headers["x-initiator"] = "agent";
+		if (!isOpencodeOauthApp() && compactType === 1) {
+			headers["x-interaction-type"] = "conversation-compaction";
+			headers["openai-intent"] = "conversation-agent";
+		}
+	}
+};
+const prepareInteractionHeaders = (sessionId, isSubagent, headers) => {
+	const sendInteractionHeaders = !isOpencodeOauthApp();
+	if (isSubagent) {
+		headers["x-initiator"] = "agent";
+		if (sendInteractionHeaders) headers["x-interaction-type"] = "conversation-subagent";
+	}
+	if (sessionId && sendInteractionHeaders) headers["x-interaction-id"] = sessionId;
+};
+const standardHeaders = () => ({
+	"content-type": "application/json",
+	accept: "application/json"
+});
+const getOpencodeVersion = () => {
+	const version = getCachedOpencodeVersion();
+	if (version) return "opencode/" + version;
+	return OPENCODE_VERSION;
+};
+const OPENCODE_VERSION = "opencode/1.14.29";
+const OPENCODE_LLM_USER_AGENT = "opencode/1.14.29 ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.13, opencode/1.14.29";
+const COPILOT_VERSION = "0.47.1";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+const CLAUDE_AGENT_USER_AGENT = "vscode_claude_code/2.1.112 (external, sdk-ts, agent-sdk/0.2.112)";
+const EDITOR_WEBSOCKET_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const API_VERSION = "2026-01-09";
+const WEBSOCKET_API_VERSION = API_VERSION;
+const copilotBaseUrl = (state) => {
+	const enterpriseDomain = getEnterpriseDomain();
+	if (enterpriseDomain) return `https://copilot-api.${enterpriseDomain}`;
+	if (isOpencodeOauthApp()) return "https://api.githubcopilot.com";
+	if (state.copilotApiUrl) return state.copilotApiUrl;
+	return state.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state.accountType}.githubcopilot.com`;
+};
+const prepareMessageProxyHeaders = (headers) => {
+	if (isOpencodeOauthApp()) return;
+	const requestIdValue = randomUUID();
+	headers["x-agent-task-id"] = requestIdValue;
+	headers["x-request-id"] = requestIdValue;
+	headers["x-interaction-type"] = "messages-proxy";
+	headers["openai-intent"] = "messages-proxy";
+	headers["user-agent"] = CLAUDE_AGENT_USER_AGENT;
+	delete headers["copilot-integration-id"];
+};
+const githubUserHeaders = (state) => {
+	if (isOpencodeOauthApp()) return {
+		Authorization: `Bearer ${state.githubToken}`,
+		"User-Agent": getOpencodeVersion()
+	};
+	return {
+		accept: "application/vnd.github+json",
+		authorization: `token ${state.githubToken}`,
+		"user-agent": USER_AGENT,
+		"x-github-api-version": "2022-11-28",
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	};
+};
+const copilotModelsHeaders = (state) => {
+	if (isOpencodeOauthApp()) return {
+		Authorization: `Bearer ${state.copilotToken}`,
+		"User-Agent": getOpencodeVersion()
+	};
+	const headers = githubCopilotHeaders(state);
+	headers["x-interaction-type"] = "model-access";
+	headers["openai-intent"] = "model-access";
+	delete headers["x-interaction-id"];
+	delete headers["content-type"];
+	return headers;
+};
+const copilotHeaders = (state, requestId, vision = false) => {
+	if (isOpencodeOauthApp()) {
+		const headers = {
+			Authorization: `Bearer ${state.copilotToken}`,
+			...getOpencodeLLMHeaders(),
+			"Openai-Intent": "conversation-edits"
+		};
+		const store = requestContext.getStore();
+		const userAgent = store?.userAgent.trim();
+		if (userAgent?.startsWith("opencode/")) headers["User-Agent"] = normalizeOpencodeUserAgent(userAgent);
+		if (store?.sessionAffinity) headers["x-session-affinity"] = store.sessionAffinity;
+		if (store?.parentSessionId) headers["x-parent-session-id"] = store.parentSessionId;
+		if (vision) headers["Copilot-Vision-Request"] = "true";
+		return headers;
+	}
+	return githubCopilotHeaders(state, requestId, vision);
+};
+const copilotWebSocketHeaders = (preparedHeaders) => {
+	if (isOpencodeOauthApp()) return omitHeader(preparedHeaders, "x-initiator");
+	const requestId = getPreparedHeader(preparedHeaders, "x-request-id") ?? randomUUID();
+	const source = createHeaderResolver(preparedHeaders);
+	const headers = {
+		Authorization: source("authorization"),
+		"X-Request-Id": requestId,
+		"OpenAI-Intent": source("openai-intent", "conversation-agent"),
+		"X-GitHub-Api-Version": source("x-github-api-version", WEBSOCKET_API_VERSION),
+		"X-Interaction-Id": source("x-interaction-id", requestId),
+		"X-Interaction-Type": source("x-interaction-type", "conversation-agent"),
+		"X-Agent-Task-Id": source("x-agent-task-id", requestId)
+	};
+	setPreparedHeader(headers, "VScode-SessionId", preparedHeaders, "vscode-sessionid");
+	setPreparedHeader(headers, "VScode-MachineId", preparedHeaders, "vscode-machineid");
+	Object.assign(headers, {
+		"Editor-Device-Id": source("editor-device-id"),
+		"Editor-Plugin-Version": source("editor-plugin-version", EDITOR_WEBSOCKET_PLUGIN_VERSION),
+		"Editor-Version": source("editor-version"),
+		"Copilot-Integration-Id": source("copilot-integration-id", "vscode-chat")
+	});
+	setPreparedHeader(headers, "Copilot-Vision-Request", preparedHeaders, "copilot-vision-request");
+	headers["user-agent"] = "node";
+	return headers;
+};
+const createHeaderResolver = (headers) => (headerName, fallback = "") => getPreparedHeader(headers, headerName) ?? fallback;
+const getPreparedHeader = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
+};
+const setPreparedHeader = (target, targetHeaderName, source, sourceHeaderName) => {
+	const value = getPreparedHeader(source, sourceHeaderName);
+	if (value) target[targetHeaderName] = value;
+};
+const omitHeader = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== normalizedHeaderName));
+};
+const githubCopilotHeaders = (state, requestId, vision = false) => {
+	const requestIdValue = requestId ?? randomUUID();
+	const headers = {
+		Authorization: `Bearer ${state.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": "vscode-chat",
+		"editor-device-id": state.vsCodeDeviceId,
+		"editor-version": `vscode/${state.vsCodeVersion}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"user-agent": USER_AGENT,
+		"openai-intent": "conversation-agent",
+		"x-github-api-version": API_VERSION,
+		"x-request-id": requestIdValue,
+		"x-vscode-user-agent-library-version": "electron-fetch",
+		"x-agent-task-id": requestIdValue,
+		"x-interaction-type": "conversation-agent"
+	};
+	if (vision) headers["copilot-vision-request"] = "true";
+	if (state.macMachineId) headers["vscode-machineid"] = state.macMachineId;
+	if (state.vsCodeSessionId) headers["vscode-sessionid"] = state.vsCodeSessionId;
+	return headers;
+};
+const GITHUB_API_BASE_URL = "https://api.github.com";
+const githubHeaders = (state) => {
+	if (isOpencodeOauthApp()) return {
+		Authorization: `Bearer ${state.githubToken}`,
+		...getOpencodeOauthHeaders()
+	};
+	return {
+		authorization: `token ${state.githubToken}`,
+		"user-agent": USER_AGENT,
+		"x-github-api-version": "2025-04-01",
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	};
+};
+const GITHUB_BASE_URL = "https://github.com";
+const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const OPENCODE_GITHUB_CLIENT_ID = "Ov23li8tweQw6odWQebz";
+//#endregion
+//#region src/lib/credential-store.ts
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+async function readOptionalFile(filePath) {
+	try {
+		return await fs.readFile(filePath, "utf8");
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function writeProtectedFile(filePath, content) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, content, "utf8");
+	try {
+		await fs.chmod(filePath, 384);
+	} catch {
+		return;
+	}
+}
+function normalizeCodexCredentials(credentials) {
+	if (!credentials || typeof credentials !== "object") return null;
+	const candidate = credentials;
+	if (typeof candidate.accessToken !== "string" || typeof candidate.refreshToken !== "string" || typeof candidate.expiresAt !== "number" || typeof candidate.accountId !== "string") return null;
+	return {
+		accessToken: candidate.accessToken,
+		refreshToken: candidate.refreshToken,
+		expiresAt: candidate.expiresAt,
+		accountId: candidate.accountId
+	};
+}
+async function readGitHubToken() {
+	return (await readOptionalFile(PATHS.GITHUB_TOKEN_PATH))?.trim() || null;
+}
+async function writeGitHubToken(token) {
+	await writeProtectedFile(PATHS.GITHUB_TOKEN_PATH, token.trim());
+}
+async function readCodexCredentials() {
+	const raw = await readOptionalFile(PATHS.CODEX_CREDENTIAL_PATH);
+	if (!raw?.trim()) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`Codex credentials file is not valid JSON: ${PATHS.CODEX_CREDENTIAL_PATH}`, { cause: error });
+	}
+	const credentials = normalizeCodexCredentials(parsed);
+	if (!credentials) throw new Error(`Codex credentials file is missing required fields: ${PATHS.CODEX_CREDENTIAL_PATH}`);
+	return credentials;
+}
+async function writeCodexCredentials(credentials) {
+	await writeProtectedFile(PATHS.CODEX_CREDENTIAL_PATH, `${JSON.stringify(credentials, null, 2)}\n`);
+}
+//#endregion
+//#region src/lib/error.ts
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+async function forwardError(c, error) {
+	consola.error("Error occurred:", error);
+	if (error instanceof HTTPError) {
+		if (error.response.status === 429) for (const [name, value] of error.response.headers) {
+			const lowerName = name.toLowerCase();
+			if (lowerName === "retry-after" || lowerName.startsWith("x-")) c.header(name, value);
+		}
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = errorText;
+		}
+		consola.error("HTTP error:", errorJson);
+		return c.json({ error: {
+			message: errorText,
+			type: "error"
+		} }, error.response.status);
+	}
+	return c.json({ error: {
+		message: error.message,
+		type: "error"
+	} }, 500);
+}
+//#endregion
+//#region src/services/github/get-copilot-token.ts
+const getCopilotToken = async () => {
+	const response = await fetch(`${getGitHubApiBaseUrl()}/copilot_internal/v2/token`, { headers: githubHeaders(state) });
+	if (!response.ok) {
+		const errorText = await response.clone().text();
+		consola.error("Failed to get Copilot token response body", errorText);
+		throw new HTTPError("Failed to get Copilot token", response);
+	}
+	return await response.json();
+};
+//#endregion
+//#region src/services/github/get-copilot-usage.ts
+const getCopilotUsage = async (githubToken) => {
+	const resolvedGithubToken = githubToken ?? state.githubToken;
+	if (!resolvedGithubToken) throw new Error("GitHub token not found");
+	const authState = {
+		...state,
+		githubToken: resolvedGithubToken
+	};
+	const response = await fetch(`${getGitHubApiBaseUrl()}/copilot_internal/user`, { headers: githubHeaders(authState) });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
+	return await response.json();
+};
+//#endregion
+//#region src/services/github/get-device-code.ts
+async function getDeviceCode() {
+	const { clientId, headers, scope } = getOauthAppConfig();
+	const { deviceCodeUrl } = getOauthUrls();
+	const response = await fetch(deviceCodeUrl, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			client_id: clientId,
+			scope
+		})
+	});
+	if (!response.ok) throw new HTTPError("Failed to get device code", response);
+	return await response.json();
+}
+//#endregion
+//#region src/services/github/get-user.ts
+async function getGitHubUser(githubToken) {
+	const resolvedGithubToken = githubToken ?? state.githubToken;
+	if (!resolvedGithubToken) throw new Error("GitHub token not found");
+	const authState = {
+		...state,
+		githubToken: resolvedGithubToken
+	};
+	const response = await fetch(`${getGitHubApiBaseUrl()}/user`, { headers: githubUserHeaders(authState) });
+	if (!response.ok) throw new HTTPError("Failed to get GitHub user", response);
+	return await response.json();
+}
+//#endregion
+//#region src/services/copilot/get-models.ts
+const getModels = async () => {
+	consola.info(`Fetching models from ${copilotBaseUrl(state)}/models`);
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotModelsHeaders(state) });
+	if (!response.ok) {
+		const errorText = await response.clone().text();
+		consola.error("Failed to get models response body", errorText);
+		throw new HTTPError("Failed to get models", response);
+	}
+	return await response.json();
+};
+//#endregion
+//#region src/services/get-vscode-version.ts
+const FALLBACK = "1.119.1";
+async function getVSCodeVersion() {
+	await Promise.resolve();
+	return FALLBACK;
+}
+//#endregion
+//#region src/lib/deviceid.ts
+const WINDOWS_DEVICE_ID_KEY = String.raw`\SOFTWARE\Microsoft\DeveloperTools`;
+const WINDOWS_DEVICE_ID_NAME = "deviceid";
+const windows64Architectures = new Set([
+	"AMD64",
+	"ARM64",
+	"IA64"
+]);
+const getPosixHomeDir = () => {
+	if (!process.env.HOME) throw new Error("Home directory not found");
+	return process.env.HOME;
+};
+const getDeviceIdFilePath = () => {
+	let folder;
+	switch (process.platform) {
+		case "darwin":
+			folder = path.posix.join(getPosixHomeDir(), "Library", "Application Support");
+			break;
+		case "linux":
+			folder = process.env.XDG_CACHE_HOME ?? path.posix.join(getPosixHomeDir(), ".cache");
+			break;
+		default: throw new Error("Unsupported platform");
+	}
+	return path.posix.join(folder, "Microsoft", "DeveloperTools", "deviceid");
+};
+const isMissingFileError = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
+const readStoredDeviceIdFile = async (filePath) => {
+	const { readFile } = await import("node:fs/promises");
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return;
+		throw error;
+	}
+};
+const writeStoredDeviceIdFile = async (filePath, deviceId) => {
+	const { mkdir, writeFile } = await import("node:fs/promises");
+	await mkdir(path.posix.dirname(filePath), { recursive: true });
+	await writeFile(filePath, deviceId, "utf8");
+};
+const getWindowsRegistryArch = () => {
+	const architecture = (process.env.PROCESSOR_ARCHITEW6432 ?? process.env.PROCESSOR_ARCHITECTURE)?.toUpperCase();
+	return architecture && windows64Architectures.has(architecture) ? "x64" : void 0;
+};
+const loadWinreg = async () => {
+	const module = await import("winreg");
+	return "default" in module ? module.default : module;
+};
+const isMissingRegistryError = (error) => {
+	if (!error) return false;
+	const errorCode = Number(error.code);
+	return Number.isFinite(errorCode) && errorCode === 1;
+};
+const createWindowsRegistry = async () => {
+	const Winreg = await loadWinreg();
+	return {
+		registry: new Winreg({
+			hive: Winreg.HKCU,
+			key: WINDOWS_DEVICE_ID_KEY,
+			arch: getWindowsRegistryArch()
+		}),
+		regSz: Winreg.REG_SZ
+	};
+};
+const readRegistryString = async (registry, name) => {
+	return new Promise((resolve, reject) => {
+		registry.get(name, (error, item) => {
+			if (isMissingRegistryError(error)) {
+				resolve(void 0);
+				return;
+			}
+			if (error) {
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown registry error"));
+				return;
+			}
+			resolve(item?.value);
+		});
+	});
+};
+const writeRegistryString = async ({ registry, regSz, name, value }) => {
+	return new Promise((resolve, reject) => {
+		registry.set(name, regSz, value, (error) => {
+			if (error) {
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown registry error"));
+				return;
+			}
+			resolve();
+		});
+	});
+};
+const getStoredVSCodeDeviceId = async () => {
+	switch (process.platform) {
+		case "win32": {
+			const { registry } = await createWindowsRegistry();
+			return readRegistryString(registry, WINDOWS_DEVICE_ID_NAME);
+		}
+		case "darwin":
+		case "linux": return readStoredDeviceIdFile(getDeviceIdFilePath());
+		default: throw new Error("Unsupported platform");
+	}
+};
+const setStoredVSCodeDeviceId = async (deviceId) => {
+	switch (process.platform) {
+		case "win32": {
+			const { registry, regSz } = await createWindowsRegistry();
+			await writeRegistryString({
+				registry,
+				regSz,
+				name: WINDOWS_DEVICE_ID_NAME,
+				value: deviceId
+			});
+			return;
+		}
+		case "darwin":
+		case "linux":
+			await writeStoredDeviceIdFile(getDeviceIdFilePath(), deviceId);
+			return;
+		default: throw new Error("Unsupported platform");
+	}
+};
+const createVSCodeDeviceId = () => randomUUID().toLowerCase();
+async function getVSCodeDeviceId() {
+	let deviceId;
+	try {
+		deviceId = await getStoredVSCodeDeviceId();
+	} catch (error) {
+		consola.debug("Failed to read VSCode device id", error);
+	}
+	if (deviceId) return deviceId;
+	const newDeviceId = createVSCodeDeviceId();
+	try {
+		await setStoredVSCodeDeviceId(newDeviceId);
+	} catch (error) {
+		consola.warn("Failed to persist VSCode device id, using ephemeral id", error);
+	}
+	return newDeviceId;
+}
+//#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+async function cacheModels() {
+	const models = await getModels();
+	state.models = {
+		...models,
+		data: models.data.filter((model) => model.model_picker_enabled || model.capabilities.type === "embeddings")
+	};
+}
+const cacheVSCodeVersion = async () => {
+	const response = await getVSCodeVersion();
+	state.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+};
+const invalidMacAddresses = new Set([
+	"00:00:00:00:00:00",
+	"ff:ff:ff:ff:ff:ff",
+	"ac:de:48:00:11:22"
+]);
+function validateMacAddress(candidate) {
+	const tempCandidate = candidate.replaceAll("-", ":").toLowerCase();
+	return !invalidMacAddresses.has(tempCandidate);
+}
+function getMac() {
+	const ifaces = networkInterfaces();
+	for (const name in ifaces) {
+		const networkInterface = ifaces[name];
+		if (networkInterface) {
+			for (const { mac } of networkInterface) if (validateMacAddress(mac)) return mac;
+		}
+	}
+	return null;
+}
+const cacheMacMachineId = () => {
+	const macAddress = getMac() ?? randomUUID();
+	state.macMachineId = createHash("sha256").update(macAddress, "utf8").digest("hex");
+	consola.debug(`Using machine ID: ${state.macMachineId}`);
+};
+const cacheVsCodeDeviceId = async () => {
+	state.vsCodeDeviceId = await getVSCodeDeviceId();
+	consola.debug(`Using VSCode device ID: ${state.vsCodeDeviceId}`);
+};
+const SESSION_REFRESH_BASE_MS = 3600 * 1e3;
+const SESSION_REFRESH_JITTER_MS = 1200 * 1e3;
+let vsCodeSessionRefreshTimer = null;
+const generateSessionId = () => {
+	state.vsCodeSessionId = randomUUID() + Date.now().toString();
+	consola.debug(`Generated VSCode session ID: ${state.vsCodeSessionId}`);
+};
+const stopVsCodeSessionRefreshLoop = () => {
+	if (vsCodeSessionRefreshTimer) {
+		clearTimeout(vsCodeSessionRefreshTimer);
+		vsCodeSessionRefreshTimer = null;
+	}
+};
+const scheduleSessionIdRefresh = () => {
+	const delay = SESSION_REFRESH_BASE_MS + Math.floor(Math.random() * SESSION_REFRESH_JITTER_MS);
+	consola.debug(`Scheduling next VSCode session ID refresh in ${Math.round(delay / 1e3)} seconds`);
+	stopVsCodeSessionRefreshLoop();
+	vsCodeSessionRefreshTimer = setTimeout(() => {
+		try {
+			generateSessionId();
+		} catch (error) {
+			consola.error("Failed to refresh session ID, rescheduling...", error);
+		} finally {
+			scheduleSessionIdRefresh();
+		}
+	}, delay);
+};
+const cacheVsCodeSessionId = () => {
+	stopVsCodeSessionRefreshLoop();
+	generateSessionId();
+	scheduleSessionIdRefresh();
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const getUserIdJsonField = (userIdPayload, field) => {
+	const value = userIdPayload?.[field];
+	return typeof value === "string" && value.length > 0 ? value : null;
+};
+const parseJsonUserId = (userId) => {
+	try {
+		const parsed = JSON.parse(userId);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+};
+const parseUserIdMetadata = (userId) => {
+	if (!userId || typeof userId !== "string") return {
+		safetyIdentifier: null,
+		sessionId: null
+	};
+	const legacySafetyIdentifier = userId.match(/user_([^_]+)_account/)?.[1] ?? null;
+	const legacySessionId = userId.match(/_session_(.+)$/)?.[1] ?? null;
+	const parsedUserId = legacySafetyIdentifier && legacySessionId ? null : parseJsonUserId(userId);
+	return {
+		safetyIdentifier: legacySafetyIdentifier ?? getUserIdJsonField(parsedUserId, "device_id") ?? getUserIdJsonField(parsedUserId, "account_uuid"),
+		sessionId: legacySessionId ?? getUserIdJsonField(parsedUserId, "session_id")
+	};
+};
+const findLastUserContent = (messages) => {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user" && msg.content) {
+			if (typeof msg.content === "string") return msg.content;
+			else if (Array.isArray(msg.content)) {
+				const array = msg.content.filter((n) => n.type !== "tool_result").map((n) => ({
+					...n,
+					cache_control: void 0
+				}));
+				if (array.length > 0) return JSON.stringify(array);
+			}
+		}
+	}
+	return null;
+};
+const generateRequestIdFromPayload = (payload, sessionId) => {
+	const messages = payload.messages;
+	if (messages) {
+		const lastUserContent = typeof messages === "string" ? messages : findLastUserContent(messages);
+		if (lastUserContent) return getUUID((sessionId ?? "") + (state.macMachineId ?? "") + lastUserContent);
+	}
+	return randomUUID();
+};
+const getRootSessionId = (anthropicPayload, c) => {
+	const userId = anthropicPayload.metadata?.user_id;
+	const sessionId = userId ? parseUserIdMetadata(userId).sessionId || void 0 : c.req.header("x-session-id");
+	return sessionId ? getUUID(sessionId) : sessionId;
+};
+const getUUID = (content) => {
+	const uuidBytes = createHash("sha256").update(content).digest().subarray(0, 16);
+	uuidBytes[6] = uuidBytes[6] & 15 | 64;
+	uuidBytes[8] = uuidBytes[8] & 63 | 128;
+	const uuidHex = uuidBytes.toString("hex");
+	return `${uuidHex.slice(0, 8)}-${uuidHex.slice(8, 12)}-${uuidHex.slice(12, 16)}-${uuidHex.slice(16, 20)}-${uuidHex.slice(20)}`;
+};
+//#endregion
+//#region src/services/github/poll-access-token.ts
+async function pollAccessToken(deviceCode) {
+	const { clientId, headers } = getOauthAppConfig();
+	const { accessTokenUrl } = getOauthUrls();
+	const sleepDuration = (deviceCode.interval + 1) * 1e3;
+	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+	while (true) {
+		const response = await fetch(accessTokenUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				client_id: clientId,
+				device_code: deviceCode.device_code,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		if (!response.ok) {
+			await sleep(sleepDuration);
+			consola.error("Failed to poll access token:", await response.text());
+			continue;
+		}
+		const json = await response.json();
+		consola.debug("Polling access token response:", json);
+		const { access_token } = json;
+		if (access_token) return access_token;
+		else await sleep(sleepDuration);
+	}
+}
+//#endregion
+//#region src/lib/token.ts
+let copilotRefreshLoopController = null;
+let codexRefreshLoopController = null;
+const stopCopilotRefreshLoop = () => {
+	if (!copilotRefreshLoopController) return;
+	copilotRefreshLoopController.abort();
+	copilotRefreshLoopController = null;
+};
+const stopCodexRefreshLoop = () => {
+	if (!codexRefreshLoopController) return;
+	codexRefreshLoopController.abort();
+	codexRefreshLoopController = null;
+};
+function applyCodexCredentials(credentials) {
+	state.codexAccessToken = credentials.accessToken;
+	state.codexRefreshToken = credentials.refreshToken;
+	state.codexExpiresAt = credentials.expiresAt;
+	state.codexAccountId = credentials.accountId;
+	consola.debug("Codex credentials loaded successfully");
+	if (state.showToken) consola.info("Codex access token:", credentials.accessToken);
+}
+function getLoadedCodexCredentials() {
+	if (!state.codexAccessToken || !state.codexRefreshToken || !state.codexExpiresAt || !state.codexAccountId) return null;
+	return {
+		accessToken: state.codexAccessToken,
+		refreshToken: state.codexRefreshToken,
+		expiresAt: state.codexExpiresAt,
+		accountId: state.codexAccountId
+	};
+}
+function syncCodexProviderConfig(options) {
+	const existingProviderConfig = getRawProviderConfig("codex") ?? {};
+	setProviderConfig("codex", {
+		...existingProviderConfig,
+		type: "openai-responses",
+		enabled: options?.enabled ?? existingProviderConfig.enabled,
+		baseUrl: CODEX_API_BASE_URL,
+		authType: "oauth2"
+	});
+}
+async function persistCodexCredentials(credentials, options) {
+	await writeCodexCredentials(credentials);
+	syncCodexProviderConfig({ enabled: options?.enableProvider ? true : void 0 });
+	applyCodexCredentials(credentials);
+}
+const setupCopilotToken = async () => {
+	if (isOpencodeOauthApp()) {
+		if (!state.githubToken) throw new Error(`opencode token not found`);
+		state.copilotToken = state.githubToken;
+		consola.debug("GitHub Copilot token set from opencode auth token");
+		if (state.showToken) consola.info("Copilot token:", state.copilotToken);
+		stopCopilotRefreshLoop();
+		return;
+	}
+	const { token, refresh_in } = await getCopilotToken();
+	state.copilotToken = token;
+	consola.debug("GitHub Copilot Token fetched successfully!");
+	if (state.showToken) consola.info("Copilot token:", token);
+	stopCopilotRefreshLoop();
+	const controller = new AbortController();
+	copilotRefreshLoopController = controller;
+	runCopilotRefreshLoop(refresh_in, controller.signal).catch(() => {
+		consola.warn("Copilot token refresh loop stopped");
+	}).finally(() => {
+		if (copilotRefreshLoopController === controller) copilotRefreshLoopController = null;
+	});
+};
+const setupCodexToken = async () => {
+	const loadedCredentials = getLoadedCodexCredentials();
+	if (loadedCredentials && !isCodexCredentialsExpired(loadedCredentials)) {
+		if (codexRefreshLoopController) return;
+		applyCodexCredentials(loadedCredentials);
+	}
+	const credentials = loadedCredentials ?? await readCodexCredentials();
+	if (!credentials) throw new Error(`Codex credentials not found. Run \`copilot-api auth login --provider codex\` first.`);
+	syncCodexProviderConfig();
+	let nextCredentials = credentials;
+	if (isCodexCredentialsExpired(credentials)) {
+		consola.debug("Refreshing expired Codex credentials");
+		nextCredentials = await refreshCodexCredentials(credentials);
+		await persistCodexCredentials(nextCredentials);
+	}
+	applyCodexCredentials(nextCredentials);
+	stopCodexRefreshLoop();
+	const controller = new AbortController();
+	codexRefreshLoopController = controller;
+	runCodexRefreshLoop(controller.signal).catch(() => {
+		consola.warn("Codex token refresh loop stopped");
+	}).finally(() => {
+		if (codexRefreshLoopController === controller) codexRefreshLoopController = null;
+	});
+};
+const REFRESH_POLL_INTERVAL_MS = 15e3;
+const EARLY_REFRESH_BUFFER_MS = 6e4;
+const RETRY_REFRESH_DELAY_MS = 15e3;
+const MIN_REFRESH_DELAY_MS = 1e3;
+const getRefreshDeadlineMs = (refreshIn, nowMs = Date.now()) => nowMs + Math.max(refreshIn * 1e3 - EARLY_REFRESH_BUFFER_MS, MIN_REFRESH_DELAY_MS);
+const getRefreshPollDelayMs = (refreshAtMs, nowMs = Date.now()) => Math.min(Math.max(refreshAtMs - nowMs, 0), REFRESH_POLL_INTERVAL_MS);
+const runCopilotRefreshLoop = async (refreshIn, signal) => {
+	let refreshAtMs = getRefreshDeadlineMs(refreshIn);
+	while (!signal.aborted) {
+		const nextDelayMs = getRefreshPollDelayMs(refreshAtMs);
+		if (nextDelayMs > 0) {
+			await setTimeout$1(nextDelayMs, void 0, { signal });
+			continue;
+		}
+		consola.debug("Refreshing Copilot token");
+		try {
+			const { token, refresh_in } = await getCopilotToken();
+			state.copilotToken = token;
+			refreshAtMs = getRefreshDeadlineMs(refresh_in);
+			consola.debug("Copilot token refreshed");
+			if (state.showToken) consola.info("Refreshed Copilot token:", token);
+		} catch (error) {
+			consola.error("Failed to refresh Copilot token:", error);
+			refreshAtMs = Date.now() + RETRY_REFRESH_DELAY_MS;
+			consola.warn(`Retrying Copilot token refresh in ${RETRY_REFRESH_DELAY_MS / 1e3}s`);
+		}
+	}
+};
+const runCodexRefreshLoop = async (signal) => {
+	let refreshAtMs = Math.max((state.codexExpiresAt ?? Date.now()) - EARLY_REFRESH_BUFFER_MS, Date.now());
+	while (!signal.aborted) {
+		const expiresAt = state.codexExpiresAt;
+		const refreshToken = state.codexRefreshToken;
+		if (!expiresAt || !refreshToken) return;
+		const nextDelayMs = getRefreshPollDelayMs(refreshAtMs);
+		if (nextDelayMs > 0) {
+			await setTimeout$1(nextDelayMs, void 0, { signal });
+			continue;
+		}
+		consola.debug("Refreshing Codex credentials");
+		try {
+			const credentials = await refreshCodexCredentials({
+				accessToken: state.codexAccessToken ?? "",
+				refreshToken,
+				expiresAt,
+				accountId: state.codexAccountId ?? ""
+			});
+			await persistCodexCredentials(credentials);
+			refreshAtMs = Math.max(credentials.expiresAt - EARLY_REFRESH_BUFFER_MS, Date.now());
+			consola.debug("Codex credentials refreshed");
+		} catch (error) {
+			consola.error("Failed to refresh Codex credentials:", error);
+			refreshAtMs = Date.now() + RETRY_REFRESH_DELAY_MS;
+			consola.warn(`Retrying Codex token refresh in ${RETRY_REFRESH_DELAY_MS / 1e3}s`);
+		}
+	}
+};
+async function setupGitHubToken(options) {
+	try {
+		const githubToken = await readGitHubToken();
+		if (githubToken && !options?.force) {
+			state.githubToken = githubToken;
+			if (state.showToken) consola.info("GitHub token:", githubToken);
+			await logUser();
+			return;
+		}
+		consola.info("Not logged in, getting new access token");
+		const response = await getDeviceCode();
+		consola.debug("Device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri}`);
+		const token = await pollAccessToken(response);
+		await writeGitHubToken(token);
+		state.githubToken = token;
+		if (state.showToken) consola.info("GitHub token:", token);
+		await logUser();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub token:", error);
+		throw error;
+	}
+}
+async function logUser() {
+	const user = await getGitHubUser();
+	state.userName = user.login;
+	consola.info(`Logged in as ${user.login}`);
+	state.copilotApiUrl = (await getCopilotUsage()).endpoints.api;
+}
+//#endregion
+export { compactSystemPromptStarts as A, createWebSocketUrl as B, prepareForCompact as C, compactAutoContinuePromptStarts as D, initOpencodeVersion as E, normalizeCodexResponsesEvent as F, state as H, generateTraceId as I, requestContext as L, loginCodex as M, createStandardizedCodexResponsesEventStream as N, compactMessageSections as O, forwardCodexResponses as P, resolveTraceId as R, copilotWebSocketHeaders as S, prepareMessageProxyHeaders as T, logCodexRateLimitsEvent as U, initProxyFromEnv as V, getCopilotUsage as _, setupGitHubToken as a, copilotBaseUrl as b, cacheVSCodeVersion as c, generateRequestIdFromPayload as d, getRootSessionId as f, sleep as g, parseUserIdMetadata as h, setupCopilotToken as i, compactTextOnlyGuard as j, compactSummaryPromptStart as k, cacheVsCodeDeviceId as l, isNullish as m, persistCodexCredentials as n, cacheMacMachineId as o, getUUID as p, setupCodexToken as r, cacheModels as s, logUser as t, cacheVsCodeSessionId as u, HTTPError as v, prepareInteractionHeaders as w, copilotHeaders as x, forwardError as y, createPooledWebSocketStream as z };
+
+//# sourceMappingURL=token-BVXHiYEl.js.map