xiaodcs-copilot-api 2.1.0-recovery.1

package/dist/token--3EQGrXj.js

@@ -0,0 +1,1503 @@
+import { A as isResponsesApiWebSocketEnabled, M as PATHS, c as setProviderConfig, n as getRawProviderConfig } from "./config-RMZKaZqy.js";
+import consola from "consola";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import fs, { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createServer } from "node:http";
+import { events } from "fetch-event-stream";
+import { getProxyForUrl } from "proxy-from-env";
+import { WebSocket } from "undici";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { exec } from "node:child_process";
+//#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/lib/state.ts
+const state = {
+	accountType: "individual",
+	showToken: false,
+	verbose: false,
+	vsCodeDeviceId: randomUUID()
+};
+//#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) {
+		consola.debug("websocket from pool");
+		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 proxy = typeof Bun === "undefined" ? void 0 : getProxyUrl(url);
+	const websocket = new WebSocket(url, {
+		headers,
+		...proxy ? { proxy } : {}
+	});
+	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 = () => {
+		consola.debug("WebSocket closed");
+		closed = true;
+		wake();
+	};
+	const onError = (event) => {
+		consola.error("WebSocket error:", event, event.error);
+		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();
+};
+const getProxyUrl = (url) => {
+	return getProxyForUrl(url.replace(/^wss:/, "https:").replace(/^ws:/, "http:"));
+};
+//#endregion
+//#region src/services/responses-websocket-helpers.ts
+const encodePoolKeyPart = (value) => encodeURIComponent(value);
+const getErrorMessage = (error) => {
+	if (error instanceof Error && error.message) return error.message;
+	return String(error);
+};
+const createResponsesErrorServerSentEventChunk = (message) => {
+	const errorEvent = {
+		code: null,
+		message,
+		param: null,
+		sequence_number: 0,
+		type: "error"
+	};
+	return {
+		event: errorEvent.type,
+		data: JSON.stringify(errorEvent)
+	};
+};
+const isTerminalResponsesStreamChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return false;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
+	} catch {
+		return false;
+	}
+};
+const createResponsesSafeStream = async function* (source) {
+	try {
+		yield* source;
+	} catch (error) {
+		yield createResponsesErrorServerSentEventChunk(getErrorMessage(error));
+	}
+};
+//#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([
+	"accept-encoding",
+	"authorization",
+	"cdn-loop",
+	"connection",
+	"content-length",
+	"host",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"true-client-ip",
+	"upgrade",
+	"x-api-key",
+	"x-forwarded-for",
+	"x-forwarded-proto"
+]);
+const STRIPPED_CODEX_WEBSOCKET_HEADERS = new Set(["accept", "content-type"]);
+const shouldForwardCodexRequestHeader = (headerName) => {
+	const headerNameLower = headerName.toLowerCase();
+	return !STRIPPED_CODEX_REQUEST_HEADERS.has(headerNameLower) && !headerNameLower.includes("trace") && !headerNameLower.startsWith("cf-");
+};
+const buildForwardedCodexRequestHeaders = (requestHeaders) => {
+	const headers = new Headers();
+	for (const [headerName, headerValue] of requestHeaders) if (shouldForwardCodexRequestHeader(headerName)) headers.set(headerName, headerValue);
+	return headers;
+};
+const setDefaultCodexHeader = (headers, headerName, headerValue) => {
+	if (!headers.has(headerName)) headers.set(headerName, headerValue);
+};
+const applyOpencodeCodexHeaders = (headers) => {
+	if (!headers.get("user-agent")?.startsWith("opencode")) return;
+	headers.set("originator", "opencode");
+	const sessionId = requestContext.getStore()?.sessionAffinity;
+	if (sessionId) headers.set("session-id", sessionId);
+};
+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 headers = buildCodexRequestHeaders(requestHeaders);
+	setDefaultCodexHeader(headers, "accept", options.stream ? "text/event-stream" : "application/json");
+	setDefaultCodexHeader(headers, "content-type", "application/json");
+	return headers;
+}
+function buildCodexRequestHeaders(requestHeaders) {
+	const { accessToken, accountId } = requireCodexAuthContext();
+	const headers = buildForwardedCodexRequestHeaders(requestHeaders);
+	headers.set("authorization", `Bearer ${accessToken}`);
+	headers.set("chatgpt-account-id", accountId);
+	setDefaultCodexHeader(headers, "originator", "copilot-api");
+	setDefaultCodexHeader(headers, "user-agent", "copilot-api");
+	applyOpencodeCodexHeaders(headers);
+	return headers;
+}
+function resolveCodexResponsesTransport(transport) {
+	return transport ?? (isResponsesApiWebSocketEnabled() ? "websocket" : "http");
+}
+function buildCodexResponsesWebSocketHeaders(requestHeaders) {
+	const headers = buildCodexResponsesHeaders(requestHeaders);
+	setDefaultCodexHeader(headers, "openai-beta", "responses_websockets=2026-02-06");
+	for (const headerName of STRIPPED_CODEX_WEBSOCKET_HEADERS) headers.delete(headerName);
+	return Object.fromEntries(headers);
+}
+function buildCodexResponsesWebSocketPayload(payload) {
+	const websocketPayload = {
+		type: "response.create",
+		...normalizeCodexResponsesPayload(payload)
+	};
+	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 = {}) {
+	consola.log(`<-- model: ${payload.model}`);
+	const transport = resolveCodexResponsesTransport(options.transport);
+	if (payload.stream && transport === "websocket") return forwardCodexResponsesOverWebSocket(payload, requestHeaders, baseUrl);
+	const normalizedPayload = normalizeCodexResponsesPayload(payload);
+	const response = await fetch(resolveCodexResponsesUrl(baseUrl), {
+		method: "POST",
+		headers: buildCodexResponsesHeaders(requestHeaders, { stream: normalizedPayload.stream }),
+		body: JSON.stringify(normalizedPayload)
+	});
+	if (!response.ok) throw new HTTPError("Failed to create codex responses", response);
+	if (normalizedPayload.stream) return events(response);
+	return await response.json();
+}
+const normalizeCodexResponsesPayload = (payload) => {
+	const normalizedPayload = {
+		...payload,
+		store: false
+	};
+	delete normalizedPayload.temperature;
+	delete normalizedPayload.top_p;
+	delete normalizedPayload.max_output_tokens;
+	delete normalizedPayload.metadata;
+	if (typeof normalizedPayload.instructions === "string" && normalizedPayload.instructions.trim().length > 0 || !Array.isArray(normalizedPayload.input)) return normalizedPayload;
+	const instructions = [];
+	let messageCount = 0;
+	const remainingInput = normalizedPayload.input.filter((inputItem) => {
+		const message = getResponseInputMessage(inputItem);
+		if (!message) return true;
+		messageCount += 1;
+		if (message.role !== "system" || messageCount > 3) return true;
+		const systemPrompt = getTextContent(message.content);
+		if (systemPrompt === void 0) return true;
+		if (systemPrompt.trim().length > 0) instructions.push(systemPrompt);
+		return false;
+	});
+	if (remainingInput.length === normalizedPayload.input.length) return normalizedPayload;
+	if (instructions.length > 0) normalizedPayload.instructions = instructions.join("\n\n");
+	if (remainingInput.length > 0) normalizedPayload.input = remainingInput;
+	else delete normalizedPayload.input;
+	return normalizedPayload;
+};
+const getResponseInputMessage = (inputItem) => {
+	if (typeof inputItem !== "object" || inputItem === null) return;
+	const { role, type } = inputItem;
+	if (typeof role !== "string" || type !== void 0 && type !== "message") return;
+	return inputItem;
+};
+const getTextContent = (content) => {
+	if (typeof content === "string") return content;
+	if (content === void 0) return "";
+	if (!Array.isArray(content)) return;
+	const textBlocks = [];
+	for (const contentBlock of content) {
+		const text = getTextBlock(contentBlock);
+		if (text === void 0) return;
+		if (text.length > 0) textBlocks.push(text);
+	}
+	return textBlocks.join("\n\n");
+};
+const getTextBlock = (contentBlock) => {
+	if (typeof contentBlock !== "object" || contentBlock === null) return;
+	const { text, type } = contentBlock;
+	if (type !== void 0 && type !== "input_text" && type !== "output_text") return;
+	return typeof text === "string" ? text : void 0;
+};
+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).filter(([headerName]) => !headerName.toLowerCase().includes("trace")).sort(([left], [right]) => left.localeCompare(right)))).digest("hex").slice(0, 16);
+	return [
+		"codex",
+		resolveCodexResponsesUrl(baseUrl),
+		payload.model,
+		authFingerprint,
+		headerFingerprint
+	].map(encodePoolKeyPart).join("|");
+};
+const forwardCodexResponsesOverWebSocket = (payload, requestHeaders, baseUrl) => {
+	return createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl));
+};
+const createCodexResponsesWebSocketStream = (request) => createResponsesSafeStream(createPooledWebSocketStream(request, {
+	createChunk: createCodexResponsesWebSocketStreamChunk,
+	isTerminalChunk: isTerminalResponsesStreamChunk,
+	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);
+		if (parsed.type === "error" && parsed.error) {
+			consola.warn("Codex responses websocket stream error:", parsed.error);
+			parsed.message = parsed.error.message;
+		}
+		return {
+			event: typeof parsed.type === "string" ? parsed.type : void 0,
+			data: JSON.stringify(parsed),
+			id: typeof parsed.id === "string" ? parsed.id : void 0
+		};
+	} catch {
+		return { data };
+	}
+};
+//#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;
+const CALLBACK_TIMEOUT_MS = 45e3;
+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 {
+		const timeout = new Promise((resolve) => {
+			setTimeout(() => resolve(null), CALLBACK_TIMEOUT_MS);
+		});
+		return await Promise.race([waitForCode, timeout]);
+	} 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.58.0";
+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-06-01";
+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 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/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) return null;
+	const authState = {
+		...state,
+		githubToken: resolvedGithubToken
+	};
+	const response = await fetch(`${getGitHubApiBaseUrl()}/copilot_internal/user`, { headers: githubHeaders(authState) });
+	if (!response.ok) {
+		const errorText = await response.clone().text();
+		consola.error("Failed to get Copilot user response body", errorText);
+		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/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+const isResponsesStream = (value) => isAsyncIterable(value);
+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",
+		pricingCurrency: "USD"
+	});
+}
+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 MAX_RETRY_REFRESH_DELAY_MS = 6e5;
+const RETRY_REFRESH_JITTER_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);
+	let retryDelayMs = RETRY_REFRESH_DELAY_MS;
+	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);
+			retryDelayMs = RETRY_REFRESH_DELAY_MS;
+			consola.debug("Copilot token refreshed");
+			if (state.showToken) consola.info("Refreshed Copilot token:", token);
+		} catch (error) {
+			consola.error("Failed to refresh Copilot token:", error);
+			const delayMs = Math.min(retryDelayMs + Math.floor(Math.random() * RETRY_REFRESH_JITTER_MS), MAX_RETRY_REFRESH_DELAY_MS);
+			refreshAtMs = Date.now() + delayMs;
+			retryDelayMs = Math.min(retryDelayMs * 2, MAX_RETRY_REFRESH_DELAY_MS);
+			consola.warn(`Retrying Copilot token refresh in ${Math.round(delayMs / 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 copilotUser = await getCopilotUsage();
+	if (!copilotUser) throw new Error("GitHub token not found");
+	state.userName = copilotUser.login;
+	consola.info(`Logged in as ${copilotUser.login}`);
+	state.copilotApiUrl = copilotUser.endpoints.api;
+	state.tokenBasedBilling = copilotUser.token_based_billing;
+}
+//#endregion
+export { buildCodexRequestHeaders as A, state as B, compactAutoContinuePromptStarts as C, compactTextOnlyGuard as D, compactSystemPromptStarts as E, createResponsesSafeStream as F, forwardError as H, encodePoolKeyPart as I, isTerminalResponsesStreamChunk as L, generateTraceId as M, requestContext as N, loginCodex as O, resolveTraceId as P, createPooledWebSocketStream as R, initOpencodeVersion as S, compactSummaryPromptStart as T, HTTPError as V, copilotModelsHeaders as _, setupGitHubToken as a, prepareInteractionHeaders as b, getUUID as c, isResponsesStream as d, parseUserIdMetadata as f, copilotHeaders as g, copilotBaseUrl as h, setupCopilotToken as i, forwardCodexResponses as j, CODEX_API_BASE_URL as k, isAsyncIterable as l, readGitHubToken as m, persistCodexCredentials as n, generateRequestIdFromPayload as o, getCopilotUsage as p, setupCodexToken as r, getRootSessionId as s, logUser as t, isNullish as u, copilotWebSocketHeaders as v, compactMessageSections as w, prepareMessageProxyHeaders as x, prepareForCompact as y, createWebSocketUrl as z };