betahi-copilot-bridge 0.1.1 → 0.1.3

package/README.md

@@ -5,7 +5,7 @@ endpoint, so [Codex CLI](https://github.com/openai/codex) and
 [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) can
 talk to Copilot transparently.
 
-**Supports:** Codex CLI and Claude Code out of the box.
+**Supports:** **Codex CLI** and **Claude Code** out of the box.
 
 > [!WARNING]
 > This is a reverse-engineered bridge for the GitHub Copilot API. It is not
@@ -95,6 +95,11 @@ model = "gpt-5.3-codex"
 model_reasoning_effort = "high"
 ```
 
+If `model_reasoning_effort` is omitted, the bridge leaves it unset and Codex
+uses that model's default reasoning effort (a startup info log also reminds you).
+
+`model_reasoning_effort` only affects Codex requests; it does not affect Claude.
+
 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
@@ -112,7 +117,13 @@ limit (about 900k succeeds; around 1,000,046 is rejected as too long).
 
 Bridge endpoints: `POST /v1/messages`, `POST /v1/messages/count_tokens`.
 
-Point Claude Code at the bridge through **`~/.claude/settings.json`**:
+`copilot-bridge start` automatically writes `ANTHROPIC_BASE_URL` (and a dummy
+`ANTHROPIC_AUTH_TOKEN` if absent) into **`~/.claude/settings.json`**, so
+`claude` works the moment the bridge is listening — even on a different host
+or port. Pass `--no-claude-setup` to skip this. All other keys in your
+settings file (model overrides, plugins, marketplaces) are preserved.
+
+If you prefer to wire it yourself:
 
 ```json
 {
@@ -122,15 +133,20 @@ Point Claude Code at the bridge through **`~/.claude/settings.json`**:
     "ANTHROPIC_MODEL": "claude-opus-4.7",
     "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4.6",
     "ANTHROPIC_SMALL_FAST_MODEL": "claude-haiku-4.5",
-    "COPILOT_REASONING_EFFORT": "medium"
+    "MODEL_REASONING_EFFORT": "medium"
   },
   "model": "claude-opus-4.7"
 }
 ```
 
-`COPILOT_REASONING_EFFORT` is also read from the project-local
-`.claude/settings.json` and `.claude/settings.local.json` and applied to the
-upstream call when the model supports reasoning.
+`MODEL_REASONING_EFFORT` (case-insensitive key lookup) is also read from the
+project-local `.claude/settings.json` and `.claude/settings.local.json` and
+applied to Claude requests only when the model supports reasoning.
+
+For backward compatibility, `COPILOT_REASONING_EFFORT` is accepted as an alias.
+
+If Claude-side reasoning is not configured, Claude requests fall back to
+`medium` (when the target model supports reasoning).
 
 ## Environment overrides
 
@@ -140,7 +156,10 @@ upstream call when the model supports reasoning.
 | `COPILOT_ACCOUNT_TYPE`     | `individual` \| `business` \| `enterprise`.          |
 | `COPILOT_BASE_URL`         | Override the upstream Copilot base URL.              |
 | `COPILOT_VSCODE_VERSION`   | Override the VS Code version sent upstream.          |
-| `COPILOT_REASONING_EFFORT` | Default reasoning effort when the model supports it. |
+| `MODEL_REASONING_EFFORT`   | Claude-side default reasoning effort (preferred key). |
+| `COPILOT_REASONING_EFFORT` | Alias of `MODEL_REASONING_EFFORT` (backward compatible). |
+
+
 
 ## Supported models
 
@@ -189,7 +208,8 @@ accepts upstream.
 If an unsupported value is sent for a reasoning-capable model, the bridge
 falls back to the model's default (`medium` for the GPT-5 / Claude Opus 4.7
 families) instead of forwarding an invalid request upstream. Set the default
-globally via `COPILOT_REASONING_EFFORT` (env, or `env` in
+globally via `MODEL_REASONING_EFFORT` (or `COPILOT_REASONING_EFFORT` alias)
+(env, or `env` in
 `~/.claude/settings.json`); per-request `reasoning_effort` (or Anthropic
 `thinking.budget_tokens`) takes precedence.
 
@@ -211,3 +231,7 @@ bun run ./src/main.ts start --host 127.0.0.1 --port 4141 --no-prompt
 Adding another CLI: drop a new translator under `src/bridges/<client>/`,
 reuse `src/services/copilot/` for upstream calls, register routes in
 `src/server.ts`, and add tests under `tests/`.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/main.js

@@ -281,6 +281,111 @@ const auth = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/claude-settings.ts
+const getClaudeSettingsPaths = () => {
+	const cwd = process.cwd();
+	const home = process.env.HOME ?? os.homedir();
+	return [
+		path.join(home, ".claude", "settings.json"),
+		path.join(cwd, ".claude", "settings.json"),
+		path.join(cwd, ".claude", "settings.local.json")
+	];
+};
+const readClaudeSettingsFile = async (filePath) => {
+	try {
+		const content = await fs.readFile(filePath, "utf8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		consola.warn(`Failed to read Claude settings from ${filePath}:`, error);
+		return;
+	}
+};
+/**
+* Read just the `ANTHROPIC_BASE_URL` from a single Claude settings file.
+* Used at startup so the user can pin the bridge port by editing one place
+* instead of passing `--port` every time.
+*/
+const readClaudeBaseUrl = async (configPath) => {
+	const value = (await readClaudeSettingsFile(configPath))?.env?.ANTHROPIC_BASE_URL;
+	return typeof value === "string" ? value : void 0;
+};
+/**
+* Parse the port from an `ANTHROPIC_BASE_URL`-style string. Returns
+* `undefined` if the URL is malformed or has no explicit port.
+*/
+const parsePortFromBaseUrl = (baseUrl) => {
+	if (!baseUrl) return void 0;
+	try {
+		const url = new URL(baseUrl);
+		if (!url.port) return void 0;
+		const port = Number.parseInt(url.port, 10);
+		return Number.isFinite(port) && port > 0 ? port : void 0;
+	} catch {
+		return;
+	}
+};
+const getClaudeSettingsEnv = async () => {
+	const merged = {};
+	for (const filePath of getClaudeSettingsPaths()) {
+		const settings = await readClaudeSettingsFile(filePath);
+		if (!settings?.env) continue;
+		for (const [key, value] of Object.entries(settings.env)) if (typeof value === "string") merged[key] = value;
+	}
+	return merged;
+};
+/**
+* Update `~/.claude/settings.json` so its env block points Claude Code at the
+* running bridge. Preserves all unrelated keys (model overrides, plugins,
+* marketplaces, etc.). Sets a dummy auth token only if none is present.
+*/
+async function applyClaudeConfig(input) {
+	const { configPath, baseUrl } = input;
+	let raw = "";
+	let created = false;
+	try {
+		raw = await fs.readFile(configPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") created = true;
+		else throw error;
+	}
+	let parsed = {};
+	if (raw.trim().length > 0) try {
+		parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) parsed = {};
+	} catch {
+		return {
+			configPath,
+			changed: false,
+			created: false
+		};
+	}
+	const env = typeof parsed.env === "object" && parsed.env !== null && !Array.isArray(parsed.env) ? { ...parsed.env } : {};
+	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
+	env.ANTHROPIC_BASE_URL = baseUrl;
+	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
+	const next = {
+		...parsed,
+		env
+	};
+	const serialized = `${JSON.stringify(next, null, 2)}\n`;
+	if (serialized === raw) return {
+		configPath,
+		changed: false,
+		created: false,
+		previousBaseUrl
+	};
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await fs.writeFile(configPath, serialized);
+	return {
+		configPath,
+		changed: true,
+		created,
+		previousBaseUrl
+	};
+}
+
 //#endregion
 //#region src/lib/codex-config.ts
 const BEGIN_MARK = "# >>> copilot-bridge managed block — auto-generated, do not edit between markers >>>";
@@ -395,6 +500,18 @@ async function readCodexUserConfigFromDisk(configPath) {
 	}
 }
 
+//#endregion
+//#region src/lib/defaults.ts
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 4142;
+const CODEX_DEFAULTS = {
+	providerId: "bridge",
+	providerName: "Copilot Bridge",
+	setAsDefault: true,
+	configPath: path.join(os.homedir(), ".codex", "config.toml")
+};
+const CLAUDE_CONFIG_PATH = path.join(os.homedir(), ".claude", "settings.json");
+
 //#endregion
 //#region src/lib/model-capabilities.ts
 const MODEL_CAPABILITIES = [
@@ -615,49 +732,6 @@ const clampReasoningEffort = (modelId, requested) => {
 	};
 };
 
-//#endregion
-//#region src/lib/settings.ts
-const SETTINGS_DIR = path.join(os.homedir(), ".config", "copilot-bridge");
-const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");
-const DEFAULT_SETTINGS = {
-	host: "127.0.0.1",
-	port: 4142,
-	codex: {
-		enabled: true,
-		providerId: "bridge",
-		providerName: "Copilot Bridge",
-		setAsDefault: true,
-		configPath: path.join(os.homedir(), ".codex", "config.toml")
-	}
-};
-function deepMerge(base, override) {
-	if (typeof base !== "object" || base === null || Array.isArray(base) || typeof override !== "object" || override === null || Array.isArray(override)) return override ?? base;
-	const out = { ...base };
-	for (const [key, value] of Object.entries(override)) out[key] = deepMerge(base[key], value);
-	return out;
-}
-async function loadSettings() {
-	try {
-		const raw = await fs.readFile(SETTINGS_FILE, "utf8");
-		return deepMerge(DEFAULT_SETTINGS, JSON.parse(raw));
-	} catch {
-		return {
-			...DEFAULT_SETTINGS,
-			codex: { ...DEFAULT_SETTINGS.codex }
-		};
-	}
-}
-async function ensureSettingsFile() {
-	const settings = await loadSettings();
-	try {
-		await fs.access(SETTINGS_FILE);
-	} catch {
-		await fs.mkdir(SETTINGS_DIR, { recursive: true });
-		await fs.writeFile(SETTINGS_FILE, `${JSON.stringify(settings, null, 2)}\n`);
-	}
-	return settings;
-}
-
 //#endregion
 //#region src/lib/rate-limit.ts
 const sleep = (ms) => new Promise((resolve) => {
@@ -702,37 +776,6 @@ var RateLimitError = class extends Error {
 	}
 };
 
-//#endregion
-//#region src/lib/claude-settings.ts
-const getClaudeSettingsPaths = () => {
-	const cwd = process.cwd();
-	const home = process.env.HOME ?? os.homedir();
-	return [
-		path.join(home, ".claude", "settings.json"),
-		path.join(cwd, ".claude", "settings.json"),
-		path.join(cwd, ".claude", "settings.local.json")
-	];
-};
-const readClaudeSettingsFile = async (filePath) => {
-	try {
-		const content = await fs.readFile(filePath, "utf8");
-		return JSON.parse(content);
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		consola.warn(`Failed to read Claude settings from ${filePath}:`, error);
-		return;
-	}
-};
-const getClaudeSettingsEnv = async () => {
-	const merged = {};
-	for (const filePath of getClaudeSettingsPaths()) {
-		const settings = await readClaudeSettingsFile(filePath);
-		if (!settings?.env) continue;
-		for (const [key, value] of Object.entries(settings.env)) if (typeof value === "string") merged[key] = value;
-	}
-	return merged;
-};
-
 //#endregion
 //#region src/services/copilot/responses.ts
 const RESPONSES_ONLY_MODEL_PATTERN = /^(?:gpt-5\.3-codex|gpt-5\.4-mini)(?:-|$)/i;
@@ -961,7 +1004,7 @@ function getFinishReason(response, hasFunctionCalls) {
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const usesMaxCompletionTokens = (modelId) => modelId.startsWith("gpt-5");
-const isClaudeOpus47Model$1 = (modelId) => modelId === "claude-opus-4.7";
+const isClaudeOpus47Model$1 = (modelId) => modelId.startsWith("claude-opus-4.7");
 const MAX_USER_LENGTH = 64;
 const defaultReasoningEffort = (modelId) => usesMaxCompletionTokens(modelId) ? "medium" : void 0;
 const getAllowedReasoningEfforts = (modelId) => {
@@ -1016,33 +1059,47 @@ const normalizeClaudeOpus47Effort = (value) => {
 		default: return;
 	}
 };
-const getRequestedReasoningEffort = (payload, claudeSettingsEnv) => {
-	const requestedReasoningEffort = payload.reasoning_effort ?? normalizeReasoningEffort$1(process.env.COPILOT_REASONING_EFFORT) ?? normalizeReasoningEffort$1(claudeSettingsEnv.COPILOT_REASONING_EFFORT);
-	return sanitizeReasoningEffortForModel(payload.model, requestedReasoningEffort) ?? defaultReasoningEffort(payload.model);
+const getEnvValueCaseInsensitive = (env, key) => {
+	const direct = env[key];
+	if (typeof direct === "string") return direct;
+	const lower = key.toLowerCase();
+	return Object.entries(env).find(([k]) => k.toLowerCase() === lower)?.[1];
+};
+const getConfiguredReasoningEffort = (client, claudeSettingsEnv) => {
+	if (client !== "claude") return;
+	return process.env.MODEL_REASONING_EFFORT ?? process.env.COPILOT_REASONING_EFFORT ?? getEnvValueCaseInsensitive(claudeSettingsEnv, "MODEL_REASONING_EFFORT") ?? getEnvValueCaseInsensitive(claudeSettingsEnv, "COPILOT_REASONING_EFFORT");
+};
+const getRequestedReasoningEffort = (payload, claudeSettingsEnv, client) => {
+	const configuredReasoningEffort = getConfiguredReasoningEffort(client, claudeSettingsEnv);
+	const defaultEffort = client === "claude" ? "medium" : defaultReasoningEffort(payload.model);
+	const requestedReasoningEffort = payload.reasoning_effort ?? normalizeReasoningEffort$1(configuredReasoningEffort);
+	return sanitizeReasoningEffortForModel(payload.model, requestedReasoningEffort) ?? defaultEffort;
 };
-const getRequestedClaudeOpus47Effort = (payload, claudeSettingsEnv) => {
+const getRequestedClaudeOpus47Effort = (payload, claudeSettingsEnv, client) => {
 	if (!isClaudeOpus47Model$1(payload.model)) return;
-	return payload.output_config?.effort ?? normalizeClaudeOpus47Effort(payload.reasoning_effort) ?? normalizeClaudeOpus47Effort(process.env.COPILOT_REASONING_EFFORT) ?? normalizeClaudeOpus47Effort(claudeSettingsEnv.COPILOT_REASONING_EFFORT);
+	const configuredReasoningEffort = getConfiguredReasoningEffort(client, claudeSettingsEnv);
+	return payload.output_config?.effort ?? normalizeClaudeOpus47Effort(payload.reasoning_effort) ?? normalizeClaudeOpus47Effort(configuredReasoningEffort) ?? (client === "claude" ? "medium" : void 0);
 };
 const sanitizeUserIdentifier = (user) => {
 	if (!user) return;
 	return user.slice(0, MAX_USER_LENGTH);
 };
-const buildRequestPayload = (payload, claudeSettingsEnv) => {
-	const requestedReasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv);
-	const requestedClaudeOpus47Effort = getRequestedClaudeOpus47Effort(payload, claudeSettingsEnv);
+const buildRequestPayload = (payload, claudeSettingsEnv, client) => {
+	const requestedReasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv, client);
+	const requestedClaudeOpus47Effort = getRequestedClaudeOpus47Effort(payload, claudeSettingsEnv, client);
 	const reasoningEffort = usesMaxCompletionTokens(payload.model) && payload.tools !== null && payload.tools !== void 0 && payload.tools.length > 0 ? void 0 : requestedReasoningEffort;
 	if (!usesMaxCompletionTokens(payload.model) || payload.max_tokens === null || payload.max_tokens === void 0) {
+		const shouldAttachReasoningEffort = !isClaudeOpus47Model$1(payload.model);
 		const sanitizedPayload = {
 			...payload,
 			output_config: requestedClaudeOpus47Effort ? {
 				...payload.output_config,
 				effort: requestedClaudeOpus47Effort
 			} : payload.output_config,
-			reasoning_effort: isClaudeOpus47Model$1(payload.model) ? void 0 : payload.reasoning_effort,
+			reasoning_effort: shouldAttachReasoningEffort ? payload.reasoning_effort : void 0,
 			user: sanitizeUserIdentifier(payload.user)
 		};
-		return reasoningEffort === null || reasoningEffort === void 0 ? sanitizedPayload : {
+		return !shouldAttachReasoningEffort || reasoningEffort === null || reasoningEffort === void 0 ? sanitizedPayload : {
 			...sanitizedPayload,
 			reasoning_effort: reasoningEffort
 		};
@@ -1057,13 +1114,14 @@ const buildRequestPayload = (payload, claudeSettingsEnv) => {
 };
 const isAgentInitiator = (messages) => messages.some((msg) => msg.role === "assistant" || msg.role === "tool") ? "agent" : "user";
 const messagesIncludeImage = (messages) => messages.some((msg) => typeof msg.content !== "string" && msg.content?.some((part) => part.type === "image_url"));
-const createChatCompletions = async (config, payload) => {
+const createChatCompletions = async (config, payload, options) => {
 	const provider = getCopilotProviderContext(config);
 	const enableVision = messagesIncludeImage(payload.messages);
 	const initiator = isAgentInitiator(payload.messages);
-	const claudeSettingsEnv = await getClaudeSettingsEnv();
-	const requestPayload = buildRequestPayload(payload, claudeSettingsEnv);
-	if (shouldUseResponsesApiForModel(payload.model)) return createResponses(provider, payload, claudeSettingsEnv, {
+	const client = options?.client ?? "generic";
+	const claudeSettingsEnv = client === "claude" ? await getClaudeSettingsEnv() : {};
+	const requestPayload = buildRequestPayload(payload, claudeSettingsEnv, client);
+	if (shouldUseResponsesApiForModel(payload.model)) return createResponses(provider, payload, claudeSettingsEnv, client, {
 		vision: enableVision,
 		initiator
 	});
@@ -1079,7 +1137,7 @@ const createChatCompletions = async (config, payload) => {
 		initiator
 	});
 	if (!response.ok) {
-		if (await shouldRetryWithResponses(response)) return createResponses(provider, payload, claudeSettingsEnv, {
+		if (await shouldRetryWithResponses(response)) return createResponses(provider, payload, claudeSettingsEnv, client, {
 			vision: enableVision,
 			initiator
 		});
@@ -1089,8 +1147,8 @@ const createChatCompletions = async (config, payload) => {
 	if (payload.stream) return events(response);
 	return await response.json();
 };
-async function createResponses(provider, payload, claudeSettingsEnv, options) {
-	const reasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv);
+async function createResponses(provider, payload, claudeSettingsEnv, client, options) {
+	const reasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv, client);
 	const response = await fetchCopilot(provider, "/responses", {
 		method: "POST",
 		headers: {
@@ -1125,7 +1183,7 @@ chatCompletionRoutes.post("/", async (c) => {
 	try {
 		await checkRateLimit();
 		const payload = await c.req.json();
-		const response = await createChatCompletions(c.var.config, payload);
+		const response = await createChatCompletions(c.var.config, payload, { client: "generic" });
 		if (isNonStreaming(response)) return c.json(response);
 		return streamSSE(c, async (stream) => {
 			for await (const chunk of response) await stream.writeSSE(chunk);
@@ -1272,7 +1330,7 @@ function isClaudeModel(modelId) {
 	return modelId.startsWith("claude-");
 }
 function isClaudeOpus47Model(modelId) {
-	return modelId === "claude-opus-4.7";
+	return modelId.startsWith("claude-opus-4.7");
 }
 function normalizeClaudeEffort(value) {
 	switch (value?.toLowerCase()) {
@@ -1814,7 +1872,7 @@ messageRoutes.post("/", async (c) => {
 	}
 	const openAIPayload = translateToOpenAI(await c.req.json());
 	try {
-		const response = await createChatCompletions(config, openAIPayload);
+		const response = await createChatCompletions(config, openAIPayload, { client: "claude" });
 		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response));
 		return streamSSE(c, async (stream) => {
 			const streamState = {
@@ -2428,11 +2486,11 @@ const start = defineCommand({
 	args: {
 		host: {
 			type: "string",
-			description: "Host to bind (overrides settings.json)."
+			description: `Host to bind (default: ${DEFAULT_HOST}).`
 		},
 		port: {
 			type: "string",
-			description: "Port to listen on (overrides settings.json)."
+			description: `Port to listen on (default: ${DEFAULT_PORT}).`
 		},
 		"show-token": {
 			type: "boolean",
@@ -2444,15 +2502,20 @@ const start = defineCommand({
 			default: false,
 			description: "Skip writing the bridge provider into ~/.codex/config.toml."
 		},
+		"no-claude-setup": {
+			type: "boolean",
+			default: false,
+			description: "Skip writing ANTHROPIC_BASE_URL into ~/.claude/settings.json."
+		},
 		"select-model": {
 			type: "boolean",
 			default: false,
-			description: "Force the model picker even when codex.model is set."
+			description: "Force the model picker even when ~/.codex/config.toml already has a model."
 		},
 		"no-prompt": {
 			type: "boolean",
 			default: false,
-			description: "Never prompt; use codex.model from settings.json as-is."
+			description: "Never prompt; use the existing model from ~/.codex/config.toml as-is."
 		},
 		"rate-limit": {
 			type: "string",
@@ -2465,10 +2528,13 @@ const start = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const settings = await ensureSettingsFile();
+		const claudeConfigPath = CLAUDE_CONFIG_PATH;
+		const claudePort = parsePortFromBaseUrl(await readClaudeBaseUrl(claudeConfigPath));
+		const envPortRaw = process.env.PORT;
+		const envPort = envPortRaw && Number.isFinite(Number(envPortRaw)) ? Number(envPortRaw) : void 0;
 		const config = readBridgeConfig({
-			host: args.host ? String(args.host) : settings.host,
-			port: args.port ? Number(args.port) : settings.port
+			host: args.host ? String(args.host) : DEFAULT_HOST,
+			port: args.port ? Number(args.port) : envPort !== void 0 ? envPort : claudePort !== void 0 ? claudePort : DEFAULT_PORT
 		});
 		const rateLimitRaw = args["rate-limit"];
 		if (rateLimitRaw !== void 0) {
@@ -2485,48 +2551,76 @@ const start = defineCommand({
 		const server = startServer(config);
 		consola.success(`copilot-bridge listening on http://${config.host}:${config.port}`);
 		consola.info(`copilot base url: ${config.copilotBaseUrl}`);
+		const baseUrl = `http://${config.host}:${config.port}`;
+		const codexConfigPath = CODEX_DEFAULTS.configPath;
+		if (!args["no-claude-setup"]) try {
+			const claudeResult = await applyClaudeConfig({
+				baseUrl,
+				configPath: claudeConfigPath
+			});
+			if (claudeResult.changed) {
+				consola.success(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
+				if (claudeResult.previousBaseUrl && claudeResult.previousBaseUrl !== baseUrl) consola.info(`ANTHROPIC_BASE_URL: ${claudeResult.previousBaseUrl} → ${baseUrl}`);
+			} else consola.info(`claude settings already up to date: ${claudeResult.configPath}`);
+		} catch (error) {
+			consola.warn(`Could not update claude settings (${claudeConfigPath}):`, error);
+		}
+		const codexUserConfig = await readCodexUserConfigFromDisk(codexConfigPath);
+		let chosenModel = codexUserConfig.model;
+		let chosenEffort = codexUserConfig.modelReasoningEffort;
+		if (chosenModel && !chosenEffort) consola.info(`codex model_reasoning_effort not set; using ${chosenModel}'s default reasoning effort`);
+		if (!args["no-codex-setup"]) try {
+			const result = await applyCodexConfig({
+				baseUrl: `${baseUrl}/v1`,
+				configPath: codexConfigPath,
+				settings: CODEX_DEFAULTS,
+				model: chosenModel,
+				modelReasoningEffort: chosenEffort
+			});
+			if (result.changed) {
+				consola.success(`codex config ${result.created ? "created" : "updated"}: ${result.configPath}`);
+				if (CODEX_DEFAULTS.setAsDefault) consola.info(`codex now defaults to provider "${CODEX_DEFAULTS.providerId}". Run \`codex exec "..."\` directly.`);
+				else consola.info(`provider "${CODEX_DEFAULTS.providerId}" registered. Use \`codex -c model_provider="${CODEX_DEFAULTS.providerId}" ...\``);
+			} else consola.info(`codex config already up to date: ${result.configPath}`);
+		} catch (error) {
+			consola.warn(`Could not update codex config (${codexConfigPath}):`, error);
+		}
 		const models = await fetchAvailableModels(config);
 		const supportedIds = new Set(MODEL_CAPABILITIES.map((m) => m.id));
 		const pickable = models.length > 0 ? models.filter((id) => supportedIds.has(id)) : MODEL_CAPABILITIES.map((m) => m.id);
 		const finalPickable = pickable.length > 0 ? pickable : MODEL_CAPABILITIES.map((m) => m.id);
 		if (models.length > 0) consola.info(`Available models:\n${models.map((id) => `- ${id}${supportedIds.has(id) ? " (bridge-supported)" : ""}`).join("\n")}`);
 		else consola.warn("Could not fetch model list from upstream Copilot API");
-		const codexUserConfig = await readCodexUserConfigFromDisk(settings.codex.configPath);
-		let chosenModel = codexUserConfig.model;
-		let chosenEffort = codexUserConfig.modelReasoningEffort;
+		consola.box([
+			`🌐 Usage viewer`,
+			``,
+			`  https://betahi.github.io/copilot-bridge?endpoint=${baseUrl}/usage`
+		].join("\n"));
 		if (!args["no-prompt"] && finalPickable.length > 0 && (args["select-model"] || !chosenModel)) {
 			const defaultId = chosenModel && finalPickable.includes(chosenModel) ? chosenModel : finalPickable.includes("gpt-5.3-codex") ? "gpt-5.3-codex" : finalPickable[0];
-			const selected = await consola.prompt(`Select a model for codex (writes to ${settings.codex.configPath})`, {
+			const selected = await consola.prompt(`Select a model for codex (writes to ${codexConfigPath})`, {
 				type: "select",
 				options: finalPickable,
 				initial: defaultId
 			});
-			if (selected) {
+			if (selected && selected !== chosenModel) {
 				chosenModel = selected;
 				const supported = getModelCapability(selected)?.reasoning?.supported;
 				if (chosenEffort && supported && !supported.includes(chosenEffort)) chosenEffort = void 0;
+				if (!args["no-codex-setup"]) try {
+					const result = await applyCodexConfig({
+						baseUrl: `${baseUrl}/v1`,
+						configPath: codexConfigPath,
+						settings: CODEX_DEFAULTS,
+						model: chosenModel,
+						modelReasoningEffort: chosenEffort
+					});
+					if (result.changed) consola.success(`codex config updated: ${result.configPath}`);
+				} catch (error) {
+					consola.warn(`Could not update codex config (${codexConfigPath}):`, error);
+				}
 			}
 		}
-		const baseUrl = `http://${config.host}:${config.port}`;
-		consola.box([
-			`🌐 Usage viewer`,
-			``,
-			`  https://betahi.github.io/copilot-bridge?endpoint=${baseUrl}/usage`
-		].join("\n"));
-		if (settings.codex.enabled && !args["no-codex-setup"]) {
-			const result = await applyCodexConfig({
-				baseUrl: `${baseUrl}/v1`,
-				configPath: settings.codex.configPath,
-				settings: settings.codex,
-				model: chosenModel,
-				modelReasoningEffort: chosenEffort
-			});
-			if (result.changed) {
-				consola.success(`codex config ${result.created ? "created" : "updated"}: ${result.configPath}`);
-				if (settings.codex.setAsDefault) consola.info(`codex now defaults to provider "${settings.codex.providerId}". Run \`codex exec "..."\` directly.`);
-				else consola.info(`provider "${settings.codex.providerId}" registered. Use \`codex -c model_provider="${settings.codex.providerId}" ...\``);
-			} else consola.info(`codex config already up to date: ${result.configPath}`);
-		}
 		await new Promise((resolve, reject) => {
 			server.on("close", resolve);
 			server.on("error", reject);