copilot-relay 0.3.5 → 0.3.7

package/dist/main.js

@@ -547,13 +547,39 @@ const defaultModelRouting = {
 	opusModel: "claude-opus-5"
 };
 const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+const invalidRequestEffort = (message) => new HTTPError(message, new Response(JSON.stringify({
+	type: "error",
+	error: {
+		type: "invalid_request_error",
+		message
+	}
+}), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}), message);
+function getRequestReasoningEffort(request) {
+	let nativeEffort;
+	const outputConfig = request.output_config;
+	if (outputConfig !== void 0 && outputConfig !== null) {
+		if (typeof outputConfig !== "object" || Array.isArray(outputConfig)) throw invalidRequestEffort("Invalid output_config: expected an object.");
+		if ("effort" in outputConfig) nativeEffort = outputConfig.effort;
+	}
+	const requested = nativeEffort ?? request.reasoning_effort;
+	if (requested === void 0 || requested === null) return void 0;
+	if (!isReasoningEffort(requested)) throw invalidRequestEffort(`Invalid ${nativeEffort !== void 0 && nativeEffort !== null ? "output_config.effort" : "reasoning_effort"}: expected none, low, medium, high, xhigh, or max.`);
+	return requested;
+}
+const resolveReasoningEffort = (requested) => requested ?? runtimeState.thinkEffort ?? defaultReasoningEffort;
 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 +743,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 () => {
@@ -841,10 +867,10 @@ const serializeConfig = (config) => [
 	"# Number of days to keep files in ~/.copilot-relay/logs.",
 	`logRetentionDays: ${config.logRetentionDays}`,
 	"",
-	"# Default upstream thinking/reasoning effort: none, low, medium, high, xhigh, max.",
+	"# Fallback effort when the request omits it: 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 +1216,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 +1247,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 +1260,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 +1418,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 +1962,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) {
@@ -1764,7 +2016,7 @@ const sanitizeReasoningEffortForModel = (_modelId, reasoningEffort) => {
 	return reasoningEffort ?? void 0;
 };
 const getRequestedReasoningEffort = (payload) => {
-	return sanitizeReasoningEffortForModel(payload.model, runtimeState.thinkEffort ?? defaultReasoningEffort);
+	return sanitizeReasoningEffortForModel(payload.model, resolveReasoningEffort(getRequestReasoningEffort(payload)));
 };
 const sanitizeUserIdentifier = (user) => {
 	if (!user) return;
@@ -1829,13 +2081,21 @@ const messagesIncludeImage = (messages) => messages.some((msg) => typeof msg.con
 const createChatCompletions = async (config, payload, options = {}) => {
 	const client = options.client ?? "generic";
 	const requestedModel = options.requestedModel ?? payload.model;
-	const requestedThinkEffort = options.requestedThinkEffort ?? payload.reasoning_effort ?? "none";
+	const requestedThinkEffort = options.requestedThinkEffort ?? getRequestReasoningEffort(payload) ?? "none";
+	const reasoningEffort = getRequestedReasoningEffort(payload);
 	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,
+		reasoning_effort: reasoningEffort,
+		max_tokens: maxTokens,
+		stream: bufferResponse ? true : payload.stream
 	};
 	const useResponsesApi = shouldUseResponsesApiForModel(upstreamPayload.model);
 	const compatiblePayload = useResponsesApi ? upstreamPayload : normalizeFinalAssistantPrefill$1(upstreamPayload);
@@ -1854,13 +2114,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 +2136,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 +2150,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 +2216,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,
@@ -2099,7 +2350,7 @@ function translateToOpenAI(payload, _settings, toolNameMapper) {
 		stream: payload.stream,
 		temperature: payload.temperature,
 		top_p: payload.top_p,
-		reasoning_effort: runtimeState.thinkEffort ?? defaultReasoningEffort,
+		reasoning_effort: resolveReasoningEffort(getRequestReasoningEffort(payload)),
 		user: payload.metadata?.user_id,
 		tools,
 		tool_choice: tools && tools.length > 0 ? translateClaudeToolChoiceToOpenAI(payload.tool_choice, mapper) : void 0
@@ -2544,6 +2795,7 @@ const buildWebSearchRequestPayload = (payload, requestedQuery, model) => ({
 	model,
 	input: buildSearchInput(payload, requestedQuery),
 	tools: [{ type: "web_search_preview" }],
+	reasoning: { effort: resolveReasoningEffort(getRequestReasoningEffort(payload)) },
 	max_output_tokens: Math.max(256, Math.min(payload.max_tokens ?? 1024, 1200)),
 	temperature: payload.temperature,
 	top_p: payload.top_p
@@ -2729,56 +2981,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 +3062,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 +3103,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,12 +3211,12 @@ 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");
-const getClaudeRequestedThinkEffort = (payload) => payload.reasoning_effort ?? "none";
+const getClaudeRequestedThinkEffort = (payload) => getRequestReasoningEffort(payload) ?? "none";
 const getClaudeRequestedThinking = (payload) => {
 	if (!payload.thinking) return "none";
 	return [`type:${payload.thinking.type}`, `budget:${payload.thinking.budget_tokens ?? "none"}`].join(",");
@@ -3192,7 +3394,10 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 		const webSearchToolCall = shouldLetModelDecideWebSearch ? getClaudeWebSearchToolCallFromChatResponse(effectiveResponse, toolNameMapper) : void 0;
 		let claudeResponse;
 		if (webSearchToolCall) {
-			const search = await createClaudeWebSearchExecution(config, claudePayload, webSearchToolCall.query, {
+			const search = await createClaudeWebSearchExecution(config, {
+				...claudePayload,
+				reasoning_effort: openAIPayload.reasoning_effort
+			}, webSearchToolCall.query, {
 				requestId,
 				signal: requestSignal,
 				timeoutMs: config.upstreamTimeoutMs
@@ -3246,17 +3451,33 @@ 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");
 	const requestId = c.get("requestId");
 	const claudePayload = await c.req.json();
+	try {
+		getRequestReasoningEffort(claudePayload);
+	} catch (error) {
+		if (!(error instanceof HTTPError)) throw error;
+		c.set("requestErrorMessage", error.message);
+		log.error(`request_id=${requestId} ${error.message}`);
+		return error.response;
+	}
 	const requestSignal = createCopilotRequestSignal(c.req.raw.signal, config.upstreamTimeoutMs);
 	log.debug("Full Claude request payload", { payload: claudePayload });
 	if (claudePayload.stream) return streamSSE(c, async (stream) => {
@@ -3301,19 +3522,25 @@ 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) {
 		log.error("Error counting tokens:", error);
+		if (error instanceof HTTPError) {
+			c.set("requestErrorMessage", error.message);
+			return error.response;
+		}
 		return c.json({ input_tokens: 1 });
 	}
 });
@@ -3429,6 +3656,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;
@@ -3440,9 +3668,8 @@ async function startRelay(appConfig) {
 	};
 	applyRuntimeConfig(appConfig);
 	log.info(`Log level: ${appConfig.logLevel}`);
-	log.info(`Think effort: ${appConfig.thinkEffort}`);
+	log.info(`Default 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 +3677,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 +3687,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}`);