copilot-relay 0.0.8 → 0.1.0

package/dist/main.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import fs from "node:fs/promises";
-import { inspect } from "node:util";
+import { inspect, promisify } from "node:util";
 import consola from "consola";
 import os from "node:os";
 import path, { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
+import { Agent, fetch as fetch$1 } from "undici";
 import { events } from "fetch-event-stream";
 import { readFileSync } from "node:fs";
-import { serve } from "@hono/node-server";
+import { createAdaptorServer } from "@hono/node-server";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -56,6 +58,7 @@ const copilotTokenPath = path.join(appDir, "copilot_token.json");
 const githubTokenPath = path.join(appDir, "github_token");
 const logsDir = path.join(appDir, "logs");
 const logPath = path.join(logsDir, "copilot-relay.log");
+const pidPath = path.join(appDir, "copilot-relay.pid");
 const paths = {
 	appDir,
 	configPath,
@@ -68,7 +71,8 @@ const paths = {
 	],
 	legacyCopilotTokenPaths,
 	logPath,
-	logsDir
+	logsDir,
+	pidPath
 };
 async function ensurePaths() {
 	await fs.mkdir(paths.appDir, { recursive: true });
@@ -167,7 +171,7 @@ const standardHeaders = () => ({
 	accept: "application/json",
 	"content-type": "application/json"
 });
-const sleep = (ms) => new Promise((resolve$1) => {
+const sleep$1 = (ms) => new Promise((resolve$1) => {
 	setTimeout(resolve$1, ms);
 });
 const readGitHubToken = async () => {
@@ -245,12 +249,12 @@ const pollAccessToken = async (deviceCode) => {
 			})
 		});
 		if (!response.ok) {
-			await sleep(sleepDuration);
+			await sleep$1(sleepDuration);
 			continue;
 		}
 		const json = await response.json();
 		if (json.access_token) return json.access_token;
-		await sleep(sleepDuration);
+		await sleep$1(sleepDuration);
 	}
 };
 const getGitHubUser = async (githubToken, vsCodeVersion) => {
@@ -627,6 +631,179 @@ const auth = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/lifecycle.ts
+const execFileAsync = promisify(execFile);
+const stopTimeoutMs = 5e3;
+const stopPollMs = 100;
+const isNodeErrno = (error) => typeof error === "object" && error !== null && "code" in error;
+const sleep = (ms) => new Promise((resolve$1) => {
+	setTimeout(resolve$1, ms);
+});
+const parsePid = (value) => {
+	const pid = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value.trim(), 10) : NaN;
+	return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+};
+const readCommandOutput = async (file, args) => {
+	try {
+		const { stdout } = await execFileAsync(file, args, {
+			maxBuffer: 1024 * 1024,
+			windowsHide: true
+		});
+		return String(stdout);
+	} catch (error) {
+		if (typeof error === "object" && error !== null && "stdout" in error && (typeof error.stdout === "string" || Buffer.isBuffer(error.stdout))) return String(error.stdout);
+		return "";
+	}
+};
+const parsePidLines = (output) => output.split(/\r?\n/).map((line) => parsePid(line)).filter((pid) => pid !== void 0);
+const isRelayStartProcess = (command, cwd) => {
+	const normalizedCommand = command.replaceAll("\\", "/");
+	const normalizedCwd = cwd?.replaceAll("\\", "/");
+	if (!/(?:^|\s)start(?:\s|$)/.test(normalizedCommand)) return false;
+	if (normalizedCommand.includes("copilot-relay")) return true;
+	const usesNode = /(?:^|\s|\/)node(?:\.exe)?(?:\s|$)/i.test(normalizedCommand);
+	const usesDistMain = /(?:^|\s|\/)dist\/main\.js(?:\s|$)/.test(normalizedCommand);
+	return Boolean(usesNode && usesDistMain && normalizedCwd && normalizedCwd.split("/").some((part) => part.includes("copilot-relay")));
+};
+const isProcessAlive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return isNodeErrno(error) && error.code === "EPERM";
+	}
+};
+const readRelayPidFile = async () => {
+	try {
+		const trimmed = (await fs.readFile(paths.pidPath, "utf8")).trim();
+		if (!trimmed) return;
+		if (trimmed.startsWith("{")) return parsePid(JSON.parse(trimmed).pid);
+		return parsePid(trimmed);
+	} catch (error) {
+		if (isNodeErrno(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const writeRelayPidFile = async (config) => {
+	await fs.mkdir(paths.appDir, { recursive: true });
+	const payload = {
+		host: config.host,
+		pid: process.pid,
+		port: config.port,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await fs.writeFile(paths.pidPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
+};
+const clearRelayPidFile = async (pid = process.pid, options = {}) => {
+	const currentPid = await readRelayPidFile();
+	if (!options.force && currentPid !== void 0 && currentPid !== pid) return;
+	await fs.unlink(paths.pidPath).catch((error) => {
+		if (!isNodeErrno(error) || error.code !== "ENOENT") throw error;
+	});
+};
+const getProcessCommand = async (pid) => {
+	if (process.platform === "win32") return (await readCommandOutput("powershell.exe", [
+		"-NoProfile",
+		"-Command",
+		`Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}" | Select-Object -ExpandProperty CommandLine`
+	])).trim() || void 0;
+	return (await readCommandOutput("ps", [
+		"-p",
+		String(pid),
+		"-o",
+		"command="
+	])).trim() || void 0;
+};
+const getProcessCwd = async (pid) => {
+	if (process.platform === "win32") return;
+	return (await readCommandOutput("lsof", [
+		"-a",
+		"-p",
+		String(pid),
+		"-d",
+		"cwd",
+		"-Fn"
+	])).split(/\r?\n/).find((line) => line.startsWith("n"))?.slice(1);
+};
+const getPortListenerPids = async (port) => {
+	if (process.platform === "win32") return parsePidLines(await readCommandOutput("powershell.exe", [
+		"-NoProfile",
+		"-Command",
+		`Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess -Unique`
+	]));
+	return parsePidLines(await readCommandOutput("lsof", [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:LISTEN",
+		"-t"
+	]));
+};
+const getProcessList = async () => {
+	return (process.platform === "win32" ? await readCommandOutput("powershell.exe", [
+		"-NoProfile",
+		"-Command",
+		"Get-CimInstance Win32_Process | ForEach-Object { \"$($_.ProcessId)`t$($_.CommandLine)\" }"
+	]) : await readCommandOutput("ps", ["-axo", "pid=,command="])).split(/\r?\n/).flatMap((line) => {
+		const match = process.platform === "win32" ? line.match(/^(\d+)\t(.+)$/) : line.match(/^\s*(\d+)\s+(.+)$/);
+		const pid = parsePid(match?.[1]);
+		const command = match?.[2]?.trim();
+		return pid && command ? [{
+			command,
+			pid
+		}] : [];
+	});
+};
+const isRelayPid = async (pid) => {
+	if (pid === process.pid || !isProcessAlive(pid)) return false;
+	const command = await getProcessCommand(pid);
+	if (!command) return false;
+	return isRelayStartProcess(command, await getProcessCwd(pid));
+};
+const findRelayProcessIds = async (config) => {
+	const candidates = /* @__PURE__ */ new Set();
+	const storedPid = await readRelayPidFile();
+	if (storedPid) candidates.add(storedPid);
+	for (const pid of await getPortListenerPids(config.port)) candidates.add(pid);
+	for (const { command, pid } of await getProcessList()) {
+		if (pid === process.pid) continue;
+		if (command.includes("copilot-relay") || command.includes("dist/main.js")) {
+			if (isRelayStartProcess(command, await getProcessCwd(pid))) candidates.add(pid);
+		}
+	}
+	const relayPids = [];
+	for (const pid of candidates) if (await isRelayPid(pid)) relayPids.push(pid);
+	return [...new Set(relayPids)].sort((left, right) => left - right);
+};
+const waitForExit = async (pid, timeoutMs) => {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (!isProcessAlive(pid)) return true;
+		await sleep(stopPollMs);
+	}
+	return !isProcessAlive(pid);
+};
+const stopProcess = async (pid) => {
+	if (!isProcessAlive(pid)) return;
+	log.info(`Stopping existing copilot-relay process pid=${pid}`);
+	process.kill(pid, "SIGTERM");
+	if (await waitForExit(pid, stopTimeoutMs)) return;
+	log.error(`copilot-relay process pid=${pid} did not stop; forcing termination`);
+	process.kill(pid, "SIGKILL");
+	if (!await waitForExit(pid, stopTimeoutMs)) throw new Error(`Could not stop copilot-relay process pid=${pid}`);
+};
+const stopExistingRelay = async (config) => {
+	const relayPids = await findRelayProcessIds(config);
+	if (relayPids.length === 0) {
+		log.info("No existing copilot-relay instance found");
+		await clearRelayPidFile(0, { force: true });
+		return [];
+	}
+	for (const pid of relayPids) await stopProcess(pid);
+	await clearRelayPidFile(0, { force: true });
+	return relayPids;
+};
+
 //#endregion
 //#region src/lib/claude-settings.ts
 /**
@@ -692,6 +869,10 @@ const userAgent = `GitHubCopilotChat/${copilotVersion}`;
 const apiVersion = "2025-04-01";
 const maxFetchAttempts = 2;
 const copilotRequestTimeoutMs = 18e4;
+const copilotDispatcher = new Agent({
+	allowH2: false,
+	connect: { allowH2: false }
+});
 const getCopilotProviderContext = (config) => ({
 	baseUrl: config.copilotBaseUrl,
 	token: config.copilotToken,
@@ -735,7 +916,7 @@ const readCopilotText = async (response, signal, timeoutMs = copilotRequestTimeo
 		throw toCopilotAbortHTTPError(error, signal, timeoutMs) ?? error;
 	}
 };
-const buildHeaders = (provider, init, options) => {
+const buildHeaders = (provider, init, options, upstreamRequestId) => {
 	const headers = new Headers(init.headers);
 	headers.set("authorization", `Bearer ${provider.token}`);
 	headers.set("copilot-integration-id", "vscode-chat");
@@ -744,36 +925,57 @@ const buildHeaders = (provider, init, options) => {
 	headers.set("user-agent", userAgent);
 	headers.set("openai-intent", "conversation-panel");
 	headers.set("x-github-api-version", apiVersion);
-	headers.set("x-request-id", randomUUID());
+	headers.set("x-request-id", upstreamRequestId);
 	headers.set("x-vscode-user-agent-library-version", "electron-fetch");
 	if (options.vision) headers.set("copilot-vision-request", "true");
 	if (options.initiator) headers.set("x-initiator", options.initiator);
 	if (!headers.has("content-type") && init.body !== void 0) headers.set("content-type", "application/json");
 	if (!headers.has("accept")) headers.set("accept", "application/json");
-	return headers;
+	return Object.fromEntries(headers.entries());
+};
+const formatRequestId = (requestId) => requestId ? `request_id=${requestId} ` : "";
+const logUpstreamLifecycle = (requestId, message) => {
+	if (requestId) {
+		log.info(`${formatRequestId(requestId)}${message}`);
+		return;
+	}
+	log.debug(message);
 };
 const fetchCopilot = async (provider, path$1, init, options = {}) => {
 	if (!provider.token) throw new ProxyNotImplementedError("Copilot token is not configured for copilot-relay.");
 	const timeoutMs = options.timeoutMs ?? copilotRequestTimeoutMs;
 	const signal = createCopilotRequestSignal(options.signal, timeoutMs);
 	let lastError;
-	for (let attempt = 1; attempt <= maxFetchAttempts; attempt++) try {
-		const started = performance.now();
-		const response = await fetch(`${provider.baseUrl}${path$1}`, {
-			...init,
-			headers: buildHeaders(provider, init, options),
-			signal
-		});
-		const ms = Math.round(performance.now() - started);
-		log.debug(`Copilot ${init.method ?? "GET"} ${path$1} -> ${response.status} ${ms}ms (attempt ${attempt})`);
-		if (!shouldRetryResponse(response) || attempt === maxFetchAttempts) return response;
-		log.error(`Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts})`);
-	} catch (error) {
-		const abortError = toCopilotAbortHTTPError(error, signal, timeoutMs);
-		if (abortError) throw abortError;
-		lastError = error;
-		if (attempt === maxFetchAttempts) throw error;
-		log.error(`Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts})`, error);
+	for (let attempt = 1; attempt <= maxFetchAttempts; attempt++) {
+		const upstreamRequestId = randomUUID();
+		try {
+			const started = performance.now();
+			logUpstreamLifecycle(options.requestId, `send upstream method=${init.method ?? "GET"} path=${path$1} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
+			const response = await fetch$1(`${provider.baseUrl}${path$1}`, {
+				...init,
+				headers: buildHeaders(provider, init, options, upstreamRequestId),
+				dispatcher: copilotDispatcher,
+				signal
+			});
+			const ms = Math.round(performance.now() - started);
+			logUpstreamLifecycle(options.requestId, `return from upstream method=${init.method ?? "GET"} path=${path$1} status=${response.status} ms=${ms} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
+			log.debug(`${formatRequestId(options.requestId)}Copilot ${init.method ?? "GET"} ${path$1} -> ${response.status} ${ms}ms (attempt ${attempt}) upstream_request_id=${upstreamRequestId}`);
+			if (!shouldRetryResponse(response) || attempt === maxFetchAttempts) return response;
+			log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`);
+		} catch (error) {
+			const abortError = toCopilotAbortHTTPError(error, signal, timeoutMs);
+			if (abortError) {
+				logUpstreamLifecycle(options.requestId, `upstream failed method=${init.method ?? "GET"} path=${path$1} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
+				throw abortError;
+			}
+			logUpstreamLifecycle(options.requestId, `upstream failed method=${init.method ?? "GET"} path=${path$1} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
+			lastError = error;
+			if (attempt === maxFetchAttempts) {
+				log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} request failed after ${attempt} attempts upstream_request_id=${upstreamRequestId}`, error);
+				throw error;
+			}
+			log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`, error);
+		}
 	}
 	throw lastError;
 };
@@ -1228,6 +1430,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		"Model request",
 		`client=${client}`,
 		`requested_model=${requestedModel}`,
+		...options.requestId ? [`request_id=${options.requestId}`] : [],
 		`upstream_model=${compatiblePayload.model}`,
 		`requested_think_effort=${requestedThinkEffort}`,
 		`requested_thinking=${requestedThinking}`,
@@ -1237,6 +1440,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	if (useResponsesApi) return createResponses(provider, compatiblePayload, {
 		vision: enableVision,
 		initiator,
+		requestId: options.requestId,
 		signal,
 		timeoutMs: options.timeoutMs
 	});
@@ -1250,6 +1454,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	}, {
 		vision: enableVision,
 		initiator,
+		requestId: options.requestId,
 		signal,
 		timeoutMs: options.timeoutMs
 	});
@@ -1257,13 +1462,15 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		if (await shouldRetryWithResponses(response, signal, options.timeoutMs)) return createResponses(provider, compatiblePayload, {
 			vision: enableVision,
 			initiator,
+			requestId: options.requestId,
 			signal,
 			timeoutMs: options.timeoutMs
 		});
 		throw new HTTPError("Failed to create chat completions", response, await logUpstreamError("Failed to create chat completions", response, {
 			model: payload.model,
 			request: requestPayload,
-			route: "/chat/completions"
+			route: "/chat/completions",
+			requestId: options.requestId
 		}, signal, options.timeoutMs));
 	}
 	if (compatiblePayload.stream) return events(response);
@@ -1281,13 +1488,15 @@ async function createResponses(provider, payload, options) {
 	}, {
 		vision: options.vision,
 		initiator: options.initiator,
+		requestId: options.requestId,
 		signal: options.signal,
 		timeoutMs: options.timeoutMs
 	});
 	if (!response.ok) throw new HTTPError("Failed to create responses", response, await logUpstreamError("Failed to create responses", response, {
 		model: payload.model,
 		request: requestPayload,
-		route: "/responses"
+		route: "/responses",
+		requestId: options.requestId
 	}, options.signal, options.timeoutMs));
 	if (payload.stream) return translateResponsesStreamToChatCompletionStream(events(response));
 	return translateResponsesToChatCompletion(await readCopilotJson(response, options.signal, options.timeoutMs));
@@ -1295,10 +1504,11 @@ async function createResponses(provider, payload, options) {
 async function logUpstreamError(message, response, context, signal, timeoutMs) {
 	const errorBody = await readCopilotText(response.clone(), signal, timeoutMs).catch(() => "");
 	const detail = getUpstreamErrorDetail(response, errorBody);
-	log.error(`${message}: route=${context.route} model=${context.model} status=${response.status}`, {
+	log.error(`${message}: route=${context.route} model=${context.model} status=${response.status}${context.requestId ? ` request_id=${context.requestId}` : ""}`, {
 		message,
 		route: context.route,
 		model: context.model,
+		requestId: context.requestId,
 		request: context.request,
 		response: {
 			status: response.status,
@@ -1993,6 +2203,7 @@ const createClaudeWebSearchExecution = async (config, payload, requestedQuery, o
 		body: JSON.stringify(buildWebSearchRequestPayload(payload, requestedQuery, backendModel))
 	}, {
 		initiator: "agent",
+		requestId: options.requestId,
 		signal,
 		timeoutMs: options.timeoutMs
 	});
@@ -2266,6 +2477,7 @@ const getTokenCount = async (payload, model) => {
 //#endregion
 //#region src/routes/claude.ts
 const claudeRoutes = new Hono();
+const streamKeepAliveIntervalMs = 15e3;
 const createTokenCountModel = (modelId) => ({
 	capabilities: { tokenizer: "o200k_base" },
 	id: modelId
@@ -2336,6 +2548,104 @@ const eventsFromClaudeResponse = (response) => {
 	events$1.push({ type: "message_stop" });
 	return events$1;
 };
+const createQueuedClaudeStreamWriter = (write) => {
+	let pending = Promise.resolve();
+	return (event) => {
+		pending = pending.then(() => write(event));
+		return pending;
+	};
+};
+const startClaudeStreamKeepAlive = (writeEvent) => {
+	const writePing = () => {
+		writeEvent({ type: "ping" }).catch(() => void 0);
+	};
+	writePing();
+	const timer = setInterval(writePing, streamKeepAliveIntervalMs);
+	if (typeof timer.unref === "function") timer.unref();
+	return () => {
+		clearInterval(timer);
+	};
+};
+const writeClaudeStreamEvents = async (events$1, writeEvent) => {
+	for (const event of events$1) await writeEvent(event);
+};
+const handleClaudeMessageRequest = async (config, claudePayload, requestSignal, requestId, writeEvent) => {
+	const upstreamModel = translateModelName(claudePayload.model);
+	const shouldLetModelDecideWebSearch = hasClaudeWebSearch(claudePayload);
+	const decisionPayload = shouldLetModelDecideWebSearch ? prepareClaudeWebSearchDecisionPayload(claudePayload) : claudePayload;
+	const toolNameMapper = createClaudeToolNameMapper(decisionPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
+	const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper);
+	if (shouldLetModelDecideWebSearch) openAIPayload.stream = false;
+	const response = await createChatCompletions(config, openAIPayload, {
+		client: "claude",
+		requestedModel: claudePayload.model,
+		requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
+		requestedThinking: getClaudeRequestedThinking(claudePayload),
+		requestId,
+		signal: requestSignal,
+		timeoutMs: config.upstreamTimeoutMs
+	});
+	if (isNonStreamingResponse(response)) {
+		const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(response, toolNameMapper) : void 0;
+		let claudeResponse;
+		if (webSearchToolCall) {
+			const search = await createClaudeWebSearchExecution(config, claudePayload, webSearchToolCall.query, {
+				requestId,
+				signal: requestSignal,
+				timeoutMs: config.upstreamTimeoutMs
+			});
+			const searchResponse = createClaudeWebSearchResponse(search);
+			if (search.results.length === 0) claudeResponse = searchResponse;
+			else {
+				const finalResponse = await createChatCompletions(config, createFinalWebSearchPayload(openAIPayload, search), {
+					client: "claude",
+					requestedModel: claudePayload.model,
+					requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
+					requestedThinking: getClaudeRequestedThinking(claudePayload),
+					requestId,
+					signal: requestSignal,
+					timeoutMs: config.upstreamTimeoutMs
+				});
+				if (!isNonStreamingResponse(finalResponse)) throw new HTTPError("Claude web search final answer request unexpectedly streamed", new Response("Claude web search final answer request unexpectedly streamed", {
+					status: 502,
+					headers: { "content-type": "text/plain" }
+				}));
+				claudeResponse = mergeWebSearchAndFinalResponse(searchResponse, translateToClaude(finalResponse, toolNameMapper));
+			}
+		} else claudeResponse = translateToClaude(response, toolNameMapper);
+		if (writeEvent) {
+			await writeClaudeStreamEvents(eventsFromClaudeResponse(claudeResponse), writeEvent);
+			return;
+		}
+		return claudeResponse;
+	}
+	if (shouldLetModelDecideWebSearch) throw new HTTPError("Claude web search model-decision request unexpectedly streamed", new Response("Claude web search model-decision request unexpectedly streamed", {
+		status: 502,
+		headers: { "content-type": "text/plain" }
+	}));
+	if (!writeEvent) throw new HTTPError("Claude non-streaming request unexpectedly streamed", new Response("Claude non-streaming request unexpectedly streamed", {
+		status: 502,
+		headers: { "content-type": "text/plain" }
+	}));
+	const streamState = {
+		messageStartSent: false,
+		contentBlockIndex: 0,
+		contentBlockOpen: false,
+		thinkingBlockOpen: false,
+		toolCalls: {}
+	};
+	for await (const rawEvent of response) {
+		if (rawEvent.data === "[DONE]") break;
+		if (!rawEvent.data) continue;
+		let chunk;
+		try {
+			chunk = JSON.parse(rawEvent.data);
+		} catch {
+			continue;
+		}
+		await writeClaudeStreamEvents(translateChunkToClaudeEvents(chunk, streamState, toolNameMapper), writeEvent);
+	}
+};
 claudeRoutes.get("/models", (c) => c.json({
 	object: "list",
 	data: getExposedModelIds().map((id) => ({
@@ -2347,94 +2657,29 @@ claudeRoutes.get("/models", (c) => c.json({
 }));
 claudeRoutes.post("/messages", async (c) => {
 	const config = c.get("config");
+	const requestId = c.get("requestId");
 	const claudePayload = await c.req.json();
 	const requestSignal = createCopilotRequestSignal(c.req.raw.signal, config.upstreamTimeoutMs);
 	log.debug("Full Claude request payload", { payload: claudePayload });
-	try {
-		const upstreamModel = translateModelName(claudePayload.model);
-		const shouldLetModelDecideWebSearch = hasClaudeWebSearch(claudePayload);
-		const decisionPayload = shouldLetModelDecideWebSearch ? prepareClaudeWebSearchDecisionPayload(claudePayload) : claudePayload;
-		const toolNameMapper = createClaudeToolNameMapper(decisionPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
-		const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper);
-		if (shouldLetModelDecideWebSearch) openAIPayload.stream = false;
-		const response = await createChatCompletions(config, openAIPayload, {
-			client: "claude",
-			requestedModel: claudePayload.model,
-			requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
-			requestedThinking: getClaudeRequestedThinking(claudePayload),
-			signal: requestSignal,
-			timeoutMs: config.upstreamTimeoutMs
-		});
-		if (isNonStreamingResponse(response)) {
-			const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(response, toolNameMapper) : void 0;
-			let claudeResponse;
-			if (webSearchToolCall) {
-				const search = await createClaudeWebSearchExecution(config, claudePayload, webSearchToolCall.query, {
-					signal: requestSignal,
-					timeoutMs: config.upstreamTimeoutMs
-				});
-				const searchResponse = createClaudeWebSearchResponse(search);
-				if (search.results.length === 0) claudeResponse = searchResponse;
-				else {
-					const finalResponse = await createChatCompletions(config, createFinalWebSearchPayload(openAIPayload, search), {
-						client: "claude",
-						requestedModel: claudePayload.model,
-						requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
-						requestedThinking: getClaudeRequestedThinking(claudePayload),
-						signal: requestSignal,
-						timeoutMs: config.upstreamTimeoutMs
-					});
-					if (!isNonStreamingResponse(finalResponse)) throw new HTTPError("Claude web search final answer request unexpectedly streamed", new Response("Claude web search final answer request unexpectedly streamed", {
-						status: 502,
-						headers: { "content-type": "text/plain" }
-					}));
-					claudeResponse = mergeWebSearchAndFinalResponse(searchResponse, translateToClaude(finalResponse, toolNameMapper));
-				}
-			} else claudeResponse = translateToClaude(response, toolNameMapper);
-			if (!claudePayload.stream) return c.json(claudeResponse);
-			return streamSSE(c, async (stream) => {
-				for (const event of eventsFromClaudeResponse(claudeResponse)) await stream.writeSSE({
-					event: event.type,
-					data: JSON.stringify(event)
-				});
-			});
-		}
-		if (shouldLetModelDecideWebSearch) throw new HTTPError("Claude web search model-decision request unexpectedly streamed", new Response("Claude web search model-decision request unexpectedly streamed", {
-			status: 502,
-			headers: { "content-type": "text/plain" }
+	if (claudePayload.stream) return streamSSE(c, async (stream) => {
+		const streamStarted = performance.now();
+		const writeEvent = createQueuedClaudeStreamWriter((event) => stream.writeSSE({
+			event: event.type,
+			data: JSON.stringify(event)
 		}));
-		return streamSSE(c, async (stream) => {
-			const streamState = {
-				messageStartSent: false,
-				contentBlockIndex: 0,
-				contentBlockOpen: false,
-				thinkingBlockOpen: false,
-				toolCalls: {}
-			};
-			try {
-				for await (const rawEvent of response) {
-					if (rawEvent.data === "[DONE]") break;
-					if (!rawEvent.data) continue;
-					let chunk;
-					try {
-						chunk = JSON.parse(rawEvent.data);
-					} catch {
-						continue;
-					}
-					for (const event of translateChunkToClaudeEvents(chunk, streamState, toolNameMapper)) await stream.writeSSE({
-						event: event.type,
-						data: JSON.stringify(event)
-					});
-				}
-			} catch (error) {
-				log.error("Error during Claude stream translation:", error);
-				const errorEvent = translateErrorToClaudeErrorEvent();
-				await stream.writeSSE({
-					event: errorEvent.type,
-					data: JSON.stringify(errorEvent)
-				});
-			}
-		});
+		const stopKeepAlive = startClaudeStreamKeepAlive(writeEvent);
+		try {
+			await handleClaudeMessageRequest(config, claudePayload, requestSignal, requestId, writeEvent);
+		} catch (error) {
+			log.error("Error during Claude stream request:", error);
+			await writeEvent(translateErrorToClaudeErrorEvent());
+		} finally {
+			stopKeepAlive();
+			log.info(`request_id=${requestId} stream completed ${Math.round(performance.now() - streamStarted)}ms`);
+		}
+	});
+	try {
+		return c.json(await handleClaudeMessageRequest(config, claudePayload, requestSignal, requestId));
 	} catch (error) {
 		if (error instanceof ProxyNotImplementedError) {
 			c.set("requestErrorMessage", error.message);
@@ -2498,25 +2743,35 @@ const getLoggedHeaders = (request) => Object.fromEntries(loggedRequestHeaders.fl
 	const value = request.headers.get(name);
 	return value ? [[name, value]] : [];
 }));
-const formatStatusLog = (method, path$1, status, ms, errorMessage) => {
-	const base = `${method} ${path$1} -> ${status} ${ms}ms`;
+const formatStatusLog = (requestId, method, path$1, status, ms, errorMessage) => {
+	const base = `request_id=${requestId} ${method} ${path$1} -> ${status} ${ms}ms`;
 	return status >= 400 && errorMessage ? `${base} error=${JSON.stringify(errorMessage)}` : base;
 };
 const createServer = (config) => {
 	const app = new Hono();
-	app.use("*", cors());
 	app.use("*", async (c, next) => {
+		const requestId = randomUUID();
 		c.set("config", config);
+		c.set("requestId", requestId);
+		c.header("x-copilot-relay-request-id", requestId);
+		log.info(`request_id=${requestId} request received method=${c.req.method} path=${c.req.path}`);
 		const started = performance.now();
 		try {
 			await next();
 		} finally {
 			const ms = Math.round(performance.now() - started);
-			log.info(formatStatusLog(c.req.method, c.req.path, c.res.status, ms, c.get("requestErrorMessage")));
+			log.info(formatStatusLog(requestId, c.req.method, c.req.path, c.res.status, ms, c.get("requestErrorMessage")));
 		}
 	});
+	app.use("*", cors());
 	app.onError((error, c) => {
 		c.set("requestErrorMessage", error.message);
+		log.error("Unhandled Claude API request error", {
+			method: c.req.method,
+			path: c.req.path,
+			requestId: c.get("requestId"),
+			error
+		});
 		return c.json({ error: { message: "Internal server error" } }, 500);
 	});
 	app.get("/", (c) => c.json({
@@ -2531,6 +2786,7 @@ const createServer = (config) => {
 		log.error("Unsupported Claude API request", {
 			method: c.req.method,
 			path: c.req.path,
+			requestId: c.get("requestId"),
 			headers: getLoggedHeaders(c.req.raw),
 			payload: await readRequestPayloadForLog(c.req.raw)
 		});
@@ -2538,79 +2794,147 @@ const createServer = (config) => {
 	});
 	return app;
 };
-const startServer = (config) => serve({
-	fetch: createServer(config).fetch,
-	hostname: config.host,
-	port: config.port
+const startServer = (config) => new Promise((resolve$1, reject) => {
+	const server = createAdaptorServer({
+		fetch: createServer(config).fetch,
+		hostname: config.host,
+		port: config.port
+	});
+	const onError = (error) => {
+		server.off("listening", onListening);
+		reject(error);
+	};
+	const onListening = () => {
+		server.off("error", onError);
+		resolve$1(server);
+	};
+	server.once("error", onError);
+	server.once("listening", onListening);
+	server.listen(config.port, config.host);
 });
 
 //#endregion
 //#region src/start.ts
+async function startRelay(appConfig) {
+	appConfig ??= await readAppConfig();
+	setLogLevel(appConfig.logLevel);
+	await cleanupLogs(appConfig.logRetentionDays);
+	const claudeConfigPath$1 = claudeConfigPath;
+	const config = readProxyConfig(appConfig);
+	const applyRuntimeConfig = (nextConfig) => {
+		setLogLevel(nextConfig.logLevel);
+		cleanupLogs(nextConfig.logRetentionDays);
+		runtimeState.debug = nextConfig.logLevel === "debug";
+		runtimeState.thinkEffort = nextConfig.thinkEffort;
+		config.copilotBaseUrl = nextConfig.copilotBaseUrl;
+		config.host = nextConfig.host;
+		config.port = nextConfig.port;
+		config.upstreamTimeoutMs = nextConfig.upstreamTimeoutSeconds * 1e3;
+		config.webSearchBackend = nextConfig.webSearchBackend;
+		runtimeState.modelRouting = {
+			gptModel: nextConfig.gptModel,
+			opusModel: nextConfig.opusModel
+		};
+	};
+	applyRuntimeConfig(appConfig);
+	log.info(`Log level: ${appConfig.logLevel}`);
+	log.info(`Think effort: ${appConfig.thinkEffort}`);
+	log.info(`Upstream timeout: ${appConfig.upstreamTimeoutSeconds}s`);
+	log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
+	const authSession = await setupProxyAuth(config);
+	try {
+		await validateUpstream(config, appConfig.thinkEffort);
+	} catch (error) {
+		log.error("Startup preflight failed:", error);
+		process.exit(1);
+	}
+	const server = await startServer(config);
+	await writeRelayPidFile(config);
+	log.info(`copilot-relay version: ${appVersion}`);
+	if (authSession.githubLogin) log.info(`GitHub user: ${authSession.githubLogin}`);
+	else log.error("GitHub user: unavailable");
+	log.info(`copilot-relay listening on http://${config.host}:${config.port}`);
+	log.info(`copilot base url: ${config.copilotBaseUrl}`);
+	const baseUrl = `http://${config.host}:${config.port}`;
+	if (appConfig.claudeSetup) try {
+		const claudeResult = await applyClaudeConfig({
+			baseUrl,
+			configPath: claudeConfigPath$1
+		});
+		if (claudeResult.changed) {
+			log.info(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
+			if (claudeResult.previousBaseUrl && claudeResult.previousBaseUrl !== baseUrl) log.info(`ANTHROPIC_BASE_URL: ${claudeResult.previousBaseUrl} → ${baseUrl}`);
+		} else log.info(`claude settings already up to date: ${claudeResult.configPath}`);
+	} catch (error) {
+		log.error(`Could not update claude settings (${claudeConfigPath$1}):`, error);
+	}
+	watchAppConfig((nextConfig) => {
+		applyRuntimeConfig(nextConfig);
+		log.info(`Config reloaded: logLevel=${nextConfig.logLevel} thinkEffort=${nextConfig.thinkEffort} upstreamTimeoutSeconds=${nextConfig.upstreamTimeoutSeconds}`);
+	});
+	const shutdown = (signal) => {
+		log.info(`Received ${signal}; shutting down copilot-relay`);
+		server.close((error) => {
+			if (error) {
+				log.error("Error while shutting down copilot-relay:", error);
+				process.exitCode = 1;
+			}
+		});
+	};
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	try {
+		await new Promise((resolve$1, reject) => {
+			server.on("close", resolve$1);
+			server.on("error", reject);
+		});
+	} finally {
+		process.off("SIGINT", shutdown);
+		process.off("SIGTERM", shutdown);
+		await clearRelayPidFile();
+	}
+}
 const start = defineCommand({
 	meta: {
 		name: "start",
 		description: "Start the copilot-relay HTTP server."
 	},
+	async run() {
+		await startRelay();
+	}
+});
+
+//#endregion
+//#region src/restart.ts
+const restart = defineCommand({
+	meta: {
+		name: "restart",
+		description: "Stop any existing copilot-relay instance and start a new one."
+	},
 	async run() {
 		const appConfig = await readAppConfig();
 		setLogLevel(appConfig.logLevel);
 		await cleanupLogs(appConfig.logRetentionDays);
-		const claudeConfigPath$1 = claudeConfigPath;
-		const config = readProxyConfig(appConfig);
-		const applyRuntimeConfig = (nextConfig) => {
-			setLogLevel(nextConfig.logLevel);
-			cleanupLogs(nextConfig.logRetentionDays);
-			runtimeState.debug = nextConfig.logLevel === "debug";
-			runtimeState.thinkEffort = nextConfig.thinkEffort;
-			config.copilotBaseUrl = nextConfig.copilotBaseUrl;
-			config.host = nextConfig.host;
-			config.port = nextConfig.port;
-			config.upstreamTimeoutMs = nextConfig.upstreamTimeoutSeconds * 1e3;
-			config.webSearchBackend = nextConfig.webSearchBackend;
-			runtimeState.modelRouting = {
-				gptModel: nextConfig.gptModel,
-				opusModel: nextConfig.opusModel
-			};
-		};
-		applyRuntimeConfig(appConfig);
-		log.info(`Log level: ${appConfig.logLevel}`);
-		log.info(`Think effort: ${appConfig.thinkEffort}`);
-		log.info(`Upstream timeout: ${appConfig.upstreamTimeoutSeconds}s`);
-		log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
-		const authSession = await setupProxyAuth(config);
-		try {
-			await validateUpstream(config, appConfig.thinkEffort);
-		} catch (error) {
-			log.error("Startup preflight failed:", error);
-			process.exit(1);
-		}
-		const server = startServer(config);
-		log.info(`copilot-relay version: ${appVersion}`);
-		if (authSession.githubLogin) log.info(`GitHub user: ${authSession.githubLogin}`);
-		else log.error("GitHub user: unavailable");
-		log.info(`copilot-relay listening on http://${config.host}:${config.port}`);
-		log.info(`copilot base url: ${config.copilotBaseUrl}`);
-		const baseUrl = `http://${config.host}:${config.port}`;
-		if (appConfig.claudeSetup) try {
-			const claudeResult = await applyClaudeConfig({
-				baseUrl,
-				configPath: claudeConfigPath$1
-			});
-			if (claudeResult.changed) {
-				log.info(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
-				if (claudeResult.previousBaseUrl && claudeResult.previousBaseUrl !== baseUrl) log.info(`ANTHROPIC_BASE_URL: ${claudeResult.previousBaseUrl} → ${baseUrl}`);
-			} else log.info(`claude settings already up to date: ${claudeResult.configPath}`);
-		} catch (error) {
-			log.error(`Could not update claude settings (${claudeConfigPath$1}):`, error);
-		}
-		watchAppConfig((nextConfig) => {
-			applyRuntimeConfig(nextConfig);
-			log.info(`Config reloaded: logLevel=${nextConfig.logLevel} thinkEffort=${nextConfig.thinkEffort} upstreamTimeoutSeconds=${nextConfig.upstreamTimeoutSeconds}`);
-		});
-		await new Promise((resolve$1, reject) => {
-			server.on("close", resolve$1);
-			server.on("error", reject);
-		});
+		const stopped = await stopExistingRelay(readProxyConfig(appConfig));
+		if (stopped.length > 0) log.info(`Stopped copilot-relay pid(s): ${stopped.join(", ")}`);
+		log.info("Starting copilot-relay");
+		await startRelay(appConfig);
+	}
+});
+
+//#endregion
+//#region src/stop.ts
+const stop = defineCommand({
+	meta: {
+		name: "stop",
+		description: "Stop all detected copilot-relay server instances."
+	},
+	async run() {
+		const appConfig = await readAppConfig();
+		setLogLevel(appConfig.logLevel);
+		await cleanupLogs(appConfig.logRetentionDays);
+		const stopped = await stopExistingRelay(readProxyConfig(appConfig));
+		if (stopped.length > 0) log.info(`Stopped copilot-relay pid(s): ${stopped.join(", ")}`);
 	}
 });
 
@@ -2623,7 +2947,9 @@ await runMain(defineCommand({
 	},
 	subCommands: {
 		auth,
-		start
+		restart,
+		start,
+		stop
 	}
 }));