copilot-relay 0.0.3 → 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 D0n9X1n
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -52,12 +52,11 @@ thinkEffort: xhigh
 
 | Level | Logs |
 | --- | --- |
-| `silent` | Nothing |
 | `error` | Startup, preflight, and request failures |
-| `warn` | Errors plus recoverable warnings |
-| `info` | Warnings plus startup status, preflight status, HTTP requests, and model routing summaries |
-| `debug` | Info plus Copilot upstream timings, token refresh scheduling, and upstream error request summaries |
-| `trace` | Debug plus full Claude request payloads and full upstream Copilot request payloads without redaction |
+| `info` | Errors plus startup status, preflight status, and local HTTP status codes |
+| `debug` | Info plus model routing summaries, Copilot upstream timings, and request payloads |
+
+Any other `logLevel` value is invalid and stops startup.
 
 Valid `thinkEffort`: `none`, `low`, `medium`, `high`, `xhigh`.
 
@@ -72,17 +71,27 @@ copilot-relay start
 
 ## Logging
 
-At `info`, every model request logs the requested model, upstream model, requested think effort, requested thinking, and effective think effort.
+At `debug`, every model request logs the requested model, upstream model, requested think effort, requested thinking, and effective think effort.
 
-At `trace`, copilot-relay logs the full Claude request payload and full upstream request payload without redaction.
+Upstream failures are logged at `error` with full request and response context in the same log file.
 
 Logs are written to `~/.copilot-relay/logs/copilot-relay.log`; old `.log` files are cleaned according to `logRetentionDays`.
 
+Quick inspection:
+
+```sh
+tail -f ~/.copilot-relay/logs/copilot-relay.log
+grep -n "Failed to create\\|Startup preflight failed" ~/.copilot-relay/logs/copilot-relay.log
+```
+
+See [`docs/troubleshooting.md`](docs/troubleshooting.md) for common debugging workflows.
+
 ## Development
 
 Developer notes live in [`docs/development.md`](docs/development.md).
 Architecture notes live in [`docs/architecture.md`](docs/architecture.md).
 Logging notes live in [`docs/logging.md`](docs/logging.md).
+Troubleshooting notes live in [`docs/troubleshooting.md`](docs/troubleshooting.md).
 
 ```sh
 npm install

package/config.default.yaml

@@ -2,6 +2,8 @@
 #
 # This file is copied to ~/.copilot-relay/config.yaml on first start.
 # Edit the user config file, not this template, for local changes.
+# Most values hot-reload while the service is running. host and port still
+# require restart because the listening socket is already bound.
 
 # Local host for the Claude Code-compatible HTTP server.
 host: 127.0.0.1
@@ -18,15 +20,12 @@ copilotBaseUrl: https://api.githubcopilot.com
 claudeSetup: true
 
 # Log verbosity:
-#   silent - no logs
-#   error  - startup/preflight/request failures only
-#   warn   - error logs plus recoverable warnings
-#   info   - warn logs plus startup status, preflight status, HTTP requests,
-#            and model routing summaries
-#   debug  - info logs plus Copilot upstream timings, token refresh scheduling,
-#            and upstream error request summaries
-#   trace  - debug logs plus full Claude request payloads and full upstream
-#            Copilot request payloads without redaction
+#   error - startup/preflight/request failures only
+#   info  - error logs plus startup status, preflight status, and local HTTP
+#           status codes
+#   debug - info logs plus model routing summaries, Copilot upstream timings,
+#           and request payloads
+# Any other value is invalid and stops startup.
 logLevel: info
 
 # Number of days to keep files in ~/.copilot-relay/logs.

package/dist/main.js

@@ -22,10 +22,12 @@ var ProxyNotImplementedError = class extends Error {
 	}
 };
 var HTTPError = class extends Error {
+	detail;
 	response;
-	constructor(message, response) {
+	constructor(message, response, detail) {
 		super(message);
 		this.name = "HTTPError";
+		this.detail = detail;
 		this.response = response;
 	}
 };
@@ -100,14 +102,18 @@ const logCleanupCheckIntervalMs = 3600 * 1e3;
 let logRetentionDays = 3;
 let nextLogCleanupCheckAt = 0;
 const consolaLevelByName = {
-	silent: -Infinity,
 	error: 0,
-	warn: 1,
 	info: 3,
-	debug: 4,
-	trace: 5
+	debug: 4
 };
+const fileLevelByMethod = {
+	error: consolaLevelByName.error,
+	info: consolaLevelByName.info,
+	debug: consolaLevelByName.debug
+};
+let currentLogLevel = consolaLevelByName.info;
 const setLogLevel = (level) => {
+	currentLogLevel = consolaLevelByName[level];
 	consola.level = consolaLevelByName[level];
 };
 const formatLogValue = (value) => typeof value === "string" ? value : inspect(value, { depth: null });
@@ -128,15 +134,12 @@ const cleanupLogsIfDue = async () => {
 	await cleanupLogs(logRetentionDays);
 };
 const wrapFileLog = (level, fn) => ((...args) => {
-	writeLogFile(level, args).catch(() => void 0);
+	if ((fileLevelByMethod[level] ?? consolaLevelByName.info) <= currentLogLevel) writeLogFile(level, args).catch(() => void 0);
 	return fn(...args);
 });
 consola.error = wrapFileLog("error", consola.error.bind(consola));
-consola.warn = wrapFileLog("warn", consola.warn.bind(consola));
 consola.info = wrapFileLog("info", consola.info.bind(consola));
-consola.success = wrapFileLog("success", consola.success.bind(consola));
 consola.debug = wrapFileLog("debug", consola.debug.bind(consola));
-consola.trace = wrapFileLog("trace", consola.trace.bind(consola));
 const cleanupLogs = async (retentionDays) => {
 	logRetentionDays = retentionDays;
 	await fs.mkdir(paths.logsDir, { recursive: true });
@@ -264,21 +267,21 @@ const isCopilotTokenError = (error) => error instanceof HTTPError && error.messa
 const ensureGitHubToken = async (options = {}) => {
 	const existingToken = options.force ? "" : await readGitHubToken();
 	if (existingToken) {
-		log.debug(`Using cached GitHub token at ${paths.githubTokenPath}`);
+		log.info(`Using cached GitHub token at ${paths.githubTokenPath}`);
 		return existingToken;
 	}
 	const deviceCode = await getDeviceCode();
 	log.info(`Open ${deviceCode.verification_uri} and enter code ${deviceCode.user_code}`);
 	const githubToken = await pollAccessToken(deviceCode);
 	await writeGitHubToken(githubToken);
-	log.success(`GitHub token synced to ${paths.githubTokenPath}`);
+	log.info(`GitHub token synced to ${paths.githubTokenPath}`);
 	return githubToken;
 };
 const loadGitHubLogin = async (githubToken, vsCodeVersion) => {
 	try {
 		return (await getGitHubUser(githubToken, vsCodeVersion)).login;
 	} catch (error) {
-		log.warn("Could not load GitHub user:", error);
+		log.error("Could not load GitHub user:", error);
 		return;
 	}
 };
@@ -293,11 +296,11 @@ const setupProxyAuth = async (config, options = {}) => {
 	const scheduleCopilotTokenRefresh = (refreshIn$1) => {
 		if (copilotTokenRefreshTimer) clearTimeout(copilotTokenRefreshTimer);
 		const refreshMs = Math.max(refreshIn$1 - 60, 60) * 1e3;
-		log.debug(`Next Copilot token refresh in ${Math.round(refreshMs / 1e3)}s`);
+		log.info(`Next Copilot token refresh in ${Math.round(refreshMs / 1e3)}s`);
 		copilotTokenRefreshTimer = setTimeout(async () => {
 			try {
 				const nextRefreshIn = await applyCopilotToken();
-				log.debug("Refreshed Copilot token");
+				log.info("Refreshed Copilot token");
 				scheduleCopilotTokenRefresh(nextRefreshIn);
 			} catch (error) {
 				log.error("Failed to refresh Copilot token:", error);
@@ -311,12 +314,12 @@ const setupProxyAuth = async (config, options = {}) => {
 	if (storedToken && getStoredTokenRemainingSeconds(storedToken) > 60) {
 		config.copilotToken = storedToken.token;
 		refreshIn = getStoredTokenRemainingSeconds(storedToken);
-		log.debug(`Using cached Copilot token at ${paths.copilotTokenPath}`);
+		log.info(`Using cached Copilot token at ${paths.copilotTokenPath}`);
 	} else try {
 		refreshIn = await applyCopilotToken();
 	} catch (error) {
 		if (options.force || !isCopilotTokenError(error)) throw error;
-		log.warn("Cached GitHub auth could not get a Copilot token; running device auth again.");
+		log.error("Cached GitHub auth could not get a Copilot token; running device auth again.");
 		githubToken = await ensureGitHubToken({
 			...options,
 			force: true
@@ -355,12 +358,9 @@ const routeModelId = (model) => {
 //#endregion
 //#region src/lib/app-config.ts
 const logLevels = [
-	"silent",
 	"error",
-	"warn",
 	"info",
-	"debug",
-	"trace"
+	"debug"
 ];
 const defaultConfig = {
 	claudeSetup: true,
@@ -374,7 +374,13 @@ const defaultConfig = {
 	thinkEffort: defaultReasoningEffort
 };
 const isLogLevelName = (value) => typeof value === "string" && logLevels.includes(value.toLowerCase());
-const normalizeLogLevel = (value) => isLogLevelName(value) ? value.toLowerCase() : void 0;
+const normalizeLogLevel = (value) => {
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(`Invalid logLevel: expected one of ${logLevels.join(", ")}`);
+	const normalized = value.toLowerCase();
+	if (!isLogLevelName(normalized)) throw new Error(`Invalid logLevel "${value}": expected one of ${logLevels.join(", ")}`);
+	return normalized;
+};
 const normalizeBoolean = (value) => {
 	if (typeof value === "boolean") return value;
 	if (typeof value !== "string") return;
@@ -498,15 +504,11 @@ const serializeConfig = (config) => [
 	`claudeSetup: ${config.claudeSetup}`,
 	"",
 	"# Log verbosity:",
-	"#   silent - no logs",
-	"#   error  - startup/preflight/request failures only",
-	"#   warn   - error logs plus recoverable warnings",
-	"#   info   - warn logs plus startup status, preflight status, HTTP requests,",
-	"#            and model routing summaries",
-	"#   debug  - info logs plus Copilot upstream timings, token refresh scheduling,",
-	"#            and upstream error request summaries",
-	"#   trace  - debug logs plus full Claude request payloads and full upstream",
-	"#            Copilot request payloads without redaction",
+	"#   error - startup/preflight/request failures only",
+	"#   info  - error logs plus startup status, preflight status, and local HTTP",
+	"#           status codes",
+	"#   debug - info logs plus model routing summaries, Copilot upstream timings,",
+	"#           and request payloads",
 	`logLevel: ${config.logLevel}`,
 	"",
 	"# Number of days to keep files in ~/.copilot-relay/logs.",
@@ -594,7 +596,7 @@ const auth = defineCommand({
 		config.copilotToken = void 0;
 		const authSession = await setupProxyAuth(config, { force: true });
 		if (authSession.githubLogin) log.info(`Logged in as ${authSession.githubLogin}`);
-		log.success("copilot-relay auth completed");
+		log.info("copilot-relay auth completed");
 	}
 });
 
@@ -697,84 +699,15 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 		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.warn(`Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts})`);
+		log.error(`Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts})`);
 	} catch (error) {
 		lastError = error;
 		if (attempt === maxFetchAttempts) throw error;
-		log.warn(`Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts})`, error);
+		log.error(`Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts})`, error);
 	}
 	throw lastError;
 };
 
-//#endregion
-//#region src/lib/upstream-diagnostics.ts
-const openaiToolNamePattern = /^[A-Za-z0-9_-]{1,64}$/;
-const toolSchemaSuspectKeys = new Set([
-	"$defs",
-	"allOf",
-	"definitions",
-	"dependentRequired",
-	"dependentSchemas",
-	"else",
-	"if",
-	"not",
-	"oneOf",
-	"patternProperties",
-	"then"
-]);
-const maxDiagnosticItems = 8;
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const getToolName = (tool) => {
-	if (!isRecord(tool)) return "";
-	const functionValue = tool.function;
-	if (isRecord(functionValue) && typeof functionValue.name === "string") return functionValue.name;
-	return typeof tool.name === "string" ? tool.name : "";
-};
-const getToolParameters = (tool) => {
-	if (!isRecord(tool)) return;
-	const functionValue = tool.function;
-	if (isRecord(functionValue) && "parameters" in functionValue) return functionValue.parameters;
-	return tool.parameters;
-};
-const collectSuspiciousSchemaKeys = (value, path$1 = "$", keys = []) => {
-	if (keys.length >= maxDiagnosticItems) return keys;
-	if (Array.isArray(value)) {
-		for (const [index, item] of value.entries()) {
-			collectSuspiciousSchemaKeys(item, `${path$1}[${index}]`, keys);
-			if (keys.length >= maxDiagnosticItems) break;
-		}
-		return keys;
-	}
-	if (!isRecord(value)) return keys;
-	for (const [key, nestedValue] of Object.entries(value)) {
-		const nextPath = `${path$1}.${key}`;
-		if (toolSchemaSuspectKeys.has(key)) {
-			if (!keys.includes(nextPath)) keys.push(nextPath);
-			if (keys.length >= maxDiagnosticItems) break;
-		}
-		collectSuspiciousSchemaKeys(nestedValue, nextPath, keys);
-		if (keys.length >= maxDiagnosticItems) break;
-	}
-	return keys;
-};
-const summarizeToolsForDiagnostics = (tools) => {
-	if (!Array.isArray(tools) || tools.length === 0) return;
-	const invalidNames = tools.map((tool) => getToolName(tool)).filter((name) => !openaiToolNamePattern.test(name)).slice(0, maxDiagnosticItems);
-	const suspiciousSchemas = tools.flatMap((tool) => {
-		const name = getToolName(tool) || "<missing>";
-		const keys = collectSuspiciousSchemaKeys(getToolParameters(tool));
-		return keys.length > 0 ? [{
-			keys,
-			name
-		}] : [];
-	}).slice(0, maxDiagnosticItems);
-	return {
-		count: tools.length,
-		...invalidNames.length > 0 ? { invalidNames } : {},
-		...suspiciousSchemas.length > 0 ? { suspiciousSchemas } : {}
-	};
-};
-
 //#endregion
 //#region src/copilot/responses.ts
 const responsesOnlyModelPattern = /^(?:gpt-5\.5)(?:-|$)/i;
@@ -1145,16 +1078,6 @@ const sanitizeUserIdentifier = (user) => {
 	if (!user) return;
 	return user.slice(0, maxUserLength);
 };
-const summarizeRequestForDiagnostics = (payload) => ({
-	max_completion_tokens: payload.max_completion_tokens,
-	max_tokens: payload.max_tokens,
-	message_count: payload.messages.length,
-	output_config_effort: payload.output_config?.effort,
-	reasoning_effort: payload.reasoning_effort,
-	stream: payload.stream ?? void 0,
-	tool_choice: payload.tool_choice,
-	tools: summarizeToolsForDiagnostics(payload.tools)
-});
 const buildRequestPayload = (payload) => {
 	const requestedReasoningEffort = getRequestedReasoningEffort(payload);
 	if (!usesMaxCompletionTokens(payload.model) || payload.max_tokens === null || payload.max_tokens === void 0) return {
@@ -1186,7 +1109,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	const enableVision = messagesIncludeImage(upstreamPayload.messages);
 	const initiator = isAgentInitiator(upstreamPayload.messages);
 	const requestPayload = buildRequestPayload(upstreamPayload);
-	log.info([
+	log.debug([
 		"Model request",
 		`client=${client}`,
 		`requested_model=${requestedModel}`,
@@ -1195,7 +1118,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		`requested_thinking=${requestedThinking}`,
 		`effective_think_effort=${requestPayload.reasoning_effort ?? "none"}`
 	].join(" "));
-	log.trace("Full request payload", { payload: requestPayload });
+	log.debug("Full request payload", { payload: requestPayload });
 	if (shouldUseResponsesApiForModel(upstreamPayload.model)) return createResponses(provider, upstreamPayload, {
 		vision: enableVision,
 		initiator
@@ -1216,49 +1139,62 @@ const createChatCompletions = async (config, payload, options = {}) => {
 			vision: enableVision,
 			initiator
 		});
-		await logUpstreamError("Failed to create chat completions", response, {
+		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"
-		});
-		throw new HTTPError("Failed to create chat completions", response);
+		}));
 	}
 	if (upstreamPayload.stream) return events(response);
 	return await response.json();
 };
 async function createResponses(provider, payload, options) {
-	const reasoningEffort = getRequestedReasoningEffort(payload);
+	const requestPayload = buildResponsesRequestPayload(payload, getRequestedReasoningEffort(payload));
 	const response = await fetchCopilot(provider, "/responses", {
 		method: "POST",
 		headers: {
 			accept: payload.stream ? "text/event-stream" : "application/json",
 			"content-type": "application/json"
 		},
-		body: JSON.stringify(buildResponsesRequestPayload(payload, reasoningEffort))
+		body: JSON.stringify(requestPayload)
 	}, {
 		vision: options.vision,
 		initiator: options.initiator
 	});
-	if (!response.ok) {
-		await logUpstreamError("Failed to create responses", response, {
-			model: payload.model,
-			route: "/responses"
-		});
-		throw new HTTPError("Failed to create responses", response);
-	}
+	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"
+	}));
 	if (payload.stream) return translateResponsesStreamToChatCompletionStream(events(response));
 	return translateResponsesToChatCompletion(await response.json());
 }
 async function logUpstreamError(message, response, context) {
 	const errorBody = await response.clone().text().catch(() => "");
-	log.error(message, {
+	const detail = getUpstreamErrorDetail(response, errorBody);
+	log.error(`${message}: route=${context.route} model=${context.model} status=${response.status}`, {
+		message,
 		route: context.route,
 		model: context.model,
-		status: response.status,
-		statusText: response.statusText,
-		body: errorBody || void 0,
-		request: runtimeState.debug && context.request ? JSON.stringify(summarizeRequestForDiagnostics(context.request)) : void 0
+		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
+		}
 	});
+	return detail;
+}
+function getUpstreamErrorDetail(response, body) {
+	if (!body) return response.statusText || void 0;
+	try {
+		const payload = JSON.parse(body);
+		return payload.error?.message ?? payload.error?.code ?? body.slice(0, 240);
+	} catch {
+		return body.slice(0, 240);
+	}
 }
 async function shouldRetryWithResponses(response) {
 	try {
@@ -1419,7 +1355,7 @@ function translateToOpenAI(payload, _settings, toolNameMapper) {
 	const tools = translateClaudeToolsToOpenAI(payload.tools, mapper);
 	return {
 		model,
-		messages: translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper),
+		messages: normalizeFinalAssistantPrefill(translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper)),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -1492,6 +1428,31 @@ function handleAssistantMessage(message, toolNameMapper) {
 		content: mapContent(message.content)
 	}];
 }
+const continuePrefillPrompt = "Continue the assistant response from the previous assistant message.";
+const normalizeFinalAssistantPrefill = (messages) => {
+	let lastAssistantIndex = -1;
+	for (let index = messages.length - 1; index >= 0; index--) if (messages[index]?.role === "assistant") {
+		lastAssistantIndex = index;
+		break;
+	}
+	if (lastAssistantIndex < 0) return messages;
+	if (lastAssistantIndex !== messages.length - 1) return messages;
+	const lastAssistant = messages[lastAssistantIndex];
+	if (typeof lastAssistant.content !== "string") return messages.slice(0, -1);
+	const trimmedContent = lastAssistant.content.trimEnd();
+	const nextMessages = [...messages];
+	if (trimmedContent) {
+		nextMessages[lastAssistantIndex] = {
+			...lastAssistant,
+			content: trimmedContent
+		};
+		nextMessages.push({
+			role: "user",
+			content: continuePrefillPrompt
+		});
+	} else nextMessages.pop();
+	return nextMessages;
+};
 function mapContent(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return null;
@@ -2003,7 +1964,7 @@ claudeRoutes.get("/models", (c) => c.json({
 claudeRoutes.post("/messages", async (c) => {
 	const config = c.get("config");
 	const claudePayload = await c.req.json();
-	log.trace("Full Claude request payload", { payload: claudePayload });
+	log.debug("Full Claude request payload", { payload: claudePayload });
 	try {
 		const upstreamModel = translateModelName(claudePayload.model);
 		const toolNameMapper = createClaudeToolNameMapper(claudePayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
@@ -2056,12 +2017,16 @@ claudeRoutes.post("/messages", async (c) => {
 			}
 		});
 	} catch (error) {
-		if (error instanceof ProxyNotImplementedError) return c.json({ error: {
-			type: error.name,
-			message: error.message
-		} }, 501);
+		if (error instanceof ProxyNotImplementedError) {
+			c.set("requestErrorMessage", error.message);
+			return c.json({ error: {
+				type: error.name,
+				message: error.message
+			} }, 501);
+		}
 		if (error instanceof HTTPError) {
 			const text = await error.response.text().catch(() => "");
+			c.set("requestErrorMessage", error.detail ?? text.slice(0, 240));
 			return new Response(text, {
 				status: error.response.status,
 				headers: { "content-type": error.response.headers.get("content-type") ?? "application/json" }
@@ -2095,6 +2060,10 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 
 //#endregion
 //#region src/server.ts
+const formatStatusLog = (method, path$1, status, ms, errorMessage) => {
+	const base = `${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());
@@ -2105,11 +2074,11 @@ const createServer = (config) => {
 			await next();
 		} finally {
 			const ms = Math.round(performance.now() - started);
-			log.info(`${c.req.method} ${c.req.path} -> ${c.res.status} ${ms}ms`);
+			log.info(formatStatusLog(c.req.method, c.req.path, c.res.status, ms, c.get("requestErrorMessage")));
 		}
 	});
 	app.onError((error, c) => {
-		log.error(`${c.req.method} ${c.req.path} failed`, error);
+		c.set("requestErrorMessage", error.message);
 		return c.json({ error: { message: "Internal server error" } }, 500);
 	});
 	app.get("/", (c) => c.json({
@@ -2142,7 +2111,7 @@ const start = defineCommand({
 		const applyRuntimeConfig = (nextConfig) => {
 			setLogLevel(nextConfig.logLevel);
 			cleanupLogs(nextConfig.logRetentionDays);
-			runtimeState.debug = nextConfig.logLevel === "debug" || nextConfig.logLevel === "trace";
+			runtimeState.debug = nextConfig.logLevel === "debug";
 			runtimeState.thinkEffort = nextConfig.thinkEffort;
 			config.copilotBaseUrl = nextConfig.copilotBaseUrl;
 			config.host = nextConfig.host;
@@ -2153,7 +2122,6 @@ const start = defineCommand({
 			};
 		};
 		applyRuntimeConfig(appConfig);
-		if (runtimeState.debug) log.info("Debug diagnostics enabled; upstream errors include request summaries");
 		log.info(`Log level: ${appConfig.logLevel}`);
 		log.info(`Think effort: ${appConfig.thinkEffort}`);
 		log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
@@ -2167,9 +2135,9 @@ const start = defineCommand({
 		const server = startServer(config);
 		log.info(`copilot-relay version: ${appVersion}`);
 		if (authSession.githubLogin) log.info(`GitHub user: ${authSession.githubLogin}`);
-		else log.warn("GitHub user: unavailable");
-		log.success(`copilot-relay listening on http://${config.host}:${config.port}`);
-		log.debug(`copilot base url: ${config.copilotBaseUrl}`);
+		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({
@@ -2177,11 +2145,11 @@ const start = defineCommand({
 				configPath: claudeConfigPath$1
 			});
 			if (claudeResult.changed) {
-				log.success(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
+				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.warn(`Could not update claude settings (${claudeConfigPath$1}):`, error);
+			log.error(`Could not update claude settings (${claudeConfigPath$1}):`, error);
 		}
 		watchAppConfig((nextConfig) => {
 			applyRuntimeConfig(nextConfig);