ghc-proxy 0.1.1 → 0.2.0

package/dist/{main.js → main.mjs}

@@ -83,20 +83,6 @@ async function writeConfigField(field, value) {
 	}
 }
 
-//#endregion
-//#region src/lib/state.ts
-const state = {
-	auth: {},
-	config: {
-		accountType: "individual",
-		manualApprove: false,
-		rateLimitWait: false,
-		showToken: false
-	},
-	cache: {},
-	rateLimit: {}
-};
-
 //#endregion
 //#region src/lib/api-config.ts
 function standardHeaders() {
@@ -112,9 +98,9 @@ const API_VERSION = "2025-04-01";
 function copilotBaseUrl(config) {
 	return config.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${config.accountType}.githubcopilot.com`;
 }
-function copilotHeaders(auth$1, config, vision = false) {
+function copilotHeaders(auth, config, vision = false) {
 	const headers = {
-		"Authorization": `Bearer ${auth$1.copilotToken}`,
+		"Authorization": `Bearer ${auth.copilotToken}`,
 		"content-type": standardHeaders()["content-type"],
 		"copilot-integration-id": "vscode-chat",
 		"editor-version": `vscode/${config.vsCodeVersion ?? "unknown"}`,
@@ -129,10 +115,10 @@ function copilotHeaders(auth$1, config, vision = false) {
 	return headers;
 }
 const GITHUB_API_BASE_URL = "https://api.github.com";
-function githubHeaders(auth$1, config) {
+function githubHeaders(auth, config) {
 	return {
 		...standardHeaders(),
-		"authorization": `token ${auth$1.githubToken}`,
+		"authorization": `token ${auth.githubToken}`,
 		"editor-version": `vscode/${config.vsCodeVersion ?? "unknown"}`,
 		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 		"user-agent": USER_AGENT,
@@ -169,6 +155,10 @@ async function forwardError(c, error) {
 			type: "error"
 		} }, error.response.status);
 	}
+	if (error instanceof Error && error.name === "AbortError") return c.json({ error: {
+		message: "Upstream request was aborted",
+		type: "timeout_error"
+	} }, 504);
 	return c.json({ error: {
 		message: error.message,
 		type: "error"
@@ -181,8 +171,8 @@ var CopilotClient = class {
 	auth;
 	config;
 	fetchImpl;
-	constructor(auth$1, config, deps) {
-		this.auth = auth$1;
+	constructor(auth, config, deps) {
+		this.auth = auth;
 		this.config = config;
 		this.fetchImpl = deps?.fetch ?? fetch;
 	}
@@ -223,35 +213,17 @@ var CopilotClient = class {
 		return await response.json();
 	}
 };
-
-//#endregion
-//#region src/lib/client-config.ts
-function getClientConfig(appState) {
-	return {
-		accountType: appState.config.accountType,
-		vsCodeVersion: appState.cache.vsCodeVersion
-	};
+function isNonStreamingResponse(response) {
+	return Object.hasOwn(response, "choices");
 }
 
 //#endregion
-//#region src/lib/utils.ts
+//#region src/lib/sleep.ts
 function sleep(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
 	});
 }
-function isNullish(value) {
-	return value === null || value === void 0;
-}
-async function cacheModels(client) {
-	const models = await (client ?? new CopilotClient(state.auth, getClientConfig(state))).getModels();
-	state.cache.models = models;
-}
-async function cacheVSCodeVersion() {
-	const response = await getVSCodeVersion();
-	state.cache.vsCodeVersion = response;
-	consola.info(`Using VSCode version: ${response}`);
-}
 
 //#endregion
 //#region src/clients/github-client.ts
@@ -259,8 +231,8 @@ var GitHubClient = class {
 	auth;
 	config;
 	fetchImpl;
-	constructor(auth$1, config, deps) {
-		this.auth = auth$1;
+	constructor(auth, config, deps) {
+		this.auth = auth;
 		this.config = config;
 		this.fetchImpl = deps?.fetch ?? fetch;
 	}
@@ -287,9 +259,10 @@ var GitHubClient = class {
 		return await response.json();
 	}
 	async pollAccessToken(deviceCode) {
+		const MAX_POLL_ATTEMPTS = 60;
 		const sleepDuration = (deviceCode.interval + 1) * 1e3;
 		consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
-		while (true) {
+		for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
 			const response = await this.fetchImpl(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
 				method: "POST",
 				headers: standardHeaders(),
@@ -309,6 +282,7 @@ var GitHubClient = class {
 			if (json.access_token) return json.access_token;
 			await sleep(sleepDuration);
 		}
+		throw new Error("Device code authorization timed out");
 	}
 	async getGitHubUser() {
 		const response = await this.fetchImpl(`${GITHUB_API_BASE_URL}/user`, { headers: {
@@ -339,6 +313,35 @@ async function getVSCodeVersion() {
 	}
 }
 
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	auth: {},
+	config: {
+		accountType: "individual",
+		manualApprove: false,
+		rateLimitWait: false,
+		showToken: false
+	},
+	cache: {},
+	rateLimit: {}
+};
+function getClientConfig() {
+	return {
+		accountType: state.config.accountType,
+		vsCodeVersion: state.cache.vsCodeVersion
+	};
+}
+async function cacheModels(client) {
+	const models = await (client ?? new CopilotClient(state.auth, getClientConfig())).getModels();
+	state.cache.models = models;
+}
+async function cacheVSCodeVersion() {
+	const response = await getVSCodeVersion();
+	state.cache.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+}
+
 //#endregion
 //#region src/lib/token.ts
 async function writeGithubToken(token) {
@@ -355,10 +358,10 @@ async function setupCopilotToken() {
 	const refreshCopilotToken = async () => {
 		consola.debug("Refreshing Copilot token");
 		try {
-			const { token: token$1 } = await githubClient.getCopilotToken();
-			state.auth.copilotToken = token$1;
+			const { token } = await githubClient.getCopilotToken();
+			state.auth.copilotToken = token;
 			consola.debug("Copilot token refreshed");
-			if (state.config.showToken) consola.info("Refreshed Copilot token:", token$1);
+			if (state.config.showToken) consola.info("Refreshed Copilot token:", token);
 		} catch (error) {
 			consola.error("Failed to refresh Copilot token:", error);
 		}
@@ -413,7 +416,7 @@ async function logUser() {
 	consola.info(`Logged in as ${user.login}`);
 }
 function createGitHubClient() {
-	return new GitHubClient(state.auth, getClientConfig(state));
+	return new GitHubClient(state.auth, getClientConfig());
 }
 async function ensureVSCodeVersion() {
 	if (!state.cache.vsCodeVersion) await cacheVSCodeVersion();
@@ -472,7 +475,7 @@ const checkUsage = defineCommand({
 		await cacheVSCodeVersion();
 		await setupGitHubToken();
 		try {
-			const usage = await new GitHubClient(state.auth, getClientConfig(state)).getCopilotUsage();
+			const usage = await new GitHubClient(state.auth, getClientConfig()).getCopilotUsage();
 			const premium = usage.quota_snapshots.premium_interactions;
 			const premiumTotal = premium.entitlement;
 			const premiumUsed = premiumTotal - premium.remaining;
@@ -629,8 +632,7 @@ function getShell() {
 	const { platform, ppid, env } = process;
 	if (platform === "win32") {
 		try {
-			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
-			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -678,8 +680,8 @@ function generateEnvScript(envVars, commandToRun = "") {
 
 //#endregion
 //#region src/lib/request-logger.ts
-function formatElapsed(start$1) {
-	const delta = Date.now() - start$1;
+function formatElapsed(start) {
+	const delta = Date.now() - start;
 	return delta < 1e3 ? `${delta}ms` : `${Math.round(delta / 1e3)}s`;
 }
 function formatPath(rawUrl) {
@@ -717,17 +719,17 @@ function formatModelMapping(info) {
 }
 const requestLogger = async (c, next) => {
 	const { method, url } = c.req;
-	const path$1 = formatPath(url);
-	const start$1 = Date.now();
+	const path = formatPath(url);
+	const start = Date.now();
 	try {
 		await next();
 	} finally {
-		const elapsed = formatElapsed(start$1);
+		const elapsed = formatElapsed(start);
 		const status = c.res.status;
 		const modelInfo = c.get("modelMappingInfo");
 		const line = [
 			colorizeMethod(method),
-			colorize("white", path$1),
+			colorize("white", path),
 			colorizeStatus(status),
 			colorize("dim", elapsed)
 		].join(" ");
@@ -746,33 +748,33 @@ async function awaitApproval() {
 
 //#endregion
 //#region src/lib/rate-limit.ts
-async function checkRateLimit(state$1) {
-	if (state$1.config.rateLimitSeconds === void 0) return;
+async function checkRateLimit(state) {
+	if (state.config.rateLimitSeconds === void 0) return;
 	const now = Date.now();
-	if (!state$1.rateLimit.lastRequestTimestamp) {
-		state$1.rateLimit.lastRequestTimestamp = now;
+	if (!state.rateLimit.lastRequestTimestamp) {
+		state.rateLimit.lastRequestTimestamp = now;
 		return;
 	}
-	const elapsedSeconds = (now - state$1.rateLimit.lastRequestTimestamp) / 1e3;
-	if (elapsedSeconds > state$1.config.rateLimitSeconds) {
-		state$1.rateLimit.lastRequestTimestamp = now;
+	const elapsedSeconds = (now - state.rateLimit.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state.config.rateLimitSeconds) {
+		state.rateLimit.lastRequestTimestamp = now;
 		return;
 	}
-	const waitTimeSeconds = Math.ceil(state$1.config.rateLimitSeconds - elapsedSeconds);
-	if (!state$1.config.rateLimitWait) {
+	const waitTimeSeconds = Math.ceil(state.config.rateLimitSeconds - elapsedSeconds);
+	if (!state.config.rateLimitWait) {
 		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
 		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
 	}
 	const waitTimeMs = waitTimeSeconds * 1e3;
 	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
 	await sleep(waitTimeMs);
-	state$1.rateLimit.lastRequestTimestamp = now;
+	state.rateLimit.lastRequestTimestamp = now;
 	consola.info("Rate limit wait completed, proceeding with request");
 }
 
 //#endregion
 //#region src/routes/middleware/request-guard.ts
-const requestGuard = async (c, next) => {
+const requestGuard = async (_c, next) => {
 	await checkRateLimit(state);
 	if (state.config.manualApprove) await awaitApproval();
 	await next();
@@ -788,16 +790,26 @@ const ENCODING_MAP = {
 	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
 };
 const encodingCache = /* @__PURE__ */ new Map();
+const TOKENS_PER_MESSAGE = 3;
+const TOKENS_PER_NAME = 1;
+const REPLY_PRIMING_TOKENS = 3;
+const BASE_CONSTANTS = {
+	propertyInitOverhead: 3,
+	propertyKeyOverhead: 3,
+	enumOverhead: -3,
+	enumItemCost: 3,
+	functionEndOverhead: 12
+};
 /**
 * Calculate tokens for tool calls
 */
 function calculateToolCallsTokens(toolCalls, encoder, constants) {
 	let tokens = 0;
 	for (const toolCall of toolCalls) {
-		tokens += constants.funcInit;
+		tokens += constants.functionInitOverhead;
 		tokens += encoder.encode(JSON.stringify(toolCall)).length;
 	}
-	tokens += constants.funcEnd;
+	tokens += constants.functionEndOverhead;
 	return tokens;
 }
 /**
@@ -813,12 +825,10 @@ function calculateContentPartsTokens(contentParts, encoder) {
 * Calculate tokens for a single message
 */
 function calculateMessageTokens(message, encoder, constants) {
-	const tokensPerMessage = 3;
-	const tokensPerName = 1;
-	let tokens = tokensPerMessage;
+	let tokens = TOKENS_PER_MESSAGE;
 	for (const [key, value] of Object.entries(message)) {
 		if (typeof value === "string") tokens += encoder.encode(value).length;
-		if (key === "name") tokens += tokensPerName;
+		if (key === "name") tokens += TOKENS_PER_NAME;
 		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
 		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
 	}
@@ -831,17 +841,15 @@ function calculateTokens(messages, encoder, constants) {
 	if (messages.length === 0) return 0;
 	let numTokens = 0;
 	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
-	numTokens += 3;
+	numTokens += REPLY_PRIMING_TOKENS;
 	return numTokens;
 }
 /**
 * Get the corresponding encoder module based on encoding type
 */
-async function getEncodeChatFunction(encoding) {
-	if (encodingCache.has(encoding)) {
-		const cached = encodingCache.get(encoding);
-		if (cached) return cached;
-	}
+async function getEncoder(encoding) {
+	const cached = encodingCache.get(encoding);
+	if (cached) return cached;
 	const supportedEncoding = encoding;
 	if (!(supportedEncoding in ENCODING_MAP)) {
 		const fallbackModule = await ENCODING_MAP.o200k_base();
@@ -862,20 +870,10 @@ function getTokenizerFromModel(model) {
 * Get model-specific constants for token calculation
 */
 function getModelConstants(model) {
-	return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
-		funcInit: 10,
-		propInit: 3,
-		propKey: 3,
-		enumInit: -3,
-		enumItem: 3,
-		funcEnd: 12
-	} : {
-		funcInit: 7,
-		propInit: 3,
-		propKey: 3,
-		enumInit: -3,
-		enumItem: 3,
-		funcEnd: 12
+	const isLegacy = model.id === "gpt-3.5-turbo" || model.id === "gpt-4";
+	return {
+		...BASE_CONSTANTS,
+		functionInitOverhead: isLegacy ? 10 : 7
 	};
 }
 /**
@@ -883,16 +881,16 @@ function getModelConstants(model) {
 */
 function calculateParameterTokens(key, prop, context) {
 	const { encoder, constants } = context;
-	let tokens = constants.propKey;
+	let tokens = constants.propertyKeyOverhead;
 	if (typeof prop !== "object" || prop === null) return tokens;
 	const param = prop;
 	const paramName = key;
 	const paramType = param.type || "string";
 	let paramDesc = param.description || "";
 	if (param.enum && Array.isArray(param.enum)) {
-		tokens += constants.enumInit;
+		tokens += constants.enumOverhead;
 		for (const item of param.enum) {
-			tokens += constants.enumItem;
+			tokens += constants.enumItemCost;
 			tokens += encoder.encode(String(item)).length;
 		}
 	}
@@ -921,7 +919,7 @@ function calculateParametersTokens(parameters, encoder, constants) {
 	for (const [key, value] of Object.entries(params)) if (key === "properties") {
 		const properties = value;
 		if (Object.keys(properties).length > 0) {
-			tokens += constants.propInit;
+			tokens += constants.propertyInitOverhead;
 			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
 				encoder,
 				constants
@@ -937,12 +935,12 @@ function calculateParametersTokens(parameters, encoder, constants) {
 * Calculate tokens for a single tool
 */
 function calculateToolTokens(tool, encoder, constants) {
-	let tokens = constants.funcInit;
+	let tokens = constants.functionInitOverhead;
 	const func = tool.function;
-	const fName = func.name;
-	let fDesc = func.description || "";
-	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
-	const line = `${fName}:${fDesc}`;
+	const functionName = func.name;
+	let functionDescription = func.description || "";
+	if (functionDescription.endsWith(".")) functionDescription = functionDescription.slice(0, -1);
+	const line = `${functionName}:${functionDescription}`;
 	tokens += encoder.encode(line).length;
 	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
 	return tokens;
@@ -951,20 +949,18 @@ function calculateToolTokens(tool, encoder, constants) {
 * Calculate token count for tools based on model
 */
 function numTokensForTools(tools, encoder, constants) {
-	let funcTokenCount = 0;
-	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
-	funcTokenCount += constants.funcEnd;
-	return funcTokenCount;
+	let toolTokenCount = 0;
+	for (const tool of tools) toolTokenCount += calculateToolTokens(tool, encoder, constants);
+	toolTokenCount += constants.functionEndOverhead;
+	return toolTokenCount;
 }
 /**
 * Calculate the token count of messages, supporting multiple GPT encoders
 */
 async function getTokenCount(payload, model) {
-	const tokenizer = getTokenizerFromModel(model);
-	const encoder = await getEncodeChatFunction(tokenizer);
-	const simplifiedMessages = payload.messages;
-	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
-	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
+	const encoder = await getEncoder(getTokenizerFromModel(model));
+	const inputMessages = payload.messages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = payload.messages.filter((msg) => msg.role === "assistant");
 	const constants = getModelConstants(model);
 	let inputTokens = calculateTokens(inputMessages, encoder, constants);
 	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
@@ -975,6 +971,23 @@ async function getTokenCount(payload, model) {
 	};
 }
 
+//#endregion
+//#region src/lib/upstream-signal.ts
+const DEFAULT_TIMEOUT_MS = 3e5;
+function createUpstreamSignal(clientSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const controller = new AbortController();
+	const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+	const onAbort = () => controller.abort();
+	if (clientSignal && !clientSignal.aborted) clientSignal.addEventListener("abort", onAbort);
+	return {
+		signal: controller.signal,
+		cleanup: () => {
+			if (timeout) clearTimeout(timeout);
+			clientSignal?.removeEventListener("abort", onAbort);
+		}
+	};
+}
+
 //#endregion
 //#region src/lib/validation.ts
 const openAIMessageSchema = z.object({
@@ -1048,16 +1061,18 @@ async function handleCompletion$1(c) {
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
-	if (isNullish(payload.max_tokens)) {
+	if (payload.max_tokens == null) {
 		payload = {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
-	const response = await new CopilotClient(state.auth, getClientConfig(state)).createChatCompletions(payload, { signal: c.req.raw.signal });
-	if (isNonStreaming$1(response)) {
+	const { signal, cleanup } = createUpstreamSignal(c.req.raw.signal, state.config.upstreamTimeoutSeconds !== void 0 ? state.config.upstreamTimeoutSeconds * 1e3 : void 0);
+	const response = await new CopilotClient(state.auth, getClientConfig()).createChatCompletions(payload, { signal });
+	if (isNonStreamingResponse(response)) {
 		consola.debug("Non-streaming response:", JSON.stringify(response));
+		cleanup();
 		return c.json(response);
 	}
 	consola.debug("Streaming response");
@@ -1067,12 +1082,11 @@ async function handleCompletion$1(c) {
 				consola.debug("Streaming chunk:", JSON.stringify(chunk));
 				await stream.writeSSE(chunk);
 			}
-		} finally {}
+		} finally {
+			cleanup();
+		}
 	});
 }
-function isNonStreaming$1(response) {
-	return Object.hasOwn(response, "choices");
-}
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -1084,7 +1098,7 @@ completionRoutes.post("/", requestGuard, (c) => handleCompletion$1(c));
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	const payload = parseEmbeddingRequest(await c.req.json());
-	const response = await new CopilotClient(state.auth, getClientConfig(state)).createEmbeddings(payload);
+	const response = await new CopilotClient(state.auth, getClientConfig()).createEmbeddings(payload);
 	return c.json(response);
 });
 
@@ -1099,6 +1113,13 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 		content_filter: "end_turn"
 	}[finishReason];
 }
+function mapOpenAIUsageToAnthropic(usage) {
+	return {
+		input_tokens: (usage?.prompt_tokens ?? 0) - (usage?.prompt_tokens_details?.cached_tokens ?? 0),
+		output_tokens: usage?.completion_tokens ?? 0,
+		...usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: usage.prompt_tokens_details.cached_tokens }
+	};
+}
 
 //#endregion
 //#region src/translator/anthropic/anthropic-stream-translator.ts
@@ -1109,19 +1130,21 @@ var AnthropicStreamTranslator = class {
 			messageStartSent: false,
 			contentBlockIndex: 0,
 			contentBlockOpen: false,
+			thinkingBlockOpen: false,
 			toolCalls: {}
 		};
 	}
 	onChunk(chunk) {
 		if (chunk.choices.length === 0) return [];
-		const events$1 = [];
+		const events = [];
 		const choice = chunk.choices[0];
 		const { delta } = choice;
-		this.appendMessageStart(events$1, chunk);
-		this.appendContentDelta(events$1, delta.content);
-		this.appendToolCalls(events$1, delta.tool_calls);
-		this.appendFinish(events$1, chunk, choice.finish_reason);
-		return events$1;
+		this.appendMessageStart(events, chunk);
+		this.appendThinkingDelta(events, delta.reasoning_text);
+		this.appendContentDelta(events, delta.content);
+		this.appendToolCalls(events, delta.tool_calls);
+		this.appendFinish(events, chunk, choice.finish_reason);
+		return events;
 	}
 	onError(error) {
 		return [{
@@ -1147,9 +1170,9 @@ var AnthropicStreamTranslator = class {
 			return tc !== void 0 && tc.anthropicBlockIndex === this.state.contentBlockIndex;
 		});
 	}
-	appendMessageStart(events$1, chunk) {
+	appendMessageStart(events, chunk) {
 		if (this.state.messageStartSent) return;
-		events$1.push({
+		events.push({
 			type: "message_start",
 			message: {
 				id: chunk.id,
@@ -1160,18 +1183,57 @@ var AnthropicStreamTranslator = class {
 				stop_reason: null,
 				stop_sequence: null,
 				usage: {
-					input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-					output_tokens: 0,
-					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+					...mapOpenAIUsageToAnthropic(chunk.usage),
+					output_tokens: 0
 				}
 			}
 		});
 		this.state.messageStartSent = true;
 	}
-	appendContentDelta(events$1, content) {
+	appendThinkingDelta(events, reasoningText) {
+		if (!reasoningText) return;
+		if (this.state.contentBlockOpen && !this.state.thinkingBlockOpen) {
+			events.push({
+				type: "content_block_stop",
+				index: this.state.contentBlockIndex
+			});
+			this.state.contentBlockIndex++;
+			this.state.contentBlockOpen = false;
+		}
+		if (!this.state.thinkingBlockOpen) {
+			events.push({
+				type: "content_block_start",
+				index: this.state.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			this.state.contentBlockOpen = true;
+			this.state.thinkingBlockOpen = true;
+		}
+		events.push({
+			type: "content_block_delta",
+			index: this.state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: reasoningText
+			}
+		});
+	}
+	appendContentDelta(events, content) {
 		if (!content) return;
+		if (this.state.thinkingBlockOpen) {
+			events.push({
+				type: "content_block_stop",
+				index: this.state.contentBlockIndex
+			});
+			this.state.contentBlockIndex++;
+			this.state.contentBlockOpen = false;
+			this.state.thinkingBlockOpen = false;
+		}
 		if (this.isToolBlockOpen()) {
-			events$1.push({
+			events.push({
 				type: "content_block_stop",
 				index: this.state.contentBlockIndex
 			});
@@ -1179,7 +1241,7 @@ var AnthropicStreamTranslator = class {
 			this.state.contentBlockOpen = false;
 		}
 		if (!this.state.contentBlockOpen) {
-			events$1.push({
+			events.push({
 				type: "content_block_start",
 				index: this.state.contentBlockIndex,
 				content_block: {
@@ -1189,7 +1251,7 @@ var AnthropicStreamTranslator = class {
 			});
 			this.state.contentBlockOpen = true;
 		}
-		events$1.push({
+		events.push({
 			type: "content_block_delta",
 			index: this.state.contentBlockIndex,
 			delta: {
@@ -1198,17 +1260,18 @@ var AnthropicStreamTranslator = class {
 			}
 		});
 	}
-	appendToolCalls(events$1, toolCalls) {
+	appendToolCalls(events, toolCalls) {
 		if (!toolCalls || toolCalls.length === 0) return;
 		for (const toolCall of toolCalls) {
 			if (toolCall.id && toolCall.function?.name) {
 				if (this.state.contentBlockOpen) {
-					events$1.push({
+					events.push({
 						type: "content_block_stop",
 						index: this.state.contentBlockIndex
 					});
 					this.state.contentBlockIndex++;
 					this.state.contentBlockOpen = false;
+					this.state.thinkingBlockOpen = false;
 				}
 				const anthropicBlockIndex = this.state.contentBlockIndex;
 				this.state.toolCalls[toolCall.index] = {
@@ -1216,7 +1279,7 @@ var AnthropicStreamTranslator = class {
 					name: toolCall.function.name,
 					anthropicBlockIndex
 				};
-				events$1.push({
+				events.push({
 					type: "content_block_start",
 					index: anthropicBlockIndex,
 					content_block: {
@@ -1231,7 +1294,7 @@ var AnthropicStreamTranslator = class {
 			if (toolCall.function?.arguments) {
 				const toolCallInfo = this.state.toolCalls[toolCall.index];
 				if (!toolCallInfo) continue;
-				events$1.push({
+				events.push({
 					type: "content_block_delta",
 					index: toolCallInfo.anthropicBlockIndex,
 					delta: {
@@ -1242,26 +1305,23 @@ var AnthropicStreamTranslator = class {
 			}
 		}
 	}
-	appendFinish(events$1, chunk, finishReason) {
+	appendFinish(events, chunk, finishReason) {
 		if (!finishReason) return;
 		if (this.state.contentBlockOpen) {
-			events$1.push({
+			events.push({
 				type: "content_block_stop",
 				index: this.state.contentBlockIndex
 			});
 			this.state.contentBlockOpen = false;
+			this.state.thinkingBlockOpen = false;
 		}
-		events$1.push({
+		events.push({
 			type: "message_delta",
 			delta: {
 				stop_reason: mapOpenAIStopReasonToAnthropic(finishReason),
 				stop_sequence: null
 			},
-			usage: {
-				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-				output_tokens: chunk.usage?.completion_tokens ?? 0,
-				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
-			}
+			usage: mapOpenAIUsageToAnthropic(chunk.usage)
 		}, { type: "message_stop" });
 	}
 };
@@ -1274,11 +1334,11 @@ const DEFAULT_FALLBACKS = {
 	claudeHaiku: "claude-haiku-4.5"
 };
 function getModelFallbackConfig() {
-	const cachedConfig$1 = getCachedConfig();
+	const cachedConfig = getCachedConfig();
 	return {
-		claudeOpus: process.env.MODEL_FALLBACK_CLAUDE_OPUS || cachedConfig$1.modelFallback?.claudeOpus || DEFAULT_FALLBACKS.claudeOpus,
-		claudeSonnet: process.env.MODEL_FALLBACK_CLAUDE_SONNET || cachedConfig$1.modelFallback?.claudeSonnet || DEFAULT_FALLBACKS.claudeSonnet,
-		claudeHaiku: process.env.MODEL_FALLBACK_CLAUDE_HAIKU || cachedConfig$1.modelFallback?.claudeHaiku || DEFAULT_FALLBACKS.claudeHaiku
+		claudeOpus: process.env.MODEL_FALLBACK_CLAUDE_OPUS || cachedConfig.modelFallback?.claudeOpus || DEFAULT_FALLBACKS.claudeOpus,
+		claudeSonnet: process.env.MODEL_FALLBACK_CLAUDE_SONNET || cachedConfig.modelFallback?.claudeSonnet || DEFAULT_FALLBACKS.claudeSonnet,
+		claudeHaiku: process.env.MODEL_FALLBACK_CLAUDE_HAIKU || cachedConfig.modelFallback?.claudeHaiku || DEFAULT_FALLBACKS.claudeHaiku
 	};
 }
 function resolveModel(modelId, knownModelIds, config) {
@@ -1293,17 +1353,20 @@ function resolveModel(modelId, knownModelIds, config) {
 //#region src/translator/anthropic/anthropic-translator.ts
 var AnthropicTranslator = class {
 	toOpenAI(payload) {
+		const thinkingParams = this.translateThinking(payload.thinking, payload.model);
+		const isThinkingActive = payload.thinking?.type === "enabled" || payload.thinking?.type === "adaptive";
 		return {
 			model: this.translateModelName(payload.model),
 			messages: this.translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
 			max_tokens: payload.max_tokens,
 			stop: payload.stop_sequences,
 			stream: payload.stream,
-			temperature: payload.temperature,
-			top_p: payload.top_p,
+			temperature: isThinkingActive ? void 0 : payload.temperature,
+			top_p: isThinkingActive ? void 0 : payload.top_p,
 			user: payload.metadata?.user_id,
 			tools: this.translateAnthropicToolsToOpenAI(payload.tools),
-			tool_choice: this.translateAnthropicToolChoiceToOpenAI(payload.tool_choice)
+			tool_choice: this.translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
+			...thinkingParams
 		};
 	}
 	fromOpenAI(response) {
@@ -1326,20 +1389,32 @@ var AnthropicTranslator = class {
 			content: [...allTextBlocks, ...allToolUseBlocks],
 			stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
 			stop_sequence: null,
-			usage: {
-				input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-				output_tokens: response.usage?.completion_tokens ?? 0,
-				...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens }
-			}
+			usage: mapOpenAIUsageToAnthropic(response.usage)
 		};
 	}
 	createStreamTranslator() {
 		return new AnthropicStreamTranslator();
 	}
 	translateModelName(model) {
-		const knownModelIds = state.cache.models ? new Set(state.cache.models.data.map((m) => m.id)) : void 0;
-		const config = getModelFallbackConfig();
-		return resolveModel(model, knownModelIds, config);
+		return resolveModel(model, state.cache.models ? new Set(state.cache.models.data.map((m) => m.id)) : void 0, getModelFallbackConfig());
+	}
+	translateThinking(thinking, model) {
+		if (!thinking || thinking.type === "disabled") return {};
+		const isClaude = model.startsWith("claude");
+		if (thinking.type === "adaptive") return {
+			reasoning_effort: "medium",
+			...isClaude && { thinking_budget: 24e3 }
+		};
+		const budgetTokens = thinking.budget_tokens;
+		return {
+			reasoning_effort: this.budgetToReasoningEffort(budgetTokens),
+			...isClaude && { thinking_budget: budgetTokens }
+		};
+	}
+	budgetToReasoningEffort(budgetTokens) {
+		if (budgetTokens <= 8e3) return "low";
+		if (budgetTokens <= 24e3) return "medium";
+		return "high";
 	}
 	translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
 		const systemMessages = this.handleSystemPrompt(system);
@@ -1480,6 +1555,10 @@ var AnthropicTranslator = class {
 
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
+const CLAUDE_TOOL_OVERHEAD_TOKENS = 346;
+const GROK_TOOL_OVERHEAD_TOKENS = 480;
+const CLAUDE_ESTIMATION_FACTOR = 1.15;
+const GROK_ESTIMATION_FACTOR = 1.03;
 /**
 * Handles token counting for Anthropic messages
 */
@@ -1498,13 +1577,13 @@ async function handleCountTokens(c) {
 		let mcpToolExist = false;
 		if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
 		if (!mcpToolExist) {
-			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
-			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 480;
+			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + CLAUDE_TOOL_OVERHEAD_TOKENS;
+			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + GROK_TOOL_OVERHEAD_TOKENS;
 		}
 	}
 	let finalTokenCount = tokenCount.input + tokenCount.output;
-	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
-	else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * 1.03);
+	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * CLAUDE_ESTIMATION_FACTOR);
+	else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * GROK_ESTIMATION_FACTOR);
 	consola.info("Token count:", finalTokenCount);
 	return c.json({ input_tokens: finalTokenCount });
 }
@@ -1522,11 +1601,13 @@ async function handleCompletion(c) {
 	});
 	consola.debug("Claude Code requested model:", anthropicPayload.model, "-> Copilot model:", openAIPayload.model);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
-	const response = await new CopilotClient(state.auth, getClientConfig(state)).createChatCompletions(openAIPayload, { signal: c.req.raw.signal });
-	if (isNonStreaming(response)) {
-		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
+	const { signal, cleanup } = createUpstreamSignal(c.req.raw.signal, state.config.upstreamTimeoutSeconds !== void 0 ? state.config.upstreamTimeoutSeconds * 1e3 : void 0);
+	const response = await new CopilotClient(state.auth, getClientConfig()).createChatCompletions(openAIPayload, { signal });
+	if (isNonStreamingResponse(response)) {
+		consola.debug("Non-streaming response from Copilot (full):", JSON.stringify(response, null, 2));
 		const anthropicResponse = translator.fromOpenAI(response);
 		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		cleanup();
 		return c.json(anthropicResponse);
 	}
 	consola.debug("Streaming response from Copilot");
@@ -1538,8 +1619,8 @@ async function handleCompletion(c) {
 				if (rawEvent.data === "[DONE]") break;
 				if (!rawEvent.data) continue;
 				const chunk = JSON.parse(rawEvent.data);
-				const events$1 = streamTranslator.onChunk(chunk);
-				for (const event of events$1) {
+				const events = streamTranslator.onChunk(chunk);
+				for (const event of events) {
 					consola.debug("Translated Anthropic event:", JSON.stringify(event));
 					await stream.writeSSE({
 						event: event.type,
@@ -1558,12 +1639,11 @@ async function handleCompletion(c) {
 				event: event.type,
 				data: JSON.stringify(event)
 			});
+		} finally {
+			cleanup();
 		}
 	});
 }
-function isNonStreaming(response) {
-	return Object.hasOwn(response, "choices");
-}
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -1575,10 +1655,7 @@ messageRoutes.post("/count_tokens", (c) => handleCountTokens(c));
 //#region src/routes/models/route.ts
 const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
-	if (!state.cache.models) {
-		const copilotClient = new CopilotClient(state.auth, getClientConfig(state));
-		await cacheModels(copilotClient);
-	}
+	if (!state.cache.models) await cacheModels(new CopilotClient(state.auth, getClientConfig()));
 	const models = state.cache.models?.data.map((model) => ({
 		id: model.id,
 		object: "model",
@@ -1606,7 +1683,7 @@ tokenRoute.get("/", (c) => {
 //#region src/routes/usage/route.ts
 const usageRoute = new Hono();
 usageRoute.get("/", async (c) => {
-	const usage = await new GitHubClient(state.auth, getClientConfig(state)).getCopilotUsage();
+	const usage = await new GitHubClient(state.auth, getClientConfig()).getCopilotUsage();
 	return c.json(usage);
 });
 
@@ -1677,17 +1754,13 @@ async function runServer(options) {
 	state.config.rateLimitSeconds = options.rateLimit;
 	state.config.rateLimitWait = options.rateLimitWait;
 	state.config.showToken = options.showToken;
+	state.config.upstreamTimeoutSeconds = options.upstreamTimeoutSeconds;
 	await ensurePaths();
 	await readConfig();
 	await cacheVSCodeVersion();
 	if (!options.githubToken) await setupGitHubToken();
 	await setupCopilotToken();
-	const clientConfig = {
-		...getClientConfig(state),
-		accountType
-	};
-	const copilotClient = new CopilotClient(state.auth, clientConfig);
-	await cacheModels(copilotClient);
+	await cacheModels(new CopilotClient(state.auth, getClientConfig()));
 	consola.info(`Available models: \n${state.cache.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
 	if (options.claudeCode) {
@@ -1700,6 +1773,15 @@ async function runServer(options) {
 		bun: options.idleTimeoutSeconds === void 0 ? void 0 : { idleTimeout: options.idleTimeoutSeconds }
 	});
 }
+function parseIntArg(raw, name, fallbackMsg) {
+	if (raw === void 0) return void 0;
+	const n = Number.parseInt(raw, 10);
+	if (Number.isNaN(n) || n < 0) {
+		consola.warn(`Invalid --${name} value "${raw}". ${fallbackMsg}`);
+		return;
+	}
+	return n;
+}
 const start = defineCommand({
 	meta: {
 		name: "start",
@@ -1765,17 +1847,17 @@ const start = defineCommand({
 			type: "string",
 			default: "120",
 			description: "Bun server idle timeout in seconds"
+		},
+		"upstream-timeout": {
+			type: "string",
+			default: "300",
+			description: "Upstream request timeout in seconds (0 to disable)"
 		}
 	},
 	run({ args }) {
-		const rateLimitRaw = args["rate-limit"];
-		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
-		const idleTimeoutRaw = args["idle-timeout"];
-		let idleTimeoutSeconds = idleTimeoutRaw === void 0 ? void 0 : Number.parseInt(idleTimeoutRaw, 10);
-		if (idleTimeoutSeconds !== void 0 && (Number.isNaN(idleTimeoutSeconds) || idleTimeoutSeconds < 0)) {
-			consola.warn(`Invalid --idle-timeout value "${idleTimeoutRaw}". Falling back to Bun default.`);
-			idleTimeoutSeconds = void 0;
-		}
+		const rateLimit = parseIntArg(args["rate-limit"], "rate-limit", "Rate limiting disabled.");
+		const idleTimeoutSeconds = parseIntArg(args["idle-timeout"], "idle-timeout", "Falling back to Bun default.");
+		const upstreamTimeoutSeconds = parseIntArg(args["upstream-timeout"], "upstream-timeout", "Falling back to default (300s).");
 		return runServer({
 			port: Number.parseInt(args.port, 10),
 			verbose: args.verbose,
@@ -1787,14 +1869,15 @@ const start = defineCommand({
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
-			idleTimeoutSeconds
+			idleTimeoutSeconds,
+			upstreamTimeoutSeconds
 		});
 	}
 });
 
 //#endregion
 //#region src/main.ts
-const main = defineCommand({
+runMain(defineCommand({
 	meta: {
 		name: "ghc-proxy",
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
@@ -1805,12 +1888,11 @@ const main = defineCommand({
 		"check-usage": checkUsage,
 		debug
 	}
-});
-runMain(main).catch((error) => {
+})).catch((error) => {
 	consola.error("Failed to start CLI:", error);
 	process.exitCode = 1;
 });
 
 //#endregion
 export {  };
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.mjs.map