@ashsec/copilot-api 0.7.4 → 0.7.6

package/dist/main.js

@@ -48,7 +48,8 @@ const state = {
 	accountType: "individual",
 	manualApprove: false,
 	rateLimitWait: false,
-	showToken: false
+	showToken: false,
+	debug: false
 };
 
 //#endregion
@@ -96,11 +97,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) {
@@ -112,6 +118,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"
@@ -209,8 +224,11 @@ function getAzureDeploymentName(modelId) {
 
 //#endregion
 //#region src/lib/retry-fetch.ts
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_BASE_DELAY_MS = 1e3;
+const RETRY_DELAYS_MS = [
+	100,
+	200,
+	300
+];
 /**
 * Check if an error is retryable (transient network error)
 */
@@ -224,6 +242,7 @@ function isRetryableError(error) {
 		"connection reset",
 		"econnreset",
 		"socket hang up",
+		"socket connection was closed unexpectedly",
 		"etimedout",
 		"econnrefused",
 		"network error",
@@ -238,13 +257,14 @@ function isRetryableStatus(status) {
 	return status === 408 || status === 429 || status >= 500 && status <= 599;
 }
 /**
-* Fetch with automatic retry on transient failures
+* Fetch with automatic fast retry on transient failures
+* Retries with delays: 100ms, 200ms, 300ms (max ~600ms total wait)
 */
-async function fetchWithRetry(input, init, options = {}) {
-	const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS } = options;
+async function fetchWithRetry(input, init) {
+	const maxAttempts = RETRY_DELAYS_MS.length + 1;
 	let lastError;
 	let lastResponse;
-	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+	for (let attempt = 0; attempt < maxAttempts; attempt++) try {
 		const headers = new Headers(init?.headers);
 		headers.set("Connection", "close");
 		const response = await fetch(input, {
@@ -252,19 +272,19 @@ async function fetchWithRetry(input, init, options = {}) {
 			headers,
 			keepalive: false
 		});
-		if (isRetryableStatus(response.status) && attempt < maxRetries) {
+		if (isRetryableStatus(response.status) && attempt < maxAttempts - 1) {
 			lastResponse = response;
-			const delayMs = baseDelayMs * 2 ** attempt;
-			consola.warn(`HTTP ${response.status} (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delayMs}ms`);
+			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 === maxRetries) throw error;
-		const delayMs = baseDelayMs * 2 ** attempt;
-		consola.warn(`Fetch failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delayMs}ms:`, lastError.message);
+		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;
@@ -292,7 +312,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();
@@ -578,7 +598,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,
@@ -592,7 +613,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 {
@@ -635,10 +656,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,
@@ -667,6 +689,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) {
@@ -693,18 +735,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
@@ -712,11 +768,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;
 }
 /**
@@ -753,8 +813,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();
@@ -767,6 +828,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: [{
@@ -800,8 +869,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();
@@ -884,6 +1032,10 @@ async function mainMenu() {
 					label: "➕ Add new rule",
 					value: "add"
 				},
+				{
+					label: "✏️  Edit rule",
+					value: "edit"
+				},
 				{
 					label: "➖ Remove rule",
 					value: "remove"
@@ -914,6 +1066,9 @@ async function mainMenu() {
 			case "add":
 				await addNewReplacement();
 				break;
+			case "edit":
+				await editExistingReplacement();
+				break;
 			case "remove":
 				await removeExistingReplacement();
 				break;
@@ -1155,6 +1310,39 @@ function getStatusColor(status) {
 	return colors.green;
 }
 /**
+* Log raw HTTP request details (for debug mode)
+*/
+async function logRawRequest(c) {
+	const method = c.req.method;
+	const url = c.req.url;
+	const headers = Object.fromEntries(c.req.raw.headers.entries());
+	const lines = [];
+	lines.push(`${colors.magenta}${colors.bold}[DEBUG] Incoming Request${colors.reset}`);
+	lines.push(`${colors.cyan}${method}${colors.reset} ${url}`);
+	lines.push(`${colors.dim}Headers:${colors.reset}`);
+	for (const [key, value] of Object.entries(headers)) {
+		const displayValue = key.toLowerCase().includes("authorization") ? `${value.slice(0, 20)}...` : value;
+		lines.push(`  ${colors.gray}${key}:${colors.reset} ${displayValue}`);
+	}
+	if (method !== "GET" && method !== "HEAD") try {
+		const body = await c.req.raw.clone().text();
+		if (body) try {
+			const parsed = JSON.parse(body);
+			const sanitized = {};
+			for (const [key, value] of Object.entries(parsed)) if (key === "messages" || key === "prompt") sanitized[key] = `[${Array.isArray(value) ? value.length : 1} items omitted]`;
+			else sanitized[key] = value;
+			lines.push(`${colors.dim}Body (sanitized):${colors.reset}`);
+			lines.push(`  ${JSON.stringify(sanitized, null, 2).split("\n").join("\n  ")}`);
+		} catch {
+			lines.push(`${colors.dim}Body:${colors.reset} [${body.length} bytes]`);
+		}
+	} catch {
+		lines.push(`${colors.dim}Body:${colors.reset} [unable to read]`);
+	}
+	lines.push(`${colors.dim}${"─".repeat(60)}${colors.reset}`);
+	console.log(lines.join("\n"));
+}
+/**
 * Set request context for logging
 */
 function setRequestContext(c, ctx) {
@@ -1168,6 +1356,7 @@ function setRequestContext(c, ctx) {
 * Custom request logger middleware
 */
 async function requestLogger(c, next) {
+	if (state.debug) await logRawRequest(c);
 	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] : "");
@@ -1202,6 +1391,18 @@ const awaitApproval = async () => {
 	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
 };
 
+//#endregion
+//#region src/lib/model-resolver.ts
+/**
+* Normalize a model name by converting dashes to dots between numbers.
+* e.g., "claude-opus-4-5" -> "claude-opus-4.5"
+*       "gpt-4-1" -> "gpt-4.1"
+*       "gpt-5-1-codex" -> "gpt-5.1-codex"
+*/
+function normalizeModelName(model) {
+	return model.replace(/(\d)-(\d)/g, (_, p1, p2) => `${p1}.${p2}`);
+}
+
 //#endregion
 //#region src/lib/rate-limit.ts
 async function checkRateLimit(state$1) {
@@ -1454,6 +1655,10 @@ async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	const rawPayload = await c.req.json();
 	let payload = await applyReplacementsToPayload(rawPayload);
+	payload = {
+		...payload,
+		model: normalizeModelName(payload.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);
@@ -1463,7 +1668,7 @@ async function handleCompletion$1(c) {
 		});
 		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,
@@ -1494,7 +1699,7 @@ async function handleCompletion$1(c) {
 	try {
 		if (selectedModel) {
 			const tokenCount = await getTokenCount(payload, selectedModel);
-			setRequestContext(c, { inputTokens: tokenCount });
+			setRequestContext(c, { inputTokens: tokenCount.input });
 		}
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
@@ -1508,7 +1713,7 @@ 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,
@@ -1531,7 +1736,7 @@ async function handleCompletion$1(c) {
 		}
 	});
 }
-const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -1599,8 +1804,8 @@ function translateToOpenAI(payload) {
 	};
 }
 function translateModelName(model) {
-	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
-	else if (model.startsWith("claude-opus-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
+	if (model.match(/^claude-sonnet-4-\d{8}/)) return "claude-sonnet-4";
+	else if (model.match(/^claude-opus-4-\d{8}/)) return "claude-opus-4";
 	return model;
 }
 function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
@@ -1821,12 +2026,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;
@@ -1908,6 +2108,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: {
@@ -1915,9 +2118,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" });
 	}
@@ -1931,98 +2135,75 @@ async function handleCompletion(c) {
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const translatedPayload = translateToOpenAI(anthropicPayload);
-	const openAIPayload = await applyReplacementsToPayload(translatedPayload);
+	let openAIPayload = await applyReplacementsToPayload(translatedPayload);
+	openAIPayload = {
+		...openAIPayload,
+		model: normalizeModelName(openAIPayload.model)
+	};
 	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);
 		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);
-		}
-		consola.debug("Streaming response from Azure OpenAI");
+	} 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);
-				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));
-					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);
 				}
 			}
 		});
 	}
-	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);
-	}
-	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);
-			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));
-				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
@@ -2089,7 +2270,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) => {
@@ -2097,6 +2278,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);
@@ -2171,6 +2359,8 @@ async function runServer(options) {
 	state.rateLimitSeconds = options.rateLimit;
 	state.rateLimitWait = options.rateLimitWait;
 	state.showToken = options.showToken;
+	state.debug = options.debug;
+	if (options.debug) consola.info("Debug mode enabled - raw HTTP requests will be logged");
 	await ensurePaths();
 	await cacheVSCodeVersion();
 	if (options.githubToken) {
@@ -2284,6 +2474,12 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Disable SSL certificate verification (for corporate proxies with self-signed certs)"
+		},
+		debug: {
+			alias: "d",
+			type: "boolean",
+			default: false,
+			description: "Log raw HTTP requests received by the server (headers, method, path)"
 		}
 	},
 	run({ args }) {
@@ -2300,7 +2496,8 @@ const start = defineCommand({
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
-			insecure: args.insecure
+			insecure: args.insecure,
+			debug: args.debug
 		});
 	}
 });