betahi-copilot-bridge 0.1.0

package/dist/main.js

@@ -0,0 +1,2552 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import consola from "consola";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
+
+//#region src/lib/error.ts
+var BridgeNotImplementedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BridgeNotImplementedError";
+	}
+};
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.name = "HTTPError";
+		this.response = response;
+	}
+};
+
+//#endregion
+//#region src/lib/paths.ts
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-bridge");
+const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH
+};
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+}
+async function ensureFile(filePath) {
+	try {
+		await fs.access(filePath, fs.constants.W_OK);
+	} catch {
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/lib/state.ts
+const runtimeState = {};
+
+//#endregion
+//#region src/providers/copilot/client.ts
+const COPILOT_VERSION$2 = "0.26.7";
+const EDITOR_PLUGIN_VERSION$2 = `copilot-chat/${COPILOT_VERSION$2}`;
+const USER_AGENT$2 = `GitHubCopilotChat/${COPILOT_VERSION$2}`;
+const API_VERSION = "2025-04-01";
+const getCopilotProviderContext = (config) => ({
+	baseUrl: config.copilotBaseUrl,
+	token: config.copilotToken,
+	vsCodeVersion: config.vsCodeVersion
+});
+const fetchCopilot = async (provider, path$1, init, options = {}) => {
+	if (!provider.token) throw new BridgeNotImplementedError("COPILOT_TOKEN is not configured for copilot-bridge.");
+	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", EDITOR_PLUGIN_VERSION$2);
+	headers.set("user-agent", USER_AGENT$2);
+	headers.set("openai-intent", "conversation-panel");
+	headers.set("x-github-api-version", API_VERSION);
+	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 fetch(`${provider.baseUrl}${path$1}`, {
+		...init,
+		headers
+	});
+};
+
+//#endregion
+//#region src/providers/copilot/get-models.ts
+const getModels = async (config) => {
+	const response = await fetchCopilot(getCopilotProviderContext(config), "/models", {
+		method: "GET",
+		headers: { accept: "application/json" }
+	});
+	if (!response.ok) throw new HTTPError("Failed to get models", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/lib/auth.ts
+const COPILOT_VERSION$1 = "0.26.7";
+const EDITOR_PLUGIN_VERSION$1 = `copilot-chat/${COPILOT_VERSION$1}`;
+const USER_AGENT$1 = `GitHubCopilotChat/${COPILOT_VERSION$1}`;
+const GITHUB_API_VERSION$1 = "2022-11-28";
+const GITHUB_API_BASE_URL$1 = "https://api.github.com";
+const GITHUB_BASE_URL = "https://github.com";
+const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const standardHeaders = () => ({
+	accept: "application/json",
+	"content-type": "application/json"
+});
+const sleep$1 = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const readGitHubToken$1 = async () => {
+	return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim();
+};
+const writeGitHubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, `${token.trim()}\n`, { mode: 384 });
+const githubHeaders = (githubToken, vsCodeVersion) => ({
+	...standardHeaders(),
+	authorization: `token ${githubToken}`,
+	"editor-plugin-version": EDITOR_PLUGIN_VERSION$1,
+	"editor-version": `vscode/${vsCodeVersion}`,
+	"user-agent": USER_AGENT$1,
+	"x-github-api-version": GITHUB_API_VERSION$1,
+	"x-vscode-user-agent-library-version": "electron-fetch"
+});
+const getDeviceCode = async () => {
+	const response = await fetch(`${GITHUB_BASE_URL}/login/device/code`, {
+		method: "POST",
+		headers: standardHeaders(),
+		body: JSON.stringify({
+			client_id: GITHUB_CLIENT_ID,
+			scope: GITHUB_APP_SCOPES
+		})
+	});
+	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(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
+			method: "POST",
+			headers: standardHeaders(),
+			body: JSON.stringify({
+				client_id: GITHUB_CLIENT_ID,
+				device_code: deviceCode.device_code,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		if (!response.ok) {
+			await sleep$1(sleepDuration);
+			continue;
+		}
+		const json = await response.json();
+		if (json.access_token) return json.access_token;
+		await sleep$1(sleepDuration);
+	}
+};
+const getGitHubUser = async (githubToken, vsCodeVersion) => {
+	const response = await fetch(`${GITHUB_API_BASE_URL$1}/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(`${GITHUB_API_BASE_URL$1}/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 ensureGitHubToken = async (config, options = {}) => {
+	await ensurePaths();
+	const existingToken = options.force ? "" : await readGitHubToken$1();
+	if (existingToken) return existingToken;
+	const deviceCode = await getDeviceCode();
+	consola.info(`Open ${deviceCode.verification_uri} and enter code ${deviceCode.user_code}`);
+	const githubToken = await pollAccessToken(deviceCode);
+	await writeGitHubToken(githubToken);
+	if (options.showToken) consola.info("GitHub token:", githubToken);
+	const user = await getGitHubUser(githubToken, config.vsCodeVersion);
+	consola.success(`Logged in as ${user.login}`);
+	return githubToken;
+};
+const setupBridgeAuth = async (config, options = {}) => {
+	if (config.copilotToken) {
+		if (options.showToken) consola.info("Using COPILOT_TOKEN from environment");
+		await loadModels(config);
+		return;
+	}
+	const githubToken = await ensureGitHubToken(config, options);
+	const applyCopilotToken = async () => {
+		const { refresh_in, token } = await getCopilotToken(githubToken, config.vsCodeVersion);
+		config.copilotToken = token;
+		if (options.showToken) consola.info("Copilot token:", token);
+		return refresh_in;
+	};
+	const refreshIn = await applyCopilotToken();
+	const refreshInterval = Math.max(refreshIn - 60, 60) * 1e3;
+	setInterval(async () => {
+		try {
+			await applyCopilotToken();
+			consola.debug("Refreshed Copilot token");
+		} catch (error) {
+			consola.error("Failed to refresh Copilot token:", error);
+		}
+	}, refreshInterval);
+	await loadModels(config);
+};
+const loadModels = async (config) => {
+	try {
+		runtimeState.models = await getModels(config);
+		consola.success(`Loaded ${runtimeState.models.data.length} Copilot models`);
+	} catch (error) {
+		consola.warn("Failed to load Copilot models:", error);
+	}
+};
+
+//#endregion
+//#region src/lib/config.ts
+const accountTypeSchema = z.enum([
+	"individual",
+	"business",
+	"enterprise"
+]);
+const inputSchema = z.object({
+	host: z.string().min(1),
+	port: z.number().int().min(1).max(65535)
+});
+const readBridgeConfig = (input) => {
+	const parsedInput = inputSchema.parse(input);
+	const accountType = accountTypeSchema.parse(process.env.COPILOT_ACCOUNT_TYPE ?? "individual");
+	const copilotBaseUrl = process.env.COPILOT_BASE_URL ?? (accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${accountType}.githubcopilot.com`);
+	return {
+		host: parsedInput.host,
+		port: parsedInput.port,
+		accountType,
+		copilotBaseUrl,
+		copilotToken: process.env.COPILOT_TOKEN,
+		vsCodeVersion: process.env.COPILOT_VSCODE_VERSION ?? "1.99.3"
+	};
+};
+
+//#endregion
+//#region src/auth.ts
+const auth = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Run GitHub device auth and cache credentials for copilot-bridge."
+	},
+	args: {
+		host: {
+			type: "string",
+			default: "127.0.0.1",
+			description: "Host used for config initialization."
+		},
+		port: {
+			type: "string",
+			default: "4142",
+			description: "Port used for config initialization."
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Print GitHub and Copilot tokens during auth."
+		}
+	},
+	async run({ args }) {
+		const config = readBridgeConfig({
+			host: String(args.host),
+			port: Number(args.port)
+		});
+		config.copilotToken = void 0;
+		await setupBridgeAuth(config, {
+			force: true,
+			showToken: args["show-token"]
+		});
+		consola.success("copilot-bridge auth completed");
+	}
+});
+
+//#endregion
+//#region src/lib/codex-config.ts
+const BEGIN_MARK = "# >>> copilot-bridge managed block — auto-generated, do not edit between markers >>>";
+const END_MARK = "# <<< copilot-bridge managed block — edits outside this block are preserved <<<";
+const LEGACY_BEGIN_MARK = "# >>> copilot-bridge managed (do not edit) >>>";
+const LEGACY_END_MARK = "# <<< copilot-bridge managed (do not edit) <<<";
+function tomlEscape(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function buildManagedBlock(input) {
+	const { baseUrl, settings } = input;
+	const lines = [];
+	lines.push(BEGIN_MARK);
+	if (settings.setAsDefault) lines.push(`model_provider = "${tomlEscape(settings.providerId)}"`);
+	lines.push("");
+	lines.push(`[model_providers.${settings.providerId}]`);
+	lines.push(`name = "${tomlEscape(settings.providerName)}"`);
+	lines.push(`base_url = "${tomlEscape(baseUrl)}"`);
+	lines.push(`wire_api = "responses"`);
+	lines.push(`prefer_websockets = false`);
+	lines.push(`requires_openai_auth = false`);
+	lines.push(END_MARK);
+	return lines.join("\n");
+}
+function stripManagedBlock(content) {
+	let next = content;
+	for (const [begin, end] of [[BEGIN_MARK, END_MARK], [LEGACY_BEGIN_MARK, LEGACY_END_MARK]]) while (true) {
+		const beginIdx = next.indexOf(begin);
+		if (beginIdx === -1) break;
+		const endIdx = next.indexOf(end, beginIdx);
+		if (endIdx === -1) break;
+		const before = next.slice(0, beginIdx).replace(/\n*$/, "");
+		const after = next.slice(endIdx + end.length).replace(/^\n+/, "");
+		if (before.length === 0) next = after;
+		else if (after.length === 0) next = `${before}\n`;
+		else next = `${before}\n\n${after}`;
+	}
+	return next;
+}
+function splitTopSection(content) {
+	const lines = content.split("\n");
+	let cut = lines.length;
+	for (let i = 0; i < lines.length; i++) if (/^\s*\[/.test(lines[i])) {
+		cut = i;
+		break;
+	}
+	return {
+		top: lines.slice(0, cut).join("\n"),
+		rest: lines.slice(cut).join("\n")
+	};
+}
+const scalarRegex = (key) => new RegExp(`^\\s*${key}\\s*=\\s*"((?:[^"\\\\]|\\\\.)*)"\\s*$`, "m");
+function readCodexUserConfig(content) {
+	const { top } = splitTopSection(stripManagedBlock(content));
+	const out = {};
+	const m = top.match(scalarRegex("model"));
+	if (m) out.model = m[1];
+	const e = top.match(scalarRegex("model_reasoning_effort"));
+	if (e) out.modelReasoningEffort = e[1];
+	return out;
+}
+function setTopScalar(topSection, key, value) {
+	const re = scalarRegex(key);
+	if (value === void 0) return topSection;
+	const line = `${key} = "${tomlEscape(value)}"`;
+	if (re.test(topSection)) return topSection.replace(re, line);
+	if (topSection.length === 0) return `${line}\n`;
+	return `${line}\n${topSection.startsWith("\n") ? "" : ""}${topSection}`;
+}
+function applyUserScalars(content, input) {
+	const { top, rest } = splitTopSection(content);
+	let nextTop = top;
+	nextTop = setTopScalar(nextTop, "model", input.model);
+	nextTop = setTopScalar(nextTop, "model_reasoning_effort", input.modelReasoningEffort);
+	if (nextTop === top) return content;
+	if (rest.length === 0) return nextTop.endsWith("\n") ? nextTop : `${nextTop}\n`;
+	const sep = nextTop.endsWith("\n") ? "" : "\n";
+	return `${nextTop}${sep}${rest}`;
+}
+async function applyCodexConfig(input) {
+	const { configPath } = input;
+	let existing = "";
+	let created = false;
+	try {
+		existing = await fs.readFile(configPath, "utf8");
+	} catch {
+		created = true;
+	}
+	let stripped = stripManagedBlock(existing);
+	stripped = applyUserScalars(stripped, input);
+	const block = buildManagedBlock(input);
+	const trimmed = stripped.replace(/\n+$/, "");
+	const next = trimmed.length === 0 ? `${block}\n` : `${trimmed}\n\n${block}\n`;
+	if (next === existing) return {
+		configPath,
+		changed: false,
+		created: false
+	};
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await fs.writeFile(configPath, next);
+	return {
+		configPath,
+		changed: true,
+		created
+	};
+}
+async function readCodexUserConfigFromDisk(configPath) {
+	try {
+		return readCodexUserConfig(await fs.readFile(configPath, "utf8"));
+	} catch {
+		return {};
+	}
+}
+
+//#endregion
+//#region src/lib/model-capabilities.ts
+const MODEL_CAPABILITIES = [
+	{
+		id: "gpt-5.5",
+		reasoning: {
+			supported: [
+				"none",
+				"low",
+				"medium",
+				"high",
+				"xhigh"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5.4",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high",
+				"xhigh"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5.4-mini",
+		reasoning: {
+			supported: [
+				"none",
+				"low",
+				"medium"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5.3-codex",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high",
+				"xhigh"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5.2",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high",
+				"xhigh"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5.2-codex",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high",
+				"xhigh"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "gpt-5-mini",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "claude-opus-4.7",
+		fallback: "chat-completions",
+		reasoningField: "output_config.effort",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high",
+				"xhigh",
+				"max"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "claude-opus-4.6",
+		fallback: "chat-completions",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "claude-opus-4.6-1m",
+		fallback: "chat-completions",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "claude-opus-4.5",
+		fallback: "chat-completions"
+	},
+	{
+		id: "claude-sonnet-4.6",
+		fallback: "chat-completions",
+		reasoning: {
+			supported: [
+				"low",
+				"medium",
+				"high"
+			],
+			default: "medium"
+		}
+	},
+	{
+		id: "claude-sonnet-4.5",
+		fallback: "chat-completions"
+	},
+	{
+		id: "claude-sonnet-4",
+		fallback: "chat-completions"
+	},
+	{
+		id: "claude-haiku-4.5",
+		fallback: "chat-completions"
+	},
+	{
+		id: "gemini-3.1-pro-preview",
+		fallback: "chat-completions",
+		aliases: ["gemini-3.1-pro"]
+	},
+	{
+		id: "gemini-3-flash-preview",
+		fallback: "chat-completions",
+		aliases: ["gemini-3-flash"]
+	},
+	{
+		id: "gemini-2.5-pro",
+		fallback: "chat-completions"
+	},
+	{
+		id: "gpt-4.1",
+		fallback: "chat-completions"
+	},
+	{
+		id: "gpt-4o",
+		fallback: "chat-completions"
+	}
+];
+const CAPABILITY_BY_ID = new Map(MODEL_CAPABILITIES.flatMap((m) => {
+	const entries = [[m.id, m]];
+	for (const alias of m.aliases ?? []) entries.push([alias, m]);
+	return entries;
+}));
+const resolveModelId = (modelId) => CAPABILITY_BY_ID.get(modelId)?.id ?? modelId;
+const getModelCapability = (modelId) => CAPABILITY_BY_ID.get(modelId);
+const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+const clampReasoningEffort = (modelId, requested) => {
+	const capability = getModelCapability(modelId);
+	if (!capability?.reasoning) return void 0;
+	const { supported, default: defaultEffort } = capability.reasoning;
+	if (requested === void 0 || requested === null) return {
+		effort: defaultEffort,
+		changed: false
+	};
+	if (!isReasoningEffort(requested)) return {
+		effort: defaultEffort,
+		changed: true,
+		reason: "unsupported-effort"
+	};
+	if (supported.includes(requested)) return {
+		effort: requested,
+		changed: false
+	};
+	const order = [
+		"none",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	];
+	const reqIdx = order.indexOf(requested);
+	const supportedSorted = [...supported].sort((a, b) => order.indexOf(a) - order.indexOf(b));
+	const lowest = supportedSorted[0];
+	const highest = supportedSorted[supportedSorted.length - 1];
+	return {
+		effort: reqIdx > order.indexOf(highest) ? highest : reqIdx < order.indexOf(lowest) ? lowest : supportedSorted.find((e) => order.indexOf(e) >= reqIdx) ?? defaultEffort,
+		changed: true,
+		reason: "unsupported-effort"
+	};
+};
+
+//#endregion
+//#region src/lib/settings.ts
+const SETTINGS_DIR = path.join(os.homedir(), ".config", "copilot-bridge");
+const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");
+const DEFAULT_SETTINGS = {
+	host: "127.0.0.1",
+	port: 4142,
+	codex: {
+		enabled: true,
+		providerId: "bridge",
+		providerName: "Copilot Bridge",
+		setAsDefault: true,
+		configPath: path.join(os.homedir(), ".codex", "config.toml")
+	}
+};
+function deepMerge(base, override) {
+	if (typeof base !== "object" || base === null || Array.isArray(base) || typeof override !== "object" || override === null || Array.isArray(override)) return override ?? base;
+	const out = { ...base };
+	for (const [key, value] of Object.entries(override)) out[key] = deepMerge(base[key], value);
+	return out;
+}
+async function loadSettings() {
+	try {
+		const raw = await fs.readFile(SETTINGS_FILE, "utf8");
+		return deepMerge(DEFAULT_SETTINGS, JSON.parse(raw));
+	} catch {
+		return {
+			...DEFAULT_SETTINGS,
+			codex: { ...DEFAULT_SETTINGS.codex }
+		};
+	}
+}
+async function ensureSettingsFile() {
+	const settings = await loadSettings();
+	try {
+		await fs.access(SETTINGS_FILE);
+	} catch {
+		await fs.mkdir(SETTINGS_DIR, { recursive: true });
+		await fs.writeFile(SETTINGS_FILE, `${JSON.stringify(settings, null, 2)}\n`);
+	}
+	return settings;
+}
+
+//#endregion
+//#region src/lib/rate-limit.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* Enforces the configured rate limit window between mutating upstream calls.
+*
+* - Resolves silently if no rate limit is configured or enough time has passed.
+* - Throws a Response (HTTP 429) when the window has not elapsed and `wait` is
+*   disabled, so route handlers can `c.json` it directly.
+* - When `wait` is enabled, sleeps until the window elapses, then resolves.
+*/
+const checkRateLimit = async () => {
+	const { rateLimitSeconds, rateLimitWait } = runtimeState;
+	if (rateLimitSeconds === void 0) return;
+	const now = Date.now();
+	if (!runtimeState.lastRequestTimestamp) {
+		runtimeState.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsed = (now - runtimeState.lastRequestTimestamp) / 1e3;
+	if (elapsed > rateLimitSeconds) {
+		runtimeState.lastRequestTimestamp = now;
+		return;
+	}
+	const waitSeconds = Math.ceil(rateLimitSeconds - elapsed);
+	if (!rateLimitWait) {
+		consola.warn(`Rate limit exceeded. Need to wait ${waitSeconds} more seconds.`);
+		throw new RateLimitError(waitSeconds);
+	}
+	consola.warn(`Rate limit reached. Waiting ${waitSeconds}s before proceeding...`);
+	await sleep(waitSeconds * 1e3);
+	runtimeState.lastRequestTimestamp = Date.now();
+};
+var RateLimitError = class extends Error {
+	waitSeconds;
+	constructor(waitSeconds) {
+		super(`Rate limit exceeded. Try again in ${waitSeconds}s.`);
+		this.name = "RateLimitError";
+		this.waitSeconds = waitSeconds;
+	}
+};
+
+//#endregion
+//#region src/lib/claude-settings.ts
+const getClaudeSettingsPaths = () => {
+	const cwd = process.cwd();
+	const home = process.env.HOME ?? os.homedir();
+	return [
+		path.join(home, ".claude", "settings.json"),
+		path.join(cwd, ".claude", "settings.json"),
+		path.join(cwd, ".claude", "settings.local.json")
+	];
+};
+const readClaudeSettingsFile = async (filePath) => {
+	try {
+		const content = await fs.readFile(filePath, "utf8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		consola.warn(`Failed to read Claude settings from ${filePath}:`, error);
+		return;
+	}
+};
+const getClaudeSettingsEnv = async () => {
+	const merged = {};
+	for (const filePath of getClaudeSettingsPaths()) {
+		const settings = await readClaudeSettingsFile(filePath);
+		if (!settings?.env) continue;
+		for (const [key, value] of Object.entries(settings.env)) if (typeof value === "string") merged[key] = value;
+	}
+	return merged;
+};
+
+//#endregion
+//#region src/services/copilot/responses.ts
+const RESPONSES_ONLY_MODEL_PATTERN = /^(?:gpt-5\.3-codex|gpt-5\.4-mini)(?:-|$)/i;
+function shouldUseResponsesApiForModel(model) {
+	return RESPONSES_ONLY_MODEL_PATTERN.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("");
+	return {
+		id: response.id,
+		object: "chat.completion",
+		created: response.created_at,
+		model: response.model,
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: content || null,
+				...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
+	};
+	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_text.delta") {
+			yield createRoleChunk(state);
+			yield createChunk(state, { delta: { content: event.delta } });
+			continue;
+		}
+		if (event.type === "response.function_call_arguments.delta") {
+			if (event.output_index === void 0) continue;
+			yield createRoleChunk(state);
+			yield createChunk(state, { delta: { tool_calls: [{
+				index: event.output_index,
+				type: "function",
+				function: { arguments: event.delta ?? "" }
+			}] } });
+			continue;
+		}
+		if (event.type === "response.completed") {
+			if (!event.response) continue;
+			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 === "function_call" && event.output_index !== void 0) {
+		state.started = true;
+		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: event.item.arguments ?? ""
+				}
+			}]
+		} });
+	}
+}
+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 getFinishReason(response, hasFunctionCalls) {
+	if (hasFunctionCalls) return "tool_calls";
+	if (response.incomplete_details?.reason?.includes("max_output_tokens")) return "length";
+	return "stop";
+}
+
+//#endregion
+//#region src/services/copilot/create-chat-completions.ts
+const usesMaxCompletionTokens = (modelId) => modelId.startsWith("gpt-5");
+const isClaudeOpus47Model$1 = (modelId) => modelId === "claude-opus-4.7";
+const MAX_USER_LENGTH = 64;
+const defaultReasoningEffort = (modelId) => usesMaxCompletionTokens(modelId) ? "medium" : void 0;
+const getAllowedReasoningEfforts = (modelId) => {
+	if (modelId.startsWith("gpt-5.5")) return [
+		"none",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	];
+	if (modelId.startsWith("gpt-5.4-mini")) return [
+		"none",
+		"low",
+		"medium"
+	];
+	if (modelId.startsWith("gpt-5.4") || modelId.startsWith("gpt-5.3-codex")) return [
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	];
+	if (usesMaxCompletionTokens(modelId)) return [
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	];
+	return [];
+};
+const sanitizeReasoningEffortForModel = (modelId, reasoningEffort) => {
+	if (!reasoningEffort) return;
+	return getAllowedReasoningEfforts(modelId).includes(reasoningEffort) ? reasoningEffort : void 0;
+};
+const normalizeReasoningEffort$1 = (value) => {
+	switch (value?.toLowerCase()) {
+		case "none": return "none";
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
+		default: return;
+	}
+};
+const normalizeClaudeOpus47Effort = (value) => {
+	switch (value?.toLowerCase()) {
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
+		default: return;
+	}
+};
+const getRequestedReasoningEffort = (payload, claudeSettingsEnv) => {
+	const requestedReasoningEffort = payload.reasoning_effort ?? normalizeReasoningEffort$1(process.env.COPILOT_REASONING_EFFORT) ?? normalizeReasoningEffort$1(claudeSettingsEnv.COPILOT_REASONING_EFFORT);
+	return sanitizeReasoningEffortForModel(payload.model, requestedReasoningEffort) ?? defaultReasoningEffort(payload.model);
+};
+const getRequestedClaudeOpus47Effort = (payload, claudeSettingsEnv) => {
+	if (!isClaudeOpus47Model$1(payload.model)) return;
+	return payload.output_config?.effort ?? normalizeClaudeOpus47Effort(payload.reasoning_effort) ?? normalizeClaudeOpus47Effort(process.env.COPILOT_REASONING_EFFORT) ?? normalizeClaudeOpus47Effort(claudeSettingsEnv.COPILOT_REASONING_EFFORT);
+};
+const sanitizeUserIdentifier = (user) => {
+	if (!user) return;
+	return user.slice(0, MAX_USER_LENGTH);
+};
+const buildRequestPayload = (payload, claudeSettingsEnv) => {
+	const requestedReasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv);
+	const requestedClaudeOpus47Effort = getRequestedClaudeOpus47Effort(payload, claudeSettingsEnv);
+	const reasoningEffort = usesMaxCompletionTokens(payload.model) && payload.tools !== null && payload.tools !== void 0 && payload.tools.length > 0 ? void 0 : requestedReasoningEffort;
+	if (!usesMaxCompletionTokens(payload.model) || payload.max_tokens === null || payload.max_tokens === void 0) {
+		const sanitizedPayload = {
+			...payload,
+			output_config: requestedClaudeOpus47Effort ? {
+				...payload.output_config,
+				effort: requestedClaudeOpus47Effort
+			} : payload.output_config,
+			reasoning_effort: isClaudeOpus47Model$1(payload.model) ? void 0 : payload.reasoning_effort,
+			user: sanitizeUserIdentifier(payload.user)
+		};
+		return reasoningEffort === null || reasoningEffort === void 0 ? sanitizedPayload : {
+			...sanitizedPayload,
+			reasoning_effort: reasoningEffort
+		};
+	}
+	return {
+		...payload,
+		max_tokens: void 0,
+		max_completion_tokens: payload.max_tokens,
+		reasoning_effort: reasoningEffort,
+		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) => {
+	const provider = getCopilotProviderContext(config);
+	const enableVision = messagesIncludeImage(payload.messages);
+	const initiator = isAgentInitiator(payload.messages);
+	const claudeSettingsEnv = await getClaudeSettingsEnv();
+	const requestPayload = buildRequestPayload(payload, claudeSettingsEnv);
+	if (shouldUseResponsesApiForModel(payload.model)) return createResponses(provider, payload, claudeSettingsEnv, {
+		vision: enableVision,
+		initiator
+	});
+	const response = await fetchCopilot(provider, "/chat/completions", {
+		method: "POST",
+		headers: {
+			accept: payload.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, payload, claudeSettingsEnv, {
+			vision: enableVision,
+			initiator
+		});
+		consola.error("Failed to create chat completions", response);
+		throw new HTTPError("Failed to create chat completions", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+async function createResponses(provider, payload, claudeSettingsEnv, options) {
+	const reasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv);
+	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) {
+		consola.error("Failed to create responses", response);
+		throw new HTTPError("Failed to create responses", response);
+	}
+	if (payload.stream) return translateResponsesStreamToChatCompletionStream(events(response));
+	return translateResponsesToChatCompletion(await response.json());
+}
+async function shouldRetryWithResponses(response) {
+	try {
+		return (await response.clone().json()).error?.code === "unsupported_api_for_model";
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/routes/chat-completions.ts
+const chatCompletionRoutes = new Hono();
+const isNonStreaming = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
+chatCompletionRoutes.post("/", async (c) => {
+	try {
+		await checkRateLimit();
+		const payload = await c.req.json();
+		const response = await createChatCompletions(c.var.config, payload);
+		if (isNonStreaming(response)) return c.json(response);
+		return streamSSE(c, async (stream) => {
+			for await (const chunk of response) await stream.writeSSE(chunk);
+		});
+	} catch (error) {
+		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
+		if (error instanceof BridgeNotImplementedError) 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;
+	}
+});
+
+//#endregion
+//#region src/providers/copilot/create-embeddings.ts
+const createEmbeddings = async (config, payload) => {
+	const response = await fetchCopilot(getCopilotProviderContext(config), "/embeddings", {
+		method: "POST",
+		headers: {
+			accept: "application/json",
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/embeddings.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		await checkRateLimit();
+		const payload = await c.req.json();
+		const response = await createEmbeddings(c.var.config, payload);
+		return c.json(response);
+	} catch (error) {
+		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
+		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;
+	}
+});
+
+//#endregion
+//#region src/lib/models-resolver.ts
+const normalizeModelId = (modelId) => modelId.trim().toLowerCase().replaceAll(/[\s._-]+/g, "");
+const stripSnapshotSuffix = (modelId) => {
+	const id = modelId.trim().toLowerCase().replace(/\[1m\]$/, "");
+	if (id.startsWith("claude-sonnet-4-")) return "claude-sonnet-4";
+	if (/^claude-opus-4-7-\d{8}$/.test(id)) return "claude-opus-4.7";
+	if (id.startsWith("claude-opus-4-")) return "claude-opus-4";
+	return id;
+};
+const getAliasCandidates = (modelId) => {
+	const canonicalModelId = stripSnapshotSuffix(modelId);
+	const aliases = new Set([canonicalModelId]);
+	const familyMatch = canonicalModelId.match(/^[a-z]+(?:-[a-z]+)*-\d+(?:\.\d+)?/);
+	if (familyMatch) {
+		aliases.add(familyMatch[0]);
+		aliases.add(familyMatch[0].replace(/\.\d+$/, ""));
+	}
+	if (/^gpt-5(?:[.-]\d+)?$/i.test(canonicalModelId)) aliases.add("gpt-5");
+	return [...aliases];
+};
+const scoreModelCandidate = (model) => {
+	let score = 0;
+	if (model.model_picker_enabled) score += 20;
+	if (!model.preview) score += 10;
+	if (/mini|nano|fast|flash|haiku/i.test(model.id)) score -= 15;
+	return score - model.id.length / 1e3;
+};
+const pickBestModel = (models) => [...models].sort((left, right) => scoreModelCandidate(right) - scoreModelCandidate(left))[0];
+const getBestPrefixMatches = (models, aliasCandidates) => {
+	let bestMatchLength = 0;
+	const matches = [];
+	for (const model of models) {
+		const normalizedModelId = normalizeModelId(model.id);
+		const matchedAliasLength = Math.max(0, ...aliasCandidates.map((candidate) => {
+			const normalizedCandidate = normalizeModelId(candidate);
+			return normalizedCandidate.length >= 4 && normalizedModelId.startsWith(normalizedCandidate) ? normalizedCandidate.length : 0;
+		}));
+		if (matchedAliasLength === 0) continue;
+		if (matchedAliasLength > bestMatchLength) {
+			bestMatchLength = matchedAliasLength;
+			matches.length = 0;
+			matches.push(model);
+			continue;
+		}
+		if (matchedAliasLength === bestMatchLength) matches.push(model);
+	}
+	return matches;
+};
+const resolveModel = (requestedModelId, models = runtimeState.models?.data) => {
+	if (!models || models.length === 0) return;
+	const exactMatch = models.find((model) => model.id === requestedModelId);
+	if (exactMatch) return exactMatch;
+	const aliasCandidates = getAliasCandidates(requestedModelId);
+	const normalizedAliases = new Set(aliasCandidates.map((candidate) => normalizeModelId(candidate)));
+	const normalizedExactMatches = models.filter((model) => normalizedAliases.has(normalizeModelId(model.id)));
+	if (normalizedExactMatches.length > 0) return pickBestModel(normalizedExactMatches);
+	return pickBestModel(getBestPrefixMatches(models, aliasCandidates));
+};
+const resolveUpstreamModelId = (requestedModelId, models = runtimeState.models?.data) => resolveModel(requestedModelId, models)?.id ?? stripSnapshotSuffix(requestedModelId);
+
+//#endregion
+//#region src/bridges/claude/utils.ts
+function mapOpenAIStopReasonToAnthropic(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/bridges/claude/non-stream-translation.ts
+const normalizeClaudeModelAlias = (model) => {
+	const normalized = model.trim().toLowerCase().replace(/\[1m\]$/, "");
+	if (/^claude-(opus|sonnet|haiku)-\d-\d(?:-1m)?$/.test(normalized)) return normalized.replace(/^claude-(opus|sonnet|haiku)-(\d)-(\d)(-1m)?$/, "claude-$1-$2.$3$4");
+	if (/^claude-opus-4-7-\d{8}$/.test(normalized)) return "claude-opus-4.7";
+	return normalized;
+};
+function translateModelName(model) {
+	return resolveUpstreamModelId(normalizeClaudeModelAlias(model));
+}
+function isClaudeModel(modelId) {
+	return modelId.startsWith("claude-");
+}
+function isClaudeOpus47Model(modelId) {
+	return modelId === "claude-opus-4.7";
+}
+function normalizeClaudeEffort(value) {
+	switch (value?.toLowerCase()) {
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
+		default: return;
+	}
+}
+function getClaudeOpus47Effort(payload) {
+	const explicitEffort = normalizeClaudeEffort(payload.reasoning_effort);
+	if (explicitEffort) return explicitEffort;
+	if (payload.thinking?.type !== "enabled") return;
+	const budgetTokens = payload.thinking.budget_tokens;
+	if (budgetTokens === void 0) return "medium";
+	if (budgetTokens <= 2048) return "low";
+	if (budgetTokens <= 8192) return "medium";
+	if (budgetTokens <= 24576) return "high";
+	return "xhigh";
+}
+function translateThinking(payload) {
+	if (!isClaudeOpus47Model(translateModelName(payload.model))) return;
+	if (payload.thinking?.type === "adaptive") return { type: "adaptive" };
+	return payload.thinking?.type === "enabled" ? { type: "adaptive" } : void 0;
+}
+function translateOutputConfig(payload) {
+	if (!isClaudeOpus47Model(translateModelName(payload.model))) return;
+	const effort = getClaudeOpus47Effort(payload);
+	return effort ? { effort } : void 0;
+}
+function normalizeReasoningEffort(value) {
+	switch (value.toLowerCase()) {
+		case "none": return "none";
+		case "low": return "low";
+		case "medium": return "medium";
+		case "high": return "high";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
+		default: return;
+	}
+}
+function translateReasoningEffort(payload) {
+	const modelId = translateModelName(payload.model);
+	if (isClaudeModel(modelId)) return;
+	if (payload.reasoning_effort) return sanitizeReasoningEffortForModel(modelId, normalizeReasoningEffort(payload.reasoning_effort));
+	if (payload.thinking?.type !== "enabled") return;
+	const budgetTokens = payload.thinking.budget_tokens;
+	if (budgetTokens === void 0) return sanitizeReasoningEffortForModel(modelId, "medium");
+	if (budgetTokens <= 2048) return sanitizeReasoningEffortForModel(modelId, "low");
+	if (budgetTokens <= 8192) return sanitizeReasoningEffortForModel(modelId, "medium");
+	if (budgetTokens <= 24576) return sanitizeReasoningEffortForModel(modelId, "high");
+	return sanitizeReasoningEffortForModel(modelId, "xhigh");
+}
+function translateToOpenAI(payload) {
+	return {
+		model: translateModelName(payload.model),
+		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
+		max_tokens: payload.max_tokens,
+		stop: payload.stop_sequences,
+		stream: payload.stream,
+		temperature: payload.temperature,
+		top_p: payload.top_p,
+		thinking: translateThinking(payload),
+		output_config: translateOutputConfig(payload),
+		reasoning_effort: translateReasoningEffort(payload),
+		user: payload.metadata?.user_id,
+		tools: translateAnthropicToolsToOpenAI(payload.tools),
+		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice)
+	};
+}
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
+	const systemMessages = handleSystemPrompt(system);
+	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message));
+	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) {
+	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: 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 translateAnthropicToolsToOpenAI(anthropicTools) {
+	if (!anthropicTools) return;
+	return anthropicTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.input_schema
+		}
+	}));
+}
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+	if (!anthropicToolChoice) return;
+	switch (anthropicToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (anthropicToolChoice.name) return {
+				type: "function",
+				function: { name: anthropicToolChoice.name }
+			};
+			return;
+		case "none": return "none";
+		default: return;
+	}
+}
+function translateToAnthropic(response) {
+	const allTextBlocks = [];
+	const allToolUseBlocks = [];
+	let stopReason = null;
+	stopReason = response.choices[0]?.finish_reason ?? stopReason;
+	for (const choice of response.choices) {
+		allTextBlocks.push(...getAnthropicTextBlocks(choice.message.content));
+		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls));
+		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
+	}
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [...allTextBlocks, ...allToolUseBlocks],
+		stop_reason: mapOpenAIStopReasonToAnthropic(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 getAnthropicTextBlocks(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 getAnthropicToolUseBlocks(toolCalls) {
+	if (!toolCalls) return [];
+	return toolCalls.map((toolCall) => ({
+		type: "tool_use",
+		id: toolCall.id,
+		name: toolCall.function.name,
+		input: safeJsonParse(toolCall.function.arguments)
+	}));
+}
+function safeJsonParse(input) {
+	try {
+		return JSON.parse(input);
+	} catch {
+		return { raw: input };
+	}
+}
+
+//#endregion
+//#region src/bridges/claude/stream-translation.ts
+function isToolBlockOpen(state) {
+	if (!state.contentBlockOpen) return false;
+	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state) {
+	const events$1 = [];
+	if (chunk.choices.length === 0) return events$1;
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	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 (delta.content) {
+		if (isToolBlockOpen(state)) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state.contentBlockIndex
+			});
+			state.contentBlockIndex++;
+			state.contentBlockOpen = false;
+		}
+		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) {
+				events$1.push({
+					type: "content_block_stop",
+					index: state.contentBlockIndex
+				});
+				state.contentBlockIndex++;
+				state.contentBlockOpen = false;
+			}
+			const anthropicBlockIndex = state.contentBlockIndex;
+			state.toolCalls[toolCall.index] = {
+				id: toolCall.id,
+				name: toolCall.function.name,
+				anthropicBlockIndex
+			};
+			events$1.push({
+				type: "content_block_start",
+				index: anthropicBlockIndex,
+				content_block: {
+					type: "tool_use",
+					id: toolCall.id,
+					name: toolCall.function.name,
+					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.anthropicBlockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: toolCall.function.arguments
+				}
+			});
+		}
+	}
+	if (choice.finish_reason) {
+		if (state.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state.contentBlockIndex
+			});
+			state.contentBlockOpen = false;
+		}
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(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 translateErrorToAnthropicErrorEvent() {
+	return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message: "An unexpected error occurred during streaming."
+		}
+	};
+}
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	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 ENCODING_MAP)) {
+		const fallback = await ENCODING_MAP.o200k_base();
+		encodingCache.set(encoding, fallback);
+		return fallback;
+	}
+	const mod = await ENCODING_MAP[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/messages.ts
+const messageRoutes = new Hono();
+const isNonStreamingResponse = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
+messageRoutes.post("/", async (c) => {
+	const config = c.get("config");
+	try {
+		await checkRateLimit();
+	} catch (error) {
+		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
+		throw error;
+	}
+	const openAIPayload = translateToOpenAI(await c.req.json());
+	try {
+		const response = await createChatCompletions(config, openAIPayload);
+		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response));
+		return streamSSE(c, async (stream) => {
+			const streamState = {
+				messageStartSent: false,
+				contentBlockIndex: 0,
+				contentBlockOpen: 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;
+					}
+					const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
+					for (const event of events$1) await stream.writeSSE({
+						event: event.type,
+						data: JSON.stringify(event)
+					});
+				}
+			} catch (error) {
+				consola.error("Error during Anthropic stream translation:", error);
+				const errorEvent = translateErrorToAnthropicErrorEvent();
+				await stream.writeSSE({
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
+				});
+			}
+		});
+	} catch (error) {
+		if (error instanceof BridgeNotImplementedError) 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;
+	}
+});
+messageRoutes.post("/count_tokens", async (c) => {
+	try {
+		const anthropicBeta = c.req.header("anthropic-beta");
+		const anthropicPayload = await c.req.json();
+		const openAIPayload = translateToOpenAI(anthropicPayload);
+		const selectedModel = resolveModel(openAIPayload.model);
+		if (!selectedModel) {
+			consola.warn(`Model ${openAIPayload.model} not found in registry, returning fallback token count`);
+			return c.json({ input_tokens: 1 });
+		}
+		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+		const effectiveModelId = selectedModel.id;
+		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+			let mcpToolExist = false;
+			if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
+			if (!mcpToolExist) {
+				if (effectiveModelId.startsWith("claude")) tokenCount.input += 346;
+				else if (effectiveModelId.startsWith("grok")) tokenCount.input += 480;
+			}
+		}
+		let finalTokenCount = tokenCount.input + tokenCount.output;
+		if (effectiveModelId.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
+		else if (effectiveModelId.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * 1.03);
+		return c.json({ input_tokens: Math.max(1, finalTokenCount) });
+	} catch (error) {
+		consola.error("Error counting tokens:", error);
+		return c.json({ input_tokens: 1 });
+	}
+});
+
+//#endregion
+//#region src/routes/models.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	const provider = getCopilotProviderContext(c.get("config"));
+	const search = new URL(c.req.url).search;
+	try {
+		const upstream = await fetchCopilot(provider, `/models${search}`, {
+			method: "GET",
+			headers: { accept: c.req.header("accept") ?? "application/json" }
+		});
+		return new Response(upstream.body, {
+			status: upstream.status,
+			headers: upstream.headers
+		});
+	} catch (error) {
+		if (error instanceof BridgeNotImplementedError) return c.json({ error: {
+			type: error.name,
+			message: error.message
+		} }, 500);
+		throw error;
+	}
+});
+
+//#endregion
+//#region src/bridges/codex/chat-fallback.ts
+const collectText = (content) => {
+	if (typeof content === "string") return {
+		text: content,
+		parts: [{
+			type: "text",
+			text: content
+		}]
+	};
+	const parts = [];
+	let textBuf = "";
+	for (const p of content ?? []) if (p.type === "input_text" || p.type === "output_text" || p.type === "text") {
+		const t = p.text ?? "";
+		textBuf += t;
+		parts.push({
+			type: "text",
+			text: t
+		});
+	} else if (p.type === "input_image") {
+		const url = typeof p.image_url === "string" ? p.image_url : p.image_url?.url ?? "";
+		if (url) parts.push({
+			type: "image_url",
+			image_url: {
+				url,
+				detail: p.detail
+			}
+		});
+	}
+	return {
+		text: textBuf,
+		parts
+	};
+};
+const placeReasoning = (payload, capability, effort) => {
+	if (!effort || !capability.reasoning) return;
+	if (capability.reasoningField === "output_config.effort") payload.output_config = {
+		...payload.output_config ?? {},
+		effort
+	};
+	else payload.reasoning_effort = effort;
+};
+const responsesPayloadToChatPayload = (request, capability) => {
+	const messages = [];
+	if (request.instructions) messages.push({
+		role: "system",
+		content: request.instructions
+	});
+	const inputItems = typeof request.input === "string" ? [{
+		role: "user",
+		content: request.input
+	}] : request.input ?? [];
+	for (const item of inputItems) if ("role" in item && (item.type === void 0 || item.type === "message")) {
+		const { text, parts } = collectText(item.content);
+		const role = item.role === "developer" ? "system" : item.role === "system" ? "system" : item.role === "assistant" ? "assistant" : "user";
+		const useStringContent = parts.length <= 1 && parts.every((p) => p.type === "text");
+		messages.push({
+			role,
+			content: useStringContent ? text : parts
+		});
+	} else if (item.type === "function_call") messages.push({
+		role: "assistant",
+		content: null,
+		tool_calls: [{
+			id: item.call_id,
+			type: "function",
+			function: {
+				name: item.name,
+				arguments: item.arguments
+			}
+		}]
+	});
+	else if (item.type === "function_call_output") messages.push({
+		role: "tool",
+		tool_call_id: item.call_id,
+		content: item.output
+	});
+	const tools = request.tools?.filter((t) => {
+		const name = t.function?.name ?? t.name;
+		return t.type === "function" && typeof name === "string" && name.length > 0;
+	}).map((t) => ({
+		type: "function",
+		function: {
+			name: t.function?.name ?? t.name ?? "",
+			description: t.function?.description ?? t.description,
+			parameters: t.function?.parameters ?? t.parameters
+		}
+	}));
+	const payload = {
+		model: capability.id,
+		messages,
+		stream: false,
+		max_tokens: request.max_output_tokens,
+		temperature: request.temperature,
+		top_p: request.top_p,
+		user: request.user,
+		tools: tools && tools.length > 0 ? tools : void 0,
+		tool_choice: tools && tools.length > 0 ? request.tool_choice : void 0
+	};
+	placeReasoning(payload, capability, request.reasoning?.effort);
+	return payload;
+};
+const buildResponsesResult = (request, chat) => {
+	const message = chat.choices[0]?.message;
+	const text = typeof message?.content === "string" ? message.content : Array.isArray(message?.content) ? message.content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("") : "";
+	const output = [];
+	if (text.length > 0) output.push({
+		id: `msg_${randomUUID()}`,
+		type: "message",
+		role: "assistant",
+		status: "completed",
+		content: [{
+			type: "output_text",
+			text,
+			annotations: []
+		}]
+	});
+	for (const tc of message?.tool_calls ?? []) output.push({
+		id: `fc_${randomUUID()}`,
+		type: "function_call",
+		status: "completed",
+		call_id: tc.id,
+		name: tc.function.name,
+		arguments: tc.function.arguments
+	});
+	return {
+		id: chat.id ?? `resp_${randomUUID()}`,
+		object: "response",
+		status: "completed",
+		created_at: chat.created ?? Math.floor(Date.now() / 1e3),
+		model: chat.model ?? request.model,
+		output,
+		usage: chat.usage ? {
+			input_tokens: chat.usage.prompt_tokens ?? 0,
+			output_tokens: chat.usage.completion_tokens ?? 0,
+			total_tokens: chat.usage.total_tokens ?? 0
+		} : void 0
+	};
+};
+const chatResponseToResponsesJson = buildResponsesResult;
+const sse = (event, data) => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+const synthesizeResponsesSseFromChat = (request, chat) => {
+	const result = buildResponsesResult(request, chat);
+	const encoder = new TextEncoder();
+	const baseResponse = {
+		id: result.id,
+		object: "response",
+		created_at: result.created_at,
+		model: result.model,
+		status: "in_progress",
+		output: []
+	};
+	return new ReadableStream({ start(controller) {
+		const push = (event, data) => controller.enqueue(encoder.encode(sse(event, data)));
+		push("response.created", {
+			type: "response.created",
+			response: baseResponse
+		});
+		push("response.in_progress", {
+			type: "response.in_progress",
+			response: baseResponse
+		});
+		result.output.forEach((item, index) => {
+			push("response.output_item.added", {
+				type: "response.output_item.added",
+				output_index: index,
+				item
+			});
+			if (item.type === "message") {
+				const text = item.content[0]?.text ?? "";
+				const part = {
+					type: "output_text",
+					text: "",
+					annotations: []
+				};
+				push("response.content_part.added", {
+					type: "response.content_part.added",
+					item_id: item.id,
+					output_index: index,
+					content_index: 0,
+					part
+				});
+				if (text) push("response.output_text.delta", {
+					type: "response.output_text.delta",
+					item_id: item.id,
+					output_index: index,
+					content_index: 0,
+					delta: text
+				});
+				push("response.output_text.done", {
+					type: "response.output_text.done",
+					item_id: item.id,
+					output_index: index,
+					content_index: 0,
+					text
+				});
+				push("response.content_part.done", {
+					type: "response.content_part.done",
+					item_id: item.id,
+					output_index: index,
+					content_index: 0,
+					part: {
+						...part,
+						text
+					}
+				});
+			} else if (item.type === "function_call") {
+				if (item.arguments) push("response.function_call_arguments.delta", {
+					type: "response.function_call_arguments.delta",
+					item_id: item.id,
+					output_index: index,
+					delta: item.arguments
+				});
+				push("response.function_call_arguments.done", {
+					type: "response.function_call_arguments.done",
+					item_id: item.id,
+					output_index: index,
+					arguments: item.arguments
+				});
+			}
+			push("response.output_item.done", {
+				type: "response.output_item.done",
+				output_index: index,
+				item
+			});
+		});
+		push("response.completed", {
+			type: "response.completed",
+			response: {
+				...result,
+				status: "completed"
+			}
+		});
+		controller.close();
+	} });
+};
+
+//#endregion
+//#region src/bridges/codex/normalize-stream.ts
+const normalizeEventPayload = (rawData, stableResponse) => {
+	let event;
+	try {
+		event = JSON.parse(rawData);
+	} catch {
+		return rawData;
+	}
+	if (event.response && typeof event.response === "object") {
+		const incoming = event.response;
+		if (!stableResponse.initialized) {
+			if (incoming.id) stableResponse.id = incoming.id;
+			if (typeof incoming.created_at === "number") stableResponse.created_at = incoming.created_at;
+			if (incoming.model) stableResponse.model = incoming.model;
+			stableResponse.initialized = true;
+		}
+		event.response = {
+			...incoming,
+			...stableResponse.id ? { id: stableResponse.id } : {},
+			...stableResponse.created_at ? { created_at: stableResponse.created_at } : {},
+			...stableResponse.model ? { model: stableResponse.model } : {}
+		};
+	}
+	return JSON.stringify(event);
+};
+const transformSseChunk = (chunk, stableResponse) => {
+	return chunk.split("\n").map((line) => {
+		if (!line.startsWith("data: ")) return line;
+		const rawData = line.slice(6);
+		if (!rawData || rawData === "[DONE]") return line;
+		return `data: ${normalizeEventPayload(rawData, stableResponse)}`;
+	}).join("\n");
+};
+const normalizeResponsesSseStream = (upstreamBody) => {
+	const stableResponse = {
+		created_at: 0,
+		id: "",
+		initialized: false,
+		model: ""
+	};
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	let buffer = "";
+	return new ReadableStream({ async start(controller) {
+		const reader = upstreamBody.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += decoder.decode(value, { stream: true });
+				let separatorIndex = buffer.indexOf("\n\n");
+				while (separatorIndex !== -1) {
+					const rawEvent = buffer.slice(0, separatorIndex);
+					buffer = buffer.slice(separatorIndex + 2);
+					const transformed = transformSseChunk(rawEvent, stableResponse);
+					controller.enqueue(encoder.encode(`${transformed}\n\n`));
+					separatorIndex = buffer.indexOf("\n\n");
+				}
+			}
+			if (buffer.length > 0) {
+				const transformed = transformSseChunk(buffer, stableResponse);
+				controller.enqueue(encoder.encode(transformed));
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		controller.close();
+	} });
+};
+
+//#endregion
+//#region src/bridges/codex/responses.ts
+const codexResponsesRequestSchema = z.object({
+	model: z.string().min(1),
+	stream: z.boolean().optional()
+}).passthrough();
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const normalizeCodexResponsesRequest = (payload) => {
+	const parsed = codexResponsesRequestSchema.parse(payload);
+	const canonical = resolveModelId(parsed.model);
+	const capability = getModelCapability(canonical);
+	if (!capability) return parsed;
+	const next = {
+		...parsed,
+		model: canonical
+	};
+	if (!capability.reasoning) {
+		if ("reasoning" in next) delete next.reasoning;
+		return next;
+	}
+	const incoming = isPlainObject(next.reasoning) ? next.reasoning : void 0;
+	const clamped = clampReasoningEffort(canonical, incoming?.effort);
+	if (clamped) next.reasoning = {
+		...incoming ?? {},
+		effort: clamped.effort
+	};
+	return next;
+};
+
+//#endregion
+//#region src/routes/responses.ts
+const responsesRoutes = new Hono();
+responsesRoutes.post("/", async (c) => {
+	try {
+		await checkRateLimit();
+	} catch (error) {
+		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
+		throw error;
+	}
+	const payload = normalizeCodexResponsesRequest(await c.req.json());
+	const provider = getCopilotProviderContext(c.get("config"));
+	const search = new URL(c.req.url).search;
+	const capability = getModelCapability(payload.model);
+	try {
+		if (capability?.fallback === "chat-completions") {
+			const chatPayload = responsesPayloadToChatPayload(payload, capability);
+			const upstream$1 = await fetchCopilot(provider, `/chat/completions${search}`, {
+				method: "POST",
+				headers: {
+					accept: "application/json",
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(chatPayload)
+			});
+			if (!upstream$1.ok) {
+				const text = await upstream$1.text();
+				return new Response(text, {
+					status: upstream$1.status,
+					headers: { "content-type": upstream$1.headers.get("content-type") ?? "application/json" }
+				});
+			}
+			const chatJson = await upstream$1.json();
+			if (payload.stream) {
+				const stream = synthesizeResponsesSseFromChat(payload, chatJson);
+				return new Response(stream, {
+					status: 200,
+					headers: {
+						"content-type": "text/event-stream; charset=utf-8",
+						"cache-control": "no-cache",
+						connection: "keep-alive"
+					}
+				});
+			}
+			const responsesJson = chatResponseToResponsesJson(payload, chatJson);
+			return new Response(JSON.stringify(responsesJson), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		}
+		const upstream = await fetchCopilot(provider, `/responses${search}`, {
+			method: "POST",
+			headers: {
+				accept: c.req.header("accept") ?? "application/json",
+				"content-type": c.req.header("content-type") ?? "application/json"
+			},
+			body: JSON.stringify(payload)
+		});
+		const contentType = upstream.headers.get("content-type") ?? "";
+		if (payload.stream && upstream.body && contentType.includes("text/event-stream")) return new Response(normalizeResponsesSseStream(upstream.body), {
+			status: upstream.status,
+			headers: upstream.headers
+		});
+		return new Response(upstream.body, {
+			status: upstream.status,
+			headers: upstream.headers
+		});
+	} catch (error) {
+		if (error instanceof BridgeNotImplementedError) return c.json({ error: {
+			type: error.name,
+			message: error.message
+		} }, 501);
+		throw error;
+	}
+});
+
+//#endregion
+//#region src/providers/github/get-copilot-usage.ts
+const COPILOT_VERSION = "0.26.7";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+const GITHUB_API_VERSION = "2022-11-28";
+const GITHUB_API_BASE_URL = "https://api.github.com";
+const readGitHubToken = async () => {
+	return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim();
+};
+const getCopilotUsage = async (config) => {
+	const githubToken = await readGitHubToken();
+	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/user`, { headers: {
+		accept: "application/json",
+		authorization: `token ${githubToken}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"editor-version": `vscode/${config.vsCodeVersion}`,
+		"user-agent": USER_AGENT,
+		"x-github-api-version": GITHUB_API_VERSION,
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	} });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/usage.ts
+const usageRoutes = new Hono();
+usageRoutes.get("/", async (c) => {
+	c.header("access-control-allow-origin", "*");
+	c.header("access-control-allow-methods", "GET, OPTIONS");
+	c.header("access-control-allow-headers", "*");
+	try {
+		const usage = await getCopilotUsage(c.var.config);
+		return c.json(usage);
+	} catch (error) {
+		console.error("Error fetching Copilot usage:", error);
+		return c.json({ error: "Failed to fetch Copilot usage" }, 500);
+	}
+});
+usageRoutes.options("/", (c) => {
+	c.header("access-control-allow-origin", "*");
+	c.header("access-control-allow-methods", "GET, OPTIONS");
+	c.header("access-control-allow-headers", "*");
+	return c.body(null, 204);
+});
+
+//#endregion
+//#region src/server.ts
+const createServer = (config) => {
+	const app = new Hono();
+	app.use(logger());
+	app.use("*", cors());
+	app.use("*", async (c, next) => {
+		c.set("config", config);
+		await next();
+	});
+	app.get("/", (c) => c.json({
+		name: "copilot-bridge",
+		status: "ok"
+	}));
+	app.get("/healthz", (c) => c.json({ ok: true }));
+	app.route("/v1/models", modelRoutes);
+	app.route("/v1/responses", responsesRoutes);
+	app.route("/v1/messages", messageRoutes);
+	app.route("/v1/chat/completions", chatCompletionRoutes);
+	app.route("/v1/embeddings", embeddingRoutes);
+	app.route("/usage", usageRoutes);
+	return app;
+};
+const startServer = (config) => serve({
+	fetch: createServer(config).fetch,
+	hostname: config.host,
+	port: config.port
+});
+
+//#endregion
+//#region src/start.ts
+const fetchAvailableModels = async (config) => {
+	try {
+		const response = await fetchCopilot(getCopilotProviderContext(config), "/models", {
+			method: "GET",
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return [];
+		return ((await response.json()).data ?? []).map((m) => m.id).filter(Boolean);
+	} catch {
+		return [];
+	}
+};
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the copilot-bridge HTTP server."
+	},
+	args: {
+		host: {
+			type: "string",
+			description: "Host to bind (overrides settings.json)."
+		},
+		port: {
+			type: "string",
+			description: "Port to listen on (overrides settings.json)."
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Print GitHub and Copilot tokens during startup."
+		},
+		"no-codex-setup": {
+			type: "boolean",
+			default: false,
+			description: "Skip writing the bridge provider into ~/.codex/config.toml."
+		},
+		"select-model": {
+			type: "boolean",
+			default: false,
+			description: "Force the model picker even when codex.model is set."
+		},
+		"no-prompt": {
+			type: "boolean",
+			default: false,
+			description: "Never prompt; use codex.model from settings.json as-is."
+		},
+		"rate-limit": {
+			type: "string",
+			description: "Minimum seconds between upstream requests (anti-abuse throttle)."
+		},
+		wait: {
+			type: "boolean",
+			default: false,
+			description: "When --rate-limit is set, wait instead of returning HTTP 429."
+		}
+	},
+	async run({ args }) {
+		const settings = await ensureSettingsFile();
+		const config = readBridgeConfig({
+			host: args.host ? String(args.host) : settings.host,
+			port: args.port ? Number(args.port) : settings.port
+		});
+		const rateLimitRaw = args["rate-limit"];
+		if (rateLimitRaw !== void 0) {
+			const parsed = Number.parseInt(String(rateLimitRaw), 10);
+			if (!Number.isFinite(parsed) || parsed <= 0) {
+				consola.error(`Invalid --rate-limit value: ${rateLimitRaw}`);
+				process.exit(1);
+			}
+			runtimeState.rateLimitSeconds = parsed;
+			runtimeState.rateLimitWait = Boolean(args.wait);
+			consola.info(`Rate limit: ${parsed}s between requests (${runtimeState.rateLimitWait ? "wait" : "reject"} on overflow)`);
+		}
+		await setupBridgeAuth(config, { showToken: args["show-token"] });
+		const server = startServer(config);
+		consola.success(`copilot-bridge listening on http://${config.host}:${config.port}`);
+		consola.info(`copilot base url: ${config.copilotBaseUrl}`);
+		const models = await fetchAvailableModels(config);
+		const supportedIds = new Set(MODEL_CAPABILITIES.map((m) => m.id));
+		const pickable = models.length > 0 ? models.filter((id) => supportedIds.has(id)) : MODEL_CAPABILITIES.map((m) => m.id);
+		const finalPickable = pickable.length > 0 ? pickable : MODEL_CAPABILITIES.map((m) => m.id);
+		if (models.length > 0) consola.info(`Available models:\n${models.map((id) => `- ${id}${supportedIds.has(id) ? " (bridge-supported)" : ""}`).join("\n")}`);
+		else consola.warn("Could not fetch model list from upstream Copilot API");
+		const codexUserConfig = await readCodexUserConfigFromDisk(settings.codex.configPath);
+		let chosenModel = codexUserConfig.model;
+		let chosenEffort = codexUserConfig.modelReasoningEffort;
+		if (!args["no-prompt"] && finalPickable.length > 0 && (args["select-model"] || !chosenModel)) {
+			const defaultId = chosenModel && finalPickable.includes(chosenModel) ? chosenModel : finalPickable.includes("gpt-5.3-codex") ? "gpt-5.3-codex" : finalPickable[0];
+			const selected = await consola.prompt(`Select a model for codex (writes to ${settings.codex.configPath})`, {
+				type: "select",
+				options: finalPickable,
+				initial: defaultId
+			});
+			if (selected) {
+				chosenModel = selected;
+				const supported = getModelCapability(selected)?.reasoning?.supported;
+				if (chosenEffort && supported && !supported.includes(chosenEffort)) chosenEffort = void 0;
+			}
+		}
+		const baseUrl = `http://${config.host}:${config.port}`;
+		consola.box([
+			`🌐 Usage viewer`,
+			``,
+			`  https://betahi.github.io/copilot-api?endpoint=${baseUrl}/usage`
+		].join("\n"));
+		if (settings.codex.enabled && !args["no-codex-setup"]) {
+			const result = await applyCodexConfig({
+				baseUrl: `${baseUrl}/v1`,
+				configPath: settings.codex.configPath,
+				settings: settings.codex,
+				model: chosenModel,
+				modelReasoningEffort: chosenEffort
+			});
+			if (result.changed) {
+				consola.success(`codex config ${result.created ? "created" : "updated"}: ${result.configPath}`);
+				if (settings.codex.setAsDefault) consola.info(`codex now defaults to provider "${settings.codex.providerId}". Run \`codex exec "..."\` directly.`);
+				else consola.info(`provider "${settings.codex.providerId}" registered. Use \`codex -c model_provider="${settings.codex.providerId}" ...\``);
+			} else consola.info(`codex config already up to date: ${result.configPath}`);
+		}
+		await new Promise((resolve, reject) => {
+			server.on("close", resolve);
+			server.on("error", reject);
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+await runMain(defineCommand({
+	meta: {
+		name: "copilot-bridge",
+		description: "Model-layer bridge for routing Codex CLI, Claude Code, and similar clients to GitHub Copilot."
+	},
+	subCommands: {
+		auth,
+		start
+	}
+}));
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map