github-router 0.3.10 → 0.3.12

package/dist/main.js

@@ -6,6 +6,7 @@ import os from "node:os";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import process$1 from "node:process";
+import { execFileSync, spawn } from "node:child_process";
 import { serve } from "srvx";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
@@ -76,7 +77,7 @@ const copilotHeaders = (state$1, vision = false, integrationId = "vscode-chat")
 	if (vision) headers["copilot-vision-request"] = "true";
 	return headers;
 };
-const GITHUB_API_BASE_URL = "https://api.github.com";
+const GITHUB_API_BASE_URL = process.env.GITHUB_API_URL ?? "https://api.github.com";
 const githubHeaders = (state$1) => ({
 	...standardHeaders(),
 	authorization: `token ${state$1.githubToken}`,
@@ -222,19 +223,68 @@ function filterBetaHeader(value) {
 	return value.split(",").map((v) => v.trim()).filter((v) => v && ALLOWED_BETA_PREFIXES.some((prefix) => v.startsWith(prefix))).join(",") || void 0;
 }
 /**
+* Normalize a model ID for fuzzy comparison: lowercase, replace dots with
+* dashes, insert dash at letter→digit boundaries, and collapse repeated
+* dashes. E.g. "gpt5.3-codex" → "gpt-5-3-codex", "GPT-5.3-Codex" → "gpt-5-3-codex".
+*/
+function normalizeModelId(id) {
+	return id.toLowerCase().replace(/\./g, "-").replace(/([a-z])(\d)/g, "$1-$2").replace(/-{2,}/g, "-");
+}
+/**
 * Resolve a model name to the best available variant in the Copilot model list.
-* Prefers the 1M context variant for opus models.
+*
+* Resolution cascade:
+* 1. Exact match
+* 2. Case-insensitive match
+* 3. Family preference (opus→1m, codex→highest version)
+* 4. Normalized match (dots→dashes, letter-digit boundaries)
+* 5. Return as-is with a warning
 */
 function resolveModel(modelId) {
 	const models = state.models?.data;
 	if (!models) return modelId;
 	if (models.some((m) => m.id === modelId)) return modelId;
-	if (modelId.toLowerCase().includes("opus")) {
+	const lower = modelId.toLowerCase();
+	const ciMatch = models.find((m) => m.id.toLowerCase() === lower);
+	if (ciMatch) return ciMatch.id;
+	if (lower.includes("opus")) {
 		const oneM = models.find((m) => m.id.includes("opus") && m.id.endsWith("-1m"));
 		if (oneM) return oneM.id;
 	}
+	if (lower.includes("codex")) {
+		const codexModels = models.filter((m) => m.id.includes("codex") && !m.id.includes("mini"));
+		if (codexModels.length > 0) {
+			codexModels.sort((a, b) => b.id.localeCompare(a.id));
+			return codexModels[0].id;
+		}
+	}
+	const normalized = normalizeModelId(modelId);
+	const normMatch = models.find((m) => normalizeModelId(m.id) === normalized);
+	if (normMatch) return normMatch.id;
+	consola.warn(`Model "${modelId}" not found in Copilot model list. Available: ${models.map((m) => m.id).join(", ")}`);
 	return modelId;
 }
+/**
+* Resolve a codex model ID, falling back to the best available codex model.
+* Used by the codex subcommand for model selection.
+*/
+function resolveCodexModel(modelId) {
+	const resolved = resolveModel(modelId);
+	const models = state.models?.data;
+	if (!models) return resolved;
+	if (models.some((m) => m.id === resolved)) return resolved;
+	const codexModels = models.filter((m) => {
+		const endpoints = m.supported_endpoints ?? [];
+		return m.id.includes("codex") && !m.id.includes("mini") && (endpoints.length === 0 || endpoints.includes("/responses"));
+	});
+	if (codexModels.length > 0) {
+		codexModels.sort((a, b) => b.id.localeCompare(a.id));
+		const best = codexModels[0].id;
+		consola.warn(`Model "${modelId}" not available, using "${best}" instead`);
+		return best;
+	}
+	return resolved;
+}
 async function cacheModels() {
 	state.models = await getModels();
 }
@@ -415,7 +465,7 @@ const checkUsage = defineCommand({
 //#endregion
 //#region src/lib/port.ts
 const DEFAULT_PORT = 8787;
-const DEFAULT_CODEX_MODEL = "gpt5.3-codex";
+const DEFAULT_CODEX_MODEL = "gpt-5.3-codex";
 const PORT_RANGE_MIN = 11e3;
 const PORT_RANGE_MAX = 65535;
 /** Generate a random port number in the range [11000, 65535]. */
@@ -425,6 +475,14 @@ function generateRandomPort() {
 
 //#endregion
 //#region src/lib/launch.ts
+function commandExists(name) {
+	try {
+		execFileSync(process$1.platform === "win32" ? "where.exe" : "which", [name], { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
 function buildLaunchCommand(target) {
 	return {
 		cmd: target.kind === "claude-code" ? [
@@ -433,6 +491,7 @@ function buildLaunchCommand(target) {
 			...target.extraArgs
 		] : [
 			"codex",
+			"--full-auto",
 			"-m",
 			target.model ?? DEFAULT_CODEX_MODEL,
 			...target.extraArgs
@@ -446,18 +505,20 @@ function buildLaunchCommand(target) {
 function launchChild(target, server$1) {
 	const { cmd, env } = buildLaunchCommand(target);
 	const executable = cmd[0];
-	if (!Bun.which(executable)) {
+	if (!commandExists(executable)) {
 		consola.error(`"${executable}" not found on PATH. Install it first, then try again.`);
 		process$1.exit(1);
 	}
 	let child;
 	try {
-		child = Bun.spawn({
-			cmd,
+		if (process$1.platform === "win32") child = spawn(cmd.map((a) => a.includes(" ") ? `"${a}"` : a).join(" "), [], {
+			env,
+			stdio: "inherit",
+			shell: true
+		});
+		else child = spawn(cmd[0], cmd.slice(1), {
 			env,
-			stdin: "inherit",
-			stdout: "inherit",
-			stderr: "inherit"
+			stdio: "inherit"
 		});
 	} catch (error) {
 		consola.error(`Failed to launch ${executable}:`, error instanceof Error ? error.message : String(error));
@@ -488,10 +549,58 @@ function launchChild(target, server$1) {
 	};
 	process$1.on("SIGINT", onSignal);
 	process$1.on("SIGTERM", onSignal);
-	child.exited.then(async (exitCode) => {
-		await cleanup();
-		exit(exitCode ?? 0);
-	}).catch(() => exit(1));
+	child.on("exit", (exitCode) => {
+		cleanup().then(() => exit(exitCode ?? 0)).catch(() => exit(1));
+	});
+	child.on("error", () => exit(1));
+}
+
+//#endregion
+//#region src/lib/model-validation.ts
+const ENDPOINT_ALIASES = {
+	"/chat/completions": "/chat/completions",
+	"/v1/chat/completions": "/chat/completions",
+	"/responses": "/responses",
+	"/v1/responses": "/responses",
+	"/v1/messages": "/v1/messages"
+};
+/**
+* Check whether a model supports the given endpoint, based on cached
+* `supported_endpoints` metadata from the Copilot `/models` response.
+*
+* Returns `true` (allow) when:
+* - the model is not found in the cache (don't block unknown models)
+* - the model has no `supported_endpoints` field (backward-compat)
+* - the endpoint is listed in `supported_endpoints`
+*/
+function modelSupportsEndpoint(modelId, path$1) {
+	const endpoint = ENDPOINT_ALIASES[path$1] ?? path$1;
+	const model = state.models?.data.find((m) => m.id === modelId);
+	if (!model) return true;
+	const supported = model.supported_endpoints;
+	if (!supported || supported.length === 0) return true;
+	return supported.includes(endpoint);
+}
+/**
+* Log an error when a model is used on an endpoint it doesn't support.
+* Returns `true` if a mismatch was detected (for testing).
+*/
+function logEndpointMismatch(modelId, path$1) {
+	if (modelSupportsEndpoint(modelId, path$1)) return false;
+	const supported = (state.models?.data.find((m) => m.id === modelId))?.supported_endpoints ?? [];
+	consola.error(`Model "${modelId}" does not support ${path$1}. Supported endpoints: ${supported.join(", ")}`);
+	return true;
+}
+/**
+* Return model IDs that support the given endpoint.
+*/
+function listModelsForEndpoint(path$1) {
+	const endpoint = ENDPOINT_ALIASES[path$1] ?? path$1;
+	return (state.models?.data ?? []).filter((m) => {
+		const supported = m.supported_endpoints;
+		if (!supported || supported.length === 0) return true;
+		return supported.includes(endpoint);
+	}).map((m) => m.id);
 }
 
 //#endregion
@@ -588,7 +697,7 @@ function formatTokens(n) {
 function formatTokenInfo(inputTokens, outputTokens, model) {
 	if (inputTokens === void 0) return void 0;
 	const parts = [];
-	const maxPrompt = model?.capabilities.limits.max_prompt_tokens;
+	const maxPrompt = model?.capabilities?.limits?.max_prompt_tokens;
 	if (maxPrompt) {
 		const pct = (inputTokens / maxPrompt * 100).toFixed(1);
 		parts.push(`in:${formatTokens(inputTokens)}/${formatTokens(maxPrompt)} (${pct}%)`);
@@ -708,7 +817,7 @@ const getEncodeChatFunction = async (encoding) => {
 * Get tokenizer type from model information
 */
 const getTokenizerFromModel = (model) => {
-	return model.capabilities.tokenizer || "o200k_base";
+	return model.capabilities?.tokenizer || "o200k_base";
 };
 /**
 * Get model-specific constants for token calculation
@@ -942,6 +1051,7 @@ async function handleCompletion$1(c) {
 	const resolvedModel = resolveModel(payload.model);
 	if (resolvedModel !== payload.model) payload.model = resolvedModel;
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	logEndpointMismatch(payload.model, "/chat/completions");
 	let inputTokens;
 	try {
 		if (selectedModel) inputTokens = (await getTokenCount(payload, selectedModel)).input;
@@ -949,7 +1059,7 @@ async function handleCompletion$1(c) {
 	if (isNullish(payload.max_tokens)) {
 		payload = {
 			...payload,
-			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
+			max_tokens: selectedModel?.capabilities?.limits?.max_output_tokens
 		};
 		if (debugEnabled) consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
@@ -1360,7 +1470,9 @@ async function handleCompletion(c) {
 	if (state.manualApprove) await awaitApproval();
 	const betaHeaders = extractBetaHeaders(c);
 	const { body: resolvedBody, originalModel, resolvedModel } = resolveModelInBody(await processWebSearch(rawBody));
-	const selectedModel = state.models?.data.find((m) => m.id === (resolvedModel ?? originalModel));
+	const modelId = resolvedModel ?? originalModel;
+	const selectedModel = state.models?.data.find((m) => m.id === modelId);
+	if (modelId) logEndpointMismatch(modelId, "/v1/messages");
 	const effectiveBetas = applyDefaultBetas(betaHeaders, resolvedModel ?? originalModel);
 	let response;
 	try {
@@ -1484,11 +1596,17 @@ modelRoutes.get("/", async (c) => {
 		const models = state.models?.data.map((model) => ({
 			id: model.id,
 			object: "model",
-			type: "model",
+			type: model.capabilities?.type ?? "model",
 			created: 0,
 			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
 			owned_by: model.vendor,
-			display_name: model.name
+			display_name: model.name,
+			capabilities: model.capabilities,
+			supported_endpoints: model.supported_endpoints,
+			preview: model.preview,
+			version: model.version,
+			model_picker_enabled: model.model_picker_enabled,
+			policy: model.policy
 		}));
 		return c.json({
 			object: "list",
@@ -1579,12 +1697,9 @@ async function handleResponses(c) {
 	const resolvedModel = resolveModel(payload.model);
 	if (resolvedModel !== payload.model) payload.model = resolvedModel;
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	logEndpointMismatch(payload.model, "/responses");
 	if (state.manualApprove) await awaitApproval();
 	await injectWebSearchIfNeeded(payload);
-	if (isNullish(payload.max_output_tokens)) {
-		payload.max_output_tokens = selectedModel?.capabilities.limits.max_output_tokens;
-		if (debugEnabled) consola.debug("Set max_output_tokens to:", JSON.stringify(payload.max_output_tokens));
-	}
 	const response = await createResponses(payload, selectedModel?.requestHeaders).catch(async (error) => {
 		if (error instanceof HTTPError) {
 			const errorBody = await error.response.clone().text().catch(() => "");
@@ -1661,6 +1776,32 @@ function extractUserQuery(input) {
 		}
 	}
 }
+async function handleResponsesCompact(c) {
+	const startTime = Date.now();
+	await checkRateLimit(state);
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	if (state.manualApprove) await awaitApproval();
+	const body = await c.req.text();
+	const response = await fetch(`${copilotBaseUrl(state)}/responses/compact`, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body
+	});
+	if (!response.ok) {
+		logRequest({
+			method: "POST",
+			path: c.req.path,
+			status: response.status
+		}, void 0, startTime);
+		throw new HTTPError("Copilot responses/compact request failed", response);
+	}
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		status: 200
+	}, void 0, startTime);
+	return c.json(await response.json());
+}
 
 //#endregion
 //#region src/routes/responses/route.ts
@@ -1672,6 +1813,13 @@ responsesRoutes.post("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
+responsesRoutes.post("/compact", async (c) => {
+	try {
+		return await handleResponsesCompact(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
 
 //#endregion
 //#region src/routes/search/route.ts
@@ -1745,6 +1893,7 @@ async function setupAndServe(options) {
 	state.rateLimitSeconds = options.rateLimit;
 	state.rateLimitWait = options.rateLimitWait;
 	state.showToken = options.showToken;
+	if (process.env.COPILOT_API_URL) state.copilotApiUrl = process.env.COPILOT_API_URL;
 	await ensurePaths();
 	await cacheVSCodeVersion();
 	if (options.githubToken) {
@@ -1753,7 +1902,7 @@ async function setupAndServe(options) {
 	} else await setupGitHubToken();
 	await setupCopilotToken();
 	await cacheModels();
-	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	consola.debug(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serveOptions = {
 		fetch: server.fetch,
 		hostname: "127.0.0.1",
@@ -1932,13 +2081,22 @@ const claude = defineCommand({
 			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
 			process$1.exit(1);
 		}
+		let resolvedModel;
+		if (args.model) {
+			resolvedModel = resolveModel(args.model);
+			if (resolvedModel !== args.model) consola.info(`Model "${args.model}" resolved to "${resolvedModel}"`);
+			if (!state.models?.data.find((m) => m.id === resolvedModel)) {
+				const available = listModelsForEndpoint("/v1/messages");
+				consola.warn(`Model "${resolvedModel}" not found. Available claude models: ${available.join(", ")}`);
+			}
+		}
 		consola.success(`Server ready on ${serverUrl}, launching Claude Code...`);
 		consola.level = 1;
 		launchChild({
 			kind: "claude-code",
-			envVars: getClaudeCodeEnvVars(serverUrl, args.model),
+			envVars: getClaudeCodeEnvVars(serverUrl, resolvedModel ?? args.model),
 			extraArgs: args._ ?? [],
-			model: args.model
+			model: resolvedModel ?? args.model
 		}, server$1);
 	}
 });
@@ -1978,14 +2136,24 @@ const codex = defineCommand({
 			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
 			process$1.exit(1);
 		}
-		const codexModel = args.model ?? DEFAULT_CODEX_MODEL;
+		const requestedModel = args.model ?? DEFAULT_CODEX_MODEL;
+		const codexModel = resolveCodexModel(requestedModel);
+		if (codexModel !== requestedModel) consola.info(`Model "${requestedModel}" resolved to "${codexModel}"`);
+		const modelEntry = state.models?.data.find((m) => m.id === codexModel);
+		if (!modelEntry) {
+			const available = listModelsForEndpoint("/responses");
+			consola.warn(`Model "${codexModel}" not found. Available codex models: ${available.join(", ")}`);
+		} else {
+			const ctx = modelEntry.capabilities?.limits?.max_context_window_tokens;
+			if (ctx) consola.info(`Model context window: ${ctx.toLocaleString()} tokens`);
+		}
 		consola.success(`Server ready on ${serverUrl}, launching Codex CLI (${codexModel})...`);
 		consola.level = 1;
 		launchChild({
 			kind: "codex",
 			envVars: getCodexEnvVars(serverUrl),
 			extraArgs: args._ ?? [],
-			model: args.model
+			model: codexModel
 		}, server$1);
 	}
 });