copilot-relay 0.2.5 → 0.2.7

package/README.md

@@ -24,6 +24,11 @@ Public API:
 - `POST /v1/messages/count_tokens`
 - `GET /v1/models`
 - `GET /healthz`
+- `GET|HEAD /api/hello`
+
+`/api/hello` is a static reachability probe Claude Code sends on startup and
+around real traffic. Like `/healthz` it never contacts Copilot, so it proves the
+relay is listening and nothing more.
 
 Claude WebSearch is bridge-managed: when the model selects the WebSearch tool,
 the relay executes Copilot `/responses` with `web_search_preview`, then sends the
@@ -135,8 +140,10 @@ check that proves the relay can actually serve Claude Code — a relay whose
 Copilot token expired an hour ago still answers `/healthz` and `/v1/models`,
 because neither contacts upstream. It is opt-in because it spends a few tokens.
 
-`--json` emits machine-readable output. Exit codes: `0` running, `1` not
-running, `2` running but the deep check failed.
+`--json` emits machine-readable output. Exit codes: `0` running and reachable,
+`1` not running, `2` running but not usable — the health probe failed, or
+`--deep` was requested and failed. `0` requires a live process *and* a passing
+health probe, so a relay that cannot answer `/healthz` never reports success.
 
 ## Logging
 

package/dist/main.js

@@ -7,11 +7,11 @@ import os from "node:os";
 import path, { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFile } from "node:child_process";
+import { createAdaptorServer } from "@hono/node-server";
 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";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -864,6 +864,27 @@ const isRelayPid = async (pid) => {
 	if (!command) return false;
 	return isRelayStartProcess(command, await getProcessCwd(pid));
 };
+/**
+* The relay serving `config.port`, or undefined if nothing is.
+*
+* Deliberately narrower than findRelayProcessIds: it never consults the global
+* process list. `stop` wants "any relay anywhere" so it can clean up strays;
+* `status` is asked about one configured relay, and answering with a different
+* one is worse than answering "not running" because it looks authoritative.
+*
+* Returns pid and address as a single coherent record, so a pid discovered one
+* way can never be printed next to an address taken from another.
+*/
+const findRelayOnPort = async (config) => {
+	const entry = await readRelayPidFileEntry();
+	if (entry && entry.port === config.port && isProcessAlive(entry.pid) && await isRelayPid(entry.pid)) return entry;
+	for (const pid of await getPortListenerPids(config.port)) if (await isRelayPid(pid)) return {
+		host: config.host,
+		pid,
+		port: config.port,
+		startedAt: ""
+	};
+};
 const findRelayProcessIds = async (config) => {
 	const candidates = /* @__PURE__ */ new Set();
 	const storedPid = await readRelayPidFile();
@@ -1487,6 +1508,7 @@ function getFinishReason(response, hasFunctionCalls) {
 //#region src/copilot/chat.ts
 const usesMaxCompletionTokens = (modelId) => modelId.startsWith("gpt-5");
 const continuePrefillPrompt$1 = "Continue the assistant response from the previous assistant message.";
+const continueAfterNonUserPrompt = "Continue based on the context above.";
 const maxUserLength = 64;
 const sanitizeReasoningEffortForModel = (_modelId, reasoningEffort) => {
 	return reasoningEffort ?? void 0;
@@ -1515,7 +1537,14 @@ const buildRequestPayload = (payload) => {
 };
 const normalizeFinalAssistantPrefill$1 = (payload) => {
 	const lastMessage = payload.messages.at(-1);
-	if (lastMessage?.role !== "assistant") return payload;
+	if (!lastMessage || lastMessage.role === "user") return payload;
+	if (lastMessage.role !== "assistant") return {
+		...payload,
+		messages: [...payload.messages, {
+			role: "user",
+			content: continueAfterNonUserPrompt
+		}]
+	};
 	const messages = [...payload.messages];
 	if (typeof lastMessage.content !== "string") {
 		messages.pop();
@@ -2414,10 +2443,10 @@ const getWebSearchResultText = (search) => {
 	].join("\n");
 };
 const createWebSearchResultContextMessage = (search) => ({
-	role: "system",
+	role: "user",
 	content: [
 		"Trusted bridge retrieval context: the assistant selected web_search, and copilot-relay executed it.",
-		"Use this context for the final answer. Do not describe it as user-provided or injected. Do not call web_search again.",
+		"Use this context to complete the request. Do not describe it as user-provided or injected.",
 		"If the user requested a specific output format, answer using only matching information from this context.",
 		"If the user asked for a URL only, output only that URL with no surrounding text.",
 		"",
@@ -2426,24 +2455,26 @@ const createWebSearchResultContextMessage = (search) => ({
 		getWebSearchResultText(search)
 	].join("\n")
 });
-const createFinalWebSearchPayload = (payload, search) => {
-	const messages = payload.messages.flatMap((message) => {
-		if (message.role === "tool") return [{
-			role: "developer",
-			content: ["Prior local tool result from the conversation:", String(message.content ?? "")].join("\n")
-		}];
-		if (message.tool_calls && message.tool_calls.length > 0) return message.content ? [{
-			...message,
-			tool_calls: void 0
-		}] : [];
-		return [message];
-	});
+const isWebSearchTool = (tool, toolNameMapper) => isClaudeWebSearchToolName(toolNameMapper.toClaude(tool.function.name));
+const removeWebSearchTool = (tools, toolNameMapper) => {
+	if (!tools || tools.length === 0) return;
+	const remaining = tools.filter((tool) => !isWebSearchTool(tool, toolNameMapper));
+	return remaining.length > 0 ? remaining : void 0;
+};
+const normalizeFinalToolChoice = (toolChoice, tools, toolNameMapper) => {
+	if (!tools || tools.length === 0) return;
+	if (toolChoice === "required") return "auto";
+	if (toolChoice && typeof toolChoice === "object" && isClaudeWebSearchToolName(toolNameMapper.toClaude(toolChoice.function.name))) return "auto";
+	return toolChoice;
+};
+const createFinalWebSearchPayload = (payload, search, toolNameMapper) => {
+	const tools = removeWebSearchTool(payload.tools, toolNameMapper);
 	return {
 		...payload,
 		stream: false,
-		tools: void 0,
-		tool_choice: void 0,
-		messages: [...messages, createWebSearchResultContextMessage(search)]
+		tools,
+		tool_choice: normalizeFinalToolChoice(payload.tool_choice, tools, toolNameMapper),
+		messages: [...payload.messages, createWebSearchResultContextMessage(search)]
 	};
 };
 const mergeWebSearchAndFinalResponse = (searchResponse, finalResponse) => ({
@@ -2723,7 +2754,7 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 			const searchResponse = createClaudeWebSearchResponse(search);
 			if (search.results.length === 0) claudeResponse = searchResponse;
 			else {
-				const finalResponse = await createChatCompletions(config, createFinalWebSearchPayload(openAIPayload, search), {
+				const finalResponse = await createChatCompletions(config, createFinalWebSearchPayload(openAIPayload, search, toolNameMapper), {
 					client: "claude",
 					requestedModel: claudePayload.model,
 					requestedThinkEffort: getClaudeRequestedThinkEffort(claudePayload),
@@ -2903,6 +2934,7 @@ const createServer = (config) => {
 		status: "ok"
 	}));
 	app.get("/healthz", (c) => c.json({ ok: true }));
+	app.on(["GET", "HEAD"], "/api/hello", (c) => c.body(null, 200));
 	app.route("/v1", claudeRoutes);
 	app.notFound(async (c) => {
 		const message = "Unsupported Claude API route";
@@ -2939,6 +2971,7 @@ const startServer = (config) => new Promise((resolve$1, reject) => {
 
 //#endregion
 //#region src/start.ts
+const canCloseConnections = (server) => typeof server.closeIdleConnections === "function" && typeof server.closeAllConnections === "function";
 async function startRelay(appConfig) {
 	appConfig ??= await readAppConfig();
 	setLogLevel(appConfig.logLevel);
@@ -2997,6 +3030,7 @@ async function startRelay(appConfig) {
 		applyRuntimeConfig(nextConfig);
 		log.info(`Config reloaded: logLevel=${nextConfig.logLevel} thinkEffort=${nextConfig.thinkEffort} upstreamTimeoutSeconds=${nextConfig.upstreamTimeoutSeconds}`);
 	});
+	const shutdownGraceMs = 2e3;
 	const shutdown = (signal) => {
 		log.info(`Received ${signal}; shutting down copilot-relay`);
 		server.close((error) => {
@@ -3005,6 +3039,13 @@ async function startRelay(appConfig) {
 				process.exitCode = 1;
 			}
 		});
+		if (canCloseConnections(server)) {
+			server.closeIdleConnections();
+			setTimeout(() => {
+				log.info("Grace period elapsed; closing remaining connections");
+				server.closeAllConnections();
+			}, shutdownGraceMs).unref();
+		}
 	};
 	process.once("SIGINT", shutdown);
 	process.once("SIGTERM", shutdown);
@@ -3054,14 +3095,26 @@ const restart = defineCommand({
 *
 * 2 is distinct from 1 on purpose: "running but broken" and "not running" call
 * for different responses - restart the service versus re-authenticate.
+*
+* A failed health probe is a 2, not a 0. Printing FAILED while exiting 0 would
+* make every scripted caller treat an unreachable relay as fine. See #34.
 */
 const exitCodes = {
-	deepCheckFailed: 2,
 	notRunning: 1,
+	notUsable: 2,
 	running: 0
 };
 const localProbeTimeoutMs = 5e3;
 const deepProbeTimeoutMs = 6e4;
+/**
+* Status to exit code. Pure, because this mapping is the contract every
+* scripted caller depends on and deserves direct coverage.
+*
+* 0 requires a live process *and* a passing health probe. Printing FAILED while
+* exiting 0 would make every scripted caller treat an unreachable relay as
+* fine. See #34.
+*/
+const resolveExitCode = (status$1) => !status$1.running ? exitCodes.notRunning : !status$1.health?.ok ? exitCodes.notUsable : status$1.deep && !status$1.deep.ok ? exitCodes.notUsable : exitCodes.running;
 const formatUptime = (startedAt) => {
 	if (!startedAt) return "unknown";
 	const started = Date.parse(startedAt);
@@ -3189,15 +3242,12 @@ const collectStatus = async (options) => {
 		thinkEffort: appConfig.thinkEffort,
 		version: appVersion
 	};
-	const pids = await findRelayProcessIds(readProxyConfig(appConfig));
-	if (pids.length === 0) return {
+	const relay = await findRelayOnPort(readProxyConfig(appConfig));
+	if (!relay) return {
 		...base,
 		running: false
 	};
-	const entry = await readRelayPidFileEntry();
-	const host = entry?.host ?? appConfig.host;
-	const port = entry?.port ?? appConfig.port;
-	const baseUrl = `http://${host}:${port}`;
+	const baseUrl = `http://${relay.host}:${relay.port}`;
 	const health = await checkHealth(baseUrl);
 	const models = health.ok ? await readModels(baseUrl) : [];
 	const deep = options.deep && health.ok ? await checkDeep(baseUrl, models[0] ?? appConfig.gptModel) : void 0;
@@ -3207,10 +3257,10 @@ const collectStatus = async (options) => {
 		...deep ? { deep } : {},
 		health,
 		models,
-		pid: entry?.pid ?? pids[0],
-		port,
+		pid: relay.pid,
+		port: relay.port,
 		running: true,
-		...entry?.startedAt ? { startedAt: entry.startedAt } : {}
+		...relay.startedAt ? { startedAt: relay.startedAt } : {}
 	};
 };
 const status = defineCommand({
@@ -3232,7 +3282,7 @@ const status = defineCommand({
 		const result = await collectStatus({ deep: Boolean(args.deep) });
 		if (args.json) console.log(JSON.stringify(result, null, 2));
 		else console.log(renderStatus(result).join("\n"));
-		process.exitCode = !result.running ? exitCodes.notRunning : result.deep && !result.deep.ok ? exitCodes.deepCheckFailed : exitCodes.running;
+		process.exitCode = resolveExitCode(result);
 	}
 });