betahi-copilot-bridge 0.1.4 → 0.1.6

package/README.md

@@ -1,11 +1,11 @@
 <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" 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.1.6" 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>
 
-> 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.
+> Use GitHub Copilot as a local OpenAI/Anthropic-compatible API, so [Codex CLI](https://developers.openai.com/codex/cli), [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
@@ -50,8 +50,9 @@ npx betahi-copilot-bridge@latest auth
 npx betahi-copilot-bridge@latest start
 ```
 
-`start` flags: `--host`, `--port`, `--show-token`, `--no-codex-setup`,
-`--select-model`, `--no-prompt`, `--rate-limit <seconds>`, `--wait`.
+`start` flags: `--host`, `--port`, `--show-token`, `--debug`,
+`--no-codex-setup`, `--select-model`, `--no-prompt`,
+`--rate-limit <seconds>`, `--wait`.
 
 After startup the banner prints a **Usage Viewer** link of the form
 `https://betahi.github.io/copilot-bridge?endpoint=http://127.0.0.1:4142/usage`,
@@ -68,6 +69,12 @@ globally for browser-based clients.
 requests (anti–abuse-detection throttle). Add `--wait` to block instead
 of returning HTTP 429 when the window has not elapsed.
 
+`--debug` enables extra upstream error diagnostics in console logs.
+- Includes: token limits, stream mode, tool count, invalid tool names, and suspicious tool-schema paths.
+- Does not include: request messages, prompt text, bearer tokens, tool descriptions, or the full request body.
+
+**Review or redact debug logs before sharing them publicly.**
+
 ## Configure Codex CLI
 
 `start` writes a managed block into **`~/.codex/config.toml`**. You don't edit
@@ -95,8 +102,8 @@ 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).
+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).
 
 `model_reasoning_effort` only affects Codex requests; it does not affect Claude.
 
@@ -153,12 +160,8 @@ Optional slot-specific:
 
 `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).
+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.
 
 ## Environment overrides
 
@@ -168,8 +171,7 @@ If Claude-side reasoning is not configured, Claude requests fall back to
 | `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.          |
-| `MODEL_REASONING_EFFORT`   | Claude-side default reasoning effort (preferred key). |
-| `COPILOT_REASONING_EFFORT` | Alias of `MODEL_REASONING_EFFORT` (backward compatible). |
+| `MODEL_REASONING_EFFORT`   | Claude-side reasoning effort override.              |
 
 
 
@@ -217,13 +219,12 @@ accepts upstream.
 
 ### Reasoning effort
 
-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 `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.
+For OpenAI-compatible clients, unsupported reasoning values are clamped to the
+model capability table instead of being forwarded upstream. If a request omits
+reasoning effort, the bridge leaves it omitted rather than inferring a default.
+Claude-side reasoning can be set globally via `MODEL_REASONING_EFFORT` (env, or
+`env` in `~/.claude/settings.json`); invalid Claude-side values are ignored,
+and per-request `reasoning_effort` takes precedence.
 
 ## Development
 

package/dist/main.js

@@ -60,13 +60,14 @@ const COPILOT_VERSION$2 = "0.26.7";
 const EDITOR_PLUGIN_VERSION$2 = `copilot-chat/${COPILOT_VERSION$2}`;
 const USER_AGENT$2 = `GitHubCopilotChat/${COPILOT_VERSION$2}`;
 const API_VERSION = "2025-04-01";
+const MAX_FETCH_ATTEMPTS = 2;
 const getCopilotProviderContext = (config) => ({
 	baseUrl: config.copilotBaseUrl,
 	token: config.copilotToken,
 	vsCodeVersion: config.vsCodeVersion
 });
-const fetchCopilot = async (provider, path$1, init, options = {}) => {
-	if (!provider.token) throw new BridgeNotImplementedError("COPILOT_TOKEN is not configured for copilot-bridge.");
+const shouldRetryResponse = (response) => response.status >= 500 && response.status <= 599;
+const buildHeaders = (provider, init, options) => {
 	const headers = new Headers(init.headers);
 	headers.set("authorization", `Bearer ${provider.token}`);
 	headers.set("copilot-integration-id", "vscode-chat");
@@ -81,10 +82,22 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 	if (options.initiator) headers.set("x-initiator", options.initiator);
 	if (!headers.has("content-type") && init.body !== void 0) headers.set("content-type", "application/json");
 	if (!headers.has("accept")) headers.set("accept", "application/json");
-	return fetch(`${provider.baseUrl}${path$1}`, {
-		...init,
-		headers
-	});
+	return headers;
+};
+const fetchCopilot = async (provider, path$1, init, options = {}) => {
+	if (!provider.token) throw new BridgeNotImplementedError("COPILOT_TOKEN is not configured for copilot-bridge.");
+	let lastError;
+	for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS; attempt++) try {
+		const response = await fetch(`${provider.baseUrl}${path$1}`, {
+			...init,
+			headers: buildHeaders(provider, init, options)
+		});
+		if (!shouldRetryResponse(response) || attempt === MAX_FETCH_ATTEMPTS) return response;
+	} catch (error) {
+		lastError = error;
+		if (attempt === MAX_FETCH_ATTEMPTS) throw error;
+	}
+	throw lastError;
 };
 
 //#endregion
@@ -171,6 +184,7 @@ const getCopilotToken = async (githubToken, vsCodeVersion) => {
 	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
 	return await response.json();
 };
+const isCopilotTokenError = (error) => error instanceof HTTPError && error.message === "Failed to get Copilot token";
 const ensureGitHubToken = async (config, options = {}) => {
 	await ensurePaths();
 	const existingToken = options.force ? "" : await readGitHubToken$1();
@@ -190,14 +204,25 @@ const setupBridgeAuth = async (config, options = {}) => {
 		await loadModels(config);
 		return;
 	}
-	const githubToken = await ensureGitHubToken(config, options);
+	let githubToken = await ensureGitHubToken(config, options);
 	const applyCopilotToken = async () => {
 		const { refresh_in, token } = await getCopilotToken(githubToken, config.vsCodeVersion);
 		config.copilotToken = token;
 		if (options.showToken) consola.info("Copilot token:", token);
 		return refresh_in;
 	};
-	const refreshIn = await applyCopilotToken();
+	let refreshIn;
+	try {
+		refreshIn = await applyCopilotToken();
+	} catch (error) {
+		if (options.force || !isCopilotTokenError(error)) throw error;
+		consola.warn("Cached GitHub auth could not get a Copilot token; running device auth again.");
+		githubToken = await ensureGitHubToken(config, {
+			...options,
+			force: true
+		});
+		refreshIn = await applyCopilotToken();
+	}
 	const refreshInterval = Math.max(refreshIn - 60, 60) * 1e3;
 	setInterval(async () => {
 		try {
@@ -806,9 +831,78 @@ var RateLimitError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/lib/upstream-diagnostics.ts
+const OPENAI_TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+const TOOL_SCHEMA_SUSPECT_KEYS = new Set([
+	"$defs",
+	"allOf",
+	"definitions",
+	"dependentRequired",
+	"dependentSchemas",
+	"else",
+	"if",
+	"not",
+	"oneOf",
+	"patternProperties",
+	"then"
+]);
+const MAX_DIAGNOSTIC_ITEMS = 8;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getToolName = (tool) => {
+	if (!isRecord(tool)) return "";
+	const functionValue = tool.function;
+	if (isRecord(functionValue) && typeof functionValue.name === "string") return functionValue.name;
+	return typeof tool.name === "string" ? tool.name : "";
+};
+const getToolParameters = (tool) => {
+	if (!isRecord(tool)) return;
+	const functionValue = tool.function;
+	if (isRecord(functionValue) && "parameters" in functionValue) return functionValue.parameters;
+	return tool.parameters;
+};
+const collectSuspiciousSchemaKeys = (value, path$1 = "$", keys = []) => {
+	if (keys.length >= MAX_DIAGNOSTIC_ITEMS) return keys;
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) {
+			collectSuspiciousSchemaKeys(item, `${path$1}[${index}]`, keys);
+			if (keys.length >= MAX_DIAGNOSTIC_ITEMS) break;
+		}
+		return keys;
+	}
+	if (!isRecord(value)) return keys;
+	for (const [key, nestedValue] of Object.entries(value)) {
+		const nextPath = `${path$1}.${key}`;
+		if (TOOL_SCHEMA_SUSPECT_KEYS.has(key)) {
+			if (!keys.includes(nextPath)) keys.push(nextPath);
+			if (keys.length >= MAX_DIAGNOSTIC_ITEMS) break;
+		}
+		collectSuspiciousSchemaKeys(nestedValue, nextPath, keys);
+		if (keys.length >= MAX_DIAGNOSTIC_ITEMS) break;
+	}
+	return keys;
+};
+const summarizeToolsForDiagnostics = (tools) => {
+	if (!Array.isArray(tools) || tools.length === 0) return;
+	const invalidNames = tools.map((tool) => getToolName(tool)).filter((name) => !OPENAI_TOOL_NAME_PATTERN.test(name)).slice(0, MAX_DIAGNOSTIC_ITEMS);
+	const suspiciousSchemas = tools.flatMap((tool) => {
+		const name = getToolName(tool) || "<missing>";
+		const keys = collectSuspiciousSchemaKeys(getToolParameters(tool));
+		return keys.length > 0 ? [{
+			keys,
+			name
+		}] : [];
+	}).slice(0, MAX_DIAGNOSTIC_ITEMS);
+	return {
+		count: tools.length,
+		...invalidNames.length > 0 ? { invalidNames } : {},
+		...suspiciousSchemas.length > 0 ? { suspiciousSchemas } : {}
+	};
+};
+
 //#endregion
 //#region src/services/copilot/responses.ts
-const RESPONSES_ONLY_MODEL_PATTERN = /^(?:gpt-5\.3-codex|gpt-5\.4-mini)(?:-|$)/i;
+const RESPONSES_ONLY_MODEL_PATTERN = /^(?:gpt-5\.5|gpt-5\.4-mini|gpt-5\.3-codex|gpt-5\.2-codex)(?:-|$)/i;
 function shouldUseResponsesApiForModel(model) {
 	return RESPONSES_ONLY_MODEL_PATTERN.test(model);
 }
@@ -1036,7 +1130,6 @@ function getFinishReason(response, hasFunctionCalls) {
 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 sanitizeReasoningEffortForModel = (modelId, reasoningEffort) => {
 	if (!reasoningEffort) return;
 	return clampReasoningEffort(modelId, reasoningEffort)?.effort;
@@ -1070,23 +1163,32 @@ const getEnvValueCaseInsensitive = (env, key) => {
 };
 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");
+	return process.env.MODEL_REASONING_EFFORT ?? getEnvValueCaseInsensitive(claudeSettingsEnv, "MODEL_REASONING_EFFORT");
 };
 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;
+	return sanitizeReasoningEffortForModel(payload.model, requestedReasoningEffort);
 };
 const getRequestedClaudeOpus47Effort = (payload, claudeSettingsEnv, client) => {
 	if (!isClaudeOpus47Model$1(payload.model)) return;
 	const configuredReasoningEffort = getConfiguredReasoningEffort(client, claudeSettingsEnv);
-	return payload.output_config?.effort ?? normalizeClaudeOpus47Effort(payload.reasoning_effort) ?? normalizeClaudeOpus47Effort(configuredReasoningEffort) ?? (client === "claude" ? "medium" : void 0);
+	return payload.output_config?.effort ?? normalizeClaudeOpus47Effort(payload.reasoning_effort) ?? normalizeClaudeOpus47Effort(configuredReasoningEffort);
 };
 const sanitizeUserIdentifier = (user) => {
 	if (!user) return;
 	return user.slice(0, MAX_USER_LENGTH);
 };
+const summarizeRequestForDiagnostics = (payload) => ({
+	max_completion_tokens: payload.max_completion_tokens,
+	max_tokens: payload.max_tokens,
+	message_count: payload.messages.length,
+	output_config_effort: payload.output_config?.effort,
+	reasoning_effort: payload.reasoning_effort,
+	stream: payload.stream ?? void 0,
+	tool_choice: payload.tool_choice,
+	tools: summarizeToolsForDiagnostics(payload.tools)
+});
 const buildRequestPayload = (payload, claudeSettingsEnv, client) => {
 	const requestedReasoningEffort = getRequestedReasoningEffort(payload, claudeSettingsEnv, client);
 	const requestedClaudeOpus47Effort = getRequestedClaudeOpus47Effort(payload, claudeSettingsEnv, client);
@@ -1142,6 +1244,7 @@ const createChatCompletions = async (config, payload, options) => {
 		});
 		await logUpstreamError("Failed to create chat completions", response, {
 			model: payload.model,
+			request: requestPayload,
 			route: "/chat/completions"
 		});
 		throw new HTTPError("Failed to create chat completions", response);
@@ -1179,7 +1282,8 @@ async function logUpstreamError(message, response, context) {
 		model: context.model,
 		status: response.status,
 		statusText: response.statusText,
-		body: errorBody || void 0
+		body: errorBody || void 0,
+		request: runtimeState.debug && context.request ? JSON.stringify(summarizeRequestForDiagnostics(context.request)) : void 0
 	});
 }
 async function shouldRetryWithResponses(response) {
@@ -1422,8 +1526,9 @@ function normalizeReasoningEffort(value) {
 }
 function translateReasoningEffort(payload, settings) {
 	const modelId = translateModelName(payload.model, settings);
-	if (isClaudeModel(modelId)) return;
+	if (isClaudeOpus47Model(modelId)) return;
 	if (payload.reasoning_effort) return sanitizeReasoningEffortForModel(modelId, normalizeReasoningEffort(payload.reasoning_effort));
+	if (isClaudeModel(modelId)) return;
 	if (payload.thinking?.type !== "enabled") return;
 	const budgetTokens = payload.thinking.budget_tokens;
 	if (budgetTokens === void 0) return sanitizeReasoningEffortForModel(modelId, "medium");
@@ -1433,8 +1538,10 @@ function translateReasoningEffort(payload, settings) {
 	return sanitizeReasoningEffortForModel(modelId, "xhigh");
 }
 function translateToOpenAI(payload, settings) {
+	const model = translateModelName(payload.model, settings);
+	const tools = translateAnthropicToolsToOpenAI(payload.tools);
 	return {
-		model: translateModelName(payload.model, settings),
+		model,
 		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
@@ -1445,8 +1552,8 @@ function translateToOpenAI(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)
+		tools,
+		tool_choice: tools && tools.length > 0 ? translateAnthropicToolChoiceToOpenAI(payload.tool_choice) : void 0
 	};
 }
 function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
@@ -1538,7 +1645,7 @@ function mapContent(content) {
 	return contentParts;
 }
 function translateAnthropicToolsToOpenAI(anthropicTools) {
-	if (!anthropicTools) return;
+	if (!anthropicTools || anthropicTools.length === 0) return;
 	return anthropicTools.map((tool) => ({
 		type: "function",
 		function: {
@@ -2335,6 +2442,11 @@ const codexResponsesRequestSchema = z.object({
 	model: z.string().min(1),
 	stream: z.boolean().optional()
 }).passthrough();
+const removeReasoningEffort = (reasoning) => {
+	const next = { ...reasoning };
+	delete next.effort;
+	return Object.keys(next).length > 0 ? next : void 0;
+};
 const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const normalizeCodexResponsesRequest = (payload) => {
 	const parsed = codexResponsesRequestSchema.parse(payload);
@@ -2349,12 +2461,21 @@ const normalizeCodexResponsesRequest = (payload) => {
 		if ("reasoning" in next) delete next.reasoning;
 		return next;
 	}
-	const incoming = isPlainObject(next.reasoning) ? next.reasoning : void 0;
-	const clamped = clampReasoningEffort(canonical, incoming?.effort);
-	if (clamped) next.reasoning = {
-		...incoming ?? {},
-		effort: clamped.effort
-	};
+	if ("reasoning" in next) if (!isPlainObject(next.reasoning)) delete next.reasoning;
+	else {
+		const incoming = next.reasoning;
+		if (incoming.effort === void 0 || incoming.effort === null) {
+			const reasoning = removeReasoningEffort(incoming);
+			if (reasoning) next.reasoning = reasoning;
+			else delete next.reasoning;
+		} else {
+			const clamped = clampReasoningEffort(canonical, incoming.effort);
+			if (clamped) next.reasoning = {
+				...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;
@@ -2370,6 +2491,28 @@ const normalizeCodexResponsesRequest = (payload) => {
 //#endregion
 //#region src/routes/responses.ts
 const responsesRoutes = new Hono();
+const summarizeResponsesRequestForDiagnostics = (payload) => ({
+	has_instructions: Boolean(payload.instructions),
+	input_item_count: Array.isArray(payload.input) ? payload.input.length : void 0,
+	input_kind: typeof payload.input === "string" ? "string" : Array.isArray(payload.input) ? "array" : payload.input === void 0 ? void 0 : typeof payload.input,
+	max_output_tokens: payload.max_output_tokens,
+	reasoning_effort: payload.reasoning?.effort,
+	stream: payload.stream ?? void 0,
+	tool_choice: payload.tool_choice,
+	tools: summarizeToolsForDiagnostics(payload.tools)
+});
+const logResponsesUpstreamError = async (message, response, context) => {
+	if (!runtimeState.debug) return;
+	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,
+		request: JSON.stringify(summarizeResponsesRequestForDiagnostics(context.request))
+	});
+};
 responsesRoutes.post("/", async (c) => {
 	try {
 		await checkRateLimit();
@@ -2393,6 +2536,11 @@ responsesRoutes.post("/", async (c) => {
 				body: JSON.stringify(chatPayload)
 			});
 			if (!upstream$1.ok) {
+				await logResponsesUpstreamError("Failed to create chat completions", upstream$1, {
+					model: payload.model,
+					request: payload,
+					route: "/chat/completions"
+				});
 				const text = await upstream$1.text();
 				return new Response(text, {
 					status: upstream$1.status,
@@ -2426,6 +2574,11 @@ responsesRoutes.post("/", async (c) => {
 			body: JSON.stringify(payload)
 		});
 		const contentType = upstream.headers.get("content-type") ?? "";
+		if (!upstream.ok) await logResponsesUpstreamError("Failed to create responses", upstream, {
+			model: payload.model,
+			request: payload,
+			route: "/responses"
+		});
 		if (payload.stream && upstream.body && contentType.includes("text/event-stream")) return new Response(normalizeResponsesSseStream(upstream.body), {
 			status: upstream.status,
 			headers: upstream.headers
@@ -2552,6 +2705,11 @@ const start = defineCommand({
 			default: false,
 			description: "Print GitHub and Copilot tokens during startup."
 		},
+		debug: {
+			type: "boolean",
+			default: false,
+			description: "Enable upstream request diagnostics in console logs."
+		},
 		"codex-setup": {
 			type: "boolean",
 			default: true,
@@ -2596,6 +2754,8 @@ const start = defineCommand({
 			host: args.host ? String(args.host) : DEFAULT_HOST,
 			port: args.port ? Number(args.port) : envPort !== void 0 ? envPort : claudePort !== void 0 ? claudePort : DEFAULT_PORT
 		});
+		runtimeState.debug = Boolean(args.debug);
+		if (runtimeState.debug) consola.info("Debug mode enabled; upstream errors include request summaries");
 		const rateLimitRaw = args["rate-limit"];
 		if (rateLimitRaw !== void 0) {
 			const parsed = Number.parseInt(String(rateLimitRaw), 10);
@@ -2630,7 +2790,12 @@ const start = defineCommand({
 		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 (chosenModel && !chosenEffort) {
+			const capability = getModelCapability(chosenModel);
+			if (capability && !capability.reasoning) consola.info(`codex model_reasoning_effort not set; ${chosenModel} does not accept reasoning effort`);
+			else if (capability?.reasoning) consola.info(`codex model_reasoning_effort not set; leaving reasoning effort unset for ${chosenModel}`);
+			else consola.info(`codex model_reasoning_effort not set; leaving reasoning effort unset for ${chosenModel}`);
+		}
 		if (!isClaudeCodeMode && args["codex-setup"]) try {
 			const result = await applyCodexConfig({
 				baseUrl: `${baseUrl}/v1`,