copilot-relay 0.3.7 → 0.3.9

package/README.md

@@ -117,16 +117,19 @@ for live model discovery, compatible thinking efforts, and copy-paste updates.
 | Level | Logs |
 | --- | --- |
 | `error` | Startup, preflight, and request failures |
-| `info` | Errors plus startup status, preflight status, request IDs, upstream lifecycle, and local HTTP status codes |
-| `debug` | Info plus model routing summaries, Copilot upstream timings, and request payloads |
+| `info` | Errors plus startup/preflight status, request IDs, model/effort summaries, upstream lifecycle, and local HTTP status codes |
+| `debug` | Info plus detailed Copilot timings and request payloads |
 
 Any other `logLevel` value is invalid and stops startup.
 
-Valid `thinkEffort`: `none`, `low`, `medium`, `high`, `xhigh`, `max`.
+Valid `thinkEffort` defaults: `low`, `medium`, `high`, `xhigh`, `max`.
 It is a fallback, not a forced override: Claude Code's `output_config.effort`
 wins, followed by the legacy `reasoning_effort` field, then `thinkEffort` when
 neither request field supplies a value. The selected effort is preserved through
 all model and WebSearch passes; existing config values are not rewritten.
+`none` and other invalid explicit defaults fail startup before authentication or
+config write-back, with a clear list of valid choices. They are not silently
+replaced with `max`. Explicit request-level `none` remains model-dependent.
 
 `upstreamTimeoutSeconds` controls the maximum time a single Claude request can
 spend waiting on upstream Copilot calls, including chat, Responses, preflight,
@@ -212,7 +215,10 @@ health probe, so a relay that cannot answer `/healthz` never reports success.
 
 ## Logging
 
-At `debug`, every model request logs the requested model, upstream model, requested think effort, requested thinking, and effective think effort.
+At `info`, every model request logs the requested model, upstream model, requested
+think effort, requested thinking, and effective think effort. Missing request
+effort is shown as `unset`, distinct from explicit `none`; full normal request
+payloads remain at `debug`.
 
 Upstream failures are logged at `error` with full request and response context in the same log file.
 

package/config.default.yaml

@@ -26,10 +26,9 @@ claudeSetup: true
 
 # Log verbosity:
 #   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
+#   info  - error logs plus startup/preflight status, model/effort summaries,
+#           and local HTTP status codes
+#   debug - info logs plus detailed Copilot timings and request payloads
 # Any other value is invalid and stops startup.
 logLevel: info
 
@@ -41,7 +40,7 @@ logRetentionDays: 3
 
 # Fallback upstream effort when Claude Code does not specify one.
 # Request output_config.effort wins, followed by legacy reasoning_effort.
-# Valid values: none, low, medium, high, xhigh, max.
+# Valid values: low, medium, high, xhigh, max.
 thinkEffort: max
 
 # Max seconds to wait for one Claude request's upstream Copilot calls.

package/dist/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
 import fs from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
 import { inspect, promisify } from "node:util";
 import consola from "consola";
 import os from "node:os";
@@ -9,7 +10,6 @@ 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 { Hono } from "hono";
@@ -407,7 +407,16 @@ const writeStoredCopilotToken = async (input) => {
 		refreshIn: input.refresh_in,
 		token: input.token
 	};
-	await fs.writeFile(paths.copilotTokenPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
+	const temporaryPath = `${paths.copilotTokenPath}.${randomUUID()}.tmp`;
+	try {
+		await fs.writeFile(temporaryPath, `${JSON.stringify(payload, null, 2)}\n`, {
+			mode: 384,
+			flag: "wx"
+		});
+		await fs.rename(temporaryPath, paths.copilotTokenPath);
+	} finally {
+		await fs.rm(temporaryPath, { force: true });
+	}
 };
 const getStoredTokenRemainingSeconds = (token) => {
 	const ageSeconds = Math.floor((Date.now() - token.refreshedAt) / 1e3);
@@ -460,8 +469,11 @@ const getGitHubUser = async (githubToken, vsCodeVersion) => {
 	if (!response.ok) throw new HTTPError("Failed to get GitHub user", response);
 	return await response.json();
 };
-const getCopilotToken = async (githubToken, vsCodeVersion) => {
-	const response = await fetch(`${githubApiBaseUrl}/copilot_internal/v2/token`, { headers: githubHeaders(githubToken, vsCodeVersion) });
+const getCopilotToken = async (githubToken, vsCodeVersion, signal) => {
+	const response = await fetch(`${githubApiBaseUrl}/copilot_internal/v2/token`, {
+		headers: githubHeaders(githubToken, vsCodeVersion),
+		signal
+	});
 	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
 	return await response.json();
 };
@@ -489,11 +501,21 @@ const loadGitHubLogin = async (githubToken, vsCodeVersion) => {
 };
 const setupProxyAuth = async (config, options = {}) => {
 	let githubToken = await ensureGitHubToken(options);
-	const applyCopilotToken = async () => {
-		const tokenResponse = await getCopilotToken(githubToken, config.vsCodeVersion);
-		config.copilotToken = tokenResponse.token;
-		await writeStoredCopilotToken(tokenResponse);
-		return tokenResponse.refresh_in;
+	let refreshInFlight;
+	const applyCopilotToken = () => {
+		if (refreshInFlight) return refreshInFlight;
+		refreshInFlight = (async () => {
+			const tokenResponse = await getCopilotToken(githubToken, config.vsCodeVersion, AbortSignal.timeout(config.upstreamTimeoutMs > 0 ? config.upstreamTimeoutMs : 18e4));
+			if (typeof tokenResponse.token !== "string" || !tokenResponse.token.trim() || !Number.isFinite(tokenResponse.refresh_in) || tokenResponse.refresh_in <= 0) throw new Error("Copilot token exchange returned invalid credentials metadata.");
+			await writeStoredCopilotToken(tokenResponse);
+			config.copilotToken = tokenResponse.token;
+			config.copilotTokenGeneration = (config.copilotTokenGeneration ?? 0) + 1;
+			scheduleCopilotTokenRefresh(tokenResponse.refresh_in);
+			return tokenResponse.refresh_in;
+		})().finally(() => {
+			refreshInFlight = void 0;
+		});
+		return refreshInFlight;
 	};
 	const scheduleCopilotTokenRefresh = (refreshIn$1) => {
 		if (copilotTokenRefreshTimer) clearTimeout(copilotTokenRefreshTimer);
@@ -501,11 +523,10 @@ const setupProxyAuth = async (config, options = {}) => {
 		log.info(`Next Copilot token refresh in ${Math.round(refreshMs / 1e3)}s`);
 		copilotTokenRefreshTimer = setTimeout(async () => {
 			try {
-				const nextRefreshIn = await applyCopilotToken();
+				await applyCopilotToken();
 				log.info("Refreshed Copilot token");
-				scheduleCopilotTokenRefresh(nextRefreshIn);
-			} catch (error) {
-				log.error("Failed to refresh Copilot token:", error);
+			} catch {
+				log.error("Failed to refresh Copilot token; retrying in 60s");
 				scheduleCopilotTokenRefresh(60);
 			}
 		}, refreshMs);
@@ -517,6 +538,7 @@ const setupProxyAuth = async (config, options = {}) => {
 		config.copilotToken = storedToken.token;
 		refreshIn = getStoredTokenRemainingSeconds(storedToken);
 		log.info(`Using cached Copilot token at ${paths.copilotTokenPath}`);
+		scheduleCopilotTokenRefresh(refreshIn);
 	} else try {
 		refreshIn = await applyCopilotToken();
 	} catch (error) {
@@ -528,7 +550,14 @@ const setupProxyAuth = async (config, options = {}) => {
 		});
 		refreshIn = await applyCopilotToken();
 	}
-	scheduleCopilotTokenRefresh(refreshIn);
+	config.refreshCopilotToken = async (rejectedToken, generation) => {
+		if (config.copilotToken !== rejectedToken || (config.copilotTokenGeneration ?? 0) !== generation) return;
+		try {
+			await applyCopilotToken();
+		} catch {
+			throw new Error("Copilot token refresh failed; upstream request was not replayed.");
+		}
+	};
 	return {
 		githubLogin: await loadGitHubLogin(githubToken, config.vsCodeVersion),
 		source: "github-token"
@@ -541,12 +570,20 @@ const runtimeState = {};
 
 //#endregion
 //#region src/lib/models.ts
+const configurableReasoningEfforts = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
 const defaultReasoningEffort = "max";
 const defaultModelRouting = {
 	gptModel: "gpt-6-astra",
 	opusModel: "claude-opus-5"
 };
-const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+const isConfiguredReasoningEffort = (value) => configurableReasoningEfforts.some((effort) => effort === value);
+const isReasoningEffort = (value) => value === "none" || isConfiguredReasoningEffort(value);
 const invalidRequestEffort = (message) => new HTTPError(message, new Response(JSON.stringify({
 	type: "error",
 	error: {
@@ -736,10 +773,19 @@ const normalizeCopilotBaseUrl = (value) => {
 	if (parsed.username || parsed.password) throw new Error(copilotBaseUrlCredentialsMessage);
 	return trimmed;
 };
+var InvalidThinkEffortError = class extends Error {
+	constructor() {
+		super(`Invalid thinkEffort. Valid values: ${configurableReasoningEfforts.join(", ")}. "none" is not allowed as a configured default.`);
+		this.name = "InvalidThinkEffortError";
+	}
+};
 const normalizeThinkEffort = (value) => {
-	if (typeof value !== "string") return;
-	const normalized = value.toLowerCase() === "minimal" ? "low" : value.toLowerCase();
-	return isReasoningEffort(normalized) ? normalized : void 0;
+	if (value === void 0) return void 0;
+	if (typeof value === "string") {
+		const normalized = value.toLowerCase() === "minimal" ? "low" : value.toLowerCase();
+		if (isConfiguredReasoningEffort(normalized)) return normalized;
+	}
+	throw new InvalidThinkEffortError();
 };
 const normalizeUpstreamTimeoutSeconds = (value) => {
 	if (value === void 0) return;
@@ -858,16 +904,15 @@ const serializeConfig = (config) => [
 	"",
 	"# Log verbosity:",
 	"#   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",
+	"#   info  - error logs plus startup/preflight status, model/effort summaries,",
+	"#           and local HTTP status codes",
+	"#   debug - info logs plus detailed Copilot timings and request payloads",
 	`logLevel: ${config.logLevel}`,
 	"",
 	"# Number of days to keep files in ~/.copilot-relay/logs.",
 	`logRetentionDays: ${config.logRetentionDays}`,
 	"",
-	"# Fallback effort when the request omits it: none, low, medium, high, xhigh, max.",
+	`# Fallback effort when the request omits it: ${configurableReasoningEfforts.join(", ")}.`,
 	`thinkEffort: ${config.thinkEffort}`,
 	"",
 	"# Max seconds for one request's upstream calls; 0 disables the relay deadline.",
@@ -926,7 +971,10 @@ const watchAppConfig = (onReload) => {
 			if (nextMtime === lastMtime) return;
 			lastMtime = nextMtime;
 			onReload(await readAppConfig());
-		} catch {}
+		} catch (error) {
+			if (error instanceof InvalidThinkEffortError) log.error(`${error.message} Keeping the previous runtime settings.`);
+			else log.error(`Could not reload config. Check ${paths.configPath} for invalid values or file errors.`);
+		}
 	}, 1e3);
 	if (typeof timer.unref === "function") timer.unref();
 	getConfigMtime().then((mtime) => {
@@ -1313,7 +1361,13 @@ const copilotDispatcher = new Agent({
 });
 const getCopilotProviderContext = (config) => ({
 	baseUrl: config.copilotBaseUrl,
-	token: config.copilotToken,
+	get token() {
+		return config.copilotToken;
+	},
+	get tokenGeneration() {
+		return config.copilotTokenGeneration ?? 0;
+	},
+	refreshToken: config.refreshCopilotToken,
 	vsCodeVersion: config.vsCodeVersion
 });
 const shouldRetryResponse = (response) => response.status >= 500 && response.status <= 599;
@@ -1379,27 +1433,68 @@ const logUpstreamLifecycle = (requestId, message) => {
 	}
 	log.debug(message);
 };
+const waitWithSignal = (pending, signal) => {
+	if (!signal) return pending;
+	if (signal.aborted) {
+		pending.catch(() => {});
+		return Promise.reject(signal.reason);
+	}
+	return new Promise((resolve$1, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then(resolve$1, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+};
+const isAuthRejection = async (response, signal) => {
+	if (response.status === 401) return true;
+	if (response.status !== 403) return false;
+	const reader = response.clone().body?.getReader();
+	if (!reader) return false;
+	const decoder = new TextDecoder();
+	let text = "";
+	let size = 0;
+	try {
+		for (;;) {
+			const chunk = await waitWithSignal(reader.read(), signal);
+			if (chunk.done) return (text + decoder.decode()).trim().toLowerCase() === "forbidden";
+			size += chunk.value.byteLength;
+			if (size > 128) return false;
+			text += decoder.decode(chunk.value, { stream: true });
+		}
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return false;
+	} finally {
+		reader.cancel().catch(() => {});
+	}
+};
 const fetchCopilot = async (provider, path$1, init, options = {}) => {
 	if (!provider.token) throw new ProxyNotImplementedError("Copilot token is not configured for copilot-relay.");
 	const timeoutMs = options.timeoutMs ?? copilotRequestTimeoutMs;
 	const signal = createCopilotRequestSignal(options.signal, timeoutMs);
 	let lastError;
-	for (let attempt = 1; attempt <= maxFetchAttempts; attempt++) {
+	let transientRetries = 0;
+	let authRecoveryUsed = false;
+	for (let attempt = 1; attempt <= maxFetchAttempts + 1; attempt++) {
 		const upstreamRequestId = randomUUID();
+		const attemptedToken = provider.token;
+		const attemptedGeneration = provider.tokenGeneration ?? 0;
+		let response;
 		try {
 			const started = performance.now();
 			logUpstreamLifecycle(options.requestId, `send upstream method=${init.method ?? "GET"} path=${path$1} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
-			const response = await fetch$1(`${provider.baseUrl}${path$1}`, {
+			response = await fetch$1(`${provider.baseUrl}${path$1}`, {
 				...init,
-				headers: buildHeaders(provider, init, options, upstreamRequestId),
+				headers: buildHeaders({
+					...provider,
+					token: attemptedToken
+				}, init, options, upstreamRequestId),
 				dispatcher: copilotDispatcher,
 				signal
 			});
 			const ms = Math.round(performance.now() - started);
 			logUpstreamLifecycle(options.requestId, `return from upstream method=${init.method ?? "GET"} path=${path$1} status=${response.status} ms=${ms} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
 			log.debug(`${formatRequestId(options.requestId)}Copilot ${init.method ?? "GET"} ${path$1} -> ${response.status} ${ms}ms (attempt ${attempt}) upstream_request_id=${upstreamRequestId}`);
-			if (!shouldRetryResponse(response) || attempt === maxFetchAttempts) return response;
-			log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} returned ${response.status}; retrying (${attempt}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`);
 		} catch (error) {
 			const abortError = toCopilotAbortHTTPError(error, signal, timeoutMs);
 			if (abortError) {
@@ -1408,12 +1503,37 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 			}
 			logUpstreamLifecycle(options.requestId, `upstream failed method=${init.method ?? "GET"} path=${path$1} attempt=${attempt} upstream_request_id=${upstreamRequestId}`);
 			lastError = error;
-			if (attempt === maxFetchAttempts) {
+			if (transientRetries >= maxFetchAttempts - 1) {
 				log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} request failed after ${attempt} attempts upstream_request_id=${upstreamRequestId}`, error);
 				throw error;
 			}
-			log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} request failed; retrying (${attempt}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`, error);
+			transientRetries++;
+			log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} request failed; retrying (${transientRetries}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`, error);
+			continue;
+		}
+		try {
+			signal?.throwIfAborted();
+			if (!authRecoveryUsed && provider.refreshToken && await isAuthRejection(response, signal)) {
+				authRecoveryUsed = true;
+				log.info(`${formatRequestId(options.requestId)}Copilot ${path$1} authentication rejected status=${response.status}; refreshing token`);
+				await response.body?.cancel();
+				signal?.throwIfAborted();
+				await waitWithSignal(provider.refreshToken(attemptedToken, attemptedGeneration), signal);
+				signal?.throwIfAborted();
+				log.info(`${formatRequestId(options.requestId)}Copilot token refresh completed; retrying ${path$1}`);
+				continue;
+			}
+		} catch (error) {
+			response.body?.cancel().catch(() => {});
+			const abortError = toCopilotAbortHTTPError(error, signal, timeoutMs);
+			if (abortError) throw abortError;
+			log.error(`${formatRequestId(options.requestId)}Copilot token recovery failed; request not replayed`);
+			throw new Error("Copilot token recovery failed; request not replayed.");
 		}
+		if (!shouldRetryResponse(response) || transientRetries >= maxFetchAttempts - 1) return response;
+		transientRetries++;
+		log.error(`${formatRequestId(options.requestId)}Copilot ${path$1} returned ${response.status}; retrying (${transientRetries}/${maxFetchAttempts}) upstream_request_id=${upstreamRequestId}`);
+		await response.body?.cancel();
 	}
 	throw lastError;
 };
@@ -1962,7 +2082,8 @@ function translateTools(tools) {
 		type: "function",
 		name: tool.function.name,
 		description: tool.function.description,
-		parameters: normalizeResponsesToolSchema(tool.function.parameters)
+		parameters: normalizeResponsesToolSchema(tool.function.parameters),
+		strict: false
 	}));
 }
 function translateToolChoice(toolChoice) {
@@ -2081,7 +2202,7 @@ const messagesIncludeImage = (messages) => messages.some((msg) => typeof msg.con
 const createChatCompletions = async (config, payload, options = {}) => {
 	const client = options.client ?? "generic";
 	const requestedModel = options.requestedModel ?? payload.model;
-	const requestedThinkEffort = options.requestedThinkEffort ?? getRequestReasoningEffort(payload) ?? "none";
+	const requestedThinkEffort = options.requestedThinkEffort ?? getRequestReasoningEffort(payload) ?? "unset";
 	const reasoningEffort = getRequestedReasoningEffort(payload);
 	const requestedThinking = options.requestedThinking ?? "none";
 	const signal = createCopilotRequestSignal(options.signal, options.timeoutMs);
@@ -2103,7 +2224,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	const enableVision = messagesIncludeImage(compatiblePayload.messages);
 	const initiator = isAgentInitiator(compatiblePayload.messages);
 	const requestPayload = buildRequestPayload(compatiblePayload);
-	log.debug([
+	log.info(sanitizeTerminalString([
 		"Model request",
 		`client=${client}`,
 		`requested_model=${requestedModel}`,
@@ -2111,8 +2232,8 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		`upstream_model=${compatiblePayload.model}`,
 		`requested_think_effort=${requestedThinkEffort}`,
 		`requested_thinking=${requestedThinking}`,
-		`effective_think_effort=${requestPayload.reasoning_effort ?? "none"}`
-	].join(" "));
+		`effective_think_effort=${requestPayload.reasoning_effort ?? "unset"}`
+	].join(" ")));
 	log.debug("Full request payload", { payload: requestPayload });
 	if (useResponsesApi) return completeResponse(await createResponses(provider, compatiblePayload, {
 		vision: enableVision,
@@ -2842,6 +2963,36 @@ const createFailedSearchExecution = (payload, requestedQuery, model, message) =>
 	results: [],
 	text: message
 });
+const getSearchFailureCategory = (status$1) => {
+	if (status$1 === 503) return "service unavailable";
+	if (status$1 >= 500) return "server failure";
+	if (status$1 === 429) return "rate limited";
+	if (status$1 === 401) return "authentication rejected";
+	if (status$1 === 403) return "access denied";
+	return "request failed";
+};
+const getSearchFailureDetail = (body, token) => {
+	let detail = body.trim();
+	try {
+		const parsed = JSON.parse(detail);
+		const error = isRecord(parsed) && isRecord(parsed.error) ? parsed.error : void 0;
+		detail = typeof error?.message === "string" ? error.message : typeof error?.code === "string" ? error.code : "";
+	} catch {
+		if (/^[{[<]/.test(detail)) return "";
+	}
+	detail = scrubSensitiveUrls(sanitizeTerminalString(detail));
+	detail = detail.replace(/https?:\/\/[^\s'"`<>]+/gi, (raw) => {
+		try {
+			const url = new URL(raw);
+			return url.username || url.password || url.search || url.hash ? `${url.origin}/[redacted]` : raw;
+		} catch {
+			return "[redacted]";
+		}
+	});
+	if (token) detail = detail.replaceAll(token, "[redacted]");
+	if (/\b(?:authorization|bearer|api[_ -]?key|password|secret|access[_ -]?token|refresh[_ -]?token)\b/i.test(detail) || /\btoken\s*[=:]/i.test(detail) || /\b(?:gh[pousr]_|github_pat_|sk-|eyJ)[A-Za-z0-9_-]+/.test(detail) || /\b(?:request|payload|prompt|messages|input|headers|conversation)\b["']?\s*[:=]/i.test(detail)) return "";
+	return detail.trim().slice(0, 240);
+};
 const createClaudeWebSearchExecution = async (config, payload, requestedQuery, options = {}) => {
 	const backendModel = getWebSearchBackendModel(config);
 	const signal = createCopilotRequestSignal(options.signal, options.timeoutMs);
@@ -2859,8 +3010,8 @@ const createClaudeWebSearchExecution = async (config, payload, requestedQuery, o
 		timeoutMs: options.timeoutMs
 	});
 	if (!response.ok) {
-		const detail = await readCopilotText(response, signal, options.timeoutMs).catch(() => "");
-		return createFailedSearchExecution(payload, requestedQuery, backendModel, [`Copilot web search is not available for model ${backendModel}.`, detail ? `Upstream response: ${detail}` : ""].filter(Boolean).join("\n"));
+		const detail = getSearchFailureDetail(await readCopilotText(response, signal, options.timeoutMs).catch(() => ""), config.copilotToken);
+		return createFailedSearchExecution(payload, requestedQuery, backendModel, [`Copilot web search upstream ${getSearchFailureCategory(response.status)} (HTTP ${response.status}; model ${backendModel}).`, detail ? `Upstream response: ${detail}` : ""].filter(Boolean).join("\n"));
 	}
 	const upstream = await readCopilotJson(response, signal, options.timeoutMs);
 	const text = getResponseText(upstream);
@@ -3216,7 +3367,7 @@ const createTokenCountModel = (modelId, tokenizer = "o200k_base") => ({
 	id: modelId
 });
 const isNonStreamingResponse = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
-const getClaudeRequestedThinkEffort = (payload) => getRequestReasoningEffort(payload) ?? "none";
+const getClaudeRequestedThinkEffort = (payload) => getRequestReasoningEffort(payload) ?? "unset";
 const getClaudeRequestedThinking = (payload) => {
 	if (!payload.thinking) return "none";
 	return [`type:${payload.thinking.type}`, `budget:${payload.thinking.budget_tokens ?? "none"}`].join(",");
@@ -3645,6 +3796,10 @@ const startServer = (config) => new Promise((resolve$1, reject) => {
 const canCloseConnections = (server) => typeof server.closeIdleConnections === "function" && typeof server.closeAllConnections === "function";
 async function startRelay(appConfig) {
 	appConfig ??= await readAppConfig();
+	appConfig = {
+		...appConfig,
+		thinkEffort: normalizeThinkEffort(appConfig.thinkEffort) ?? defaultReasoningEffort
+	};
 	setLogLevel(appConfig.logLevel);
 	await cleanupLogs(appConfig.logRetentionDays);
 	const claudeConfigPath$1 = claudeConfigPath;