copilot-relay 0.2.0 → 0.2.2

package/README.md

@@ -37,7 +37,17 @@ Routing:
 | Requested model | Upstream model |
 | --- | --- |
 | contains `opus` | `claude-opus-4.8` |
-| anything else | `gpt-5.6-sol` |
+| `gpt-5.6-sol[1m]`, plain `gpt-5.6-sol`, or another non-Opus alias | `gpt-5.6-sol` |
+
+The relay advertises `gpt-5.6-sol[1m]` to Claude Code. The `[1m]` selector
+changes Claude Code's client-side context budgeting only; every Copilot request
+still uses `gpt-5.6-sol`, and the relay cannot enlarge GitHub Copilot's upstream
+capacity. An explicit CLI or API model override that bypasses the managed Claude
+settings is outside this guarantee.
+
+Claude Code can still show its built-in Haiku and Sonnet picker entries. The
+managed `model` field sets the startup default but does not restrict
+`availableModels`; selecting any non-Opus alias still follows the GPT route.
 
 ## Install & run
 
@@ -48,7 +58,11 @@ npx copilot-relay@latest restart
 npx copilot-relay@latest stop
 ```
 
-`start` writes `ANTHROPIC_BASE_URL` and a dummy `ANTHROPIC_AUTH_TOKEN` into `~/.claude/settings.json`.
+With `claudeSetup: true`, `start` manages `ANTHROPIC_BASE_URL`, a dummy
+`ANTHROPIC_AUTH_TOKEN` when auth is absent, and the configured GPT default via
+the top-level `model` field in `~/.claude/settings.json`. Exact
+`gpt-5.6-sol` model overrides are normalized to the Claude-facing
+`gpt-5.6-sol[1m]` identity; unrelated model choices are preserved.
 
 ## Config
 

package/dist/main.js

@@ -349,8 +349,24 @@ const defaultModelRouting = {
 	opusModel: "claude-opus-4.8"
 };
 const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
-const getModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
+const exactGpt56SolPattern = /^gpt-5\.6-sol(?:\[1m\])*$/i;
+const claudeContextModelId = "gpt-5.6-sol[1m]";
+const copilotModelId = "gpt-5.6-sol";
+const normalizeClaudeModelId = (model) => exactGpt56SolPattern.test(model) ? claudeContextModelId : model;
+const normalizeCopilotModelId = (model) => exactGpt56SolPattern.test(model) ? copilotModelId : model;
+const getConfiguredModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
+const getModelRouting = () => {
+	const routing = getConfiguredModelRouting();
+	return {
+		gptModel: normalizeCopilotModelId(routing.gptModel),
+		opusModel: normalizeCopilotModelId(routing.opusModel)
+	};
+};
 const getExposedModelIds = () => {
+	const routing = getConfiguredModelRouting();
+	return [normalizeClaudeModelId(routing.gptModel), routing.opusModel];
+};
+const getUpstreamModelIds = () => {
 	const routing = getModelRouting();
 	return [routing.gptModel, routing.opusModel];
 };
@@ -806,13 +822,30 @@ const stopExistingRelay = async (config) => {
 
 //#endregion
 //#region src/lib/claude-settings.ts
+const knownModelEnvKeys = [
+	"ANTHROPIC_MODEL",
+	"ANTHROPIC_DEFAULT_SONNET_MODEL",
+	"ANTHROPIC_DEFAULT_HAIKU_MODEL",
+	"ANTHROPIC_DEFAULT_OPUS_MODEL",
+	"ANTHROPIC_DEFAULT_FABLE_MODEL",
+	"ANTHROPIC_SMALL_FAST_MODEL",
+	"CLAUDE_CODE_SUBAGENT_MODEL"
+];
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasMalformedModelOverride = (parsed) => {
+	if (parsed.model !== void 0 && typeof parsed.model !== "string") return true;
+	const env = parsed.env;
+	if (!isRecord$1(env)) return false;
+	return knownModelEnvKeys.some((key) => env[key] !== void 0 && typeof env[key] !== "string");
+};
+const hasPrimaryModelOverride = (parsed, env) => typeof parsed.model === "string" || typeof env.ANTHROPIC_MODEL === "string";
 /**
 * Update `~/.claude/settings.json` so its env block points Claude Code at the
-* running proxy. Preserves all unrelated keys (model overrides, plugins,
-* marketplaces, etc.). Sets a dummy auth token only if none is present.
+* running proxy. Preserves unrelated keys and model choices while normalizing
+* managed gpt-5.6-sol overrides. Sets a dummy auth token only if none is present.
 */
 async function applyClaudeConfig(input) {
-	const { configPath: configPath$1, baseUrl } = input;
+	const { configPath: configPath$1, baseUrl, gptModel } = input;
 	let raw = "";
 	let created = false;
 	try {
@@ -822,9 +855,19 @@ async function applyClaudeConfig(input) {
 		else throw error;
 	}
 	let parsed = {};
+	if (!created && raw.trim().length === 0) return {
+		configPath: configPath$1,
+		changed: false,
+		created: false
+	};
 	if (raw.trim().length > 0) try {
-		parsed = JSON.parse(raw);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) parsed = {};
+		const value = JSON.parse(raw);
+		if (!isRecord$1(value) || value.env !== void 0 && !isRecord$1(value.env) || hasMalformedModelOverride(value)) return {
+			configPath: configPath$1,
+			changed: false,
+			created: false
+		};
+		parsed = value;
 	} catch {
 		return {
 			configPath: configPath$1,
@@ -832,12 +875,19 @@ async function applyClaudeConfig(input) {
 			created: false
 		};
 	}
-	const env = typeof parsed.env === "object" && parsed.env !== null && !Array.isArray(parsed.env) ? { ...parsed.env } : {};
+	const env = isRecord$1(parsed.env) ? { ...parsed.env } : {};
 	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
+	const hadPrimaryModelOverride = hasPrimaryModelOverride(parsed, env);
+	const claudeGptModel = normalizeClaudeModelId(gptModel);
+	const shouldSeedTopLevelModel = !hadPrimaryModelOverride;
+	const nextModel = typeof parsed.model === "string" ? normalizeClaudeModelId(parsed.model) : void 0;
+	for (const key of knownModelEnvKeys) if (typeof env[key] === "string") env[key] = normalizeClaudeModelId(env[key]);
 	env.ANTHROPIC_BASE_URL = baseUrl;
 	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
 	const next = {
 		...parsed,
+		...nextModel !== void 0 && { model: nextModel },
+		...shouldSeedTopLevelModel && { model: claudeGptModel },
 		env
 	};
 	const serialized = `${JSON.stringify(next, null, 2)}\n`;
@@ -1539,7 +1589,7 @@ async function shouldRetryWithResponses(response, signal, timeoutMs) {
 
 //#endregion
 //#region src/lib/preflight.ts
-const getUpstreamModelIds = async (config) => {
+const fetchUpstreamModelIds = async (config) => {
 	const provider = getCopilotProviderContext(config);
 	const signal = createCopilotRequestSignal(void 0, config.upstreamTimeoutMs);
 	const response = await fetchCopilot(provider, "/models", {
@@ -1554,8 +1604,8 @@ const getUpstreamModelIds = async (config) => {
 	return new Set((payload.data ?? []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0));
 };
 const ensureRequiredModels = async (config) => {
-	const upstreamModels = await getUpstreamModelIds(config);
-	const requiredModels = getExposedModelIds();
+	const upstreamModels = await fetchUpstreamModelIds(config);
+	const requiredModels = getUpstreamModelIds();
 	const missingModels = requiredModels.filter((model) => !upstreamModels.has(model));
 	if (missingModels.length > 0) throw new Error(`Required Copilot model(s) unavailable upstream: ${missingModels.join(", ")}`);
 	log.info(`Upstream models available: ${requiredModels.join(", ")}`);
@@ -1589,7 +1639,7 @@ const validateModelRequest = async (config, model, thinkEffort) => {
 const validateUpstream = async (config, thinkEffort) => {
 	log.info("Running upstream preflight");
 	await ensureRequiredModels(config);
-	for (const model of getExposedModelIds()) await validateModelRequest(config, model, thinkEffort);
+	for (const model of getUpstreamModelIds()) await validateModelRequest(config, model, thinkEffort);
 };
 
 //#endregion
@@ -1865,7 +1915,7 @@ function translateToClaude(response, toolNameMapper = createClaudeToolNameMapper
 		id: response.id,
 		type: "message",
 		role: "assistant",
-		model: response.model,
+		model: normalizeClaudeModelId(response.model),
 		content: [
 			...allThinkingBlocks,
 			...allTextBlocks,
@@ -1945,7 +1995,7 @@ function translateChunkToClaudeEvents(chunk, state, toolNameMapper = createClaud
 				type: "message",
 				role: "assistant",
 				content: [],
-				model: chunk.model,
+				model: normalizeClaudeModelId(chunk.model),
 				stop_reason: null,
 				stop_sequence: null,
 				usage: {
@@ -2083,7 +2133,7 @@ const isClaudeCodeWebSearchTool = (tool) => tool.name === claudeCodeWebSearchToo
 const isClaudeWebSearchTool = (tool) => isAnthropicNativeWebSearchTool(tool) || isClaudeCodeWebSearchTool(tool);
 const hasClaudeWebSearch = (payload) => payload.tools?.some(isClaudeWebSearchTool) ?? false;
 const isClaudeWebSearchToolName = (name) => name === "web_search" || name === claudeCodeWebSearchToolName;
-const getWebSearchBackendModel = (config) => config.webSearchBackend?.trim() || getModelRouting().gptModel;
+const getWebSearchBackendModel = (config) => normalizeCopilotModelId(config.webSearchBackend?.trim() || getModelRouting().gptModel);
 const prepareClaudeWebSearchDecisionPayload = (payload) => {
 	if (!hasClaudeWebSearch(payload)) return payload;
 	return {
@@ -2257,7 +2307,7 @@ const createClaudeWebSearchResponse = (search) => {
 		type: "message",
 		role: "assistant",
 		content,
-		model: search.model,
+		model: normalizeClaudeModelId(search.model),
 		stop_reason: "end_turn",
 		stop_sequence: null,
 		usage: {
@@ -2845,7 +2895,8 @@ async function startRelay(appConfig) {
 	if (appConfig.claudeSetup) try {
 		const claudeResult = await applyClaudeConfig({
 			baseUrl,
-			configPath: claudeConfigPath$1
+			configPath: claudeConfigPath$1,
+			gptModel: appConfig.gptModel
 		});
 		if (claudeResult.changed) {
 			log.info(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);