@ashsec/copilot-api 0.7.0 → 0.7.4

package/dist/main.js

@@ -15,17 +15,18 @@ import { execSync } from "node:child_process";
 import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { logger } from "hono/logger";
 import { streamSSE } from "hono/streaming";
 
 //#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,
 	GITHUB_TOKEN_PATH,
-	AZURE_OPENAI_CONFIG_PATH
+	AZURE_OPENAI_CONFIG_PATH,
+	REPLACEMENTS_CONFIG_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
@@ -164,15 +165,15 @@ async function loadAzureOpenAIConfig() {
 		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 = JSON.parse(decoded);
-		if (!config.endpoint || !config.apiKey) return null;
-		return config;
+		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) {
-	const encoded = Buffer.from(JSON.stringify(config)).toString("base64");
+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");
@@ -192,12 +193,12 @@ async function promptAzureOpenAISetup() {
 		consola.warn("No API key provided, skipping Azure OpenAI setup");
 		return null;
 	}
-	const config = {
+	const config$1 = {
 		endpoint: endpoint.trim().replace(/\/$/, ""),
 		apiKey: apiKey.trim()
 	};
-	await saveAzureOpenAIConfig(config);
-	return config;
+	await saveAzureOpenAIConfig(config$1);
+	return config$1;
 }
 function isAzureOpenAIModel(modelId) {
 	return modelId.startsWith(AZURE_OPENAI_MODEL_PREFIX);
@@ -206,10 +207,74 @@ function getAzureDeploymentName(modelId) {
 	return modelId.slice(13);
 }
 
+//#endregion
+//#region src/lib/retry-fetch.ts
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 1e3;
+/**
+* Check if an error is retryable (transient network error)
+*/
+function isRetryableError(error) {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	const causeMessage = error.cause instanceof Error ? error.cause.message.toLowerCase() : "";
+	return [
+		"fetch failed",
+		"other side closed",
+		"connection reset",
+		"econnreset",
+		"socket hang up",
+		"etimedout",
+		"econnrefused",
+		"network error",
+		"aborted",
+		"timeout"
+	].some((pattern) => message.includes(pattern) || causeMessage.includes(pattern));
+}
+/**
+* Check if an HTTP response status is retryable
+*/
+function isRetryableStatus(status) {
+	return status === 408 || status === 429 || status >= 500 && status <= 599;
+}
+/**
+* Fetch with automatic retry on transient failures
+*/
+async function fetchWithRetry(input, init, options = {}) {
+	const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS } = options;
+	let lastError;
+	let lastResponse;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		const headers = new Headers(init?.headers);
+		headers.set("Connection", "close");
+		const response = await fetch(input, {
+			...init,
+			headers,
+			keepalive: false
+		});
+		if (isRetryableStatus(response.status) && attempt < maxRetries) {
+			lastResponse = response;
+			const delayMs = baseDelayMs * 2 ** attempt;
+			consola.warn(`HTTP ${response.status} (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delayMs}ms`);
+			await sleep(delayMs);
+			continue;
+		}
+		return response;
+	} catch (error) {
+		lastError = error;
+		if (!isRetryableError(error) || attempt === maxRetries) throw error;
+		const delayMs = baseDelayMs * 2 ** attempt;
+		consola.warn(`Fetch failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delayMs}ms:`, lastError.message);
+		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, payload) {
+async function createAzureOpenAIChatCompletions(config$1, payload) {
 	const deploymentName = getAzureDeploymentName(payload.model);
 	const { max_tokens,...restPayload } = payload;
 	const azurePayload = {
@@ -217,10 +282,10 @@ async function createAzureOpenAIChatCompletions(config, payload) {
 		model: deploymentName,
 		...max_tokens != null && { max_completion_tokens: max_tokens }
 	};
-	const response = await fetch(`${config.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
+	const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
 		method: "POST",
 		headers: {
-			"api-key": config.apiKey,
+			"api-key": config$1.apiKey,
 			"Content-Type": "application/json"
 		},
 		body: JSON.stringify(azurePayload)
@@ -236,10 +301,10 @@ async function createAzureOpenAIChatCompletions(config, payload) {
 //#endregion
 //#region src/services/azure-openai/get-models.ts
 const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
-async function getAzureOpenAIDeployments(config) {
+async function getAzureOpenAIDeployments(config$1) {
 	try {
-		const response = await fetch(`${config.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
-			"api-key": config.apiKey,
+		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) {
@@ -265,8 +330,20 @@ async function getAzureOpenAIDeployments(config) {
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
-	if (!response.ok) throw new HTTPError("Failed to get models", response);
+	const url = `${copilotBaseUrl(state)}/models`;
+	const response = await fetchWithRetry(url, { headers: copilotHeaders(state) });
+	if (!response.ok) {
+		const errorBody = await response.text();
+		let errorDetails;
+		try {
+			const parsed = JSON.parse(errorBody);
+			errorDetails = JSON.stringify(parsed, null, 2);
+		} catch {
+			errorDetails = errorBody || "(empty response)";
+		}
+		consola.error(`Failed to get models from ${url}\nStatus: ${response.status} ${response.statusText}\nResponse: ${errorDetails}`);
+		throw new HTTPError(`Failed to get models: ${response.status} ${response.statusText}`, response);
+	}
 	return await response.json();
 };
 
@@ -297,7 +374,16 @@ const sleep = (ms) => new Promise((resolve) => {
 });
 const isNullish = (value) => value === null || value === void 0;
 async function cacheModels() {
-	state.models = await getModels();
+	try {
+		state.models = await getModels();
+	} catch (error) {
+		consola.error("Failed to fetch and cache models. This could be due to:");
+		consola.error("  - Invalid or expired Copilot token");
+		consola.error("  - Network connectivity issues");
+		consola.error("  - GitHub Copilot service unavailable");
+		consola.error("  - Account type mismatch (try --account-type=individual or --account-type=business)");
+		throw error;
+	}
 }
 const cacheVSCodeVersion = async () => {
 	const response = await getVSCodeVersion();
@@ -305,16 +391,16 @@ const cacheVSCodeVersion = async () => {
 	consola.info(`Using VSCode version: ${response}`);
 };
 async function setupAzureOpenAI() {
-	let config = await loadAzureOpenAIConfig();
-	if (!config) config = await promptAzureOpenAISetup();
-	if (!config) {
+	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;
+	state.azureOpenAIConfig = config$1;
 	consola.info("Azure OpenAI configuration loaded");
 	try {
-		const deployments = await getAzureOpenAIDeployments(config);
+		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");
@@ -488,6 +574,377 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/auto-replace.ts
+const SYSTEM_REPLACEMENTS = [{
+	id: "system-anthropic-billing",
+	pattern: "x-anthropic-billing-header:[^\n]*\n?",
+	replacement: "",
+	isRegex: true,
+	enabled: true,
+	isSystem: true
+}];
+let userReplacements = [];
+let isLoaded = false;
+/**
+* Load user replacements from disk
+*/
+async function loadReplacements() {
+	try {
+		const data = await fs.readFile(PATHS.REPLACEMENTS_CONFIG_PATH);
+		userReplacements = JSON.parse(data).filter((r) => !r.isSystem);
+		isLoaded = true;
+		consola.debug(`Loaded ${userReplacements.length} user replacement rules`);
+	} catch {
+		userReplacements = [];
+		isLoaded = true;
+	}
+}
+/**
+* Save user replacements to disk
+*/
+async function saveReplacements() {
+	try {
+		await fs.writeFile(PATHS.REPLACEMENTS_CONFIG_PATH, JSON.stringify(userReplacements, null, 2), "utf8");
+		consola.debug(`Saved ${userReplacements.length} user replacement rules`);
+	} catch (error) {
+		consola.error("Failed to save replacement rules:", error);
+		throw error;
+	}
+}
+/**
+* Ensure replacements are loaded before accessing
+*/
+async function ensureLoaded() {
+	if (!isLoaded) await loadReplacements();
+}
+/**
+* Get all replacement rules (system + user)
+*/
+async function getAllReplacements() {
+	await ensureLoaded();
+	return [...SYSTEM_REPLACEMENTS, ...userReplacements];
+}
+/**
+* Get only user-configurable replacements
+*/
+async function getUserReplacements() {
+	await ensureLoaded();
+	return userReplacements;
+}
+/**
+* Add a new user replacement rule
+*/
+async function addReplacement(pattern, replacement, isRegex = false) {
+	await ensureLoaded();
+	const rule = {
+		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		pattern,
+		replacement,
+		isRegex,
+		enabled: true,
+		isSystem: false
+	};
+	userReplacements.push(rule);
+	await saveReplacements();
+	consola.info(`Added replacement rule: "${pattern}" -> "${replacement}"`);
+	return rule;
+}
+/**
+* Remove a user replacement rule by ID
+*/
+async function removeReplacement(id) {
+	await ensureLoaded();
+	const rule = userReplacements.find((r) => r.id === id);
+	if (!rule) return false;
+	if (rule.isSystem) {
+		consola.warn("Cannot remove system replacement rule");
+		return false;
+	}
+	userReplacements = userReplacements.filter((r) => r.id !== id);
+	await saveReplacements();
+	consola.info(`Removed replacement rule: ${id}`);
+	return true;
+}
+/**
+* Toggle a replacement rule on/off
+*/
+async function toggleReplacement(id) {
+	await ensureLoaded();
+	const userRule = userReplacements.find((r) => r.id === id);
+	if (userRule) {
+		userRule.enabled = !userRule.enabled;
+		await saveReplacements();
+		consola.info(`Toggled replacement rule ${id}: ${userRule.enabled ? "enabled" : "disabled"}`);
+		return userRule;
+	}
+	if (SYSTEM_REPLACEMENTS.find((r) => r.id === id)) {
+		consola.warn("Cannot toggle system replacement rule");
+		return null;
+	}
+	return null;
+}
+/**
+* Clear all user replacements
+*/
+async function clearUserReplacements() {
+	userReplacements = [];
+	await saveReplacements();
+	consola.info("Cleared all user replacement rules");
+}
+/**
+* Apply a single replacement rule to text
+*/
+function applyRule(text, rule) {
+	if (!rule.enabled) return text;
+	if (rule.isRegex) try {
+		const regex = new RegExp(rule.pattern, "g");
+		return text.replace(regex, rule.replacement);
+	} catch {
+		consola.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.pattern}`);
+		return text;
+	}
+	return text.split(rule.pattern).join(rule.replacement);
+}
+/**
+* Apply all replacement rules to text
+*/
+async function applyReplacements(text) {
+	let result = text;
+	const allRules = await getAllReplacements();
+	for (const rule of allRules) {
+		const before = result;
+		result = applyRule(result, rule);
+		if (before !== result) consola.debug(`Applied replacement rule: ${rule.id}`);
+	}
+	return result;
+}
+/**
+* Apply replacements to a chat completions payload
+* This modifies message content in place
+*/
+async function applyReplacementsToPayload(payload) {
+	const processedMessages = await Promise.all(payload.messages.map(async (message) => {
+		if (typeof message.content === "string") return {
+			...message,
+			content: await applyReplacements(message.content)
+		};
+		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)
+				};
+				return part;
+			}))
+		};
+		return message;
+	}));
+	return {
+		...payload,
+		messages: processedMessages
+	};
+}
+
+//#endregion
+//#region src/config.ts
+function formatRule(rule, index) {
+	const status = rule.enabled ? "✓" : "✗";
+	const type = rule.isRegex ? "regex" : "string";
+	const system = rule.isSystem ? " [system]" : "";
+	const replacement = rule.replacement || "(empty)";
+	return `${index + 1}. [${status}] (${type})${system} "${rule.pattern}" → "${replacement}"`;
+}
+async function listReplacements() {
+	const all = await getAllReplacements();
+	if (all.length === 0) {
+		consola.info("No replacement rules configured.");
+		return;
+	}
+	consola.info("\n📋 Replacement Rules:\n");
+	for (const [i, element] of all.entries()) console.log(formatRule(element, i));
+	console.log();
+}
+async function addNewReplacement() {
+	const matchType = await consola.prompt("Match type:", {
+		type: "select",
+		options: [{
+			label: "String (exact match)",
+			value: "string"
+		}, {
+			label: "Regex (regular expression)",
+			value: "regex"
+		}]
+	});
+	if (typeof matchType === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const pattern = await consola.prompt("Pattern to match:", { type: "text" });
+	if (typeof pattern === "symbol" || !pattern) {
+		consola.info("Cancelled.");
+		return;
+	}
+	if (matchType === "regex") try {
+		new RegExp(pattern);
+	} catch {
+		consola.error(`Invalid regex pattern: ${pattern}`);
+		return;
+	}
+	const replacement = await consola.prompt("Replacement text (leave empty to delete matches):", {
+		type: "text",
+		default: ""
+	});
+	if (typeof replacement === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const rule = await addReplacement(pattern, replacement, matchType === "regex");
+	consola.success(`Added rule: ${rule.id}`);
+}
+async function removeExistingReplacement() {
+	const userRules = await getUserReplacements();
+	if (userRules.length === 0) {
+		consola.info("No user rules to remove.");
+		return;
+	}
+	const options = userRules.map((rule, i) => ({
+		label: formatRule(rule, i),
+		value: rule.id
+	}));
+	const selected = await consola.prompt("Select rule to remove:", {
+		type: "select",
+		options
+	});
+	if (typeof selected === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	if (await removeReplacement(selected)) consola.success("Rule removed.");
+	else consola.error("Failed to remove rule.");
+}
+async function toggleExistingReplacement() {
+	const userRules = await getUserReplacements();
+	if (userRules.length === 0) {
+		consola.info("No user rules to toggle.");
+		return;
+	}
+	const options = userRules.map((rule$1, i) => ({
+		label: formatRule(rule$1, i),
+		value: rule$1.id
+	}));
+	const selected = await consola.prompt("Select rule to toggle:", {
+		type: "select",
+		options
+	});
+	if (typeof selected === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const rule = await toggleReplacement(selected);
+	if (rule) consola.success(`Rule ${rule.enabled ? "enabled" : "disabled"}.`);
+	else consola.error("Failed to toggle rule.");
+}
+async function testReplacements() {
+	const testText = await consola.prompt("Enter text to test replacements:", { type: "text" });
+	if (typeof testText === "symbol" || !testText) {
+		consola.info("Cancelled.");
+		return;
+	}
+	const result = await applyReplacements(testText);
+	consola.info("\n📝 Original:");
+	console.log(testText);
+	consola.info("\n✨ After replacements:");
+	console.log(result);
+	console.log();
+}
+async function clearAllReplacements() {
+	if (await consola.prompt("Are you sure you want to clear all user replacements?", {
+		type: "confirm",
+		initial: false
+	})) {
+		await clearUserReplacements();
+		consola.success("All user replacements cleared.");
+	} else consola.info("Cancelled.");
+}
+async function mainMenu() {
+	consola.info(`\n🔧 Copilot API - Replacement Configuration`);
+	consola.info(`Config file: ${PATHS.REPLACEMENTS_CONFIG_PATH}\n`);
+	let running = true;
+	while (running) {
+		const action = await consola.prompt("What would you like to do?", {
+			type: "select",
+			options: [
+				{
+					label: "📋 List all rules",
+					value: "list"
+				},
+				{
+					label: "➕ Add new rule",
+					value: "add"
+				},
+				{
+					label: "➖ Remove rule",
+					value: "remove"
+				},
+				{
+					label: "🔄 Toggle rule on/off",
+					value: "toggle"
+				},
+				{
+					label: "🧪 Test replacements",
+					value: "test"
+				},
+				{
+					label: "🗑️  Clear all user rules",
+					value: "clear"
+				},
+				{
+					label: "🚪 Exit",
+					value: "exit"
+				}
+			]
+		});
+		if (typeof action === "symbol") break;
+		switch (action) {
+			case "list":
+				await listReplacements();
+				break;
+			case "add":
+				await addNewReplacement();
+				break;
+			case "remove":
+				await removeExistingReplacement();
+				break;
+			case "toggle":
+				await toggleExistingReplacement();
+				break;
+			case "test":
+				await testReplacements();
+				break;
+			case "clear":
+				await clearAllReplacements();
+				break;
+			case "exit":
+				running = false;
+				break;
+			default: break;
+		}
+	}
+	consola.info("Goodbye! 👋");
+}
+const config = defineCommand({
+	meta: {
+		name: "config",
+		description: "Configure replacement rules interactively"
+	},
+	run: async () => {
+		await ensurePaths();
+		await mainMenu();
+	}
+});
+
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -661,6 +1118,84 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/request-logger.ts
+const REQUEST_CONTEXT_KEY = "requestContext";
+const colors = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	bold: "\x1B[1m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	red: "\x1B[31m",
+	magenta: "\x1B[35m",
+	blue: "\x1B[34m",
+	white: "\x1B[37m",
+	gray: "\x1B[90m"
+};
+/**
+* Get the current time formatted as HH:MM:SS
+*/
+function getTimeString() {
+	return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+}
+/**
+* Get status color based on HTTP status code
+*/
+function getStatusColor(status) {
+	if (status >= 500) return colors.red;
+	if (status >= 400) return colors.yellow;
+	if (status >= 300) return colors.cyan;
+	return colors.green;
+}
+/**
+* Set request context for logging
+*/
+function setRequestContext(c, ctx) {
+	const existing = c.get(REQUEST_CONTEXT_KEY);
+	if (existing) c.set(REQUEST_CONTEXT_KEY, {
+		...existing,
+		...ctx
+	});
+}
+/**
+* Custom request logger middleware
+*/
+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 });
+	await next();
+	const ctx = c.get(REQUEST_CONTEXT_KEY);
+	const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
+	const status = c.res.status;
+	const statusColor = getStatusColor(status);
+	const lines = [];
+	lines.push(`${colors.dim}${"─".repeat(60)}${colors.reset}`);
+	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("  ")}`);
+	}
+	lines.push(`  ${colors.dim}${getTimeString()}${colors.reset}`);
+	console.log(lines.join("\n"));
+}
+
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -900,7 +1435,7 @@ const createChatCompletions = async (payload) => {
 		...copilotHeaders(state, enableVision),
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
-	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
@@ -917,32 +1452,50 @@ const createChatCompletions = async (payload) => {
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
-	let payload = await c.req.json();
+	const rawPayload = await c.req.json();
+	let payload = await applyReplacementsToPayload(rawPayload);
 	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);
-		consola.info(`Routing to Azure OpenAI -> ${payload.model}`);
+		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);
 			}
 		});
 	}
-	consola.info(`Routing to Copilot -> ${payload.model}`);
+	setRequestContext(c, {
+		provider: "Copilot",
+		model: payload.model
+	});
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
 		if (selectedModel) {
 			const tokenCount = await getTokenCount(payload, selectedModel);
-			consola.info("Current token count:", tokenCount);
-		} else consola.warn("No model selected, skipping token count calculation");
+			setRequestContext(c, { inputTokens: tokenCount });
+		}
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -957,12 +1510,23 @@ async function handleCompletion$1(c) {
 	const response = await createChatCompletions(payload);
 	if (isNonStreaming$1(response)) {
 		consola.debug("Non-streaming response:", JSON.stringify(response));
+		if (response.usage) setRequestContext(c, {
+			inputTokens: response.usage.prompt_tokens,
+			outputTokens: response.usage.completion_tokens
+		});
 		return c.json(response);
 	}
 	consola.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		for await (const chunk of response) {
 			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);
 		}
 	});
@@ -984,7 +1548,7 @@ completionRoutes.post("/", async (c) => {
 //#region src/services/copilot/create-embeddings.ts
 const createEmbeddings = async (payload) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/embeddings`, {
 		method: "POST",
 		headers: copilotHeaders(state),
 		body: JSON.stringify(payload)
@@ -1366,15 +1930,23 @@ async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const translatedPayload = translateToOpenAI(anthropicPayload);
+	const openAIPayload = await applyReplacementsToPayload(translatedPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
 	if (isAzureOpenAIModel(openAIPayload.model)) {
 		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		consola.info(`Routing to Azure OpenAI -> ${openAIPayload.model}`);
+		setRequestContext(c, {
+			provider: "Azure OpenAI",
+			model: openAIPayload.model
+		});
 		const response$1 = await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, openAIPayload);
 		if (isNonStreaming(response$1)) {
 			consola.debug("Non-streaming response from Azure OpenAI:", JSON.stringify(response$1).slice(-400));
+			if (response$1.usage) setRequestContext(c, {
+				inputTokens: response$1.usage.prompt_tokens,
+				outputTokens: response$1.usage.completion_tokens
+			});
 			const anthropicResponse = translateToAnthropic(response$1);
 			consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 			return c.json(anthropicResponse);
@@ -1392,6 +1964,10 @@ async function handleCompletion(c) {
 				if (rawEvent.data === "[DONE]") break;
 				if (!rawEvent.data) continue;
 				const chunk = JSON.parse(rawEvent.data);
+				if (chunk.usage) setRequestContext(c, {
+					inputTokens: chunk.usage.prompt_tokens,
+					outputTokens: chunk.usage.completion_tokens
+				});
 				const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 				for (const event of events$1) {
 					consola.debug("Translated Anthropic event:", JSON.stringify(event));
@@ -1403,10 +1979,17 @@ async function handleCompletion(c) {
 			}
 		});
 	}
-	consola.info(`Routing to Copilot -> ${openAIPayload.model}`);
+	setRequestContext(c, {
+		provider: "Copilot",
+		model: openAIPayload.model
+	});
 	const response = await createChatCompletions(openAIPayload);
 	if (isNonStreaming(response)) {
 		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
+		if (response.usage) setRequestContext(c, {
+			inputTokens: response.usage.prompt_tokens,
+			outputTokens: response.usage.completion_tokens
+		});
 		const anthropicResponse = translateToAnthropic(response);
 		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 		return c.json(anthropicResponse);
@@ -1424,6 +2007,10 @@ async function handleCompletion(c) {
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
+			if (chunk.usage) setRequestContext(c, {
+				inputTokens: chunk.usage.prompt_tokens,
+				outputTokens: chunk.usage.completion_tokens
+			});
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				consola.debug("Translated Anthropic event:", JSON.stringify(event));
@@ -1490,6 +2077,37 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/routes/replacements/route.ts
+const replacementsRoute = new Hono();
+replacementsRoute.get("/", async (c) => {
+	return c.json({
+		all: await getAllReplacements(),
+		user: await getUserReplacements()
+	});
+});
+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);
+	return c.json(rule, 201);
+});
+replacementsRoute.delete("/:id", async (c) => {
+	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/toggle", async (c) => {
+	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);
+});
+replacementsRoute.delete("/", async (c) => {
+	await clearUserReplacements();
+	return c.json({ success: true });
+});
+
 //#endregion
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
@@ -1521,7 +2139,7 @@ usageRoute.get("/", async (c) => {
 //#endregion
 //#region src/server.ts
 const server = new Hono();
-server.use(logger());
+server.use(requestLogger);
 server.use(cors());
 server.get("/", (c) => c.text("Server running"));
 server.route("/chat/completions", completionRoutes);
@@ -1529,6 +2147,7 @@ server.route("/models", modelRoutes);
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
+server.route("/replacements", replacementsRoute);
 server.route("/v1/chat/completions", completionRoutes);
 server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
@@ -1537,6 +2156,10 @@ server.route("/v1/messages", messageRoutes);
 //#endregion
 //#region src/start.ts
 async function runServer(options) {
+	if (options.insecure) {
+		process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+		consola.warn("SSL certificate verification disabled (insecure mode)");
+	}
 	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
@@ -1656,6 +2279,11 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Initialize proxy from environment variables"
+		},
+		insecure: {
+			type: "boolean",
+			default: false,
+			description: "Disable SSL certificate verification (for corporate proxies with self-signed certs)"
 		}
 	},
 	run({ args }) {
@@ -1671,7 +2299,8 @@ const start = defineCommand({
 			githubToken: args["github-token"],
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
-			proxyEnv: args["proxy-env"]
+			proxyEnv: args["proxy-env"],
+			insecure: args.insecure
 		});
 	}
 });
@@ -1687,7 +2316,8 @@ const main = defineCommand({
 		auth,
 		start,
 		"check-usage": checkUsage,
-		debug
+		debug,
+		config
 	}
 });
 await runMain(main);