copilot-relay 0.4.3 → 0.4.5

package/dist/main.js

@@ -3,6 +3,7 @@ import { defineCommand, runMain } from "citty";
 import fs from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
+import timers from "node:timers";
 import { inspect, isDeepStrictEqual, promisify } from "node:util";
 import consola from "consola";
 import os from "node:os";
@@ -268,7 +269,6 @@ const consoleSuppressed = new AsyncLocalStorage();
 const withoutLogging = (run) => loggingSuppressed.run(true, run);
 const withoutConsoleLogging = (run) => consoleSuppressed.run(true, run);
 let currentLogLevel = consolaLevelByName.info;
-const pendingLogWrites = /* @__PURE__ */ new Set();
 const registeredLogSecrets = /* @__PURE__ */ new Set();
 const logSecretForms = /* @__PURE__ */ new Set();
 let logSecretPattern;
@@ -320,9 +320,6 @@ const boundLogText = (value, maxBytes) => {
 	return bytes.subarray(0, end).toString("utf8") + truncatedMarker;
 };
 const isDebugLogging = () => currentLogLevel >= consolaLevelByName.debug;
-const flushLogs = async () => {
-	while (pendingLogWrites.size > 0) await Promise.all([...pendingLogWrites]);
-};
 const setLogLevel = (level) => {
 	currentLogLevel = consolaLevelByName[level];
 	consola.level = consolaLevelByName[level];
@@ -353,7 +350,7 @@ const ensurePrivateDirectory = async (directory) => {
 	});
 	const observed = await fs.lstat(directory);
 	if (!observed.isDirectory() || observed.isSymbolicLink()) throw new Error("Refusing an unsafe log directory");
-	if (process.platform === "win32") return;
+	if (process.platform === "win32") return observed;
 	const handle = await fs.open(directory, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
 	try {
 		const opened = await handle.stat();
@@ -362,12 +359,26 @@ const ensurePrivateDirectory = async (directory) => {
 	} finally {
 		await handle.close();
 	}
+	return observed;
 };
+const logDirectories = [paths.appDir, paths.logsDir];
 const ensureLogDirectory = async () => {
-	await ensurePrivateDirectory(paths.appDir);
-	await ensurePrivateDirectory(paths.logsDir);
-};
-const appendPrivateLog = async (filePath, content) => {
+	const checked = [];
+	for (const directory of logDirectories) checked.push(await ensurePrivateDirectory(directory));
+	return checked;
+};
+let logQueue = [];
+let logWriteChain = Promise.resolve();
+let activeLog;
+let logIdleClose;
+const maxLogWriteBytes = 256 * 1024;
+const hasMode = (stats, mode) => process.platform === "win32" || (stats.mode & 511) === mode;
+const isSameDirectory = (current, checked) => current !== void 0 && current.isDirectory() && sameFile$2(current, checked) && hasMode(current, 448);
+const isStillActive = async (active) => {
+	const [current, ...directories] = await Promise.all([active.filePath, ...logDirectories].map((target) => fs.lstat(target).catch(() => void 0)));
+	return current !== void 0 && current.isFile() && current.nlink === 1 && sameFile$2(current, active.identity) && hasMode(current, 384) && active.directories.every((checked, index) => isSameDirectory(directories[index], checked));
+};
+const openPrivateLog = async (filePath, directories) => {
 	const observed = await fs.lstat(filePath).catch((error) => {
 		if (!isMissing$1(error)) throw error;
 	});
@@ -379,28 +390,88 @@ const appendPrivateLog = async (filePath, content) => {
 		const current = await fs.lstat(filePath);
 		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || !sameFile$2(opened, current) || observed && !sameFile$2(observed, opened)) throw new Error("Log file changed while opening");
 		if (process.platform !== "win32") await handle.chmod(384);
-		await handle.appendFile(content);
-	} finally {
-		await handle.close();
+		return {
+			filePath,
+			handle,
+			identity: opened,
+			directories
+		};
+	} catch (error) {
+		await handle.close().catch(() => void 0);
+		throw error;
 	}
 };
-/**
-* Appends one already-rendered entry.
-*
-* Takes strings rather than raw values: rendering happens once in wrapFileLog,
-* so the console and the file are guaranteed to carry the same redacted text.
-* Inspecting again here would reintroduce the gap this closes - the file would
-* be scrubbed while the console showed the original object. See #47.
-*/
-const writeLogFile = async (level, values) => {
-	await ensureLogDirectory();
-	await cleanupLogsIfDue();
-	const line = [
-		(/* @__PURE__ */ new Date()).toISOString(),
-		level,
-		values.join(" ")
-	].join(" ");
-	await appendPrivateLog(getLogPath(), `${line}\n`);
+const closeActiveLog = async () => {
+	const closing = activeLog;
+	activeLog = void 0;
+	await closing?.handle.close().catch(() => void 0);
+};
+const logIdleCloseMs = 1e3;
+const scheduleLogIdleClose = () => {
+	timers.clearTimeout(logIdleClose);
+	logIdleClose = timers.setTimeout(() => {
+		logWriteChain = logWriteChain.then(closeActiveLog);
+	}, logIdleCloseMs);
+	logIdleClose.unref();
+};
+const openActiveLog = async (filePath) => {
+	if (activeLog?.filePath === filePath && await isStillActive(activeLog)) return activeLog.handle;
+	await closeActiveLog();
+	activeLog = await openPrivateLog(filePath, await ensureLogDirectory());
+	return activeLog.handle;
+};
+const appendLogLines = async (filePath, lines) => {
+	const handle = await openActiveLog(filePath);
+	let chunk = "";
+	let chunkBytes = 0;
+	for (const line of lines) {
+		const lineBytes = Buffer.byteLength(line);
+		if (chunk !== "" && chunkBytes + lineBytes > maxLogWriteBytes) {
+			await handle.appendFile(chunk);
+			chunk = "";
+			chunkBytes = 0;
+		}
+		chunk += line;
+		chunkBytes += lineBytes;
+	}
+	await handle.appendFile(chunk);
+};
+const drainLogQueue = async () => {
+	const entries = logQueue;
+	logQueue = [];
+	await cleanupLogsIfDue().catch(() => void 0);
+	const groups = [];
+	for (const entry of entries) {
+		const last = groups.at(-1);
+		if (last?.filePath === entry.filePath) last.lines.push(entry.line);
+		else groups.push({
+			filePath: entry.filePath,
+			lines: [entry.line]
+		});
+	}
+	for (const group of groups) try {
+		await appendLogLines(group.filePath, group.lines);
+	} catch {
+		await closeActiveLog();
+	}
+	scheduleLogIdleClose();
+};
+const queueLogEntry = (entry) => {
+	logQueue.push(entry);
+	if (logQueue.length === 1) {
+		timers.clearTimeout(logIdleClose);
+		logWriteChain = logWriteChain.then(drainLogQueue).catch(() => void 0);
+	}
+};
+const flushLogs = async () => {
+	let pending = true;
+	while (pending) {
+		const closed = logWriteChain.then(closeActiveLog);
+		logWriteChain = closed;
+		await closed;
+		pending = logQueue.length > 0;
+	}
+	timers.clearTimeout(logIdleClose);
 };
 const cleanupLogsIfDue = async () => {
 	const now = Date.now();
@@ -430,9 +501,11 @@ const wrapFileLog = (level, fn) => ((...args) => {
 	if (!writesToFile && !writesToConsole) return quiet ? void 0 : fn(...args);
 	const rendered = [boundLogText(args.map((value) => boundLogText(escapeLogLineSeparators(scrubLogSecrets(scrubSensitiveUrls(formatLogValue(value)))), maxLogArgumentBytes)).join(" "), maxLogPayloadBytes)];
 	if (writesToFile) {
-		const pending = writeLogFile(level, rendered).catch(() => void 0);
-		pendingLogWrites.add(pending);
-		pending.then(() => pendingLogWrites.delete(pending));
+		const now = /* @__PURE__ */ new Date();
+		queueLogEntry({
+			filePath: getLogPath(now),
+			line: `${now.toISOString()} ${level} ${rendered.join(" ")}\n`
+		});
 	}
 	return quiet ? void 0 : fn(...rendered);
 });
@@ -758,6 +831,7 @@ const normalizeClaudeModelId = (model, contextWindowTokens) => {
 	return contextWindowTokens !== void 0 && contextWindowTokens !== 1e6 ? normalized : `${normalized}[1m]`;
 };
 const normalizeCopilotModelId = (model) => normalizeOneMillionContextModel(model) ?? model;
+const isClaudeModelId = (model) => model.startsWith("claude-");
 const getConfiguredModelRouting = () => getRuntimeState().modelRouting ?? defaultModelRouting;
 const getModelRouting = () => {
 	const routing = getConfiguredModelRouting();
@@ -1839,8 +1913,7 @@ var RequestTrace = class RequestTrace {
 			request: emptyBody(`upstream-${order}-request.bin`, "complete")
 		};
 		this.manifest.exchanges.push(exchange);
-		const bytes = Buffer.from(input.body ?? "");
-		this.append(exchange.request, bytes);
+		this.append(exchange.request, input.body ?? "");
 		try {
 			const response = await (transportContext.getStore()?.fetch(input) ?? fallback());
 			exchange.status = response.status;
@@ -1955,16 +2028,17 @@ var RequestTrace = class RequestTrace {
 			}
 		}, { highWaterMark: 0 });
 	}
-	append(body, bytes) {
-		body.bytes += bytes.byteLength;
+	append(body, data) {
+		const byteLength = typeof data === "string" ? Buffer.byteLength(data) : data.byteLength;
+		body.bytes += byteLength;
 		if (!this.captureDirectory || this.manifest.captureError) return;
-		if (body.chunks.length >= 1e5 || this.queuedBytes + bytes.byteLength > maxQueuedBytes) {
+		if (body.chunks.length >= 1e5 || this.queuedBytes + byteLength > maxQueuedBytes) {
 			this.manifest.captureError = "capture_queue_limit";
 			this.manifest.captureState = "incomplete";
 			return;
 		}
-		body.chunks.push(bytes.byteLength);
-		const buffer = Buffer.from(bytes);
+		body.chunks.push(byteLength);
+		const buffer = Buffer.from(data);
 		this.queuedBytes += buffer.length;
 		this.queue = this.queue.then(async () => {
 			await this.checkDirectories();
@@ -2162,7 +2236,8 @@ const maxFetchAttempts = 2;
 const copilotRequestTimeoutMs = 18e4;
 const copilotDispatcher = new Agent({
 	allowH2: false,
-	connect: { allowH2: false }
+	connect: { allowH2: false },
+	keepAliveTimeout: 5e4
 });
 const getCopilotProviderContext = (config) => ({
 	baseUrl: config.copilotBaseUrl,
@@ -2414,6 +2489,11 @@ const parseStringArray = (value) => {
 	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return;
 	return value;
 };
+const parseReasoningEfforts = (supports) => {
+	if (supports === void 0) return;
+	if (supports.reasoning_effort === false || !Object.hasOwn(supports, "reasoning_effort")) return [];
+	return parseStringArray(supports.reasoning_effort);
+};
 async function loadCopilotModelCatalog(config) {
 	const provider = getCopilotProviderContext(config);
 	const pending = pendingCatalogs.get(config);
@@ -2437,13 +2517,14 @@ async function loadCopilotModelCatalog(config) {
 			const limits = parseModelTokenLimits(capabilities?.limits);
 			const supports = isRecord$3(capabilities?.supports) ? capabilities.supports : void 0;
 			const supportedEndpoints = parseStringArray(model.supported_endpoints);
-			const reasoningEfforts = supports?.reasoning_effort === false ? [] : parseStringArray(supports?.reasoning_effort);
+			const reasoningEfforts = parseReasoningEfforts(supports);
 			models$1.set(model.id, {
 				...limits && { limits },
 				...typeof capabilities?.tokenizer === "string" && { tokenizer: capabilities.tokenizer },
 				...supportedEndpoints !== void 0 && { supportedEndpoints },
 				...typeof capabilities?.type === "string" && { type: capabilities.type },
-				...reasoningEfforts !== void 0 && { reasoningEfforts }
+				...reasoningEfforts !== void 0 && { reasoningEfforts },
+				...typeof model.name === "string" && model.name !== "" && { name: model.name }
 			});
 		}
 		const catalog = {
@@ -2483,6 +2564,75 @@ async function boundModelOutputTokens(config, model, requested) {
 	return bounded;
 }
 
+//#endregion
+//#region src/copilot/endpoint.ts
+const copilotEndpoints = [
+	"/chat/completions",
+	"/responses",
+	"/v1/messages"
+];
+const legacyResponsesPattern = /^(?:gpt-5\.4(?!-mini)|gpt-5\.5|gpt-5\.6|gpt-6-astra)(?:-|$)/i;
+function selectCopilotEndpoint(config, model) {
+	const capabilities = getCachedCopilotModel(config, model);
+	const advertisedEndpoints = capabilities?.supportedEndpoints;
+	if (capabilities?.type !== void 0 && capabilities.type !== "chat") return { reason: "unsupported-model-type" };
+	const isClaude = isClaudeModelId(model);
+	const protocolMode = config.claudeUpstreamApi ?? "chat-completions";
+	if (isClaude && protocolMode === "messages") return {
+		endpoint: "/v1/messages",
+		source: "policy",
+		responsesFallback: false
+	};
+	if (isClaude && protocolMode === "auto" && advertisedEndpoints?.includes("/v1/messages")) return {
+		endpoint: "/v1/messages",
+		source: "catalog",
+		responsesFallback: false
+	};
+	const isChatPinned = isClaude && protocolMode === "chat-completions";
+	const preferredEndpoint = legacyResponsesPattern.test(model) ? "/responses" : "/chat/completions";
+	if (advertisedEndpoints === void 0) return {
+		endpoint: isChatPinned ? "/chat/completions" : preferredEndpoint,
+		source: isChatPinned ? "policy" : "legacy",
+		responsesFallback: !isChatPinned && preferredEndpoint === "/chat/completions"
+	};
+	if (advertisedEndpoints.length === 0) return { reason: "no-advertised-endpoint" };
+	if (isChatPinned) {
+		if (advertisedEndpoints.includes("/chat/completions")) return {
+			endpoint: "/chat/completions",
+			source: "policy",
+			responsesFallback: false
+		};
+		return { reason: advertisedEndpoints.some((endpoint) => endpoint === "/responses" || endpoint === "/v1/messages") ? "protocol-policy-conflict" : "unsupported-relay-endpoint" };
+	}
+	const selectedEndpoint = [preferredEndpoint, preferredEndpoint === "/responses" ? "/chat/completions" : "/responses"].find((endpoint) => advertisedEndpoints.includes(endpoint));
+	if (!selectedEndpoint) return { reason: "unsupported-relay-endpoint" };
+	return {
+		endpoint: selectedEndpoint,
+		source: "catalog",
+		responsesFallback: selectedEndpoint === "/chat/completions" && advertisedEndpoints.includes("/responses")
+	};
+}
+const unavailableEndpointMessages = {
+	"unsupported-model-type": "The selected upstream model does not advertise a chat interface.",
+	"no-advertised-endpoint": "The selected upstream model advertises no inference endpoints.",
+	"unsupported-relay-endpoint": "The selected upstream model advertises no compatible relay endpoint.",
+	"protocol-policy-conflict": "The selected upstream model has no Chat endpoint allowed by claudeUpstreamApi. Choose an advertised protocol explicitly."
+};
+function requireCopilotEndpoint(config, model) {
+	const selection = selectCopilotEndpoint(config, model);
+	if (selection.endpoint) return selection;
+	const message = unavailableEndpointMessages[selection.reason];
+	throw new HTTPError(message, Response.json({
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			code: "relay_unsupported_endpoint",
+			reason: selection.reason,
+			message
+		}
+	}, { status: 400 }), message);
+}
+
 //#endregion
 //#region src/lib/terminal.ts
 const colorEnabled = (env = process.env, isTTY = Boolean(process.stdout.isTTY)) => {
@@ -2527,6 +2677,7 @@ const reasonLabels = {
 	"no-advertised-endpoint": "No advertised route",
 	"protocol-policy-conflict": "Protocol policy conflict",
 	"unsupported-api": "Unsupported API",
+	"model-not-supported": "Model not supported",
 	"unsupported-effort": "Unsupported effort",
 	"unsafe-or-noncanonical-id": "Unsupported model ID",
 	"upstream-response-failed": "Upstream failed",
@@ -2626,6 +2777,7 @@ const probeHint = (code) => {
 	if (code === "refusal") return "Refusal: inspect the failing request's evidence; a short probe does not explain its cause.";
 	if (code.includes("budget-exhausted")) return "Output limit: reachability is not completion; review the probe's output budget.";
 	if (code === "model-mismatch") return "Model mismatch: compare selected, sent and reported IDs with --details.";
+	if (code === "model-not-supported") return "Model not supported: upstream lists this ID but rejects inference for it; choose another model.";
 	if (apiFailureCodes.includes(code) || /^HTTP-5\d\d$/.test(code)) return "API failure: the request ID locates the local summary; --details shows evidence on a new probe.";
 };
 
@@ -2760,7 +2912,7 @@ const createClaudeToolNameMapper = (tools, options = {}) => {
 function translateModelName(model) {
 	return routeModelId(model);
 }
-function translateToOpenAI(payload, _settings, toolNameMapper) {
+function translateToOpenAI(payload, _settings, toolNameMapper, options = {}) {
 	const model = translateModelName(payload.model);
 	const mapper = toolNameMapper ?? createClaudeToolNameMapper(payload.tools, { ...getToolNameMapperOptionsForModel(model) });
 	const tools = translateClaudeToolsToOpenAI(payload.tools, mapper);
@@ -2768,7 +2920,7 @@ function translateToOpenAI(payload, _settings, toolNameMapper) {
 	validateClaudeMessages(payload.messages);
 	return {
 		model,
-		messages: normalizeFinalAssistantPrefill$1(translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper)),
+		messages: normalizeFinalAssistantPrefill$1(translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper, options.endpoint === "/chat/completions" && isClaudeModelId(model))),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -2794,20 +2946,50 @@ function validateClaudeMessages(messages, native = false) {
 		if (typeof message.content !== "string" && (!Array.isArray(message.content) || message.content.some((block) => !block || block.type !== "text" || typeof block.text !== "string"))) throw invalidMessage("System message content must contain only text.");
 	}
 }
-function translateClaudeMessagesToOpenAI(claudeMessages, system, toolNameMapper) {
-	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = claudeMessages.flatMap((message) => {
-		switch (message.role) {
-			case "user": return handleUserMessage(message);
-			case "assistant": return handleAssistantMessage(message, toolNameMapper);
-			case "system":
-				if (message.output_config !== void 0 && (typeof message.content === "string" ? message.content.length === 0 : message.content.every((block) => block.text.length === 0))) return [];
-				return handleSystemPrompt(message.content);
-			default: throw invalidMessage("Unsupported message role.");
-		}
-	});
-	return [...systemMessages, ...otherMessages];
+function translateClaudeMessagesToOpenAI(claudeMessages, system, toolNameMapper, claudeChatRoute) {
+	const translated = handleSystemPrompt(system);
+	if (claudeChatRoute && hasCacheBreakpoint(system)) markCacheBreakpoint(translated.at(-1));
+	for (const message of claudeMessages) {
+		const start$1 = translated.length;
+		translated.push(...translateClaudeMessage(message, toolNameMapper, claudeChatRoute));
+		if (claudeChatRoute) markMessageBreakpoints(message, translated, start$1);
+	}
+	return translated;
+}
+function markMessageBreakpoints(message, translated, start$1) {
+	if (message.role !== "user" || !Array.isArray(message.content)) {
+		if (hasCacheBreakpoint(message.content)) markCacheBreakpoint(translated.at(-1));
+		return;
+	}
+	let toolIndex = start$1;
+	for (const block of message.content) if (block.type === "tool_result") {
+		if (isCacheBreakpoint(block)) markCacheBreakpoint(translated[toolIndex]);
+		toolIndex += 1;
+	} else if (isCacheBreakpoint(block)) markCacheBreakpoint(translated.at(-1));
+}
+function translateClaudeMessage(message, toolNameMapper, claudeChatRoute) {
+	switch (message.role) {
+		case "user": return handleUserMessage(message);
+		case "assistant": return handleAssistantMessage(message, toolNameMapper);
+		case "system":
+			if (message.output_config !== void 0 && (typeof message.content === "string" ? message.content.length === 0 : message.content.every((block) => block.text.length === 0))) return [];
+			return claudeChatRoute ? toSystemReminder(message.content) : handleSystemPrompt(message.content);
+		default: throw invalidMessage("Unsupported message role.");
+	}
+}
+function toSystemReminder(content) {
+	const text$1 = typeof content === "string" ? content : content.map((block) => block.text).join("\n\n");
+	if (text$1.trim().length === 0) return [];
+	return [{
+		role: "user",
+		content: `<system-reminder>\n${text$1}\n</system-reminder>`
+	}];
 }
+const isCacheBreakpoint = (block) => "cache_control" in block && Boolean(block.cache_control);
+const hasCacheBreakpoint = (content) => Array.isArray(content) && content.some(isCacheBreakpoint);
+const markCacheBreakpoint = (message) => {
+	if (message) message.copilot_cache_control = { type: "ephemeral" };
+};
 const invalidMessage = (message) => new HTTPError(message, new Response(JSON.stringify({
 	type: "error",
 	error: {
@@ -3905,6 +4087,12 @@ const getEncodeChatFunction = async (encoding) => {
 	encodingCache.set(encoding, encoder);
 	return encoder;
 };
+const preloadTokenizers = async (reported) => {
+	const encodings = new Set(["o200k_base"]);
+	for (const tokenizer of reported) if (tokenizer !== void 0 && isSupportedTokenizer(tokenizer)) encodings.add(tokenizer);
+	for (const encoding of encodings) await getEncodeChatFunction(encoding);
+};
+const loadedTokenizers = () => [...encodingCache.keys()];
 const getTokenizerFromModel = (model) => model.capabilities.tokenizer || "o200k_base";
 const getModelConstants = (model) => model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
 	funcInit: 10,
@@ -4001,75 +4189,6 @@ const getTokenCount = async (payload, model) => {
 	};
 };
 
-//#endregion
-//#region src/copilot/endpoint.ts
-const copilotEndpoints = [
-	"/chat/completions",
-	"/responses",
-	"/v1/messages"
-];
-const legacyResponsesPattern = /^(?:gpt-5\.5|gpt-5\.6|gpt-6-astra)(?:-|$)/i;
-function selectCopilotEndpoint(config, model) {
-	const capabilities = getCachedCopilotModel(config, model);
-	const advertisedEndpoints = capabilities?.supportedEndpoints;
-	if (capabilities?.type !== void 0 && capabilities.type !== "chat") return { reason: "unsupported-model-type" };
-	const isClaude = model.startsWith("claude-");
-	const protocolMode = config.claudeUpstreamApi ?? "chat-completions";
-	if (isClaude && protocolMode === "messages") return {
-		endpoint: "/v1/messages",
-		source: "policy",
-		responsesFallback: false
-	};
-	if (isClaude && protocolMode === "auto" && advertisedEndpoints?.includes("/v1/messages")) return {
-		endpoint: "/v1/messages",
-		source: "catalog",
-		responsesFallback: false
-	};
-	const isChatPinned = isClaude && protocolMode === "chat-completions";
-	const preferredEndpoint = legacyResponsesPattern.test(model) ? "/responses" : "/chat/completions";
-	if (advertisedEndpoints === void 0) return {
-		endpoint: isChatPinned ? "/chat/completions" : preferredEndpoint,
-		source: isChatPinned ? "policy" : "legacy",
-		responsesFallback: !isChatPinned && preferredEndpoint === "/chat/completions"
-	};
-	if (advertisedEndpoints.length === 0) return { reason: "no-advertised-endpoint" };
-	if (isChatPinned) {
-		if (advertisedEndpoints.includes("/chat/completions")) return {
-			endpoint: "/chat/completions",
-			source: "policy",
-			responsesFallback: false
-		};
-		return { reason: advertisedEndpoints.some((endpoint) => endpoint === "/responses" || endpoint === "/v1/messages") ? "protocol-policy-conflict" : "unsupported-relay-endpoint" };
-	}
-	const selectedEndpoint = [preferredEndpoint, preferredEndpoint === "/responses" ? "/chat/completions" : "/responses"].find((endpoint) => advertisedEndpoints.includes(endpoint));
-	if (!selectedEndpoint) return { reason: "unsupported-relay-endpoint" };
-	return {
-		endpoint: selectedEndpoint,
-		source: "catalog",
-		responsesFallback: selectedEndpoint === "/chat/completions" && advertisedEndpoints.includes("/responses")
-	};
-}
-const unavailableEndpointMessages = {
-	"unsupported-model-type": "The selected upstream model does not advertise a chat interface.",
-	"no-advertised-endpoint": "The selected upstream model advertises no inference endpoints.",
-	"unsupported-relay-endpoint": "The selected upstream model advertises no compatible relay endpoint.",
-	"protocol-policy-conflict": "The selected upstream model has no Chat endpoint allowed by claudeUpstreamApi. Choose an advertised protocol explicitly."
-};
-function requireCopilotEndpoint(config, model) {
-	const selection = selectCopilotEndpoint(config, model);
-	if (selection.endpoint) return selection;
-	const message = unavailableEndpointMessages[selection.reason];
-	throw new HTTPError(message, Response.json({
-		type: "error",
-		error: {
-			type: "invalid_request_error",
-			code: "relay_unsupported_endpoint",
-			reason: selection.reason,
-			message
-		}
-	}, { status: 400 }), message);
-}
-
 //#endregion
 //#region src/copilot/tool-schema.ts
 const schemaMapKeywords = new Set([
@@ -4120,17 +4239,45 @@ function hasUnsupportedPatternFeatures(pattern) {
 	}
 	return false;
 }
+const removed = Symbol("removed");
+function mapRecord(record$3, map) {
+	const keys = Object.keys(record$3);
+	let entries;
+	for (let index = 0; index < keys.length; index++) {
+		const key = keys[index];
+		const value = record$3[key];
+		const mapped = map(key, value);
+		if (!entries && Object.is(mapped, value)) continue;
+		entries ??= keys.slice(0, index).map((kept) => [kept, record$3[kept]]);
+		if (mapped !== removed) entries.push([key, mapped]);
+	}
+	return entries ? Object.fromEntries(entries) : record$3;
+}
+function mapArray(values) {
+	let copy;
+	for (let index = 0; index < values.length; index++) {
+		if (!(index in values)) continue;
+		const value = values[index];
+		const mapped = normalizeSchemaValue(value);
+		if (!copy && Object.is(mapped, value)) continue;
+		copy ??= values.slice(0, index);
+		copy[index] = mapped;
+	}
+	if (!copy) return values;
+	copy.length = values.length;
+	return copy;
+}
 function normalizeSchemaValue(value) {
-	if (Array.isArray(value)) return value.map(normalizeSchemaValue);
+	if (Array.isArray(value)) return mapArray(value);
 	return isRecord$1(value) ? normalizeResponsesToolSchema(value) : value;
 }
 function normalizeResponsesToolSchema(schema) {
-	return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
-		if (key === "pattern" && typeof value === "string" && hasUnsupportedPatternFeatures(value)) return [];
-		if (schemaMapKeywords.has(key) && isRecord$1(value)) return [[key, Object.fromEntries(Object.entries(value).map(([name, nested]) => [name, normalizeSchemaValue(nested)]))]];
-		if (nestedSchemaKeywords.has(key)) return [[key, normalizeSchemaValue(value)]];
-		return [[key, value]];
-	}));
+	return mapRecord(schema, (key, value) => {
+		if (key === "pattern" && typeof value === "string" && hasUnsupportedPatternFeatures(value)) return removed;
+		if (schemaMapKeywords.has(key) && isRecord$1(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
+		if (nestedSchemaKeywords.has(key)) return normalizeSchemaValue(value);
+		return value;
+	});
 }
 
 //#endregion
@@ -4702,14 +4849,14 @@ async function logUpstreamError(message, response, context, signal, timeoutMs) {
 		route: context.route,
 		model: context.model,
 		requestId: context.requestId,
-		request: context.request,
 		response: {
 			status: response.status,
 			statusText: response.statusText || void 0,
 			url: response.url || void 0,
 			headers: Object.fromEntries(response.headers.entries()),
 			body: errorBody || void 0
-		}
+		},
+		request: context.request
 	});
 	return detail;
 }
@@ -5336,6 +5483,10 @@ const createQueuedClaudeStreamWriter = (write) => {
 const writeClaudeStreamEvents = async (events$1, writeEvent) => {
 	for (const event of events$1) await writeEvent(event);
 };
+const translationEndpoint = (config, model) => {
+	const selection = selectCopilotEndpoint(config, normalizeCopilotModelId(model));
+	return selection.endpoint && !selection.responsesFallback ? selection.endpoint : void 0;
+};
 const handleClaudeMessageRequest = async (config, claudePayload, requestSignal, requestId, writeEvent, requestHeaders) => {
 	const upstreamModel = translateModelName(claudePayload.model);
 	if (shouldUseNativeMessages(config, upstreamModel)) return handleNativeMessages(config, {
@@ -5349,7 +5500,7 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 	const shouldLetModelDecideWebSearch = hasClaudeWebSearch(claudePayload);
 	const decisionPayload = shouldLetModelDecideWebSearch ? prepareClaudeWebSearchDecisionPayload(claudePayload) : claudePayload;
 	const toolNameMapper = createClaudeToolNameMapper(decisionPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
-	const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper);
+	const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper, { endpoint: translationEndpoint(config, upstreamModel) });
 	const canStreamWebSearchDecision = shouldLetModelDecideWebSearch && !!writeEvent;
 	if (shouldLetModelDecideWebSearch && !canStreamWebSearchDecision) openAIPayload.stream = false;
 	const response = await createChatCompletions(config, openAIPayload, {
@@ -5601,7 +5752,7 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 				const { output_config: _outputConfig, clear_at: _clearAt,...textMessage } = message;
 				return textMessage;
 			})
-		} : claudePayload);
+		} : claudePayload, void 0, void 0, { endpoint: translationEndpoint(c.get("config"), translateModelName(claudePayload.model)) });
 		const exposedModels = getExposedModelIds();
 		const upstreamModel = getCachedCopilotModel(c.get("config"), openAIPayload.model);
 		const hasDiscoveredTokenizer = upstreamModel?.tokenizer !== void 0 && isSupportedTokenizer(upstreamModel.tokenizer);
@@ -5824,6 +5975,13 @@ const settleDiagnostic = async (trace) => {
 		clearTimeout(timer);
 	}
 };
+const datedSnapshot = /^(.+)-\d{4}-\d{2}-\d{2}$/;
+const reportsSelectedModel = (endpoint, id, reported) => {
+	if (normalizeCopilotModelId(reported) === id) return true;
+	if (endpoint === "/v1/messages" && id === "claude-opus-5.5" && reported === "claude-opus-5-5") return true;
+	if (endpoint === "/responses" && id === "gpt-5.6-sol-fast" && normalizeCopilotModelId(reported) === "gpt-5.6-sol") return true;
+	return !datedSnapshot.test(id) && datedSnapshot.exec(reported)?.[1] === id;
+};
 const failureFromEvidence = (row, diagnostic) => {
 	if ([
 		"probe-timeout",
@@ -5869,7 +6027,8 @@ async function probeModels(config, entries, options) {
 				"xhigh",
 				"max"
 			].filter((effort$1) => model.reasoningEfforts?.includes(effort$1));
-			const defaultProbeEffort = advertisesNoReasoningEffort(model) ? void 0 : recognizedEfforts.find(isReasoningEffort) ?? "low";
+			const lowestEffort = recognizedEfforts.find((effort$1) => effort$1 !== "none") ?? recognizedEfforts.find(isReasoningEffort);
+			const defaultProbeEffort = advertisesNoReasoningEffort(model) ? void 0 : lowestEffort ?? "low";
 			const effort = options.effort ?? defaultProbeEffort;
 			const maxTokens = Math.min(options.maxTokens, model.limits?.max_output_tokens ?? options.maxTokens, model.limits?.max_non_streaming_output_tokens ?? options.maxTokens);
 			const timeoutMs = Math.min(options.timeoutMs, config.upstreamTimeoutMs > 0 ? config.upstreamTimeoutMs : Infinity);
@@ -5959,11 +6118,11 @@ async function probeModels(config, entries, options) {
 							row.detail = "upstream-response-incomplete";
 						}
 						if (code === "unsupported_api_for_model") row.detail = "unsupported-api";
+						if (code === "model_not_supported") row.detail = "model-not-supported";
 					} else if (!record$1(body) || !Array.isArray(body.content)) row.detail = "malformed-response";
 					else {
 						row.reported = safeId(body.model, config.copilotToken) ? body.model : "unreported";
-						const nativeOpusSpelling = endpoint === "/v1/messages" && id === "claude-opus-5.5" && row.reported === "claude-opus-5-5";
-						if (normalizeCopilotModelId(row.reported) !== id && !nativeOpusSpelling) row.detail = "model-mismatch";
+						if (!reportsSelectedModel(endpoint, id, row.reported)) row.detail = "model-mismatch";
 						else if (body.stop_reason === "max_tokens") {
 							row.status = "INCOMPLETE";
 							const outputTokens = record$1(body.usage) ? body.usage.output_tokens : void 0;
@@ -6022,14 +6181,139 @@ async function probeModels(config, entries, options) {
 	return results.length > 0 && results.every((row) => row.status === "PASS") ? 0 : 2;
 }
 
+//#endregion
+//#region src/lib/model-listing.ts
+const normalizeModelSearch = (text$1) => text$1.toLowerCase().replace(/[^a-z0-9]/g, "");
+const contains = (model, fragment) => normalizeModelSearch(model.id).includes(fragment) || normalizeModelSearch(model.name ?? "").includes(fragment);
+const minimumFragment = 4;
+const firstMatches = (models$1, fragments) => {
+	for (const fragment of fragments) {
+		const matches = models$1.filter((model) => contains(model, fragment));
+		if (matches.length > 0) return matches;
+	}
+	return [];
+};
+const closestModels = (models$1, search) => {
+	const starts = [];
+	const ends = [];
+	for (let length = search.length - 1; length >= minimumFragment; length--) {
+		starts.push(search.slice(0, length));
+		ends.push(search.slice(search.length - length));
+	}
+	const near = new Set([...firstMatches(models$1, starts), ...firstMatches(models$1, ends)]);
+	return models$1.filter((model) => near.has(model));
+};
+const searchModels = (models$1, search) => {
+	const wanted = normalizeModelSearch(search);
+	const matches = models$1.filter((model) => contains(model, wanted));
+	if (matches.length === 0) return {
+		found: false,
+		models: closestModels(models$1, wanted)
+	};
+	const usable = matches.filter((model) => model.unusable === void 0);
+	return {
+		found: true,
+		models: matches,
+		chosen: usable.find((model) => normalizeModelSearch(model.id) === wanted) ?? (usable.length === 1 ? usable[0] : void 0)
+	};
+};
+const maximumIdWidth = 40;
+const lowerFirst = (text$1) => text$1.charAt(0).toLowerCase() + text$1.slice(1);
+const detailsOf = (model) => {
+	const details = [];
+	if (model.name !== void 0) details.push(model.name);
+	if (model.unusable !== void 0) details.push(`cannot be gptModel or opusModel: ${lowerFirst(model.unusable)}`);
+	return details.join(" · ");
+};
+const renderModelRows = (models$1) => {
+	const described = models$1.filter((model) => detailsOf(model) !== "");
+	const width = Math.min(maximumIdWidth, Math.max(0, ...described.map((model) => model.id.length)));
+	return models$1.map((model) => {
+		const details = detailsOf(model);
+		if (details === "") return model.id;
+		return `${model.id.padEnd(width)}  ${details}`;
+	});
+};
+const routes = {
+	gptModel: "requests without \"opus\" in the model name",
+	opusModel: "requests with \"opus\" in the model name"
+};
+const applyNote = "A running relay applies the change to new requests; restarting reruns the startup check.";
+const keyFor = (id) => id.toLowerCase().includes("opus") ? "opusModel" : "gptModel";
+const problemOf = (model) => {
+	if (!model.advertised) return "is not advertised by upstream";
+	if (model.unusable !== void 0) return `cannot be used (${lowerFirst(model.unusable)})`;
+};
+const settingOf = (model) => `${model.key}: ${model.value}`;
+const renderConfigGuide = (configPath$1, configured, chosen) => {
+	const width = Math.max(...configured.map((model) => settingOf(model).length));
+	const lines = [`Config file: ${configPath$1}`];
+	for (const model of configured) lines.push(`  ${settingOf(model).padEnd(width)}  # ${routes[model.key]}`);
+	for (const model of configured) {
+		const problem = problemOf(model);
+		if (problem !== void 0) lines.push(`  Warning: ${model.key} ${model.value} ${problem}; the startup check rejects it.`);
+	}
+	if (chosen === void 0) {
+		lines.push("Set gptModel or opusModel to a chat model ID exactly as listed.", applyNote);
+		return lines;
+	}
+	const key = keyFor(chosen.id);
+	if (configured.some((model) => model.key === key && model.value === chosen.id)) {
+		lines.push(`${key} already uses ${chosen.id}.`);
+		return lines;
+	}
+	lines.push(`To use ${chosen.id}, set this line in the config file:`, `  ${key}: ${chosen.id}`, applyNote);
+	return lines;
+};
+
 //#endregion
 //#region src/models.ts
+var ModelsUsageError = class extends Error {};
+const displayName = (name) => {
+	const text$1 = sanitizeTerminalString(name ?? "").trim();
+	if (text$1 === "") return;
+	return text$1.length > 80 ? `${text$1.slice(0, 77)}...` : text$1;
+};
+const listedModels = (config, catalog) => [...catalog.models.keys()].sort().map((id) => {
+	const selection = selectCopilotEndpoint(config, id);
+	const name = displayName(catalog.models.get(id)?.name);
+	return {
+		id: sanitizeTerminalString(id),
+		...name !== void 0 && { name },
+		...!selection.endpoint && { unusable: probeReason(selection.reason) }
+	};
+});
+const configuredModels = (appConfig, config, catalog) => ["gptModel", "opusModel"].map((key) => {
+	const id = normalizeCopilotModelId(appConfig[key]);
+	const selection = selectCopilotEndpoint(config, id);
+	return {
+		key,
+		value: sanitizeTerminalString(appConfig[key]),
+		advertised: catalog.models.has(id),
+		...!selection.endpoint && { unusable: probeReason(selection.reason) }
+	};
+});
+const listingHeading = (search, result) => {
+	if (search === "") {
+		if (result.models.length === 0) return "No models advertised by upstream.";
+		return `Upstream-advertised models (${result.models.length}):`;
+	}
+	const label = sanitizeTerminalString(search);
+	if (result.found) return `Upstream models matching "${label}" (${result.models.length}):`;
+	if (result.models.length === 0) return `No upstream model matches "${label}". List them all with copilot-relay models.`;
+	return `No upstream model matches "${label}". Closest IDs (${result.models.length}):`;
+};
 const models = defineCommand({
 	meta: {
 		name: "models",
 		description: "List upstream models; use --deep to test inference availability."
 	},
 	args: {
+		search: {
+			type: "positional",
+			required: false,
+			description: "Find models by ID or display name and print the config line to use."
+		},
 		deep: {
 			type: "boolean",
 			description: "Send real inference probes through an isolated relay pipeline; consumes Copilot usage."
@@ -6076,6 +6360,9 @@ const models = defineCommand({
 				args["total-timeout"]
 			].some((value) => value !== void 0))) throw new Error("deep required");
 			if (args.effort !== void 0 && !isReasoningEffort(args.effort)) throw new Error("invalid effort");
+			const search = args._.join(" ").trim();
+			if (search !== "" && args.deep) throw new ModelsUsageError("A search lists models; check one with copilot-relay models --deep --model <id>.");
+			if (search !== "" && normalizeModelSearch(search) === "") throw new ModelsUsageError("A search needs at least one letter or digit.");
 			const probeOptions = {
 				maxTokens: positive(args["max-tokens"], 4096),
 				timeoutMs: positive(args.timeout, 30) * 1e3,
@@ -6085,22 +6372,23 @@ const models = defineCommand({
 			};
 			const prepare = async () => {
 				failure = "Could not load relay configuration";
-				const appConfig = await readAppConfig();
-				setLogLevel(appConfig.logLevel);
-				registerSensitiveOrigin(appConfig.copilotBaseUrl);
-				const config$1 = readProxyConfig(appConfig);
+				const appConfig$1 = await readAppConfig();
+				setLogLevel(appConfig$1.logLevel);
+				registerSensitiveOrigin(appConfig$1.copilotBaseUrl);
+				const config$1 = readProxyConfig(appConfig$1);
 				failure = "Could not authenticate with GitHub Copilot";
 				await setupProxyAuth(config$1, args.deep ? { onDeviceCode: (url, code) => console.error(`Sign in: open ${terminalText(url)} and enter ${terminalText(code)}.`) } : void 0);
 				failure = "Could not fetch upstream model catalog";
 				return {
+					appConfig: appConfig$1,
 					config: config$1,
 					catalog: await loadCopilotModelCatalog(config$1)
 				};
 			};
-			const { config, catalog } = args.deep ? await withoutConsoleLogging(prepare) : await prepare();
+			const { appConfig, config, catalog } = args.deep ? await withoutConsoleLogging(prepare) : await prepare();
 			if (args.deep) {
 				failure = "Selected model is not advertised by upstream";
-				if (args.model !== void 0 && !catalog.models.has(args.model)) throw new Error("unknown model");
+				if (args.model !== void 0 && !catalog.models.has(args.model)) throw new ModelsUsageError("Find the exact ID with copilot-relay models <search>.");
 				const entries = [...catalog.models].sort(([a], [b]) => {
 					if (a < b) return -1;
 					return a > b ? 1 : 0;
@@ -6109,12 +6397,20 @@ const models = defineCommand({
 				process.exitCode = await probeModels(config, entries, probeOptions);
 				return;
 			}
-			const ids = [...catalog.models.keys()].sort().map(sanitizeTerminalString);
-			console.log(scrubSensitiveUrls(ids.length ? `Upstream-advertised models (${ids.length}):\n${ids.join("\n")}` : "No models advertised by upstream."));
-			console.log("Inference, tool, and effort compatibility are not verified by this listing.");
+			const listed = listedModels(config, catalog);
+			const result = search === "" ? {
+				found: true,
+				models: listed
+			} : searchModels(listed, search);
+			const lines = [listingHeading(search, result), ...renderModelRows(result.models)];
+			if (result.models.length > 0) lines.push("Inference, tool, and effort compatibility are not verified by this listing.", `Test one with copilot-relay models --deep --model ${result.chosen?.id ?? "<id>"}; it consumes Copilot usage.`);
+			lines.push("", ...renderConfigGuide(paths.configPath, configuredModels(appConfig, config, catalog), result.chosen));
+			console.log(scrubSensitiveUrls(lines.join("\n")));
+			if (!result.found) process.exitCode = 1;
 		} catch (error) {
 			let detail = "Check configuration, authentication, and upstream connectivity.";
-			if (error instanceof HTTPError) {
+			if (error instanceof ModelsUsageError) detail = error.message;
+			else if (error instanceof HTTPError) {
 				if (error.detail !== void 0) detail = error.response.status === 504 ? "request timed out" : "request cancelled";
 				else detail = `HTTP ${error.response.status}`;
 				await error.response.body?.cancel().catch(() => {});
@@ -6670,9 +6966,9 @@ const replay = defineCommand({
 		const result = await replayCapture(args.target);
 		console.log(result.verdict);
 		if (result.summary) {
-			const { method, path: path$1, status: status$1, routes, outcome } = result.summary;
+			const { method, path: path$1, status: status$1, routes: routes$1, outcome } = result.summary;
 			console.log(`${method} ${path$1} status=${status$1 ?? "unknown"} outcome=${outcome}`);
-			console.log(`upstream=${routes.join(" -> ") || "none"}`);
+			console.log(`upstream=${routes$1.join(" -> ") || "none"}`);
 			for (const exchange of result.summary.exchanges) {
 				const usage = Object.entries(exchange.usage).map(([key, value]) => `${key}=${value}`).join(" ");
 				console.log(`exchange=${exchange.order} path=${exchange.path} status=${exchange.status ?? "unknown"} outcome=${exchange.outcome}${usage ? ` ${usage}` : ""}${exchange.refusalCategory ? ` refusal_category=${exchange.refusalCategory}` : ""}`);
@@ -7306,6 +7602,12 @@ async function startRelay(appConfig) {
 		process.exit(1);
 	}
 	log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
+	try {
+		await preloadTokenizers(getUpstreamModelIds().map((id) => getCachedCopilotModel(config, id)?.tokenizer));
+		log.info(`Tokenizers loaded: ${loadedTokenizers().join(", ")}`);
+	} catch (error) {
+		log.error("Tokenizer preload failed; count_tokens loads tokenizers on first use:", error);
+	}
 	const server = await startServer(config);
 	await writeRelayPidFile(config);
 	log.info(`copilot-relay version: ${appVersion}`);