github-router 0.2.0 → 0.3.1

package/dist/main.js

@@ -56,7 +56,7 @@ const standardHeaders = () => ({
 const COPILOT_VERSION = "0.26.7";
 const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
 const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
-const API_VERSION = "2025-04-01";
+const API_VERSION = "2025-05-01";
 const copilotBaseUrl = (state$1) => state$1.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state$1.accountType}.githubcopilot.com`;
 const copilotHeaders = (state$1, vision = false, integrationId = "vscode-chat") => {
 	const headers = {
@@ -67,6 +67,7 @@ const copilotHeaders = (state$1, vision = false, integrationId = "vscode-chat")
 		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 		"user-agent": USER_AGENT,
 		"openai-intent": "conversation-panel",
+		"x-interaction-type": "conversation-panel",
 		"x-github-api-version": API_VERSION,
 		"x-request-id": randomUUID(),
 		"x-vscode-user-agent-library-version": "electron-fetch"
@@ -105,19 +106,30 @@ async function forwardError(c, error) {
 		try {
 			errorJson = JSON.parse(errorText);
 		} catch {
-			errorJson = errorText;
+			errorJson = void 0;
 		}
-		consola.error("HTTP error:", errorJson);
+		const message = resolveErrorMessage(errorJson, errorText);
+		consola.error("HTTP error:", errorJson ?? errorText);
 		return c.json({ error: {
-			message: errorText,
+			message,
 			type: "error"
 		} }, error.response.status);
 	}
 	return c.json({ error: {
-		message: error.message,
+		message: error instanceof Error ? error.message : String(error),
 		type: "error"
 	} }, 500);
 }
+function resolveErrorMessage(errorJson, fallback) {
+	if (typeof errorJson !== "object" || errorJson === null) return fallback;
+	const errorRecord = errorJson;
+	if (errorRecord.message !== void 0) return String(errorRecord.message);
+	if (typeof errorRecord.error === "object" && errorRecord.error !== null) {
+		const nestedRecord = errorRecord.error;
+		if (nestedRecord.message !== void 0) return String(nestedRecord.message);
+	}
+	return fallback;
+}
 
 //#endregion
 //#region src/services/github/get-copilot-token.ts
@@ -201,7 +213,8 @@ const cacheVSCodeVersion = async () => {
 async function pollAccessToken(deviceCode) {
 	const sleepDuration = (deviceCode.interval + 1) * 1e3;
 	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
-	while (true) {
+	const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
+	while (Date.now() < expiresAt) {
 		const response = await fetch(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
 			method: "POST",
 			headers: standardHeaders(),
@@ -212,16 +225,19 @@ async function pollAccessToken(deviceCode) {
 			})
 		});
 		if (!response.ok) {
-			await sleep(sleepDuration);
 			consola.error("Failed to poll access token:", await response.text());
+			if (Date.now() >= expiresAt) break;
+			await sleep(sleepDuration);
 			continue;
 		}
 		const json = await response.json();
 		consola.debug("Polling access token response:", json);
 		const { access_token } = json;
 		if (access_token) return access_token;
-		else await sleep(sleepDuration);
+		if (Date.now() >= expiresAt) break;
+		await sleep(sleepDuration);
 	}
+	throw new Error("Device code expired. Please run auth again.");
 }
 
 //#endregion
@@ -233,7 +249,7 @@ const setupCopilotToken = async () => {
 	state.copilotToken = token;
 	consola.debug("GitHub Copilot Token fetched successfully!");
 	if (state.showToken) consola.info("Copilot token:", token);
-	const refreshInterval = (refresh_in - 60) * 1e3;
+	const refreshInterval = Math.max((refresh_in - 60) * 1e3, 1e3);
 	setInterval(async () => {
 		consola.debug("Refreshing Copilot token");
 		try {
@@ -485,8 +501,10 @@ function initProxyFromEnv() {
 function getShell() {
 	const { platform, ppid, env } = process$1;
 	if (platform === "win32") {
+		if (env.POWERSHELL_DISTRIBUTION_CHANNEL) return "powershell";
 		try {
-			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			const parentProcess = execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString();
+			if (parentProcess.toLowerCase().includes("powershell.exe") || parentProcess.toLowerCase().includes("pwsh.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -501,6 +519,12 @@ function getShell() {
 		return "sh";
 	}
 }
+function quotePosixValue(value) {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function quotePowerShellValue(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
 /**
 * Generates a copy-pasteable script to set multiple environment variables
 * and run a subsequent command.
@@ -514,28 +538,28 @@ function generateEnvScript(envVars, commandToRun = "") {
 	let commandBlock;
 	switch (shell) {
 		case "powershell":
-			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${value}`).join("; ");
+			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${quotePowerShellValue(value)}`).join("; ");
 			break;
 		case "cmd":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set ${key}=${value}`).join(" & ");
+			commandBlock = filteredEnvVars.map(([key, value]) => `set "${key}=${value}"`).join(" & ");
 			break;
 		case "fish":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${value}`).join("; ");
+			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${quotePosixValue(value)}`).join("; ");
 			break;
 		default: {
-			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${value}`).join(" ");
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${quotePosixValue(value)}`).join(" ");
 			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
 			break;
 		}
 	}
-	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : shell === "powershell" ? "; " : " && "}${commandToRun}`;
 	return commandBlock || commandToRun;
 }
 
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
-	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected by user", Response.json({ message: "Request rejected by user" }, { status: 403 }));
 };
 
 //#endregion
@@ -560,7 +584,7 @@ async function checkRateLimit(state$1) {
 	const waitTimeMs = waitTimeSeconds * 1e3;
 	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
 	await sleep(waitTimeMs);
-	state$1.lastRequestTimestamp = now;
+	state$1.lastRequestTimestamp = Date.now();
 	consola.info("Rate limit wait completed, proceeding with request");
 }
 
@@ -776,19 +800,100 @@ const createChatCompletions = async (payload) => {
 		body: JSON.stringify(payload)
 	});
 	if (!response.ok) {
-		consola.error("Failed to create chat completions", response);
-		throw new HTTPError("Failed to create chat completions", response);
+		let errorBody = "";
+		try {
+			errorBody = await response.text();
+		} catch {
+			errorBody = "(could not read error body)";
+		}
+		const claudeModels = state.models?.data.filter((m) => m.id.startsWith("claude")).map((m) => m.id).join(", ") ?? "(models not loaded)";
+		consola.error(`Copilot rejected model "${payload.model}": ${response.status} ${errorBody} (available Claude models: ${claudeModels})`);
+		throw new HTTPError("Failed to create chat completions", new Response(errorBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		}));
 	}
 	if (payload.stream) return events(response);
 	return await response.json();
 };
 
+//#endregion
+//#region src/services/copilot/web-search.ts
+const MAX_SEARCHES_PER_SECOND = 3;
+let searchTimestamps = [];
+async function throttleSearch() {
+	const now = Date.now();
+	searchTimestamps = searchTimestamps.filter((t) => now - t < 1e3);
+	if (searchTimestamps.length >= MAX_SEARCHES_PER_SECOND) {
+		const waitMs = 1e3 - (now - searchTimestamps[0]);
+		if (waitMs > 0) {
+			consola.debug(`Web search rate limited, waiting ${waitMs}ms`);
+			await sleep(waitMs);
+		}
+	}
+	searchTimestamps.push(Date.now());
+}
+function threadsHeaders() {
+	return copilotHeaders(state, false, "copilot-chat");
+}
+async function createThread() {
+	const response = await fetch(`${copilotBaseUrl(state)}/github/chat/threads`, {
+		method: "POST",
+		headers: threadsHeaders(),
+		body: JSON.stringify({})
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat thread", response.status);
+		throw new Error(`Failed to create chat thread: ${response.status}`);
+	}
+	return (await response.json()).thread_id;
+}
+async function sendThreadMessage(threadId, query) {
+	const response = await fetch(`${copilotBaseUrl(state)}/github/chat/threads/${threadId}/messages`, {
+		method: "POST",
+		headers: threadsHeaders(),
+		body: JSON.stringify({
+			content: query,
+			intent: "conversation",
+			skills: ["web-search"],
+			references: []
+		})
+	});
+	if (!response.ok) {
+		consola.error("Failed to send thread message", response.status);
+		throw new Error(`Failed to send thread message: ${response.status}`);
+	}
+	return await response.json();
+}
+async function searchWeb(query) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	await throttleSearch();
+	consola.info(`Web search: "${query.slice(0, 80)}"`);
+	const response = await sendThreadMessage(await createThread(), query);
+	const references = [];
+	for (const ref of response.message.references ?? []) if (ref.results) {
+		for (const result of ref.results) if (result.url && result.reference_type !== "bing_search") references.push({
+			title: result.title,
+			url: result.url
+		});
+	}
+	consola.debug(`Web search returned ${references.length} references`);
+	return {
+		content: response.message.content,
+		references
+	};
+}
+
 //#endregion
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	let payload = await c.req.json();
-	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	if (state.manualApprove) await awaitApproval();
+	await injectWebSearchIfNeeded$1(payload);
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
 		if (selectedModel) {
@@ -798,28 +903,68 @@ async function handleCompletion$1(c) {
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
-	if (state.manualApprove) await awaitApproval();
 	if (isNullish(payload.max_tokens)) {
 		payload = {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+		if (debugEnabled) consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
 	const response = await createChatCompletions(payload);
-	if (isNonStreaming$2(response)) {
-		consola.debug("Non-streaming response:", JSON.stringify(response));
+	if (isNonStreaming$1(response)) {
+		if (debugEnabled) consola.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	}
 	consola.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		for await (const chunk of response) {
-			consola.debug("Streaming chunk:", JSON.stringify(chunk));
+			if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(chunk));
 			await stream.writeSSE(chunk);
 		}
 	});
 }
-const isNonStreaming$2 = (response) => Object.hasOwn(response, "choices");
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+async function injectWebSearchIfNeeded$1(payload) {
+	if (!payload.tools?.some((t) => "type" in t && t.type === "web_search" || t.function?.name === "web_search")) return;
+	const query = payload.messages.some((msg) => msg.role === "tool") ? void 0 : extractUserQuery$1(payload.messages);
+	if (query) try {
+		const results = await searchWeb(query);
+		const searchContext = [
+			"[Web Search Results]",
+			results.content,
+			"",
+			results.references.map((r) => `- [${r.title}](${r.url})`).join("\n"),
+			"[End Web Search Results]"
+		].join("\n");
+		const systemMsg = payload.messages.find((msg) => msg.role === "system");
+		if (systemMsg) systemMsg.content = `${searchContext}\n\n${typeof systemMsg.content === "string" ? systemMsg.content : Array.isArray(systemMsg.content) ? systemMsg.content.filter((p) => p.type === "text").map((p) => "text" in p ? p.text : "").join("\n") : ""}`;
+		else payload.messages.unshift({
+			role: "system",
+			content: searchContext
+		});
+	} catch (error) {
+		consola.warn("Web search failed, continuing without results:", error);
+	}
+	payload.tools = payload.tools?.filter((t) => !("type" in t && t.type === "web_search" || t.function?.name === "web_search"));
+	if (payload.tools?.length === 0) payload.tools = void 0;
+	if (!payload.tools) payload.tool_choice = void 0;
+	else if (payload.tool_choice && typeof payload.tool_choice === "object" && "type" in payload.tool_choice && payload.tool_choice.type === "function") {
+		const toolChoiceName = payload.tool_choice.function?.name;
+		if (toolChoiceName && !payload.tools.some((tool) => tool.function.name === toolChoiceName)) payload.tool_choice = void 0;
+	}
+}
+function extractUserQuery$1(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") return msg.content;
+			if (Array.isArray(msg.content)) {
+				const text = msg.content.find((p) => p.type === "text");
+				if (text && "text" in text) return text.text;
+			}
+		}
+	}
+}
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -858,399 +1003,128 @@ embeddingRoutes.post("/", async (c) => {
 });
 
 //#endregion
-//#region src/routes/messages/utils.ts
-function mapOpenAIStopReasonToAnthropic(finishReason) {
-	if (finishReason === null) return null;
-	return {
-		stop: "end_turn",
-		length: "max_tokens",
-		tool_calls: "tool_use",
-		content_filter: "end_turn"
-	}[finishReason];
-}
-
-//#endregion
-//#region src/routes/messages/non-stream-translation.ts
-function translateToOpenAI(payload) {
+//#region src/services/copilot/create-messages.ts
+/**
+* Build headers that match what VS Code Copilot Chat sends to the Copilot API.
+*
+* copilotHeaders() provides: Authorization, content-type, copilot-integration-id,
+* editor-version, editor-plugin-version, user-agent, openai-intent,
+* x-github-api-version, x-request-id, x-vscode-user-agent-library-version.
+*
+* We add the remaining headers VS Code sends for /v1/messages:
+* - X-Initiator (VS Code sets dynamically; "agent" is safe for CLI use)
+* - anthropic-version (VS Code's Anthropic SDK sends this)
+* - X-Interaction-Id (VS Code sends a session-scoped UUID)
+*
+* We intentionally omit copilot-vision-request — VS Code only sends it when
+* images are present, and the native /v1/messages endpoint handles vision
+* without requiring the header.
+*/
+function buildHeaders() {
 	return {
-		model: translateModelName(payload.model),
-		messages: 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,
-		user: payload.metadata?.user_id,
-		tools: translateAnthropicToolsToOpenAI(payload.tools),
-		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice)
+		...copilotHeaders(state),
+		"X-Initiator": "agent",
+		"anthropic-version": "2023-06-01",
+		"X-Interaction-Id": randomUUID()
 	};
 }
-function translateModelName(model) {
-	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
-	else if (model.startsWith("claude-opus-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
-	return model;
-}
-function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
-	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message));
-	return [...systemMessages, ...otherMessages];
-}
-function handleSystemPrompt(system) {
-	if (!system) return [];
-	if (typeof system === "string") return [{
-		role: "system",
-		content: system
-	}];
-	else return [{
-		role: "system",
-		content: system.map((block) => block.text).join("\n\n")
-	}];
-}
-function handleUserMessage(message) {
-	const newMessages = [];
-	if (Array.isArray(message.content)) {
-		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
-		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
-		for (const block of toolResultBlocks) newMessages.push({
-			role: "tool",
-			tool_call_id: block.tool_use_id,
-			content: mapContent(block.content)
-		});
-		if (otherBlocks.length > 0) newMessages.push({
-			role: "user",
-			content: mapContent(otherBlocks)
-		});
-	} else newMessages.push({
-		role: "user",
-		content: mapContent(message.content)
+/**
+* Forward an Anthropic Messages API request to Copilot's native /v1/messages endpoint.
+* Returns the raw Response so callers can handle streaming vs non-streaming.
+*/
+async function createMessages(body) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const headers = buildHeaders();
+	const url = `${copilotBaseUrl(state)}/v1/messages`;
+	consola.debug(`Forwarding to ${url}`);
+	const response = await fetch(url, {
+		method: "POST",
+		headers,
+		body
 	});
-	return newMessages;
-}
-function handleAssistantMessage(message) {
-	if (!Array.isArray(message.content)) return [{
-		role: "assistant",
-		content: mapContent(message.content)
-	}];
-	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
-	const textBlocks = message.content.filter((block) => block.type === "text");
-	const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
-	const allTextContent = [...textBlocks.map((b) => b.text), ...thinkingBlocks.map((b) => b.thinking)].join("\n\n");
-	return toolUseBlocks.length > 0 ? [{
-		role: "assistant",
-		content: allTextContent || null,
-		tool_calls: toolUseBlocks.map((toolUse) => ({
-			id: toolUse.id,
-			type: "function",
-			function: {
-				name: toolUse.name,
-				arguments: JSON.stringify(toolUse.input)
-			}
-		}))
-	}] : [{
-		role: "assistant",
-		content: mapContent(message.content)
-	}];
-}
-function mapContent(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return null;
-	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
-	const contentParts = [];
-	for (const block of content) switch (block.type) {
-		case "text":
-			contentParts.push({
-				type: "text",
-				text: block.text
-			});
-			break;
-		case "thinking":
-			contentParts.push({
-				type: "text",
-				text: block.thinking
-			});
-			break;
-		case "image":
-			contentParts.push({
-				type: "image_url",
-				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-			});
-			break;
-	}
-	return contentParts;
-}
-function translateAnthropicToolsToOpenAI(anthropicTools) {
-	if (!anthropicTools) return;
-	return anthropicTools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.input_schema
+	if (!response.ok) {
+		let errorBody = "";
+		try {
+			errorBody = await response.text();
+		} catch {
+			errorBody = "(could not read error body)";
 		}
-	}));
-}
-function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
-	if (!anthropicToolChoice) return;
-	switch (anthropicToolChoice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool":
-			if (anthropicToolChoice.name) return {
-				type: "function",
-				function: { name: anthropicToolChoice.name }
-			};
-			return;
-		case "none": return "none";
-		default: return;
+		consola.error(`Copilot /v1/messages error: ${response.status} ${errorBody}`);
+		throw new HTTPError("Copilot messages request failed", new Response(errorBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		}));
 	}
+	return response;
 }
-function translateToAnthropic(response) {
-	const allTextBlocks = [];
-	const allToolUseBlocks = [];
-	let stopReason = null;
-	stopReason = response.choices[0]?.finish_reason ?? stopReason;
-	for (const choice of response.choices) {
-		const textBlocks = getAnthropicTextBlocks(choice.message.content);
-		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls);
-		allTextBlocks.push(...textBlocks);
-		allToolUseBlocks.push(...toolUseBlocks);
-		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
-	}
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		model: response.model,
-		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 }
+/**
+* Forward an Anthropic count_tokens request to Copilot's native endpoint.
+* Returns the raw Response.
+*/
+async function countTokens(body) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const headers = buildHeaders();
+	const url = `${copilotBaseUrl(state)}/v1/messages/count_tokens`;
+	consola.debug(`Forwarding to ${url}`);
+	const response = await fetch(url, {
+		method: "POST",
+		headers,
+		body
+	});
+	if (!response.ok) {
+		let errorBody = "";
+		try {
+			errorBody = await response.text();
+		} catch {
+			errorBody = "(could not read error body)";
 		}
-	};
-}
-function getAnthropicTextBlocks(messageContent) {
-	if (typeof messageContent === "string") return [{
-		type: "text",
-		text: messageContent
-	}];
-	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
-		type: "text",
-		text: part.text
-	}));
-	return [];
-}
-function getAnthropicToolUseBlocks(toolCalls) {
-	if (!toolCalls) return [];
-	return toolCalls.map((toolCall) => ({
-		type: "tool_use",
-		id: toolCall.id,
-		name: toolCall.function.name,
-		input: JSON.parse(toolCall.function.arguments)
-	}));
+		consola.error(`Copilot count_tokens error: ${response.status} ${errorBody}`);
+		throw new HTTPError("Copilot count_tokens request failed", new Response(errorBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		}));
+	}
+	return response;
 }
 
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
 /**
-* Handles token counting for Anthropic messages
+* Passthrough handler for Anthropic token counting.
+* Forwards the request directly to Copilot's native /v1/messages/count_tokens endpoint.
 */
 async function handleCountTokens(c) {
-	try {
-		const anthropicBeta = c.req.header("anthropic-beta");
-		const anthropicPayload = await c.req.json();
-		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const selectedModel = state.models?.data.find((model) => model.id === anthropicPayload.model);
-		if (!selectedModel) {
-			consola.warn("Model not found, returning default token count");
-			return c.json({ input_tokens: 1 });
-		}
-		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
-			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;
-			}
-		}
-		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);
-		consola.info("Token count:", finalTokenCount);
-		return c.json({ input_tokens: finalTokenCount });
-	} catch (error) {
-		consola.error("Error counting tokens:", error);
-		return c.json({ input_tokens: 1 });
-	}
-}
-
-//#endregion
-//#region src/routes/messages/stream-translation.ts
-function isToolBlockOpen(state$1) {
-	if (!state$1.contentBlockOpen) return false;
-	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
-}
-function translateChunkToAnthropicEvents(chunk, state$1) {
-	const events$1 = [];
-	if (chunk.choices.length === 0) return events$1;
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	if (!state$1.messageStartSent) {
-		events$1.push({
-			type: "message_start",
-			message: {
-				id: chunk.id,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: chunk.model,
-				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 }
-				}
-			}
-		});
-		state$1.messageStartSent = true;
-	}
-	if (delta.content) {
-		if (isToolBlockOpen(state$1)) {
-			events$1.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockIndex++;
-			state$1.contentBlockOpen = false;
-		}
-		if (!state$1.contentBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
-			});
-			state$1.contentBlockOpen = true;
-		}
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "text_delta",
-				text: delta.content
-			}
-		});
-	}
-	if (delta.tool_calls) for (const toolCall of delta.tool_calls) {
-		if (toolCall.id && toolCall.function?.name) {
-			if (state$1.contentBlockOpen) {
-				events$1.push({
-					type: "content_block_stop",
-					index: state$1.contentBlockIndex
-				});
-				state$1.contentBlockIndex++;
-				state$1.contentBlockOpen = false;
-			}
-			const anthropicBlockIndex = state$1.contentBlockIndex;
-			state$1.toolCalls[toolCall.index] = {
-				id: toolCall.id,
-				name: toolCall.function.name,
-				anthropicBlockIndex
-			};
-			events$1.push({
-				type: "content_block_start",
-				index: anthropicBlockIndex,
-				content_block: {
-					type: "tool_use",
-					id: toolCall.id,
-					name: toolCall.function.name,
-					input: {}
-				}
-			});
-			state$1.contentBlockOpen = true;
-		}
-		if (toolCall.function?.arguments) {
-			const toolCallInfo = state$1.toolCalls[toolCall.index];
-			if (toolCallInfo) events$1.push({
-				type: "content_block_delta",
-				index: toolCallInfo.anthropicBlockIndex,
-				delta: {
-					type: "input_json_delta",
-					partial_json: toolCall.function.arguments
-				}
-			});
-		}
-	}
-	if (choice.finish_reason) {
-		if (state$1.contentBlockOpen) {
-			events$1.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockOpen = false;
-		}
-		events$1.push({
-			type: "message_delta",
-			delta: {
-				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
-				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 }
-			}
-		}, { type: "message_stop" });
-	}
-	return events$1;
+	const body = await (await countTokens(await c.req.text())).json();
+	consola.info("Token count:", JSON.stringify(body));
+	return c.json(body);
 }
 
 //#endregion
 //#region src/routes/messages/handler.ts
 async function handleCompletion(c) {
 	await checkRateLimit(state);
-	const anthropicPayload = await c.req.json();
-	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const openAIPayload = translateToOpenAI(anthropicPayload);
-	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	const rawBody = await c.req.text();
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Anthropic request body:", rawBody.slice(0, 2e3));
 	if (state.manualApprove) await awaitApproval();
-	const response = await createChatCompletions(openAIPayload);
-	if (isNonStreaming$1(response)) {
-		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
-		const anthropicResponse = translateToAnthropic(response);
-		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-		return c.json(anthropicResponse);
-	}
-	consola.debug("Streaming response from Copilot");
-	return streamSSE(c, async (stream) => {
-		const streamState = {
-			messageStartSent: false,
-			contentBlockIndex: 0,
-			contentBlockOpen: false,
-			toolCalls: {}
-		};
-		for await (const rawEvent of response) {
-			consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
-			if (rawEvent.data === "[DONE]") break;
-			if (!rawEvent.data) continue;
-			const events$1 = translateChunkToAnthropicEvents(JSON.parse(rawEvent.data), streamState);
-			for (const event of events$1) {
-				consola.debug("Translated Anthropic event:", JSON.stringify(event));
-				await stream.writeSSE({
-					event: event.type,
-					data: JSON.stringify(event)
-				});
+	const response = await createMessages(rawBody);
+	if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+		if (debugEnabled) consola.debug("Streaming response from Copilot /v1/messages");
+		return new Response(response.body, {
+			status: response.status,
+			headers: {
+				"content-type": "text/event-stream",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
 			}
-		}
-	});
+		});
+	}
+	const body = await response.json();
+	if (debugEnabled) consola.debug("Non-streaming response from Copilot /v1/messages:", JSON.stringify(body).slice(0, 2e3));
+	return c.json(body, response.status);
 }
-const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -1331,7 +1205,7 @@ function detectAgentCall(input) {
 	if (!Array.isArray(input)) return false;
 	return input.some((item) => {
 		if ("role" in item && item.role === "assistant") return true;
-		if ("type" in item && item.type === "function_call_output") return true;
+		if ("type" in item && (item.type === "function_call" || item.type === "function_call_output")) return true;
 		return false;
 	});
 }
@@ -1342,77 +1216,23 @@ function filterUnsupportedTools(payload) {
 		if (!isSupported) consola.debug(`Stripping unsupported tool type: ${tool.type}`);
 		return isSupported;
 	});
+	let toolChoice = payload.tool_choice;
+	if (supported.length === 0) toolChoice = void 0;
+	else if (toolChoice && typeof toolChoice === "object") {
+		const supportedNames = new Set(supported.map((tool) => tool.name).filter(Boolean));
+		const toolChoiceName = getToolChoiceName(toolChoice);
+		if (toolChoiceName && !supportedNames.has(toolChoiceName)) toolChoice = void 0;
+	}
 	return {
 		...payload,
-		tools: supported.length > 0 ? supported : void 0
+		tools: supported.length > 0 ? supported : void 0,
+		tool_choice: toolChoice
 	};
 }
-
-//#endregion
-//#region src/services/copilot/web-search.ts
-const MAX_SEARCHES_PER_SECOND = 3;
-let searchTimestamps = [];
-async function throttleSearch() {
-	const now = Date.now();
-	searchTimestamps = searchTimestamps.filter((t) => now - t < 1e3);
-	if (searchTimestamps.length >= MAX_SEARCHES_PER_SECOND) {
-		const waitMs = 1e3 - (now - searchTimestamps[0]);
-		if (waitMs > 0) {
-			consola.debug(`Web search rate limited, waiting ${waitMs}ms`);
-			await sleep(waitMs);
-		}
-	}
-	searchTimestamps.push(Date.now());
-}
-function threadsHeaders() {
-	return copilotHeaders(state, false, "copilot-chat");
-}
-async function createThread() {
-	const response = await fetch(`${copilotBaseUrl(state)}/github/chat/threads`, {
-		method: "POST",
-		headers: threadsHeaders(),
-		body: JSON.stringify({})
-	});
-	if (!response.ok) {
-		consola.error("Failed to create chat thread", response.status);
-		throw new Error(`Failed to create chat thread: ${response.status}`);
-	}
-	return (await response.json()).thread_id;
-}
-async function sendThreadMessage(threadId, query) {
-	const response = await fetch(`${copilotBaseUrl(state)}/github/chat/threads/${threadId}/messages`, {
-		method: "POST",
-		headers: threadsHeaders(),
-		body: JSON.stringify({
-			content: query,
-			intent: "conversation",
-			skills: ["web-search"],
-			references: []
-		})
-	});
-	if (!response.ok) {
-		consola.error("Failed to send thread message", response.status);
-		throw new Error(`Failed to send thread message: ${response.status}`);
-	}
-	return await response.json();
-}
-async function searchWeb(query) {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	await throttleSearch();
-	consola.info(`Web search: "${query.slice(0, 80)}"`);
-	const response = await sendThreadMessage(await createThread(), query);
-	const references = [];
-	for (const ref of response.message.references) if (ref.results) {
-		for (const result of ref.results) if (result.url && result.reference_type !== "bing_search") references.push({
-			title: result.title,
-			url: result.url
-		});
-	}
-	consola.debug(`Web search returned ${references.length} references`);
-	return {
-		content: response.message.content,
-		references
-	};
+function getToolChoiceName(toolChoice) {
+	if (typeof toolChoice !== "object") return void 0;
+	if ("function" in toolChoice && toolChoice.function && typeof toolChoice.function === "object") return toolChoice.function.name;
+	if ("name" in toolChoice) return toolChoice.name;
 }
 
 //#endregion
@@ -1420,24 +1240,25 @@ async function searchWeb(query) {
 async function handleResponses(c) {
 	await checkRateLimit(state);
 	const payload = await c.req.json();
-	consola.debug("Responses request payload:", JSON.stringify(payload).slice(-400));
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Responses request payload:", JSON.stringify(payload).slice(-400));
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	consola.info("Token counting not yet supported for /responses endpoint");
 	if (state.manualApprove) await awaitApproval();
 	await injectWebSearchIfNeeded(payload);
 	if (isNullish(payload.max_output_tokens)) {
 		payload.max_output_tokens = selectedModel?.capabilities.limits.max_output_tokens;
-		consola.debug("Set max_output_tokens to:", JSON.stringify(payload.max_output_tokens));
+		if (debugEnabled) consola.debug("Set max_output_tokens to:", JSON.stringify(payload.max_output_tokens));
 	}
 	const response = await createResponses(payload);
 	if (isNonStreaming(response)) {
-		consola.debug("Non-streaming response:", JSON.stringify(response));
+		if (debugEnabled) consola.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	}
 	consola.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		for await (const chunk of response) {
-			consola.debug("Streaming chunk:", JSON.stringify(chunk));
+			if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(chunk));
 			if (chunk.data === "[DONE]") break;
 			if (!chunk.data) continue;
 			await stream.writeSSE({
@@ -1514,6 +1335,10 @@ searchRoutes.post("/", async (c) => {
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
 tokenRoute.get("/", (c) => {
+	if (!state.showToken) return c.json({ error: {
+		message: "Token endpoint disabled",
+		type: "error"
+	} }, 403);
 	return c.json({ token: state.copilotToken });
 });
 
@@ -1552,18 +1377,35 @@ server.route("/v1/messages", messageRoutes);
 
 //#endregion
 //#region src/start.ts
+const allowedAccountTypes = new Set([
+	"individual",
+	"business",
+	"enterprise"
+]);
+function filterModelsByEndpoint(models, endpoint) {
+	const filtered = models.filter((model) => {
+		const endpoints = model.supported_endpoints;
+		if (!endpoints || endpoints.length === 0) return true;
+		return endpoints.some((entry) => {
+			return entry.replace(/^\/?v1\//, "").replace(/^\//, "") === endpoint;
+		});
+	});
+	return filtered.length > 0 ? filtered : models;
+}
 async function generateClaudeCodeCommand(serverUrl) {
 	invariant(state.models, "Models should be loaded by now");
+	const supportedModels = filterModelsByEndpoint(state.models.data, "v1/messages");
 	const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
 		type: "select",
-		options: state.models.data.map((model) => model.id)
+		options: supportedModels.map((model) => model.id)
 	});
 	const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
 		type: "select",
-		options: state.models.data.map((model) => model.id)
+		options: supportedModels.map((model) => model.id)
 	});
 	const command = generateEnvScript({
 		ANTHROPIC_BASE_URL: serverUrl,
+		ANTHROPIC_API_KEY: "dummy",
 		ANTHROPIC_AUTH_TOKEN: "dummy",
 		ANTHROPIC_MODEL: selectedModel,
 		ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
@@ -1582,15 +1424,17 @@ async function generateClaudeCodeCommand(serverUrl) {
 }
 async function generateCodexCommand(serverUrl) {
 	invariant(state.models, "Models should be loaded by now");
-	const defaultCodexModel = state.models.data.find((model) => model.id === "gpt5.2-codex");
+	const supportedModels = filterModelsByEndpoint(state.models.data, "responses");
+	const defaultCodexModel = supportedModels.find((model) => model.id === "gpt5.2-codex");
 	const selectedModel = defaultCodexModel ? defaultCodexModel.id : await consola.prompt("Select a model to use with Codex CLI", {
 		type: "select",
-		options: state.models.data.map((model) => model.id)
+		options: supportedModels.map((model) => model.id)
 	});
+	const quotedModel = JSON.stringify(selectedModel);
 	const command = generateEnvScript({
 		OPENAI_BASE_URL: `${serverUrl}/v1`,
 		OPENAI_API_KEY: "dummy"
-	}, `codex -m ${selectedModel}`);
+	}, `codex -m ${quotedModel}`);
 	try {
 		clipboard.writeSync(command);
 		consola.success("Copied Codex CLI command to clipboard!");
@@ -1626,6 +1470,7 @@ async function runServer(options) {
 	consola.box(`🌐 Usage Viewer: https://animeshkundu.github.io/github-router/dashboard.html?endpoint=${serverUrl}/usage`);
 	serve({
 		fetch: server.fetch,
+		hostname: "127.0.0.1",
 		port: options.port
 	});
 }
@@ -1698,15 +1543,26 @@ const start = defineCommand({
 	},
 	run({ args }) {
 		const rateLimitRaw = args["rate-limit"];
-		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		let rateLimit;
+		if (rateLimitRaw !== void 0) {
+			rateLimit = Number.parseInt(rateLimitRaw, 10);
+			if (Number.isNaN(rateLimit) || rateLimit <= 0) throw new Error("Invalid rate limit. Must be a positive integer.");
+		}
+		const port = Number.parseInt(args.port, 10);
+		if (Number.isNaN(port) || port <= 0 || port > 65535) throw new Error("Invalid port. Must be between 1 and 65535.");
+		const accountType = args["account-type"];
+		if (!allowedAccountTypes.has(accountType)) throw new Error("Invalid account type. Must be individual, business, or enterprise.");
+		const rateLimitWait = args.wait && rateLimit !== void 0;
+		if (args.wait && rateLimit === void 0) consola.warn("Rate limit wait ignored because no rate limit was set.");
+		const githubToken = args["github-token"] ?? process.env.GH_TOKEN;
 		return runServer({
-			port: Number.parseInt(args.port, 10),
+			port,
 			verbose: args.verbose,
-			accountType: args["account-type"],
+			accountType,
 			manual: args.manual,
 			rateLimit,
-			rateLimitWait: args.wait,
-			githubToken: args["github-token"],
+			rateLimitWait,
+			githubToken,
 			claudeCode: args["claude-code"],
 			codex: args.codex,
 			showToken: args["show-token"],