betahi-copilot-bridge 0.19.0 → 0.20.0

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">copilot-bridge</h1>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/betahi-copilot-bridge"><img src="https://img.shields.io/npm/v/betahi-copilot-bridge.svg?v=0.19.0" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/betahi-copilot-bridge"><img src="https://img.shields.io/npm/v/betahi-copilot-bridge.svg?v=0.20.0" alt="npm version"></a>
   <a href="https://github.com/betahi/copilot-bridge/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/betahi-copilot-bridge.svg" alt="license"></a>
 </p>
 
@@ -83,6 +83,7 @@ this block; the bridge regenerates it on every start.
 ```toml
 # >>> copilot-bridge managed block — auto-generated, do not edit between markers >>>
 model_provider = "bridge"
+model_supports_reasoning_summaries = true
 
 [model_providers.bridge]
 name = "Copilot Bridge"
@@ -100,23 +101,8 @@ these keys across rewrites:
 ```toml
 model = "gpt-5.3-codex"
 model_reasoning_effort = "high"
-model_supports_reasoning_summaries = true
 ```
 
-If `model_reasoning_effort` is omitted, the bridge leaves it unset and does not
-send a reasoning effort for Codex requests (a startup info log also reminds you).
-Codex requires `model_supports_reasoning_summaries = true` for custom providers
-to serialize the `reasoning` object; `start --select-model` writes it for you
-when it writes `model_reasoning_effort`.
-
-`model_reasoning_effort` only affects Codex requests; it does not affect Claude.
-
-For Claude Opus 4.7 through Codex, you can keep `model = "claude-opus-4.7"`
-and set `model_reasoning_effort = "high"` or `"xhigh"`; the bridge routes the
-request to the matching Opus 4.7 reasoning variant upstream. Use
-`model = "claude-opus-4.7-1m"` for the 1M context window; it maps to the upstream
-1M model without exposing the upstream-only suffix in your config.
-
 That's it — `codex exec '...'` will now route through the bridge to Copilot.
 
 Use `--no-codex-setup` to skip the managed-block writer entirely (e.g. if you
@@ -173,11 +159,6 @@ project-local `.claude/settings.json` and `.claude/settings.local.json` and
 applied to Claude requests only when the model supports reasoning. If it is not
 configured, Claude requests do not infer or attach a reasoning effort.
 
-For compatibility, `ANTHROPIC_MODEL=claude-opus-4.7` plus
-`MODEL_REASONING_EFFORT=high` or `xhigh` is automatically routed to the matching
-Opus 4.7 reasoning variant upstream, so existing settings keep the intended
-reasoning level.
-
 ## Environment overrides
 
 | Variable                   | Purpose                                              |
@@ -223,6 +204,10 @@ accepts upstream.
 | `claude-sonnet-4`                | —                                       | Reasoning not accepted upstream.       |
 | `claude-haiku-4.5`               | —                                       | Reasoning not accepted upstream.       |
 
+For Claude Opus 4.7, both Codex CLI and Claude Code can use
+`claude-opus-4.7` with reasoning effort `high` or `xhigh`; the bridge routes the
+request to the matching upstream reasoning variant.
+
 ### Gemini family — translated to chat completions
 
 | Model                    | Aliases          |

package/dist/main.js

@@ -439,6 +439,18 @@ const BEGIN_MARK = "# >>> copilot-bridge managed block — auto-generated, do no
 const END_MARK = "# <<< copilot-bridge managed block — edits outside this block are preserved <<<";
 const LEGACY_BEGIN_MARK = "# >>> copilot-bridge managed (do not edit) >>>";
 const LEGACY_END_MARK = "# <<< copilot-bridge managed (do not edit) <<<";
+function normalizeCodexConfigReasoningEffort(value) {
+	switch (value?.toLowerCase()) {
+		case "none":
+		case "minimal":
+		case "low":
+		case "medium":
+		case "high":
+		case "xhigh": return value.toLowerCase();
+		case "max": return "xhigh";
+		default: return;
+	}
+}
 function tomlEscape(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }
@@ -447,6 +459,7 @@ function buildManagedBlock(input) {
 	const lines = [];
 	lines.push(BEGIN_MARK);
 	if (settings.setAsDefault) lines.push(`model_provider = "${tomlEscape(settings.providerId)}"`);
+	lines.push("model_supports_reasoning_summaries = true");
 	lines.push("");
 	lines.push(`[model_providers.${settings.providerId}]`);
 	lines.push(`name = "${tomlEscape(settings.providerName)}"`);
@@ -502,20 +515,25 @@ function setTopScalar(topSection, key, value) {
 	if (topSection.length === 0) return `${line}\n`;
 	return `${line}\n${topSection.startsWith("\n") ? "" : ""}${topSection}`;
 }
-function setTopBoolean(topSection, key, value) {
-	if (value === void 0) return topSection;
-	const re = new RegExp(`^\\s*${key}\\s*=\\s*(true|false)\\s*$`, "m");
-	const line = `${key} = ${value ? "true" : "false"}`;
-	if (re.test(topSection)) return topSection.replace(re, line);
-	if (topSection.length === 0) return `${line}\n`;
-	return `${line}\n${topSection.startsWith("\n") ? "" : ""}${topSection}`;
+function removeTopKey(topSection, key) {
+	const lines = topSection.split("\n");
+	const re = /* @__PURE__ */ new RegExp(`^\\s*${key}\\s*=`);
+	return lines.filter((line) => !re.test(line)).join("\n");
+}
+function sanitizeTopReasoningEffort(topSection) {
+	const match = topSection.match(scalarRegex("model_reasoning_effort"));
+	if (!match) return topSection;
+	const normalized = normalizeCodexConfigReasoningEffort(match[1]);
+	if (!normalized) return removeTopKey(topSection, "model_reasoning_effort");
+	if (normalized === match[1]) return topSection;
+	return topSection.replace(scalarRegex("model_reasoning_effort"), `model_reasoning_effort = "${tomlEscape(normalized)}"`);
 }
 function applyUserScalars(content, input) {
 	const { top, rest } = splitTopSection(content);
-	let nextTop = top;
+	let nextTop = removeTopKey(top, "model_supports_reasoning_summaries");
+	nextTop = sanitizeTopReasoningEffort(nextTop);
 	nextTop = setTopScalar(nextTop, "model", input.model);
-	nextTop = setTopScalar(nextTop, "model_reasoning_effort", input.modelReasoningEffort);
-	nextTop = setTopBoolean(nextTop, "model_supports_reasoning_summaries", input.modelReasoningEffort === void 0 ? void 0 : true);
+	nextTop = setTopScalar(nextTop, "model_reasoning_effort", normalizeCodexConfigReasoningEffort(input.modelReasoningEffort));
 	if (nextTop === top) return content;
 	if (rest.length === 0) return nextTop.endsWith("\n") ? nextTop : `${nextTop}\n`;
 	const sep = nextTop.endsWith("\n") ? "" : "\n";
@@ -2605,9 +2623,9 @@ const routeClaudeOpus47ByReasoningEffort = (model, effort) => {
 		default: return model;
 	}
 };
-const normalizeCodexResponsesRequest = (payload) => {
+const normalizeCodexResponsesRequest = (payload, configuredReasoningEffort) => {
 	const parsed = codexResponsesRequestSchema.parse(payload);
-	const requestedReasoningEffort = isPlainObject(parsed.reasoning) ? parsed.reasoning.effort : void 0;
+	const requestedReasoningEffort = (isPlainObject(parsed.reasoning) ? parsed.reasoning : void 0)?.effort ?? configuredReasoningEffort;
 	const canonical = routeClaudeOpus47ByReasoningEffort(resolveModelId(parsed.model), requestedReasoningEffort);
 	const capability = getModelCapability(canonical);
 	if (!capability) return parsed;
@@ -2619,21 +2637,30 @@ const normalizeCodexResponsesRequest = (payload) => {
 		if ("reasoning" in next) delete next.reasoning;
 		return next;
 	}
-	if ("reasoning" in next) if (!isPlainObject(next.reasoning)) delete next.reasoning;
+	if ("reasoning" in next) if (!isPlainObject(next.reasoning)) if (configuredReasoningEffort === void 0 || configuredReasoningEffort === null) delete next.reasoning;
+	else {
+		const clamped = clampReasoningEffort(canonical, configuredReasoningEffort);
+		if (clamped) next.reasoning = { effort: clamped.effort };
+	}
 	else {
 		const incoming = next.reasoning;
-		if (incoming.effort === void 0 || incoming.effort === null) {
+		const effort = incoming.effort ?? configuredReasoningEffort;
+		if (effort === void 0 || effort === null) {
 			const reasoning = removeReasoningEffort(incoming);
 			if (reasoning) next.reasoning = reasoning;
 			else delete next.reasoning;
 		} else {
-			const clamped = clampReasoningEffort(canonical, incoming.effort);
+			const clamped = clampReasoningEffort(canonical, effort);
 			if (clamped) next.reasoning = {
 				...incoming,
 				effort: clamped.effort
 			};
 		}
 	}
+	else if (configuredReasoningEffort !== void 0 && configuredReasoningEffort !== null) {
+		const clamped = clampReasoningEffort(canonical, configuredReasoningEffort);
+		if (clamped) next.reasoning = { effort: clamped.effort };
+	}
 	const text = isPlainObject(next.text) ? next.text : void 0;
 	if (text && capability.textVerbosity && "verbosity" in text) {
 		const { supported, default: defaultVerbosity } = capability.textVerbosity;
@@ -2671,6 +2698,9 @@ const logResponsesUpstreamError = async (message, response, context) => {
 		request: JSON.stringify(summarizeResponsesRequestForDiagnostics(context.request))
 	});
 };
+const readConfiguredCodexReasoningEffort = async () => {
+	return normalizeCodexConfigReasoningEffort((await readCodexUserConfigFromDisk(process.env.CODEX_CONFIG_PATH ?? CODEX_DEFAULTS.configPath)).modelReasoningEffort);
+};
 responsesRoutes.post("/", async (c) => {
 	try {
 		await checkRateLimit();
@@ -2678,7 +2708,7 @@ responsesRoutes.post("/", async (c) => {
 		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
 		throw error;
 	}
-	const payload = normalizeCodexResponsesRequest(await c.req.json());
+	const payload = normalizeCodexResponsesRequest(await c.req.json(), await readConfiguredCodexReasoningEffort());
 	const provider = getCopilotProviderContext(c.get("config"));
 	const search = new URL(c.req.url).search;
 	const capability = getModelCapability(payload.model);