copilot-relay 0.4.5 → 0.4.6

package/dist/main.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import fs from "node:fs/promises";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 import timers from "node:timers";
 import { inspect, isDeepStrictEqual, promisify } from "node:util";
 import consola from "consola";
 import os from "node:os";
 import path, { dirname, posix, resolve } from "node:path";
+import { Agent, EnvHttpProxyAgent, ProxyAgent, fetch } from "undici";
 import { fileURLToPath } from "node:url";
-import { Agent, fetch as fetch$1 } from "undici";
-import { readFileSync } from "node:fs";
-import { isIPv4 } from "node:net";
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import { BlockList, isIP, isIPv4 } from "node:net";
 import { createAdaptorServer } from "@hono/node-server";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -35,6 +35,19 @@ var HTTPError = class extends Error {
 		this.response = response;
 	}
 };
+var PromptTooLongError = class extends HTTPError {
+	constructor(tokens, limit, detail) {
+		const message = tokens !== void 0 && limit !== void 0 ? `prompt is too long: ${tokens} tokens > ${limit} maximum` : "prompt is too long";
+		super(message, Response.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message
+			}
+		}, { status: 400 }), detail);
+		this.name = "PromptTooLongError";
+	}
+};
 
 //#endregion
 //#region src/lib/paths.ts
@@ -188,6 +201,20 @@ const formatUrlForDisplay = (raw) => {
 	return isOriginOnly(parsed) ? raw : `${parsed.origin} (path/query/fragment hidden)`;
 };
 /**
+* Renders an upstreamProxy value for display: "env" as written, a proxy URL as
+* its origin.
+*
+* A proxy URL may carry a user name and password. Neither is shown; a marker
+* says they were there, so a reader can still tell the proxy authenticates.
+* Never throws.
+*/
+const formatUpstreamProxyForDisplay = (upstreamProxy) => {
+	if (upstreamProxy === "env") return upstreamProxy;
+	const parsed = parseHttpUrl(upstreamProxy);
+	if (!parsed) return "(invalid url)";
+	return parsed.username !== "" || parsed.password !== "" ? `${parsed.origin} (credentials hidden)` : parsed.origin;
+};
+/**
 * Strips ANSI escapes and control bytes from a string bound for the terminal.
 *
 * `status` prints config values directly to stdout. A config string carrying
@@ -253,7 +280,7 @@ const scrubSensitiveUrls = (text$1) => {
 const logCleanupCheckIntervalMs = 3600 * 1e3;
 let logRetentionDays = 3;
 let nextLogCleanupCheckAt = 0;
-const datedLogFilePattern = /* @__PURE__ */ new RegExp(`^${paths.logFileBaseName}\\.(\\d{4})-(\\d{2})-(\\d{2})\\.log$`);
+const datedLogFilePattern$1 = /* @__PURE__ */ new RegExp(`^${paths.logFileBaseName}\\.(\\d{4})-(\\d{2})-(\\d{2})\\.log$`);
 const consolaLevelByName = {
 	error: 0,
 	info: 3,
@@ -268,6 +295,7 @@ const loggingSuppressed = new AsyncLocalStorage();
 const consoleSuppressed = new AsyncLocalStorage();
 const withoutLogging = (run) => loggingSuppressed.run(true, run);
 const withoutConsoleLogging = (run) => consoleSuppressed.run(true, run);
+const isLoggingSuppressed = () => loggingSuppressed.getStore() === true;
 let currentLogLevel = consolaLevelByName.info;
 const registeredLogSecrets = /* @__PURE__ */ new Set();
 const logSecretForms = /* @__PURE__ */ new Set();
@@ -342,7 +370,7 @@ const formatLogValue = (value) => typeof value === "string" ? value : inspect(va
 	maxStringLength: 4e3
 });
 const escapeLogLineSeparators = (value) => value.replaceAll("\r", "\\r").replaceAll("\n", "\\n").replaceAll(String.fromCodePoint(8232), "\\u2028").replaceAll(String.fromCodePoint(8233), "\\u2029");
-const isMissing$1 = (error) => error.code === "ENOENT";
+const isMissing$2 = (error) => error.code === "ENOENT";
 const sameFile$2 = (left, right) => left.dev === right.dev && left.ino === right.ino;
 const ensurePrivateDirectory = async (directory) => {
 	await fs.mkdir(directory, { mode: 448 }).catch((error) => {
@@ -380,7 +408,7 @@ const isStillActive = async (active) => {
 };
 const openPrivateLog = async (filePath, directories) => {
 	const observed = await fs.lstat(filePath).catch((error) => {
-		if (!isMissing$1(error)) throw error;
+		if (!isMissing$2(error)) throw error;
 	});
 	if (observed && (!observed.isFile() || observed.isSymbolicLink() || observed.nlink !== 1)) throw new Error("Refusing an unsafe log file");
 	const flags = fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | (process.platform === "win32" ? 0 : fs.constants.O_NOFOLLOW);
@@ -521,7 +549,7 @@ consola.debug = wrapFileLog("debug", consola.debug.bind(consola));
 * extend or shorten the retention window.
 */
 const parseLogFileDate = (fileName) => {
-	const match = datedLogFilePattern.exec(fileName);
+	const match = datedLogFilePattern$1.exec(fileName);
 	if (!match) return;
 	const [, year, month, day] = match;
 	const date = new Date(Number(year), Number(month) - 1, Number(day));
@@ -535,10 +563,10 @@ const cleanupLogs = async (retentionDays) => {
 	oldestDay.setDate(oldestDay.getDate() - (retentionDays - 1));
 	const cutoff = oldestDay.getTime();
 	const entries = await fs.readdir(paths.logsDir, { withFileTypes: true });
-	await Promise.all(entries.filter((entry) => entry.isFile() && (entry.name === `${paths.logFileBaseName}.log` || datedLogFilePattern.test(entry.name))).map(async (entry) => {
+	await Promise.all(entries.filter((entry) => entry.isFile() && (entry.name === `${paths.logFileBaseName}.log` || datedLogFilePattern$1.test(entry.name))).map(async (entry) => {
 		const filePath = `${paths.logsDir}/${entry.name}`;
 		const current = await fs.lstat(filePath).catch((error) => {
-			if (!isMissing$1(error)) throw error;
+			if (!isMissing$2(error)) throw error;
 		});
 		if (!current?.isFile() || current.nlink !== 1) return;
 		if ((parseLogFileDate(entry.name)?.getTime() ?? current.mtimeMs) < cutoff) await fs.rm(filePath, { force: true });
@@ -546,6 +574,216 @@ const cleanupLogs = async (retentionDays) => {
 };
 const log = consola;
 
+//#endregion
+//#region src/lib/upstream-dispatcher.ts
+const connectionOptions = {
+	allowH2: false,
+	connect: { allowH2: false },
+	keepAliveTimeout: 5e4
+};
+/**
+* A malformed HTTPS_PROXY or HTTP_PROXY with upstreamProxy: env. The message is fixed: the proxy
+* URL comes from the environment, can carry a password, and undici's own error repeats it. This
+* message reaches the terminal and the log.
+*/
+var InvalidProxyEnvironmentError = class extends Error {
+	constructor() {
+		super("Invalid HTTPS_PROXY or HTTP_PROXY: with upstreamProxy: env, each one that is set must be an absolute http(s) proxy URL");
+		this.name = "InvalidProxyEnvironmentError";
+	}
+};
+/**
+* Builds the dispatcher for one resolved upstreamProxy value.
+*
+* Empty connects directly, as every release before #153 did. "env" hands HTTPS_PROXY, HTTP_PROXY
+* and NO_PROXY, in upper or lower case, to EnvHttpProxyAgent. Anything else is a proxy URL that
+* normalizeUpstreamProxy has already validated.
+*/
+const buildUpstreamDispatcher = (upstreamProxy) => {
+	if (upstreamProxy === void 0) return new Agent(connectionOptions);
+	if (upstreamProxy === "env") try {
+		return new EnvHttpProxyAgent(connectionOptions);
+	} catch {
+		throw new InvalidProxyEnvironmentError();
+	}
+	return new ProxyAgent({
+		...connectionOptions,
+		uri: upstreamProxy
+	});
+};
+let upstreamDispatcher = buildUpstreamDispatcher(void 0);
+let configuredUpstreamProxy;
+/**
+* The proxy URLs a dispatcher for this upstreamProxy can send through: none when it is empty, the
+* URL itself, or with "env" each proxy variable EnvHttpProxyAgent reads, the lower-case spelling
+* first, as undici does.
+*/
+const proxyUrlsFor = (upstreamProxy) => {
+	if (upstreamProxy === void 0) return [];
+	if (upstreamProxy !== "env") return [upstreamProxy];
+	return [process.env.http_proxy ?? process.env.HTTP_PROXY, process.env.https_proxy ?? process.env.HTTPS_PROXY].filter((value) => value !== void 0 && value !== "");
+};
+const decodeOrKeep = (value) => {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+};
+const parseProxyUrl = (proxyUrl) => {
+	try {
+		return new URL(proxyUrl);
+	} catch {
+		return;
+	}
+};
+/**
+* The forms a proxy's credentials take together: user:password as written in the URL and decoded,
+* and the Basic value undici sends in Proxy-Authorization. None when the URL lacks either part,
+* because undici then sends no Proxy-Authorization at all.
+*/
+const credentialPairForms = (proxyUrl) => {
+	const url = parseProxyUrl(proxyUrl);
+	if (url === void 0 || url.username === "" || url.password === "") return [];
+	const decoded$1 = `${decodeOrKeep(url.username)}:${decodeOrKeep(url.password)}`;
+	return [
+		`${url.username}:${url.password}`,
+		decoded$1,
+		Buffer.from(decoded$1).toString("base64")
+	];
+};
+const credentialForms = (proxyUrl) => {
+	const url = parseProxyUrl(proxyUrl);
+	if (url === void 0) return [];
+	return [
+		...credentialPairForms(proxyUrl),
+		url.username,
+		decodeOrKeep(url.username),
+		url.password,
+		decodeOrKeep(url.password)
+	].filter((form) => form !== "");
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+let activeCredentialPattern;
+const minimumRegisteredLength = 8;
+/**
+* Builds this process's upstream dispatcher from the resolved upstreamProxy, and registers the
+* credentials of each proxy it can use with the log redaction.
+*
+* start, auth, models and usage call it once, after reading the config and before their first
+* upstream call. Until one does, upstream calls connect directly, as they did before the key
+* existed. A config reload never calls it, which is why upstreamProxy, like host and port, takes
+* effect on restart, and why a reload registers no credentials. It is never undici's global
+* dispatcher, and calls to the relay itself never use it.
+*
+* Only the user:password pair and the Basic value are registered, never a user name or password
+* alone: registerLogSecret replaces a value in every log line, and a short or common user name such
+* as "copilot" would also cut it out of "copilot-relay".
+*/
+const configureUpstreamDispatcher = (upstreamProxy) => {
+	const previous = upstreamDispatcher;
+	upstreamDispatcher = buildUpstreamDispatcher(upstreamProxy);
+	configuredUpstreamProxy = upstreamProxy;
+	const proxyUrls = proxyUrlsFor(upstreamProxy);
+	for (const form of proxyUrls.flatMap((proxyUrl) => credentialPairForms(proxyUrl))) if (form.length >= minimumRegisteredLength) registerLogSecret(form);
+	const forms = [...new Set(proxyUrls.flatMap((proxyUrl) => credentialForms(proxyUrl)))].sort((left, right) => right.length - left.length);
+	activeCredentialPattern = forms.length === 0 ? void 0 : new RegExp(forms.map((form) => escapeRegExp(form)).join("|"), "g");
+	previous.close().catch(() => void 0);
+};
+const proxyVariables = [
+	"HTTPS_PROXY",
+	"https_proxy",
+	"HTTP_PROXY",
+	"http_proxy"
+];
+let proxyHintLogged = false;
+/**
+* Logs, once per process, that a proxy the environment names was not used.
+*
+* Only for a request that failed without an HTTP response while upstreamProxy is empty: the relay
+* ignored HTTPS_PROXY or HTTP_PROXY and went direct, and those variables suggest the network
+* expects a proxy. A cancelled request or a passed deadline is not that kind of failure.
+*
+* The hint counts as logged only once it is written. Under withoutLogging, where models --deep
+* runs its probes, log.error writes nothing, so a failure there leaves the hint for a later one.
+*/
+const noteConnectionFailure = (signal) => {
+	if (proxyHintLogged || configuredUpstreamProxy !== void 0 || signal?.aborted || isLoggingSuppressed()) return;
+	if (!proxyVariables.some((name) => process.env[name])) return;
+	proxyHintLogged = true;
+	log.error(`Upstream request failed without a response. HTTPS_PROXY or HTTP_PROXY is set, but upstreamProxy is empty, so copilot-relay connected directly. To use that proxy, set upstreamProxy: env in ${paths.configPath}, then run the command again or restart the relay.`);
+};
+const redacted = "[redacted]";
+const rawPayloadKeys = ["data", "body"];
+const replaceText = (error, key, value) => {
+	try {
+		Object.defineProperty(error, key, {
+			configurable: true,
+			enumerable: false,
+			value,
+			writable: true
+		});
+	} catch {}
+};
+const scrubStackHead = (stack, pattern) => {
+	const frames = stack.search(/\n\s+at /);
+	if (frames === -1) return stack.replace(pattern, redacted);
+	return stack.slice(0, frames).replace(pattern, redacted) + stack.slice(frames);
+};
+/**
+* Cleans the error of an upstream request that failed without a response, in place, so it keeps
+* its type, code and cause, which callers read.
+*
+* It drops the raw payload undici can keep from the peer anywhere in the cause chain: a proxy that
+* answers CONNECT with a reply undici cannot parse leaves the rest of that reply in
+* HTTPParserError.data, and a reply that echoes Proxy-Authorization would carry the password into
+* every log line that prints the error. It also replaces every form of the active proxy's
+* credentials in each message, short ones and a user name or password alone included: unlike the
+* log redaction, only this error changes.
+*/
+const sanitizeTransportError = (error, seen = /* @__PURE__ */ new Set()) => {
+	if (!(error instanceof Error) || seen.has(error)) return;
+	seen.add(error);
+	for (const key of rawPayloadKeys) Reflect.deleteProperty(error, key);
+	if (activeCredentialPattern !== void 0) {
+		if (typeof error.message === "string") {
+			const message = error.message.replace(activeCredentialPattern, redacted);
+			if (message !== error.message) replaceText(error, "message", message);
+		}
+		if (typeof error.stack === "string") {
+			const stack = scrubStackHead(error.stack, activeCredentialPattern);
+			if (stack !== error.stack) replaceText(error, "stack", stack);
+		}
+	}
+	sanitizeTransportError(error.cause, seen);
+	if (error instanceof AggregateError) for (const inner of error.errors) sanitizeTransportError(inner, seen);
+};
+/**
+* fetch for an upstream call, through this process's upstream dispatcher.
+*
+* A request that fails without a response rejects with its error cleaned by
+* sanitizeTransportError, before any caller can log it. The undici response is rewrapped as a
+* global Response, so callers, HTTPError included, keep the Response type the rest of the relay
+* uses.
+*/
+const fetchUpstream = async (url, init) => {
+	const response = await fetch(url, {
+		...init,
+		dispatcher: upstreamDispatcher
+	}).catch((error) => {
+		sanitizeTransportError(error);
+		noteConnectionFailure(init.signal);
+		throw error;
+	});
+	const wrappedResponse = new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	Object.defineProperty(wrappedResponse, "url", { value: response.url });
+	return wrappedResponse;
+};
+
 //#endregion
 //#region src/lib/auth.ts
 const copilotVersion$1 = "0.26.7";
@@ -570,6 +808,18 @@ const readGitHubToken = async () => {
 	registerLogSecret(token.trim());
 	return token.trim();
 };
+const readStoredGitHubToken = async () => {
+	let content;
+	try {
+		content = await fs.readFile(paths.githubTokenPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	const token = content.trim();
+	registerLogSecret(token);
+	return token === "" ? void 0 : token;
+};
 const writeGitHubToken = async (token) => {
 	registerLogSecret(token.trim());
 	await ensurePaths();
@@ -632,7 +882,7 @@ const githubHeaders = (githubToken, vsCodeVersion) => ({
 	"x-vscode-user-agent-library-version": "electron-fetch"
 });
 const getDeviceCode = async () => {
-	const response = await fetch(`${githubBaseUrl}/login/device/code`, {
+	const response = await fetchUpstream(`${githubBaseUrl}/login/device/code`, {
 		method: "POST",
 		headers: standardHeaders(),
 		body: JSON.stringify({
@@ -646,7 +896,7 @@ const getDeviceCode = async () => {
 const pollAccessToken = async (deviceCode) => {
 	const sleepDuration = (deviceCode.interval + 1) * 1e3;
 	while (true) {
-		const response = await fetch(`${githubBaseUrl}/login/oauth/access_token`, {
+		const response = await fetchUpstream(`${githubBaseUrl}/login/oauth/access_token`, {
 			method: "POST",
 			headers: standardHeaders(),
 			body: JSON.stringify({
@@ -665,18 +915,26 @@ const pollAccessToken = async (deviceCode) => {
 	}
 };
 const getGitHubUser = async (githubToken, vsCodeVersion) => {
-	const response = await fetch(`${githubApiBaseUrl}/user`, { headers: githubHeaders(githubToken, vsCodeVersion) });
+	const response = await fetchUpstream(`${githubApiBaseUrl}/user`, { headers: githubHeaders(githubToken, vsCodeVersion) });
 	if (!response.ok) throw new HTTPError("Failed to get GitHub user", response);
 	return await response.json();
 };
 const getCopilotToken = async (githubToken, vsCodeVersion, signal) => {
-	const response = await fetch(`${githubApiBaseUrl}/copilot_internal/v2/token`, {
+	const response = await fetchUpstream(`${githubApiBaseUrl}/copilot_internal/v2/token`, {
 		headers: githubHeaders(githubToken, vsCodeVersion),
 		signal
 	});
 	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
 	return await response.json();
 };
+const getCopilotUsage = async (githubToken, vsCodeVersion, signal) => {
+	const response = await fetchUpstream(`${githubApiBaseUrl}/copilot_internal/user`, {
+		headers: githubHeaders(githubToken, vsCodeVersion),
+		signal
+	});
+	if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
+	return response.json();
+};
 const isCopilotTokenError = (error) => error instanceof HTTPError && error.message === "Failed to get Copilot token";
 const ensureGitHubToken = async (options = {}) => {
 	const existingToken = options.force ? "" : await readGitHubToken();
@@ -861,7 +1119,13 @@ var FileConflictError = class extends Error {
 		this.name = "FileConflictError";
 	}
 };
-const isMissing = (error) => error.code === "ENOENT";
+var NotRegularFileError = class extends Error {
+	constructor(filePath) {
+		super(`${filePath} is not a regular file`);
+		this.name = "NotRegularFileError";
+	}
+};
+const isMissing$1 = (error) => error.code === "ENOENT";
 const identityOf = (stat) => ({
 	dev: stat.dev,
 	ino: stat.ino,
@@ -874,9 +1138,9 @@ const resolveTarget = async (filePath, remainingLinks = 40) => {
 	try {
 		return await fs.realpath(filePath);
 	} catch (error) {
-		if (!isMissing(error)) throw error;
+		if (!isMissing$1(error)) throw error;
 		if ((await fs.lstat(filePath).catch((cause) => {
-			if (!isMissing(cause)) throw cause;
+			if (!isMissing$1(cause)) throw cause;
 		}))?.isSymbolicLink()) {
 			if (remainingLinks === 0) throw new Error("Too many symbolic links");
 			return resolveTarget(path.resolve(path.dirname(filePath), await fs.readlink(filePath)), remainingLinks - 1);
@@ -890,7 +1154,7 @@ const readStableSnapshot = async (filePath) => {
 	const requestedPath = path.resolve(filePath);
 	const resolvedPath = await resolveTarget(requestedPath);
 	const before = await fs.lstat(resolvedPath).catch((error) => {
-		if (!isMissing(error)) throw error;
+		if (!isMissing$1(error)) throw error;
 	});
 	if (!before) return {
 		requestedPath,
@@ -899,14 +1163,14 @@ const readStableSnapshot = async (filePath) => {
 		mode: 384,
 		identity: null
 	};
-	if (!before.isFile()) throw new FileConflictError();
+	if (!before.isFile()) throw new NotRegularFileError(resolvedPath);
 	let raw;
 	let after;
 	try {
 		raw = await fs.readFile(resolvedPath, "utf8");
 		after = await fs.lstat(resolvedPath);
 	} catch (error) {
-		if (isMissing(error)) throw new FileConflictError();
+		if (isMissing$1(error)) throw new FileConflictError();
 		throw error;
 	}
 	const snapshot = {
@@ -955,7 +1219,7 @@ const assertUnchanged = async (expected) => {
 	if (current.resolvedPath !== expected.resolvedPath || current.raw !== expected.raw || current.mode !== expected.mode || !sameIdentity(current.identity, expected.identity)) throw new FileConflictError();
 };
 const pendingWrites = /* @__PURE__ */ new Map();
-const publish = async (snapshot, content) => {
+const publish = async (snapshot, content, options) => {
 	await assertUnchanged(snapshot);
 	const directory = path.dirname(snapshot.resolvedPath);
 	await fs.mkdir(directory, {
@@ -968,7 +1232,7 @@ const publish = async (snapshot, content) => {
 	try {
 		try {
 			await handle.writeFile(content, "utf8");
-			if (process.platform !== "win32") await handle.chmod(snapshot.mode);
+			if (process.platform !== "win32") await handle.chmod(options.ownerOnly ? 384 : snapshot.mode);
 			await handle.sync();
 		} finally {
 			await handle.close();
@@ -985,8 +1249,8 @@ const publish = async (snapshot, content) => {
 		await fs.rm(temporaryPath, { force: true });
 	}
 };
-const writeFileSnapshot = async (snapshot, content) => {
-	const current = (pendingWrites.get(snapshot.resolvedPath) ?? Promise.resolve()).catch(() => void 0).then(() => publish(snapshot, content));
+const writeFileSnapshot = async (snapshot, content, options = {}) => {
+	const current = (pendingWrites.get(snapshot.resolvedPath) ?? Promise.resolve()).catch(() => void 0).then(() => publish(snapshot, content, options));
 	pendingWrites.set(snapshot.resolvedPath, current);
 	try {
 		await current;
@@ -995,6 +1259,29 @@ const writeFileSnapshot = async (snapshot, content) => {
 	}
 };
 
+//#endregion
+//#region src/lib/terminal.ts
+const colorEnabled = (env = process.env, isTTY = Boolean(process.stdout.isTTY)) => {
+	if (env.NO_COLOR !== void 0 || env.FORCE_COLOR === "0") return false;
+	if (env.FORCE_COLOR !== void 0) return env.FORCE_COLOR === "" || [
+		"1",
+		"2",
+		"3",
+		"true"
+	].includes(env.FORCE_COLOR);
+	return isTTY && env.TERM !== "dumb";
+};
+const ansiColorCodes = {
+	good: 32,
+	bad: 31,
+	warning: 33,
+	muted: 90
+};
+const hiddenCharacters = /[\x80-\x9f]|\p{Cf}|\p{Zl}|\p{Zp}/gu;
+const withoutHiddenCharacters = (value) => value.replace(hiddenCharacters, "");
+const terminalText = (value) => withoutHiddenCharacters(sanitizeTerminalString(value));
+const colorText = (text$1, tone, enabled) => enabled ? `\u001b[${ansiColorCodes[tone]}m${text$1}\u001b[0m` : text$1;
+
 //#endregion
 //#region src/lib/app-config.ts
 const logLevels = [
@@ -1011,6 +1298,7 @@ const logLevels = [
 * rewrite a value the user's config already holds.
 */
 const defaultConfig = {
+	apiKey: "",
 	claudeSetup: true,
 	copilotBaseUrl: "https://api.githubcopilot.com",
 	gptModel: "gpt-6-astra",
@@ -1022,6 +1310,7 @@ const defaultConfig = {
 	thinkEffort: defaultReasoningEffort,
 	upstreamTimeoutSeconds: 180,
 	webSearchBackend: void 0,
+	upstreamProxy: void 0,
 	claudeUpstreamApi: "chat-completions"
 };
 const isLogLevelName = (value) => typeof value === "string" && logLevels.includes(value.toLowerCase());
@@ -1029,7 +1318,7 @@ const normalizeLogLevel = (value) => {
 	if (value === void 0) return;
 	if (typeof value !== "string") throw new Error(`Invalid logLevel: expected one of ${logLevels.join(", ")}`);
 	const normalized = value.toLowerCase();
-	if (!isLogLevelName(normalized)) throw new Error(`Invalid logLevel "${value}": expected one of ${logLevels.join(", ")}`);
+	if (!isLogLevelName(normalized)) throw new Error(`Invalid logLevel: expected one of ${logLevels.join(", ")}`);
 	return normalized;
 };
 const normalizeClaudeUpstreamApi = (value) => {
@@ -1059,6 +1348,22 @@ const normalizeRequiredString = (value, key) => {
 	if (normalized === void 0) throw new Error(`Invalid ${key}: expected a non-empty string`);
 	return normalized;
 };
+const invalidApiKeyMessage = "Invalid apiKey: expected empty, or at least 16 visible ASCII characters";
+/**
+* Validates the optional inbound apiKey. Empty disables it.
+*
+* A set key is at least 16 visible ASCII characters. It travels in an HTTP
+* header, which cannot carry a space, a control byte or a non-ASCII character
+* reliably. Every logged copy of it is redacted as text, which would also hide
+* any ordinary text that a very short key happened to match.
+*/
+const normalizeApiKey = (value) => {
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(invalidApiKeyMessage);
+	const trimmed = value.trim();
+	if (trimmed !== "" && !/^[\x21-\x7E]{16,}$/.test(trimmed)) throw new Error(invalidApiKeyMessage);
+	return trimmed;
+};
 /**
 * A conventional http(s) URL: scheme followed by a literal "//" authority.
 *
@@ -1140,6 +1445,49 @@ const normalizeCopilotBaseUrl = (value) => {
 	if (parsed.username || parsed.password) throw new Error(copilotBaseUrlCredentialsMessage);
 	return trimmed;
 };
+/**
+* Fixed strings, like the copilotBaseUrl messages: a proxy URL can carry a password, and these
+* messages reach the terminal and the log, so the rejected value is never repeated.
+*/
+const invalidUpstreamProxyMessage = "Invalid upstreamProxy: expected empty, env, or an absolute http(s) proxy URL such as http://proxy.example:3128";
+const upstreamProxyPathMessage = "Invalid upstreamProxy: a proxy URL takes no path, query or fragment";
+const upstreamProxyCredentialsMessage = "Invalid upstreamProxy: credentials need both a username and a password, with reserved characters percent-encoded";
+const canDecodeURIComponent = (value) => {
+	try {
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* Validates upstreamProxy: empty, the literal "env", or an absolute http(s) proxy URL.
+*
+* Each rule stops a value that undici's ProxyAgent would turn into a confusing failure. A path,
+* query or fragment makes it throw "invalid url" when the relay builds its dispatcher. A username
+* without a password, or the reverse, makes it send no Proxy-Authorization at all. A malformed
+* percent-escape in the credentials makes its decodeURIComponent throw. The explicit "http://" or
+* "https://" prefix is required for the reason copilotBaseUrl requires it: the shorthand forms
+* WHATWG also accepts are not URLs anyone would recognize in a log line.
+*
+* Userinfo is accepted, unlike in copilotBaseUrl: it is how a proxy takes Basic credentials, and
+* configureUpstreamDispatcher registers it with the log redaction when it builds the dispatcher.
+*
+* The accepted value is the trimmed original, which is what the dispatcher is built from.
+*/
+const normalizeUpstreamProxy = (value) => {
+	const trimmed = normalizeString(value);
+	if (trimmed === void 0 || trimmed === "env") return trimmed;
+	if (!conventionalHttpUrlPattern.test(trimmed)) throw new Error(invalidUpstreamProxyMessage);
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		throw new Error(invalidUpstreamProxyMessage);
+	}
+	if (parsed.pathname !== "/" || parsed.search || parsed.hash) throw new Error(upstreamProxyPathMessage);
+	if (parsed.username !== "" !== (parsed.password !== "") || !canDecodeURIComponent(parsed.username) || !canDecodeURIComponent(parsed.password)) throw new Error(upstreamProxyCredentialsMessage);
+	return trimmed;
+};
 var InvalidThinkEffortError = class extends Error {
 	constructor() {
 		super(`Invalid thinkEffort. Valid values: ${configurableReasoningEfforts.join(", ")}. "none" is not allowed as a configured default.`);
@@ -1180,6 +1528,7 @@ const readDefaultConfigTemplate = async () => {
 	}
 };
 const configAliases = {
+	api_key: "apiKey",
 	claude_setup: "claudeSetup",
 	copilot_base_url: "copilotBaseUrl",
 	gpt_model: "gptModel",
@@ -1187,6 +1536,7 @@ const configAliases = {
 	log_retention_days: "logRetentionDays",
 	opus_model: "opusModel",
 	think_effort: "thinkEffort",
+	upstream_proxy: "upstreamProxy",
 	upstream_timeout_seconds: "upstreamTimeoutSeconds",
 	web_search_backend: "webSearchBackend",
 	claude_upstream_api: "claudeUpstreamApi"
@@ -1238,7 +1588,7 @@ const serializeConfig = (config) => [
 	"# copilot-relay configuration",
 	"#",
 	"# Valid complete edits hot-reload without rewriting this file.",
-	"# host, port, and claudeSetup require restart.",
+	"# host, port, claudeSetup, and upstreamProxy require restart.",
 	"",
 	"# Local host for the Claude Code-compatible HTTP server.",
 	`host: ${config.host}`,
@@ -1246,9 +1596,17 @@ const serializeConfig = (config) => [
 	"# Local port for the HTTP server.",
 	`port: ${config.port}`,
 	"",
+	"# Key clients must send as x-api-key or Authorization: Bearer; empty disables it.",
+	"# Set one before binding host beyond loopback.",
+	`apiKey: ${config.apiKey}`,
+	"",
 	"# GitHub Copilot API base URL.",
 	`copilotBaseUrl: ${config.copilotBaseUrl}`,
 	"",
+	"# Outbound proxy for Copilot and GitHub calls. Empty connects directly; env uses",
+	"# HTTPS_PROXY, HTTP_PROXY and NO_PROXY; or a URL such as http://proxy.example:3128.",
+	`upstreamProxy: ${config.upstreamProxy ?? ""}`,
+	"",
 	"# Update ~/.claude/settings.json on start.",
 	`claudeSetup: ${config.claudeSetup}`,
 	"",
@@ -1283,6 +1641,7 @@ const serializeConfig = (config) => [
 	""
 ].join("\n");
 const resolveConfig = (raw) => ({
+	apiKey: normalizeApiKey(raw.apiKey) ?? defaultConfig.apiKey,
 	claudeSetup: normalizeBoolean(raw.claudeSetup) ?? defaultConfig.claudeSetup,
 	copilotBaseUrl: normalizeCopilotBaseUrl(normalizeRequiredString(raw.copilotBaseUrl, "copilotBaseUrl")) ?? defaultConfig.copilotBaseUrl,
 	gptModel: normalizeRequiredString(raw.gptModel, "gptModel") ?? defaultConfig.gptModel,
@@ -1294,6 +1653,7 @@ const resolveConfig = (raw) => ({
 	thinkEffort: normalizeThinkEffort(raw.thinkEffort) ?? defaultConfig.thinkEffort,
 	upstreamTimeoutSeconds: normalizeUpstreamTimeoutSeconds(raw.upstreamTimeoutSeconds) ?? defaultConfig.upstreamTimeoutSeconds,
 	webSearchBackend: normalizeString(raw.webSearchBackend),
+	upstreamProxy: normalizeUpstreamProxy(raw.upstreamProxy),
 	claudeUpstreamApi: normalizeClaudeUpstreamApi(raw.claudeUpstreamApi) ?? defaultConfig.claudeUpstreamApi
 });
 async function readAppConfig() {
@@ -1305,26 +1665,64 @@ async function readAppConfig() {
 	if (content !== snapshot.raw) await writeFileSnapshot(snapshot, content);
 	return config;
 }
+/**
+* Reads and resolves config.yaml without creating, completing or rewriting it, for a command that
+* writes no file, such as `usage`. Returns undefined when there is no config.yaml; unlike
+* readAppConfig, it consults neither a legacy config file nor the default template. An invalid
+* file throws the error readAppConfig would.
+*/
+const readExistingAppConfig = async () => {
+	const snapshot = await readFileSnapshot(paths.configPath);
+	if (snapshot.raw === null) return;
+	return resolveConfig(parseConfigYaml(snapshot.raw));
+};
 const sameSnapshot = (left, right) => left.resolvedPath === right.resolvedPath && left.raw === right.raw && left.mode === right.mode && JSON.stringify(left.identity) === JSON.stringify(right.identity);
+const isSameFailure = (reported, reason, snapshot) => {
+	if (!reported || reported.reason !== reason) return false;
+	if (!reported.snapshot || !snapshot) return reported.snapshot === snapshot;
+	return sameSnapshot(reported.snapshot, snapshot);
+};
+const readConfigSnapshot = async () => {
+	try {
+		return await readFileSnapshot(paths.configPath);
+	} catch (error) {
+		if (error instanceof FileConflictError) return;
+		throw error;
+	}
+};
 const watchAppConfig = (onReload) => {
 	let lastSnapshot;
+	let reportedFailure;
 	let reloading = false;
 	const timer = setInterval(async () => {
 		if (reloading) return;
 		reloading = true;
+		let snapshot;
 		try {
-			const snapshot = await readFileSnapshot(paths.configPath);
-			if (lastSnapshot && sameSnapshot(lastSnapshot, snapshot)) return;
+			snapshot = await readConfigSnapshot();
+			if (!snapshot) return;
+			if (lastSnapshot && sameSnapshot(lastSnapshot, snapshot)) {
+				reportedFailure = void 0;
+				return;
+			}
 			if (snapshot.raw === null) throw new Error("Config file is missing");
 			const raw = parseConfigYaml(snapshot.raw);
 			if (configKeys.some((key) => !Object.hasOwn(raw, key))) throw new Error("Config reload requires every materialized key");
 			const config = resolveConfig(raw);
-			if (!sameSnapshot(snapshot, await readFileSnapshot(paths.configPath))) throw new FileConflictError();
+			const current = await readConfigSnapshot();
+			if (!current || !sameSnapshot(snapshot, current)) return;
 			onReload(config);
 			lastSnapshot = snapshot;
+			reportedFailure = void 0;
 		} catch (error) {
-			if (error instanceof InvalidThinkEffortError) log.error(`${error.message} Keeping the previous runtime settings.`);
-			else log.error(`Could not reload config. Check ${paths.configPath} for invalid values or file errors.`);
+			const reason = error instanceof Error ? error.message : String(error);
+			if (isSameFailure(reportedFailure, reason, snapshot)) return;
+			reportedFailure = {
+				reason,
+				snapshot
+			};
+			const sentence = /[.!?]$/.test(reason) ? reason : `${reason}.`;
+			log.error(terminalText(`Could not reload config (${paths.configPath}): ${sentence} Keeping the previous runtime settings.`));
 		} finally {
 			reloading = false;
 		}
@@ -1363,7 +1761,8 @@ const readProxyConfig = (config) => ({
 	upstreamTimeoutMs: config.upstreamTimeoutSeconds * 1e3,
 	vsCodeVersion: vscodeVersion,
 	webSearchBackend: config.webSearchBackend,
-	claudeUpstreamApi: config.claudeUpstreamApi
+	claudeUpstreamApi: config.claudeUpstreamApi,
+	apiKey: config.apiKey
 });
 
 //#endregion
@@ -1374,7 +1773,9 @@ const auth = defineCommand({
 		description: "Run GitHub device auth and cache credentials for copilot-relay."
 	},
 	async run() {
-		const config = readProxyConfig(await readAppConfig());
+		const appConfig = await readAppConfig();
+		configureUpstreamDispatcher(appConfig.upstreamProxy);
+		const config = readProxyConfig(appConfig);
 		config.copilotToken = void 0;
 		const authSession = await setupProxyAuth(config, { force: true });
 		if (authSession.githubLogin) log.info(`Logged in as ${authSession.githubLogin}`);
@@ -1382,6 +1783,499 @@ const auth = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/cache-report.ts
+const completionRoutes = [
+	"/chat/completions",
+	"/responses",
+	"/v1/messages"
+];
+/** A flag the command cannot use. The message is shown to the user as it is. */
+var CacheUsageError = class extends Error {};
+const defaultGoal = 95;
+const timestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const fieldPattern = /^([A-Za-z0-9_]+)=(\S+)$/;
+const countPattern = /^\d+$/;
+const countFields = [
+	"input_tokens",
+	"cache_read_input_tokens",
+	"cache_creation_input_tokens"
+];
+const isCompletionRoute = (value) => completionRoutes.some((route) => route === value);
+const parseTimestamp = (text$1) => {
+	if (!timestampPattern.test(text$1)) return;
+	const date = new Date(text$1);
+	if (Number.isNaN(date.getTime()) || date.toISOString() !== text$1) return;
+	return date;
+};
+const isCount = (value) => value !== void 0 && countPattern.test(value) && Number.isSafeInteger(Number(value));
+const countField = (fields, key) => {
+	const value = fields.get(key);
+	return value === void 0 ? void 0 : Number(value);
+};
+/**
+* The completion entry on a log line, or undefined for any other line.
+*
+* Only a successful call is returned: an info entry for HTTP 200 on one of the three routes, with
+* a numeric input_tokens. A line that is not exactly what the relay writes is skipped rather than
+* guessed at, since one bad count would skew a whole row.
+*/
+const parseCompletionLine = (line) => {
+	if (!line.includes(" completion path=")) return;
+	const tokens = line.split(" ");
+	const timestamp = parseTimestamp(tokens[0]);
+	const marker = tokens.indexOf("completion", 2);
+	if (timestamp === void 0 || tokens[1] !== "info" || marker === -1) return;
+	if (!tokens.slice(2, marker).every((token) => fieldPattern.test(token))) return;
+	const fields = /* @__PURE__ */ new Map();
+	for (const token of tokens.slice(marker + 1)) {
+		const field = fieldPattern.exec(token);
+		if (field === null || fields.has(field[1])) return;
+		fields.set(field[1], field[2]);
+	}
+	if (countFields.some((key) => fields.has(key) && !isCount(fields.get(key)))) return;
+	const route = fields.get("path");
+	const inputTokens = countField(fields, "input_tokens");
+	const cacheReadTokens = countField(fields, "cache_read_input_tokens");
+	const cacheWriteTokens = countField(fields, "cache_creation_input_tokens");
+	if (!isCompletionRoute(route) || fields.get("http_status") !== "200" || inputTokens === void 0) return;
+	if (route !== "/v1/messages" && cacheReadTokens !== void 0 && cacheReadTokens > inputTokens) return;
+	return {
+		timestamp,
+		model: terminalText(fields.get("model") ?? "") || "unknown",
+		route,
+		inputTokens,
+		...cacheReadTokens !== void 0 && { cacheReadTokens },
+		...cacheWriteTokens !== void 0 && { cacheWriteTokens }
+	};
+};
+const datedLogFilePattern = /* @__PURE__ */ new RegExp(`^${paths.logFileBaseName}\\.(\\d{4})-(\\d{2})-(\\d{2})\\.log$`);
+const dayNumber = (year, month, day) => year * 1e4 + month * 100 + day;
+const maxLineLength = 1024 * 1024;
+const isMissing = (error) => error.code === "ENOENT";
+const readLogDirectory = async () => {
+	try {
+		return await fs.readdir(paths.logsDir, { withFileTypes: true });
+	} catch (error) {
+		if (isMissing(error)) return [];
+		throw error;
+	}
+};
+/**
+* The dated log files that can hold entries at or after `since`; all of them without it.
+*
+* A file is named for the local date its entries were written on. UTC offsets span 26 hours, from
+* UTC-12 to UTC+14, so after a time-zone change an entry can sit in a file dated up to two days
+* before the date the current zone gives `since`. Those days are read too, and every entry is then
+* checked against `since` itself.
+*/
+const listLogFiles = async (since) => {
+	let earliestDay = Number.NEGATIVE_INFINITY;
+	if (since !== void 0) {
+		const twoDaysBefore = new Date(since.getTime());
+		twoDaysBefore.setDate(twoDaysBefore.getDate() - 2);
+		if (!Number.isNaN(twoDaysBefore.getTime())) earliestDay = dayNumber(twoDaysBefore.getFullYear(), twoDaysBefore.getMonth() + 1, twoDaysBefore.getDate());
+	}
+	return (await readLogDirectory()).filter((entry) => {
+		const date = datedLogFilePattern.exec(entry.name);
+		if (!entry.isFile() || date === null) return false;
+		return dayNumber(Number(date[1]), Number(date[2]), Number(date[3])) >= earliestDay;
+	}).map((entry) => path.join(paths.logsDir, entry.name));
+};
+const withoutCarriageReturn = (line) => line.endsWith("\r") ? line.slice(0, -1) : line;
+/**
+* The complete lines of a file. A last line without its line break is dropped: the relay may still
+* be appending it, and half an entry can hold a cut-off count that still parses as a number.
+*/
+async function* readLines(filePath) {
+	const stream = createReadStream(filePath, { encoding: "utf8" });
+	let partial = "";
+	let oversized = false;
+	for await (const chunk of stream) {
+		const pieces = chunk.split("\n");
+		const unfinished = pieces.pop() ?? "";
+		for (const piece of pieces) {
+			if (!oversized) yield withoutCarriageReturn(partial + piece);
+			partial = "";
+			oversized = false;
+		}
+		if (!oversized) partial += unfinished;
+		if (partial.length > maxLineLength) {
+			partial = "";
+			oversized = true;
+		}
+	}
+}
+const isInWindow = (record$3, since) => since === void 0 || record$3.timestamp.getTime() >= since.getTime();
+async function* readCompletionRecords(since) {
+	for (const filePath of await listLogFiles(since)) try {
+		for await (const line of readLines(filePath)) {
+			const record$3 = parseCompletionLine(line);
+			if (record$3 !== void 0 && isInWindow(record$3, since)) yield record$3;
+		}
+	} catch (error) {
+		if (!isMissing(error)) throw error;
+	}
+}
+const emptyTotals = (bucket, record$3) => ({
+	bucket: bucket.label,
+	...bucket.utcOffset !== void 0 && { utcOffset: bucket.utcOffset },
+	firstCall: record$3.timestamp.getTime(),
+	model: record$3.model,
+	route: record$3.route,
+	requests: 0,
+	unknownCacheRequests: 0,
+	zeroCacheReadRequests: 0,
+	totalInputTokens: 0,
+	cacheReadTokens: 0,
+	cacheWriteTokens: null
+});
+const addRecord = (totals, record$3) => {
+	totals.requests += 1;
+	totals.firstCall = Math.min(totals.firstCall, record$3.timestamp.getTime());
+	if (record$3.cacheReadTokens === void 0) {
+		totals.unknownCacheRequests += 1;
+		return;
+	}
+	const totalInput = record$3.route === "/v1/messages" ? record$3.inputTokens + record$3.cacheReadTokens + (record$3.cacheWriteTokens ?? 0) : record$3.inputTokens;
+	totals.totalInputTokens += totalInput;
+	totals.cacheReadTokens += record$3.cacheReadTokens;
+	if (record$3.cacheReadTokens === 0) totals.zeroCacheReadRequests += 1;
+	if (record$3.cacheWriteTokens !== void 0) totals.cacheWriteTokens = (totals.cacheWriteTokens ?? 0) + record$3.cacheWriteTokens;
+};
+const hitBasisPoints = (cacheReadTokens, totalInputTokens) => Number(BigInt(cacheReadTokens) * 10000n / BigInt(totalInputTokens));
+const toRow = (totals, goal) => {
+	const hasInput = totals.totalInputTokens > 0;
+	return {
+		bucket: totals.bucket,
+		model: totals.model,
+		route: totals.route,
+		requests: totals.requests,
+		unknownCacheRequests: totals.unknownCacheRequests,
+		zeroCacheReadRequests: totals.zeroCacheReadRequests,
+		totalInputTokens: totals.totalInputTokens,
+		cacheReadTokens: totals.cacheReadTokens,
+		uncachedInputTokens: totals.totalInputTokens - totals.cacheReadTokens,
+		cacheWriteTokens: totals.cacheWriteTokens,
+		hitRate: hasInput ? totals.cacheReadTokens / totals.totalInputTokens : null,
+		belowGoal: hasInput && hitBasisPoints(totals.cacheReadTokens, totals.totalInputTokens) < Math.round(goal * 100)
+	};
+};
+const twoDigits = (value) => String(value).padStart(2, "0");
+const formatUtcOffset = (timestamp) => {
+	const minutes = -timestamp.getTimezoneOffset();
+	const sign = minutes < 0 ? "-" : "+";
+	const absolute = Math.abs(minutes);
+	return `UTC${sign}${twoDigits(Math.floor(absolute / 60))}:${twoDigits(absolute % 60)}`;
+};
+const bucketOf = (timestamp, view) => {
+	if (view === "daily") return { label: formatLogDate(timestamp) };
+	if (view === "hourly") return {
+		label: `${formatLogDate(timestamp)} ${twoDigits(timestamp.getHours())}:00`,
+		utcOffset: formatUtcOffset(timestamp)
+	};
+	return { label: null };
+};
+const compareText = (left, right) => {
+	if (left < right) return -1;
+	return left > right ? 1 : 0;
+};
+const segmentOf = (totals) => JSON.stringify([totals.bucket, totals.utcOffset ?? null]);
+const sortTotals = (groups) => {
+	const firstCalls = /* @__PURE__ */ new Map();
+	for (const totals of groups) {
+		const segment = segmentOf(totals);
+		firstCalls.set(segment, Math.min(firstCalls.get(segment) ?? totals.firstCall, totals.firstCall));
+	}
+	const firstCallOf = (totals) => firstCalls.get(segmentOf(totals)) ?? totals.firstCall;
+	return [...groups].sort((left, right) => firstCallOf(left) - firstCallOf(right) || compareText(left.model, right.model) || compareText(left.route, right.route));
+};
+const labelRepeatedHours = (sorted) => {
+	const offsetsByLabel = /* @__PURE__ */ new Map();
+	for (const totals of sorted) if (totals.utcOffset !== void 0 && totals.bucket !== null) {
+		const offsets = offsetsByLabel.get(totals.bucket) ?? /* @__PURE__ */ new Set();
+		offsets.add(totals.utcOffset);
+		offsetsByLabel.set(totals.bucket, offsets);
+	}
+	for (const totals of sorted) {
+		const offsets = totals.bucket === null ? void 0 : offsetsByLabel.get(totals.bucket);
+		if (totals.utcOffset !== void 0 && offsets !== void 0 && offsets.size > 1) totals.bucket = `${totals.bucket} ${totals.utcOffset}`;
+	}
+};
+/** Reads the retained logs and returns one row per bucket, model and route. */
+const buildCacheReport = async (options) => {
+	parseGoal(String(options.goal));
+	const modelFilter = options.model?.toLowerCase();
+	const groups = /* @__PURE__ */ new Map();
+	for await (const record$3 of readCompletionRecords(options.since)) {
+		if (modelFilter !== void 0 && !record$3.model.toLowerCase().includes(modelFilter)) continue;
+		const bucket = bucketOf(record$3.timestamp, options.view);
+		const key = JSON.stringify([
+			bucket.label,
+			bucket.utcOffset ?? null,
+			record$3.model,
+			record$3.route
+		]);
+		let totals = groups.get(key);
+		if (totals === void 0) {
+			totals = emptyTotals(bucket, record$3);
+			groups.set(key, totals);
+		}
+		addRecord(totals, record$3);
+	}
+	const sorted = sortTotals([...groups.values()]);
+	labelRepeatedHours(sorted);
+	return sorted.map((totals) => toRow(totals, options.goal));
+};
+const minuteMs = 60 * 1e3;
+const hourMs = 60 * minuteMs;
+const dayMs = 24 * hourMs;
+const durationUnits = {
+	m: minuteMs,
+	h: hourMs,
+	d: dayMs
+};
+const durationPattern = /^(\d+)([mhd])$/i;
+const isoTimePattern = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})?)?$/i;
+const sinceUsage = "--since needs a duration such as 30m, 6h or 2d, or an ISO date or time such as 2026-10-03 or 2026-10-03T09:00.";
+const goalPattern = /^(\d+(?:\.\d{1,2})?)%?$/;
+const goalUsage = "--goal needs a percentage from 0 to 100 with at most two decimals, such as --goal 95 or --goal 97.5.";
+const isCalendarDate = (year, month, day) => {
+	const date = new Date(year, month - 1, day);
+	return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+};
+const parseIsoTime = (text$1) => {
+	const match = isoTimePattern.exec(text$1);
+	if (match === null) return;
+	const [, year, month, day, hour, minute, second = "00"] = match;
+	if (!isCalendarDate(Number(year), Number(month), Number(day))) return;
+	if (hour === void 0) return new Date(Number(year), Number(month) - 1, Number(day));
+	if (Number(hour) > 23 || Number(minute) > 59 || Number(second) > 59) return;
+	const time = Date.parse(text$1.toUpperCase().replace(" ", "T"));
+	return Number.isNaN(time) ? void 0 : new Date(time);
+};
+/**
+* The start of the window for --since: a duration counted back from `now`, or an ISO date or
+* time. A date, or a time without Z or an offset, is local, like every other time in the report.
+*/
+const parseSince = (value, now) => {
+	const text$1 = value.trim();
+	const duration = durationPattern.exec(text$1);
+	if (duration !== null) {
+		const unit = durationUnits[duration[2].toLowerCase()];
+		const start$1 = new Date(now.getTime() - Number(duration[1]) * unit);
+		if (Number.isNaN(start$1.getTime())) throw new CacheUsageError(sinceUsage);
+		return start$1;
+	}
+	const time = parseIsoTime(text$1);
+	if (time === void 0) throw new CacheUsageError(sinceUsage);
+	return time;
+};
+/** The hit-rate goal for --goal, in percent with at most two decimals, with or without a trailing "%". */
+const parseGoal = (value) => {
+	const match = goalPattern.exec(value.trim());
+	if (match === null || Number(match[1]) > 100) throw new CacheUsageError(goalUsage);
+	return Number(match[1]);
+};
+const singleValue = (value, flag) => {
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new CacheUsageError(`Give ${flag} once.`);
+	return value;
+};
+/**
+* The report options for the command's flags.
+*
+* The summary and the hourly trend cover the last 24 hours by default, and the daily trend every
+* retained day. --since replaces either default.
+*/
+const resolveCacheOptions = (args, now) => {
+	if (args.hourly && args.daily) throw new CacheUsageError("Choose one of --hourly and --daily.");
+	let view = "summary";
+	if (args.hourly) view = "hourly";
+	else if (args.daily) view = "daily";
+	const sinceText = singleValue(args.since, "--since");
+	const goalText = singleValue(args.goal, "--goal");
+	const model = singleValue(args.model, "--model")?.trim();
+	let since;
+	if (sinceText !== void 0) since = parseSince(sinceText, now);
+	else if (view !== "daily") since = new Date(now.getTime() - dayMs);
+	if (model === "") throw new CacheUsageError("--model needs part of a model name, such as --model opus.");
+	return {
+		view,
+		goal: goalText === void 0 ? defaultGoal : parseGoal(goalText),
+		...since !== void 0 && { since },
+		...model !== void 0 && { model }
+	};
+};
+const formatCount = (value) => value.toLocaleString("en-US");
+const formatHitRate = (row) => {
+	if (row.hitRate === null) return "-";
+	const basisPoints = hitBasisPoints(row.cacheReadTokens, row.totalInputTokens);
+	return `${Math.floor(basisPoints / 100)}.${twoDigits(basisPoints % 100)}%`;
+};
+const hitRateTone = (row) => {
+	if (row.hitRate === null) return "muted";
+	return row.belowGoal ? "bad" : "good";
+};
+const bucketColumns = {
+	summary: [],
+	hourly: [{
+		header: "HOUR",
+		alignRight: false,
+		cell: (row) => row.bucket ?? ""
+	}],
+	daily: [{
+		header: "DAY",
+		alignRight: false,
+		cell: (row) => row.bucket ?? ""
+	}]
+};
+const dataColumns = [
+	{
+		header: "MODEL",
+		alignRight: false,
+		cell: (row) => row.model
+	},
+	{
+		header: "ROUTE",
+		alignRight: false,
+		cell: (row) => row.route
+	},
+	{
+		header: "REQUESTS",
+		alignRight: true,
+		cell: (row) => formatCount(row.requests)
+	},
+	{
+		header: "UNKNOWN",
+		alignRight: true,
+		cell: (row) => formatCount(row.unknownCacheRequests)
+	},
+	{
+		header: "0-READ",
+		alignRight: true,
+		cell: (row) => formatCount(row.zeroCacheReadRequests)
+	},
+	{
+		header: "INPUT",
+		alignRight: true,
+		cell: (row) => formatCount(row.totalInputTokens)
+	},
+	{
+		header: "CACHE READ",
+		alignRight: true,
+		cell: (row) => formatCount(row.cacheReadTokens)
+	},
+	{
+		header: "UNCACHED",
+		alignRight: true,
+		cell: (row) => formatCount(row.uncachedInputTokens)
+	},
+	{
+		header: "CACHE WRITE",
+		alignRight: true,
+		cell: (row) => row.cacheWriteTokens === null ? "-" : formatCount(row.cacheWriteTokens)
+	},
+	{
+		header: "HIT RATE",
+		alignRight: true,
+		cell: formatHitRate,
+		tone: hitRateTone
+	}
+];
+const renderTable = (rows, view, color) => {
+	const columns = [...bucketColumns[view], ...dataColumns];
+	const cells = rows.map((row) => columns.map((column) => column.cell(row)));
+	const widths = columns.map((column, index) => Math.max(column.header.length, ...cells.map((rowCells) => rowCells[index].length)));
+	const pad = (text$1, index) => columns[index].alignRight ? text$1.padStart(widths[index]) : text$1.padEnd(widths[index]);
+	const header = columns.map((column, index) => pad(column.header, index)).join("  ");
+	const body = rows.map((row, rowIndex) => {
+		const rendered = columns.map((column, index) => {
+			const text$1 = pad(cells[rowIndex][index], index);
+			return column.tone === void 0 ? text$1 : colorText(text$1, column.tone(row), color);
+		});
+		const marker = row.belowGoal ? `  ${colorText("below goal", "bad", color)}` : "";
+		return `  ${rendered.join("  ")}${marker}`;
+	});
+	return [`  ${header}`, ...body];
+};
+const viewTitles = {
+	summary: "Prompt-cache hit rate",
+	hourly: "Prompt-cache hit rate by local hour",
+	daily: "Prompt-cache hit rate by local day"
+};
+const formatLocalTime = (date) => `${formatLogDate(date)} ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}`;
+const describeScope = (options) => {
+	return `${options.since === void 0 ? "across all retained logs" : `since ${formatLocalTime(options.since)} local time`}${options.model === void 0 ? "" : `, for models matching "${terminalText(options.model)}"`}`;
+};
+const unknownNote = "UNKNOWN calls logged no cache_read_input_tokens; they are left out of the token columns and HIT RATE.";
+/** The report as text lines. Kept free of IO, so it is tested without a terminal. */
+const renderCacheReport = (rows, options, color = false) => {
+	if (rows.length === 0) return [
+		`No prompt-cache data ${describeScope(options)}.`,
+		`The report reads the upstream completion entries in ${paths.logsDir}.`,
+		"They are written at logLevel info or debug, not error, and kept for logRetentionDays."
+	];
+	const lines = [
+		`${viewTitles[options.view]} ${describeScope(options)}, goal ${options.goal}%`,
+		"",
+		...renderTable(rows, options.view, color)
+	];
+	if (rows.some((row) => row.unknownCacheRequests > 0)) lines.push("", unknownNote);
+	return lines;
+};
+
+//#endregion
+//#region src/cache.ts
+const cache = defineCommand({
+	meta: {
+		name: "cache",
+		description: "Show prompt-cache hit rates per model and upstream route, read from local logs."
+	},
+	args: {
+		hourly: {
+			description: "Show the trend by local hour. Covers the last 24 hours unless --since is given.",
+			type: "boolean"
+		},
+		daily: {
+			description: "Show the trend by local day. Covers every retained day unless --since is given.",
+			type: "boolean"
+		},
+		since: {
+			description: "Start of the window: a duration such as 6h or 2d, or an ISO date or time. Without it, the summary covers the last 24 hours.",
+			type: "string"
+		},
+		model: {
+			description: "Only count models whose name contains this text, ignoring case.",
+			type: "string"
+		},
+		json: {
+			description: "Print the rows as a JSON array.",
+			type: "boolean"
+		},
+		goal: {
+			default: String(defaultGoal),
+			description: "Hit-rate goal in percent, with at most two decimals. Rows below it are flagged.",
+			type: "string"
+		}
+	},
+	async run({ args }) {
+		try {
+			const options = resolveCacheOptions(args, /* @__PURE__ */ new Date());
+			const rows = await buildCacheReport(options);
+			if (args.json) console.log(JSON.stringify(rows, null, 2));
+			else console.log(renderCacheReport(rows, options, colorEnabled()).join("\n"));
+		} catch (error) {
+			if (error instanceof CacheUsageError) console.error(error.message);
+			else {
+				const detail = error instanceof Error ? error.message : String(error);
+				console.error(terminalText(`Could not build the cache report from ${paths.logsDir}: ${detail}`));
+			}
+			process.exitCode = 1;
+		}
+	}
+});
+
 //#endregion
 //#region src/lib/version.ts
 const packageName = /^(?:@[a-z0-9][a-z0-9._-]*\/)?copilot-relay$/;
@@ -1550,13 +2444,13 @@ var OutcomeObserver = class {
 		const incomplete = this.metadataValue(value.incomplete_details?.reason);
 		if (incomplete) this.fields.incomplete_reason = ["max_output_tokens", "content_filter"].includes(incomplete) ? incomplete : "unknown";
 		if (payload.type === "error" || record$2(payload.error)) this.fields.error = "upstream_error";
-		const usage = findUsage(payload, value);
-		if (usage) {
+		const usage$1 = findUsage(payload, value);
+		if (usage$1) {
 			for (const [target, input] of [
-				["input_tokens", usage.input_tokens ?? usage.prompt_tokens],
-				["output_tokens", usage.output_tokens ?? usage.completion_tokens],
-				["cache_read_input_tokens", usage.cache_read_input_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? usage.input_tokens_details?.cached_tokens],
-				["cache_creation_input_tokens", usage.cache_creation_input_tokens]
+				["input_tokens", usage$1.input_tokens ?? usage$1.prompt_tokens],
+				["output_tokens", usage$1.output_tokens ?? usage$1.completion_tokens],
+				["cache_read_input_tokens", usage$1.cache_read_input_tokens ?? usage$1.prompt_tokens_details?.cached_tokens ?? usage$1.input_tokens_details?.cached_tokens],
+				["cache_creation_input_tokens", usage$1.cache_creation_input_tokens]
 			]) if (typeof input === "number" && Number.isSafeInteger(input) && input >= 0) this.fields[target] = input;
 		}
 	}
@@ -1772,6 +2666,7 @@ var RequestTrace = class RequestTrace {
 	constructor(requestId, request, config, runtime) {
 		this.requestId = requestId;
 		this.protectCredential(config.copilotToken);
+		this.protectCredential(config.apiKey);
 		this.protectCredential(request.headers.get("authorization")?.replace(/^Bearer\s+/i, ""));
 		this.protectCredential(request.headers.get("x-api-key") ?? void 0);
 		this.signal = AbortSignal.any([request.signal, this.controller.signal]);
@@ -2234,11 +3129,6 @@ const userAgent = `GitHubCopilotChat/${copilotVersion}`;
 const apiVersion = "2025-04-01";
 const maxFetchAttempts = 2;
 const copilotRequestTimeoutMs = 18e4;
-const copilotDispatcher = new Agent({
-	allowH2: false,
-	connect: { allowH2: false },
-	keepAliveTimeout: 5e4
-});
 const getCopilotProviderContext = (config) => ({
 	baseUrl: config.copilotBaseUrl,
 	get token() {
@@ -2278,6 +3168,33 @@ const toCopilotAbortHTTPError = (error, signal, timeoutMs = copilotRequestTimeou
 		headers: { "content-type": "application/json" }
 	}), message);
 };
+const copilotPromptTooLongPattern = /^prompt token count of (\d+) exceeds the limit of (\d+)$/;
+const anthropicPromptTooLongPattern = /^prompt is too long: (\d+) tokens > (\d+) maximum$/;
+const parseJsonBody = (body) => {
+	try {
+		return JSON.parse(body);
+	} catch {
+		return;
+	}
+};
+const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseTokenCount = (digits) => {
+	const count = Number(digits);
+	return Number.isSafeInteger(count) ? count : void 0;
+};
+const toPromptTooLongError = (status$1, body, detail) => {
+	if (status$1 !== 400) return;
+	const payload = parseJsonBody(body);
+	const upstreamError = isJsonObject(payload) ? payload.error : void 0;
+	if (!isJsonObject(payload) || !isJsonObject(upstreamError)) return;
+	const { code, message, type: errorType } = upstreamError;
+	const upstreamMessage = typeof message === "string" ? message : "";
+	const isCopilotOverflow = code === "model_max_prompt_tokens_exceeded";
+	const isAnthropicOverflow = payload.type === "error" && errorType === "invalid_request_error" && upstreamMessage.startsWith("prompt is too long");
+	if (!isCopilotOverflow && !isAnthropicOverflow) return;
+	const counts = copilotPromptTooLongPattern.exec(upstreamMessage) ?? anthropicPromptTooLongPattern.exec(upstreamMessage);
+	return new PromptTooLongError(parseTokenCount(counts?.[1]), parseTokenCount(counts?.[2]), detail ?? (upstreamMessage || void 0));
+};
 const readCopilotJson = async (response, signal, timeoutMs = copilotRequestTimeoutMs) => {
 	try {
 		return await response.json();
@@ -2380,21 +3297,12 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 				headers,
 				upstreamRequestId,
 				signal
-			}, async () => {
-				const undiciResponse = await fetch$1(`${provider.baseUrl}${path$1}`, {
-					...init,
-					headers,
-					dispatcher: copilotDispatcher,
-					signal
-				});
-				const wrappedResponse = new Response(undiciResponse.body, {
-					status: undiciResponse.status,
-					statusText: undiciResponse.statusText,
-					headers: undiciResponse.headers
-				});
-				Object.defineProperty(wrappedResponse, "url", { value: undiciResponse.url });
-				return wrappedResponse;
-			});
+			}, () => fetchUpstream(`${provider.baseUrl}${path$1}`, {
+				body: init.body,
+				headers,
+				method: init.method,
+				signal
+			}));
 			const ms = Math.round(performance.now() - started);
 			logUpstreamLifecycle(options.requestId, `return from upstream method=${init.method ?? "GET"} path=${path$1} status=${response.status} ms=${ms} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
 			log.debug(`${formatRequestId(options.requestId)}Copilot ${init.method ?? "GET"} ${path$1} -> ${response.status} ${ms}ms (attempt ${attempt}) upstream_request_id=${upstreamRequestId}`);
@@ -2450,10 +3358,10 @@ const pinCopilotModelCatalog = (config) => {
 	pinnedCatalogs.set(config, config.modelCatalog);
 };
 const pendingCatalogs = /* @__PURE__ */ new WeakMap();
-const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 function parseModelTokenLimits(value) {
-	if (!isRecord$3(value)) return;
+	if (!isRecord$4(value)) return;
 	const context = value.max_context_window_tokens;
 	const prompt = value.max_prompt_tokens;
 	const output = value.max_output_tokens;
@@ -2509,13 +3417,13 @@ async function loadCopilotModelCatalog(config) {
 		});
 		if (!response.ok) throw new HTTPError("Failed to validate upstream models", response);
 		const payload = await readCopilotJson(response, signal, config.upstreamTimeoutMs);
-		if (!isRecord$3(payload) || !Array.isArray(payload.data)) throw new Error("Copilot /models returned an invalid model catalog.");
+		if (!isRecord$4(payload) || !Array.isArray(payload.data)) throw new Error("Copilot /models returned an invalid model catalog.");
 		const models$1 = /* @__PURE__ */ new Map();
 		for (const model of payload.data) {
-			if (!isRecord$3(model) || typeof model.id !== "string" || !model.id) continue;
-			const capabilities = isRecord$3(model.capabilities) ? model.capabilities : void 0;
+			if (!isRecord$4(model) || typeof model.id !== "string" || !model.id) continue;
+			const capabilities = isRecord$4(model.capabilities) ? model.capabilities : void 0;
 			const limits = parseModelTokenLimits(capabilities?.limits);
-			const supports = isRecord$3(capabilities?.supports) ? capabilities.supports : void 0;
+			const supports = isRecord$4(capabilities?.supports) ? capabilities.supports : void 0;
 			const supportedEndpoints = parseStringArray(model.supported_endpoints);
 			const reasoningEfforts = parseReasoningEfforts(supports);
 			models$1.set(model.id, {
@@ -2633,27 +3541,6 @@ function requireCopilotEndpoint(config, model) {
 	}, { status: 400 }), message);
 }
 
-//#endregion
-//#region src/lib/terminal.ts
-const colorEnabled = (env = process.env, isTTY = Boolean(process.stdout.isTTY)) => {
-	if (env.NO_COLOR !== void 0 || env.FORCE_COLOR === "0") return false;
-	if (env.FORCE_COLOR !== void 0) return env.FORCE_COLOR === "" || [
-		"1",
-		"2",
-		"3",
-		"true"
-	].includes(env.FORCE_COLOR);
-	return isTTY && env.TERM !== "dumb";
-};
-const ansiColorCodes = {
-	good: 32,
-	bad: 31,
-	warning: 33,
-	muted: 90
-};
-const terminalText = (value) => sanitizeTerminalString(value).replace(/[\x80-\x9f]|\p{Cf}|\p{Zl}|\p{Zp}/gu, "");
-const colorText = (text$1, tone, enabled) => enabled ? `\u001b[${ansiColorCodes[tone]}m${text$1}\u001b[0m` : text$1;
-
 //#endregion
 //#region src/lib/model-probe-output.ts
 const tones = {
@@ -2781,6 +3668,50 @@ const probeHint = (code) => {
 	if (apiFailureCodes.includes(code) || /^HTTP-5\d\d$/.test(code)) return "API failure: the request ID locates the local summary; --details shows evidence on a new probe.";
 };
 
+//#endregion
+//#region src/claude/billing-line.ts
+const billingLinePrefix = "x-anthropic-billing-header:";
+const afterBillingLine = (text$1) => {
+	if (!text$1.startsWith(billingLinePrefix)) return;
+	const lineEnd = text$1.indexOf("\n");
+	if (lineEnd === -1) return "";
+	return text$1.slice(lineEnd + 1).replace(/^(?:\r?\n)+/, "");
+};
+const isTextBlock = (block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string";
+const withSystem = (payload, system) => {
+	const { system: _removed,...rest } = payload;
+	return system === void 0 ? rest : {
+		...rest,
+		system
+	};
+};
+const removeBillingLine = (payload) => {
+	if (typeof payload !== "object" || payload === null) return payload;
+	const { system } = payload;
+	if (typeof system === "string") {
+		const rest = afterBillingLine(system);
+		if (rest === void 0) return payload;
+		return withSystem(payload, rest.trim() === "" ? void 0 : rest);
+	}
+	if (!Array.isArray(system)) return payload;
+	let changed = false;
+	const kept = [];
+	for (const block of system) {
+		const rest = isTextBlock(block) ? afterBillingLine(block.text) : void 0;
+		if (rest === void 0) {
+			kept.push(block);
+			continue;
+		}
+		changed = true;
+		if (rest.trim() !== "") kept.push({
+			...block,
+			text: rest
+		});
+	}
+	if (!changed) return payload;
+	return withSystem(payload, kept.length > 0 ? kept : void 0);
+};
+
 //#endregion
 //#region src/claude/utils.ts
 const isEffortOnlyControl = (control) => control !== null && typeof control === "object" && !Array.isArray(control) && Object.keys(control).length === 1 && "effort" in control && isConfiguredReasoningEffort(control.effort);
@@ -3342,6 +4273,13 @@ function translateChunkToClaudeEvents(chunk, state, toolNameMapper = createClaud
 	return events$1;
 }
 function translateErrorToClaudeErrorEvent(error) {
+	if (error instanceof PromptTooLongError) return {
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			message: error.message
+		}
+	};
 	return {
 		type: "error",
 		error: {
@@ -3365,7 +4303,7 @@ const webSearchInputSchema = {
 	required: ["query"],
 	additionalProperties: false
 };
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isAnthropicNativeWebSearchTool = (tool) => tool.name === "web_search" && typeof tool.type === "string" && anthropicWebSearchToolPattern.test(tool.type);
 const isClaudeCodeWebSearchTool = (tool) => tool.name === claudeCodeWebSearchToolName;
 const isClaudeWebSearchTool = (tool) => isAnthropicNativeWebSearchTool(tool) || isClaudeCodeWebSearchTool(tool);
@@ -3382,11 +4320,16 @@ const prepareClaudeWebSearchDecisionPayload = (payload) => {
 		} : tool)
 	};
 };
+const toolResultText = (content) => {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((block) => block.type === "text" ? block.text : `[${block.type}]`).join("\n\n");
+};
 const textFromMessageContent = (content) => {
 	if (typeof content === "string") return content;
 	return content.flatMap((block) => {
 		if (block.type === "text") return [block.text];
-		if (block.type === "tool_result") return [block.content];
+		if (block.type === "tool_result") return [toolResultText(block.content)];
 		return [];
 	}).join("\n\n");
 };
@@ -3400,7 +4343,7 @@ const getQueryFromToolArguments = (value) => {
 	if (!trimmed) return;
 	try {
 		const parsed = JSON.parse(trimmed);
-		if (isRecord$2(parsed) && typeof parsed.query === "string" && parsed.query.trim()) return parsed.query.trim();
+		if (isRecord$3(parsed) && typeof parsed.query === "string" && parsed.query.trim()) return parsed.query.trim();
 	} catch {
 		return trimmed;
 	}
@@ -3457,7 +4400,7 @@ const getReportedQuery = (action, queries) => {
 const getSearchQuery = (response, requestedQuery) => {
 	for (const item of response.output ?? []) {
 		if (item.type !== "web_search_call") continue;
-		const action = isRecord$2(item.action) ? item.action : void 0;
+		const action = isRecord$3(item.action) ? item.action : void 0;
 		const query = getReportedQuery(action, Array.isArray(action?.queries) ? action.queries : []);
 		if (query) return query;
 	}
@@ -3465,7 +4408,7 @@ const getSearchQuery = (response, requestedQuery) => {
 };
 const getResponseText = (response) => (response.output ?? []).flatMap((item) => {
 	if (item.type !== "message") return [];
-	return (Array.isArray(item.content) ? item.content : []).flatMap((part) => isRecord$2(part) && part.type === "output_text" && typeof part.text === "string" ? [part.text] : []);
+	return (Array.isArray(item.content) ? item.content : []).flatMap((part) => isRecord$3(part) && part.type === "output_text" && typeof part.text === "string" ? [part.text] : []);
 }).join("\n").trim();
 const cleanTitle = (line, url) => {
 	return line.slice(0, line.indexOf(url)).replace(/^\s*(?:[-*]|\d+[.)])\s*/, "").replace(/\s*(?:[-:|])\s*$/, "").trim() || new URL(url).hostname;
@@ -3489,15 +4432,15 @@ const parseSearchResults = (text$1) => {
 const getStructuredSearchResults = (response) => {
 	const sources = [];
 	for (const item of response.output ?? []) {
-		if (item.type === "web_search_call" && isRecord$2(item.action) && Array.isArray(item.action.sources)) sources.push(...item.action.sources);
+		if (item.type === "web_search_call" && isRecord$3(item.action) && Array.isArray(item.action.sources)) sources.push(...item.action.sources);
 		if (item.type === "message" && Array.isArray(item.content)) {
-			for (const part of item.content) if (isRecord$2(part) && Array.isArray(part.annotations)) sources.push(...part.annotations.filter((annotation) => isRecord$2(annotation) && annotation.type === "url_citation"));
+			for (const part of item.content) if (isRecord$3(part) && Array.isArray(part.annotations)) sources.push(...part.annotations.filter((annotation) => isRecord$3(annotation) && annotation.type === "url_citation"));
 		}
 	}
 	const results = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const source of sources) {
-		if (!isRecord$2(source) || typeof source.url !== "string") continue;
+		if (!isRecord$3(source) || typeof source.url !== "string") continue;
 		try {
 			const url = new URL(source.url);
 			if (!/^https?:$/.test(url.protocol) || url.username || url.password || seen.has(url.href)) continue;
@@ -3549,21 +4492,21 @@ const getResultSource = (structured, results) => {
 	return results.length ? "text" : "none";
 };
 const interpretSearchResponse = (raw, config, requestedQuery, request, requestedEffort, requestId) => {
-	const malformed = !isRecord$2(raw) || raw.output !== void 0 && (!Array.isArray(raw.output) || !raw.output.every(isRecord$2));
-	const upstream = isRecord$2(raw) ? {
+	const malformed = !isRecord$3(raw) || raw.output !== void 0 && (!Array.isArray(raw.output) || !raw.output.every(isRecord$3));
+	const upstream = isRecord$3(raw) ? {
 		...raw,
-		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$2) : []
+		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$3) : []
 	} : {};
 	const status$1 = recognizedValue(upstream.status, responseStates);
-	const reason = recognizedValue(isRecord$2(upstream.incomplete_details) ? upstream.incomplete_details.reason : void 0, incompleteReasons);
+	const reason = recognizedValue(isRecord$3(upstream.incomplete_details) ? upstream.incomplete_details.reason : void 0, incompleteReasons);
 	const items = upstream.output ?? [];
 	const calls = items.filter((item) => item.type === "web_search_call");
 	const callStates = calls.map((item) => recognizedValue(item.status, searchStates));
-	const usage = isRecord$2(upstream.usage) ? upstream.usage : {};
-	const inputTokens = reportedTokens(usage.input_tokens);
-	const cachedInputTokens = reportedTokens(isRecord$2(usage.input_tokens_details) ? usage.input_tokens_details.cached_tokens : void 0);
-	const outputTokens = reportedTokens(usage.output_tokens);
-	const reasoningTokens = reportedTokens(isRecord$2(usage.output_tokens_details) ? usage.output_tokens_details.reasoning_tokens : void 0);
+	const usage$1 = isRecord$3(upstream.usage) ? upstream.usage : {};
+	const inputTokens = reportedTokens(usage$1.input_tokens);
+	const cachedInputTokens = reportedTokens(isRecord$3(usage$1.input_tokens_details) ? usage$1.input_tokens_details.cached_tokens : void 0);
+	const outputTokens = reportedTokens(usage$1.output_tokens);
+	const reasoningTokens = reportedTokens(isRecord$3(usage$1.output_tokens_details) ? usage$1.output_tokens_details.reasoning_tokens : void 0);
 	const upstreamResponseId = safeResponseId(upstream.id, config.copilotToken);
 	const safeRequestId = typeof requestId === "string" && /^[a-f0-9-]{36}$/i.test(requestId) ? requestId : "unreported";
 	const text$1 = getResponseText(upstream);
@@ -3651,7 +4594,7 @@ const getSearchFailureDetail = (body, token) => {
 	let detail = body.trim();
 	try {
 		const parsed = JSON.parse(detail);
-		detail = getErrorMessageOrCode(isRecord$2(parsed) && isRecord$2(parsed.error) ? parsed.error : void 0);
+		detail = getErrorMessageOrCode(isRecord$3(parsed) && isRecord$3(parsed.error) ? parsed.error : void 0);
 	} catch {
 		if (/^[{[<]/.test(detail)) return "";
 	}
@@ -3820,9 +4763,9 @@ const accumulateChunks = (chunks) => {
 	let reasoning = "";
 	let refusal = "";
 	let finishReason = null;
-	let usage;
+	let usage$1;
 	for (const chunk of chunks) {
-		if (chunk.usage) usage = chunk.usage;
+		if (chunk.usage) usage$1 = chunk.usage;
 		const choice = chunk.choices[0];
 		if (!choice) continue;
 		if (typeof choice.delta?.content === "string") content += choice.delta.content;
@@ -3863,7 +4806,7 @@ const accumulateChunks = (chunks) => {
 			},
 			finish_reason: refusal ? "content_filter" : finishReason ?? "stop"
 		}],
-		...usage ? { usage } : {}
+		...usage$1 ? { usage: usage$1 } : {}
 	};
 };
 const incompleteStreamError = () => {
@@ -3879,7 +4822,7 @@ const incompleteStreamError = () => {
 async function* normalizeChatCompletionStream(stream) {
 	let terminal;
 	let refusal = false;
-	let usage;
+	let usage$1;
 	for await (const event of stream) {
 		if (event.event === "error") throw incompleteStreamError();
 		if (!event.data) continue;
@@ -3891,7 +4834,7 @@ async function* normalizeChatCompletionStream(stream) {
 			throw incompleteStreamError();
 		}
 		if (!chunk || !Array.isArray(chunk.choices)) throw incompleteStreamError();
-		if (chunk.usage) usage = chunk.usage;
+		if (chunk.usage) usage$1 = chunk.usage;
 		if (chunk.choices.length === 0) continue;
 		const choice = chunk.choices[0];
 		if (!choice || !choice.delta || typeof choice.delta !== "object" || terminal) throw incompleteStreamError();
@@ -3923,7 +4866,7 @@ async function* normalizeChatCompletionStream(stream) {
 	if (!terminal) throw incompleteStreamError();
 	yield { data: JSON.stringify({
 		...terminal,
-		...usage && { usage }
+		...usage$1 && { usage: usage$1 }
 	}) };
 	yield { data: "[DONE]" };
 }
@@ -4223,7 +5166,7 @@ const lookaroundPrefixes = [
 	"(?<=",
 	"(?<!"
 ];
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function hasUnsupportedPatternFeatures(pattern) {
 	let inCharacterClass = false;
 	for (let index = 0; index < pattern.length; index++) {
@@ -4269,12 +5212,12 @@ function mapArray(values) {
 }
 function normalizeSchemaValue(value) {
 	if (Array.isArray(value)) return mapArray(value);
-	return isRecord$1(value) ? normalizeResponsesToolSchema(value) : value;
+	return isRecord$2(value) ? normalizeResponsesToolSchema(value) : value;
 }
 function normalizeResponsesToolSchema(schema) {
 	return mapRecord(schema, (key, value) => {
 		if (key === "pattern" && typeof value === "string" && hasUnsupportedPatternFeatures(value)) return removed;
-		if (schemaMapKeywords.has(key) && isRecord$1(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
+		if (schemaMapKeywords.has(key) && isRecord$2(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
 		if (nestedSchemaKeywords.has(key)) return normalizeSchemaValue(value);
 		return value;
 	});
@@ -4553,7 +5496,7 @@ function createRoleChunk(state) {
 	state.started = true;
 	return createChunk(state, { delta: { role: "assistant" } });
 }
-function createChunk(state, { delta, finishReason = null, usage }) {
+function createChunk(state, { delta, finishReason = null, usage: usage$1 }) {
 	return { data: JSON.stringify({
 		id: state.responseId,
 		object: "chat.completion.chunk",
@@ -4565,7 +5508,7 @@ function createChunk(state, { delta, finishReason = null, usage }) {
 			finish_reason: finishReason,
 			logprobs: null
 		}],
-		usage
+		usage: usage$1
 	}) };
 }
 function translateMessagesToResponsesInput(messages) {
@@ -4577,7 +5520,7 @@ function translateMessage(message) {
 	if (message.role === "tool") return [{
 		type: "function_call_output",
 		call_id: message.tool_call_id ?? "",
-		output: stringifyToolOutput(message.content)
+		output: translateToolOutput(message.content)
 	}];
 	const translated = [];
 	if (hasContent(message.content)) translated.push({
@@ -4613,6 +5556,21 @@ function translateContentPart(part) {
 		detail: part.image_url.detail ?? "auto"
 	};
 }
+function translateToolOutput(content) {
+	if (Array.isArray(content) && content.some((part) => part.type === "image_url")) return content.flatMap((part) => translateToolOutputPart(part));
+	return stringifyToolOutput(content);
+}
+function translateToolOutputPart(part) {
+	if (part.type === "image_url") return [{
+		type: "input_image",
+		image_url: part.image_url.url
+	}];
+	if (part.text === "") return [];
+	return [{
+		type: "input_text",
+		text: part.text
+	}];
+}
 function stringifyToolOutput(content) {
 	if (typeof content === "string") return content;
 	if (!content) return "";
@@ -4636,13 +5594,13 @@ function translateToolChoice(toolChoice) {
 		name: toolChoice.function.name
 	};
 }
-function translateUsage(usage) {
-	if (!usage) return;
+function translateUsage(usage$1) {
+	if (!usage$1) return;
 	return {
-		prompt_tokens: usage.input_tokens,
-		completion_tokens: usage.output_tokens,
-		total_tokens: usage.total_tokens,
-		...usage.input_tokens_details?.cached_tokens !== void 0 && { prompt_tokens_details: { cached_tokens: usage.input_tokens_details.cached_tokens } }
+		prompt_tokens: usage$1.input_tokens,
+		completion_tokens: usage$1.output_tokens,
+		total_tokens: usage$1.total_tokens,
+		...usage$1.input_tokens_details?.cached_tokens !== void 0 && { prompt_tokens_details: { cached_tokens: usage$1.input_tokens_details.cached_tokens } }
 	};
 }
 function getMessageOutputText(content) {
@@ -4733,7 +5691,57 @@ const normalizeFinalAssistantPrefill = (payload) => {
 	};
 };
 const isAgentInitiator = (messages) => messages.some((message) => message.role === "assistant" || message.role === "tool") ? "agent" : "user";
-const messagesIncludeImage = (messages) => messages.some((message) => typeof message.content !== "string" && message.content?.some((part) => part.type === "image_url"));
+const holdsImage = (message) => Array.isArray(message.content) && message.content.some((part) => part.type === "image_url");
+const messagesIncludeImage = (messages) => messages.some(holdsImage);
+const isToolImageMessage = (message) => message.role === "tool" && holdsImage(message);
+const joinTextParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+const toContentParts = (content) => {
+	if (typeof content === "string") return [{
+		type: "text",
+		text: content
+	}];
+	return content ?? [];
+};
+const toolImageNote = "Image output follows in the next user message.";
+const moveToolImagesToUserMessages = (payload) => {
+	if (isClaudeModelId(payload.model) || !payload.messages.some(isToolImageMessage)) return payload;
+	const messages = [];
+	let movedImages = [];
+	for (const message of payload.messages) {
+		if (isToolImageMessage(message)) {
+			messages.push({
+				...message,
+				content: joinTextParts(message.content) || toolImageNote
+			});
+			movedImages.push({
+				type: "text",
+				text: `Image output of tool call ${message.tool_call_id ?? ""}:`
+			}, ...message.content.filter((part) => part.type === "image_url"));
+			continue;
+		}
+		if (message.role === "tool" || movedImages.length === 0) {
+			messages.push(message);
+			continue;
+		}
+		if (message.role === "user") messages.push({
+			...message,
+			content: [...movedImages, ...toContentParts(message.content)]
+		});
+		else messages.push({
+			role: "user",
+			content: movedImages
+		}, message);
+		movedImages = [];
+	}
+	if (movedImages.length > 0) messages.push({
+		role: "user",
+		content: movedImages
+	});
+	return {
+		...payload,
+		messages
+	};
+};
 const createChatCompletions = async (config, payload, options = {}) => {
 	const client = options.client ?? "generic";
 	const requestedModel = options.requestedModel ?? payload.model;
@@ -4756,7 +5764,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		stream: bufferResponse ? true : payload.stream
 	};
 	const useResponsesApi = selection.endpoint === "/responses";
-	const compatiblePayload = useResponsesApi ? upstreamPayload : normalizeFinalAssistantPrefill(upstreamPayload);
+	const compatiblePayload = useResponsesApi ? upstreamPayload : normalizeFinalAssistantPrefill(moveToolImagesToUserMessages(upstreamPayload));
 	const provider = getCopilotProviderContext(config);
 	const enableVision = messagesIncludeImage(compatiblePayload.messages);
 	const initiator = isAgentInitiator(compatiblePayload.messages);
@@ -4798,19 +5806,19 @@ const createChatCompletions = async (config, payload, options = {}) => {
 			markDiscardedResponse(response);
 			await response.body?.cancel();
 			return completeResponse(await createResponses(provider, upstreamPayload, {
-				vision: enableVision,
+				vision: messagesIncludeImage(upstreamPayload.messages),
 				initiator,
 				requestId: options.requestId,
 				signal,
 				timeoutMs: options.timeoutMs
 			}));
 		}
-		throw new HTTPError("Failed to create chat completions", response, await logUpstreamError("Failed to create chat completions", response, {
+		throw await logUpstreamError("Failed to create chat completions", response, {
 			model: payload.model,
 			request: requestPayload,
 			route: "/chat/completions",
 			requestId: options.requestId
-		}, signal, options.timeoutMs));
+		}, signal, options.timeoutMs);
 	}
 	if (compatiblePayload.stream) return completeResponse(normalizeChatCompletionStream(events(response)));
 	return readCopilotJson(response, signal, options.timeoutMs);
@@ -4832,12 +5840,12 @@ async function createResponses(provider, payload, options) {
 		signal: options.signal,
 		timeoutMs: options.timeoutMs
 	});
-	if (!response.ok) throw new HTTPError("Failed to create responses", response, await logUpstreamError("Failed to create responses", response, {
+	if (!response.ok) throw await logUpstreamError("Failed to create responses", response, {
 		model: payload.model,
 		request: requestPayload,
 		route: "/responses",
 		requestId: options.requestId
-	}, options.signal, options.timeoutMs));
+	}, options.signal, options.timeoutMs);
 	if (payload.stream) return normalizeChatCompletionStream(translateResponsesStreamToChatCompletionStream(events(response)));
 	return translateResponsesToChatCompletion(await readCopilotJson(response, options.signal, options.timeoutMs));
 }
@@ -4858,7 +5866,7 @@ async function logUpstreamError(message, response, context, signal, timeoutMs) {
 		},
 		request: context.request
 	});
-	return detail;
+	return toPromptTooLongError(response.status, errorBody, detail) ?? new HTTPError(message, response, detail);
 }
 function getUpstreamErrorDetail(response, body) {
 	if (!body) return response.statusText || void 0;
@@ -5018,6 +6026,8 @@ async function createNativeMessages(config, payload, options) {
 	if (!response.ok) {
 		const detail = await readCopilotText(response, options.signal, config.upstreamTimeoutMs);
 		const contentType = response.headers.get("content-type") ?? "application/json";
+		const promptTooLong = toPromptTooLongError(response.status, detail);
+		if (promptTooLong) throw promptTooLong;
 		throw new HTTPError("Native upstream request failed", new Response(detail, {
 			status: response.status,
 			headers: { "content-type": contentType }
@@ -5247,7 +6257,7 @@ async function handleNativeMessages(config, payload, options, write) {
 	};
 	const upstreamToolResult = toolResult(searchCall.id, resultBlock.content);
 	const hasSiblingTools = message.content.some((block) => block.type === "tool_use" && block !== searchCall);
-	let usage = mergeUsage(message.usage, searchMessage.usage);
+	let usage$1 = mergeUsage(message.usage, searchMessage.usage);
 	const combined = [...displayDecision, resultBlock];
 	if (write) for (const [index, block] of combined.entries()) {
 		if (index < (heldFrom ?? message.content.length)) continue;
@@ -5258,13 +6268,13 @@ async function handleNativeMessages(config, payload, options, write) {
 			...message,
 			content: combined,
 			stop_reason: hasSiblingTools ? "tool_use" : "end_turn",
-			usage
+			usage: usage$1
 		};
 		if (!write) return complete;
 		await write({
 			type: "message_delta",
 			delta: { stop_reason: complete.stop_reason },
-			usage
+			usage: usage$1
 		});
 		await write({ type: "message_stop" });
 		return;
@@ -5297,11 +6307,11 @@ async function handleNativeMessages(config, payload, options, write) {
 		});
 	} : void 0);
 	if (finalMessage.content.some((block) => block.type === "tool_use" && isClaudeWebSearchToolName(block.name ?? ""))) throw new Error("Repeated bridge-managed search is unsupported.");
-	usage = mergeUsage(usage, finalMessage.usage);
+	usage$1 = mergeUsage(usage$1, finalMessage.usage);
 	if (!write) return {
 		...finalMessage,
 		content: [...combined, ...finalMessage.content],
-		usage
+		usage: usage$1
 	};
 	if (finalHeldFrom !== void 0) for (const [index, block] of finalMessage.content.entries()) {
 		if (index < finalHeldFrom) continue;
@@ -5314,7 +6324,7 @@ async function handleNativeMessages(config, payload, options, write) {
 			stop_sequence: finalMessage.stop_sequence,
 			..."stop_details" in finalMessage && { stop_details: finalMessage.stop_details }
 		},
-		usage
+		usage: usage$1
 	});
 	await write({ type: "message_stop" });
 }
@@ -5655,7 +6665,7 @@ claudeRoutes.get("/models", (c) => c.json({
 claudeRoutes.post("/messages", async (c) => {
 	const config = c.get("config");
 	const requestId = c.get("requestId");
-	const claudePayload = await c.req.json();
+	const claudePayload = removeBillingLine(await c.req.json());
 	const requestSignal = createCopilotRequestSignal(c.req.raw.signal, config.upstreamTimeoutMs);
 	try {
 		getRequestReasoningEffort(claudePayload);
@@ -5744,7 +6754,7 @@ claudeRoutes.post("/messages", async (c) => {
 claudeRoutes.post("/messages/count_tokens", async (c) => {
 	try {
 		const claudeBeta = c.req.header("claude-beta");
-		const claudePayload = await c.req.json();
+		const claudePayload = removeBillingLine(await c.req.json());
 		const openAIPayload = translateToOpenAI(shouldUseNativeMessages(c.get("config"), translateModelName(claudePayload.model)) ? {
 			...claudePayload,
 			messages: claudePayload.messages.map((message) => {
@@ -5816,6 +6826,22 @@ const parseAuthority = (authority, protocol) => {
 };
 const effectivePort = (url) => Number(url.port || (url.protocol === "https:" ? 443 : 80));
 const isAllowedHostname = (hostname, configuredHost) => hostname === "localhost" || hostname === "[::1]" || isIPv4(hostname) && hostname.startsWith("127.") || hostname !== "0.0.0.0" && hostname !== "[::]" && hostname === configuredHost;
+const sha256 = (value) => createHash("sha256").update(value, "utf8").digest();
+/**
+* True when the request carries the relay's apiKey as x-api-key or Authorization: Bearer.
+*
+* The configured key and each presented value are hashed with SHA-256, and timingSafeEqual compares
+* the fixed-length digests, so the comparison never stops at the first byte that differs. Both
+* headers are compared even after one matches.
+*/
+const presentsApiKey = (headers, apiKey) => {
+	const expected = sha256(apiKey);
+	const bearer = /^Bearer\s+(.+)$/i.exec(headers.get("authorization") ?? "")?.[1];
+	let matched = false;
+	for (const presented of [headers.get("x-api-key"), bearer]) if (typeof presented === "string" && timingSafeEqual(sha256(presented), expected)) matched = true;
+	return matched;
+};
+const isOpenProbe = (method, path$1) => method === "GET" && path$1 === "/healthz" || (method === "GET" || method === "HEAD") && path$1 === "/api/hello";
 const createServer = (config) => {
 	const app = new Hono();
 	const { host, port } = config;
@@ -5859,6 +6885,18 @@ const createServer = (config) => {
 				return c.json({ error: { message } }, 403);
 			}
 		}
+		const apiKey = config.apiKey;
+		if (apiKey && !isOpenProbe(c.req.method, c.req.path) && !presentsApiKey(c.req.raw.headers, apiKey)) {
+			const message = "Missing or invalid API key: send the relay apiKey as x-api-key or Authorization: Bearer";
+			c.set("requestErrorMessage", message);
+			return c.json({
+				type: "error",
+				error: {
+					type: "authentication_error",
+					message
+				}
+			}, 401, { "www-authenticate": "Bearer" });
+		}
 		if (c.req.method === "POST" && (c.req.path === "/v1/messages" || c.req.path === "/v1/messages/count_tokens") && (incoming ? Boolean(incoming.headers["transfer-encoding"]) || Number(incoming.headers["content-length"] ?? 0) > 0 : c.req.raw.body !== null) && c.req.header("content-type")?.split(";", 1)[0].trim().toLowerCase() !== "application/json") {
 			const message = "Content-Type must be application/json";
 			c.set("requestErrorMessage", message);
@@ -5939,7 +6977,14 @@ const startServer = (config) => new Promise((resolve$1, reject) => {
 //#endregion
 //#region src/lib/model-probe.ts
 const record$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const safeId = (id, token) => typeof id === "string" && /^[A-Za-z0-9._\[\]-]{1,128}$/.test(id) && !(token && id.includes(token)) && !/(?:gh[pousr]_|github_pat_|sk-|eyJ)/.test(id);
+const holdsCredential = (text$1, config) => {
+	for (const secret of [config.copilotToken, config.apiKey]) if (secret && text$1.includes(secret)) return true;
+	return false;
+};
+const safeId = (id, config) => typeof id === "string" && /^[A-Za-z0-9._\[\]-]{1,128}$/.test(id) && !holdsCredential(id, config) && !/(?:gh[pousr]_|github_pat_|sk-|eyJ)/.test(id);
+const printLine = (line) => {
+	console.log(scrubLogSecrets(scrubSensitiveUrls(line)));
+};
 const httpCategory = (status$1) => {
 	if (status$1 === 401) return "authentication-rejected";
 	if (status$1 === 403) return "access-denied";
@@ -5996,9 +7041,9 @@ const failureFromEvidence = (row, diagnostic) => {
 	return row.detail;
 };
 async function probeModels(config, entries, options) {
-	console.log(`\nModel check · ${entries.length} ${entries.length === 1 ? "model" : "models"} · real Copilot usage`);
-	console.log("Isolated relay pipeline; not running-daemon health.");
-	console.log(`Up to ${options.maxTokens} output tokens/probe; existing retries may add calls.\n`);
+	printLine(`\nModel check · ${entries.length} ${entries.length === 1 ? "model" : "models"} · real Copilot usage`);
+	printLine("Isolated relay pipeline; not running-daemon health.");
+	printLine(`Up to ${options.maxTokens} output tokens/probe; existing retries may add calls.\n`);
 	const controller = new AbortController();
 	const interrupt = () => controller.abort();
 	process.on("SIGINT", interrupt);
@@ -6012,9 +7057,9 @@ async function probeModels(config, entries, options) {
 	const results = [];
 	const app = createServer(config);
 	const columns = Math.max(40, process.stdout.columns || 80);
-	const width = probeColumnWidth(entries.map(([id]) => safeId(id, config.copilotToken) ? id : "[unsupported ID]"), columns);
+	const width = probeColumnWidth(entries.map(([id]) => safeId(id, config) ? id : "[unsupported ID]"), columns);
 	const color = colorEnabled();
-	if (entries.length) console.log(renderProbeHeader(width));
+	if (entries.length) printLine(renderProbeHeader(width));
 	try {
 		runtimeState.modelCatalog = config.modelCatalog;
 		runtimeState.upstreamBaseUrl = config.copilotBaseUrl;
@@ -6036,7 +7081,7 @@ async function probeModels(config, entries, options) {
 			const endpoint = selection.endpoint ?? "none";
 			const { advertisedEndpoints, unknownEndpoints } = summarizeAdvertisedEndpoints(model.supportedEndpoints);
 			const row = {
-				id: safeId(id, config.copilotToken) ? id : "[unsupported ID]",
+				id: safeId(id, config) ? id : "[unsupported ID]",
 				status: "NOT_TESTED",
 				reported: "-",
 				sent: false,
@@ -6051,7 +7096,7 @@ async function probeModels(config, entries, options) {
 				unverified: model.reasoningEfforts === void 0 || model.supportedEndpoints === void 0
 			};
 			if (controller.signal.aborted || totalDeadline.aborted) row.detail = controller.signal.aborted ? "cancelled" : "total-deadline";
-			else if (!safeId(id, config.copilotToken) || normalizeCopilotModelId(id) !== id) {
+			else if (!safeId(id, config) || normalizeCopilotModelId(id) !== id) {
 				row.status = "SKIPPED";
 				row.detail = "unsafe-or-noncanonical-id";
 			} else if (!selection.endpoint) {
@@ -6080,7 +7125,10 @@ async function probeModels(config, entries, options) {
 				const sendProbe = async () => {
 					const response = await app.fetch(new Request(`http://localhost${config.port ? `:${config.port}` : ""}/v1/messages`, {
 						method: "POST",
-						headers: { "content-type": "application/json" },
+						headers: {
+							"content-type": "application/json",
+							...config.apiKey ? { "x-api-key": config.apiKey } : {}
+						},
 						signal,
 						body: JSON.stringify({
 							model: id,
@@ -6121,7 +7169,7 @@ async function probeModels(config, entries, options) {
 						if (code === "model_not_supported") row.detail = "model-not-supported";
 					} else if (!record$1(body) || !Array.isArray(body.content)) row.detail = "malformed-response";
 					else {
-						row.reported = safeId(body.model, config.copilotToken) ? body.model : "unreported";
+						row.reported = safeId(body.model, config) ? body.model : "unreported";
 						if (!reportsSelectedModel(endpoint, id, row.reported)) row.detail = "model-mismatch";
 						else if (body.stop_reason === "max_tokens") {
 							row.status = "INCOMPLETE";
@@ -6153,11 +7201,11 @@ async function probeModels(config, entries, options) {
 					if (row.status === "FAIL") row.detail = failureFromEvidence(row, row.diagnostic);
 				}
 			}
-			if (!safeId(id, config.copilotToken)) row.id = "[unsupported ID]";
+			if (!safeId(id, config)) row.id = "[unsupported ID]";
 			results.push(row);
-			for (const line of renderProbeRow(row, width, color, columns)) console.log(scrubSensitiveUrls(line));
-			if (options.details) for (const line of renderProbeDetails(row, row.diagnostic)) console.log(line);
-			else if (row.status !== "PASS" && row.diagnostic) console.log(`  request_id=${row.diagnostic.requestId}`);
+			for (const line of renderProbeRow(row, width, color, columns)) printLine(line);
+			if (options.details) for (const line of renderProbeDetails(row, row.diagnostic)) printLine(line);
+			else if (row.status !== "PASS" && row.diagnostic) printLine(`  request_id=${row.diagnostic.requestId}`);
 			if (row.status !== "PASS" && row.sent) withoutConsoleLogging(() => log.info(`request_id=${row.diagnostic?.requestId ?? "unknown"} model_probe model=${row.id} status=${row.status} reason=${row.detail}`));
 		}
 	} finally {
@@ -6172,11 +7220,11 @@ async function probeModels(config, entries, options) {
 		process.off("SIGINT", interrupt);
 		process.off("SIGTERM", interrupt);
 	}
-	console.log(`\n${renderProbeSummary(results)}`);
-	if (results.some((row) => row.unverified)) console.log("* Effort or endpoint metadata is unverified.");
-	const hints = new Set(results.filter((row) => row.status !== "PASS").map((row) => probeHint(row.detail)).filter(Boolean));
-	for (const hint of hints) console.log(hint);
-	if (!options.details && results.some((row) => row.status !== "PASS" && row.sent)) console.log("Use --details for request evidence; another deep run consumes usage.");
+	printLine(`\n${renderProbeSummary(results)}`);
+	if (results.some((row) => row.unverified)) printLine("* Effort or endpoint metadata is unverified.");
+	const hints = new Set(results.filter((row) => row.status !== "PASS").map((row) => probeHint(row.detail)).filter((hint) => hint !== void 0));
+	for (const hint of hints) printLine(hint);
+	if (!options.details && results.some((row) => row.status !== "PASS" && row.sent)) printLine("Use --details for request evidence; another deep run consumes usage.");
 	if (controller.signal.aborted) return 130;
 	return results.length > 0 && results.every((row) => row.status === "PASS") ? 0 : 2;
 }
@@ -6269,8 +7317,9 @@ const renderConfigGuide = (configPath$1, configured, chosen) => {
 //#endregion
 //#region src/models.ts
 var ModelsUsageError = class extends Error {};
+const printable = (text$1) => scrubLogSecrets(terminalText(text$1));
 const displayName = (name) => {
-	const text$1 = sanitizeTerminalString(name ?? "").trim();
+	const text$1 = printable(name ?? "").trim();
 	if (text$1 === "") return;
 	return text$1.length > 80 ? `${text$1.slice(0, 77)}...` : text$1;
 };
@@ -6278,7 +7327,7 @@ const listedModels = (config, catalog) => [...catalog.models.keys()].sort().map(
 	const selection = selectCopilotEndpoint(config, id);
 	const name = displayName(catalog.models.get(id)?.name);
 	return {
-		id: sanitizeTerminalString(id),
+		id: printable(id),
 		...name !== void 0 && { name },
 		...!selection.endpoint && { unusable: probeReason(selection.reason) }
 	};
@@ -6288,7 +7337,7 @@ const configuredModels = (appConfig, config, catalog) => ["gptModel", "opusModel
 	const selection = selectCopilotEndpoint(config, id);
 	return {
 		key,
-		value: sanitizeTerminalString(appConfig[key]),
+		value: printable(appConfig[key]),
 		advertised: catalog.models.has(id),
 		...!selection.endpoint && { unusable: probeReason(selection.reason) }
 	};
@@ -6298,7 +7347,7 @@ const listingHeading = (search, result) => {
 		if (result.models.length === 0) return "No models advertised by upstream.";
 		return `Upstream-advertised models (${result.models.length}):`;
 	}
-	const label = sanitizeTerminalString(search);
+	const label = printable(search);
 	if (result.found) return `Upstream models matching "${label}" (${result.models.length}):`;
 	if (result.models.length === 0) return `No upstream model matches "${label}". List them all with copilot-relay models.`;
 	return `No upstream model matches "${label}". Closest IDs (${result.models.length}):`;
@@ -6375,6 +7424,8 @@ const models = defineCommand({
 				const appConfig$1 = await readAppConfig();
 				setLogLevel(appConfig$1.logLevel);
 				registerSensitiveOrigin(appConfig$1.copilotBaseUrl);
+				registerLogSecret(appConfig$1.apiKey);
+				configureUpstreamDispatcher(appConfig$1.upstreamProxy);
 				const config$1 = readProxyConfig(appConfig$1);
 				failure = "Could not authenticate with GitHub Copilot";
 				await setupProxyAuth(config$1, args.deep ? { onDeviceCode: (url, code) => console.error(`Sign in: open ${terminalText(url)} and enter ${terminalText(code)}.`) } : void 0);
@@ -6405,7 +7456,7 @@ const models = defineCommand({
 			const lines = [listingHeading(search, result), ...renderModelRows(result.models)];
 			if (result.models.length > 0) lines.push("Inference, tool, and effort compatibility are not verified by this listing.", `Test one with copilot-relay models --deep --model ${result.chosen?.id ?? "<id>"}; it consumes Copilot usage.`);
 			lines.push("", ...renderConfigGuide(paths.configPath, configuredModels(appConfig, config, catalog), result.chosen));
-			console.log(scrubSensitiveUrls(lines.join("\n")));
+			console.log(lines.map((line) => scrubLogSecrets(scrubSensitiveUrls(terminalText(line)))).join("\n"));
 			if (!result.found) process.exitCode = 1;
 		} catch (error) {
 			let detail = "Check configuration, authentication, and upstream connectivity.";
@@ -6970,8 +8021,8 @@ const replay = defineCommand({
 			console.log(`${method} ${path$1} status=${status$1 ?? "unknown"} outcome=${outcome}`);
 			console.log(`upstream=${routes$1.join(" -> ") || "none"}`);
 			for (const exchange of result.summary.exchanges) {
-				const usage = Object.entries(exchange.usage).map(([key, value]) => `${key}=${value}`).join(" ");
-				console.log(`exchange=${exchange.order} path=${exchange.path} status=${exchange.status ?? "unknown"} outcome=${exchange.outcome}${usage ? ` ${usage}` : ""}${exchange.refusalCategory ? ` refusal_category=${exchange.refusalCategory}` : ""}`);
+				const usage$1 = Object.entries(exchange.usage).map(([key, value]) => `${key}=${value}`).join(" ");
+				console.log(`exchange=${exchange.order} path=${exchange.path} status=${exchange.status ?? "unknown"} outcome=${exchange.outcome}${usage$1 ? ` ${usage$1}` : ""}${exchange.refusalCategory ? ` refusal_category=${exchange.refusalCategory}` : ""}`);
 			}
 			if (result.summary.contentBlocks) console.log(`client_blocks=${result.summary.contentBlocks.join(",") || "none"} tool_calls=${result.summary.toolCalls ?? 0}`);
 		}
@@ -6988,6 +8039,22 @@ const getRelayBaseUrl = (host, port) => {
 	const hostname = new URL(`http://${authority}`).hostname;
 	return `http://${loopbackForWildcard.get(hostname) ?? hostname}:${port}`;
 };
+const loopbackAddresses = new BlockList();
+loopbackAddresses.addSubnet("127.0.0.0", 8, "ipv4");
+loopbackAddresses.addAddress("::1", "ipv6");
+/**
+* True when a bind host accepts connections from this machine only.
+*
+* Literal loopback addresses and the name localhost qualify. Wildcards, other addresses and other
+* names do not: a name can resolve to any address, so it is treated as reachable from the network.
+*/
+const isLoopbackHost = (host) => {
+	const bare = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+	if (bare.toLowerCase() === "localhost") return true;
+	const family = isIP(bare);
+	if (family === 0) return false;
+	return loopbackAddresses.check(bare, family === 4 ? "ipv4" : "ipv6");
+};
 
 //#endregion
 //#region src/lib/lifecycle.ts
@@ -7424,18 +8491,20 @@ const knownModelEnvKeys = [
 	"ANTHROPIC_SMALL_FAST_MODEL",
 	"CLAUDE_CODE_SUBAGENT_MODEL"
 ];
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const hasMalformedModelOverride = (parsed) => {
 	if (parsed.model !== void 0 && typeof parsed.model !== "string") return true;
 	const env = parsed.env;
-	if (!isRecord(env)) return false;
+	if (!isRecord$1(env)) return false;
 	return knownModelEnvKeys.some((key) => env[key] !== void 0 && typeof env[key] !== "string");
 };
 const hasPrimaryModelOverride = (parsed, env) => typeof parsed.model === "string" || typeof env.ANTHROPIC_MODEL === "string";
 /**
 * Update `~/.claude/settings.json` so its env block points Claude Code at the
 * running proxy. Preserves unrelated keys and model choices while normalizing
-* managed one-million-context GPT overrides. Sets a dummy auth token only if absent.
+* managed one-million-context GPT overrides. Sets the auth token to the relay's
+* apiKey when one is configured and then publishes the file owner-only;
+* otherwise keeps an existing token and writes a dummy value only if none is set.
 */
 async function applyClaudeConfig(input) {
 	const { configPath: configPath$1, baseUrl, gptModel } = input;
@@ -7450,7 +8519,7 @@ async function applyClaudeConfig(input) {
 	};
 	if (raw.trim().length > 0) try {
 		const value = JSON.parse(raw);
-		if (!isRecord(value) || value.env !== void 0 && !isRecord(value.env) || hasMalformedModelOverride(value)) return {
+		if (!isRecord$1(value) || value.env !== void 0 && !isRecord$1(value.env) || hasMalformedModelOverride(value)) return {
 			configPath: configPath$1,
 			changed: false,
 			created: false
@@ -7463,7 +8532,7 @@ async function applyClaudeConfig(input) {
 			created: false
 		};
 	}
-	const env = isRecord(parsed.env) ? { ...parsed.env } : {};
+	const env = isRecord$1(parsed.env) ? { ...parsed.env } : {};
 	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
 	const hadPrimaryModelOverride = hasPrimaryModelOverride(parsed, env);
 	const contextWindow = input.gptLimits?.max_context_window_tokens;
@@ -7472,9 +8541,11 @@ async function applyClaudeConfig(input) {
 	const nextModel = typeof parsed.model === "string" ? normalizeClaudeModelId(parsed.model, contextWindow) : void 0;
 	for (const key of knownModelEnvKeys) if (typeof env[key] === "string") env[key] = normalizeClaudeModelId(env[key], contextWindow);
 	env.ANTHROPIC_BASE_URL = baseUrl;
-	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
+	if (input.apiKey) env.ANTHROPIC_AUTH_TOKEN = input.apiKey;
+	else if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
 	if (contextWindow !== void 0 && env.CLAUDE_CODE_MAX_CONTEXT_TOKENS === void 0) env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(contextWindow);
 	if (input.maxOutputTokens !== void 0 && env.CLAUDE_CODE_MAX_OUTPUT_TOKENS === void 0) env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = String(input.maxOutputTokens);
+	if (env.CLAUDE_CODE_AUTO_MODE_SERVER === void 0) env.CLAUDE_CODE_AUTO_MODE_SERVER = "0";
 	const next = {
 		...parsed,
 		...nextModel !== void 0 && { model: nextModel },
@@ -7482,13 +8553,15 @@ async function applyClaudeConfig(input) {
 		env
 	};
 	const serialized = `${JSON.stringify(next, null, 2)}\n`;
-	if (serialized === raw) return {
+	const writesKey = Boolean(input.apiKey);
+	const keyExposed = writesKey && process.platform !== "win32" && (snapshot.mode & 63) !== 0;
+	if (serialized === raw && !keyExposed) return {
 		configPath: configPath$1,
 		changed: false,
 		created: false,
 		previousBaseUrl
 	};
-	await writeFileSnapshot(snapshot, serialized);
+	await writeFileSnapshot(snapshot, serialized, { ownerOnly: writesKey });
 	return {
 		configPath: configPath$1,
 		changed: true,
@@ -7559,6 +8632,34 @@ const validateUpstream = async (config, thinkEffort) => {
 //#endregion
 //#region src/start.ts
 const canCloseConnections = (server) => typeof server.closeIdleConnections === "function" && typeof server.closeAllConnections === "function";
+/**
+* The startup warning for a listener that other machines may reach without a key.
+*
+* A warning rather than a refusal, so an existing `host: 0.0.0.0` setup keeps
+* working after an upgrade. It names the apiKey setting and never prints a key.
+*/
+const unauthenticatedListenerWarning = (config) => {
+	if (config.apiKey || isLoopbackHost(config.host)) return;
+	return terminalText(`apiKey is empty and host ${config.host} is not a loopback address: any client that can reach port ${config.port} can consume your Copilot usage. Set apiKey in ${paths.configPath}, or bind host to 127.0.0.1.`);
+};
+/**
+* The warning for a config.yaml that other local users can access while it holds the apiKey.
+*
+* A new config.yaml is created 0600, but an existing one keeps its mode, and the relay never
+* changes the mode of the user's own file. stat follows a symlink, so the mode checked is the
+* target's. Windows has no POSIX mode bits. It never prints a key.
+*/
+const exposedConfigWarning = (config, configPath$1 = paths.configPath) => {
+	if (!config.apiKey || process.platform === "win32") return;
+	let mode;
+	try {
+		mode = statSync(configPath$1).mode & 511;
+	} catch {
+		return;
+	}
+	if ((mode & 63) === 0) return;
+	return terminalText(`${configPath$1} holds the apiKey and has mode ${mode.toString(8).padStart(4, "0")}, which lets other local users access it. Run chmod 600 ${configPath$1}.`);
+};
 async function startRelay(appConfig) {
 	appConfig ??= await readAppConfig();
 	appConfig = {
@@ -7568,10 +8669,12 @@ async function startRelay(appConfig) {
 	setLogLevel(appConfig.logLevel);
 	await cleanupLogs(appConfig.logRetentionDays);
 	await cleanupCaptures(appConfig.logRetentionDays);
+	configureUpstreamDispatcher(appConfig.upstreamProxy);
 	const claudeConfigPath$1 = claudeConfigPath;
 	const config = readProxyConfig(appConfig);
 	const applyRuntimeConfig = (nextConfig) => {
 		registerSensitiveOrigin(nextConfig.copilotBaseUrl);
+		registerLogSecret(nextConfig.apiKey);
 		setLogLevel(nextConfig.logLevel);
 		cleanupLogs(nextConfig.logRetentionDays).catch(() => log.error("Log retention failed; existing logs retained."));
 		cleanupCaptures(nextConfig.logRetentionDays);
@@ -7585,6 +8688,7 @@ async function startRelay(appConfig) {
 		config.upstreamTimeoutMs = nextConfig.upstreamTimeoutSeconds * 1e3;
 		config.webSearchBackend = nextConfig.webSearchBackend;
 		config.claudeUpstreamApi = nextConfig.claudeUpstreamApi;
+		config.apiKey = nextConfig.apiKey;
 		runtimeState.modelRouting = {
 			gptModel: nextConfig.gptModel,
 			opusModel: nextConfig.opusModel
@@ -7594,6 +8698,11 @@ async function startRelay(appConfig) {
 	log.info(`Log level: ${appConfig.logLevel}`);
 	log.info(`Default think effort: ${appConfig.thinkEffort}`);
 	log.info(`Upstream timeout: ${appConfig.upstreamTimeoutSeconds}s`);
+	if (appConfig.upstreamProxy !== void 0) log.info(`Upstream proxy: ${formatUpstreamProxyForDisplay(appConfig.upstreamProxy)}`);
+	const listenerWarning = unauthenticatedListenerWarning(appConfig);
+	if (listenerWarning) log.error(listenerWarning);
+	const configWarning = exposedConfigWarning(appConfig);
+	if (configWarning) log.error(configWarning);
 	const authSession = await setupProxyAuth(config);
 	try {
 		await validateUpstream(config, appConfig.thinkEffort);
@@ -7620,6 +8729,7 @@ async function startRelay(appConfig) {
 		const gptLimits = getCachedCopilotModel(config, appConfig.gptModel)?.limits;
 		const opusLimits = getCachedCopilotModel(config, appConfig.opusModel)?.limits;
 		const claudeResult = await applyClaudeConfig({
+			apiKey: appConfig.apiKey,
 			baseUrl,
 			configPath: claudeConfigPath$1,
 			gptModel: appConfig.gptModel,
@@ -7634,8 +8744,11 @@ async function startRelay(appConfig) {
 		log.error(`Could not update claude settings (${claudeConfigPath$1}):`, error);
 	}
 	const configWatcher = watchAppConfig((nextConfig) => {
+		const previousApiKey = config.apiKey;
 		applyRuntimeConfig(nextConfig);
 		log.info(`Config reloaded: logLevel=${nextConfig.logLevel} thinkEffort=${nextConfig.thinkEffort} upstreamTimeoutSeconds=${nextConfig.upstreamTimeoutSeconds}`);
+		const reloadedConfigWarning = nextConfig.apiKey === previousApiKey ? void 0 : exposedConfigWarning(nextConfig);
+		if (reloadedConfigWarning) log.error(reloadedConfigWarning);
 	});
 	const shutdownGraceMs = 2e3;
 	const shutdown = (signal) => {
@@ -7718,7 +8831,9 @@ const localProbeTimeoutMs = 5e3;
 const deepProbeTimeoutMs = 6e4;
 const toStatusConfig = (config) => ({
 	...config,
+	apiKey: config.apiKey ? "[redacted]" : "",
 	copilotBaseUrl: formatUrlForDisplay(config.copilotBaseUrl),
+	upstreamProxy: config.upstreamProxy === void 0 ? null : formatUpstreamProxyForDisplay(config.upstreamProxy),
 	webSearchBackend: config.webSearchBackend ?? null,
 	claudeUpstreamApi: config.claudeUpstreamApi ?? "chat-completions"
 });
@@ -7772,27 +8887,35 @@ const formatUptime = (startedAt) => {
 const configRowOrder = {
 	host: 0,
 	port: 1,
-	copilotBaseUrl: 2,
-	claudeSetup: 3,
-	logLevel: 4,
-	logRetentionDays: 5,
-	thinkEffort: 6,
-	upstreamTimeoutSeconds: 7,
-	webSearchBackend: 8,
-	gptModel: 9,
-	opusModel: 10,
-	claudeUpstreamApi: 11
+	apiKey: 2,
+	copilotBaseUrl: 3,
+	upstreamProxy: 4,
+	claudeSetup: 5,
+	logLevel: 6,
+	logRetentionDays: 7,
+	thinkEffort: 8,
+	upstreamTimeoutSeconds: 9,
+	webSearchBackend: 10,
+	gptModel: 11,
+	opusModel: 12,
+	claudeUpstreamApi: 13
 };
 const configRowKeys = Object.keys(configRowOrder).sort((a, b) => configRowOrder[a] - configRowOrder[b]);
+const unsetConfigText = {
+	apiKey: "(unset — clients need no key)",
+	upstreamProxy: "(unset — connects directly)",
+	webSearchBackend: "(unset — uses gptModel)"
+};
 /**
 * The resolved config, one key per line.
 *
 * These are the values on disk. That is not the same question as "what is the
 * running daemon honouring", and the footnote says so rather than leaving it
-* implied: applyRuntimeConfig() in start.ts never reads claudeSetup and
-* deliberately does not rebind the listening socket when host or port
-* changes; it hot-reloads the rest. Printing every key without that line
-* would imply a live daemon had read values it has not.
+* implied: applyRuntimeConfig() in start.ts never reads claudeSetup, and
+* deliberately neither rebinds the listening socket when host or port changes
+* nor rebuilds the upstream dispatcher when upstreamProxy changes; it
+* hot-reloads the rest. Printing every key without that line would imply a
+* live daemon had read values it has not.
 *
 * Only shown when running, because with nothing up every value applies at the
 * next start and the note would be noise.
@@ -7800,10 +8923,10 @@ const configRowKeys = Object.keys(configRowOrder).sort((a, b) => configRowOrder[
 const renderConfig = (config, running) => {
 	const lines = configRowKeys.map((key) => {
 		const value = config[key];
-		const rendered = key === "webSearchBackend" && value === null ? "(unset — uses gptModel)" : String(value);
+		const rendered = (value === null || value === "" ? unsetConfigText[key] : void 0) ?? String(value);
 		return `    ${key.padEnd(24)}${sanitizeTerminalString(rendered)}`;
 	});
-	if (running) lines.push("    host, port and claudeSetup take effect on restart; the rest hot-reload.");
+	if (running) lines.push("    host, port, claudeSetup and upstreamProxy take effect on restart; the rest hot-reload.");
 	return lines;
 };
 /**
@@ -7831,9 +8954,26 @@ const renderStatus = (status$1, color = false) => {
 	if (hasVersionMismatch(status$1)) lines.push("", `  The running relay is ${status$1.daemonVersion}; ${status$1.version} is installed.`, "  Restart it to serve the installed version: copilot-relay restart");
 	return lines;
 };
+let relayAgent;
+/**
+* How the probes reach the relay's own listener: undici's fetch with a direct Agent of their own,
+* never the global dispatcher and never the upstream one. With NODE_USE_ENV_PROXY=1, Node's fetch
+* sends even a request to localhost through HTTP_PROXY unless NO_PROXY exempts it, so through a
+* proxy that refuses, status would report a healthy relay as unusable. upstreamProxy is for
+* Copilot and GitHub, not for this machine.
+*
+* An object, so a test can replace fetch.
+*/
+const relayListener = { fetch: (url, init) => {
+	relayAgent ??= new Agent();
+	return fetch(url, {
+		...init,
+		dispatcher: relayAgent
+	});
+} };
 const probe = async (url, init, timeoutMs) => {
 	const started = performance.now();
-	const response = await fetch(url, {
+	const response = await relayListener.fetch(url, {
 		...init,
 		signal: AbortSignal.timeout(timeoutMs)
 	});
@@ -7878,9 +9018,10 @@ const checkHealth = async (baseUrl) => {
 		} };
 	}
 };
-const readModels = async (baseUrl) => {
+const relayKeyHeaders = (apiKey) => apiKey ? { "x-api-key": apiKey } : {};
+const readModels = async (baseUrl, apiKey) => {
 	try {
-		const data = (await probe(`${baseUrl}/v1/models`, {}, localProbeTimeoutMs)).body?.data;
+		const data = (await probe(`${baseUrl}/v1/models`, { headers: relayKeyHeaders(apiKey) }, localProbeTimeoutMs)).body?.data;
 		return Array.isArray(data) ? data.flatMap((model) => typeof model.id === "string" ? [model.id] : []) : [];
 	} catch {
 		return [];
@@ -7892,7 +9033,7 @@ const readModels = async (baseUrl) => {
 * Opt-in because it spends tokens. It is the only check that exercises token
 * refresh, the upstream call, and translation back to Claude shape.
 */
-const checkDeep = async (baseUrl, model) => {
+const checkDeep = async (baseUrl, model, apiKey) => {
 	try {
 		const result = await probe(`${baseUrl}/v1/messages`, {
 			body: JSON.stringify({
@@ -7905,7 +9046,8 @@ const checkDeep = async (baseUrl, model) => {
 			}),
 			headers: {
 				"anthropic-version": "2023-06-01",
-				"content-type": "application/json"
+				"content-type": "application/json",
+				...relayKeyHeaders(apiKey)
 			},
 			method: "POST"
 		}, deepProbeTimeoutMs);
@@ -7948,6 +9090,7 @@ const collectStatus = async (options) => {
 	});
 	setLogLevel(appConfig.logLevel);
 	registerSensitiveOrigin(appConfig.copilotBaseUrl);
+	registerLogSecret(appConfig.apiKey);
 	const base = {
 		config: toStatusConfig(appConfig),
 		configPath: paths.configPath,
@@ -7963,8 +9106,8 @@ const collectStatus = async (options) => {
 	};
 	const baseUrl = getRelayBaseUrl(relay.host, relay.port);
 	const health = await checkHealth(baseUrl);
-	const models$1 = health.result.ok ? await readModels(baseUrl) : [];
-	const deep = options.deep && health.result.ok ? await checkDeep(baseUrl, models$1[0] ?? appConfig.gptModel) : void 0;
+	const models$1 = health.result.ok ? await readModels(baseUrl, appConfig.apiKey) : [];
+	const deep = options.deep && health.result.ok ? await checkDeep(baseUrl, models$1[0] ?? appConfig.gptModel, appConfig.apiKey) : void 0;
 	const daemonVersion = health.version ?? relay.version;
 	return {
 		...base,
@@ -8009,8 +9152,8 @@ const status = defineCommand({
 			process.exitCode = exitCodes.notUsable;
 			return;
 		}
-		if (args.json) console.log(scrubSensitiveUrls(JSON.stringify(result, null, 2)));
-		else console.log(scrubSensitiveUrls(renderStatus(result, colorEnabled()).join("\n")));
+		if (args.json) console.log(scrubLogSecrets(scrubSensitiveUrls(withoutHiddenCharacters(JSON.stringify(result, null, 2)))));
+		else console.log(scrubLogSecrets(scrubSensitiveUrls(withoutHiddenCharacters(renderStatus(result, colorEnabled()).join("\n")))));
 		process.exitCode = resolveExitCode(result);
 	}
 });
@@ -8037,6 +9180,225 @@ const stop = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/usage.ts
+const knownQuotaIds = [
+	"chat",
+	"completions",
+	"premium_interactions"
+];
+/** A failure the command reports. The message is one printable line and never holds the token. */
+var CopilotUsageError = class extends Error {};
+const notAnObject = "GitHub's answer to the usage request was not a JSON object.";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringField = (value) => typeof value === "string" ? terminalText(value) : null;
+const numberField = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+const booleanField = (value) => typeof value === "boolean" ? value : null;
+const parseSnapshot = (value) => {
+	if (!isRecord(value)) return null;
+	return {
+		unlimited: booleanField(value.unlimited),
+		entitlement: numberField(value.entitlement),
+		remaining: numberField(value.remaining),
+		percent_remaining: numberField(value.percent_remaining),
+		overage_permitted: booleanField(value.overage_permitted),
+		overage_count: numberField(value.overage_count),
+		token_based_billing: booleanField(value.token_based_billing),
+		credits_used: numberField(value.credits_used)
+	};
+};
+/**
+* The plan and quota fields of a copilot_internal/user answer, each checked on its own.
+*
+* Throws CopilotUsageError when the answer is not a JSON object at all.
+*/
+const parseCopilotUsage = (body) => {
+	if (!isRecord(body)) throw new CopilotUsageError(notAnObject);
+	const quota = body.quota_snapshots;
+	const reported = isRecord(quota) ? quota : {};
+	const snapshots = /* @__PURE__ */ new Map();
+	for (const id of knownQuotaIds) snapshots.set(id, parseSnapshot(reported[id]));
+	for (const [rawId, value] of Object.entries(reported)) {
+		const id = terminalText(rawId);
+		if (id === "" || snapshots.has(id)) continue;
+		snapshots.set(id, parseSnapshot(value));
+	}
+	return {
+		copilot_plan: stringField(body.copilot_plan),
+		access_type_sku: stringField(body.access_type_sku),
+		quota_reset_date: stringField(body.quota_reset_date),
+		quota_snapshots: Object.fromEntries(snapshots)
+	};
+};
+const notReported = "not reported";
+const formatNumber = (value) => value === null ? "?" : String(value);
+const formatAllowance = (snapshot) => {
+	if (snapshot.unlimited === true) return "unlimited";
+	return `${`${formatNumber(snapshot.remaining)} of ${formatNumber(snapshot.entitlement)} remaining`} (${formatNumber(snapshot.percent_remaining)}%)`;
+};
+const formatOverage = (snapshot) => {
+	let permitted = "overage ?";
+	if (snapshot.overage_permitted === true) permitted = "overage permitted";
+	else if (snapshot.overage_permitted === false) permitted = "overage not permitted";
+	return `${permitted}, overage count ${formatNumber(snapshot.overage_count)}`;
+};
+const formatQuota = (snapshot) => {
+	const parts = [formatAllowance(snapshot), formatOverage(snapshot)];
+	if (snapshot.credits_used !== null) parts.push(`credits used ${formatNumber(snapshot.credits_used)}`);
+	return parts.join("; ");
+};
+/** The report as text lines. Kept free of IO, so it is tested without a terminal. */
+const renderCopilotUsage = (usage$1, color = false) => {
+	const shown = (value) => value ?? colorText(notReported, "muted", color);
+	const headings = [
+		["Plan", usage$1.copilot_plan],
+		["SKU", usage$1.access_type_sku],
+		["Quota reset", usage$1.quota_reset_date]
+	];
+	const labelWidth = Math.max(...headings.map(([label]) => label.length));
+	const known = [...knownQuotaIds];
+	const ids = [...known, ...Object.keys(usage$1.quota_snapshots).filter((id) => !known.includes(id))];
+	const idWidth = Math.max(...ids.map((id) => id.length));
+	const quotaLines = ids.map((id) => {
+		const snapshot = usage$1.quota_snapshots[id] ?? null;
+		const text$1 = snapshot === null ? colorText(notReported, "muted", color) : formatQuota(snapshot);
+		return `${id.padEnd(idWidth)}  ${text$1}`;
+	});
+	return [
+		...headings.map(([label, value]) => `${label.padEnd(labelWidth)}  ${shown(value)}`),
+		"",
+		...quotaLines
+	];
+};
+const requestTimeoutSeconds = 30;
+const tokenInAnswer = "GitHub's answer to the usage request contains the stored token, so none of it is printed.";
+const visibleToken = (token) => terminalText(token);
+const withoutToken = (line, token) => {
+	const visible = visibleToken(token);
+	return visible === "" ? line : line.replaceAll(visible, "[redacted]");
+};
+const lettersAndDigits = (text$1) => text$1.replace(/[^A-Za-z0-9]/g, "");
+const minimumSpelledLength = 16;
+const spellsToken = (text$1, token) => {
+	const spelled = lettersAndDigits(visibleToken(token));
+	return spelled.length >= minimumSpelledLength && lettersAndDigits(text$1).includes(spelled);
+};
+const showsToken = (usage$1, token) => {
+	const visible = visibleToken(token);
+	const printed = [
+		usage$1.copilot_plan,
+		usage$1.access_type_sku,
+		usage$1.quota_reset_date,
+		...Object.keys(usage$1.quota_snapshots)
+	].filter((text$1) => text$1 !== null);
+	if (visible !== "" && printed.some((text$1) => text$1.includes(visible))) return true;
+	return spellsToken(printed.join(""), token);
+};
+const failureReason = (error) => {
+	const cause = error instanceof Error ? error.cause : void 0;
+	if (cause instanceof Error && cause.message !== "") return cause.message;
+	const code = cause?.code;
+	if (typeof code === "string") return code;
+	return error instanceof Error && error.message !== "" ? error.message : String(error);
+};
+const isTimeout = (error) => typeof error === "object" && error !== null && "name" in error && error.name === "TimeoutError";
+const describeRequestFailure = async (error, token) => {
+	if (error instanceof HTTPError) {
+		await error.response.body?.cancel().catch(() => {});
+		const status$1 = error.response.status;
+		if (status$1 === 401 || status$1 === 403) return new CopilotUsageError(`GitHub rejected the stored token (HTTP ${status$1}). Sign in again with copilot-relay auth.`);
+		return new CopilotUsageError(`GitHub answered the usage request with HTTP ${status$1}.`);
+	}
+	if (isTimeout(error)) return new CopilotUsageError(`GitHub did not answer within ${requestTimeoutSeconds} seconds.`);
+	if (error instanceof SyntaxError) return new CopilotUsageError(notAnObject);
+	const line = withoutToken(terminalText(`Could not reach GitHub: ${failureReason(error)}`), token);
+	return new CopilotUsageError(spellsToken(line, token) ? "Could not reach GitHub." : line);
+};
+const readToken = async () => {
+	let token;
+	try {
+		token = await readStoredGitHubToken();
+	} catch (error) {
+		const code = error?.code;
+		const reason = typeof code === "string" ? `: ${code}` : "";
+		throw new CopilotUsageError(terminalText(`Could not read the GitHub token at ${paths.githubTokenPath}${reason}.`));
+	}
+	if (token === void 0) throw new CopilotUsageError(terminalText(`No GitHub token is stored at ${paths.githubTokenPath}. Sign in with copilot-relay auth.`));
+	return token;
+};
+/**
+* Builds this process's upstream dispatcher from upstreamProxy, as start, auth and models do, but
+* reads config.yaml without creating, completing or rewriting it. Without a config.yaml the
+* request connects directly.
+*
+* A config.yaml that cannot be read or is invalid gets one fixed line, whatever the reason, so no
+* text from that file can reach the terminal: it can hold credentials, such as an upstreamProxy
+* password.
+*/
+const applyUpstreamProxy = async () => {
+	let upstreamProxy;
+	try {
+		upstreamProxy = (await readExistingAppConfig())?.upstreamProxy;
+	} catch {
+		throw new CopilotUsageError(terminalText(`Could not read the config at ${paths.configPath}; fix it, then run copilot-relay usage again.`));
+	}
+	try {
+		configureUpstreamDispatcher(upstreamProxy);
+	} catch (error) {
+		if (error instanceof InvalidProxyEnvironmentError) throw new CopilotUsageError(error.message);
+		throw error;
+	}
+};
+const requestCopilotUsage = async () => {
+	const token = await readToken();
+	await applyUpstreamProxy();
+	let body;
+	try {
+		body = await getCopilotUsage(token, vscodeVersion, AbortSignal.timeout(requestTimeoutSeconds * 1e3));
+	} catch (error) {
+		throw await describeRequestFailure(error, token);
+	}
+	const usage$1 = parseCopilotUsage(body);
+	if (showsToken(usage$1, token)) throw new CopilotUsageError(tokenInAnswer);
+	return usage$1;
+};
+/**
+* The Copilot plan and quota of the stored GitHub token's account.
+*
+* Reads the token file and config.yaml, and asks GitHub through upstreamProxy; writes nothing.
+* Logging is off throughout, so a line the upstream request would log, such as the hint about an
+* ignored proxy variable, never reaches the log file. Every failure becomes a CopilotUsageError
+* whose message is the line to print.
+*/
+const loadCopilotUsage = () => withoutLogging(requestCopilotUsage);
+
+//#endregion
+//#region src/usage.ts
+const usage = defineCommand({
+	meta: {
+		name: "usage",
+		description: "Show the Copilot plan and quota GitHub reports for the stored GitHub token."
+	},
+	args: { json: {
+		description: "Print the plan and quota fields as a JSON object.",
+		type: "boolean"
+	} },
+	async run({ args }) {
+		try {
+			const report = await loadCopilotUsage();
+			if (args.json) console.log(JSON.stringify(report, null, 2));
+			else console.log(renderCopilotUsage(report, colorEnabled()).join("\n"));
+		} catch (error) {
+			if (error instanceof CopilotUsageError) console.error(error.message);
+			else {
+				const name = error instanceof Error ? error.name : typeof error;
+				console.error(terminalText(`Could not show the Copilot usage: unexpected ${name}.`));
+			}
+			process.exitCode = 1;
+		}
+	}
+});
+
 //#endregion
 //#region src/main.ts
 await runMain(defineCommand({
@@ -8046,12 +9408,14 @@ await runMain(defineCommand({
 	},
 	subCommands: {
 		auth,
+		cache,
 		models,
 		replay,
 		restart,
 		start,
 		status,
-		stop
+		stop,
+		usage
 	}
 }));