betahi-copilot-bridge 0.1.2 → 0.1.4

package/README.md

@@ -1,11 +1,11 @@
-# copilot-bridge
+<h1 align="center">copilot-bridge</h1>
 
-Run GitHub Copilot as a local OpenAI Responses– and Anthropic-compatible
-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.
+<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" 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>
 
-**Supports:** Codex CLI and Claude Code out of the box.
+> Use GitHub Copilot as a local OpenAI/Anthropic-compatible API, so [Codex CLI](https://github.com/openai/codex), [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) and Continue can talk to Copilot with minimal configuration.
 
 > [!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
@@ -118,7 +123,20 @@ Bridge endpoints: `POST /v1/messages`, `POST /v1/messages/count_tokens`.
 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:
+Minimal recommended config is:
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:4142",
+    "ANTHROPIC_AUTH_TOKEN": "dummy",
+    "ANTHROPIC_MODEL": "claude-opus-4.7",
+    "MODEL_REASONING_EFFORT": "medium"
+  }
+}
+```
+
+Optional slot-specific:
 
 ```json
 {
@@ -128,15 +146,19 @@ If you prefer to wire it yourself:
     "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": "claude-opus-4.7"
+    "MODEL_REASONING_EFFORT": "medium"
+  }
 }
 ```
 
-`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
 
@@ -146,7 +168,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
 
@@ -195,7 +220,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.
 
@@ -217,3 +243,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

@@ -326,15 +326,21 @@ const parsePortFromBaseUrl = (baseUrl) => {
 		return;
 	}
 };
-const getClaudeSettingsEnv = async () => {
+const getClaudeSettings = async () => {
 	const merged = {};
+	let model;
 	for (const filePath of getClaudeSettingsPaths()) {
 		const settings = await readClaudeSettingsFile(filePath);
+		if (typeof settings?.model === "string") model = settings.model;
 		if (!settings?.env) continue;
 		for (const [key, value] of Object.entries(settings.env)) if (typeof value === "string") merged[key] = value;
 	}
-	return merged;
+	return {
+		env: merged,
+		model
+	};
 };
+const getClaudeSettingsEnv = async () => (await getClaudeSettings()).env;
 /**
 * Update `~/.claude/settings.json` so its env block points Claude Code at the
 * running bridge. Preserves all unrelated keys (model overrides, plugins,
@@ -386,6 +392,22 @@ async function applyClaudeConfig(input) {
 	};
 }
 
+//#endregion
+//#region src/lib/claude-launch.ts
+const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const pickClaudeLaunchDefaults = (availableModels, preferredModel) => {
+	return { model: preferredModel && availableModels.includes(preferredModel) ? preferredModel : availableModels.includes("gpt-5.3-codex") ? "gpt-5.3-codex" : availableModels[0] ?? "gpt-5.3-codex" };
+};
+const buildClaudeLaunchCommand = (input) => {
+	const env = {
+		ANTHROPIC_BASE_URL: input.baseUrl,
+		ANTHROPIC_AUTH_TOKEN: "dummy",
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+	};
+	return `${Object.entries(env).map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ")} && claude --model ${shellQuote(input.model)}`;
+};
+
 //#endregion
 //#region src/lib/codex-config.ts
 const BEGIN_MARK = "# >>> copilot-bridge managed block — auto-generated, do not edit between markers >>>";
@@ -585,6 +607,10 @@ const MODEL_CAPABILITIES = [
 				"xhigh"
 			],
 			default: "medium"
+		},
+		textVerbosity: {
+			supported: ["medium"],
+			default: "medium"
 		}
 	},
 	{
@@ -696,6 +722,8 @@ const CAPABILITY_BY_ID = new Map(MODEL_CAPABILITIES.flatMap((m) => {
 const resolveModelId = (modelId) => CAPABILITY_BY_ID.get(modelId)?.id ?? modelId;
 const getModelCapability = (modelId) => CAPABILITY_BY_ID.get(modelId);
 const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+const isTextVerbosity = (value) => value === "low" || value === "medium" || value === "high";
+const normalizeRequestedReasoningEffort = (requested) => requested === "minimal" ? "low" : requested;
 const clampReasoningEffort = (modelId, requested) => {
 	const capability = getModelCapability(modelId);
 	if (!capability?.reasoning) return void 0;
@@ -704,14 +732,16 @@ const clampReasoningEffort = (modelId, requested) => {
 		effort: defaultEffort,
 		changed: false
 	};
-	if (!isReasoningEffort(requested)) return {
+	const normalizedRequested = normalizeRequestedReasoningEffort(requested);
+	if (!isReasoningEffort(normalizedRequested)) return {
 		effort: defaultEffort,
 		changed: true,
 		reason: "unsupported-effort"
 	};
-	if (supported.includes(requested)) return {
-		effort: requested,
-		changed: false
+	if (supported.includes(normalizedRequested)) return {
+		effort: normalizedRequested,
+		changed: normalizedRequested !== requested,
+		reason: normalizedRequested !== requested ? "unsupported-effort" : void 0
 	};
 	const order = [
 		"none",
@@ -721,7 +751,7 @@ const clampReasoningEffort = (modelId, requested) => {
 		"xhigh",
 		"max"
 	];
-	const reqIdx = order.indexOf(requested);
+	const reqIdx = order.indexOf(normalizedRequested);
 	const supportedSorted = [...supported].sort((a, b) => order.indexOf(a) - order.indexOf(b));
 	const lowest = supportedSorted[0];
 	const highest = supportedSorted[supportedSorted.length - 1];
@@ -1007,36 +1037,9 @@ const usesMaxCompletionTokens = (modelId) => modelId.startsWith("gpt-5");
 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) => {
-	if (modelId.startsWith("gpt-5.5")) return [
-		"none",
-		"low",
-		"medium",
-		"high",
-		"xhigh"
-	];
-	if (modelId.startsWith("gpt-5.4-mini")) return [
-		"none",
-		"low",
-		"medium"
-	];
-	if (modelId.startsWith("gpt-5.4") || modelId.startsWith("gpt-5.3-codex")) return [
-		"low",
-		"medium",
-		"high",
-		"xhigh"
-	];
-	if (usesMaxCompletionTokens(modelId)) return [
-		"low",
-		"medium",
-		"high",
-		"xhigh"
-	];
-	return [];
-};
 const sanitizeReasoningEffortForModel = (modelId, reasoningEffort) => {
 	if (!reasoningEffort) return;
-	return getAllowedReasoningEfforts(modelId).includes(reasoningEffort) ? reasoningEffort : void 0;
+	return clampReasoningEffort(modelId, reasoningEffort)?.effort;
 };
 const normalizeReasoningEffort$1 = (value) => {
 	switch (value?.toLowerCase()) {
@@ -1059,36 +1062,46 @@ 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 getRequestedClaudeOpus47Effort = (payload, claudeSettingsEnv) => {
+const getRequestedReasoningEffort = (payload, claudeSettingsEnv, client) => {
+	const configuredReasoningEffort = getConfiguredReasoningEffort(client, claudeSettingsEnv);
+	const defaultEffort = client === "claude" ? clampReasoningEffort(payload.model, void 0)?.effort : defaultReasoningEffort(payload.model);
+	const requestedReasoningEffort = payload.reasoning_effort ?? normalizeReasoningEffort$1(configuredReasoningEffort);
+	return sanitizeReasoningEffortForModel(payload.model, requestedReasoningEffort) ?? defaultEffort;
+};
+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 sanitizedPayload = {
+		const shouldAttachReasoningEffort = !isClaudeOpus47Model$1(payload.model);
+		return {
 			...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 ? reasoningEffort : void 0,
 			user: sanitizeUserIdentifier(payload.user)
 		};
-		return reasoningEffort === null || reasoningEffort === void 0 ? sanitizedPayload : {
-			...sanitizedPayload,
-			reasoning_effort: reasoningEffort
-		};
 	}
 	return {
 		...payload,
@@ -1100,13 +1113,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
 	});
@@ -1122,18 +1136,21 @@ 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
 		});
-		consola.error("Failed to create chat completions", response);
+		await logUpstreamError("Failed to create chat completions", response, {
+			model: payload.model,
+			route: "/chat/completions"
+		});
 		throw new HTTPError("Failed to create chat completions", response);
 	}
 	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: {
@@ -1146,12 +1163,25 @@ async function createResponses(provider, payload, claudeSettingsEnv, options) {
 		initiator: options.initiator
 	});
 	if (!response.ok) {
-		consola.error("Failed to create responses", response);
+		await logUpstreamError("Failed to create responses", response, {
+			model: payload.model,
+			route: "/responses"
+		});
 		throw new HTTPError("Failed to create responses", response);
 	}
 	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(() => "");
+	consola.error(message, {
+		route: context.route,
+		model: context.model,
+		status: response.status,
+		statusText: response.statusText,
+		body: errorBody || void 0
+	});
+}
 async function shouldRetryWithResponses(response) {
 	try {
 		return (await response.clone().json()).error?.code === "unsupported_api_for_model";
@@ -1168,7 +1198,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);
@@ -1232,14 +1262,22 @@ embeddingRoutes.post("/", async (c) => {
 const normalizeModelId = (modelId) => modelId.trim().toLowerCase().replaceAll(/[\s._-]+/g, "");
 const stripSnapshotSuffix = (modelId) => {
 	const id = modelId.trim().toLowerCase().replace(/\[1m\]$/, "");
-	if (id.startsWith("claude-sonnet-4-")) return "claude-sonnet-4";
-	if (/^claude-opus-4-7-\d{8}$/.test(id)) return "claude-opus-4.7";
-	if (id.startsWith("claude-opus-4-")) return "claude-opus-4";
+	const claudeSnapshotMatch = id.match(/^claude-(opus|sonnet|haiku)-(\d)-(\d)(-1m)?(?:-\d{8})?$/);
+	if (claudeSnapshotMatch) {
+		const [, family, major, minor, contextWindow = ""] = claudeSnapshotMatch;
+		return `claude-${family}-${major}.${minor}${contextWindow}`;
+	}
 	return id;
 };
 const getAliasCandidates = (modelId) => {
 	const canonicalModelId = stripSnapshotSuffix(modelId);
 	const aliases = new Set([canonicalModelId]);
+	const canonicalClaudeMatch = canonicalModelId.match(/^claude-(opus|sonnet|haiku)-(\d+)\.(\d+)(-1m)?$/);
+	if (canonicalClaudeMatch) {
+		const [, family, major, minor, contextWindow = ""] = canonicalClaudeMatch;
+		aliases.add(`claude-${family}-${major}-${minor}${contextWindow}`);
+		return [...aliases];
+	}
 	const familyMatch = canonicalModelId.match(/^[a-z]+(?:-[a-z]+)*-\d+(?:\.\d+)?/);
 	if (familyMatch) {
 		aliases.add(familyMatch[0]);
@@ -1303,13 +1341,36 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 //#endregion
 //#region src/bridges/claude/non-stream-translation.ts
 const normalizeClaudeModelAlias = (model) => {
-	const normalized = model.trim().toLowerCase().replace(/\[1m\]$/, "");
+	const trimmed = model.trim().toLowerCase();
+	if (trimmed === "opus[1m]") return "claude-opus-4.6-1m";
+	const normalized = trimmed.replace(/\[1m\]$/, "");
+	if (normalized === "opus") return "claude-opus";
+	if (normalized === "sonnet") return "claude-sonnet";
+	if (normalized === "haiku") return "claude-haiku";
 	if (/^claude-(opus|sonnet|haiku)-\d-\d(?:-1m)?$/.test(normalized)) return normalized.replace(/^claude-(opus|sonnet|haiku)-(\d)-(\d)(-1m)?$/, "claude-$1-$2.$3$4");
 	if (/^claude-opus-4-7-\d{8}$/.test(normalized)) return "claude-opus-4.7";
 	return normalized;
 };
-function translateModelName(model) {
-	return resolveUpstreamModelId(normalizeClaudeModelAlias(model));
+const getConfiguredClaudeDefaultModel = (settings) => {
+	if (!settings) return;
+	const env = settings.env ?? {};
+	const topLevelModel = settings.model?.trim();
+	const anthropicModel = env.ANTHROPIC_MODEL;
+	if (!topLevelModel) return anthropicModel;
+	switch (topLevelModel.toLowerCase()) {
+		case "opus[1m]": return env.ANTHROPIC_DEFAULT_OPUS_MODEL ?? topLevelModel;
+		case "opus": return env.ANTHROPIC_DEFAULT_OPUS_MODEL ?? topLevelModel;
+		case "sonnet": return env.ANTHROPIC_DEFAULT_SONNET_MODEL ?? topLevelModel;
+		case "haiku": return env.ANTHROPIC_DEFAULT_HAIKU_MODEL ?? env.ANTHROPIC_SMALL_FAST_MODEL ?? topLevelModel;
+		default: return topLevelModel;
+	}
+};
+const resolveClaudeRequestedModel = (model, settings) => {
+	if (model.trim().toLowerCase() !== "definitely-not-a-real-model") return model;
+	return getConfiguredClaudeDefaultModel(settings) ?? model;
+};
+function translateModelName(model, settings) {
+	return resolveUpstreamModelId(normalizeClaudeModelAlias(resolveClaudeRequestedModel(model, settings)));
 }
 function isClaudeModel(modelId) {
 	return modelId.startsWith("claude-");
@@ -1338,13 +1399,13 @@ function getClaudeOpus47Effort(payload) {
 	if (budgetTokens <= 24576) return "high";
 	return "xhigh";
 }
-function translateThinking(payload) {
-	if (!isClaudeOpus47Model(translateModelName(payload.model))) return;
+function translateThinking(payload, settings) {
+	if (!isClaudeOpus47Model(translateModelName(payload.model, settings))) return;
 	if (payload.thinking?.type === "adaptive") return { type: "adaptive" };
 	return payload.thinking?.type === "enabled" ? { type: "adaptive" } : void 0;
 }
-function translateOutputConfig(payload) {
-	if (!isClaudeOpus47Model(translateModelName(payload.model))) return;
+function translateOutputConfig(payload, settings) {
+	if (!isClaudeOpus47Model(translateModelName(payload.model, settings))) return;
 	const effort = getClaudeOpus47Effort(payload);
 	return effort ? { effort } : void 0;
 }
@@ -1359,8 +1420,8 @@ function normalizeReasoningEffort(value) {
 		default: return;
 	}
 }
-function translateReasoningEffort(payload) {
-	const modelId = translateModelName(payload.model);
+function translateReasoningEffort(payload, settings) {
+	const modelId = translateModelName(payload.model, settings);
 	if (isClaudeModel(modelId)) return;
 	if (payload.reasoning_effort) return sanitizeReasoningEffortForModel(modelId, normalizeReasoningEffort(payload.reasoning_effort));
 	if (payload.thinking?.type !== "enabled") return;
@@ -1371,18 +1432,18 @@ function translateReasoningEffort(payload) {
 	if (budgetTokens <= 24576) return sanitizeReasoningEffortForModel(modelId, "high");
 	return sanitizeReasoningEffortForModel(modelId, "xhigh");
 }
-function translateToOpenAI(payload) {
+function translateToOpenAI(payload, settings) {
 	return {
-		model: translateModelName(payload.model),
+		model: translateModelName(payload.model, settings),
 		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
 		temperature: payload.temperature,
 		top_p: payload.top_p,
-		thinking: translateThinking(payload),
-		output_config: translateOutputConfig(payload),
-		reasoning_effort: translateReasoningEffort(payload),
+		thinking: translateThinking(payload, settings),
+		output_config: translateOutputConfig(payload, settings),
+		reasoning_effort: translateReasoningEffort(payload, settings),
 		user: payload.metadata?.user_id,
 		tools: translateAnthropicToolsToOpenAI(payload.tools),
 		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice)
@@ -1855,9 +1916,9 @@ messageRoutes.post("/", async (c) => {
 		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
 		throw error;
 	}
-	const openAIPayload = translateToOpenAI(await c.req.json());
+	const openAIPayload = translateToOpenAI(await c.req.json(), await getClaudeSettings());
 	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 = {
@@ -1910,7 +1971,7 @@ messageRoutes.post("/count_tokens", async (c) => {
 	try {
 		const anthropicBeta = c.req.header("anthropic-beta");
 		const anthropicPayload = await c.req.json();
-		const openAIPayload = translateToOpenAI(anthropicPayload);
+		const openAIPayload = translateToOpenAI(anthropicPayload, await getClaudeSettings());
 		const selectedModel = resolveModel(openAIPayload.model);
 		if (!selectedModel) {
 			consola.warn(`Model ${openAIPayload.model} not found in registry, returning fallback token count`);
@@ -2294,6 +2355,15 @@ const normalizeCodexResponsesRequest = (payload) => {
 		...incoming ?? {},
 		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;
+		const verbosity = text.verbosity;
+		next.text = {
+			...text,
+			verbosity: isTextVerbosity(verbosity) && supported.includes(verbosity) ? verbosity : defaultVerbosity
+		};
+	}
 	return next;
 };
 
@@ -2482,24 +2552,29 @@ const start = defineCommand({
 			default: false,
 			description: "Print GitHub and Copilot tokens during startup."
 		},
-		"no-codex-setup": {
+		"codex-setup": {
 			type: "boolean",
-			default: false,
+			default: true,
 			description: "Skip writing the bridge provider into ~/.codex/config.toml."
 		},
-		"no-claude-setup": {
+		"claude-setup": {
 			type: "boolean",
-			default: false,
+			default: true,
 			description: "Skip writing ANTHROPIC_BASE_URL into ~/.claude/settings.json."
 		},
+		"claude-code": {
+			type: "boolean",
+			default: false,
+			description: "Print a one-shot `export ... && claude` command and do not modify user config files."
+		},
 		"select-model": {
 			type: "boolean",
 			default: false,
 			description: "Force the model picker even when ~/.codex/config.toml already has a model."
 		},
-		"no-prompt": {
+		prompt: {
 			type: "boolean",
-			default: false,
+			default: true,
 			description: "Never prompt; use the existing model from ~/.codex/config.toml as-is."
 		},
 		"rate-limit": {
@@ -2538,7 +2613,9 @@ const start = defineCommand({
 		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 isClaudeCodeMode = Boolean(args["claude-code"]);
+		if (isClaudeCodeMode) consola.info("--claude-code mode: not modifying ~/.claude/settings.json or ~/.codex/config.toml");
+		if (!isClaudeCodeMode && args["claude-setup"]) try {
 			const claudeResult = await applyClaudeConfig({
 				baseUrl,
 				configPath: claudeConfigPath
@@ -2553,7 +2630,8 @@ const start = defineCommand({
 		const codexUserConfig = await readCodexUserConfigFromDisk(codexConfigPath);
 		let chosenModel = codexUserConfig.model;
 		let chosenEffort = codexUserConfig.modelReasoningEffort;
-		if (!args["no-codex-setup"]) try {
+		if (chosenModel && !chosenEffort) consola.info(`codex model_reasoning_effort not set; using ${chosenModel}'s default reasoning effort`);
+		if (!isClaudeCodeMode && args["codex-setup"]) try {
 			const result = await applyCodexConfig({
 				baseUrl: `${baseUrl}/v1`,
 				configPath: codexConfigPath,
@@ -2580,7 +2658,7 @@ const start = defineCommand({
 			``,
 			`  https://betahi.github.io/copilot-bridge?endpoint=${baseUrl}/usage`
 		].join("\n"));
-		if (!args["no-prompt"] && finalPickable.length > 0 && (args["select-model"] || !chosenModel)) {
+		if (!isClaudeCodeMode && args.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 ${codexConfigPath})`, {
 				type: "select",
@@ -2591,7 +2669,7 @@ const start = defineCommand({
 				chosenModel = selected;
 				const supported = getModelCapability(selected)?.reasoning?.supported;
 				if (chosenEffort && supported && !supported.includes(chosenEffort)) chosenEffort = void 0;
-				if (!args["no-codex-setup"]) try {
+				if (args["codex-setup"]) try {
 					const result = await applyCodexConfig({
 						baseUrl: `${baseUrl}/v1`,
 						configPath: codexConfigPath,
@@ -2605,6 +2683,26 @@ const start = defineCommand({
 				}
 			}
 		}
+		if (isClaudeCodeMode) {
+			const defaults = pickClaudeLaunchDefaults(finalPickable, chosenModel);
+			let selectedModel = defaults.model;
+			if (args.prompt && finalPickable.length > 0) selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+				type: "select",
+				options: finalPickable,
+				initial: defaults.model
+			});
+			const command = buildClaudeLaunchCommand({
+				baseUrl,
+				model: selectedModel
+			});
+			consola.box([
+				"Claude one-shot command",
+				"",
+				`  ${command}`,
+				"",
+				"  The bridge verified this path with explicit --model; current Claude CLI did not reliably honor ANTHROPIC_MODEL env defaults."
+			].join("\n"));
+		}
 		await new Promise((resolve, reject) => {
 			server.on("close", resolve);
 			server.on("error", reject);