betahi-copilot-bridge 0.1.5 → 0.1.6

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.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>
 
@@ -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

@@ -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) {
@@ -2338,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);
@@ -2352,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;
@@ -2373,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();
@@ -2396,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,
@@ -2429,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
@@ -2555,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,
@@ -2599,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);
@@ -2633,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`,