ghc-proxy 0.5.6 → 0.5.7

package/README.md

@@ -489,3 +489,20 @@ bun run matrix:live --stateful-only --json --model=gpt-5.2-codex
 > - `--stateful-only`: run follow-up/resource probes such as `previous_response_id`, `input_tokens`, and `input_items`
 > - `--all-responses-models`: scan every model that advertises `/responses`
 > - `--model=<id>`: pin the Responses scan to one specific model
+
+### Tool Support Probe
+
+Tests which server-side tool types (bash, text_editor, web_search, memory, etc.) each Copilot model actually accepts. Useful for tracking backend changes over time.
+
+```bash
+bun scripts/probe-all-copilot-tools.ts              # human-readable table
+bun scripts/probe-all-copilot-tools.ts --json        # JSON snapshot to stdout
+bun scripts/probe-all-copilot-tools.ts --model=claude-opus-4.6  # single model
+```
+
+The JSON output is designed for weekly diffing — `generatedAt` is the only volatile field:
+
+```bash
+# Compare two weekly snapshots
+diff <(jq -S 'del(.generatedAt)' week1.json) <(jq -S 'del(.generatedAt)' week2.json)
+```

package/dist/main.mjs

@@ -6340,6 +6340,33 @@ async function cacheVSCodeVersion() {
 	consola.debug(`Using VSCode version: ${response}`);
 }
 
+//#endregion
+//#region src/lib/retry.ts
+/**
+* Retry an async operation with exponential backoff.
+* Delay schedule: baseDelayMs * 2^attempt (0-indexed), e.g. 5s, 10s, 20s, 40s.
+*/
+async function retryWithBackoff(fn, options) {
+	const maxRetries = options?.maxRetries ?? 4;
+	const baseDelayMs = options?.baseDelayMs ?? 5e3;
+	const shouldRetry = options?.shouldRetry ?? (() => true);
+	const onRetry = options?.onRetry;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = error;
+		if (!shouldRetry(error) || attempt >= maxRetries) throw error;
+		const delay = baseDelayMs * 2 ** attempt;
+		onRetry?.(error, attempt, delay);
+		await sleep(delay);
+	}
+	throw lastError;
+}
+function formatErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+
 //#endregion
 //#region src/lib/token.ts
 const TRAILING_SLASHES_RE = /\/+$/;
@@ -6354,20 +6381,28 @@ async function setupCopilotToken() {
 	consola.debug("GitHub Copilot Token fetched successfully!");
 	if (state.config.showToken) consola.info("Copilot token:", response.token);
 	const refreshInterval = (response.refresh_in - 60) * 1e3;
-	const refreshCopilotToken = async () => {
-		consola.debug("Refreshing Copilot token");
-		try {
-			const refreshed = await githubClient.getCopilotToken();
-			applyCopilotTokenState(refreshed);
-			consola.debug("Copilot token refreshed");
-			if (state.config.showToken) consola.info("Refreshed Copilot token:", refreshed.token);
-		} catch (error) {
-			consola.error("Failed to refresh Copilot token:", error);
-		}
+	const scheduleRefresh = () => {
+		setTimeout(() => {
+			refreshCopilotToken(githubClient).then(scheduleRefresh);
+		}, refreshInterval);
 	};
-	setInterval(() => {
-		refreshCopilotToken();
-	}, refreshInterval);
+	scheduleRefresh();
+}
+async function refreshCopilotToken(githubClient) {
+	consola.debug("Refreshing Copilot token");
+	try {
+		const refreshed = await retryWithBackoff(() => githubClient.getCopilotToken(), {
+			shouldRetry: (error) => !(error instanceof HTTPError) || isTransientHttpError(error),
+			onRetry: (error, attempt, delayMs) => {
+				consola.warn(`Token refresh failed (attempt ${attempt + 1}), retrying in ${delayMs / 1e3}s:`, formatErrorMessage(error));
+			}
+		});
+		applyCopilotTokenState(refreshed);
+		consola.debug("Copilot token refreshed");
+		if (state.config.showToken) consola.info("Refreshed Copilot token:", refreshed.token);
+	} catch (error) {
+		consola.error("Failed to refresh Copilot token:", error);
+	}
 }
 async function setupGitHubToken(options) {
 	try {
@@ -6416,6 +6451,17 @@ async function setupGitHubToken(options) {
 function isAuthError(error) {
 	return error instanceof HTTPError && (error.status === 401 || error.status === 403);
 }
+const TRANSIENT_HTTP_STATUSES = new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+function isTransientHttpError(error) {
+	return TRANSIENT_HTTP_STATUSES.has(error.status);
+}
 async function logUser() {
 	const user = await createGitHubClient().getGitHubUser();
 	state.cache.githubLogin = user.login;
@@ -6533,7 +6579,7 @@ const checkUsage = defineCommand({
 
 //#endregion
 //#region src/lib/version.ts
-const VERSION = "0.5.6";
+const VERSION = "0.5.7";
 
 //#endregion
 //#region src/debug.ts
@@ -46879,20 +46925,29 @@ const methodColors = {
 function colorizeMethod(method) {
 	return colorize(methodColors[method] ?? "white", method);
 }
+function getEffectiveModel(info) {
+	return info.steps.length > 0 ? info.steps.at(-1).result : info.originalModel ?? "-";
+}
+function appendModelStep(info, tag, newModel) {
+	if (newModel === getEffectiveModel(info)) return info;
+	return {
+		originalModel: info.originalModel,
+		steps: [...info.steps, {
+			tag,
+			result: newModel
+		}]
+	};
+}
 function formatModelMapping(info) {
 	if (!info) return "";
-	const { originalModel, rewrittenModel, mappedModel } = info;
-	if (!originalModel && !rewrittenModel && !mappedModel) return "";
-	const parts = [];
-	const displayOriginal = originalModel ?? "-";
-	parts.push(colorize("blueBright", displayOriginal));
-	if (rewrittenModel && rewrittenModel !== displayOriginal) {
-		parts.push(colorize("dim", "~>"));
-		parts.push(colorize("cyanBright", rewrittenModel));
-	}
-	if (mappedModel && mappedModel !== (rewrittenModel ?? displayOriginal)) {
-		parts.push(colorize("dim", "→"));
-		parts.push(colorize("greenBright", mappedModel));
+	const { originalModel, steps } = info;
+	if (!originalModel && steps.length === 0) return "";
+	const parts = [colorize("blueBright", originalModel ?? "-")];
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		const isLast = i === steps.length - 1;
+		parts.push(colorize("dim", `-[${step.tag}]->`));
+		parts.push(colorize(isLast ? "greenBright" : "cyanBright", step.result));
 	}
 	return ` ${colorize("dim", "model=")}${parts.join(" ")}`;
 }
@@ -48569,13 +48624,15 @@ function rewriteModel(modelId) {
 	if (userRules) {
 		for (const rule of userRules) if (matchesGlob(rule.from, modelId)) return {
 			originalModel: modelId,
-			model: normalizeToKnownModel(rule.to) ?? rule.to
+			model: normalizeToKnownModel(rule.to) ?? rule.to,
+			reason: "CONFIG_REWRITE"
 		};
 	}
 	const normalized = normalizeToKnownModel(modelId);
 	if (normalized && normalized !== modelId) return {
 		originalModel: modelId,
-		model: normalized
+		model: normalized,
+		reason: "AUTO_CORRECT"
 	};
 	return {
 		originalModel: modelId,
@@ -49279,8 +49336,13 @@ const responsesReasoningSummarySchema = object({
 const responsesReasoningInputSchema = object({
 	id: string().optional(),
 	type: literal("reasoning"),
-	summary: array(responsesReasoningSummarySchema),
-	encrypted_content: string().min(1)
+	summary: array(responsesReasoningSummarySchema).optional(),
+	encrypted_content: string().nullable().optional(),
+	status: _enum([
+		"in_progress",
+		"completed",
+		"incomplete"
+	]).optional()
 }).loose();
 const responsesCompactionInputSchema = object({
 	id: string().min(1),
@@ -49513,7 +49575,11 @@ async function handleCompletionCore({ body, signal, headers }) {
 	const requestContext = normalizeChatRequestContext(payload, headers);
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	const rewrite = applyModelRewrite(payload);
-	const originalModel = rewrite.originalModel;
+	const steps = [];
+	if (rewrite.reason) steps.push({
+		tag: rewrite.reason,
+		result: rewrite.model
+	});
 	const selectedModel = findModelById(payload.model);
 	try {
 		if (selectedModel) {
@@ -49532,11 +49598,10 @@ async function handleCompletionCore({ body, signal, headers }) {
 	}
 	const upstreamSignal = createUpstreamSignalFromConfig(signal);
 	const plan = adapter.toCapiPlan(payload, { requestContext });
-	const modelMapping = {
-		originalModel,
-		rewrittenModel: rewrite.model,
-		mappedModel: plan.resolvedModel
-	};
+	const modelMapping = appendModelStep({
+		originalModel: rewrite.originalModel,
+		steps
+	}, "MODEL_RESOLVE", plan.resolvedModel);
 	const transport = new CopilotTransport(createCopilotClient());
 	consola.debug("Streaming response");
 	return {
@@ -50913,10 +50978,6 @@ const responsesApiEntry = {
 			if (error instanceof TranslationFailure) throw fromTranslationFailure(error);
 			throw error;
 		}
-		const modelMapping = {
-			originalModel: ctx.modelMapping.originalModel,
-			mappedModel: responsesPayload.model
-		};
 		applyContextManagement(responsesPayload, ctx.selectedModel?.capabilities.limits.max_prompt_tokens);
 		compactInputByLatestCompaction(responsesPayload);
 		const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
@@ -50927,7 +50988,7 @@ const responsesApiEntry = {
 				signal: ctx.upstreamSignal.signal,
 				requestContext: ctx.requestContext
 			}), ctx.upstreamSignal),
-			modelMapping
+			modelMapping: ctx.modelMapping
 		};
 	}
 };
@@ -50943,10 +51004,7 @@ const chatCompletionsEntry = {
 			if (error instanceof TranslationFailure) throw fromTranslationFailure(error);
 			throw error;
 		}
-		const modelMapping = {
-			originalModel: ctx.modelMapping.originalModel,
-			mappedModel: plan.resolvedModel
-		};
+		const modelMapping = appendModelStep(ctx.modelMapping, "MODEL_RESOLVE", plan.resolvedModel);
 		consola.debug("Claude Code requested model:", ctx.anthropicPayload.model, "-> Copilot model:", plan.resolvedModel);
 		if (consola.level >= 4) consola.debug("Planned Copilot request payload:", JSON.stringify(plan.payload));
 		return {
@@ -50996,17 +51054,33 @@ async function handleMessagesCore({ body, signal, headers }) {
 	const requestContext = normalizeAnthropicRequestContext(anthropicPayload, headers);
 	if (consola.level >= 4) consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const rewrite = applyModelRewrite(anthropicPayload);
+	const steps = [];
+	if (rewrite.reason) steps.push({
+		tag: rewrite.reason,
+		result: rewrite.model
+	});
 	const betaResult = processAnthropicBetaHeader(headers.get("anthropic-beta"), anthropicPayload.model);
 	if (betaResult.upgradeTarget) {
 		consola.debug(`Beta header context upgrade: ${anthropicPayload.model} → ${betaResult.upgradeTarget}`);
 		anthropicPayload.model = betaResult.upgradeTarget;
+		steps.push({
+			tag: "BETA_UPGRADE",
+			result: betaResult.upgradeTarget
+		});
 	}
 	const anthropicBetaHeader = betaResult.header;
 	const modelRouting = applyMessagesModelPolicy(anthropicPayload, { betaUpgraded: !!betaResult.upgradeTarget });
+	if (modelRouting.reason === "context-upgrade") steps.push({
+		tag: "CONTEXT_UPGRADE",
+		result: modelRouting.routedModel
+	});
+	else if (modelRouting.reason === "compact") steps.push({
+		tag: "COMPACT",
+		result: modelRouting.routedModel
+	});
 	const modelMapping = {
 		originalModel: rewrite.originalModel,
-		rewrittenModel: rewrite.model,
-		mappedModel: modelRouting.routedModel
+		steps
 	};
 	if (modelRouting.reason) consola.debug(`Routed anthropic request via ${modelRouting.reason}:`, `${modelRouting.originalModel} -> ${modelRouting.routedModel}`);
 	const selectedModel = findModelById(anthropicPayload.model);
@@ -51040,8 +51114,10 @@ async function handleMessagesCore({ body, signal, headers }) {
 			upstreamSignal: retrySignal,
 			modelMapping: {
 				originalModel: rewrite.originalModel,
-				rewrittenModel: rewrite.model,
-				mappedModel: upgradeTarget
+				steps: [...steps, {
+					tag: "RETRY_UPGRADE",
+					result: upgradeTarget
+				}]
 			}
 		});
 	}
@@ -51458,8 +51534,10 @@ async function handleResponsesCore({ body, signal, headers }) {
 		result,
 		modelMapping: {
 			originalModel: rewrite.originalModel,
-			rewrittenModel: rewrite.model,
-			mappedModel: effectivePayload.model
+			steps: rewrite.reason ? [{
+				tag: rewrite.reason,
+				result: rewrite.model
+			}] : []
 		}
 	};
 }
@@ -51705,7 +51783,7 @@ function createServer(options) {
 		const model = body && typeof body === "object" && "model" in body ? body.model : void 0;
 		if (typeof model === "string") setRequestModelMapping(request, {
 			originalModel: model,
-			mappedModel: model
+			steps: []
 		});
 	}).onAfterResponse(({ request, requestStart, set }) => {
 		const elapsed = formatElapsed(requestStart);