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

package/dist/token-D9svRIYW.js

@@ -0,0 +1,1950 @@
+import { E as getResponsesTransportConfig, P as PATHS, c as setProviderConfig, j as isResponsesApiWebSocketEnabled, n as getRawProviderConfig, w as getConfig } from "./config-SytZjLq8.js";
+import consola from "consola";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import path from "node:path";
+import fs, { readFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { getProxyForUrl } from "proxy-from-env";
+import { WebSocket } from "undici";
+import { events } from "fetch-event-stream";
+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) {
+	if (c.req.raw.signal.aborted || isAbortError$1(error)) return new Response(null, {
+		status: 499,
+		statusText: "Client Closed Request"
+	});
+	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);
+}
+const isAbortError$1 = (error) => error instanceof Error && error.name === "AbortError";
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	accountType: "individual",
+	showToken: false,
+	verbose: false,
+	vsCodeDeviceId: randomUUID()
+};
+//#endregion
+//#region src/services/responses-websocket.ts
+const websocketPool = /* @__PURE__ */ new Map();
+const websocketActiveRequests = /* @__PURE__ */ new Map();
+var ResponsesWebSocketOpenTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses websocket did not open within ${timeoutMs}ms`);
+		this.name = "ResponsesWebSocketOpenTimeoutError";
+	}
+};
+var ResponsesWebSocketInactivityTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses websocket stream was inactive for ${timeoutMs}ms`);
+		this.name = "ResponsesWebSocketInactivityTimeoutError";
+	}
+};
+var ResponsesWebSocketBufferOverflowError = class extends Error {
+	constructor(maxBufferedBytes, maxBufferedMessages) {
+		super(`Responses websocket buffer exceeded ${maxBufferedBytes} bytes or ${maxBufferedMessages} messages; downstream consumption is too slow`);
+		this.name = "ResponsesWebSocketBufferOverflowError";
+	}
+};
+var WebSocketMessageBuffer = class {
+	entries = [];
+	head = 0;
+	maxBufferedBytes;
+	maxBufferedMessages;
+	sizeBytes = 0;
+	constructor(maxBufferedBytes, maxBufferedMessages) {
+		this.maxBufferedBytes = maxBufferedBytes;
+		this.maxBufferedMessages = maxBufferedMessages;
+	}
+	get bufferedBytes() {
+		return this.sizeBytes;
+	}
+	get bufferedMessages() {
+		return this.entries.length - this.head;
+	}
+	enqueue(data) {
+		const size = getWebSocketMessageSize(data);
+		if (this.sizeBytes + size > this.maxBufferedBytes || this.bufferedMessages + 1 > this.maxBufferedMessages) return false;
+		this.entries.push({
+			data: normalizeWebSocketMessageData(data),
+			size
+		});
+		this.sizeBytes += size;
+		return true;
+	}
+	dequeue() {
+		const entry = this.entries[this.head];
+		if (!entry) return void 0;
+		this.entries[this.head] = void 0;
+		this.head += 1;
+		this.sizeBytes -= entry.size;
+		this.compactIfNeeded();
+		return entry.data;
+	}
+	clear() {
+		this.entries.length = 0;
+		this.head = 0;
+		this.sizeBytes = 0;
+	}
+	compactIfNeeded() {
+		if (this.head < 256 || this.head * 2 < this.entries.length) return;
+		this.entries.splice(0, this.head);
+		this.head = 0;
+	}
+};
+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) {
+	throwIfAborted(request.signal);
+	const { entry, pooled } = getPooledWebSocketRequestTarget(request, options);
+	const release = acquirePooledWebSocketEntry(request.poolKey, entry, pooled);
+	let messageStream = null;
+	let reusable = false;
+	try {
+		const websocket = await getReadyPooledWebSocket(request.poolKey, entry, pooled, options);
+		throwIfAborted(request.signal);
+		messageStream = createWebSocketMessageStream(websocket, request.signal, options);
+		messageStream.start();
+		websocket.send(JSON.stringify(request.payload));
+		for await (const data of messageStream.iterable) {
+			const chunk = options.createChunk(data);
+			const isTerminal = options.isTerminalChunk(chunk);
+			if (isTerminal) {
+				messageStream.complete();
+				reusable = true;
+			}
+			yield chunk;
+			if (isTerminal) return;
+		}
+		throw new Error(options.terminalChunkMissingMessage);
+	} catch (error) {
+		throw toError$1(error);
+	} finally {
+		messageStream?.dispose();
+		if (!reusable) removePooledWebSocketEntry(request.poolKey, entry);
+		release(reusable);
+	}
+};
+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");
+		clearPooledWebSocketIdleState(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 websocketPromise = openWebSocket({
+		headers: request.headers,
+		openErrorMessage: options.openErrorMessage,
+		openTimeoutMs: options.openTimeoutMs,
+		signal: request.signal,
+		url: request.url
+	});
+	const entry = {
+		closed: false,
+		idleMessageListener: null,
+		idleTimer: null,
+		poolIdleTimeoutMs: options.poolIdleTimeoutMs,
+		requestCount: 0,
+		websocket: null,
+		websocketPromise
+	};
+	entry.websocketPromise.then((websocket) => {
+		entry.websocket = 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) => {
+	clearPooledWebSocketIdleState(entry);
+	incrementPooledWebSocketActiveRequestCount(poolKey);
+	entry.requestCount += 1;
+	let released = false;
+	return (reusable) => {
+		if (released) return;
+		released = true;
+		entry.requestCount -= 1;
+		decrementPooledWebSocketActiveRequestCount(poolKey);
+		if (!reusable) {
+			removePooledWebSocketEntry(poolKey, entry);
+			return;
+		}
+		if (entry.closed || entry.requestCount > 0) return;
+		if (pooled && websocketPool.get(poolKey) === entry) {
+			schedulePooledWebSocketIdleClose(poolKey, entry);
+			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) => {
+	clearPooledWebSocketIdleState(entry);
+	const websocket = entry.websocket;
+	if (!websocket || websocket.readyState !== WebSocket.OPEN) {
+		removePooledWebSocketEntry(poolKey, entry);
+		return;
+	}
+	entry.idleMessageListener = () => {
+		removePooledWebSocketEntry(poolKey, entry);
+	};
+	websocket.addEventListener("message", entry.idleMessageListener);
+	entry.idleTimer = setTimeout(() => {
+		removePooledWebSocketEntry(poolKey, entry);
+	}, entry.poolIdleTimeoutMs);
+	unrefTimer(entry.idleTimer);
+};
+const clearPooledWebSocketIdleState = (entry) => {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+		entry.idleTimer = null;
+	}
+	if (entry.websocket && entry.idleMessageListener) {
+		entry.websocket.removeEventListener("message", entry.idleMessageListener);
+		entry.idleMessageListener = 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);
+	else websocketActiveRequests.set(poolKey, nextCount);
+};
+const removePooledWebSocketEntry = (poolKey, entry) => {
+	if (websocketPool.get(poolKey) === entry) websocketPool.delete(poolKey);
+	if (entry.closed) return;
+	entry.closed = true;
+	clearPooledWebSocketIdleState(entry);
+	entry.websocketPromise.then(closeWebSocket).catch(() => {});
+};
+const createWebSocketError = (message, event) => {
+	const reason = event?.error ?? event?.message;
+	if (reason === void 0 || reason === "") return new Error(message);
+	const cause = toError$1(reason);
+	return new Error(`${message}: ${cause.message}`, { cause });
+};
+const openWebSocket = async ({ headers, openErrorMessage, openTimeoutMs, signal, url }) => await new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(toAbortReason$1(signal.reason));
+		return;
+	}
+	const proxy = typeof Bun === "undefined" ? void 0 : getProxyUrl(url);
+	const websocket = new WebSocket(url, {
+		headers,
+		...proxy ? { proxy } : {}
+	});
+	let settled = false;
+	const timer = setTimeout(() => {
+		fail(new ResponsesWebSocketOpenTimeoutError(openTimeoutMs));
+	}, openTimeoutMs);
+	const cleanup = () => {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
+		websocket.removeEventListener("open", onOpen);
+		websocket.removeEventListener("close", onClose);
+		websocket.removeEventListener("error", onError);
+	};
+	const fail = (error) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		closeWebSocket(websocket);
+		reject(error);
+	};
+	const onAbort = () => fail(toAbortReason$1(signal?.reason));
+	const onOpen = () => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		resolve(websocket);
+	};
+	const onClose = () => fail(new Error(openErrorMessage));
+	const onError = (event) => {
+		fail(createWebSocketError(openErrorMessage, event));
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	websocket.addEventListener("open", onOpen);
+	websocket.addEventListener("close", onClose);
+	websocket.addEventListener("error", onError);
+});
+const createWebSocketMessageStream = (websocket, signal, options) => {
+	const buffer = new WebSocketMessageBuffer(options.maxBufferedBytes, options.maxBufferedMessages);
+	let closed = false;
+	let disposed = false;
+	let error = null;
+	let inactivityTimer = null;
+	let notify = null;
+	const wake = () => {
+		notify?.();
+		notify = null;
+	};
+	const clearInactivityTimer = () => {
+		if (!inactivityTimer) return;
+		clearTimeout(inactivityTimer);
+		inactivityTimer = null;
+	};
+	const fail = (nextError, close = true) => {
+		if (error || disposed) return;
+		error = nextError;
+		clearInactivityTimer();
+		buffer.clear();
+		if (close) closeWebSocket(websocket);
+		wake();
+	};
+	const resetInactivityTimer = () => {
+		clearInactivityTimer();
+		if (disposed || closed || error) return;
+		inactivityTimer = setTimeout(() => {
+			fail(new ResponsesWebSocketInactivityTimeoutError(options.streamInactivityTimeoutMs));
+		}, options.streamInactivityTimeoutMs);
+	};
+	const onMessage = (event) => {
+		resetInactivityTimer();
+		if (!buffer.enqueue(event.data)) {
+			fail(new ResponsesWebSocketBufferOverflowError(options.maxBufferedBytes, options.maxBufferedMessages));
+			return;
+		}
+		wake();
+	};
+	const onClose = (event) => {
+		consola.debug("WebSocket closed", {
+			code: event.code,
+			reason: event.reason,
+			wasClean: event.wasClean
+		});
+		closed = true;
+		clearInactivityTimer();
+		wake();
+	};
+	const onError = (event) => {
+		consola.error("WebSocket error:", event, event.error);
+		fail(createWebSocketError(options.streamErrorMessage, event), false);
+	};
+	const onAbort = () => fail(toAbortReason$1(signal?.reason));
+	websocket.addEventListener("message", onMessage);
+	websocket.addEventListener("close", onClose);
+	websocket.addEventListener("error", onError);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		clearInactivityTimer();
+		buffer.clear();
+		websocket.removeEventListener("message", onMessage);
+		websocket.removeEventListener("close", onClose);
+		websocket.removeEventListener("error", onError);
+		signal?.removeEventListener("abort", onAbort);
+		wake();
+	};
+	return {
+		complete: clearInactivityTimer,
+		dispose,
+		iterable: (async function* () {
+			try {
+				while (true) {
+					const item = buffer.dequeue();
+					if (item) {
+						yield await item;
+						continue;
+					}
+					if (error) throw toError$1(error);
+					if (closed) return;
+					await new Promise((resolve) => {
+						notify = resolve;
+					});
+				}
+			} finally {
+				dispose();
+			}
+		})(),
+		start: resetInactivityTimer
+	};
+};
+const normalizeWebSocketMessageData = async (data) => {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+	if (isTextReadable(data)) return await data.text();
+	return String(data);
+};
+const getWebSocketMessageSize = (data) => {
+	if (typeof data === "string") return new TextEncoder().encode(data).byteLength;
+	if (data instanceof ArrayBuffer) return data.byteLength;
+	if (ArrayBuffer.isView(data)) return data.byteLength;
+	if (isSized(data)) return data.size;
+	return new TextEncoder().encode(String(data)).byteLength;
+};
+const isTextReadable = (value) => Boolean(value && typeof value === "object" && "text" in value && typeof value.text === "function");
+const isSized = (value) => Boolean(value && typeof value === "object" && "size" in value && typeof value.size === "number");
+const toAbortReason$1 = (reason) => {
+	if (reason instanceof Error) return reason;
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+};
+const throwIfAborted = (signal) => {
+	if (signal?.aborted) throw toAbortReason$1(signal.reason);
+};
+const toError$1 = (value) => {
+	if (value instanceof Error) return value;
+	return new Error(String(value));
+};
+const closeWebSocket = (websocket) => {
+	if (websocket.readyState !== WebSocket.CONNECTING && websocket.readyState !== WebSocket.OPEN) return;
+	try {
+		websocket.close();
+	} catch {}
+};
+const getProxyUrl = (url) => getProxyForUrl(url.replace(/^wss:/u, "https:").replace(/^ws:/u, "http:"));
+const unrefTimer = (timer) => {
+	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
+};
+//#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, options = {}) {
+	try {
+		yield* source;
+	} catch (error) {
+		if (options.signal?.aborted || isAbortError(error)) return;
+		yield createResponsesErrorServerSentEventChunk(getErrorMessage(error));
+	}
+};
+const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+//#endregion
+//#region src/services/responses-http.ts
+var ResponsesHeadersTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses upstream did not return headers within ${timeoutMs}ms`);
+		this.name = "ResponsesHeadersTimeoutError";
+	}
+};
+var ResponsesStreamInactivityTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses upstream stream was inactive for ${timeoutMs}ms`);
+		this.name = "ResponsesStreamInactivityTimeoutError";
+	}
+};
+async function fetchResponsesWithLifecycle(input, init, options) {
+	const lifecycle = createRequestLifecycle(options);
+	try {
+		const response = await fetch(input, {
+			...init,
+			signal: lifecycle.signal
+		});
+		lifecycle.headersReceived();
+		return createManagedResponse(response, lifecycle, options);
+	} catch (error) {
+		throw lifecycle.finishWithError(error);
+	}
+}
+const createRequestLifecycle = (options) => {
+	const controller = new AbortController();
+	const downstreamSignal = options.signal;
+	let finished = false;
+	let headersTimer = null;
+	const abortFromDownstream = () => {
+		controller.abort(toAbortReason(downstreamSignal?.reason));
+	};
+	if (downstreamSignal?.aborted) abortFromDownstream();
+	else downstreamSignal?.addEventListener("abort", abortFromDownstream, { once: true });
+	if (!controller.signal.aborted) headersTimer = setTimeout(() => {
+		controller.abort(new ResponsesHeadersTimeoutError(options.headersTimeoutMs));
+	}, options.headersTimeoutMs);
+	const clearHeadersTimer = () => {
+		if (headersTimer === null) return;
+		clearTimeout(headersTimer);
+		headersTimer = null;
+	};
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		clearHeadersTimer();
+		downstreamSignal?.removeEventListener("abort", abortFromDownstream);
+	};
+	return {
+		abort: (reason) => {
+			if (!controller.signal.aborted) controller.abort(reason);
+		},
+		finish,
+		finishWithError: (error) => {
+			clearHeadersTimer();
+			const reason = controller.signal.reason;
+			finish();
+			return reason instanceof Error ? reason : toError(error);
+		},
+		headersReceived: clearHeadersTimer,
+		signal: controller.signal
+	};
+};
+const createManagedResponse = (response, lifecycle, options) => {
+	if (!response.body) {
+		lifecycle.finish();
+		return response;
+	}
+	const body = createManagedResponseBody(response.body, lifecycle, options);
+	return new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+};
+const createManagedResponseBody = (body, lifecycle, options) => {
+	const reader = body.getReader();
+	let finished = false;
+	let readerReleased = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		lifecycle.finish();
+	};
+	const releaseReader = () => {
+		if (readerReleased) return;
+		readerReleased = true;
+		reader.releaseLock();
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await readWithLifecycle(reader, lifecycle, options);
+				if (result.done) {
+					finish();
+					releaseReader();
+					controller.close();
+					return;
+				}
+				controller.enqueue(result.value);
+			} catch (error) {
+				const reason = lifecycle.finishWithError(error);
+				finish();
+				await reader.cancel(reason).catch(() => {});
+				releaseReader();
+				controller.error(reason);
+			}
+		},
+		async cancel(reason) {
+			const error = toAbortReason(reason);
+			lifecycle.abort(error);
+			finish();
+			await reader.cancel(error).catch(() => {});
+			releaseReader();
+		}
+	});
+};
+const createResponsesHttpEventStream = async function* (response, signal) {
+	const responseBody = response.body;
+	if (!responseBody) return;
+	const reader = responseBody.getReader();
+	const readerBackedBody = new ReadableStream({
+		async pull(controller) {
+			const result = await reader.read();
+			if (result.done) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(result.value);
+		},
+		async cancel(reason) {
+			await reader.cancel(reason);
+		}
+	});
+	try {
+		yield* events(new Response(readerBackedBody), signal);
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {} finally {
+			reader.releaseLock();
+		}
+	}
+};
+const readWithLifecycle = async (reader, lifecycle, options) => await new Promise((resolve, reject) => {
+	let settled = false;
+	const signal = lifecycle.signal;
+	const timer = setTimeout(() => {
+		const error = new ResponsesStreamInactivityTimeoutError(options.streamInactivityTimeoutMs);
+		lifecycle.abort(error);
+		settle(() => reject(error));
+	}, options.streamInactivityTimeoutMs);
+	const onAbort = () => {
+		settle(() => reject(toAbortReason(signal.reason)));
+	};
+	const cleanup = () => {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+	};
+	const settle = (action) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		action();
+	};
+	if (signal.aborted) {
+		onAbort();
+		return;
+	}
+	signal.addEventListener("abort", onAbort, { once: true });
+	reader.read().then((result) => settle(() => resolve(result)), (error) => settle(() => reject(toError(error))));
+});
+const toAbortReason = (reason) => {
+	if (reason instanceof Error) return reason;
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+};
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	return new Error(String(value));
+};
+//#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, signal) {
+	const headers = buildCodexResponsesWebSocketHeaders(requestHeaders);
+	return {
+		headers,
+		payload: buildCodexResponsesWebSocketPayload(payload),
+		poolKey: buildCodexResponsesWebSocketPoolKey(payload, headers, baseUrl),
+		signal,
+		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, options.signal);
+	const normalizedPayload = normalizeCodexResponsesPayload(payload);
+	const transportConfig = getResponsesTransportConfig();
+	const response = await fetchResponsesWithLifecycle(resolveCodexResponsesUrl(baseUrl), {
+		method: "POST",
+		headers: buildCodexResponsesHeaders(requestHeaders, { stream: normalizedPayload.stream }),
+		body: JSON.stringify(normalizedPayload)
+	}, {
+		headersTimeoutMs: transportConfig.headersTimeoutMs,
+		signal: options.signal,
+		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs
+	});
+	if (!response.ok) throw new HTTPError("Failed to create codex responses", response);
+	if (normalizedPayload.stream) return createResponsesSafeStream(createResponsesHttpEventStream(response, options.signal), { signal: options.signal });
+	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, signal) => {
+	return createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl, signal));
+};
+const createCodexResponsesWebSocketStream = (request) => {
+	const transportConfig = getResponsesTransportConfig();
+	return createResponsesSafeStream(createPooledWebSocketStream(request, {
+		createChunk: createCodexResponsesWebSocketStreamChunk,
+		maxBufferedBytes: transportConfig.websocketMaxBufferedBytes,
+		maxBufferedMessages: transportConfig.websocketMaxBufferedMessages,
+		isTerminalChunk: isTerminalResponsesStreamChunk,
+		openErrorMessage: "Failed to create codex responses websocket",
+		openTimeoutMs: transportConfig.websocketOpenTimeoutMs,
+		poolIdleTimeoutMs: transportConfig.websocketPoolIdleTimeoutMs,
+		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs,
+		streamErrorMessage: "Upstream connection lost, Codex responses websocket stream error",
+		terminalChunkMissingMessage: "Codex responses websocket ended without a terminal response, retry your request."
+	}), { signal: request.signal });
+};
+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;
+}
+//#endregion
+//#region src/lib/request-auth.ts
+function normalizeApiKeys(apiKeys) {
+	if (!Array.isArray(apiKeys)) {
+		if (apiKeys !== void 0) consola.warn("Invalid auth.apiKeys config. Expected an array of strings.");
+		return [];
+	}
+	const normalizedKeys = apiKeys.filter((key) => typeof key === "string").map((key) => key.trim()).filter((key) => key.length > 0);
+	if (normalizedKeys.length !== apiKeys.length) consola.warn("Invalid auth.apiKeys entries found. Only non-empty strings are allowed.");
+	return [...new Set(normalizedKeys)];
+}
+function getConfiguredApiKeys() {
+	return normalizeApiKeys(getConfig().auth?.apiKeys);
+}
+function getMissingApiKeysMessage() {
+	if (getConfiguredApiKeys().length > 0) return null;
+	return ["Requests currently bypass authentication.", "Run `npx copilot-api auth keys --add <key>` to enable API key auth."].join(" ");
+}
+function normalizeApiKey(apiKey) {
+	if (typeof apiKey !== "string") return null;
+	return apiKey.trim() || null;
+}
+function getConfiguredAdminApiKeys() {
+	const adminApiKey = normalizeApiKey(getConfig().auth?.adminApiKey);
+	return adminApiKey ? [adminApiKey] : [];
+}
+function extractRequestApiKey(c) {
+	const xApiKey = c.req.header("x-api-key")?.trim();
+	if (xApiKey) return xApiKey;
+	const authorization = c.req.header("authorization");
+	if (!authorization) return null;
+	const [scheme, ...rest] = authorization.trim().split(/\s+/);
+	if (scheme.toLowerCase() !== "bearer") return null;
+	return rest.join(" ").trim() || null;
+}
+function createUnauthorizedResponse(c) {
+	c.header("WWW-Authenticate", "Bearer realm=\"copilot-api\"");
+	return c.json({ error: {
+		message: "Unauthorized",
+		type: "authentication_error"
+	} }, 401);
+}
+function createAuthMiddleware(options = {}) {
+	const getApiKeys = options.getApiKeys ?? getConfiguredApiKeys;
+	const allowUnauthenticatedPaths = options.allowUnauthenticatedPaths ?? ["/"];
+	const allowOptionsBypass = options.allowOptionsBypass ?? true;
+	const allowWhenNoApiKeys = options.allowWhenNoApiKeys ?? true;
+	const shouldSkipPath = options.shouldSkipPath ?? (() => false);
+	return async (c, next) => {
+		if (allowOptionsBypass && c.req.method === "OPTIONS") return next();
+		if (shouldSkipPath(c.req.path)) return next();
+		if (allowUnauthenticatedPaths.includes(c.req.path)) return next();
+		const apiKeys = getApiKeys();
+		if (apiKeys.length === 0) return allowWhenNoApiKeys ? next() : createUnauthorizedResponse(c);
+		const requestApiKey = extractRequestApiKey(c);
+		if (!requestApiKey || !apiKeys.includes(requestApiKey)) return createUnauthorizedResponse(c);
+		return next();
+	};
+}
+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 applyCopilotTokenResponse = (response) => {
+	state.copilotToken = response.token;
+	if (response.endpoints?.api) state.copilotApiUrl = response.endpoints.api;
+};
+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 response = await getCopilotToken();
+	applyCopilotTokenResponse(response);
+	consola.debug("GitHub Copilot Token fetched successfully!");
+	if (state.showToken) consola.info("Copilot token:", state.copilotToken);
+	stopCopilotRefreshLoop();
+	const controller = new AbortController();
+	copilotRefreshLoopController = controller;
+	runCopilotRefreshLoop(response.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 response = await getCopilotToken();
+			applyCopilotTokenResponse(response);
+			refreshAtMs = getRefreshDeadlineMs(response.refresh_in);
+			retryDelayMs = RETRY_REFRESH_DELAY_MS;
+			consola.debug("Copilot token refreshed");
+			if (state.showToken) consola.info("Refreshed Copilot token:", state.copilotToken);
+		} 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 { getConfiguredApiKeys as A, fetchResponsesWithLifecycle as B, compactAutoContinuePromptStarts as C, compactTextOnlyGuard as D, compactSystemPromptStarts as E, forwardCodexResponses as F, createWebSocketUrl as G, encodePoolKeyPart as H, generateTraceId as I, forwardError as J, state as K, requestContext as L, loginCodex as M, CODEX_API_BASE_URL as N, createAuthMiddleware as O, buildCodexRequestHeaders as P, resolveTraceId as R, initOpencodeVersion as S, compactSummaryPromptStart as T, isTerminalResponsesStreamChunk as U, createResponsesSafeStream as V, createPooledWebSocketStream as W, 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, getMissingApiKeysMessage as j, getConfiguredAdminApiKeys as k, isAsyncIterable as l, readGitHubToken as m, persistCodexCredentials as n, generateRequestIdFromPayload as o, getCopilotUsage as p, HTTPError as q, setupCodexToken as r, getRootSessionId as s, logUser as t, isNullish as u, copilotWebSocketHeaders as v, compactMessageSections as w, prepareMessageProxyHeaders as x, prepareForCompact as y, createResponsesHttpEventStream as z };