copilot-relay 0.3.4 → 0.3.6

package/README.md

@@ -75,7 +75,17 @@ 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-6-astra` and `gpt-5.6-sol` overrides are normalized to Claude-facing
-`[1m]` identities; unrelated model choices are preserved.
+`[1m]` identities when discovery reports exactly 1M; other reported windows use
+plain GPT IDs with Claude's numeric context setting. Unrelated model choices and
+existing token-budget overrides are preserved.
+
+Startup retains Copilot's actual context, prompt, and output limits and exposes
+them on `GET /v1/models`. Managed Claude setup seeds
+`CLAUDE_CODE_MAX_CONTEXT_TOKENS` and `CLAUDE_CODE_MAX_OUTPUT_TOKENS` when absent.
+The default models support 1M total context, with up to 128K output tokens for
+Astra and 64K for Opus. Input text is never shortened; smaller explicit output
+budgets remain respected. See [full-context configuration](wiki/EN-Configuration.md)
+for existing/manual Claude setups and the limits on input plus output.
 
 ## Config
 
@@ -116,7 +126,9 @@ Valid `thinkEffort`: `none`, `low`, `medium`, `high`, `xhigh`, `max`.
 
 `upstreamTimeoutSeconds` controls the maximum time a single Claude request can
 spend waiting on upstream Copilot calls, including chat, Responses, preflight,
-and bridge-managed WebSearch calls. The default is `180`.
+and bridge-managed WebSearch calls. The default is `180`. Set `0` to disable the
+relay deadline for very long requests; client cancellation and provider/transport
+timeouts still apply. Existing saved timeouts are never changed by an upgrade.
 
 `webSearchBackend` controls bridge-managed Claude WebSearch. Leave it empty to
 use `gptModel`, or set a Copilot Responses model ID such as `gpt-5.5`.

package/config.default.yaml

@@ -21,6 +21,7 @@ copilotBaseUrl: https://api.githubcopilot.com
 
 # When true, start updates ~/.claude/settings.json with ANTHROPIC_BASE_URL
 # and a dummy ANTHROPIC_AUTH_TOKEN so Claude Code can use this proxy.
+# Also seeds context/output budgets from model discovery when not already set.
 claudeSetup: true
 
 # Log verbosity:
@@ -43,6 +44,8 @@ logRetentionDays: 3
 thinkEffort: max
 
 # Max seconds to wait for one Claude request's upstream Copilot calls.
+# Set 0 to disable the relay deadline for very long requests. Client cancellation
+# and upstream/provider limits still apply.
 upstreamTimeoutSeconds: 180
 
 # Copilot model used for bridge-managed Claude WebSearch.

package/dist/main.js

@@ -551,9 +551,12 @@ const oneMillionContextModelPattern = /^(gpt-5\.6-sol|gpt-6-astra)(?:\[1m\])*$/i
 const normalizeOneMillionContextModel = (model) => {
 	return oneMillionContextModelPattern.exec(model)?.[1]?.toLowerCase();
 };
-const normalizeClaudeModelId = (model) => {
+const normalizeClaudeModelId = (model, contextWindowTokens) => {
 	const normalized = normalizeOneMillionContextModel(model);
-	return normalized ? `${normalized}[1m]` : model;
+	if (!normalized) return model;
+	const catalog = runtimeState.modelCatalog;
+	contextWindowTokens ??= catalog?.baseUrl === runtimeState.upstreamBaseUrl ? catalog?.models.get(normalized)?.limits?.max_context_window_tokens : void 0;
+	return contextWindowTokens !== void 0 && contextWindowTokens !== 1e6 ? normalized : `${normalized}[1m]`;
 };
 const normalizeCopilotModelId = (model) => normalizeOneMillionContextModel(model) ?? model;
 const getConfiguredModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
@@ -717,8 +720,8 @@ const normalizeThinkEffort = (value) => {
 };
 const normalizeUpstreamTimeoutSeconds = (value) => {
 	if (value === void 0) return;
-	const timeout = normalizePositiveInteger(value);
-	if (timeout === void 0) throw new Error("Invalid upstreamTimeoutSeconds: expected a positive integer");
+	const timeout = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+	if (typeof timeout !== "number" || !Number.isSafeInteger(timeout) || timeout < 0) throw new Error("Invalid upstreamTimeoutSeconds: expected a non-negative integer (0 disables the deadline)");
 	return timeout;
 };
 const readRawConfig = async () => {
@@ -844,7 +847,7 @@ const serializeConfig = (config) => [
 	"# Default upstream thinking/reasoning effort: none, low, medium, high, xhigh, max.",
 	`thinkEffort: ${config.thinkEffort}`,
 	"",
-	"# Max seconds to wait for a single Claude request's upstream Copilot calls.",
+	"# Max seconds for one request's upstream calls; 0 disables the relay deadline.",
 	`upstreamTimeoutSeconds: ${config.upstreamTimeoutSeconds}`,
 	"",
 	"# Copilot model used for bridge-managed Claude WebSearch. Empty uses gptModel.",
@@ -1190,11 +1193,11 @@ const knownModelEnvKeys = [
 	"ANTHROPIC_SMALL_FAST_MODEL",
 	"CLAUDE_CODE_SUBAGENT_MODEL"
 ];
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$3 = (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;
+	if (!isRecord$3(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";
@@ -1221,7 +1224,7 @@ async function applyClaudeConfig(input) {
 	};
 	if (raw.trim().length > 0) try {
 		const value = JSON.parse(raw);
-		if (!isRecord$1(value) || value.env !== void 0 && !isRecord$1(value.env) || hasMalformedModelOverride(value)) return {
+		if (!isRecord$3(value) || value.env !== void 0 && !isRecord$3(value.env) || hasMalformedModelOverride(value)) return {
 			configPath: configPath$1,
 			changed: false,
 			created: false
@@ -1234,15 +1237,18 @@ async function applyClaudeConfig(input) {
 			created: false
 		};
 	}
-	const env = isRecord$1(parsed.env) ? { ...parsed.env } : {};
+	const env = isRecord$3(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 contextWindow = input.gptLimits?.max_context_window_tokens;
+	const claudeGptModel = normalizeClaudeModelId(gptModel, contextWindow);
 	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]);
+	const nextModel = typeof parsed.model === "string" ? normalizeClaudeModelId(parsed.model, contextWindow) : void 0;
+	for (const key of knownModelEnvKeys) if (typeof env[key] === "string") env[key] = normalizeClaudeModelId(env[key], contextWindow);
 	env.ANTHROPIC_BASE_URL = baseUrl;
 	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
+	if (contextWindow !== void 0 && env.CLAUDE_CODE_MAX_CONTEXT_TOKENS === void 0) env.CLAUDE_CODE_MAX_CONTEXT_TOKENS = String(contextWindow);
+	if (input.maxOutputTokens !== void 0 && env.CLAUDE_CODE_MAX_OUTPUT_TOKENS === void 0) env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = String(input.maxOutputTokens);
 	const next = {
 		...parsed,
 		...nextModel !== void 0 && { model: nextModel },
@@ -1389,6 +1395,229 @@ const fetchCopilot = async (provider, path$1, init, options = {}) => {
 	throw lastError;
 };
 
+//#endregion
+//#region src/copilot/models.ts
+const pendingCatalogs = /* @__PURE__ */ new WeakMap();
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+function parseModelTokenLimits(value) {
+	if (!isRecord$2(value)) return void 0;
+	const context = value.max_context_window_tokens;
+	const prompt = value.max_prompt_tokens;
+	const output = value.max_output_tokens;
+	const nonStreaming = value.max_non_streaming_output_tokens;
+	if (!isPositiveInteger(context) || !isPositiveInteger(prompt) || !isPositiveInteger(output) || prompt > context || output > context || nonStreaming !== void 0 && (!isPositiveInteger(nonStreaming) || nonStreaming > output)) return;
+	return {
+		max_context_window_tokens: context,
+		max_prompt_tokens: prompt,
+		max_output_tokens: output,
+		...nonStreaming !== void 0 && { max_non_streaming_output_tokens: nonStreaming }
+	};
+}
+function getCachedCopilotModel(config, model) {
+	return config.modelCatalog?.baseUrl === config.copilotBaseUrl ? config.modelCatalog.models.get(normalizeCopilotModelId(model)) : void 0;
+}
+async function loadCopilotModelCatalog(config) {
+	const provider = getCopilotProviderContext(config);
+	const pending = pendingCatalogs.get(config);
+	if (pending?.baseUrl === provider.baseUrl) return pending.promise;
+	const promise = (async () => {
+		const signal = createCopilotRequestSignal(void 0, config.upstreamTimeoutMs);
+		const response = await fetchCopilot(provider, "/models", {
+			method: "GET",
+			headers: { accept: "application/json" }
+		}, {
+			signal,
+			timeoutMs: config.upstreamTimeoutMs
+		});
+		if (!response.ok) throw new HTTPError("Failed to validate upstream models", response);
+		const payload = await readCopilotJson(response, signal, config.upstreamTimeoutMs);
+		if (!isRecord$2(payload) || !Array.isArray(payload.data)) throw new Error("Copilot /models returned an invalid model catalog.");
+		const models = /* @__PURE__ */ new Map();
+		for (const model of payload.data) {
+			if (!isRecord$2(model) || typeof model.id !== "string" || !model.id) continue;
+			const capabilities = isRecord$2(model.capabilities) ? model.capabilities : void 0;
+			const limits = parseModelTokenLimits(capabilities?.limits);
+			models.set(model.id, {
+				...limits && { limits },
+				...typeof capabilities?.tokenizer === "string" && { tokenizer: capabilities.tokenizer }
+			});
+		}
+		const catalog = {
+			baseUrl: provider.baseUrl,
+			models
+		};
+		if (config.copilotBaseUrl === provider.baseUrl) {
+			config.modelCatalog = catalog;
+			if (runtimeState.upstreamBaseUrl === provider.baseUrl) runtimeState.modelCatalog = catalog;
+		}
+		return catalog;
+	})();
+	pendingCatalogs.set(config, {
+		baseUrl: provider.baseUrl,
+		promise
+	});
+	try {
+		return await promise;
+	} finally {
+		if (pendingCatalogs.get(config)?.promise === promise) pendingCatalogs.delete(config);
+	}
+}
+async function boundModelOutputTokens(config, model, requested) {
+	if (!config.modelCatalog) return requested;
+	if (config.modelCatalog.baseUrl !== config.copilotBaseUrl || !config.modelCatalog.models.has(model)) {
+		await loadCopilotModelCatalog(config);
+		if (config.modelCatalog.baseUrl !== config.copilotBaseUrl) throw new Error("Copilot base URL changed during model discovery; retry the request.");
+	}
+	const limits = getCachedCopilotModel(config, model)?.limits;
+	if (!limits || !isPositiveInteger(requested)) return requested;
+	const bounded = Math.min(requested, limits.max_output_tokens);
+	if (bounded !== requested) log.info(`Model output budget: model=${model} requested=${requested} effective=${bounded}`);
+	return bounded;
+}
+
+//#endregion
+//#region src/copilot/stream.ts
+const accumulateChunks = (chunks) => {
+	const first = chunks[0];
+	const toolCalls = [];
+	let content = "";
+	let reasoning = "";
+	let finishReason = null;
+	let usage;
+	for (const chunk of chunks) {
+		if (chunk.usage) usage = chunk.usage;
+		const choice = chunk.choices[0];
+		if (!choice) continue;
+		if (typeof choice.delta?.content === "string") content += choice.delta.content;
+		const chunkReasoning = choice.delta?.reasoning_text ?? choice.delta?.reasoning_content;
+		if (typeof chunkReasoning === "string") reasoning += chunkReasoning;
+		if (choice.finish_reason) finishReason = choice.finish_reason;
+		for (const call of choice.delta?.tool_calls ?? []) {
+			const existing = toolCalls[call.index];
+			if (existing) {
+				existing.function.arguments += call.function?.arguments ?? "";
+				continue;
+			}
+			toolCalls[call.index] = {
+				id: call.id ?? `call_${call.index}`,
+				type: "function",
+				function: {
+					name: call.function?.name ?? "",
+					arguments: call.function?.arguments ?? ""
+				}
+			};
+		}
+	}
+	const collectedToolCalls = toolCalls.filter(Boolean);
+	return {
+		id: first?.id ?? "chat_stream_accumulated",
+		object: "chat.completion",
+		created: first?.created ?? 0,
+		model: first?.model ?? "",
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: content || null,
+				...reasoning ? { reasoning_text: reasoning } : {},
+				...collectedToolCalls.length > 0 ? { tool_calls: collectedToolCalls } : {}
+			},
+			finish_reason: finishReason ?? "stop"
+		}],
+		...usage ? { usage } : {}
+	};
+};
+const incompleteStreamError = () => {
+	const message = "Copilot stream ended without a completed response.";
+	return new HTTPError(message, new Response(JSON.stringify({ error: {
+		type: "api_error",
+		message
+	} }), {
+		status: 502,
+		headers: { "content-type": "application/json" }
+	}), message);
+};
+async function collectChatCompletionStream(stream, signal, timeoutMs) {
+	const chunks = [];
+	try {
+		for await (const event of stream) {
+			if (event.data === "[DONE]") break;
+			if (!event.data) continue;
+			const chunk = JSON.parse(event.data);
+			if (!chunk || !Array.isArray(chunk.choices)) throw incompleteStreamError();
+			chunks.push(chunk);
+		}
+		if (!chunks.some((chunk) => chunk.choices[0]?.finish_reason)) throw incompleteStreamError();
+		return accumulateChunks(chunks);
+	} catch (error) {
+		throw toCopilotAbortHTTPError(error, signal, timeoutMs) ?? error;
+	}
+}
+
+//#endregion
+//#region src/copilot/tool-schema.ts
+const schemaMapKeywords = new Set([
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const nestedSchemaKeywords = new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const lookaroundPrefixes = [
+	"(?=",
+	"(?!",
+	"(?<=",
+	"(?<!"
+];
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function hasUnsupportedPatternFeatures(pattern) {
+	let inCharacterClass = false;
+	for (let index = 0; index < pattern.length; index++) {
+		const character = pattern[index];
+		if (character === "\\") {
+			if ((pattern[index + 1] === "p" || pattern[index + 1] === "P") && pattern[index + 2] === "{") return true;
+			index += 1;
+			continue;
+		}
+		if (character === "[") inCharacterClass = true;
+		else if (character === "]") inCharacterClass = false;
+		else if (!inCharacterClass && character === "(" && lookaroundPrefixes.some((prefix) => pattern.startsWith(prefix, index))) return true;
+	}
+	return false;
+}
+function normalizeSchemaValue(value) {
+	if (Array.isArray(value)) return value.map(normalizeSchemaValue);
+	return isRecord$1(value) ? normalizeResponsesToolSchema(value) : value;
+}
+function normalizeResponsesToolSchema(schema) {
+	return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+		if (key === "pattern" && typeof value === "string" && hasUnsupportedPatternFeatures(value)) return [];
+		if (schemaMapKeywords.has(key) && isRecord$1(value)) return [[key, Object.fromEntries(Object.entries(value).map(([name, nested]) => [name, normalizeSchemaValue(nested)]))]];
+		if (nestedSchemaKeywords.has(key)) return [[key, normalizeSchemaValue(value)]];
+		return [[key, value]];
+	}));
+}
+
 //#endregion
 //#region src/copilot/responses.ts
 const responsesOnlyModelPattern = /^(?:gpt-5\.5|gpt-5\.6|gpt-6-astra)(?:-|$)/i;
@@ -1710,7 +1939,7 @@ function translateTools(tools) {
 		type: "function",
 		name: tool.function.name,
 		description: tool.function.description,
-		parameters: tool.function.parameters
+		parameters: normalizeResponsesToolSchema(tool.function.parameters)
 	}));
 }
 function translateToolChoice(toolChoice) {
@@ -1833,9 +2062,15 @@ const createChatCompletions = async (config, payload, options = {}) => {
 	const requestedThinking = options.requestedThinking ?? "none";
 	const signal = createCopilotRequestSignal(options.signal, options.timeoutMs);
 	const upstreamModelId = routeModelId(payload.model);
-	const upstreamPayload = upstreamModelId === payload.model ? payload : {
+	const maxTokens = await boundModelOutputTokens(config, upstreamModelId, payload.max_tokens);
+	const nonStreamingLimit = getCachedCopilotModel(config, upstreamModelId)?.limits?.max_non_streaming_output_tokens;
+	const bufferResponse = !payload.stream && typeof maxTokens === "number" && nonStreamingLimit !== void 0 && maxTokens > nonStreamingLimit;
+	const completeResponse = (response$1) => bufferResponse && !("choices" in response$1) ? collectChatCompletionStream(response$1, signal, options.timeoutMs) : response$1;
+	const upstreamPayload = {
 		...payload,
-		model: upstreamModelId
+		model: upstreamModelId,
+		max_tokens: maxTokens,
+		stream: bufferResponse ? true : payload.stream
 	};
 	const useResponsesApi = shouldUseResponsesApiForModel(upstreamPayload.model);
 	const compatiblePayload = useResponsesApi ? upstreamPayload : normalizeFinalAssistantPrefill$1(upstreamPayload);
@@ -1854,13 +2089,13 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		`effective_think_effort=${requestPayload.reasoning_effort ?? "none"}`
 	].join(" "));
 	log.debug("Full request payload", { payload: requestPayload });
-	if (useResponsesApi) return createResponses(provider, compatiblePayload, {
+	if (useResponsesApi) return completeResponse(await createResponses(provider, compatiblePayload, {
 		vision: enableVision,
 		initiator,
 		requestId: options.requestId,
 		signal,
 		timeoutMs: options.timeoutMs
-	});
+	}));
 	const response = await fetchCopilot(provider, "/chat/completions", {
 		method: "POST",
 		headers: {
@@ -1876,13 +2111,13 @@ const createChatCompletions = async (config, payload, options = {}) => {
 		timeoutMs: options.timeoutMs
 	});
 	if (!response.ok) {
-		if (await shouldRetryWithResponses(response, signal, options.timeoutMs)) return createResponses(provider, compatiblePayload, {
+		if (await shouldRetryWithResponses(response, signal, options.timeoutMs)) return completeResponse(await createResponses(provider, compatiblePayload, {
 			vision: enableVision,
 			initiator,
 			requestId: options.requestId,
 			signal,
 			timeoutMs: options.timeoutMs
-		});
+		}));
 		throw new HTTPError("Failed to create chat completions", response, await logUpstreamError("Failed to create chat completions", response, {
 			model: payload.model,
 			request: requestPayload,
@@ -1890,7 +2125,7 @@ const createChatCompletions = async (config, payload, options = {}) => {
 			requestId: options.requestId
 		}, signal, options.timeoutMs));
 	}
-	if (compatiblePayload.stream) return events(response);
+	if (compatiblePayload.stream) return completeResponse(events(response));
 	return readCopilotJson(response, signal, options.timeoutMs);
 };
 async function createResponses(provider, payload, options) {
@@ -1956,26 +2191,17 @@ async function shouldRetryWithResponses(response, signal, timeoutMs) {
 
 //#endregion
 //#region src/lib/preflight.ts
-const fetchUpstreamModelIds = async (config) => {
-	const provider = getCopilotProviderContext(config);
-	const signal = createCopilotRequestSignal(void 0, config.upstreamTimeoutMs);
-	const response = await fetchCopilot(provider, "/models", {
-		method: "GET",
-		headers: { accept: "application/json" }
-	}, {
-		signal,
-		timeoutMs: config.upstreamTimeoutMs
-	});
-	if (!response.ok) throw new HTTPError("Failed to validate upstream models", response);
-	const payload = await readCopilotJson(response, signal, config.upstreamTimeoutMs);
-	return new Set((payload.data ?? []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0));
-};
 const ensureRequiredModels = async (config) => {
-	const upstreamModels = await fetchUpstreamModelIds(config);
+	const catalog = await loadCopilotModelCatalog(config);
 	const requiredModels = getUpstreamModelIds();
-	const missingModels = requiredModels.filter((model) => !upstreamModels.has(model));
+	const missingModels = requiredModels.filter((model) => !catalog.models.has(model));
 	if (missingModels.length > 0) throw new Error(`Required Copilot model(s) unavailable upstream: ${missingModels.join(", ")}`);
 	log.info(`Upstream models available: ${requiredModels.join(", ")}`);
+	for (const model of requiredModels) {
+		const limits = catalog.models.get(model)?.limits;
+		if (limits) log.info(`Model token limits: model=${model} context=${limits.max_context_window_tokens} input=${limits.max_prompt_tokens} output=${limits.max_output_tokens} non_streaming_output=${limits.max_non_streaming_output_tokens ?? limits.max_output_tokens}`);
+		else log.error(`Model token limits unavailable: model=${model}; preserving client budgets without assuming a capacity.`);
+	}
 };
 const createProbePayload = (model) => ({
 	model,
@@ -2729,56 +2955,6 @@ const chunkSettlesDecision = (chunk) => {
 	return choice.delta?.tool_calls?.some((call) => call.function?.name) === true || !!choice.finish_reason;
 };
 const chunkHasWebSearchCall = (chunk, toolNameMapper, isWebSearchToolName) => chunk.choices[0]?.delta?.tool_calls?.some((call) => isWebSearchName(call.function?.name, toolNameMapper, isWebSearchToolName)) ?? false;
-const accumulateChunks = (chunks) => {
-	const first = chunks[0];
-	const toolCalls = [];
-	let content = "";
-	let reasoning = "";
-	let finishReason = null;
-	let usage;
-	for (const chunk of chunks) {
-		if (chunk.usage) usage = chunk.usage;
-		const choice = chunk.choices[0];
-		if (!choice) continue;
-		if (typeof choice.delta?.content === "string") content += choice.delta.content;
-		const chunkReasoning = choice.delta?.reasoning_text ?? choice.delta?.reasoning_content;
-		if (typeof chunkReasoning === "string") reasoning += chunkReasoning;
-		if (choice.finish_reason) finishReason = choice.finish_reason;
-		for (const call of choice.delta?.tool_calls ?? []) {
-			const existing = toolCalls[call.index];
-			if (existing) {
-				existing.function.arguments += call.function?.arguments ?? "";
-				continue;
-			}
-			toolCalls[call.index] = {
-				id: call.id ?? `call_${call.index}`,
-				type: "function",
-				function: {
-					name: call.function?.name ?? "",
-					arguments: call.function?.arguments ?? ""
-				}
-			};
-		}
-	}
-	const collectedToolCalls = toolCalls.filter(Boolean);
-	return {
-		id: first?.id ?? "chat_stream_accumulated",
-		object: "chat.completion",
-		created: first?.created ?? 0,
-		model: first?.model ?? "",
-		choices: [{
-			index: 0,
-			message: {
-				role: "assistant",
-				content: content || null,
-				...reasoning ? { reasoning_text: reasoning } : {},
-				...collectedToolCalls.length > 0 ? { tool_calls: collectedToolCalls } : {}
-			},
-			finish_reason: finishReason ?? "stop"
-		}],
-		...usage ? { usage } : {}
-	};
-};
 const resolveWebSearchStreamDecision = async (stream, toolNameMapper, isWebSearchToolName, onChunk) => {
 	const buffered = [];
 	const iterator = stream[Symbol.asyncIterator]();
@@ -2860,6 +3036,7 @@ const encodingMap = {
 	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
 	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
 };
+const isSupportedTokenizer = (encoding) => Object.hasOwn(encodingMap, encoding);
 const encodingCache = /* @__PURE__ */ new Map();
 const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
 	let tokens = 0;
@@ -2900,13 +3077,12 @@ const getEncodeChatFunction = async (encoding) => {
 		const cached = encodingCache.get(encoding);
 		if (cached) return cached;
 	}
-	const supported = encoding;
-	if (!(supported in encodingMap)) {
+	if (!isSupportedTokenizer(encoding)) {
 		const fallback = await encodingMap.o200k_base();
 		encodingCache.set(encoding, fallback);
 		return fallback;
 	}
-	const mod = await encodingMap[supported]();
+	const mod = await encodingMap[encoding]();
 	encodingCache.set(encoding, mod);
 	return mod;
 };
@@ -3009,8 +3185,8 @@ const getTokenCount = async (payload, model) => {
 //#endregion
 //#region src/routes/claude.ts
 const claudeRoutes = new Hono();
-const createTokenCountModel = (modelId) => ({
-	capabilities: { tokenizer: "o200k_base" },
+const createTokenCountModel = (modelId, tokenizer = "o200k_base") => ({
+	capabilities: { tokenizer },
 	id: modelId
 });
 const isNonStreamingResponse = (response) => typeof response === "object" && response !== null && Object.hasOwn(response, "choices");
@@ -3246,12 +3422,20 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 };
 claudeRoutes.get("/models", (c) => c.json({
 	object: "list",
-	data: getExposedModelIds().map((id) => ({
-		id,
-		object: "model",
-		created: 0,
-		owned_by: "github-copilot"
-	}))
+	data: getExposedModelIds().map((id) => {
+		const limits = getCachedCopilotModel(c.get("config"), id)?.limits;
+		return {
+			id,
+			object: "model",
+			created: 0,
+			owned_by: "github-copilot",
+			...limits && {
+				context_window: limits.max_context_window_tokens,
+				max_input_tokens: limits.max_prompt_tokens,
+				max_tokens: limits.max_output_tokens
+			}
+		};
+	})
 }));
 claudeRoutes.post("/messages", async (c) => {
 	const config = c.get("config");
@@ -3301,15 +3485,17 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 		const claudePayload = await c.req.json();
 		const openAIPayload = translateToOpenAI(claudePayload);
 		const exposedModels = getExposedModelIds();
-		const selectedModel = createTokenCountModel(openAIPayload.model === exposedModels[1] ? exposedModels[1] : exposedModels[0]);
+		const upstreamModel = getCachedCopilotModel(c.get("config"), openAIPayload.model);
+		const hasDiscoveredTokenizer = upstreamModel?.tokenizer !== void 0 && isSupportedTokenizer(upstreamModel.tokenizer);
+		const selectedModel = createTokenCountModel(openAIPayload.model === exposedModels[1] ? exposedModels[1] : exposedModels[0], hasDiscoveredTokenizer ? upstreamModel?.tokenizer : void 0);
 		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
 		const effectiveModelId = selectedModel.id;
 		if (claudePayload.tools && claudePayload.tools.length > 0) {
 			let mcpToolExist = false;
 			if (claudeBeta?.startsWith("claude-code")) mcpToolExist = claudePayload.tools.some((tool) => tool.name.startsWith("mcp__"));
-			if (!mcpToolExist && effectiveModelId.startsWith("claude")) tokenCount.input += 346;
+			if (!hasDiscoveredTokenizer && !mcpToolExist && effectiveModelId.startsWith("claude")) tokenCount.input += 346;
 		}
-		const multiplier = effectiveModelId.startsWith("claude") ? 1.15 : 1;
+		const multiplier = !hasDiscoveredTokenizer && effectiveModelId.startsWith("claude") ? 1.15 : 1;
 		const finalTokenCount = Math.round((tokenCount.input + tokenCount.output) * multiplier);
 		return c.json({ input_tokens: Math.max(1, finalTokenCount) });
 	} catch (error) {
@@ -3429,6 +3615,7 @@ async function startRelay(appConfig) {
 		runtimeState.debug = nextConfig.logLevel === "debug";
 		runtimeState.thinkEffort = nextConfig.thinkEffort;
 		config.copilotBaseUrl = nextConfig.copilotBaseUrl;
+		runtimeState.upstreamBaseUrl = nextConfig.copilotBaseUrl;
 		config.host = nextConfig.host;
 		config.port = nextConfig.port;
 		config.upstreamTimeoutMs = nextConfig.upstreamTimeoutSeconds * 1e3;
@@ -3442,7 +3629,6 @@ async function startRelay(appConfig) {
 	log.info(`Log level: ${appConfig.logLevel}`);
 	log.info(`Think effort: ${appConfig.thinkEffort}`);
 	log.info(`Upstream timeout: ${appConfig.upstreamTimeoutSeconds}s`);
-	log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
 	const authSession = await setupProxyAuth(config);
 	try {
 		await validateUpstream(config, appConfig.thinkEffort);
@@ -3450,6 +3636,7 @@ async function startRelay(appConfig) {
 		log.error("Startup preflight failed:", error);
 		process.exit(1);
 	}
+	log.info(`Exposed models: ${getExposedModelIds().join(", ")}`);
 	const server = await startServer(config);
 	await writeRelayPidFile(config);
 	log.info(`copilot-relay version: ${appVersion}`);
@@ -3459,10 +3646,14 @@ async function startRelay(appConfig) {
 	log.info(`copilot base url: ${formatUrlForDisplay(config.copilotBaseUrl)}`);
 	const baseUrl = `http://${config.host}:${config.port}`;
 	if (appConfig.claudeSetup) try {
+		const gptLimits = getCachedCopilotModel(config, appConfig.gptModel)?.limits;
+		const opusLimits = getCachedCopilotModel(config, appConfig.opusModel)?.limits;
 		const claudeResult = await applyClaudeConfig({
 			baseUrl,
 			configPath: claudeConfigPath$1,
-			gptModel: appConfig.gptModel
+			gptModel: appConfig.gptModel,
+			gptLimits,
+			maxOutputTokens: gptLimits && opusLimits ? Math.max(gptLimits.max_output_tokens, opusLimits.max_output_tokens) : void 0
 		});
 		if (claudeResult.changed) {
 			log.info(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);
@@ -3650,7 +3841,7 @@ const renderStatus = (status$1) => {
 	const health = status$1.health;
 	lines.push(health?.ok ? `  health     ok (${health.ms}ms)` : `  health     FAILED${health?.detail ? ` — ${health.detail}` : ""}`);
 	lines.push(status$1.models?.length ? `  models     ${status$1.models.join(", ")}` : "  models     unavailable");
-	if (status$1.deep) lines.push(status$1.deep.ok ? `  upstream   ok (${status$1.deep.ms}ms) — end-to-end Copilot round trip` : `  upstream   FAILED${status$1.deep.detail ? ` — ${status$1.deep.detail}` : ""}`);
+	if (status$1.deep) lines.push(status$1.deep.ok ? `  upstream   ok (${status$1.deep.ms}ms) — ${status$1.deep.detail ?? "end-to-end Copilot round trip"}` : `  upstream   FAILED${status$1.deep.detail ? ` — ${status$1.deep.detail}` : ""}`);
 	else lines.push("  upstream   not checked (use --deep)");
 	lines.push(`  log        ${status$1.logPath}`, `  config     ${status$1.configPath}`, ...renderConfig(status$1.config, true));
 	if (status$1.health?.ok && status$1.deep && !status$1.deep.ok) lines.push("", "  The relay is listening but cannot reach Copilot.", "  Try: copilot-relay auth");
@@ -3740,11 +3931,19 @@ const checkDeep = async (baseUrl, model) => {
 				ok: false
 			};
 		}
-		const content = result.body?.content;
-		return Array.isArray(content) && content.length > 0 ? {
-			ms: result.ms,
-			ok: true
-		} : {
+		const body = result.body;
+		if (Array.isArray(body?.content)) {
+			if (body.content.length > 0) return {
+				ms: result.ms,
+				ok: true
+			};
+			if (body.type === "message" && body.role === "assistant" && body.stop_reason === "max_tokens" && typeof body.usage?.output_tokens === "number" && Number.isFinite(body.usage.output_tokens) && body.usage.output_tokens > 0) return {
+				detail: "output budget exhausted before visible text",
+				ms: result.ms,
+				ok: true
+			};
+		}
+		return {
 			detail: "empty response",
 			ms: result.ms,
 			ok: false