@ashsec/copilot-api 0.7.2 → 0.7.5

package/dist/main.js

@@ -15,7 +15,6 @@ 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
@@ -97,11 +96,16 @@ const GITHUB_APP_SCOPES = ["read:user"].join(" ");
 //#region src/lib/error.ts
 var HTTPError = class extends Error {
 	response;
-	constructor(message, response) {
+	requestPayload;
+	constructor(message, response, requestPayload) {
 		super(message);
 		this.response = response;
+		this.requestPayload = requestPayload;
 	}
 };
+function isContentFilterError(obj) {
+	return typeof obj === "object" && obj !== null && "error" in obj && typeof obj.error === "object" && obj.error?.code === "content_filter";
+}
 async function forwardError(c, error) {
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
@@ -113,6 +117,15 @@ async function forwardError(c, error) {
 			errorJson = errorText;
 		}
 		consola.error("HTTP error:", errorJson);
+		if (isContentFilterError(errorJson)) {
+			consola.box("CONTENT FILTER TRIGGERED");
+			consola.error("Full error response:");
+			console.log(JSON.stringify(errorJson, null, 2));
+			if (error.requestPayload) {
+				consola.error("Request payload that triggered the filter:");
+				console.log(JSON.stringify(error.requestPayload, null, 2));
+			}
+		}
 		return c.json({ error: {
 			message: errorText,
 			type: "error"
@@ -208,6 +221,75 @@ function getAzureDeploymentName(modelId) {
 	return modelId.slice(13);
 }
 
+//#endregion
+//#region src/lib/retry-fetch.ts
+const RETRY_DELAYS_MS = [
+	100,
+	200,
+	300
+];
+/**
+* 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",
+		"socket connection was closed unexpectedly",
+		"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 fast retry on transient failures
+* Retries with delays: 100ms, 200ms, 300ms (max ~600ms total wait)
+*/
+async function fetchWithRetry(input, init) {
+	const maxAttempts = RETRY_DELAYS_MS.length + 1;
+	let lastError;
+	let lastResponse;
+	for (let attempt = 0; attempt < maxAttempts; 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 < maxAttempts - 1) {
+			lastResponse = response;
+			const delayMs = RETRY_DELAYS_MS[attempt];
+			consola.warn(`HTTP ${response.status} (attempt ${attempt + 1}/${maxAttempts}), retrying in ${delayMs}ms`);
+			await sleep(delayMs);
+			continue;
+		}
+		return response;
+	} catch (error) {
+		lastError = error;
+		if (!isRetryableError(error) || attempt === maxAttempts - 1) throw error;
+		const delayMs = RETRY_DELAYS_MS[attempt];
+		consola.warn(`Fetch failed (attempt ${attempt + 1}/${maxAttempts}), 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";
@@ -219,7 +301,7 @@ async function createAzureOpenAIChatCompletions(config$1, payload) {
 		model: deploymentName,
 		...max_tokens != null && { max_completion_tokens: max_tokens }
 	};
-	const response = await fetch(`${config$1.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$1.apiKey,
@@ -229,7 +311,7 @@ async function createAzureOpenAIChatCompletions(config$1, payload) {
 	});
 	if (!response.ok) {
 		consola.error("Failed to create Azure OpenAI chat completions:", response);
-		throw new HTTPError("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();
@@ -240,7 +322,7 @@ async function createAzureOpenAIChatCompletions(config$1, payload) {
 const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
 async function getAzureOpenAIDeployments(config$1) {
 	try {
-		const response = await fetch(`${config$1.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
+		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"
 		} });
@@ -268,7 +350,7 @@ async function getAzureOpenAIDeployments(config$1) {
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
 	const url = `${copilotBaseUrl(state)}/models`;
-	const response = await fetch(url, { headers: copilotHeaders(state) });
+	const response = await fetchWithRetry(url, { headers: copilotHeaders(state) });
 	if (!response.ok) {
 		const errorBody = await response.text();
 		let errorDetails;
@@ -515,7 +597,8 @@ const checkUsage = defineCommand({
 //#region src/lib/auto-replace.ts
 const SYSTEM_REPLACEMENTS = [{
 	id: "system-anthropic-billing",
-	pattern: "x-anthropic-billing-header:[^\n]*\n?",
+	name: "Remove Anthropic billing header",
+	pattern: "x-anthropic-billing-header:[^\\n]*\\n?",
 	replacement: "",
 	isRegex: true,
 	enabled: true,
@@ -529,7 +612,7 @@ let isLoaded = false;
 async function loadReplacements() {
 	try {
 		const data = await fs.readFile(PATHS.REPLACEMENTS_CONFIG_PATH);
-		userReplacements = JSON.parse(data).filter((r) => !r.isSystem);
+		userReplacements = JSON.parse(data.toString()).filter((r) => !r.isSystem);
 		isLoaded = true;
 		consola.debug(`Loaded ${userReplacements.length} user replacement rules`);
 	} catch {
@@ -572,10 +655,11 @@ async function getUserReplacements() {
 /**
 * Add a new user replacement rule
 */
-async function addReplacement(pattern, replacement, isRegex = false) {
+async function addReplacement(pattern, replacement, isRegex = false, name) {
 	await ensureLoaded();
 	const rule = {
 		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		name,
 		pattern,
 		replacement,
 		isRegex,
@@ -604,6 +688,26 @@ async function removeReplacement(id) {
 	return true;
 }
 /**
+* Update an existing user replacement rule
+*/
+async function updateReplacement(id, updates) {
+	await ensureLoaded();
+	const rule = userReplacements.find((r) => r.id === id);
+	if (!rule) return null;
+	if (rule.isSystem) {
+		consola.warn("Cannot update system replacement rule");
+		return null;
+	}
+	if (updates.name !== void 0) rule.name = updates.name;
+	if (updates.pattern !== void 0) rule.pattern = updates.pattern;
+	if (updates.replacement !== void 0) rule.replacement = updates.replacement;
+	if (updates.isRegex !== void 0) rule.isRegex = updates.isRegex;
+	if (updates.enabled !== void 0) rule.enabled = updates.enabled;
+	await saveReplacements();
+	consola.info(`Updated replacement rule: ${rule.name || rule.id}`);
+	return rule;
+}
+/**
 * Toggle a replacement rule on/off
 */
 async function toggleReplacement(id) {
@@ -630,18 +734,32 @@ async function clearUserReplacements() {
 	consola.info("Cleared all user replacement rules");
 }
 /**
-* Apply a single replacement rule to text
+* Apply a single replacement rule to text and return info about whether it matched
 */
 function applyRule(text, rule) {
-	if (!rule.enabled) return text;
+	if (!rule.enabled) return {
+		result: text,
+		matched: false
+	};
 	if (rule.isRegex) try {
 		const regex = new RegExp(rule.pattern, "g");
-		return text.replace(regex, rule.replacement);
+		const result$1 = text.replace(regex, rule.replacement);
+		return {
+			result: result$1,
+			matched: result$1 !== text
+		};
 	} catch {
 		consola.warn(`Invalid regex pattern in rule ${rule.id}: ${rule.pattern}`);
-		return text;
+		return {
+			result: text,
+			matched: false
+		};
 	}
-	return text.split(rule.pattern).join(rule.replacement);
+	const result = text.split(rule.pattern).join(rule.replacement);
+	return {
+		result,
+		matched: result !== text
+	};
 }
 /**
 * Apply all replacement rules to text
@@ -649,11 +767,15 @@ function applyRule(text, rule) {
 async function applyReplacements(text) {
 	let result = text;
 	const allRules = await getAllReplacements();
+	const appliedRules = [];
 	for (const rule of allRules) {
-		const before = result;
-		result = applyRule(result, rule);
-		if (before !== result) consola.debug(`Applied replacement rule: ${rule.id}`);
+		const { result: newResult, matched } = applyRule(result, rule);
+		if (matched) {
+			result = newResult;
+			appliedRules.push(rule.name || rule.id);
+		}
 	}
+	if (appliedRules.length > 0) consola.info(`Replacements applied: ${appliedRules.join(", ")}`);
 	return result;
 }
 /**
@@ -690,8 +812,9 @@ function formatRule(rule, index) {
 	const status = rule.enabled ? "✓" : "✗";
 	const type = rule.isRegex ? "regex" : "string";
 	const system = rule.isSystem ? " [system]" : "";
+	const name = rule.name ? ` "${rule.name}"` : "";
 	const replacement = rule.replacement || "(empty)";
-	return `${index + 1}. [${status}] (${type})${system} "${rule.pattern}" → "${replacement}"`;
+	return `${index + 1}. [${status}] (${type})${system}${name} "${rule.pattern}" → "${replacement}"`;
 }
 async function listReplacements() {
 	const all = await getAllReplacements();
@@ -704,6 +827,14 @@ async function listReplacements() {
 	console.log();
 }
 async function addNewReplacement() {
+	const name = await consola.prompt("Name (optional, short description):", {
+		type: "text",
+		default: ""
+	});
+	if (typeof name === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
 	const matchType = await consola.prompt("Match type:", {
 		type: "select",
 		options: [{
@@ -737,8 +868,87 @@ async function addNewReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	const rule = await addReplacement(pattern, replacement, matchType === "regex");
-	consola.success(`Added rule: ${rule.id}`);
+	const rule = await addReplacement(pattern, replacement, matchType === "regex", name || void 0);
+	consola.success(`Added rule: ${rule.name || rule.id}`);
+}
+async function editExistingReplacement() {
+	const userRules = await getUserReplacements();
+	if (userRules.length === 0) {
+		consola.info("No user rules to edit.");
+		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 edit:", {
+		type: "select",
+		options
+	});
+	if (typeof selected === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const rule = userRules.find((r) => r.id === selected);
+	if (!rule) {
+		consola.error("Rule not found.");
+		return;
+	}
+	consola.info(`\nEditing rule: ${rule.name || rule.id}`);
+	consola.info("Press Enter to keep current value.\n");
+	const name = await consola.prompt("Name:", {
+		type: "text",
+		default: rule.name || ""
+	});
+	if (typeof name === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const matchType = await consola.prompt("Match type:", {
+		type: "select",
+		options: [{
+			label: "String (exact match)",
+			value: "string"
+		}, {
+			label: "Regex (regular expression)",
+			value: "regex"
+		}],
+		initial: rule.isRegex ? "regex" : "string"
+	});
+	if (typeof matchType === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const pattern = await consola.prompt("Pattern to match:", {
+		type: "text",
+		default: rule.pattern
+	});
+	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:", {
+		type: "text",
+		default: rule.replacement
+	});
+	if (typeof replacement === "symbol") {
+		consola.info("Cancelled.");
+		return;
+	}
+	const updated = await updateReplacement(selected, {
+		name: name || void 0,
+		pattern,
+		replacement,
+		isRegex: matchType === "regex"
+	});
+	if (updated) consola.success(`Updated rule: ${updated.name || updated.id}`);
+	else consola.error("Failed to update rule.");
 }
 async function removeExistingReplacement() {
 	const userRules = await getUserReplacements();
@@ -821,6 +1031,10 @@ async function mainMenu() {
 					label: "➕ Add new rule",
 					value: "add"
 				},
+				{
+					label: "✏️  Edit rule",
+					value: "edit"
+				},
 				{
 					label: "➖ Remove rule",
 					value: "remove"
@@ -851,6 +1065,9 @@ async function mainMenu() {
 			case "add":
 				await addNewReplacement();
 				break;
+			case "edit":
+				await editExistingReplacement();
+				break;
 			case "remove":
 				await removeExistingReplacement();
 				break;
@@ -1055,6 +1272,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 () => {
@@ -1294,7 +1589,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)
@@ -1316,28 +1611,45 @@ async function handleCompletion$1(c) {
 	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)) {
+		if (isNonStreaming(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.input });
+		}
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -1350,19 +1662,30 @@ async function handleCompletion$1(c) {
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
 	const response = await createChatCompletions(payload);
-	if (isNonStreaming$1(response)) {
+	if (isNonStreaming(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);
 		}
 	});
 }
-const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -1379,7 +1702,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)
@@ -1652,12 +1975,7 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 				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 }
-				}
+				stop_sequence: null
 			}
 		});
 		state$1.messageStartSent = true;
@@ -1739,6 +2057,9 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 			});
 			state$1.contentBlockOpen = false;
 		}
+		const inputTokens = chunk.usage?.prompt_tokens ?? 0;
+		const outputTokens = chunk.usage?.completion_tokens ?? 0;
+		const cachedTokens = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
 		events$1.push({
 			type: "message_delta",
 			delta: {
@@ -1746,9 +2067,10 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 				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 }
+				input_tokens: inputTokens,
+				output_tokens: outputTokens,
+				cache_creation_input_tokens: 0,
+				cache_read_input_tokens: cachedTokens
 			}
 		}, { type: "message_stop" });
 	}
@@ -1765,73 +2087,68 @@ async function handleCompletion(c) {
 	const openAIPayload = await applyReplacementsToPayload(translatedPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
-	if (isAzureOpenAIModel(openAIPayload.model)) {
+	const isAzureModel = isAzureOpenAIModel(openAIPayload.model);
+	if (isAzureModel) {
 		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		consola.info(`Routing to Azure OpenAI -> ${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));
-			const anthropicResponse = translateToAnthropic(response$1);
-			consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-			return c.json(anthropicResponse);
-		}
-		consola.debug("Streaming response from Azure OpenAI");
+		setRequestContext(c, {
+			provider: "Azure OpenAI",
+			model: openAIPayload.model
+		});
+	} else setRequestContext(c, {
+		provider: "Copilot",
+		model: openAIPayload.model
+	});
+	if (anthropicPayload.stream) {
+		const streamPayload = {
+			...openAIPayload,
+			stream: true,
+			stream_options: { include_usage: true }
+		};
+		const eventStream = isAzureModel ? await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, streamPayload) : await createChatCompletions(streamPayload);
 		return streamSSE(c, async (stream) => {
 			const streamState = {
 				messageStartSent: false,
-				contentBlockIndex: 0,
 				contentBlockOpen: false,
+				contentBlockIndex: 0,
 				toolCalls: {}
 			};
-			for await (const rawEvent of response$1) {
-				consola.debug("Azure OpenAI raw stream event:", JSON.stringify(rawEvent));
-				if (rawEvent.data === "[DONE]") break;
-				if (!rawEvent.data) continue;
-				const chunk = JSON.parse(rawEvent.data);
-				const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
-				for (const event of events$1) {
-					consola.debug("Translated Anthropic event:", JSON.stringify(event));
-					await stream.writeSSE({
-						event: event.type,
-						data: JSON.stringify(event)
+			for await (const event of eventStream) {
+				if (!event.data || event.data === "[DONE]") continue;
+				try {
+					const chunk = JSON.parse(event.data);
+					consola.debug("OpenAI chunk:", JSON.stringify(chunk));
+					const anthropicEvents = translateChunkToAnthropicEvents(chunk, streamState);
+					for (const anthropicEvent of anthropicEvents) {
+						consola.debug("Anthropic event:", JSON.stringify(anthropicEvent));
+						await stream.writeSSE({
+							event: anthropicEvent.type,
+							data: JSON.stringify(anthropicEvent)
+						});
+					}
+					if (chunk.usage) setRequestContext(c, {
+						inputTokens: chunk.usage.prompt_tokens,
+						outputTokens: chunk.usage.completion_tokens
 					});
+				} catch (error) {
+					consola.error("Failed to parse chunk:", error, event.data);
 				}
 			}
 		});
 	}
-	consola.info(`Routing to Copilot -> ${openAIPayload.model}`);
-	const response = await createChatCompletions(openAIPayload);
-	if (isNonStreaming(response)) {
-		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
-		const anthropicResponse = translateToAnthropic(response);
-		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-		return c.json(anthropicResponse);
-	}
-	consola.debug("Streaming response from Copilot");
-	return streamSSE(c, async (stream) => {
-		const streamState = {
-			messageStartSent: false,
-			contentBlockIndex: 0,
-			contentBlockOpen: false,
-			toolCalls: {}
-		};
-		for await (const rawEvent of response) {
-			consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
-			if (rawEvent.data === "[DONE]") break;
-			if (!rawEvent.data) continue;
-			const chunk = JSON.parse(rawEvent.data);
-			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
-			for (const event of events$1) {
-				consola.debug("Translated Anthropic event:", JSON.stringify(event));
-				await stream.writeSSE({
-					event: event.type,
-					data: JSON.stringify(event)
-				});
-			}
-		}
+	const nonStreamPayload = {
+		...openAIPayload,
+		stream: false
+	};
+	const response = isAzureModel ? await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, nonStreamPayload) : await createChatCompletions(nonStreamPayload);
+	consola.debug("Response from upstream:", 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);
 }
-const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -1898,7 +2215,7 @@ 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);
+	const rule = await addReplacement(body.pattern, body.replacement ?? "", body.isRegex ?? false, body.name);
 	return c.json(rule, 201);
 });
 replacementsRoute.delete("/:id", async (c) => {
@@ -1906,6 +2223,13 @@ replacementsRoute.delete("/:id", async (c) => {
 	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 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 id = c.req.param("id");
 	const rule = await toggleReplacement(id);
@@ -1948,7 +2272,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);