copilot-relay 0.0.9 → 0.1.0

package/README.md

@@ -45,6 +45,7 @@ Routing:
 npx copilot-relay@latest auth
 npx copilot-relay@latest start
 npx copilot-relay@latest restart
+npx copilot-relay@latest stop
 ```
 
 `start` writes `ANTHROPIC_BASE_URL` and a dummy `ANTHROPIC_AUTH_TOKEN` into `~/.claude/settings.json`.
@@ -92,6 +93,7 @@ The same folder stores `copilot_token.json` for the cached Copilot bearer token,
 copilot-relay auth
 copilot-relay start
 copilot-relay restart
+copilot-relay stop
 ```
 
 ## Logging

package/dist/main.js

@@ -8,6 +8,7 @@ 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 { createAdaptorServer } from "@hono/node-server";
@@ -868,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,
@@ -926,7 +931,7 @@ const buildHeaders = (provider, init, options, upstreamRequestId) => {
 	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) => {
@@ -946,9 +951,10 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 		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(`${provider.baseUrl}${path$1}`, {
+			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);
@@ -2471,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
@@ -2541,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) => ({
@@ -2556,94 +2661,25 @@ claudeRoutes.post("/messages", async (c) => {
 	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),
-			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 (!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);
@@ -2886,6 +2922,22 @@ const restart = defineCommand({
 	}
 });
 
+//#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(", ")}`);
+	}
+});
+
 //#endregion
 //#region src/main.ts
 await runMain(defineCommand({
@@ -2896,7 +2948,8 @@ await runMain(defineCommand({
 	subCommands: {
 		auth,
 		restart,
-		start
+		start,
+		stop
 	}
 }));