@ashsec/copilot-api 0.8.0 → 0.11.2

package/dist/main.js

@@ -5,7 +5,6 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { events } from "fetch-event-stream";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
@@ -17,28 +16,102 @@ import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
 import util from "node:util";
 
 //#region package.json
-var version = "0.8.0";
+var name = "@ashsec/copilot-api";
+var version = "0.11.2";
+var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
+var keywords = [
+	"proxy",
+	"github-copilot",
+	"openai-compatible"
+];
+var homepage = "https://github.com/ericc-ch/copilot-api";
+var bugs = "https://github.com/ericc-ch/copilot-api/issues";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/ericc-ch/copilot-api.git"
+};
+var author = "Erick Christian <erickchristian48@gmail.com>";
+var type = "module";
+var bin = { "copilot-api": "./dist/main.js" };
+var files = ["dist"];
+var scripts = {
+	"build": "tsdown",
+	"dev": "bun run --watch ./src/main.ts",
+	"knip": "knip-bun",
+	"lint": "eslint --cache",
+	"lint:all": "eslint --cache .",
+	"prepack": "bun run build",
+	"prepare": "simple-git-hooks",
+	"release": "bumpp && bun publish --access public",
+	"start": "NODE_ENV=production bun run ./src/main.ts",
+	"typecheck": "tsc"
+};
+var simple_git_hooks = { "pre-commit": "bunx lint-staged" };
+var lint_staged = { "*": "bun run lint --fix" };
+var dependencies = {
+	"citty": "^0.1.6",
+	"clipboardy": "^5.0.0",
+	"consola": "^3.4.2",
+	"fetch-event-stream": "^0.1.5",
+	"gpt-tokenizer": "^3.0.1",
+	"hono": "^4.9.9",
+	"ms": "^2.1.3",
+	"proxy-from-env": "^1.1.0",
+	"srvx": "^0.8.9",
+	"tiny-invariant": "^1.3.3",
+	"undici": "^7.16.0",
+	"zod": "^4.1.11"
+};
+var devDependencies = {
+	"@echristian/eslint-config": "^0.0.54",
+	"@types/bun": "^1.2.23",
+	"@types/proxy-from-env": "^1.0.4",
+	"bumpp": "^10.2.3",
+	"eslint": "^9.37.0",
+	"knip": "^5.64.1",
+	"lint-staged": "^16.2.3",
+	"prettier-plugin-packagejson": "^2.5.19",
+	"simple-git-hooks": "^2.13.1",
+	"tsdown": "^0.15.6",
+	"typescript": "^5.9.3"
+};
+var package_default = {
+	name,
+	version,
+	description,
+	keywords,
+	homepage,
+	bugs,
+	repository,
+	author,
+	type,
+	bin,
+	files,
+	scripts,
+	"simple-git-hooks": simple_git_hooks,
+	"lint-staged": lint_staged,
+	dependencies,
+	devDependencies
+};
 
 //#endregion
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
-const AZURE_OPENAI_CONFIG_PATH = path.join(APP_DIR, "azure_openai_config");
 const REPLACEMENTS_CONFIG_PATH = path.join(APP_DIR, "replacements.json");
 const PATHS = {
 	APP_DIR,
 	CONFIG_PATH: path.join(APP_DIR, "config.json"),
 	GITHUB_TOKEN_PATH,
-	AZURE_OPENAI_CONFIG_PATH,
 	REPLACEMENTS_CONFIG_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-	await ensureFile(PATHS.AZURE_OPENAI_CONFIG_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -180,56 +253,6 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
-//#endregion
-//#region src/services/azure-openai/config.ts
-const AZURE_OPENAI_MODEL_PREFIX = "azure_openai_";
-async function loadAzureOpenAIConfig() {
-	try {
-		const content = await fs.readFile(PATHS.AZURE_OPENAI_CONFIG_PATH, "utf8");
-		if (!content.trim()) return null;
-		const decoded = Buffer.from(content.trim(), "base64").toString("utf8");
-		const config$1 = JSON.parse(decoded);
-		if (!config$1.endpoint || !config$1.apiKey) return null;
-		return config$1;
-	} catch {
-		return null;
-	}
-}
-async function saveAzureOpenAIConfig(config$1) {
-	const encoded = Buffer.from(JSON.stringify(config$1)).toString("base64");
-	await fs.writeFile(PATHS.AZURE_OPENAI_CONFIG_PATH, encoded, "utf8");
-	await fs.chmod(PATHS.AZURE_OPENAI_CONFIG_PATH, 384);
-	consola.success("Azure OpenAI configuration saved");
-}
-async function promptAzureOpenAISetup() {
-	if (!await consola.prompt("Would you like to add a custom Azure OpenAI endpoint?", {
-		type: "confirm",
-		initial: false
-	})) return null;
-	const endpoint = await consola.prompt("Enter your Azure OpenAI endpoint URL (e.g., https://your-resource.openai.azure.com):", { type: "text" });
-	if (!endpoint || typeof endpoint !== "string" || !endpoint.trim()) {
-		consola.warn("No endpoint provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const apiKey = await consola.prompt("Enter your Azure OpenAI API key:", { type: "text" });
-	if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
-		consola.warn("No API key provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const config$1 = {
-		endpoint: endpoint.trim().replace(/\/$/, ""),
-		apiKey: apiKey.trim()
-	};
-	await saveAzureOpenAIConfig(config$1);
-	return config$1;
-}
-function isAzureOpenAIModel(modelId) {
-	return modelId.startsWith(AZURE_OPENAI_MODEL_PREFIX);
-}
-function getAzureDeploymentName(modelId) {
-	return modelId.slice(13);
-}
-
 //#endregion
 //#region src/lib/retry-fetch.ts
 const RETRY_DELAYS_MS = [
@@ -273,8 +296,8 @@ async function fetchWithRetry(input, init) {
 	let lastError;
 	let lastResponse;
 	for (let attempt = 0; attempt < maxAttempts; attempt++) try {
-		const headers = new Headers(init?.headers);
-		headers.set("Connection", "close");
+		const headers = toHeaderRecord(init?.headers);
+		headers.Connection = "close";
 		const response = await fetch(input, {
 			...init,
 			headers,
@@ -296,63 +319,24 @@ async function fetchWithRetry(input, init) {
 		await sleep(delayMs);
 	}
 	if (lastResponse) return lastResponse;
-	throw lastError;
-}
-
-//#endregion
-//#region src/services/azure-openai/create-chat-completions.ts
-const AZURE_API_VERSION = "2024-10-21";
-async function createAzureOpenAIChatCompletions(config$1, payload) {
-	const deploymentName = getAzureDeploymentName(payload.model);
-	const { max_tokens,...restPayload } = payload;
-	const azurePayload = {
-		...restPayload,
-		model: deploymentName,
-		...max_tokens != null && { max_completion_tokens: max_tokens }
-	};
-	const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
-		method: "POST",
-		headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify(azurePayload)
-	});
-	if (!response.ok) {
-		consola.error("Failed to create Azure OpenAI chat completions:", response);
-		throw new HTTPError("Failed to create Azure OpenAI chat completions", response, payload);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
+	throw lastError ?? /* @__PURE__ */ new Error("Request failed without a captured error");
 }
-
-//#endregion
-//#region src/services/azure-openai/get-models.ts
-const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
-async function getAzureOpenAIDeployments(config$1) {
-	try {
-		const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		} });
-		if (!response.ok) {
-			const errorText = await response.text().catch(() => "");
-			consola.error(`Failed to fetch Azure OpenAI deployments: ${response.status}`, errorText);
-			throw new HTTPError("Failed to fetch Azure OpenAI deployments", response);
-		}
-		return (await response.json()).data.filter((deployment) => deployment.status === "succeeded").map((deployment) => ({
-			id: `${AZURE_OPENAI_MODEL_PREFIX}${deployment.id}`,
-			deploymentName: deployment.id,
-			model: deployment.model,
-			created: deployment.created_at,
-			object: "deployment",
-			owned_by: deployment.owner || "azure-openai"
-		}));
-	} catch (error) {
-		if (error instanceof HTTPError) throw error;
-		consola.error("Failed to fetch Azure OpenAI deployments:", error);
-		return [];
+function toHeaderRecord(headersInit) {
+	const headers = {};
+	if (!headersInit) return headers;
+	if (headersInit instanceof Headers) {
+		for (const [key, value] of headersInit.entries()) headers[key] = value;
+		return headers;
+	}
+	if (Array.isArray(headersInit)) {
+		for (const entry of headersInit) if (Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string") {
+			const [key, value] = entry;
+			headers[key] = value;
+		}
+		return headers;
 	}
+	for (const [key, value] of Object.entries(headersInit)) if (typeof value === "string") headers[key] = value;
+	return headers;
 }
 
 //#endregion
@@ -418,24 +402,6 @@ const cacheVSCodeVersion = async () => {
 	state.vsCodeVersion = response;
 	consola.info(`Using VSCode version: ${response}`);
 };
-async function setupAzureOpenAI() {
-	let config$1 = await loadAzureOpenAIConfig();
-	if (!config$1) config$1 = await promptAzureOpenAISetup();
-	if (!config$1) {
-		consola.info("Azure OpenAI not configured");
-		return;
-	}
-	state.azureOpenAIConfig = config$1;
-	consola.info("Azure OpenAI configuration loaded");
-	try {
-		const deployments = await getAzureOpenAIDeployments(config$1);
-		state.azureOpenAIDeployments = deployments;
-		if (deployments.length > 0) consola.info(`Loaded ${deployments.length} Azure OpenAI deployment(s):\n${deployments.map((d) => `- ${d.id} (${d.model})`).join("\n")}`);
-		else consola.warn("No Azure OpenAI deployments found");
-	} catch (error) {
-		consola.warn("Failed to fetch Azure OpenAI deployments:", error);
-	}
-}
 
 //#endregion
 //#region src/services/github/poll-access-token.ts
@@ -583,13 +549,13 @@ const checkUsage = defineCommand({
 			const premiumUsed = premiumTotal - premium.remaining;
 			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
 			const premiumPercentRemaining = premium.percent_remaining;
-			function summarizeQuota(name, snap) {
-				if (!snap) return `${name}: N/A`;
+			function summarizeQuota(name$1, snap) {
+				if (!snap) return `${name$1}: N/A`;
 				const total = snap.entitlement;
 				const used = total - snap.remaining;
 				const percentUsed = total > 0 ? used / total * 100 : 0;
 				const percentRemaining = snap.percent_remaining;
-				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
+				return `${name$1}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
 			}
 			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
 			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
@@ -665,11 +631,11 @@ async function getUserReplacements() {
 * Add a new user replacement rule
 */
 async function addReplacement(pattern, replacement, options) {
-	const { isRegex = false, name } = options ?? {};
+	const { isRegex = false, name: name$1 } = options ?? {};
 	await ensureLoaded();
 	const rule = {
 		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-		name,
+		name: name$1,
 		pattern,
 		replacement,
 		isRegex,
@@ -785,34 +751,49 @@ async function applyReplacements(text) {
 			appliedRules.push(rule.name || rule.id);
 		}
 	}
-	if (appliedRules.length > 0) consola.info(`Replacements applied: ${appliedRules.join(", ")}`);
-	return result;
+	return {
+		text: result,
+		appliedRules
+	};
 }
 /**
 * Apply replacements to a chat completions payload
 * This modifies message content in place
 */
 async function applyReplacementsToPayload(payload) {
+	const allAppliedRules = [];
 	const processedMessages = await Promise.all(payload.messages.map(async (message) => {
-		if (typeof message.content === "string") return {
-			...message,
-			content: await applyReplacements(message.content)
-		};
+		if (typeof message.content === "string") {
+			const { text, appliedRules } = await applyReplacements(message.content);
+			allAppliedRules.push(...appliedRules);
+			return {
+				...message,
+				content: text
+			};
+		}
 		if (Array.isArray(message.content)) return {
 			...message,
 			content: await Promise.all(message.content.map(async (part) => {
-				if (typeof part === "object" && part.type === "text" && part.text) return {
-					...part,
-					text: await applyReplacements(part.text)
-				};
+				if (typeof part === "object" && part.type === "text" && part.text) {
+					const { text, appliedRules } = await applyReplacements(part.text);
+					allAppliedRules.push(...appliedRules);
+					return {
+						...part,
+						text
+					};
+				}
 				return part;
 			}))
 		};
 		return message;
 	}));
+	const uniqueRules = [...new Set(allAppliedRules)];
 	return {
-		...payload,
-		messages: processedMessages
+		payload: {
+			...payload,
+			messages: processedMessages
+		},
+		appliedRules: uniqueRules
 	};
 }
 
@@ -820,11 +801,20 @@ async function applyReplacementsToPayload(payload) {
 //#region src/config.ts
 function formatRule(rule, index) {
 	const status = rule.enabled ? "✓" : "✗";
-	const type = rule.isRegex ? "regex" : "string";
+	const type$1 = rule.isRegex ? "regex" : "string";
 	const system = rule.isSystem ? " [system]" : "";
-	const name = rule.name ? ` "${rule.name}"` : "";
+	const name$1 = rule.name ? ` "${rule.name}"` : "";
 	const replacement = rule.replacement || "(empty)";
-	return `${index + 1}. [${status}] (${type})${system}${name} "${rule.pattern}" → "${replacement}"`;
+	return `${index + 1}. [${status}] (${type$1})${system}${name$1} "${rule.pattern}" → "${replacement}"`;
+}
+function isValidPatternForMatchType(pattern, matchType) {
+	if (matchType !== "regex") return true;
+	try {
+		new RegExp(pattern);
+		return true;
+	} catch {
+		return false;
+	}
 }
 async function listReplacements() {
 	const all = await getAllReplacements();
@@ -837,11 +827,11 @@ async function listReplacements() {
 	console.log();
 }
 async function addNewReplacement() {
-	const name = await consola.prompt("Name (optional, short description):", {
+	const name$1 = await consola.prompt("Name (optional, short description):", {
 		type: "text",
 		default: ""
 	});
-	if (typeof name === "symbol") {
+	if (typeof name$1 === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -864,9 +854,7 @@ async function addNewReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	if (matchType === "regex") try {
-		new RegExp(pattern);
-	} catch {
+	if (!isValidPatternForMatchType(pattern, matchType)) {
 		consola.error(`Invalid regex pattern: ${pattern}`);
 		return;
 	}
@@ -878,7 +866,10 @@ async function addNewReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	const rule = await addReplacement(pattern, replacement, matchType === "regex", name || void 0);
+	const rule = await addReplacement(pattern, replacement, {
+		isRegex: matchType === "regex",
+		name: name$1 || void 0
+	});
 	consola.success(`Added rule: ${rule.name || rule.id}`);
 }
 async function editExistingReplacement() {
@@ -906,11 +897,11 @@ async function editExistingReplacement() {
 	}
 	consola.info(`\nEditing rule: ${rule.name || rule.id}`);
 	consola.info("Press Enter to keep current value.\n");
-	const name = await consola.prompt("Name:", {
+	const name$1 = await consola.prompt("Name:", {
 		type: "text",
 		default: rule.name || ""
 	});
-	if (typeof name === "symbol") {
+	if (typeof name$1 === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -937,9 +928,7 @@ async function editExistingReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	if (matchType === "regex") try {
-		new RegExp(pattern);
-	} catch {
+	if (!isValidPatternForMatchType(pattern, matchType)) {
 		consola.error(`Invalid regex pattern: ${pattern}`);
 		return;
 	}
@@ -952,7 +941,7 @@ async function editExistingReplacement() {
 		return;
 	}
 	const updated = await updateReplacement(selected, {
-		name: name || void 0,
+		name: name$1 || void 0,
 		pattern,
 		replacement,
 		isRegex: matchType === "regex"
@@ -1009,7 +998,7 @@ async function testReplacements() {
 		consola.info("Cancelled.");
 		return;
 	}
-	const result = await applyReplacements(testText);
+	const { text: result } = await applyReplacements(testText);
 	consola.info("\n📝 Original:");
 	console.log(testText);
 	consola.info("\n✨ After replacements:");
@@ -1269,7 +1258,8 @@ function mergeDefaultExtraPrompts(config$1) {
 	};
 }
 function mergeConfigWithDefaults() {
-	const { mergedConfig, changed } = mergeDefaultExtraPrompts(readConfigFromDisk());
+	const config$1 = readConfigFromDisk();
+	const { mergedConfig, changed } = mergeDefaultExtraPrompts(config$1);
 	if (changed) try {
 		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
 	} catch (writeError) {
@@ -1285,14 +1275,168 @@ function getConfig() {
 function getExtraPromptForModel(model) {
 	return getConfig().extraPrompts?.[model] ?? "";
 }
-function getSmallModel() {
-	return getConfig().smallModel ?? "gpt-5-mini";
-}
-function getReasoningEffortForModel(model) {
+function getReasoningEffortForModel(model, override) {
+	if (override) return override;
 	return getConfig().modelReasoningEfforts?.[model] ?? "high";
 }
-function shouldCompactUseSmallModel() {
-	return getConfig().compactUseSmallModel ?? true;
+
+//#endregion
+//#region src/lib/model-suffix.ts
+/**
+* Hardcoded reasoning config per model, derived from Copilot CLI v0.0.414.
+* Models not in this map do not support per-request reasoning effort control.
+*/
+const MODEL_REASONING_CONFIG = {
+	"claude-sonnet-4.6": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"claude-opus-4.6": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "high"
+	},
+	"claude-opus-4.6-fast": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "high"
+	},
+	"claude-opus-4.6-1m": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "high"
+	},
+	"gpt-5.3-codex": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5.2-codex": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		],
+		defaultEffort: "high"
+	},
+	"gpt-5.2": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5.1-codex": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5.1-codex-max": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5.1": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5.1-codex-mini": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	},
+	"gpt-5-mini": {
+		supportedEfforts: [
+			"low",
+			"medium",
+			"high"
+		],
+		defaultEffort: "medium"
+	}
+};
+const VALID_EFFORTS = new Set([
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
+/**
+* Parse a model string that may contain a reasoning effort suffix.
+* Format: "model-name:effort" (e.g. "claude-sonnet-4.6:high")
+*
+* If the suffix is not a valid effort level or the model doesn't support it,
+* the suffix is ignored and the full string is treated as the model name.
+*/
+function parseModelSuffix(model) {
+	const colonIndex = model.lastIndexOf(":");
+	if (colonIndex === -1) return { baseModel: model };
+	const potentialBase = model.slice(0, colonIndex);
+	const potentialEffort = model.slice(colonIndex + 1);
+	if (!VALID_EFFORTS.has(potentialEffort)) return { baseModel: model };
+	const effort = potentialEffort;
+	const config$1 = MODEL_REASONING_CONFIG[potentialBase];
+	if (!config$1) return { baseModel: model };
+	if (!config$1.supportedEfforts.includes(effort)) return {
+		baseModel: potentialBase,
+		reasoningEffort: config$1.defaultEffort
+	};
+	return {
+		baseModel: potentialBase,
+		reasoningEffort: effort
+	};
+}
+/**
+* Generate virtual model entries for models that support reasoning effort.
+* Each supported effort level gets its own virtual model entry.
+*/
+function generateVirtualModels(models) {
+	const virtualModels = [];
+	for (const model of models) {
+		const config$1 = MODEL_REASONING_CONFIG[model.id];
+		if (!config$1) continue;
+		for (const effort of config$1.supportedEfforts) virtualModels.push({
+			id: `${model.id}:${effort}`,
+			object: "model",
+			type: "model",
+			created: 0,
+			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+			owned_by: model.vendor,
+			display_name: `${model.name} (${effort} thinking)`
+		});
+	}
+	return virtualModels;
 }
 
 //#endregion
@@ -1347,7 +1491,8 @@ function getShell() {
 	const { platform, ppid, env } = process$1;
 	if (platform === "win32") {
 		try {
-			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
+			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -1405,7 +1550,8 @@ function normalizeApiKeys(apiKeys) {
 	return [...new Set(normalizedKeys)];
 }
 function getConfiguredApiKeys() {
-	return normalizeApiKeys(getConfig().auth?.apiKeys);
+	const config$1 = getConfig();
+	return normalizeApiKeys(config$1.auth?.apiKeys);
 }
 function extractRequestApiKey(c) {
 	const xApiKey = c.req.header("x-api-key")?.trim();
@@ -1438,6 +1584,26 @@ function createAuthMiddleware(options = {}) {
 	};
 }
 
+//#endregion
+//#region src/lib/api-key-guard.ts
+/**
+* API key guard middleware that silently drops connections when the API key
+* doesn't match the expected value. Unauthorized requests get NO response.
+*
+* Only active when state.apiKeyAuth is set (via --api-key-auth CLI flag).
+*/
+async function apiKeyGuard(c, next) {
+	if (!state.apiKeyAuth) {
+		await next();
+		return;
+	}
+	if (extractRequestApiKey(c) === state.apiKeyAuth) {
+		await next();
+		return;
+	}
+	await new Promise(() => {});
+}
+
 //#endregion
 //#region src/lib/request-logger.ts
 const REQUEST_CONTEXT_KEY = "requestContext";
@@ -1498,7 +1664,8 @@ async function logRawRequest(c) {
 	if (method !== "GET" && method !== "HEAD") try {
 		const body = await c.req.raw.clone().text();
 		if (body) try {
-			const sanitized = sanitizeRequestBody(JSON.parse(body));
+			const parsed = JSON.parse(body);
+			const sanitized = sanitizeRequestBody(parsed);
 			lines.push(`${colors.dim}Body (sanitized):${colors.reset}`, `  ${JSON.stringify(sanitized, null, 2).split("\n").join("\n  ")}`);
 		} catch {
 			lines.push(`${colors.dim}Body:${colors.reset} [${body.length} bytes]`);
@@ -1520,6 +1687,34 @@ function setRequestContext(c, ctx) {
 	});
 }
 /**
+* Format the input size for display
+*/
+function formatInputSize(bytes) {
+	return bytes >= 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
+}
+/**
+* Build the model routing log line
+*/
+function buildModelLine(ctx) {
+	const parts = [];
+	if (ctx.requestedModel && ctx.requestedModel !== ctx.model) parts.push(`${colors.gray}${ctx.requestedModel}${colors.reset} ${colors.dim}→${colors.reset} ${colors.white}${ctx.model}${colors.reset}`);
+	else parts.push(`${colors.white}${ctx.model}${colors.reset}`);
+	if (ctx.provider) parts.push(`${colors.dim}via${colors.reset} ${colors.magenta}${ctx.provider}${colors.reset}`);
+	if (ctx.inputLength !== void 0) parts.push(`${colors.dim}·${colors.reset} ${colors.yellow}${formatInputSize(ctx.inputLength)}${colors.reset}`);
+	return `  ${parts.join(" ")}`;
+}
+/**
+* Build the modifications log line (effort, replacements, tokens)
+*/
+function buildModificationsLine(ctx) {
+	const modParts = [];
+	if (ctx.reasoningEffort) modParts.push(`${colors.blue}effort=${ctx.reasoningEffort}${colors.reset}`);
+	if (ctx.replacements && ctx.replacements.length > 0) modParts.push(`${colors.green}replace: ${ctx.replacements.join(", ")}${colors.reset}`);
+	if (ctx.inputTokens !== void 0) modParts.push(`${colors.yellow}${ctx.inputTokens.toLocaleString()} tokens${colors.reset}`);
+	if (modParts.length === 0) return void 0;
+	return `  ${modParts.join(` ${colors.dim}·${colors.reset} `)}`;
+}
+/**
 * Custom request logger middleware
 */
 async function requestLogger(c, next) {
@@ -1527,7 +1722,11 @@ async function requestLogger(c, next) {
 	const startTime = Date.now();
 	const method = c.req.method;
 	const path$1 = c.req.path + (c.req.raw.url.includes("?") ? "?" + c.req.raw.url.split("?")[1] : "");
-	c.set(REQUEST_CONTEXT_KEY, { startTime });
+	const contentLength = c.req.header("content-length");
+	c.set(REQUEST_CONTEXT_KEY, {
+		startTime,
+		inputLength: contentLength ? Number(contentLength) : void 0
+	});
 	await next();
 	const ctx = c.get(REQUEST_CONTEXT_KEY);
 	const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
@@ -1538,15 +1737,10 @@ async function requestLogger(c, next) {
 	const statusBadge = `${statusColor}${status}${colors.reset}`;
 	const durationStr = `${colors.cyan}${duration}s${colors.reset}`;
 	lines.push(`${colors.bold}${method}${colors.reset} ${path$1} ${statusBadge} ${durationStr}`);
-	if (ctx?.provider && ctx.model) {
-		const providerColor = ctx.provider === "Azure OpenAI" ? colors.blue : colors.magenta;
-		lines.push(`  ${colors.gray}Provider:${colors.reset} ${providerColor}${ctx.provider}${colors.reset} ${colors.gray}->${colors.reset} ${colors.white}${ctx.model}${colors.reset}`);
-	}
-	if (ctx?.inputTokens !== void 0 || ctx?.outputTokens !== void 0) {
-		const tokenParts = [];
-		if (ctx.inputTokens !== void 0) tokenParts.push(`${colors.gray}Input:${colors.reset} ${colors.yellow}${ctx.inputTokens.toLocaleString()}${colors.reset}`);
-		if (ctx.outputTokens !== void 0) tokenParts.push(`${colors.gray}Output:${colors.reset} ${colors.green}${ctx.outputTokens.toLocaleString()}${colors.reset}`);
-		lines.push(`  ${tokenParts.join("  ")}`);
+	if (ctx?.model) lines.push(buildModelLine(ctx));
+	if (ctx) {
+		const modsLine = buildModificationsLine(ctx);
+		if (modsLine) lines.push(modsLine);
 	}
 	lines.push(`  ${colors.dim}${getTimeString()}${colors.reset}`);
 	console.log(lines.join("\n"));
@@ -1561,13 +1755,17 @@ const awaitApproval = async () => {
 //#endregion
 //#region src/lib/model-resolver.ts
 /**
-* Normalize a model name by converting dashes to dots between numbers.
+* Normalize a model name by converting dashes to dots between numbers
+* and converting Anthropic's [1m] suffix to Copilot's -1m suffix.
 * e.g., "claude-opus-4-5" -> "claude-opus-4.5"
+*       "claude-opus-4-6[1m]" -> "claude-opus-4.6-1m"
 *       "gpt-4-1" -> "gpt-4.1"
 *       "gpt-5-1-codex" -> "gpt-5.1-codex"
 */
 function normalizeModelName(model) {
-	return model.replaceAll(/(\d)-(\d)/g, (_, p1, p2) => `${p1}.${p2}`);
+	let normalized = model.replace("[1m]", "-1m");
+	normalized = normalized.replaceAll(/(\d)-(\d)/g, (_, p1, p2) => `${p1}.${p2}`);
+	return normalized;
 }
 
 //#endregion
@@ -1778,7 +1976,8 @@ const numTokensForTools = (tools, encoder, constants) => {
 * Calculate the token count of messages, supporting multiple GPT encoders
 */
 const getTokenCount = async (payload, model) => {
-	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
+	const tokenizer = getTokenizerFromModel(model);
+	const encoder = await getEncodeChatFunction(tokenizer);
 	const simplifiedMessages = payload.messages;
 	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
 	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
@@ -1823,50 +2022,29 @@ const createChatCompletions = async (payload, options) => {
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
-	let payload = await applyReplacementsToPayload(await c.req.json());
-	payload = {
-		...payload,
-		model: normalizeModelName(payload.model)
+	const rawPayload = await c.req.json();
+	const requestedModel = rawPayload.model;
+	const { baseModel, reasoningEffort } = parseModelSuffix(rawPayload.model);
+	rawPayload.model = baseModel;
+	const { payload: replacedPayload, appliedRules } = await applyReplacementsToPayload(rawPayload);
+	let payload = {
+		...replacedPayload,
+		model: normalizeModelName(replacedPayload.model)
 	};
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
-	if (isAzureOpenAIModel(payload.model)) {
-		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		setRequestContext(c, {
-			provider: "Azure OpenAI",
-			model: payload.model
-		});
-		if (state.manualApprove) await awaitApproval();
-		const response$1 = await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, payload);
-		if (isNonStreaming$1(response$1)) {
-			consola.debug("Non-streaming response:", JSON.stringify(response$1));
-			if (response$1.usage) setRequestContext(c, {
-				inputTokens: response$1.usage.prompt_tokens,
-				outputTokens: response$1.usage.completion_tokens
-			});
-			return c.json(response$1);
-		}
-		consola.debug("Streaming response");
-		return streamSSE(c, async (stream) => {
-			for await (const chunk of response$1) {
-				consola.debug("Streaming chunk:", JSON.stringify(chunk));
-				if (chunk.data && chunk.data !== "[DONE]") {
-					const parsed = JSON.parse(chunk.data);
-					if (parsed.usage) setRequestContext(c, {
-						inputTokens: parsed.usage.prompt_tokens,
-						outputTokens: parsed.usage.completion_tokens
-					});
-				}
-				await stream.writeSSE(chunk);
-			}
-		});
-	}
 	setRequestContext(c, {
-		provider: "Copilot",
-		model: payload.model
+		requestedModel,
+		provider: "ChatCompletions",
+		model: payload.model,
+		replacements: appliedRules,
+		reasoningEffort
 	});
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
-		if (selectedModel) setRequestContext(c, { inputTokens: (await getTokenCount(payload, selectedModel)).input });
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(payload, selectedModel);
+			setRequestContext(c, { inputTokens: tokenCount.input });
+		}
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -1933,7 +2111,8 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const response = await createEmbeddings(await c.req.json());
+		const paylod = await c.req.json();
+		const response = await createEmbeddings(paylod);
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -2219,8 +2398,8 @@ const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : u
 	depth: null,
 	colors: false
 })).join(" ");
-const sanitizeName = (name) => {
-	const normalized = name.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
+const sanitizeName = (name$1) => {
+	const normalized = name$1.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
 	return normalized === "" ? "handler" : normalized;
 };
 const getLogStream = (filePath) => {
@@ -2274,10 +2453,10 @@ process.on("SIGTERM", () => {
 	process.exit(0);
 });
 let lastCleanup = 0;
-const createHandlerLogger = (name) => {
+const createHandlerLogger = (name$1) => {
 	ensureLogDirectory();
-	const sanitizedName = sanitizeName(name);
-	const instance = consola.withTag(name);
+	const sanitizedName = sanitizeName(name$1);
+	const instance = consola.withTag(name$1);
 	if (state.verbose) instance.level = 5;
 	instance.setReporters([]);
 	instance.addReporter({ log(logObj) {
@@ -2291,7 +2470,8 @@ const createHandlerLogger = (name) => {
 		const timestamp = date.toLocaleString("sv-SE", { hour12: false });
 		const filePath = path.join(LOG_DIR, `${sanitizedName}-${dateKey}.log`);
 		const message = formatArgs(logObj.args);
-		appendLine(filePath, `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${message ? ` ${message}` : ""}`);
+		const line = `[${timestamp}] [${logObj.type}] [${logObj.tag || name$1}]${message ? ` ${message}` : ""}`;
+		appendLine(filePath, line);
 	} });
 	return instance;
 };
@@ -2323,7 +2503,7 @@ const createResponses = async (payload, { vision, initiator }) => {
 const MESSAGE_TYPE = "message";
 const CODEX_PHASE_MODEL = "gpt-5.3-codex";
 const THINKING_TEXT = "Thinking...";
-const translateAnthropicMessagesToResponsesPayload = (payload) => {
+const translateAnthropicMessagesToResponsesPayload = (payload, effortOverride) => {
 	const input = [];
 	for (const message of payload.messages) input.push(...translateMessage(message, payload.model));
 	const translatedTools = convertAnthropicTools(payload.tools);
@@ -2345,7 +2525,7 @@ const translateAnthropicMessagesToResponsesPayload = (payload) => {
 		store: false,
 		parallel_tool_calls: true,
 		reasoning: {
-			effort: getReasoningEffortForModel(payload.model),
+			effort: getReasoningEffortForModel(payload.model, effortOverride),
 			summary: "detailed"
 		},
 		include: ["reasoning.encrypted_content"]
@@ -2646,8 +2826,9 @@ const mapResponsesStopReason = (response) => {
 const mapResponsesUsage = (response) => {
 	const inputTokens = response.usage?.input_tokens ?? 0;
 	const outputTokens = response.usage?.output_tokens ?? 0;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
 	return {
-		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 0),
+		input_tokens: inputTokens - (inputCachedTokens ?? 0),
 		output_tokens: outputTokens,
 		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
 	};
@@ -2663,9 +2844,10 @@ const parseUserId = (userId) => {
 	const userMatch = userId.match(/user_([^_]+)_account/);
 	const safetyIdentifier = userMatch ? userMatch[1] : null;
 	const sessionMatch = userId.match(/_session_(.+)$/);
+	const promptCacheKey = sessionMatch ? sessionMatch[1] : null;
 	return {
 		safetyIdentifier,
-		promptCacheKey: sessionMatch ? sessionMatch[1] : null
+		promptCacheKey
 	};
 };
 const convertToolResultContent = (content) => {
@@ -2747,11 +2929,11 @@ const handleOutputItemAdded$1 = (rawEvent, state$1) => {
 	const events$1 = new Array();
 	const functionCallDetails = extractFunctionCallDetails(rawEvent);
 	if (!functionCallDetails) return events$1;
-	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
+	const { outputIndex, toolCallId, name: name$1, initialArguments } = functionCallDetails;
 	const blockIndex = openFunctionCallBlock(state$1, {
 		outputIndex,
 		toolCallId,
-		name,
+		name: name$1,
 		events: events$1
 	});
 	if (initialArguments !== void 0 && initialArguments.length > 0) {
@@ -3044,15 +3226,16 @@ const buildErrorEvent = (message) => ({
 });
 const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
 const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
+	const { outputIndex, toolCallId, name: name$1, events: events$1 } = params;
 	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
 	if (!functionCallState) {
 		const blockIndex$1 = state$1.nextContentBlockIndex;
 		state$1.nextContentBlockIndex += 1;
+		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
 		functionCallState = {
 			blockIndex: blockIndex$1,
-			toolCallId: toolCallId ?? `tool_call_${blockIndex$1}`,
-			name: name ?? "function",
+			toolCallId: resolvedToolCallId,
+			name: name$1 ?? "function",
 			consecutiveWhitespaceCount: 0
 		};
 		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
@@ -3077,20 +3260,26 @@ const openFunctionCallBlock = (state$1, params) => {
 const extractFunctionCallDetails = (rawEvent) => {
 	const item = rawEvent.item;
 	if (item.type !== "function_call") return;
+	const outputIndex = rawEvent.output_index;
+	const toolCallId = item.call_id;
+	const name$1 = item.name;
+	const initialArguments = item.arguments;
 	return {
-		outputIndex: rawEvent.output_index,
-		toolCallId: item.call_id,
-		name: item.name,
-		initialArguments: item.arguments
+		outputIndex,
+		toolCallId,
+		name: name$1,
+		initialArguments
 	};
 };
 
 //#endregion
 //#region src/routes/responses/utils.ts
 const getResponsesRequestOptions = (payload) => {
+	const vision = hasVisionInput(payload);
+	const initiator = hasAgentInitiator(payload) ? "agent" : "user";
 	return {
-		vision: hasVisionInput(payload),
-		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+		vision,
+		initiator
 	};
 };
 const hasAgentInitiator = (payload) => {
@@ -3132,7 +3321,8 @@ const createMessages = async (payload, anthropicBetaHeader, options) => {
 		"X-Initiator": initiator
 	};
 	if (anthropicBetaHeader) {
-		const filteredBeta = anthropicBetaHeader.split(",").map((item) => item.trim()).filter((item) => item !== "claude-code-20250219").join(",");
+		const unsupportedBetas = new Set(["claude-code-20250219", "context-1m-2025-08-07"]);
+		const filteredBeta = anthropicBetaHeader.split(",").map((item) => item.trim()).filter((item) => !unsupportedBetas.has(item)).join(",");
 		if (filteredBeta) headers["anthropic-beta"] = filteredBeta;
 	} else if (payload.thinking?.budget_tokens) headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
 	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
@@ -3357,38 +3547,62 @@ async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
 	logger$1.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const requestedModel = anthropicPayload.model;
+	const { baseModel, reasoningEffort: suffixEffort } = parseModelSuffix(anthropicPayload.model);
+	anthropicPayload.model = normalizeModelName(baseModel);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
 	if (subagentMarker) logger$1.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
 	const isCompact = isCompactRequest(anthropicPayload);
 	const anthropicBeta = c.req.header("anthropic-beta");
 	logger$1.debug("Anthropic Beta header:", anthropicBeta);
-	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
-	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
-	if (isCompact) {
-		logger$1.debug("Is compact request:", isCompact);
-		if (shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
-	} else mergeToolResultForClaude(anthropicPayload);
+	applyModelVariantRouting(anthropicPayload, anthropicBeta);
+	if (isCompact) logger$1.debug("Is compact request:", isCompact);
+	else mergeToolResultForClaude(anthropicPayload);
 	if (state.manualApprove) await awaitApproval();
 	const selectedModel = state.models?.data.find((m) => m.id === anthropicPayload.model);
+	let apiType = "ChatCompletions";
+	if (shouldUseMessagesApi(selectedModel)) apiType = "Messages";
+	else if (shouldUseResponsesApi(selectedModel)) apiType = "Responses";
+	const bodyEffort = getBodyReasoningEffort(anthropicPayload);
+	const effectiveEffort = suffixEffort ?? bodyEffort;
+	setRequestContext(c, {
+		requestedModel,
+		model: anthropicPayload.model,
+		provider: apiType,
+		reasoningEffort: effectiveEffort
+	});
 	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
 		anthropicBetaHeader: anthropicBeta,
 		initiatorOverride,
-		selectedModel
+		selectedModel,
+		effortOverride: suffixEffort
+	});
+	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, {
+		initiatorOverride,
+		effortOverride: suffixEffort
 	});
-	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, initiatorOverride);
 	return await handleWithChatCompletions(c, anthropicPayload, initiatorOverride);
 }
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
 const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride) => {
-	let finalPayload = await applyReplacementsToPayload(translateToOpenAI(anthropicPayload));
-	finalPayload = {
-		...finalPayload,
-		model: normalizeModelName(finalPayload.model)
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const { payload: replacedPayload, appliedRules } = await applyReplacementsToPayload(openAIPayload);
+	const finalPayload = {
+		...replacedPayload,
+		model: normalizeModelName(replacedPayload.model)
 	};
+	if (appliedRules.length > 0) setRequestContext(c, { replacements: appliedRules });
+	try {
+		const selectedModel = state.models?.data.find((m) => m.id === finalPayload.model);
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(finalPayload, selectedModel);
+			setRequestContext(c, { inputTokens: tokenCount.input });
+		}
+	} catch {}
 	logger$1.debug("Translated OpenAI request payload:", JSON.stringify(finalPayload));
-	const response = isAzureOpenAIModel(finalPayload.model) && state.azureOpenAIConfig ? await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, finalPayload) : await createChatCompletions(finalPayload, { initiator: initiatorOverride });
+	const response = await createChatCompletions(finalPayload, { initiator: initiatorOverride });
 	if (isNonStreaming(response)) {
 		logger$1.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 		const anthropicResponse = translateToAnthropic(response);
@@ -3407,7 +3621,8 @@ const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride)
 			logger$1.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
-			const events$1 = translateChunkToAnthropicEvents(JSON.parse(rawEvent.data), streamState);
+			const chunk = JSON.parse(rawEvent.data);
+			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				logger$1.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
@@ -3418,8 +3633,9 @@ const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride)
 		}
 	});
 };
-const handleWithResponsesApi = async (c, anthropicPayload, initiatorOverride) => {
-	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+const handleWithResponsesApi = async (c, anthropicPayload, options) => {
+	const { initiatorOverride, effortOverride } = options ?? {};
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload, effortOverride);
 	logger$1.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const response = await createResponses(responsesPayload, {
@@ -3471,14 +3687,15 @@ const handleWithResponsesApi = async (c, anthropicPayload, initiatorOverride) =>
 	return c.json(anthropicResponse);
 };
 const handleWithMessagesApi = async (c, anthropicPayload, options) => {
-	const { anthropicBetaHeader, initiatorOverride, selectedModel } = options ?? {};
+	const { anthropicBetaHeader, initiatorOverride, selectedModel, effortOverride } = options ?? {};
 	for (const msg of anthropicPayload.messages) if (msg.role === "assistant" && Array.isArray(msg.content)) msg.content = msg.content.filter((block) => {
 		if (block.type !== "thinking") return true;
 		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
 	});
 	if (selectedModel?.capabilities.supports.adaptive_thinking) {
-		anthropicPayload.thinking = { type: "adaptive" };
-		anthropicPayload.output_config = { effort: getAnthropicEffortForModel(anthropicPayload.model) };
+		if (!anthropicPayload.thinking) anthropicPayload.thinking = { type: "adaptive" };
+		const clientEffort = anthropicPayload.output_config?.effort;
+		anthropicPayload.output_config = { effort: effortOverride ? getAnthropicEffortForModel(anthropicPayload.model, effortOverride) : clientEffort ?? getAnthropicEffortForModel(anthropicPayload.model) };
 	}
 	logger$1.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
 	const response = await createMessages(anthropicPayload, anthropicBetaHeader, { initiator: initiatorOverride });
@@ -3499,6 +3716,21 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 	logger$1.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
 	return c.json(response);
 };
+/**
+* Route to model variants based on client signals (1m context, fast mode).
+* Mutates the payload in place.
+*/
+function applyModelVariantRouting(payload, anthropicBeta) {
+	if (anthropicBeta?.includes("context-1m")) {
+		const candidate = `${payload.model}-1m`;
+		if (state.models?.data.some((m) => m.id === candidate)) payload.model = candidate;
+	}
+	if (payload.speed === "fast") {
+		const candidate = `${payload.model}-fast`;
+		if (state.models?.data.some((m) => m.id === candidate)) payload.model = candidate;
+		delete payload.speed;
+	}
+}
 const shouldUseResponsesApi = (selectedModel) => {
 	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
 };
@@ -3507,8 +3739,25 @@ const shouldUseMessagesApi = (selectedModel) => {
 };
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
-const getAnthropicEffortForModel = (model) => {
-	const reasoningEffort = getReasoningEffortForModel(model);
+/**
+* Extract reasoning effort info from the Anthropic request body for logging.
+* Claude Code sends effort as `output_config.effort` (low/medium/high/max)
+* and thinking mode as `thinking.type` (enabled/adaptive).
+* When effort is "high" (the default), Claude Code omits output_config.effort entirely.
+*/
+function getBodyReasoningEffort(payload) {
+	if (!payload.thinking && !payload.output_config?.effort) return void 0;
+	const parts = [];
+	const effort = payload.output_config?.effort ?? (payload.thinking ? "high" : void 0);
+	if (effort) parts.push(effort);
+	if (payload.thinking) {
+		parts.push(payload.thinking.type);
+		if (payload.thinking.budget_tokens) parts.push(`${payload.thinking.budget_tokens.toLocaleString()} budget`);
+	}
+	return parts.length > 0 ? parts.join(", ") : void 0;
+}
+const getAnthropicEffortForModel = (model, override) => {
+	const reasoningEffort = getReasoningEffortForModel(model, override);
 	if (reasoningEffort === "xhigh") return "max";
 	if (reasoningEffort === "none" || reasoningEffort === "minimal") return "low";
 	return reasoningEffort;
@@ -3597,19 +3846,10 @@ modelRoutes.get("/", async (c) => {
 			owned_by: model.vendor,
 			display_name: model.name
 		})) ?? [];
-		const azureModels = state.azureOpenAIDeployments?.map((deployment) => ({
-			id: deployment.id,
-			object: "model",
-			type: "model",
-			created: deployment.created,
-			created_at: (/* @__PURE__ */ new Date(deployment.created * 1e3)).toISOString(),
-			owned_by: deployment.owned_by,
-			display_name: `${deployment.deploymentName} (${deployment.model})`
-		})) ?? [];
-		const allModels = [...copilotModels, ...azureModels];
+		const virtualModels = state.models ? generateVirtualModels(state.models.data) : [];
 		return c.json({
 			object: "list",
-			data: allModels,
+			data: [...copilotModels, ...virtualModels],
 			has_more: false
 		});
 	} catch (error) {
@@ -3629,20 +3869,27 @@ replacementsRoute.get("/", async (c) => {
 replacementsRoute.post("/", async (c) => {
 	const body = await c.req.json();
 	if (!body.pattern) return c.json({ error: "Pattern is required" }, 400);
-	const rule = await addReplacement(body.pattern, body.replacement ?? "", body.isRegex ?? false, body.name);
+	const rule = await addReplacement(body.pattern, body.replacement ?? "", {
+		isRegex: body.isRegex ?? false,
+		name: body.name
+	});
 	return c.json(rule, 201);
 });
 replacementsRoute.delete("/:id", async (c) => {
-	if (!await removeReplacement(c.req.param("id"))) return c.json({ error: "Replacement not found or is a system rule" }, 404);
+	const id = c.req.param("id");
+	if (!await removeReplacement(id)) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json({ success: true });
 });
 replacementsRoute.patch("/:id", async (c) => {
-	const rule = await updateReplacement(c.req.param("id"), await c.req.json());
+	const id = c.req.param("id");
+	const body = await c.req.json();
+	const rule = await updateReplacement(id, body);
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
 replacementsRoute.patch("/:id/toggle", async (c) => {
-	const rule = await toggleReplacement(c.req.param("id"));
+	const id = c.req.param("id");
+	const rule = await toggleReplacement(id);
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
@@ -3692,12 +3939,36 @@ const handleItemId = (parsed, tracker) => {
 //#region src/routes/responses/handler.ts
 const logger = createHandlerLogger("responses-handler");
 const RESPONSES_ENDPOINT = "/responses";
+function isResponsesReasoningEffort(value) {
+	return value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+}
+function normalizeResponsesReasoning(payload, suffixEffort) {
+	const topLevelEffortRaw = payload.reasoningEffort ?? payload.reasoning_effort;
+	const topLevelEffort = isResponsesReasoningEffort(topLevelEffortRaw) ? topLevelEffortRaw : void 0;
+	if (topLevelEffort) payload.reasoning = payload.reasoning ? {
+		...payload.reasoning,
+		effort: payload.reasoning.effort ?? topLevelEffort
+	} : { effort: topLevelEffort };
+	delete payload.reasoningEffort;
+	delete payload.reasoning_effort;
+	if (suffixEffort) payload.reasoning = payload.reasoning ? {
+		...payload.reasoning,
+		effort: suffixEffort
+	} : { effort: suffixEffort };
+	return payload.reasoning?.effort ?? void 0;
+}
 const handleResponses = async (c) => {
 	await checkRateLimit(state);
 	const payload = await c.req.json();
+	const requestedModel = payload.model;
+	const { baseModel, reasoningEffort: suffixEffort } = parseModelSuffix(payload.model);
+	payload.model = baseModel;
+	const effectiveEffort = normalizeResponsesReasoning(payload, suffixEffort);
 	setRequestContext(c, {
-		provider: "Copilot (Responses)",
-		model: payload.model
+		requestedModel,
+		provider: "Responses",
+		model: payload.model,
+		reasoningEffort: effectiveEffort
 	});
 	logger.debug("Responses request payload:", JSON.stringify(payload));
 	useFunctionApplyPatch(payload);
@@ -3806,6 +4077,7 @@ usageRoute.get("/", async (c) => {
 //#endregion
 //#region src/server.ts
 const server = new Hono();
+server.use(apiKeyGuard);
 server.use(requestLogger);
 server.use(cors());
 server.use("*", createAuthMiddleware());
@@ -3825,8 +4097,13 @@ server.route("/v1/messages", messageRoutes);
 
 //#endregion
 //#region src/start.ts
+function getAllModelIds() {
+	const baseModelIds = state.models?.data.map((model) => model.id) ?? [];
+	const virtualModelIds = state.models ? generateVirtualModels(state.models.data).map((model) => model.id) : [];
+	return [...baseModelIds, ...virtualModelIds];
+}
 async function runServer(options) {
-	consola.info(`copilot-api v${version}`);
+	consola.info(`copilot-api v${package_default.version}`);
 	if (options.insecure) {
 		process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 		consola.warn("SSL certificate verification disabled (insecure mode)");
@@ -3844,6 +4121,9 @@ async function runServer(options) {
 	state.showToken = options.showToken;
 	state.debug = options.debug;
 	state.verbose = options.verbose;
+	state.apiKeyAuth = options.apiKeyAuth;
+	if (options.apiKeyAuth) consola.info("API key authentication enabled - unauthorized requests will be silently dropped");
+	if (options.host) consola.info(`Binding to host: ${options.host}`);
 	if (options.debug) consola.info("Debug mode enabled - raw HTTP requests will be logged");
 	await ensurePaths();
 	mergeConfigWithDefaults();
@@ -3854,12 +4134,9 @@ async function runServer(options) {
 	} else await setupGitHubToken();
 	await setupCopilotToken();
 	await cacheModels();
-	await setupAzureOpenAI();
-	const copilotModelIds = state.models?.data.map((model) => model.id) ?? [];
-	const azureModelIds = state.azureOpenAIDeployments?.map((deployment) => deployment.id) ?? [];
-	const allModelIds = [...copilotModelIds, ...azureModelIds];
+	const allModelIds = getAllModelIds();
 	consola.info(`Available models: \n${allModelIds.map((id) => `- ${id}`).join("\n")}`);
-	const serverUrl = `http://localhost:${options.port}`;
+	const serverUrl = `http://${options.host ?? "localhost"}:${options.port}`;
 	if (options.claudeCode) {
 		invariant(state.models, "Models should be loaded by now");
 		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
@@ -3892,9 +4169,21 @@ async function runServer(options) {
 	serve({
 		fetch: server.fetch,
 		port: options.port,
+		hostname: options.host,
 		bun: { idleTimeout: 255 }
 	});
 }
+/**
+* Resolve --api-key-auth value: use provided value, fall back to env, or error if flag used without value.
+*/
+function resolveApiKeyAuth(cliValue) {
+	if (cliValue === void 0) return void 0;
+	if (cliValue !== "" && cliValue !== "true") return cliValue;
+	const envValue = process.env.COPILOT_API_KEY_AUTH;
+	if (envValue) return envValue;
+	consola.error("--api-key-auth requires a value or COPILOT_API_KEY_AUTH environment variable");
+	process.exit(1);
+}
 const start = defineCommand({
 	meta: {
 		name: "start",
@@ -3966,6 +4255,14 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Log raw HTTP requests received by the server (headers, method, path)"
+		},
+		"api-key-auth": {
+			type: "string",
+			description: "API key for incoming request authentication. Requests with mismatched keys are silently dropped."
+		},
+		host: {
+			type: "string",
+			description: "Hostname/IP to bind the server to (e.g., 0.0.0.0 for all interfaces)"
 		}
 	},
 	run({ args }) {
@@ -3983,17 +4280,19 @@ const start = defineCommand({
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
 			insecure: args.insecure,
-			debug: args.debug
+			debug: args.debug,
+			apiKeyAuth: resolveApiKeyAuth(args["api-key-auth"]),
+			host: args.host
 		});
 	}
 });
 
 //#endregion
 //#region src/main.ts
-await runMain(defineCommand({
+const main = defineCommand({
 	meta: {
 		name: "copilot-api",
-		version,
+		version: package_default.version,
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
 	},
 	subCommands: {
@@ -4003,7 +4302,8 @@ await runMain(defineCommand({
 		debug,
 		config
 	}
-}));
+});
+await runMain(main);
 
 //#endregion
 export {  };