betahi-copilot-bridge 0.1.5 → 0.1.7

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" 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.7" 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>
 
@@ -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.
 
@@ -213,10 +220,11 @@ accepts upstream.
 ### Reasoning effort
 
 For OpenAI-compatible clients, unsupported reasoning values are clamped to the
-model capability table instead of being forwarded upstream. 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.
+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

@@ -4,7 +4,7 @@ import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
@@ -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,6 +831,75 @@ 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\.5|gpt-5\.4-mini|gpt-5\.3-codex|gpt-5\.2-codex)(?:-|$)/i;
@@ -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;
@@ -1074,9 +1167,8 @@ const getConfiguredReasoningEffort = (client, claudeSettingsEnv) => {
 };
 const getRequestedReasoningEffort = (payload, claudeSettingsEnv, client) => {
 	const configuredReasoningEffort = getConfiguredReasoningEffort(client, claudeSettingsEnv);
-	const defaultEffort = client === "claude" ? void 0 : 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;
@@ -1087,6 +1179,16 @@ 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) {
@@ -1338,6 +1442,84 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 	}[finishReason];
 }
 
+//#endregion
+//#region src/bridges/claude/tool-names.ts
+const STRICT_TOOL_NAME_CHARS_PATTERN = /^[A-Za-z0-9_-]+$/;
+const DOTTED_TOOL_NAME_CHARS_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const DEFAULT_TOOL_NAME_MAX_LENGTH = 64;
+const EXTENDED_TOOL_NAME_MAX_LENGTH = 128;
+const HASH_LENGTH = 10;
+const getToolNameMapperOptionsForModel = (modelId) => {
+	const normalized = modelId.trim().toLowerCase().replace(/\[1m\]$/, "-1m").replace(/[._]/g, "-");
+	if (/^claude-opus-4-(?:6|7)(?:$|-)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (/^claude-sonnet-4(?:$|-\d{8}$)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (normalized.startsWith("gemini-")) return {
+		allowDots: true,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (/^gpt-5-(?:2|4)(?:$|-)/.test(normalized) || /^gpt-5-(?:2|3)-codex(?:$|-)/.test(normalized) || /^gpt-5-4-mini(?:$|-)/.test(normalized) || /^gpt-5-5(?:$|-)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (normalized.startsWith("gpt-")) return {
+		allowDots: true,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	return {
+		allowDots: false,
+		maxNameLength: DEFAULT_TOOL_NAME_MAX_LENGTH
+	};
+};
+const makeHash = (value) => createHash("sha1").update(value).digest("hex").slice(0, HASH_LENGTH);
+const getAllowedNamePattern = (allowDots) => allowDots ? DOTTED_TOOL_NAME_CHARS_PATTERN : STRICT_TOOL_NAME_CHARS_PATTERN;
+const cleanToolName = (name, allowDots) => {
+	const invalidCharsPattern = allowDots ? /[^A-Za-z0-9_.-]/g : /[^A-Za-z0-9_-]/g;
+	return name.replace(invalidCharsPattern, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+};
+const isValidToolName = (name, maxNameLength, allowDots) => name.length > 0 && name.length <= maxNameLength && getAllowedNamePattern(allowDots).test(name);
+const makeValidToolName = (name, maxNameLength, allowDots) => {
+	if (isValidToolName(name, maxNameLength, allowDots)) return name;
+	const cleaned = cleanToolName(name, allowDots);
+	if (cleaned.length <= maxNameLength) return cleaned;
+	const hash = makeHash(name);
+	const prefixLength = maxNameLength - hash.length - 1;
+	return `${cleaned.slice(0, prefixLength)}_${hash}`;
+};
+const makeUniqueToolName = (name, used, maxNameLength, allowDots) => {
+	const candidate = makeValidToolName(name, maxNameLength, allowDots);
+	if (!used.has(candidate)) return candidate;
+	for (let index = 2;; index++) {
+		const suffix = `_${makeHash(`${name}:${index}`)}`;
+		const prefixLength = maxNameLength - suffix.length;
+		const next = `${cleanToolName(name, allowDots).slice(0, prefixLength)}${suffix}`;
+		if (!used.has(next)) return next;
+	}
+};
+const createAnthropicToolNameMapper = (tools, options = {}) => {
+	const maxNameLength = options.maxNameLength ?? DEFAULT_TOOL_NAME_MAX_LENGTH;
+	const allowDots = options.allowDots ?? false;
+	const anthropicToOpenAI = /* @__PURE__ */ new Map();
+	const openAIToAnthropic = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	for (const tool of tools ?? []) {
+		if (anthropicToOpenAI.has(tool.name)) continue;
+		const openAIName = makeUniqueToolName(tool.name, used, maxNameLength, allowDots);
+		used.add(openAIName);
+		anthropicToOpenAI.set(tool.name, openAIName);
+		openAIToAnthropic.set(openAIName, tool.name);
+	}
+	return {
+		toAnthropic: (name) => openAIToAnthropic.get(name) ?? name,
+		toOpenAI: (name) => anthropicToOpenAI.get(name) ?? makeValidToolName(name, maxNameLength, allowDots)
+	};
+};
+
 //#endregion
 //#region src/bridges/claude/non-stream-translation.ts
 const normalizeClaudeModelAlias = (model) => {
@@ -1433,12 +1615,13 @@ function translateReasoningEffort(payload, settings) {
 	if (budgetTokens <= 24576) return sanitizeReasoningEffortForModel(modelId, "high");
 	return sanitizeReasoningEffortForModel(modelId, "xhigh");
 }
-function translateToOpenAI(payload, settings) {
+function translateToOpenAI(payload, settings, toolNameMapper) {
 	const model = translateModelName(payload.model, settings);
-	const tools = translateAnthropicToolsToOpenAI(payload.tools);
+	const mapper = toolNameMapper ?? createAnthropicToolNameMapper(payload.tools, { ...getToolNameMapperOptionsForModel(model) });
+	const tools = translateAnthropicToolsToOpenAI(payload.tools, mapper);
 	return {
 		model,
-		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
+		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system, mapper),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -1449,12 +1632,12 @@ function translateToOpenAI(payload, settings) {
 		reasoning_effort: translateReasoningEffort(payload, settings),
 		user: payload.metadata?.user_id,
 		tools,
-		tool_choice: tools && tools.length > 0 ? translateAnthropicToolChoiceToOpenAI(payload.tool_choice) : void 0
+		tool_choice: tools && tools.length > 0 ? translateAnthropicToolChoiceToOpenAI(payload.tool_choice, mapper) : void 0
 	};
 }
-function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameMapper) {
 	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message));
+	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapper));
 	return [...systemMessages, ...otherMessages];
 }
 function handleSystemPrompt(system) {
@@ -1488,7 +1671,7 @@ function handleUserMessage(message) {
 	});
 	return newMessages;
 }
-function handleAssistantMessage(message) {
+function handleAssistantMessage(message, toolNameMapper) {
 	if (!Array.isArray(message.content)) return [{
 		role: "assistant",
 		content: mapContent(message.content)
@@ -1504,7 +1687,7 @@ function handleAssistantMessage(message) {
 			id: toolUse.id,
 			type: "function",
 			function: {
-				name: toolUse.name,
+				name: toolNameMapper.toOpenAI(toolUse.name),
 				arguments: JSON.stringify(toolUse.input)
 			}
 		}))
@@ -1540,18 +1723,18 @@ function mapContent(content) {
 	}
 	return contentParts;
 }
-function translateAnthropicToolsToOpenAI(anthropicTools) {
+function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapper) {
 	if (!anthropicTools || anthropicTools.length === 0) return;
 	return anthropicTools.map((tool) => ({
 		type: "function",
 		function: {
-			name: tool.name,
+			name: toolNameMapper.toOpenAI(tool.name),
 			description: tool.description,
 			parameters: tool.input_schema
 		}
 	}));
 }
-function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapper) {
 	if (!anthropicToolChoice) return;
 	switch (anthropicToolChoice.type) {
 		case "auto": return "auto";
@@ -1559,21 +1742,21 @@ function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
 		case "tool":
 			if (anthropicToolChoice.name) return {
 				type: "function",
-				function: { name: anthropicToolChoice.name }
+				function: { name: toolNameMapper.toOpenAI(anthropicToolChoice.name) }
 			};
 			return;
 		case "none": return "none";
 		default: return;
 	}
 }
-function translateToAnthropic(response) {
+function translateToAnthropic(response, toolNameMapper = createAnthropicToolNameMapper(void 0)) {
 	const allTextBlocks = [];
 	const allToolUseBlocks = [];
 	let stopReason = null;
 	stopReason = response.choices[0]?.finish_reason ?? stopReason;
 	for (const choice of response.choices) {
 		allTextBlocks.push(...getAnthropicTextBlocks(choice.message.content));
-		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls));
+		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapper));
 		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
 	}
 	return {
@@ -1602,12 +1785,12 @@ function getAnthropicTextBlocks(messageContent) {
 	}));
 	return [];
 }
-function getAnthropicToolUseBlocks(toolCalls) {
+function getAnthropicToolUseBlocks(toolCalls, toolNameMapper) {
 	if (!toolCalls) return [];
 	return toolCalls.map((toolCall) => ({
 		type: "tool_use",
 		id: toolCall.id,
-		name: toolCall.function.name,
+		name: toolNameMapper.toAnthropic(toolCall.function.name),
 		input: safeJsonParse(toolCall.function.arguments)
 	}));
 }
@@ -1625,7 +1808,7 @@ function isToolBlockOpen(state) {
 	if (!state.contentBlockOpen) return false;
 	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
 }
-function translateChunkToAnthropicEvents(chunk, state) {
+function translateChunkToAnthropicEvents(chunk, state, toolNameMapper = createAnthropicToolNameMapper(void 0)) {
 	const events$1 = [];
 	if (chunk.choices.length === 0) return events$1;
 	const choice = chunk.choices[0];
@@ -1689,10 +1872,11 @@ function translateChunkToAnthropicEvents(chunk, state) {
 				state.contentBlockIndex++;
 				state.contentBlockOpen = false;
 			}
+			const toolName = toolNameMapper.toAnthropic(toolCall.function.name);
 			const anthropicBlockIndex = state.contentBlockIndex;
 			state.toolCalls[toolCall.index] = {
 				id: toolCall.id,
-				name: toolCall.function.name,
+				name: toolName,
 				anthropicBlockIndex
 			};
 			events$1.push({
@@ -1701,7 +1885,7 @@ function translateChunkToAnthropicEvents(chunk, state) {
 				content_block: {
 					type: "tool_use",
 					id: toolCall.id,
-					name: toolCall.function.name,
+					name: toolName,
 					input: {}
 				}
 			});
@@ -1919,10 +2103,14 @@ 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(), await getClaudeSettings());
+	const anthropicPayload = await c.req.json();
+	const claudeSettings = await getClaudeSettings();
+	const upstreamModel = translateModelName(anthropicPayload.model, claudeSettings);
+	const toolNameMapper = createAnthropicToolNameMapper(anthropicPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
+	const openAIPayload = translateToOpenAI(anthropicPayload, claudeSettings, toolNameMapper);
 	try {
 		const response = await createChatCompletions(config, openAIPayload, { client: "claude" });
-		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response));
+		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response, toolNameMapper));
 		return streamSSE(c, async (stream) => {
 			const streamState = {
 				messageStartSent: false,
@@ -1940,7 +2128,7 @@ messageRoutes.post("/", async (c) => {
 					} catch {
 						continue;
 					}
-					const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
+					const events$1 = translateChunkToAnthropicEvents(chunk, streamState, toolNameMapper);
 					for (const event of events$1) await stream.writeSSE({
 						event: event.type,
 						data: JSON.stringify(event)
@@ -2338,6 +2526,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);
@@ -2352,12 +2545,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;
@@ -2373,6 +2575,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();
@@ -2396,6 +2620,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,
@@ -2429,6 +2658,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
@@ -2555,6 +2789,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,
@@ -2599,6 +2838,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);
@@ -2633,7 +2874,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`,