copilot-relay 0.2.7 → 0.3.1

package/README.md

@@ -33,9 +33,16 @@ 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
 retrieved context through a final model pass and returns Claude
-`server_tool_use` / `web_search_tool_result` blocks. Unknown API routes return
-`500` and log method, path, selected headers, and request payload to help
-implement compatible endpoints later.
+`server_tool_use` / `web_search_tool_result` blocks. The final pass keeps your
+other tools available, so the model can act on what it found in the same turn.
+
+Advertising WebSearch no longer costs streaming. The relay reads the model's
+response only as far as it takes to tell whether a search is coming, so a turn
+that never searches streams normally — which is most of them, since Claude Code
+offers the tool on every request.
+
+Unknown API routes return `500` and log method, path, selected headers, and
+request payload to help implement compatible endpoints later.
 
 Routing:
 
@@ -127,6 +134,7 @@ it is reachable:
 ```text
 copilot-relay 0.2.5
   process    running (pid 93744, up 1h 16m)
+  version    0.2.5
   listening  http://127.0.0.1:4142
   health     ok (9ms)
   models     gpt-5.6-sol[1m], claude-opus-5
@@ -135,6 +143,23 @@ copilot-relay 0.2.5
   config     ~/.copilot-relay/config.yaml (logLevel=info, thinkEffort=max)
 ```
 
+The first line is the CLI you invoked; the `version` row is the build the
+running daemon reports about itself. They differ after an upgrade that has not
+been restarted yet — the new CLI is installed, the old process is still
+serving — and `status` says so rather than letting the header imply the upgrade
+took effect:
+
+```text
+  version    0.2.6 — MISMATCH, 0.3.0 is installed
+  ...
+  The running relay is 0.2.6; 0.3.0 is installed.
+  Restart it to serve the installed version: copilot-relay restart
+```
+
+A mismatch does not change the exit code: the relay works, it is just not the
+build you installed. A daemon older than v0.3.1 does not report a version at
+all, which shows as `unknown`.
+
 `--deep` additionally sends a real request through Copilot. That is the only
 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`,

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 { readFileSync } from "node:fs";
 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 { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -708,6 +708,24 @@ const auth = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/version.ts
+const packageName = "copilot-relay";
+const readPackageVersion = () => {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		try {
+			const packageJsonPath = resolve(currentDir, "package.json");
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			if (packageJson.name === packageName && typeof packageJson.version === "string") return packageJson.version;
+		} catch {}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) return "unknown";
+		currentDir = parentDir;
+	}
+};
+const appVersion = readPackageVersion();
+
 //#endregion
 //#region src/lib/lifecycle.ts
 const execFileAsync = promisify(execFile);
@@ -772,7 +790,8 @@ const readRelayPidFileEntry = async () => {
 			host: payload.host,
 			pid,
 			port: payload.port,
-			startedAt: typeof payload.startedAt === "string" ? payload.startedAt : ""
+			startedAt: typeof payload.startedAt === "string" ? payload.startedAt : "",
+			...typeof payload.version === "string" && payload.version ? { version: payload.version } : {}
 		};
 	} catch {
 		return;
@@ -795,7 +814,8 @@ const writeRelayPidFile = async (config) => {
 		host: config.host,
 		pid: process.pid,
 		port: config.port,
-		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		version: appVersion
 	};
 	await fs.writeFile(paths.pidPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
 };
@@ -1759,24 +1779,6 @@ const validateUpstream = async (config, thinkEffort) => {
 	for (const model of getUpstreamModelIds()) await validateModelRequest(config, model, thinkEffort);
 };
 
-//#endregion
-//#region src/lib/version.ts
-const packageName = "copilot-relay";
-const readPackageVersion = () => {
-	let currentDir = dirname(fileURLToPath(import.meta.url));
-	while (true) {
-		try {
-			const packageJsonPath = resolve(currentDir, "package.json");
-			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-			if (packageJson.name === packageName && typeof packageJson.version === "string") return packageJson.version;
-		} catch {}
-		const parentDir = dirname(currentDir);
-		if (parentDir === currentDir) return "unknown";
-		currentDir = parentDir;
-	}
-};
-const appVersion = readPackageVersion();
-
 //#endregion
 //#region src/claude/utils.ts
 function mapOpenAIStopReasonToClaude(finishReason) {
@@ -2488,6 +2490,137 @@ const mergeWebSearchAndFinalResponse = (searchResponse, finalResponse) => ({
 	}
 });
 
+//#endregion
+//#region src/claude/web-search-stream.ts
+const isWebSearchName = (name, toolNameMapper, isWebSearchToolName) => !!name && isWebSearchToolName(toolNameMapper.toClaude(name));
+const chunkSettlesDecision = (chunk) => {
+	const choice = chunk.choices[0];
+	if (!choice) return false;
+	return choice.delta?.tool_calls?.some((call) => call.function?.name) === true || !!choice.finish_reason;
+};
+const chunkHasWebSearchCall = (chunk, toolNameMapper, isWebSearchToolName) => chunk.choices[0]?.delta?.tool_calls?.some((call) => isWebSearchName(call.function?.name, toolNameMapper, isWebSearchToolName)) ?? false;
+const accumulateChunks = (chunks) => {
+	const first = chunks[0];
+	const toolCalls = [];
+	let content = "";
+	let reasoning = "";
+	let finishReason = null;
+	let usage;
+	for (const chunk of chunks) {
+		if (chunk.usage) usage = chunk.usage;
+		const choice = chunk.choices[0];
+		if (!choice) continue;
+		if (typeof choice.delta?.content === "string") content += choice.delta.content;
+		const chunkReasoning = choice.delta?.reasoning_text ?? choice.delta?.reasoning_content;
+		if (typeof chunkReasoning === "string") reasoning += chunkReasoning;
+		if (choice.finish_reason) finishReason = choice.finish_reason;
+		for (const call of choice.delta?.tool_calls ?? []) {
+			const existing = toolCalls[call.index];
+			if (existing) {
+				existing.function.arguments += call.function?.arguments ?? "";
+				continue;
+			}
+			toolCalls[call.index] = {
+				id: call.id ?? `call_${call.index}`,
+				type: "function",
+				function: {
+					name: call.function?.name ?? "",
+					arguments: call.function?.arguments ?? ""
+				}
+			};
+		}
+	}
+	const collectedToolCalls = toolCalls.filter(Boolean);
+	return {
+		id: first?.id ?? "chat_stream_accumulated",
+		object: "chat.completion",
+		created: first?.created ?? 0,
+		model: first?.model ?? "",
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: content || null,
+				...reasoning ? { reasoning_text: reasoning } : {},
+				...collectedToolCalls.length > 0 ? { tool_calls: collectedToolCalls } : {}
+			},
+			finish_reason: finishReason ?? "stop"
+		}],
+		...usage ? { usage } : {}
+	};
+};
+const resolveWebSearchStreamDecision = async (stream, toolNameMapper, isWebSearchToolName, onChunk) => {
+	const buffered = [];
+	const iterator = stream[Symbol.asyncIterator]();
+	let sawWebSearch = false;
+	let settled = false;
+	let done = false;
+	let alreadyStreamed = false;
+	while (!settled) {
+		const next = await iterator.next();
+		if (next.done) {
+			done = true;
+			break;
+		}
+		const raw = next.value;
+		if (raw.data === "[DONE]") {
+			done = true;
+			break;
+		}
+		if (!raw.data) continue;
+		let chunk;
+		try {
+			chunk = JSON.parse(raw.data);
+		} catch {
+			continue;
+		}
+		buffered.push(chunk);
+		if (chunkHasWebSearchCall(chunk, toolNameMapper, isWebSearchToolName)) {
+			sawWebSearch = true;
+			settled = true;
+			break;
+		}
+		if (onChunk) {
+			await onChunk(chunk);
+			alreadyStreamed = true;
+		}
+		if (chunkSettlesDecision(chunk)) settled = true;
+	}
+	const rest = { async *[Symbol.asyncIterator]() {
+		if (done) return;
+		while (true) {
+			const next = await iterator.next();
+			if (next.done) return;
+			yield next.value;
+		}
+	} };
+	if (!sawWebSearch) return {
+		decision: {
+			kind: "streamed",
+			buffered: onChunk ? [] : buffered
+		},
+		rest,
+		alreadyStreamed
+	};
+	for await (const raw of rest) {
+		if (raw.data === "[DONE]") break;
+		if (!raw.data) continue;
+		try {
+			buffered.push(JSON.parse(raw.data));
+		} catch {
+			continue;
+		}
+	}
+	return {
+		decision: {
+			kind: "webSearch",
+			response: accumulateChunks(buffered)
+		},
+		rest: { async *[Symbol.asyncIterator]() {} },
+		alreadyStreamed
+	};
+};
+
 //#endregion
 //#region src/lib/tokenizer.ts
 const encodingMap = {
@@ -2716,6 +2849,65 @@ const eventsFromClaudeResponse = (response) => {
 	events$1.push({ type: "message_stop" });
 	return events$1;
 };
+const continuationEventsFromClaudeResponse = (response, state) => {
+	const events$1 = [];
+	if (state.contentBlockOpen) {
+		events$1.push({
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex += 1;
+		state.contentBlockOpen = false;
+		state.thinkingBlockOpen = false;
+	}
+	for (const block of response.content) {
+		const index = state.contentBlockIndex;
+		events$1.push({
+			type: "content_block_start",
+			index,
+			content_block: block
+		});
+		if (block.type === "text") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "text_delta",
+				text: block.text
+			}
+		});
+		else if (block.type === "thinking") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "thinking_delta",
+				thinking: block.thinking
+			}
+		});
+		else if (block.type === "tool_use" || block.type === "server_tool_use") events$1.push({
+			type: "content_block_delta",
+			index,
+			delta: {
+				type: "input_json_delta",
+				partial_json: JSON.stringify(block.input)
+			}
+		});
+		events$1.push({
+			type: "content_block_stop",
+			index
+		});
+		state.contentBlockIndex += 1;
+	}
+	events$1.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: response.stop_reason,
+			stop_sequence: response.stop_sequence
+		},
+		usage: { output_tokens: response.usage.output_tokens }
+	});
+	events$1.push({ type: "message_stop" });
+	return events$1;
+};
 const createQueuedClaudeStreamWriter = (write) => {
 	let pending = Promise.resolve();
 	return (event) => {
@@ -2732,7 +2924,8 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 	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 canStreamWebSearchDecision = shouldLetModelDecideWebSearch && !!writeEvent;
+	if (shouldLetModelDecideWebSearch && !canStreamWebSearchDecision) openAIPayload.stream = false;
 	const response = await createChatCompletions(config, openAIPayload, {
 		client: "claude",
 		requestedModel: claudePayload.model,
@@ -2742,8 +2935,31 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 		signal: requestSignal,
 		timeoutMs: config.upstreamTimeoutMs
 	});
-	if (isNonStreamingResponse(response)) {
-		const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(response, toolNameMapper) : void 0;
+	let decidedResponse;
+	let bufferedChunks = [];
+	let remainingStream;
+	const streamState = {
+		messageStartSent: false,
+		contentBlockIndex: 0,
+		contentBlockOpen: false,
+		thinkingBlockOpen: false,
+		toolCalls: {}
+	};
+	let streamedBeforeDecision = false;
+	if (canStreamWebSearchDecision && !isNonStreamingResponse(response)) {
+		const { decision, rest, alreadyStreamed } = await resolveWebSearchStreamDecision(response, toolNameMapper, isClaudeWebSearchToolName, async (chunk) => {
+			await writeClaudeStreamEvents(translateChunkToClaudeEvents(chunk, streamState, toolNameMapper), writeEvent);
+		});
+		streamedBeforeDecision = alreadyStreamed;
+		if (decision.kind === "webSearch") decidedResponse = decision.response;
+		else {
+			bufferedChunks = decision.buffered;
+			remainingStream = rest;
+		}
+	}
+	const effectiveResponse = decidedResponse ?? response;
+	if (isNonStreamingResponse(effectiveResponse)) {
+		const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(effectiveResponse, toolNameMapper) : void 0;
 		let claudeResponse;
 		if (webSearchToolCall) {
 			const search = await createClaudeWebSearchExecution(config, claudePayload, webSearchToolCall.query, {
@@ -2769,14 +2985,14 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 				}));
 				claudeResponse = mergeWebSearchAndFinalResponse(searchResponse, translateToClaude(finalResponse, toolNameMapper));
 			}
-		} else claudeResponse = translateToClaude(response, toolNameMapper);
+		} else claudeResponse = translateToClaude(effectiveResponse, toolNameMapper);
 		if (writeEvent) {
-			await writeClaudeStreamEvents(eventsFromClaudeResponse(claudeResponse), writeEvent);
+			await writeClaudeStreamEvents(streamedBeforeDecision ? continuationEventsFromClaudeResponse(claudeResponse, streamState) : 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", {
+	if (shouldLetModelDecideWebSearch && !canStreamWebSearchDecision) 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" }
 	}));
@@ -2784,14 +3000,9 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 		status: 502,
 		headers: { "content-type": "text/plain" }
 	}));
-	const streamState = {
-		messageStartSent: false,
-		contentBlockIndex: 0,
-		contentBlockOpen: false,
-		thinkingBlockOpen: false,
-		toolCalls: {}
-	};
-	for await (const rawEvent of response) {
+	for (const chunk of bufferedChunks) await writeClaudeStreamEvents(translateChunkToClaudeEvents(chunk, streamState, toolNameMapper), writeEvent);
+	const upstreamStream = remainingStream ?? effectiveResponse;
+	for await (const rawEvent of upstreamStream) {
 		if (rawEvent.data === "[DONE]") break;
 		if (!rawEvent.data) continue;
 		let chunk;
@@ -2933,7 +3144,10 @@ const createServer = (config) => {
 		name: "copilot-relay",
 		status: "ok"
 	}));
-	app.get("/healthz", (c) => c.json({ ok: true }));
+	app.get("/healthz", (c) => c.json({
+		ok: true,
+		version: appVersion
+	}));
 	app.on(["GET", "HEAD"], "/api/hello", (c) => c.body(null, 200));
 	app.route("/v1", claudeRoutes);
 	app.notFound(async (c) => {
@@ -3107,12 +3321,26 @@ const exitCodes = {
 const localProbeTimeoutMs = 5e3;
 const deepProbeTimeoutMs = 6e4;
 /**
+* True when the daemon is serving a different build than the invoked CLI.
+*
+* Pure and exported because it drives both the rendered warning and the
+* deliberate decision to leave the exit code at 0; both deserve direct
+* coverage. Undefined daemonVersion is not a mismatch - unknown is not
+* different, and claiming otherwise would warn on every pre-v0.3.1 daemon.
+*/
+const hasVersionMismatch = (status$1) => status$1.running && status$1.daemonVersion !== void 0 && status$1.daemonVersion !== status$1.version;
+/**
 * 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.
+*
+* A version mismatch stays 0 on purpose (#43). The relay works; it is just not
+* the build that was installed. Mapping it to 2 would overstate it and break
+* every scripted caller that treats non-zero as broken. It is surfaced in the
+* text instead.
 */
 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) => {
@@ -3135,7 +3363,9 @@ const renderStatus = (status$1) => {
 		lines.push("  process    not running", `  config     ${status$1.configPath} (logLevel=${status$1.logLevel}, thinkEffort=${status$1.thinkEffort})`, `  log        ${status$1.logPath}`, "", "  Start it with: copilot-relay start");
 		return lines;
 	}
-	lines.push(`  process    running (pid ${status$1.pid}, up ${formatUptime(status$1.startedAt)})`, `  listening  ${status$1.baseUrl}`);
+	lines.push(`  process    running (pid ${status$1.pid}, up ${formatUptime(status$1.startedAt)})`);
+	lines.push(status$1.daemonVersion === void 0 ? "  version    unknown (daemon predates version reporting — restart to report it)" : hasVersionMismatch(status$1) ? `  version    ${status$1.daemonVersion} — MISMATCH, ${status$1.version} is installed` : `  version    ${status$1.daemonVersion}`);
+	lines.push(`  listening  ${status$1.baseUrl}`);
 	const health = status$1.health;
 	lines.push(health?.ok ? `  health     ok (${health.ms}ms)` : `  health     FAILED${health?.detail ? ` — ${health.detail}` : ""}`);
 	lines.push(status$1.models?.length ? `  models     ${status$1.models.join(", ")}` : "  models     unavailable");
@@ -3143,6 +3373,7 @@ const renderStatus = (status$1) => {
 	else lines.push("  upstream   not checked (use --deep)");
 	lines.push(`  log        ${status$1.logPath}`, `  config     ${status$1.configPath} (logLevel=${status$1.logLevel}, thinkEffort=${status$1.thinkEffort})`);
 	if (status$1.health?.ok && status$1.deep && !status$1.deep.ok) lines.push("", "  The relay is listening but cannot reach Copilot.", "  Try: copilot-relay auth");
+	if (hasVersionMismatch(status$1)) lines.push("", `  The running relay is ${status$1.daemonVersion}; ${status$1.version} is installed.`, "  Restart it to serve the installed version: copilot-relay restart");
 	return lines;
 };
 const probe = async (url, init, timeoutMs) => {
@@ -3159,22 +3390,34 @@ const probe = async (url, init, timeoutMs) => {
 	};
 };
 const describeError = (error) => error instanceof Error ? error.name === "TimeoutError" ? "timed out" : error.message : String(error);
+/**
+* Probes /healthz, which also reports the daemon's own version.
+*
+* The version rides along on a probe `status` already makes, so asking what is
+* running costs nothing extra. Absent for a daemon older than v0.3.1, which is
+* itself informative, so it stays optional rather than defaulting to the
+* caller's version - that substitution is the bug. See #43.
+*/
 const checkHealth = async (baseUrl) => {
 	try {
-		const result = await probe(`${baseUrl}/healthz`, {}, localProbeTimeoutMs);
-		return result.ok ? {
-			ms: result.ms,
-			ok: true
-		} : {
-			detail: `http ${result.status}`,
-			ms: result.ms,
-			ok: false
+		const probeResult = await probe(`${baseUrl}/healthz`, {}, localProbeTimeoutMs);
+		const version = probeResult.body?.version;
+		return {
+			result: probeResult.ok ? {
+				ms: probeResult.ms,
+				ok: true
+			} : {
+				detail: `http ${probeResult.status}`,
+				ms: probeResult.ms,
+				ok: false
+			},
+			...typeof version === "string" && version ? { version } : {}
 		};
 	} catch (error) {
-		return {
+		return { result: {
 			detail: describeError(error),
 			ok: false
-		};
+		} };
 	}
 };
 const readModels = async (baseUrl) => {
@@ -3249,13 +3492,15 @@ const collectStatus = async (options) => {
 	};
 	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;
+	const models = health.result.ok ? await readModels(baseUrl) : [];
+	const deep = options.deep && health.result.ok ? await checkDeep(baseUrl, models[0] ?? appConfig.gptModel) : void 0;
+	const daemonVersion = health.version ?? relay.version;
 	return {
 		...base,
 		baseUrl,
+		...daemonVersion ? { daemonVersion } : {},
 		...deep ? { deep } : {},
-		health,
+		health: health.result,
 		models,
 		pid: relay.pid,
 		port: relay.port,