copilot-relay 0.3.6 → 0.3.8

package/README.md

@@ -117,12 +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,
@@ -208,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
 
@@ -39,8 +38,9 @@ logLevel: info
 # midnight, which is what makes this setting take effect at all.
 logRetentionDays: 3
 
-# Default upstream thinking/reasoning effort sent to Copilot.
-# Valid values: none, low, medium, high, xhigh, max.
+# Fallback upstream effort when Claude Code does not specify one.
+# Request output_config.effort wins, followed by legacy reasoning_effort.
+# 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

@@ -541,12 +541,43 @@ 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: {
+		type: "invalid_request_error",
+		message
+	}
+}), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}), message);
+function getRequestReasoningEffort(request) {
+	let nativeEffort;
+	const outputConfig = request.output_config;
+	if (outputConfig !== void 0 && outputConfig !== null) {
+		if (typeof outputConfig !== "object" || Array.isArray(outputConfig)) throw invalidRequestEffort("Invalid output_config: expected an object.");
+		if ("effort" in outputConfig) nativeEffort = outputConfig.effort;
+	}
+	const requested = nativeEffort ?? request.reasoning_effort;
+	if (requested === void 0 || requested === null) return void 0;
+	if (!isReasoningEffort(requested)) throw invalidRequestEffort(`Invalid ${nativeEffort !== void 0 && nativeEffort !== null ? "output_config.effort" : "reasoning_effort"}: expected none, low, medium, high, xhigh, or max.`);
+	return requested;
+}
+const resolveReasoningEffort = (requested) => requested ?? runtimeState.thinkEffort ?? defaultReasoningEffort;
 const oneMillionContextModelPattern = /^(gpt-5\.6-sol|gpt-6-astra)(?:\[1m\])*$/i;
 const normalizeOneMillionContextModel = (model) => {
 	return oneMillionContextModelPattern.exec(model)?.[1]?.toLowerCase();
@@ -713,10 +744,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;
@@ -835,16 +875,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}`,
 	"",
-	"# Default upstream thinking/reasoning effort: 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.",
@@ -903,7 +942,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) => {
@@ -1993,7 +2035,7 @@ const sanitizeReasoningEffortForModel = (_modelId, reasoningEffort) => {
 	return reasoningEffort ?? void 0;
 };
 const getRequestedReasoningEffort = (payload) => {
-	return sanitizeReasoningEffortForModel(payload.model, runtimeState.thinkEffort ?? defaultReasoningEffort);
+	return sanitizeReasoningEffortForModel(payload.model, resolveReasoningEffort(getRequestReasoningEffort(payload)));
 };
 const sanitizeUserIdentifier = (user) => {
 	if (!user) return;
@@ -2058,7 +2100,8 @@ 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 ?? payload.reasoning_effort ?? "none";
+	const requestedThinkEffort = options.requestedThinkEffort ?? getRequestReasoningEffort(payload) ?? "unset";
+	const reasoningEffort = getRequestedReasoningEffort(payload);
 	const requestedThinking = options.requestedThinking ?? "none";
 	const signal = createCopilotRequestSignal(options.signal, options.timeoutMs);
 	const upstreamModelId = routeModelId(payload.model);
@@ -2069,6 +2112,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	const upstreamPayload = {
 		...payload,
 		model: upstreamModelId,
+		reasoning_effort: reasoningEffort,
 		max_tokens: maxTokens,
 		stream: bufferResponse ? true : payload.stream
 	};
@@ -2078,7 +2122,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}`,
@@ -2086,8 +2130,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,
@@ -2325,7 +2369,7 @@ function translateToOpenAI(payload, _settings, toolNameMapper) {
 		stream: payload.stream,
 		temperature: payload.temperature,
 		top_p: payload.top_p,
-		reasoning_effort: runtimeState.thinkEffort ?? defaultReasoningEffort,
+		reasoning_effort: resolveReasoningEffort(getRequestReasoningEffort(payload)),
 		user: payload.metadata?.user_id,
 		tools,
 		tool_choice: tools && tools.length > 0 ? translateClaudeToolChoiceToOpenAI(payload.tool_choice, mapper) : void 0
@@ -2770,6 +2814,7 @@ const buildWebSearchRequestPayload = (payload, requestedQuery, model) => ({
 	model,
 	input: buildSearchInput(payload, requestedQuery),
 	tools: [{ type: "web_search_preview" }],
+	reasoning: { effort: resolveReasoningEffort(getRequestReasoningEffort(payload)) },
 	max_output_tokens: Math.max(256, Math.min(payload.max_tokens ?? 1024, 1200)),
 	temperature: payload.temperature,
 	top_p: payload.top_p
@@ -3190,7 +3235,7 @@ const createTokenCountModel = (modelId, tokenizer = "o200k_base") => ({
 	id: modelId
 });
 const isNonStreamingResponse = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
-const getClaudeRequestedThinkEffort = (payload) => payload.reasoning_effort ?? "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(",");
@@ -3368,7 +3413,10 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 		const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(effectiveResponse, toolNameMapper) : void 0;
 		let claudeResponse;
 		if (webSearchToolCall) {
-			const search = await createClaudeWebSearchExecution(config, claudePayload, webSearchToolCall.query, {
+			const search = await createClaudeWebSearchExecution(config, {
+				...claudePayload,
+				reasoning_effort: openAIPayload.reasoning_effort
+			}, webSearchToolCall.query, {
 				requestId,
 				signal: requestSignal,
 				timeoutMs: config.upstreamTimeoutMs
@@ -3441,6 +3489,14 @@ claudeRoutes.post("/messages", async (c) => {
 	const config = c.get("config");
 	const requestId = c.get("requestId");
 	const claudePayload = await c.req.json();
+	try {
+		getRequestReasoningEffort(claudePayload);
+	} catch (error) {
+		if (!(error instanceof HTTPError)) throw error;
+		c.set("requestErrorMessage", error.message);
+		log.error(`request_id=${requestId} ${error.message}`);
+		return error.response;
+	}
 	const requestSignal = createCopilotRequestSignal(c.req.raw.signal, config.upstreamTimeoutMs);
 	log.debug("Full Claude request payload", { payload: claudePayload });
 	if (claudePayload.stream) return streamSSE(c, async (stream) => {
@@ -3500,6 +3556,10 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 		return c.json({ input_tokens: Math.max(1, finalTokenCount) });
 	} catch (error) {
 		log.error("Error counting tokens:", error);
+		if (error instanceof HTTPError) {
+			c.set("requestErrorMessage", error.message);
+			return error.response;
+		}
 		return c.json({ input_tokens: 1 });
 	}
 });
@@ -3604,6 +3664,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;
@@ -3627,7 +3691,7 @@ async function startRelay(appConfig) {
 	};
 	applyRuntimeConfig(appConfig);
 	log.info(`Log level: ${appConfig.logLevel}`);
-	log.info(`Think effort: ${appConfig.thinkEffort}`);
+	log.info(`Default think effort: ${appConfig.thinkEffort}`);
 	log.info(`Upstream timeout: ${appConfig.upstreamTimeoutSeconds}s`);
 	const authSession = await setupProxyAuth(config);
 	try {