copilot-relay 0.0.2

package/dist/main.js

@@ -0,0 +1,2212 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import fs from "node:fs/promises";
+import { inspect } from "node:util";
+import consola from "consola";
+import os from "node:os";
+import path, { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { events } from "fetch-event-stream";
+import { readFileSync } from "node:fs";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { streamSSE } from "hono/streaming";
+
+//#region src/lib/error.ts
+var ProxyNotImplementedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ProxyNotImplementedError";
+	}
+};
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.name = "HTTPError";
+		this.response = response;
+	}
+};
+
+//#endregion
+//#region src/lib/paths.ts
+const homeDir = os.homedir();
+const appDir = path.join(homeDir, ".copilot-relay");
+const legacyGithubTokenPaths = [
+	path.join(homeDir, ".copilot-tennel", "github_token"),
+	path.join(homeDir, "Library", "Application Support", "copilot-tennel", "github_token"),
+	path.join(homeDir, ".local", "share", "copilot-tennel", "github_token"),
+	path.join(homeDir, "Library", "Application Support", "copilot-relay", "github_token"),
+	path.join(homeDir, ".local", "share", "copilot-relay", "github_token"),
+	path.join(homeDir, ".local", "share", "copilot-bridge", "github_token")
+];
+const legacyCopilotTokenPaths = [
+	path.join(homeDir, ".copilot-tennel", "copilot_token.json"),
+	path.join(homeDir, "Library", "Application Support", "copilot-tennel", "copilot_token.json"),
+	path.join(homeDir, ".local", "share", "copilot-tennel", "copilot_token.json"),
+	path.join(homeDir, "Library", "Application Support", "copilot-relay", "copilot_token.json"),
+	path.join(homeDir, ".local", "share", "copilot-relay", "copilot_token.json")
+];
+const configPath = path.join(appDir, "config.yaml");
+const copilotTokenPath = path.join(appDir, "copilot_token.json");
+const githubTokenPath = path.join(appDir, "github_token");
+const logsDir = path.join(appDir, "logs");
+const logPath = path.join(logsDir, "copilot-relay.log");
+const paths = {
+	appDir,
+	configPath,
+	copilotTokenPath,
+	githubTokenPath,
+	legacyConfigPaths: [
+		path.join(homeDir, ".copilot-relay.yaml"),
+		path.join(homeDir, ".copilot-tennel", "config.yaml"),
+		path.join(homeDir, ".copilot-tennel.yaml")
+	],
+	legacyCopilotTokenPaths,
+	logPath,
+	logsDir
+};
+async function ensurePaths() {
+	await fs.mkdir(paths.appDir, { recursive: true });
+	await ensureFile(paths.githubTokenPath, { legacyPaths: legacyGithubTokenPaths });
+}
+async function ensureFile(filePath, options = {}) {
+	try {
+		await fs.access(filePath, fs.constants.W_OK);
+	} catch {
+		for (const legacyPath of options.legacyPaths ?? []) {
+			if (legacyPath === filePath) continue;
+			try {
+				const content = await fs.readFile(legacyPath, "utf8");
+				if (content.trim()) {
+					await fs.writeFile(filePath, content, { mode: 384 });
+					await fs.chmod(filePath, 384);
+					return;
+				}
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		}
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/lib/log.ts
+const logCleanupCheckIntervalMs = 3600 * 1e3;
+let logRetentionDays = 3;
+let nextLogCleanupCheckAt = 0;
+const consolaLevelByName = {
+	silent: -Infinity,
+	error: 0,
+	warn: 1,
+	info: 3,
+	debug: 4,
+	trace: 5
+};
+const setLogLevel = (level) => {
+	consola.level = consolaLevelByName[level];
+};
+const formatLogValue = (value) => typeof value === "string" ? value : inspect(value, { depth: null });
+const writeLogFile = async (level, values) => {
+	await fs.mkdir(paths.logsDir, { recursive: true });
+	await cleanupLogsIfDue();
+	const line = [
+		(/* @__PURE__ */ new Date()).toISOString(),
+		level,
+		values.map(formatLogValue).join(" ")
+	].join(" ");
+	await fs.appendFile(paths.logPath, `${line}\n`);
+};
+const cleanupLogsIfDue = async () => {
+	const now = Date.now();
+	if (now < nextLogCleanupCheckAt) return;
+	nextLogCleanupCheckAt = now + logCleanupCheckIntervalMs;
+	await cleanupLogs(logRetentionDays);
+};
+const wrapFileLog = (level, fn) => ((...args) => {
+	writeLogFile(level, args).catch(() => void 0);
+	return fn(...args);
+});
+consola.error = wrapFileLog("error", consola.error.bind(consola));
+consola.warn = wrapFileLog("warn", consola.warn.bind(consola));
+consola.info = wrapFileLog("info", consola.info.bind(consola));
+consola.success = wrapFileLog("success", consola.success.bind(consola));
+consola.debug = wrapFileLog("debug", consola.debug.bind(consola));
+consola.trace = wrapFileLog("trace", consola.trace.bind(consola));
+const cleanupLogs = async (retentionDays) => {
+	logRetentionDays = retentionDays;
+	await fs.mkdir(paths.logsDir, { recursive: true });
+	const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+	const entries = await fs.readdir(paths.logsDir, { withFileTypes: true });
+	await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map(async (entry) => {
+		const filePath = `${paths.logsDir}/${entry.name}`;
+		if ((await fs.stat(filePath)).mtimeMs < cutoff) await fs.unlink(filePath);
+	}));
+};
+const log = consola;
+
+//#endregion
+//#region src/lib/auth.ts
+const copilotVersion$1 = "0.26.7";
+const editorPluginVersion$1 = `copilot-chat/${copilotVersion$1}`;
+const userAgent$1 = `GitHubCopilotChat/${copilotVersion$1}`;
+const githubApiVersion = "2022-11-28";
+const githubApiBaseUrl = "https://api.github.com";
+const githubBaseUrl = "https://github.com";
+const githubClientId = "Iv1.b507a08c87ecfe98";
+const githubAppScopes = ["read:user"].join(" ");
+let copilotTokenRefreshTimer;
+const standardHeaders = () => ({
+	accept: "application/json",
+	"content-type": "application/json"
+});
+const sleep = (ms) => new Promise((resolve$1) => {
+	setTimeout(resolve$1, ms);
+});
+const readGitHubToken = async () => {
+	await ensurePaths();
+	return (await fs.readFile(paths.githubTokenPath, "utf8")).trim();
+};
+const writeGitHubToken = async (token) => {
+	await ensurePaths();
+	await fs.writeFile(paths.githubTokenPath, `${token.trim()}\n`, { mode: 384 });
+};
+const readStoredCopilotToken = async () => {
+	await ensurePaths();
+	try {
+		const payload = JSON.parse(await fs.readFile(paths.copilotTokenPath, "utf8"));
+		if (typeof payload.token === "string" && typeof payload.refreshedAt === "number" && typeof payload.refreshIn === "number") return payload;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	for (const legacyPath of paths.legacyCopilotTokenPaths) try {
+		const content = await fs.readFile(legacyPath, "utf8");
+		const payload = JSON.parse(content);
+		if (typeof payload.token === "string" && typeof payload.refreshedAt === "number" && typeof payload.refreshIn === "number") {
+			await fs.writeFile(paths.copilotTokenPath, content, { mode: 384 });
+			await fs.chmod(paths.copilotTokenPath, 384);
+			return payload;
+		}
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+};
+const writeStoredCopilotToken = async (input) => {
+	await ensurePaths();
+	const payload = {
+		refreshedAt: Date.now(),
+		refreshIn: input.refresh_in,
+		token: input.token
+	};
+	await fs.writeFile(paths.copilotTokenPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
+};
+const getStoredTokenRemainingSeconds = (token) => {
+	const ageSeconds = Math.floor((Date.now() - token.refreshedAt) / 1e3);
+	return token.refreshIn - ageSeconds;
+};
+const githubHeaders = (githubToken, vsCodeVersion) => ({
+	...standardHeaders(),
+	authorization: `token ${githubToken}`,
+	"editor-plugin-version": editorPluginVersion$1,
+	"editor-version": `vscode/${vsCodeVersion}`,
+	"user-agent": userAgent$1,
+	"x-github-api-version": githubApiVersion,
+	"x-vscode-user-agent-library-version": "electron-fetch"
+});
+const getDeviceCode = async () => {
+	const response = await fetch(`${githubBaseUrl}/login/device/code`, {
+		method: "POST",
+		headers: standardHeaders(),
+		body: JSON.stringify({
+			client_id: githubClientId,
+			scope: githubAppScopes
+		})
+	});
+	if (!response.ok) throw new HTTPError("Failed to get device code", response);
+	return await response.json();
+};
+const pollAccessToken = async (deviceCode) => {
+	const sleepDuration = (deviceCode.interval + 1) * 1e3;
+	while (true) {
+		const response = await fetch(`${githubBaseUrl}/login/oauth/access_token`, {
+			method: "POST",
+			headers: standardHeaders(),
+			body: JSON.stringify({
+				client_id: githubClientId,
+				device_code: deviceCode.device_code,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		if (!response.ok) {
+			await sleep(sleepDuration);
+			continue;
+		}
+		const json = await response.json();
+		if (json.access_token) return json.access_token;
+		await sleep(sleepDuration);
+	}
+};
+const getGitHubUser = async (githubToken, vsCodeVersion) => {
+	const response = await fetch(`${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) => {
+	const response = await fetch(`${githubApiBaseUrl}/copilot_internal/v2/token`, { headers: githubHeaders(githubToken, vsCodeVersion) });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
+	return await 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();
+	if (existingToken) {
+		log.debug(`Using cached GitHub token at ${paths.githubTokenPath}`);
+		return existingToken;
+	}
+	const deviceCode = await getDeviceCode();
+	log.info(`Open ${deviceCode.verification_uri} and enter code ${deviceCode.user_code}`);
+	const githubToken = await pollAccessToken(deviceCode);
+	await writeGitHubToken(githubToken);
+	log.success(`GitHub token synced to ${paths.githubTokenPath}`);
+	return githubToken;
+};
+const loadGitHubLogin = async (githubToken, vsCodeVersion) => {
+	try {
+		return (await getGitHubUser(githubToken, vsCodeVersion)).login;
+	} catch (error) {
+		log.warn("Could not load GitHub user:", error);
+		return;
+	}
+};
+const setupProxyAuth = async (config, options = {}) => {
+	let githubToken = await ensureGitHubToken(options);
+	const applyCopilotToken = async () => {
+		const tokenResponse = await getCopilotToken(githubToken, config.vsCodeVersion);
+		config.copilotToken = tokenResponse.token;
+		await writeStoredCopilotToken(tokenResponse);
+		return tokenResponse.refresh_in;
+	};
+	const scheduleCopilotTokenRefresh = (refreshIn$1) => {
+		if (copilotTokenRefreshTimer) clearTimeout(copilotTokenRefreshTimer);
+		const refreshMs = Math.max(refreshIn$1 - 60, 60) * 1e3;
+		log.debug(`Next Copilot token refresh in ${Math.round(refreshMs / 1e3)}s`);
+		copilotTokenRefreshTimer = setTimeout(async () => {
+			try {
+				const nextRefreshIn = await applyCopilotToken();
+				log.debug("Refreshed Copilot token");
+				scheduleCopilotTokenRefresh(nextRefreshIn);
+			} catch (error) {
+				log.error("Failed to refresh Copilot token:", error);
+				scheduleCopilotTokenRefresh(60);
+			}
+		}, refreshMs);
+		if (typeof copilotTokenRefreshTimer.unref === "function") copilotTokenRefreshTimer.unref();
+	};
+	const storedToken = await readStoredCopilotToken();
+	let refreshIn;
+	if (storedToken && getStoredTokenRemainingSeconds(storedToken) > 60) {
+		config.copilotToken = storedToken.token;
+		refreshIn = getStoredTokenRemainingSeconds(storedToken);
+		log.debug(`Using cached Copilot token at ${paths.copilotTokenPath}`);
+	} else try {
+		refreshIn = await applyCopilotToken();
+	} catch (error) {
+		if (options.force || !isCopilotTokenError(error)) throw error;
+		log.warn("Cached GitHub auth could not get a Copilot token; running device auth again.");
+		githubToken = await ensureGitHubToken({
+			...options,
+			force: true
+		});
+		refreshIn = await applyCopilotToken();
+	}
+	scheduleCopilotTokenRefresh(refreshIn);
+	return {
+		githubLogin: await loadGitHubLogin(githubToken, config.vsCodeVersion),
+		source: "github-token"
+	};
+};
+
+//#endregion
+//#region src/lib/state.ts
+const runtimeState = {};
+
+//#endregion
+//#region src/lib/models.ts
+const defaultReasoningEffort = "xhigh";
+const defaultModelRouting = {
+	gptModel: "gpt-5.5",
+	opusModel: "claude-opus-4.8"
+};
+const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+const getModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
+const getExposedModelIds = () => {
+	const routing = getModelRouting();
+	return [routing.gptModel, routing.opusModel];
+};
+const routeModelId = (model) => {
+	const routing = getModelRouting();
+	return model.trim().toLowerCase().includes("opus") ? routing.opusModel : routing.gptModel;
+};
+
+//#endregion
+//#region src/lib/app-config.ts
+const logLevels = [
+	"silent",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+];
+const defaultConfig = {
+	claudeSetup: true,
+	copilotBaseUrl: "https://api.githubcopilot.com",
+	gptModel: "gpt-5.5",
+	host: "127.0.0.1",
+	logLevel: "info",
+	logRetentionDays: 3,
+	opusModel: "claude-opus-4.8",
+	port: 4142,
+	thinkEffort: defaultReasoningEffort
+};
+const isLogLevelName = (value) => typeof value === "string" && logLevels.includes(value.toLowerCase());
+const normalizeLogLevel = (value) => isLogLevelName(value) ? value.toLowerCase() : void 0;
+const normalizeBoolean = (value) => {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return;
+	const normalized = value.toLowerCase();
+	if (normalized === "true") return true;
+	if (normalized === "false") return false;
+};
+const normalizePort = (value) => {
+	const port = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+	return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
+};
+const normalizePositiveInteger = (value) => {
+	const number = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+	return Number.isInteger(number) && number > 0 ? number : void 0;
+};
+const normalizeString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+const normalizeThinkEffort = (value) => {
+	if (typeof value !== "string") return;
+	const normalized = value.toLowerCase() === "minimal" ? "low" : value.toLowerCase();
+	return isReasoningEffort(normalized) ? normalized : void 0;
+};
+const readRawConfig = async () => {
+	try {
+		return parseConfigYaml(await fs.readFile(paths.configPath, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			for (const legacyPath of paths.legacyConfigPaths) try {
+				return parseConfigYaml(await fs.readFile(legacyPath, "utf8"));
+			} catch (legacyError) {
+				if (legacyError.code !== "ENOENT") throw legacyError;
+			}
+			return readDefaultConfigTemplate();
+		}
+		throw error;
+	}
+};
+const readDefaultConfigTemplate = async () => {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) try {
+		return parseConfigYaml(await fs.readFile(resolve(currentDir, "config.default.yaml"), "utf8"));
+	} catch {
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) return {};
+		currentDir = parentDir;
+	}
+};
+const unquoteYamlScalar = (value) => {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+};
+const parseConfigYaml = (content) => {
+	const config = {};
+	for (const line of content.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const match = trimmed.match(/^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*?)\s*$/);
+		if (!match) throw new Error(`Invalid config line in ${paths.configPath}: ${line}`);
+		const [, key, value] = match;
+		switch (key) {
+			case "claudeSetup":
+			case "claude_setup":
+				config.claudeSetup = unquoteYamlScalar(value);
+				break;
+			case "copilotBaseUrl":
+			case "copilot_base_url":
+				config.copilotBaseUrl = unquoteYamlScalar(value);
+				break;
+			case "host":
+				config.host = unquoteYamlScalar(value);
+				break;
+			case "gptModel":
+			case "gpt_model":
+				config.gptModel = unquoteYamlScalar(value);
+				break;
+			case "logLevel":
+			case "log_level":
+				config.logLevel = unquoteYamlScalar(value);
+				break;
+			case "logRetentionDays":
+			case "log_retention_days":
+				config.logRetentionDays = unquoteYamlScalar(value);
+				break;
+			case "opusModel":
+			case "opus_model":
+				config.opusModel = unquoteYamlScalar(value);
+				break;
+			case "port":
+				config.port = unquoteYamlScalar(value);
+				break;
+			case "thinkEffort":
+			case "think_effort":
+				config.thinkEffort = unquoteYamlScalar(value);
+				break;
+			default: break;
+		}
+	}
+	return config;
+};
+const writeConfig = async (config) => {
+	await fs.mkdir(paths.appDir, { recursive: true });
+	const content = serializeConfig(config);
+	if (await fs.readFile(paths.configPath, "utf8").catch(() => "") === content) return;
+	await fs.writeFile(paths.configPath, content, { mode: 384 });
+};
+const serializeConfig = (config) => [
+	"# copilot-relay configuration",
+	"#",
+	"# This file is hot-reloaded while copilot-relay is running.",
+	"",
+	"# Local host for the Claude Code-compatible HTTP server.",
+	`host: ${config.host}`,
+	"",
+	"# Local port for the HTTP server.",
+	`port: ${config.port}`,
+	"",
+	"# GitHub Copilot API base URL.",
+	`copilotBaseUrl: ${config.copilotBaseUrl}`,
+	"",
+	"# Update ~/.claude/settings.json on start.",
+	`claudeSetup: ${config.claudeSetup}`,
+	"",
+	"# Log verbosity:",
+	"#   silent - no logs",
+	"#   error  - startup/preflight/request failures only",
+	"#   warn   - error logs plus recoverable warnings",
+	"#   info   - warn logs plus startup status, preflight status, HTTP requests,",
+	"#            and model routing summaries",
+	"#   debug  - info logs plus Copilot upstream timings, token refresh scheduling,",
+	"#            and upstream error request summaries",
+	"#   trace  - debug logs plus full Claude request payloads and full upstream",
+	"#            Copilot request payloads without redaction",
+	`logLevel: ${config.logLevel}`,
+	"",
+	"# Number of days to keep files in ~/.copilot-relay/logs.",
+	`logRetentionDays: ${config.logRetentionDays}`,
+	"",
+	"# Default upstream thinking/reasoning effort: none, low, medium, high, xhigh.",
+	`thinkEffort: ${config.thinkEffort}`,
+	"",
+	"# Model routing: requests containing \"opus\" use opusModel; all others use gptModel.",
+	"",
+	"# Upstream Copilot model used for non-Opus requests.",
+	`gptModel: ${config.gptModel}`,
+	"",
+	"# Upstream Copilot model used for requests containing \"opus\".",
+	`opusModel: ${config.opusModel}`,
+	""
+].join("\n");
+async function readAppConfig() {
+	const raw = await readRawConfig();
+	const claudeSetup = normalizeBoolean(raw.claudeSetup);
+	const host = normalizeString(raw.host);
+	const logLevel = normalizeLogLevel(raw.logLevel);
+	const logRetentionDays$1 = normalizePositiveInteger(raw.logRetentionDays);
+	const port = normalizePort(raw.port);
+	const thinkEffort = normalizeThinkEffort(raw.thinkEffort);
+	const config = {
+		claudeSetup: claudeSetup ?? defaultConfig.claudeSetup,
+		copilotBaseUrl: normalizeString(raw.copilotBaseUrl) ?? defaultConfig.copilotBaseUrl,
+		gptModel: normalizeString(raw.gptModel) ?? defaultConfig.gptModel,
+		host: host ?? defaultConfig.host,
+		logLevel: logLevel ?? defaultConfig.logLevel,
+		logRetentionDays: logRetentionDays$1 ?? defaultConfig.logRetentionDays,
+		opusModel: normalizeString(raw.opusModel) ?? defaultConfig.opusModel,
+		port: port ?? defaultConfig.port,
+		thinkEffort: thinkEffort ?? defaultConfig.thinkEffort
+	};
+	await writeConfig(config);
+	return config;
+}
+const getConfigMtime = async () => {
+	try {
+		return (await fs.stat(paths.configPath)).mtimeMs;
+	} catch (error) {
+		if (error.code === "ENOENT") return 0;
+		throw error;
+	}
+};
+const watchAppConfig = (onReload) => {
+	let lastMtime = 0;
+	const timer = setInterval(async () => {
+		try {
+			const nextMtime = await getConfigMtime();
+			if (nextMtime === lastMtime) return;
+			lastMtime = nextMtime;
+			onReload(await readAppConfig());
+		} catch {}
+	}, 1e3);
+	if (typeof timer.unref === "function") timer.unref();
+	getConfigMtime().then((mtime) => {
+		lastMtime = mtime;
+	});
+	return timer;
+};
+
+//#endregion
+//#region src/lib/config.ts
+const vscodeVersion = "1.99.3";
+const readProxyConfig = (config) => ({
+	copilotBaseUrl: config.copilotBaseUrl,
+	copilotToken: void 0,
+	host: config.host,
+	port: config.port,
+	vsCodeVersion: vscodeVersion
+});
+
+//#endregion
+//#region src/auth.ts
+const auth = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Run GitHub device auth and cache credentials for copilot-relay."
+	},
+	async run() {
+		const config = readProxyConfig(await readAppConfig());
+		config.copilotToken = void 0;
+		const authSession = await setupProxyAuth(config, { force: true });
+		if (authSession.githubLogin) log.info(`Logged in as ${authSession.githubLogin}`);
+		log.success("copilot-relay auth completed");
+	}
+});
+
+//#endregion
+//#region src/lib/claude-settings.ts
+/**
+* Update `~/.claude/settings.json` so its env block points Claude Code at the
+* running proxy. Preserves all unrelated keys (model overrides, plugins,
+* marketplaces, etc.). Sets a dummy auth token only if none is present.
+*/
+async function applyClaudeConfig(input) {
+	const { configPath: configPath$1, baseUrl } = input;
+	let raw = "";
+	let created = false;
+	try {
+		raw = await fs.readFile(configPath$1, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") created = true;
+		else throw error;
+	}
+	let parsed = {};
+	if (raw.trim().length > 0) try {
+		parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) parsed = {};
+	} catch {
+		return {
+			configPath: configPath$1,
+			changed: false,
+			created: false
+		};
+	}
+	const env = typeof parsed.env === "object" && parsed.env !== null && !Array.isArray(parsed.env) ? { ...parsed.env } : {};
+	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
+	env.ANTHROPIC_BASE_URL = baseUrl;
+	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
+	const next = {
+		...parsed,
+		env
+	};
+	const serialized = `${JSON.stringify(next, null, 2)}\n`;
+	if (serialized === raw) return {
+		configPath: configPath$1,
+		changed: false,
+		created: false,
+		previousBaseUrl
+	};
+	await fs.mkdir(path.dirname(configPath$1), { recursive: true });
+	await fs.writeFile(configPath$1, serialized);
+	return {
+		configPath: configPath$1,
+		changed: true,
+		created,
+		previousBaseUrl
+	};
+}
+
+//#endregion
+//#region src/lib/defaults.ts
+const claudeConfigPath = path.join(os.homedir(), ".claude", "settings.json");
+
+//#endregion
+//#region src/copilot/client.ts
+const copilotVersion = "0.26.7";
+const editorPluginVersion = `copilot-chat/${copilotVersion}`;
+const userAgent = `GitHubCopilotChat/${copilotVersion}`;
+const apiVersion = "2025-04-01";
+const maxFetchAttempts = 2;
+const getCopilotProviderContext = (config) => ({
+	baseUrl: config.copilotBaseUrl,
+	token: config.copilotToken,
+	vsCodeVersion: config.vsCodeVersion
+});
+const shouldRetryResponse = (response) => response.status >= 500 && response.status <= 599;
+const buildHeaders = (provider, init, options) => {
+	const headers = new Headers(init.headers);
+	headers.set("authorization", `Bearer ${provider.token}`);
+	headers.set("copilot-integration-id", "vscode-chat");
+	headers.set("editor-version", `vscode/${provider.vsCodeVersion}`);
+	headers.set("editor-plugin-version", editorPluginVersion);
+	headers.set("user-agent", userAgent);
+	headers.set("openai-intent", "conversation-panel");
+	headers.set("x-github-api-version", apiVersion);
+	headers.set("x-request-id", randomUUID());
+	headers.set("x-vscode-user-agent-library-version", "electron-fetch");
+	if (options.vision) headers.set("copilot-vision-request", "true");
+	if (options.initiator) headers.set("x-initiator", options.initiator);
+	if (!headers.has("content-type") && init.body !== void 0) headers.set("content-type", "application/json");
+	if (!headers.has("accept")) headers.set("accept", "application/json");
+	return headers;
+};
+const fetchCopilot = async (provider, path$1, init, options = {}) => {
+	if (!provider.token) throw new ProxyNotImplementedError("Copilot token is not configured for copilot-relay.");
+	let lastError;
+	for (let attempt = 1; attempt <= maxFetchAttempts; attempt++) try {
+		const started = performance.now();
+		const response = await fetch(`${provider.baseUrl}${path$1}`, {
+			...init,
+			headers: buildHeaders(provider, init, options)
+		});
+		const ms = Math.round(performance.now() - started);
+		log.debug(`Copilot ${init.method ?? "GET"} ${path$1} -> ${response.status} ${ms}ms (attempt ${attempt})`);
+		if (!shouldRetryResponse(response) || attempt === maxFetchAttempts) return response;
+		log.warn(`Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts})`);
+	} catch (error) {
+		lastError = error;
+		if (attempt === maxFetchAttempts) throw error;
+		log.warn(`Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts})`, error);
+	}
+	throw lastError;
+};
+
+//#endregion
+//#region src/lib/upstream-diagnostics.ts
+const openaiToolNamePattern = /^[A-Za-z0-9_-]{1,64}$/;
+const toolSchemaSuspectKeys = new Set([
+	"$defs",
+	"allOf",
+	"definitions",
+	"dependentRequired",
+	"dependentSchemas",
+	"else",
+	"if",
+	"not",
+	"oneOf",
+	"patternProperties",
+	"then"
+]);
+const maxDiagnosticItems = 8;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getToolName = (tool) => {
+	if (!isRecord(tool)) return "";
+	const functionValue = tool.function;
+	if (isRecord(functionValue) && typeof functionValue.name === "string") return functionValue.name;
+	return typeof tool.name === "string" ? tool.name : "";
+};
+const getToolParameters = (tool) => {
+	if (!isRecord(tool)) return;
+	const functionValue = tool.function;
+	if (isRecord(functionValue) && "parameters" in functionValue) return functionValue.parameters;
+	return tool.parameters;
+};
+const collectSuspiciousSchemaKeys = (value, path$1 = "$", keys = []) => {
+	if (keys.length >= maxDiagnosticItems) return keys;
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) {
+			collectSuspiciousSchemaKeys(item, `${path$1}[${index}]`, keys);
+			if (keys.length >= maxDiagnosticItems) break;
+		}
+		return keys;
+	}
+	if (!isRecord(value)) return keys;
+	for (const [key, nestedValue] of Object.entries(value)) {
+		const nextPath = `${path$1}.${key}`;
+		if (toolSchemaSuspectKeys.has(key)) {
+			if (!keys.includes(nextPath)) keys.push(nextPath);
+			if (keys.length >= maxDiagnosticItems) break;
+		}
+		collectSuspiciousSchemaKeys(nestedValue, nextPath, keys);
+		if (keys.length >= maxDiagnosticItems) break;
+	}
+	return keys;
+};
+const summarizeToolsForDiagnostics = (tools) => {
+	if (!Array.isArray(tools) || tools.length === 0) return;
+	const invalidNames = tools.map((tool) => getToolName(tool)).filter((name) => !openaiToolNamePattern.test(name)).slice(0, maxDiagnosticItems);
+	const suspiciousSchemas = tools.flatMap((tool) => {
+		const name = getToolName(tool) || "<missing>";
+		const keys = collectSuspiciousSchemaKeys(getToolParameters(tool));
+		return keys.length > 0 ? [{
+			keys,
+			name
+		}] : [];
+	}).slice(0, maxDiagnosticItems);
+	return {
+		count: tools.length,
+		...invalidNames.length > 0 ? { invalidNames } : {},
+		...suspiciousSchemas.length > 0 ? { suspiciousSchemas } : {}
+	};
+};
+
+//#endregion
+//#region src/copilot/responses.ts
+const responsesOnlyModelPattern = /^(?:gpt-5\.5)(?:-|$)/i;
+function shouldUseResponsesApiForModel(model) {
+	return responsesOnlyModelPattern.test(model);
+}
+function buildResponsesRequestPayload(payload, reasoningEffort) {
+	return {
+		model: payload.model,
+		input: translateMessagesToResponsesInput(payload.messages),
+		stream: payload.stream,
+		max_output_tokens: payload.max_tokens,
+		temperature: payload.temperature,
+		top_p: payload.top_p,
+		user: sanitizeUserIdentifier(payload.user),
+		tools: translateTools(payload.tools),
+		tool_choice: translateToolChoice(payload.tool_choice),
+		reasoning: reasoningEffort ? { effort: reasoningEffort } : void 0,
+		text: payload.response_format?.type === "json_object" ? { format: { type: "json_object" } } : void 0
+	};
+}
+function translateResponsesToChatCompletion(response) {
+	const assistantMessages = response.output.filter((item) => item.type === "message");
+	const functionCalls = response.output.filter((item) => item.type === "function_call");
+	const content = assistantMessages.flatMap((item) => item.content).map((part) => part.text).join("");
+	const reasoningText = getResponsesReasoningText(response);
+	return {
+		id: response.id,
+		object: "chat.completion",
+		created: response.created_at,
+		model: response.model,
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: content || null,
+				...reasoningText && { reasoning_text: reasoningText },
+				...functionCalls.length > 0 && { tool_calls: functionCalls.map((toolCall) => ({
+					id: toolCall.call_id,
+					type: "function",
+					function: {
+						name: toolCall.name,
+						arguments: toolCall.arguments
+					}
+				})) }
+			},
+			logprobs: null,
+			finish_reason: getFinishReason(response, functionCalls.length > 0)
+		}],
+		usage: translateUsage(response.usage)
+	};
+}
+async function* translateResponsesStreamToChatCompletionStream(responseStream) {
+	const state = {
+		responseId: randomUUID(),
+		createdAt: Math.floor(Date.now() / 1e3),
+		model: "",
+		started: false,
+		reasoningTextSent: false,
+		outputTextByIndex: {},
+		toolArgumentsByIndex: {},
+		toolStartedByIndex: {}
+	};
+	for await (const rawEvent of responseStream) {
+		if (!rawEvent.data || rawEvent.data === "[DONE]") continue;
+		const event = JSON.parse(rawEvent.data);
+		if (event.response) {
+			state.responseId = event.response.id;
+			state.createdAt = event.response.created_at;
+			state.model = event.response.model;
+		}
+		if (event.type === "response.output_item.added") {
+			const chunk = handleOutputItemAdded(state, event);
+			if (chunk) yield chunk;
+			continue;
+		}
+		if (event.type === "response.output_item.done") {
+			for (const chunk of handleOutputItemDone(state, event)) yield chunk;
+			continue;
+		}
+		if (event.type === "response.reasoning_summary_text.delta") {
+			if (event.delta) {
+				yield createRoleChunk(state);
+				yield createChunk(state, { delta: { reasoning_text: event.delta } });
+				state.reasoningTextSent = true;
+			}
+			continue;
+		}
+		if (event.type === "response.output_text.delta") {
+			const outputIndex = event.output_index ?? 0;
+			state.outputTextByIndex[outputIndex] = `${state.outputTextByIndex[outputIndex] ?? ""}${event.delta ?? ""}`;
+			yield createRoleChunk(state);
+			yield createChunk(state, { delta: { content: event.delta } });
+			continue;
+		}
+		if (event.type === "response.output_text.done") {
+			const outputIndex = event.output_index ?? 0;
+			const content = getMissingSuffix(state.outputTextByIndex[outputIndex] ?? "", event.text);
+			if (content) {
+				state.outputTextByIndex[outputIndex] = `${state.outputTextByIndex[outputIndex] ?? ""}${content}`;
+				yield createRoleChunk(state);
+				yield createChunk(state, { delta: { content } });
+			}
+			continue;
+		}
+		if (event.type === "response.function_call_arguments.delta") {
+			if (event.output_index === void 0) continue;
+			state.toolArgumentsByIndex[event.output_index] = `${state.toolArgumentsByIndex[event.output_index] ?? ""}${event.delta ?? ""}`;
+			yield createRoleChunk(state);
+			yield createChunk(state, { delta: { tool_calls: [{
+				index: event.output_index,
+				type: "function",
+				function: { arguments: event.delta ?? "" }
+			}] } });
+			continue;
+		}
+		if (event.type === "response.function_call_arguments.done") {
+			if (event.output_index === void 0) continue;
+			const content = getMissingSuffix(state.toolArgumentsByIndex[event.output_index] ?? "", event.arguments);
+			if (content) {
+				state.toolArgumentsByIndex[event.output_index] = `${state.toolArgumentsByIndex[event.output_index] ?? ""}${content}`;
+				yield createRoleChunk(state);
+				yield createChunk(state, { delta: { tool_calls: [{
+					index: event.output_index,
+					type: "function",
+					function: { arguments: content }
+				}] } });
+			}
+			continue;
+		}
+		if (event.type === "response.completed") {
+			if (!event.response) continue;
+			const reasoningText = getResponsesReasoningText({
+				output: event.response.output ?? [],
+				reasoning: event.response.reasoning
+			});
+			if (reasoningText && !state.reasoningTextSent) {
+				yield createRoleChunk(state);
+				yield createChunk(state, { delta: { reasoning_text: reasoningText } });
+				state.reasoningTextSent = true;
+			}
+			yield createChunk({
+				...state,
+				responseId: event.response.id,
+				createdAt: event.response.created_at,
+				model: event.response.model
+			}, {
+				delta: {},
+				finishReason: getFinishReason({
+					output: event.response.output ?? [],
+					incomplete_details: event.response.incomplete_details
+				}, (event.response.output ?? []).some((item) => item.type === "function_call")),
+				usage: translateUsage(event.response.usage)
+			});
+			yield { data: "[DONE]" };
+			return;
+		}
+	}
+}
+function handleOutputItemAdded(state, event) {
+	if (event.item?.type === "message") return createRoleChunk(state);
+	if (event.item?.type === "reasoning") {
+		const reasoningText = getSummaryText(event.item.summary);
+		if (!reasoningText) return;
+		state.reasoningTextSent = true;
+		return createChunk(state, { delta: { reasoning_text: reasoningText } });
+	}
+	if (event.item?.type === "function_call" && event.output_index !== void 0) {
+		const initialArguments = event.item.arguments ?? "";
+		state.started = true;
+		state.toolStartedByIndex[event.output_index] = true;
+		state.toolArgumentsByIndex[event.output_index] = initialArguments;
+		return createChunk(state, { delta: {
+			role: "assistant",
+			tool_calls: [{
+				index: event.output_index,
+				id: event.item.call_id,
+				type: "function",
+				function: {
+					name: event.item.name,
+					arguments: initialArguments
+				}
+			}]
+		} });
+	}
+}
+function handleOutputItemDone(state, event) {
+	if (event.item?.type === "reasoning") {
+		const reasoningText = getSummaryText(event.item.summary);
+		if (!reasoningText || state.reasoningTextSent) return [];
+		state.reasoningTextSent = true;
+		return [createChunk(state, { delta: { reasoning_text: reasoningText } })];
+	}
+	if (event.item?.type === "message") {
+		const outputIndex = event.output_index ?? 0;
+		const fullText = getMessageOutputText(event.item.content);
+		const content = getMissingSuffix(state.outputTextByIndex[outputIndex] ?? "", fullText);
+		if (!content) return [];
+		state.outputTextByIndex[outputIndex] = `${state.outputTextByIndex[outputIndex] ?? ""}${content}`;
+		return [createRoleChunk(state), createChunk(state, { delta: { content } })];
+	}
+	if (event.item?.type === "function_call" && event.output_index !== void 0) {
+		const outputIndex = event.output_index;
+		const chunks = [];
+		if (!state.toolStartedByIndex[outputIndex]) {
+			const initialArguments = event.item.arguments ?? "";
+			state.started = true;
+			state.toolStartedByIndex[outputIndex] = true;
+			state.toolArgumentsByIndex[outputIndex] = initialArguments;
+			chunks.push(createChunk(state, { delta: {
+				role: "assistant",
+				tool_calls: [{
+					index: outputIndex,
+					id: event.item.call_id,
+					type: "function",
+					function: {
+						name: event.item.name,
+						arguments: initialArguments
+					}
+				}]
+			} }));
+			return chunks;
+		}
+		const content = getMissingSuffix(state.toolArgumentsByIndex[outputIndex] ?? "", event.item.arguments);
+		if (content) {
+			state.toolArgumentsByIndex[outputIndex] = `${state.toolArgumentsByIndex[outputIndex] ?? ""}${content}`;
+			chunks.push(createRoleChunk(state), createChunk(state, { delta: { tool_calls: [{
+				index: outputIndex,
+				type: "function",
+				function: { arguments: content }
+			}] } }));
+		}
+		return chunks;
+	}
+	return [];
+}
+function createRoleChunk(state) {
+	if (state.started) return { data: "" };
+	state.started = true;
+	return createChunk(state, { delta: { role: "assistant" } });
+}
+function createChunk(state, { delta, finishReason = null, usage }) {
+	return { data: JSON.stringify({
+		id: state.responseId,
+		object: "chat.completion.chunk",
+		created: state.createdAt,
+		model: state.model,
+		choices: [{
+			index: 0,
+			delta,
+			finish_reason: finishReason,
+			logprobs: null
+		}],
+		usage
+	}) };
+}
+function translateMessagesToResponsesInput(messages) {
+	const items = messages.flatMap((message) => translateMessage(message));
+	if (items.length === 1 && "role" in items[0] && items[0].role === "user" && typeof items[0].content === "string") return items[0].content;
+	return items;
+}
+function translateMessage(message) {
+	if (message.role === "tool") return [{
+		type: "function_call_output",
+		call_id: message.tool_call_id ?? "",
+		output: stringifyToolOutput(message.content)
+	}];
+	const translated = [];
+	if (hasContent(message.content)) translated.push({
+		role: message.role,
+		content: translateContent(message.content)
+	});
+	if (message.role === "assistant" && message.tool_calls) translated.push(...message.tool_calls.map((toolCall) => ({
+		type: "function_call",
+		call_id: toolCall.id,
+		name: toolCall.function.name,
+		arguments: toolCall.function.arguments
+	})));
+	return translated;
+}
+function hasContent(content) {
+	if (content === null) return false;
+	if (typeof content === "string") return content.length > 0;
+	return content.length > 0;
+}
+function translateContent(content) {
+	if (typeof content === "string") return content;
+	if (!content || content.length === 0) return "";
+	return content.map((part) => translateContentPart(part));
+}
+function translateContentPart(part) {
+	if (part.type === "text") return {
+		type: "input_text",
+		text: part.text
+	};
+	return {
+		type: "input_image",
+		image_url: part.image_url.url,
+		detail: part.image_url.detail ?? "auto"
+	};
+}
+function stringifyToolOutput(content) {
+	if (typeof content === "string") return content;
+	if (!content) return "";
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n") || JSON.stringify(content);
+}
+function translateTools(tools) {
+	if (!tools) return;
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.function.name,
+		description: tool.function.description,
+		parameters: tool.function.parameters
+	}));
+}
+function translateToolChoice(toolChoice) {
+	if (!toolChoice) return;
+	if (typeof toolChoice === "string") return toolChoice;
+	return {
+		type: "function",
+		name: toolChoice.function.name
+	};
+}
+function translateUsage(usage) {
+	if (!usage) 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 } }
+	};
+}
+function getMessageOutputText(content) {
+	return content?.filter((part) => part.type === "output_text").map((part) => part.text).join("") || void 0;
+}
+function getMissingSuffix(alreadySent, finalValue) {
+	if (!finalValue) return;
+	if (!alreadySent) return finalValue;
+	if (!finalValue.startsWith(alreadySent)) return;
+	return finalValue.slice(alreadySent.length) || void 0;
+}
+function getResponsesReasoningText(response) {
+	const parts = [getSummaryText(response.reasoning?.summary), ...response.output.filter((item) => item.type === "reasoning").map((item) => getSummaryText(item.summary))].filter((part) => Boolean(part));
+	return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function getSummaryText(summary) {
+	if (typeof summary === "string") return summary || void 0;
+	if (!Array.isArray(summary)) return;
+	return summary.map((part) => part.text).filter((part) => Boolean(part)).join("\n\n") || void 0;
+}
+function getFinishReason(response, hasFunctionCalls) {
+	if (hasFunctionCalls) return "tool_calls";
+	if (response.incomplete_details?.reason?.includes("max_output_tokens")) return "length";
+	return "stop";
+}
+
+//#endregion
+//#region src/copilot/chat.ts
+const usesMaxCompletionTokens = (modelId) => modelId.startsWith("gpt-5");
+const maxUserLength = 64;
+const sanitizeReasoningEffortForModel = (_modelId, reasoningEffort) => {
+	return reasoningEffort ?? void 0;
+};
+const getRequestedReasoningEffort = (payload) => {
+	return sanitizeReasoningEffortForModel(payload.model, runtimeState.thinkEffort ?? defaultReasoningEffort);
+};
+const sanitizeUserIdentifier = (user) => {
+	if (!user) return;
+	return user.slice(0, maxUserLength);
+};
+const summarizeRequestForDiagnostics = (payload) => ({
+	max_completion_tokens: payload.max_completion_tokens,
+	max_tokens: payload.max_tokens,
+	message_count: payload.messages.length,
+	output_config_effort: payload.output_config?.effort,
+	reasoning_effort: payload.reasoning_effort,
+	stream: payload.stream ?? void 0,
+	tool_choice: payload.tool_choice,
+	tools: summarizeToolsForDiagnostics(payload.tools)
+});
+const buildRequestPayload = (payload) => {
+	const requestedReasoningEffort = getRequestedReasoningEffort(payload);
+	if (!usesMaxCompletionTokens(payload.model) || payload.max_tokens === null || payload.max_tokens === void 0) return {
+		...payload,
+		reasoning_effort: requestedReasoningEffort,
+		user: sanitizeUserIdentifier(payload.user)
+	};
+	return {
+		...payload,
+		max_tokens: void 0,
+		max_completion_tokens: payload.max_tokens,
+		reasoning_effort: requestedReasoningEffort,
+		user: sanitizeUserIdentifier(payload.user)
+	};
+};
+const isAgentInitiator = (messages) => messages.some((msg) => msg.role === "assistant" || msg.role === "tool") ? "agent" : "user";
+const messagesIncludeImage = (messages) => messages.some((msg) => typeof msg.content !== "string" && msg.content?.some((part) => part.type === "image_url"));
+const createChatCompletions = async (config, payload, options = {}) => {
+	const client = options.client ?? "generic";
+	const requestedModel = options.requestedModel ?? payload.model;
+	const requestedThinkEffort = options.requestedThinkEffort ?? payload.reasoning_effort ?? "none";
+	const requestedThinking = options.requestedThinking ?? "none";
+	const upstreamModelId = routeModelId(payload.model);
+	const upstreamPayload = upstreamModelId === payload.model ? payload : {
+		...payload,
+		model: upstreamModelId
+	};
+	const provider = getCopilotProviderContext(config);
+	const enableVision = messagesIncludeImage(upstreamPayload.messages);
+	const initiator = isAgentInitiator(upstreamPayload.messages);
+	const requestPayload = buildRequestPayload(upstreamPayload);
+	log.info([
+		"Model request",
+		`client=${client}`,
+		`requested_model=${requestedModel}`,
+		`upstream_model=${upstreamPayload.model}`,
+		`requested_think_effort=${requestedThinkEffort}`,
+		`requested_thinking=${requestedThinking}`,
+		`effective_think_effort=${requestPayload.reasoning_effort ?? "none"}`
+	].join(" "));
+	log.trace("Full request payload", { payload: requestPayload });
+	if (shouldUseResponsesApiForModel(upstreamPayload.model)) return createResponses(provider, upstreamPayload, {
+		vision: enableVision,
+		initiator
+	});
+	const response = await fetchCopilot(provider, "/chat/completions", {
+		method: "POST",
+		headers: {
+			accept: upstreamPayload.stream ? "text/event-stream" : "application/json",
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(requestPayload)
+	}, {
+		vision: enableVision,
+		initiator
+	});
+	if (!response.ok) {
+		if (await shouldRetryWithResponses(response)) return createResponses(provider, upstreamPayload, {
+			vision: enableVision,
+			initiator
+		});
+		await logUpstreamError("Failed to create chat completions", response, {
+			model: payload.model,
+			request: requestPayload,
+			route: "/chat/completions"
+		});
+		throw new HTTPError("Failed to create chat completions", response);
+	}
+	if (upstreamPayload.stream) return events(response);
+	return await response.json();
+};
+async function createResponses(provider, payload, options) {
+	const reasoningEffort = getRequestedReasoningEffort(payload);
+	const response = await fetchCopilot(provider, "/responses", {
+		method: "POST",
+		headers: {
+			accept: payload.stream ? "text/event-stream" : "application/json",
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(buildResponsesRequestPayload(payload, reasoningEffort))
+	}, {
+		vision: options.vision,
+		initiator: options.initiator
+	});
+	if (!response.ok) {
+		await logUpstreamError("Failed to create responses", response, {
+			model: payload.model,
+			route: "/responses"
+		});
+		throw new HTTPError("Failed to create responses", response);
+	}
+	if (payload.stream) return translateResponsesStreamToChatCompletionStream(events(response));
+	return translateResponsesToChatCompletion(await response.json());
+}
+async function logUpstreamError(message, response, context) {
+	const errorBody = await response.clone().text().catch(() => "");
+	log.error(message, {
+		route: context.route,
+		model: context.model,
+		status: response.status,
+		statusText: response.statusText,
+		body: errorBody || void 0,
+		request: runtimeState.debug && context.request ? JSON.stringify(summarizeRequestForDiagnostics(context.request)) : void 0
+	});
+}
+async function shouldRetryWithResponses(response) {
+	try {
+		return (await response.clone().json()).error?.code === "unsupported_api_for_model";
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/lib/preflight.ts
+const getUpstreamModelIds = async (config) => {
+	const response = await fetchCopilot(getCopilotProviderContext(config), "/models", {
+		method: "GET",
+		headers: { accept: "application/json" }
+	});
+	if (!response.ok) throw new HTTPError("Failed to validate upstream models", response);
+	const payload = await response.json();
+	return new Set((payload.data ?? []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0));
+};
+const ensureRequiredModels = async (config) => {
+	const upstreamModels = await getUpstreamModelIds(config);
+	const requiredModels = getExposedModelIds();
+	const missingModels = requiredModels.filter((model) => !upstreamModels.has(model));
+	if (missingModels.length > 0) throw new Error(`Required Copilot model(s) unavailable upstream: ${missingModels.join(", ")}`);
+	log.info(`Upstream models available: ${requiredModels.join(", ")}`);
+};
+const createProbePayload = (model) => ({
+	model,
+	max_tokens: 16,
+	stream: false,
+	messages: [{
+		role: "user",
+		content: "Reply with OK only."
+	}]
+});
+const validateModelRequest = async (config, model, thinkEffort) => {
+	try {
+		const response = await createChatCompletions(config, createProbePayload(model), {
+			client: "generic",
+			requestedModel: model
+		});
+		if (typeof response !== "object" || response === null || !("choices" in response)) throw new Error(`Preflight request for ${model} unexpectedly streamed`);
+		log.info(`Preflight OK: model=${model} think_effort=${thinkEffort}`);
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			const text = await error.response.text().catch(() => "");
+			throw new Error(`Preflight failed for model=${model} think_effort=${thinkEffort}: ${error.response.status} ${error.response.statusText}${text ? ` ${text}` : ""}`);
+		}
+		throw error;
+	}
+};
+const validateUpstream = async (config, thinkEffort) => {
+	log.info("Running upstream preflight");
+	await ensureRequiredModels(config);
+	for (const model of getExposedModelIds()) await validateModelRequest(config, model, thinkEffort);
+};
+
+//#endregion
+//#region src/lib/version.ts
+const packageName = "copilot-relay";
+const readPackageVersion = () => {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		try {
+			const packageJsonPath = resolve(currentDir, "package.json");
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			if (packageJson.name === packageName && typeof packageJson.version === "string") return packageJson.version;
+		} catch {}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) return "unknown";
+		currentDir = parentDir;
+	}
+};
+const appVersion = readPackageVersion();
+
+//#endregion
+//#region src/claude/utils.ts
+function mapOpenAIStopReasonToClaude(finishReason) {
+	if (finishReason === null) return null;
+	return {
+		stop: "end_turn",
+		length: "max_tokens",
+		tool_calls: "tool_use",
+		content_filter: "end_turn"
+	}[finishReason];
+}
+
+//#endregion
+//#region src/claude/tool-names.ts
+const strictToolNameCharsPattern = /^[A-Za-z0-9_-]+$/;
+const dottedToolNameCharsPattern = /^[A-Za-z0-9_.-]+$/;
+const defaultToolNameMaxLength = 64;
+const extendedToolNameMaxLength = 128;
+const hashLength = 10;
+const getToolNameMapperOptionsForModel = (modelId) => {
+	if (modelId.trim().toLowerCase().replace(/\[1m\]$/, "-1m").replace(/[._]/g, "-").startsWith("gpt-")) return {
+		allowDots: false,
+		maxNameLength: extendedToolNameMaxLength
+	};
+	return {
+		allowDots: false,
+		maxNameLength: defaultToolNameMaxLength
+	};
+};
+const makeHash = (value) => createHash("sha1").update(value).digest("hex").slice(0, hashLength);
+const getAllowedNamePattern = (allowDots) => allowDots ? dottedToolNameCharsPattern : strictToolNameCharsPattern;
+const cleanToolName = (name, allowDots) => {
+	const invalidCharsPattern = allowDots ? /[^A-Za-z0-9_.-]/g : /[^A-Za-z0-9_-]/g;
+	return name.replace(invalidCharsPattern, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+};
+const isValidToolName = (name, maxNameLength, allowDots) => name.length > 0 && name.length <= maxNameLength && getAllowedNamePattern(allowDots).test(name);
+const makeValidToolName = (name, maxNameLength, allowDots) => {
+	if (isValidToolName(name, maxNameLength, allowDots)) return name;
+	const cleaned = cleanToolName(name, allowDots);
+	if (cleaned.length <= maxNameLength) return cleaned;
+	const hash = makeHash(name);
+	const prefixLength = maxNameLength - hash.length - 1;
+	return `${cleaned.slice(0, prefixLength)}_${hash}`;
+};
+const makeUniqueToolName = (name, used, maxNameLength, allowDots) => {
+	const candidate = makeValidToolName(name, maxNameLength, allowDots);
+	if (!used.has(candidate)) return candidate;
+	for (let index = 2;; index++) {
+		const suffix = `_${makeHash(`${name}:${index}`)}`;
+		const prefixLength = maxNameLength - suffix.length;
+		const next = `${cleanToolName(name, allowDots).slice(0, prefixLength)}${suffix}`;
+		if (!used.has(next)) return next;
+	}
+};
+const createClaudeToolNameMapper = (tools, options = {}) => {
+	const maxNameLength = options.maxNameLength ?? defaultToolNameMaxLength;
+	const allowDots = options.allowDots ?? false;
+	const claudeToOpenAI = /* @__PURE__ */ new Map();
+	const openAIToClaude = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	for (const tool of tools ?? []) {
+		if (claudeToOpenAI.has(tool.name)) continue;
+		const openAIName = makeUniqueToolName(tool.name, used, maxNameLength, allowDots);
+		used.add(openAIName);
+		claudeToOpenAI.set(tool.name, openAIName);
+		openAIToClaude.set(openAIName, tool.name);
+	}
+	return {
+		toClaude: (name) => openAIToClaude.get(name) ?? name,
+		toOpenAI: (name) => claudeToOpenAI.get(name) ?? makeValidToolName(name, maxNameLength, allowDots)
+	};
+};
+
+//#endregion
+//#region src/claude/translate.ts
+function translateModelName(model) {
+	return routeModelId(model);
+}
+function translateToOpenAI(payload, _settings, toolNameMapper) {
+	const model = translateModelName(payload.model);
+	const mapper = toolNameMapper ?? createClaudeToolNameMapper(payload.tools, { ...getToolNameMapperOptionsForModel(model) });
+	const tools = translateClaudeToolsToOpenAI(payload.tools, mapper);
+	return {
+		model,
+		messages: translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper),
+		max_tokens: payload.max_tokens,
+		stop: payload.stop_sequences,
+		stream: payload.stream,
+		temperature: payload.temperature,
+		top_p: payload.top_p,
+		reasoning_effort: runtimeState.thinkEffort ?? defaultReasoningEffort,
+		user: payload.metadata?.user_id,
+		tools,
+		tool_choice: tools && tools.length > 0 ? translateClaudeToolChoiceToOpenAI(payload.tool_choice, mapper) : void 0
+	};
+}
+function translateClaudeMessagesToOpenAI(claudeMessages, system, toolNameMapper) {
+	const systemMessages = handleSystemPrompt(system);
+	const otherMessages = claudeMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapper));
+	return [...systemMessages, ...otherMessages];
+}
+function handleSystemPrompt(system) {
+	if (!system) return [];
+	if (typeof system === "string") return [{
+		role: "system",
+		content: system
+	}];
+	return [{
+		role: "system",
+		content: system.map((block) => block.text).join("\n\n")
+	}];
+}
+function handleUserMessage(message) {
+	const newMessages = [];
+	if (Array.isArray(message.content)) {
+		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
+		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
+		for (const block of toolResultBlocks) newMessages.push({
+			role: "tool",
+			tool_call_id: block.tool_use_id,
+			content: mapContent(block.content)
+		});
+		if (otherBlocks.length > 0) newMessages.push({
+			role: "user",
+			content: mapContent(otherBlocks)
+		});
+	} else newMessages.push({
+		role: "user",
+		content: mapContent(message.content)
+	});
+	return newMessages;
+}
+function handleAssistantMessage(message, toolNameMapper) {
+	if (!Array.isArray(message.content)) return [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+	const textBlocks = message.content.filter((block) => block.type === "text");
+	const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+	const allTextContent = [...textBlocks.map((b) => b.text), ...thinkingBlocks.map((b) => b.thinking)].join("\n\n");
+	return toolUseBlocks.length > 0 ? [{
+		role: "assistant",
+		content: allTextContent || null,
+		tool_calls: toolUseBlocks.map((toolUse) => ({
+			id: toolUse.id,
+			type: "function",
+			function: {
+				name: toolNameMapper.toOpenAI(toolUse.name),
+				arguments: JSON.stringify(toolUse.input)
+			}
+		}))
+	}] : [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+}
+function mapContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
+	const contentParts = [];
+	for (const block of content) switch (block.type) {
+		case "text":
+			contentParts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "thinking":
+			contentParts.push({
+				type: "text",
+				text: block.thinking
+			});
+			break;
+		case "image":
+			contentParts.push({
+				type: "image_url",
+				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+			});
+			break;
+	}
+	return contentParts;
+}
+function translateClaudeToolsToOpenAI(claudeTools, toolNameMapper) {
+	if (!claudeTools || claudeTools.length === 0) return;
+	const tools = claudeTools.flatMap((tool) => {
+		if (!tool.input_schema) return [];
+		return [{
+			type: "function",
+			function: {
+				name: toolNameMapper.toOpenAI(tool.name),
+				description: tool.description,
+				parameters: tool.input_schema
+			}
+		}];
+	});
+	return tools.length > 0 ? tools : void 0;
+}
+function translateClaudeToolChoiceToOpenAI(claudeToolChoice, toolNameMapper) {
+	if (!claudeToolChoice) return;
+	switch (claudeToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (claudeToolChoice.name) return {
+				type: "function",
+				function: { name: toolNameMapper.toOpenAI(claudeToolChoice.name) }
+			};
+			return;
+		case "none": return "none";
+		default: return;
+	}
+}
+function translateToClaude(response, toolNameMapper = createClaudeToolNameMapper(void 0)) {
+	const allThinkingBlocks = [];
+	const allTextBlocks = [];
+	const allToolUseBlocks = [];
+	let stopReason = null;
+	stopReason = response.choices[0]?.finish_reason ?? stopReason;
+	for (const choice of response.choices) {
+		allThinkingBlocks.push(...getClaudeThinkingBlocks(choice.message.reasoning_text ?? choice.message.reasoning_content));
+		allTextBlocks.push(...getClaudeTextBlocks(choice.message.content));
+		allToolUseBlocks.push(...getClaudeToolUseBlocks(choice.message.tool_calls, toolNameMapper));
+		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
+	}
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [
+			...allThinkingBlocks,
+			...allTextBlocks,
+			...allToolUseBlocks
+		],
+		stop_reason: mapOpenAIStopReasonToClaude(stopReason),
+		stop_sequence: null,
+		usage: {
+			input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+			output_tokens: response.usage?.completion_tokens ?? 0,
+			...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens }
+		}
+	};
+}
+function getClaudeThinkingBlocks(reasoningContent) {
+	if (!reasoningContent) return [];
+	return [{
+		type: "thinking",
+		thinking: reasoningContent
+	}];
+}
+function getClaudeTextBlocks(messageContent) {
+	if (typeof messageContent === "string") return [{
+		type: "text",
+		text: messageContent
+	}];
+	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
+		type: "text",
+		text: part.text
+	}));
+	return [];
+}
+function getClaudeToolUseBlocks(toolCalls, toolNameMapper) {
+	if (!toolCalls) return [];
+	return toolCalls.map((toolCall) => ({
+		type: "tool_use",
+		id: toolCall.id,
+		name: toolNameMapper.toClaude(toolCall.function.name),
+		input: safeJsonParse(toolCall.function.arguments)
+	}));
+}
+function safeJsonParse(input) {
+	try {
+		return JSON.parse(input);
+	} catch {
+		return { raw: input };
+	}
+}
+
+//#endregion
+//#region src/claude/stream.ts
+function isToolBlockOpen(state) {
+	if (!state.contentBlockOpen) return false;
+	return Object.values(state.toolCalls).some((tc) => tc.claudeBlockIndex === state.contentBlockIndex);
+}
+const closeOpenContentBlock = (events$1, state) => {
+	if (!state.contentBlockOpen) return;
+	events$1.push({
+		type: "content_block_stop",
+		index: state.contentBlockIndex
+	});
+	state.contentBlockIndex++;
+	state.contentBlockOpen = false;
+	state.thinkingBlockOpen = false;
+};
+function translateChunkToClaudeEvents(chunk, state, toolNameMapper = createClaudeToolNameMapper(void 0)) {
+	const events$1 = [];
+	if (chunk.choices.length === 0) return events$1;
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	const reasoningContent = delta.reasoning_text ?? delta.reasoning_content;
+	if (!state.messageStartSent) {
+		events$1.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+					output_tokens: 0,
+					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+				}
+			}
+		});
+		state.messageStartSent = true;
+	}
+	if (reasoningContent) {
+		if (state.contentBlockOpen && !state.thinkingBlockOpen) closeOpenContentBlock(events$1, state);
+		if (!state.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			state.contentBlockOpen = true;
+			state.thinkingBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: reasoningContent
+			}
+		});
+	}
+	if (delta.content) {
+		if (state.thinkingBlockOpen || isToolBlockOpen(state)) closeOpenContentBlock(events$1, state);
+		if (!state.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state.contentBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: delta.content
+			}
+		});
+	}
+	if (delta.tool_calls) for (const toolCall of delta.tool_calls) {
+		if (toolCall.id && toolCall.function?.name) {
+			if (state.contentBlockOpen) closeOpenContentBlock(events$1, state);
+			const toolName = toolNameMapper.toClaude(toolCall.function.name);
+			const claudeBlockIndex = state.contentBlockIndex;
+			state.toolCalls[toolCall.index] = {
+				id: toolCall.id,
+				name: toolName,
+				claudeBlockIndex
+			};
+			events$1.push({
+				type: "content_block_start",
+				index: claudeBlockIndex,
+				content_block: {
+					type: "tool_use",
+					id: toolCall.id,
+					name: toolName,
+					input: {}
+				}
+			});
+			state.contentBlockOpen = true;
+		}
+		if (toolCall.function?.arguments) {
+			const toolCallInfo = state.toolCalls[toolCall.index];
+			if (toolCallInfo) events$1.push({
+				type: "content_block_delta",
+				index: toolCallInfo.claudeBlockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: toolCall.function.arguments
+				}
+			});
+		}
+	}
+	if (choice.finish_reason) {
+		if (state.contentBlockOpen) closeOpenContentBlock(events$1, state);
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToClaude(choice.finish_reason),
+				stop_sequence: null
+			},
+			usage: {
+				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+				output_tokens: chunk.usage?.completion_tokens ?? 0,
+				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+			}
+		}, { type: "message_stop" });
+	}
+	return events$1;
+}
+function translateErrorToClaudeErrorEvent() {
+	return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message: "An unexpected error occurred during streaming."
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const encodingMap = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
+const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+	}
+	tokens += constants.funcEnd;
+	return tokens;
+};
+const calculateContentPartsTokens = (contentParts, encoder) => {
+	let tokens = 0;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder.encode(part.text).length;
+	return tokens;
+};
+const calculateMessageTokens = (message, encoder, constants) => {
+	const tokensPerMessage = 3;
+	const tokensPerName = 1;
+	let tokens = tokensPerMessage;
+	for (const [key, value] of Object.entries(message)) {
+		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (key === "name") tokens += tokensPerName;
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+	}
+	return tokens;
+};
+const calculateTokens = (messages, encoder, constants) => {
+	if (messages.length === 0) return 0;
+	let numTokens = 0;
+	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
+	numTokens += 3;
+	return numTokens;
+};
+const getEncodeChatFunction = async (encoding) => {
+	if (encodingCache.has(encoding)) {
+		const cached = encodingCache.get(encoding);
+		if (cached) return cached;
+	}
+	const supported = encoding;
+	if (!(supported in encodingMap)) {
+		const fallback = await encodingMap.o200k_base();
+		encodingCache.set(encoding, fallback);
+		return fallback;
+	}
+	const mod = await encodingMap[supported]();
+	encodingCache.set(encoding, mod);
+	return mod;
+};
+const getTokenizerFromModel = (model) => model.capabilities.tokenizer || "o200k_base";
+const getModelConstants = (model) => model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
+	funcInit: 10,
+	propInit: 3,
+	propKey: 3,
+	enumInit: -3,
+	enumItem: 3,
+	funcEnd: 12
+} : {
+	funcInit: 7,
+	propInit: 3,
+	propKey: 3,
+	enumInit: -3,
+	enumItem: 3,
+	funcEnd: 12
+};
+const calculateParameterTokens = (key, prop, context) => {
+	const { encoder, constants } = context;
+	let tokens = constants.propKey;
+	if (typeof prop !== "object" || prop === null) return tokens;
+	const param = prop;
+	const paramName = key;
+	const paramType = param.type || "string";
+	let paramDesc = param.description || "";
+	if (param.enum && Array.isArray(param.enum)) {
+		tokens += constants.enumInit;
+		for (const item of param.enum) {
+			tokens += constants.enumItem;
+			tokens += encoder.encode(String(item)).length;
+		}
+	}
+	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
+	const line = `${paramName}:${paramType}:${paramDesc}`;
+	tokens += encoder.encode(line).length;
+	const excludedKeys = new Set([
+		"type",
+		"description",
+		"enum"
+	]);
+	for (const propertyName of Object.keys(param)) {
+		if (excludedKeys.has(propertyName)) continue;
+		const propertyValue = param[propertyName];
+		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+	}
+	return tokens;
+};
+const calculateParametersTokens = (parameters, encoder, constants) => {
+	if (!parameters || typeof parameters !== "object") return 0;
+	const params = parameters;
+	let tokens = 0;
+	for (const [key, value] of Object.entries(params)) if (key === "properties") {
+		const properties = value;
+		if (Object.keys(properties).length > 0) {
+			tokens += constants.propInit;
+			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
+				encoder,
+				constants
+			});
+		}
+	} else {
+		const paramText = typeof value === "string" ? value : JSON.stringify(value);
+		tokens += encoder.encode(`${key}:${paramText}`).length;
+	}
+	return tokens;
+};
+const calculateToolTokens = (tool, encoder, constants) => {
+	let tokens = constants.funcInit;
+	const func = tool.function;
+	const fName = func.name;
+	let fDesc = func.description || "";
+	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
+	tokens += encoder.encode(`${fName}:${fDesc}`).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	return tokens;
+};
+const numTokensForTools = (tools, encoder, constants) => {
+	let funcTokenCount = 0;
+	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	funcTokenCount += constants.funcEnd;
+	return funcTokenCount;
+};
+const getTokenCount = async (payload, model) => {
+	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
+	const inputMessages = payload.messages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = payload.messages.filter((msg) => msg.role === "assistant");
+	const constants = getModelConstants(model);
+	let inputTokens = calculateTokens(inputMessages, encoder, constants);
+	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
+	const outputTokens = calculateTokens(outputMessages, encoder, constants);
+	return {
+		input: inputTokens,
+		output: outputTokens
+	};
+};
+
+//#endregion
+//#region src/routes/claude.ts
+const claudeRoutes = new Hono();
+const createTokenCountModel = (modelId) => ({
+	capabilities: { tokenizer: "o200k_base" },
+	id: modelId
+});
+const isNonStreamingResponse = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
+const getClaudeRequestedThinkEffort = (payload) => payload.reasoning_effort ?? "none";
+const getClaudeRequestedThinking = (payload) => {
+	if (!payload.thinking) return "none";
+	return [`type:${payload.thinking.type}`, `budget:${payload.thinking.budget_tokens ?? "none"}`].join(",");
+};
+const eventsFromClaudeResponse = (response) => {
+	const events$1 = [{
+		type: "message_start",
+		message: {
+			id: response.id,
+			type: response.type,
+			role: response.role,
+			content: [],
+			model: response.model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: response.usage
+		}
+	}];
+	response.content.forEach((block, index) => {
+		events$1.push({
+			type: "content_block_start",
+			index,
+			content_block: block
+		});
+		if (block.type === "text") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "text_delta",
+				text: block.text
+			}
+		});
+		else if (block.type === "thinking") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "thinking_delta",
+				thinking: block.thinking
+			}
+		});
+		else if (block.type === "tool_use") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "input_json_delta",
+				partial_json: JSON.stringify(block.input)
+			}
+		});
+		events$1.push({
+			type: "content_block_stop",
+			index
+		});
+	});
+	events$1.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: response.stop_reason,
+			stop_sequence: response.stop_sequence
+		},
+		usage: { output_tokens: response.usage.output_tokens }
+	});
+	events$1.push({ type: "message_stop" });
+	return events$1;
+};
+claudeRoutes.get("/models", (c) => c.json({
+	object: "list",
+	data: getExposedModelIds().map((id) => ({
+		id,
+		object: "model",
+		created: 0,
+		owned_by: "github-copilot"
+	}))
+}));
+claudeRoutes.post("/messages", async (c) => {
+	const config = c.get("config");
+	const claudePayload = await c.req.json();
+	log.trace("Full Claude request payload", { payload: claudePayload });
+	try {
+		const upstreamModel = translateModelName(claudePayload.model);
+		const toolNameMapper = createClaudeToolNameMapper(claudePayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
+		const response = await createChatCompletions(config, translateToOpenAI(claudePayload, void 0, toolNameMapper), {
+			client: "claude",
+			requestedModel: claudePayload.model,
+			requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
+			requestedThinking: getClaudeRequestedThinking(claudePayload)
+		});
+		if (isNonStreamingResponse(response)) {
+			const claudeResponse = translateToClaude(response, toolNameMapper);
+			if (!claudePayload.stream) return c.json(claudeResponse);
+			return streamSSE(c, async (stream) => {
+				for (const event of eventsFromClaudeResponse(claudeResponse)) await stream.writeSSE({
+					event: event.type,
+					data: JSON.stringify(event)
+				});
+			});
+		}
+		return streamSSE(c, async (stream) => {
+			const streamState = {
+				messageStartSent: false,
+				contentBlockIndex: 0,
+				contentBlockOpen: false,
+				thinkingBlockOpen: false,
+				toolCalls: {}
+			};
+			try {
+				for await (const rawEvent of response) {
+					if (rawEvent.data === "[DONE]") break;
+					if (!rawEvent.data) continue;
+					let chunk;
+					try {
+						chunk = JSON.parse(rawEvent.data);
+					} catch {
+						continue;
+					}
+					for (const event of translateChunkToClaudeEvents(chunk, streamState, toolNameMapper)) await stream.writeSSE({
+						event: event.type,
+						data: JSON.stringify(event)
+					});
+				}
+			} catch (error) {
+				log.error("Error during Claude stream translation:", error);
+				const errorEvent = translateErrorToClaudeErrorEvent();
+				await stream.writeSSE({
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
+				});
+			}
+		});
+	} catch (error) {
+		if (error instanceof ProxyNotImplementedError) return c.json({ error: {
+			type: error.name,
+			message: error.message
+		} }, 501);
+		if (error instanceof HTTPError) {
+			const text = await error.response.text().catch(() => "");
+			return new Response(text, {
+				status: error.response.status,
+				headers: { "content-type": error.response.headers.get("content-type") ?? "application/json" }
+			});
+		}
+		throw error;
+	}
+});
+claudeRoutes.post("/messages/count_tokens", async (c) => {
+	try {
+		const claudeBeta = c.req.header("claude-beta");
+		const claudePayload = await c.req.json();
+		const openAIPayload = translateToOpenAI(claudePayload);
+		const exposedModels = getExposedModelIds();
+		const selectedModel = createTokenCountModel(openAIPayload.model === exposedModels[1] ? exposedModels[1] : exposedModels[0]);
+		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+		const effectiveModelId = selectedModel.id;
+		if (claudePayload.tools && claudePayload.tools.length > 0) {
+			let mcpToolExist = false;
+			if (claudeBeta?.startsWith("claude-code")) mcpToolExist = claudePayload.tools.some((tool) => tool.name.startsWith("mcp__"));
+			if (!mcpToolExist && effectiveModelId.startsWith("claude")) tokenCount.input += 346;
+		}
+		const multiplier = effectiveModelId.startsWith("claude") ? 1.15 : 1;
+		const finalTokenCount = Math.round((tokenCount.input + tokenCount.output) * multiplier);
+		return c.json({ input_tokens: Math.max(1, finalTokenCount) });
+	} catch (error) {
+		log.error("Error counting tokens:", error);
+		return c.json({ input_tokens: 1 });
+	}
+});
+
+//#endregion
+//#region src/server.ts
+const createServer = (config) => {
+	const app = new Hono();
+	app.use("*", cors());
+	app.use("*", async (c, next) => {
+		c.set("config", config);
+		const started = performance.now();
+		try {
+			await next();
+		} finally {
+			const ms = Math.round(performance.now() - started);
+			log.info(`${c.req.method} ${c.req.path} -> ${c.res.status} ${ms}ms`);
+		}
+	});
+	app.onError((error, c) => {
+		log.error(`${c.req.method} ${c.req.path} failed`, error);
+		return c.json({ error: { message: "Internal server error" } }, 500);
+	});
+	app.get("/", (c) => c.json({
+		name: "copilot-relay",
+		status: "ok"
+	}));
+	app.get("/healthz", (c) => c.json({ ok: true }));
+	app.route("/v1", claudeRoutes);
+	return app;
+};
+const startServer = (config) => serve({
+	fetch: createServer(config).fetch,
+	hostname: config.host,
+	port: config.port
+});
+
+//#endregion
+//#region src/start.ts
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the copilot-relay HTTP server."
+	},
+	async run() {
+		const appConfig = await readAppConfig();
+		setLogLevel(appConfig.logLevel);
+		await cleanupLogs(appConfig.logRetentionDays);
+		const claudeConfigPath$1 = claudeConfigPath;
+		const config = readProxyConfig(appConfig);
+		const applyRuntimeConfig = (nextConfig) => {
+			setLogLevel(nextConfig.logLevel);
+			cleanupLogs(nextConfig.logRetentionDays);
+			runtimeState.debug = nextConfig.logLevel === "debug" || nextConfig.logLevel === "trace";
+			runtimeState.thinkEffort = nextConfig.thinkEffort;
+			config.copilotBaseUrl = nextConfig.copilotBaseUrl;
+			config.host = nextConfig.host;
+			config.port = nextConfig.port;
+			runtimeState.modelRouting = {
+				gptModel: nextConfig.gptModel,
+				opusModel: nextConfig.opusModel
+			};
+		};
+		applyRuntimeConfig(appConfig);
+		if (runtimeState.debug) log.info("Debug diagnostics enabled; upstream errors include request summaries");
+		log.info(`Log level: ${appConfig.logLevel}`);
+		log.info(`Think effort: ${appConfig.thinkEffort}`);
+		log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
+		const authSession = await setupProxyAuth(config);
+		try {
+			await validateUpstream(config, appConfig.thinkEffort);
+		} catch (error) {
+			log.error("Startup preflight failed:", error);
+			process.exit(1);
+		}
+		const server = startServer(config);
+		log.info(`copilot-relay version: ${appVersion}`);
+		if (authSession.githubLogin) log.info(`GitHub user: ${authSession.githubLogin}`);
+		else log.warn("GitHub user: unavailable");
+		log.success(`copilot-relay listening on http://${config.host}:${config.port}`);
+		log.debug(`copilot base url: ${config.copilotBaseUrl}`);
+		const baseUrl = `http://${config.host}:${config.port}`;
+		if (appConfig.claudeSetup) try {
+			const claudeResult = await applyClaudeConfig({
+				baseUrl,
+				configPath: claudeConfigPath$1
+			});
+			if (claudeResult.changed) {
+				log.success(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
+				if (claudeResult.previousBaseUrl && claudeResult.previousBaseUrl !== baseUrl) log.info(`ANTHROPIC_BASE_URL: ${claudeResult.previousBaseUrl} → ${baseUrl}`);
+			} else log.info(`claude settings already up to date: ${claudeResult.configPath}`);
+		} catch (error) {
+			log.warn(`Could not update claude settings (${claudeConfigPath$1}):`, error);
+		}
+		watchAppConfig((nextConfig) => {
+			applyRuntimeConfig(nextConfig);
+			log.info(`Config reloaded: logLevel=${nextConfig.logLevel} thinkEffort=${nextConfig.thinkEffort}`);
+		});
+		await new Promise((resolve$1, reject) => {
+			server.on("close", resolve$1);
+			server.on("error", reject);
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+await runMain(defineCommand({
+	meta: {
+		name: "copilot-relay",
+		description: "Yet, just another relay for Claude Code to use a GitHub Copilot subscription."
+	},
+	subCommands: {
+		auth,
+		start
+	}
+}));
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map