@ashsec/copilot-api 0.8.0 → 0.9.0

package/dist/main.js

@@ -5,7 +5,6 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { events } from "fetch-event-stream";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
@@ -17,28 +16,102 @@ import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
 import util from "node:util";
 
 //#region package.json
-var version = "0.8.0";
+var name = "@ashsec/copilot-api";
+var version = "0.9.0";
+var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
+var keywords = [
+	"proxy",
+	"github-copilot",
+	"openai-compatible"
+];
+var homepage = "https://github.com/ericc-ch/copilot-api";
+var bugs = "https://github.com/ericc-ch/copilot-api/issues";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/ericc-ch/copilot-api.git"
+};
+var author = "Erick Christian <erickchristian48@gmail.com>";
+var type = "module";
+var bin = { "copilot-api": "./dist/main.js" };
+var files = ["dist"];
+var scripts = {
+	"build": "tsdown",
+	"dev": "bun run --watch ./src/main.ts",
+	"knip": "knip-bun",
+	"lint": "eslint --cache",
+	"lint:all": "eslint --cache .",
+	"prepack": "bun run build",
+	"prepare": "simple-git-hooks",
+	"release": "bumpp && bun publish --access public",
+	"start": "NODE_ENV=production bun run ./src/main.ts",
+	"typecheck": "tsc"
+};
+var simple_git_hooks = { "pre-commit": "bunx lint-staged" };
+var lint_staged = { "*": "bun run lint --fix" };
+var dependencies = {
+	"citty": "^0.1.6",
+	"clipboardy": "^5.0.0",
+	"consola": "^3.4.2",
+	"fetch-event-stream": "^0.1.5",
+	"gpt-tokenizer": "^3.0.1",
+	"hono": "^4.9.9",
+	"ms": "^2.1.3",
+	"proxy-from-env": "^1.1.0",
+	"srvx": "^0.8.9",
+	"tiny-invariant": "^1.3.3",
+	"undici": "^7.16.0",
+	"zod": "^4.1.11"
+};
+var devDependencies = {
+	"@echristian/eslint-config": "^0.0.54",
+	"@types/bun": "^1.2.23",
+	"@types/proxy-from-env": "^1.0.4",
+	"bumpp": "^10.2.3",
+	"eslint": "^9.37.0",
+	"knip": "^5.64.1",
+	"lint-staged": "^16.2.3",
+	"prettier-plugin-packagejson": "^2.5.19",
+	"simple-git-hooks": "^2.13.1",
+	"tsdown": "^0.15.6",
+	"typescript": "^5.9.3"
+};
+var package_default = {
+	name,
+	version,
+	description,
+	keywords,
+	homepage,
+	bugs,
+	repository,
+	author,
+	type,
+	bin,
+	files,
+	scripts,
+	"simple-git-hooks": simple_git_hooks,
+	"lint-staged": lint_staged,
+	dependencies,
+	devDependencies
+};
 
 //#endregion
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
-const AZURE_OPENAI_CONFIG_PATH = path.join(APP_DIR, "azure_openai_config");
 const REPLACEMENTS_CONFIG_PATH = path.join(APP_DIR, "replacements.json");
 const PATHS = {
 	APP_DIR,
 	CONFIG_PATH: path.join(APP_DIR, "config.json"),
 	GITHUB_TOKEN_PATH,
-	AZURE_OPENAI_CONFIG_PATH,
 	REPLACEMENTS_CONFIG_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-	await ensureFile(PATHS.AZURE_OPENAI_CONFIG_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -180,56 +253,6 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
-//#endregion
-//#region src/services/azure-openai/config.ts
-const AZURE_OPENAI_MODEL_PREFIX = "azure_openai_";
-async function loadAzureOpenAIConfig() {
-	try {
-		const content = await fs.readFile(PATHS.AZURE_OPENAI_CONFIG_PATH, "utf8");
-		if (!content.trim()) return null;
-		const decoded = Buffer.from(content.trim(), "base64").toString("utf8");
-		const config$1 = JSON.parse(decoded);
-		if (!config$1.endpoint || !config$1.apiKey) return null;
-		return config$1;
-	} catch {
-		return null;
-	}
-}
-async function saveAzureOpenAIConfig(config$1) {
-	const encoded = Buffer.from(JSON.stringify(config$1)).toString("base64");
-	await fs.writeFile(PATHS.AZURE_OPENAI_CONFIG_PATH, encoded, "utf8");
-	await fs.chmod(PATHS.AZURE_OPENAI_CONFIG_PATH, 384);
-	consola.success("Azure OpenAI configuration saved");
-}
-async function promptAzureOpenAISetup() {
-	if (!await consola.prompt("Would you like to add a custom Azure OpenAI endpoint?", {
-		type: "confirm",
-		initial: false
-	})) return null;
-	const endpoint = await consola.prompt("Enter your Azure OpenAI endpoint URL (e.g., https://your-resource.openai.azure.com):", { type: "text" });
-	if (!endpoint || typeof endpoint !== "string" || !endpoint.trim()) {
-		consola.warn("No endpoint provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const apiKey = await consola.prompt("Enter your Azure OpenAI API key:", { type: "text" });
-	if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
-		consola.warn("No API key provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const config$1 = {
-		endpoint: endpoint.trim().replace(/\/$/, ""),
-		apiKey: apiKey.trim()
-	};
-	await saveAzureOpenAIConfig(config$1);
-	return config$1;
-}
-function isAzureOpenAIModel(modelId) {
-	return modelId.startsWith(AZURE_OPENAI_MODEL_PREFIX);
-}
-function getAzureDeploymentName(modelId) {
-	return modelId.slice(13);
-}
-
 //#endregion
 //#region src/lib/retry-fetch.ts
 const RETRY_DELAYS_MS = [
@@ -299,62 +322,6 @@ async function fetchWithRetry(input, init) {
 	throw lastError;
 }
 
-//#endregion
-//#region src/services/azure-openai/create-chat-completions.ts
-const AZURE_API_VERSION = "2024-10-21";
-async function createAzureOpenAIChatCompletions(config$1, payload) {
-	const deploymentName = getAzureDeploymentName(payload.model);
-	const { max_tokens,...restPayload } = payload;
-	const azurePayload = {
-		...restPayload,
-		model: deploymentName,
-		...max_tokens != null && { max_completion_tokens: max_tokens }
-	};
-	const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
-		method: "POST",
-		headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify(azurePayload)
-	});
-	if (!response.ok) {
-		consola.error("Failed to create Azure OpenAI chat completions:", response);
-		throw new HTTPError("Failed to create Azure OpenAI chat completions", response, payload);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-}
-
-//#endregion
-//#region src/services/azure-openai/get-models.ts
-const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
-async function getAzureOpenAIDeployments(config$1) {
-	try {
-		const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		} });
-		if (!response.ok) {
-			const errorText = await response.text().catch(() => "");
-			consola.error(`Failed to fetch Azure OpenAI deployments: ${response.status}`, errorText);
-			throw new HTTPError("Failed to fetch Azure OpenAI deployments", response);
-		}
-		return (await response.json()).data.filter((deployment) => deployment.status === "succeeded").map((deployment) => ({
-			id: `${AZURE_OPENAI_MODEL_PREFIX}${deployment.id}`,
-			deploymentName: deployment.id,
-			model: deployment.model,
-			created: deployment.created_at,
-			object: "deployment",
-			owned_by: deployment.owner || "azure-openai"
-		}));
-	} catch (error) {
-		if (error instanceof HTTPError) throw error;
-		consola.error("Failed to fetch Azure OpenAI deployments:", error);
-		return [];
-	}
-}
-
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
@@ -418,24 +385,6 @@ const cacheVSCodeVersion = async () => {
 	state.vsCodeVersion = response;
 	consola.info(`Using VSCode version: ${response}`);
 };
-async function setupAzureOpenAI() {
-	let config$1 = await loadAzureOpenAIConfig();
-	if (!config$1) config$1 = await promptAzureOpenAISetup();
-	if (!config$1) {
-		consola.info("Azure OpenAI not configured");
-		return;
-	}
-	state.azureOpenAIConfig = config$1;
-	consola.info("Azure OpenAI configuration loaded");
-	try {
-		const deployments = await getAzureOpenAIDeployments(config$1);
-		state.azureOpenAIDeployments = deployments;
-		if (deployments.length > 0) consola.info(`Loaded ${deployments.length} Azure OpenAI deployment(s):\n${deployments.map((d) => `- ${d.id} (${d.model})`).join("\n")}`);
-		else consola.warn("No Azure OpenAI deployments found");
-	} catch (error) {
-		consola.warn("Failed to fetch Azure OpenAI deployments:", error);
-	}
-}
 
 //#endregion
 //#region src/services/github/poll-access-token.ts
@@ -583,13 +532,13 @@ const checkUsage = defineCommand({
 			const premiumUsed = premiumTotal - premium.remaining;
 			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
 			const premiumPercentRemaining = premium.percent_remaining;
-			function summarizeQuota(name, snap) {
-				if (!snap) return `${name}: N/A`;
+			function summarizeQuota(name$1, snap) {
+				if (!snap) return `${name$1}: N/A`;
 				const total = snap.entitlement;
 				const used = total - snap.remaining;
 				const percentUsed = total > 0 ? used / total * 100 : 0;
 				const percentRemaining = snap.percent_remaining;
-				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
+				return `${name$1}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
 			}
 			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
 			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
@@ -665,11 +614,11 @@ async function getUserReplacements() {
 * Add a new user replacement rule
 */
 async function addReplacement(pattern, replacement, options) {
-	const { isRegex = false, name } = options ?? {};
+	const { isRegex = false, name: name$1 } = options ?? {};
 	await ensureLoaded();
 	const rule = {
 		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-		name,
+		name: name$1,
 		pattern,
 		replacement,
 		isRegex,
@@ -820,11 +769,11 @@ async function applyReplacementsToPayload(payload) {
 //#region src/config.ts
 function formatRule(rule, index) {
 	const status = rule.enabled ? "✓" : "✗";
-	const type = rule.isRegex ? "regex" : "string";
+	const type$1 = rule.isRegex ? "regex" : "string";
 	const system = rule.isSystem ? " [system]" : "";
-	const name = rule.name ? ` "${rule.name}"` : "";
+	const name$1 = rule.name ? ` "${rule.name}"` : "";
 	const replacement = rule.replacement || "(empty)";
-	return `${index + 1}. [${status}] (${type})${system}${name} "${rule.pattern}" → "${replacement}"`;
+	return `${index + 1}. [${status}] (${type$1})${system}${name$1} "${rule.pattern}" → "${replacement}"`;
 }
 async function listReplacements() {
 	const all = await getAllReplacements();
@@ -837,11 +786,11 @@ async function listReplacements() {
 	console.log();
 }
 async function addNewReplacement() {
-	const name = await consola.prompt("Name (optional, short description):", {
+	const name$1 = await consola.prompt("Name (optional, short description):", {
 		type: "text",
 		default: ""
 	});
-	if (typeof name === "symbol") {
+	if (typeof name$1 === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -878,7 +827,7 @@ async function addNewReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	const rule = await addReplacement(pattern, replacement, matchType === "regex", name || void 0);
+	const rule = await addReplacement(pattern, replacement, matchType === "regex", name$1 || void 0);
 	consola.success(`Added rule: ${rule.name || rule.id}`);
 }
 async function editExistingReplacement() {
@@ -906,11 +855,11 @@ async function editExistingReplacement() {
 	}
 	consola.info(`\nEditing rule: ${rule.name || rule.id}`);
 	consola.info("Press Enter to keep current value.\n");
-	const name = await consola.prompt("Name:", {
+	const name$1 = await consola.prompt("Name:", {
 		type: "text",
 		default: rule.name || ""
 	});
-	if (typeof name === "symbol") {
+	if (typeof name$1 === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -952,7 +901,7 @@ async function editExistingReplacement() {
 		return;
 	}
 	const updated = await updateReplacement(selected, {
-		name: name || void 0,
+		name: name$1 || void 0,
 		pattern,
 		replacement,
 		isRegex: matchType === "regex"
@@ -1269,7 +1218,8 @@ function mergeDefaultExtraPrompts(config$1) {
 	};
 }
 function mergeConfigWithDefaults() {
-	const { mergedConfig, changed } = mergeDefaultExtraPrompts(readConfigFromDisk());
+	const config$1 = readConfigFromDisk();
+	const { mergedConfig, changed } = mergeDefaultExtraPrompts(config$1);
 	if (changed) try {
 		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
 	} catch (writeError) {
@@ -1347,7 +1297,8 @@ function getShell() {
 	const { platform, ppid, env } = process$1;
 	if (platform === "win32") {
 		try {
-			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
+			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -1405,7 +1356,8 @@ function normalizeApiKeys(apiKeys) {
 	return [...new Set(normalizedKeys)];
 }
 function getConfiguredApiKeys() {
-	return normalizeApiKeys(getConfig().auth?.apiKeys);
+	const config$1 = getConfig();
+	return normalizeApiKeys(config$1.auth?.apiKeys);
 }
 function extractRequestApiKey(c) {
 	const xApiKey = c.req.header("x-api-key")?.trim();
@@ -1498,7 +1450,8 @@ async function logRawRequest(c) {
 	if (method !== "GET" && method !== "HEAD") try {
 		const body = await c.req.raw.clone().text();
 		if (body) try {
-			const sanitized = sanitizeRequestBody(JSON.parse(body));
+			const parsed = JSON.parse(body);
+			const sanitized = sanitizeRequestBody(parsed);
 			lines.push(`${colors.dim}Body (sanitized):${colors.reset}`, `  ${JSON.stringify(sanitized, null, 2).split("\n").join("\n  ")}`);
 		} catch {
 			lines.push(`${colors.dim}Body:${colors.reset} [${body.length} bytes]`);
@@ -1539,7 +1492,7 @@ async function requestLogger(c, next) {
 	const durationStr = `${colors.cyan}${duration}s${colors.reset}`;
 	lines.push(`${colors.bold}${method}${colors.reset} ${path$1} ${statusBadge} ${durationStr}`);
 	if (ctx?.provider && ctx.model) {
-		const providerColor = ctx.provider === "Azure OpenAI" ? colors.blue : colors.magenta;
+		const providerColor = colors.magenta;
 		lines.push(`  ${colors.gray}Provider:${colors.reset} ${providerColor}${ctx.provider}${colors.reset} ${colors.gray}->${colors.reset} ${colors.white}${ctx.model}${colors.reset}`);
 	}
 	if (ctx?.inputTokens !== void 0 || ctx?.outputTokens !== void 0) {
@@ -1778,7 +1731,8 @@ const numTokensForTools = (tools, encoder, constants) => {
 * Calculate the token count of messages, supporting multiple GPT encoders
 */
 const getTokenCount = async (payload, model) => {
-	const encoder = await getEncodeChatFunction(getTokenizerFromModel(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");
@@ -1823,50 +1777,23 @@ const createChatCompletions = async (payload, options) => {
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
-	let payload = await applyReplacementsToPayload(await c.req.json());
+	const rawPayload = await c.req.json();
+	let payload = await applyReplacementsToPayload(rawPayload);
 	payload = {
 		...payload,
 		model: normalizeModelName(payload.model)
 	};
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
-	if (isAzureOpenAIModel(payload.model)) {
-		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		setRequestContext(c, {
-			provider: "Azure OpenAI",
-			model: payload.model
-		});
-		if (state.manualApprove) await awaitApproval();
-		const response$1 = await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, payload);
-		if (isNonStreaming$1(response$1)) {
-			consola.debug("Non-streaming response:", JSON.stringify(response$1));
-			if (response$1.usage) setRequestContext(c, {
-				inputTokens: response$1.usage.prompt_tokens,
-				outputTokens: response$1.usage.completion_tokens
-			});
-			return c.json(response$1);
-		}
-		consola.debug("Streaming response");
-		return streamSSE(c, async (stream) => {
-			for await (const chunk of response$1) {
-				consola.debug("Streaming chunk:", JSON.stringify(chunk));
-				if (chunk.data && chunk.data !== "[DONE]") {
-					const parsed = JSON.parse(chunk.data);
-					if (parsed.usage) setRequestContext(c, {
-						inputTokens: parsed.usage.prompt_tokens,
-						outputTokens: parsed.usage.completion_tokens
-					});
-				}
-				await stream.writeSSE(chunk);
-			}
-		});
-	}
 	setRequestContext(c, {
 		provider: "Copilot",
 		model: payload.model
 	});
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
-		if (selectedModel) setRequestContext(c, { inputTokens: (await getTokenCount(payload, selectedModel)).input });
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(payload, selectedModel);
+			setRequestContext(c, { inputTokens: tokenCount.input });
+		}
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -1933,7 +1860,8 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const response = await createEmbeddings(await c.req.json());
+		const paylod = await c.req.json();
+		const response = await createEmbeddings(paylod);
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -2219,8 +2147,8 @@ const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : u
 	depth: null,
 	colors: false
 })).join(" ");
-const sanitizeName = (name) => {
-	const normalized = name.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
+const sanitizeName = (name$1) => {
+	const normalized = name$1.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
 	return normalized === "" ? "handler" : normalized;
 };
 const getLogStream = (filePath) => {
@@ -2274,10 +2202,10 @@ process.on("SIGTERM", () => {
 	process.exit(0);
 });
 let lastCleanup = 0;
-const createHandlerLogger = (name) => {
+const createHandlerLogger = (name$1) => {
 	ensureLogDirectory();
-	const sanitizedName = sanitizeName(name);
-	const instance = consola.withTag(name);
+	const sanitizedName = sanitizeName(name$1);
+	const instance = consola.withTag(name$1);
 	if (state.verbose) instance.level = 5;
 	instance.setReporters([]);
 	instance.addReporter({ log(logObj) {
@@ -2291,7 +2219,8 @@ const createHandlerLogger = (name) => {
 		const timestamp = date.toLocaleString("sv-SE", { hour12: false });
 		const filePath = path.join(LOG_DIR, `${sanitizedName}-${dateKey}.log`);
 		const message = formatArgs(logObj.args);
-		appendLine(filePath, `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${message ? ` ${message}` : ""}`);
+		const line = `[${timestamp}] [${logObj.type}] [${logObj.tag || name$1}]${message ? ` ${message}` : ""}`;
+		appendLine(filePath, line);
 	} });
 	return instance;
 };
@@ -2646,8 +2575,9 @@ const mapResponsesStopReason = (response) => {
 const mapResponsesUsage = (response) => {
 	const inputTokens = response.usage?.input_tokens ?? 0;
 	const outputTokens = response.usage?.output_tokens ?? 0;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
 	return {
-		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 0),
+		input_tokens: inputTokens - (inputCachedTokens ?? 0),
 		output_tokens: outputTokens,
 		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
 	};
@@ -2663,9 +2593,10 @@ const parseUserId = (userId) => {
 	const userMatch = userId.match(/user_([^_]+)_account/);
 	const safetyIdentifier = userMatch ? userMatch[1] : null;
 	const sessionMatch = userId.match(/_session_(.+)$/);
+	const promptCacheKey = sessionMatch ? sessionMatch[1] : null;
 	return {
 		safetyIdentifier,
-		promptCacheKey: sessionMatch ? sessionMatch[1] : null
+		promptCacheKey
 	};
 };
 const convertToolResultContent = (content) => {
@@ -2747,11 +2678,11 @@ const handleOutputItemAdded$1 = (rawEvent, state$1) => {
 	const events$1 = new Array();
 	const functionCallDetails = extractFunctionCallDetails(rawEvent);
 	if (!functionCallDetails) return events$1;
-	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
+	const { outputIndex, toolCallId, name: name$1, initialArguments } = functionCallDetails;
 	const blockIndex = openFunctionCallBlock(state$1, {
 		outputIndex,
 		toolCallId,
-		name,
+		name: name$1,
 		events: events$1
 	});
 	if (initialArguments !== void 0 && initialArguments.length > 0) {
@@ -3044,15 +2975,16 @@ const buildErrorEvent = (message) => ({
 });
 const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
 const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
+	const { outputIndex, toolCallId, name: name$1, events: events$1 } = params;
 	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
 	if (!functionCallState) {
 		const blockIndex$1 = state$1.nextContentBlockIndex;
 		state$1.nextContentBlockIndex += 1;
+		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
 		functionCallState = {
 			blockIndex: blockIndex$1,
-			toolCallId: toolCallId ?? `tool_call_${blockIndex$1}`,
-			name: name ?? "function",
+			toolCallId: resolvedToolCallId,
+			name: name$1 ?? "function",
 			consecutiveWhitespaceCount: 0
 		};
 		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
@@ -3077,20 +3009,26 @@ const openFunctionCallBlock = (state$1, params) => {
 const extractFunctionCallDetails = (rawEvent) => {
 	const item = rawEvent.item;
 	if (item.type !== "function_call") return;
+	const outputIndex = rawEvent.output_index;
+	const toolCallId = item.call_id;
+	const name$1 = item.name;
+	const initialArguments = item.arguments;
 	return {
-		outputIndex: rawEvent.output_index,
-		toolCallId: item.call_id,
-		name: item.name,
-		initialArguments: item.arguments
+		outputIndex,
+		toolCallId,
+		name: name$1,
+		initialArguments
 	};
 };
 
 //#endregion
 //#region src/routes/responses/utils.ts
 const getResponsesRequestOptions = (payload) => {
+	const vision = hasVisionInput(payload);
+	const initiator = hasAgentInitiator(payload) ? "agent" : "user";
 	return {
-		vision: hasVisionInput(payload),
-		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+		vision,
+		initiator
 	};
 };
 const hasAgentInitiator = (payload) => {
@@ -3382,13 +3320,14 @@ async function handleCompletion(c) {
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
 const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride) => {
-	let finalPayload = await applyReplacementsToPayload(translateToOpenAI(anthropicPayload));
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	let finalPayload = await applyReplacementsToPayload(openAIPayload);
 	finalPayload = {
 		...finalPayload,
 		model: normalizeModelName(finalPayload.model)
 	};
 	logger$1.debug("Translated OpenAI request payload:", JSON.stringify(finalPayload));
-	const response = isAzureOpenAIModel(finalPayload.model) && state.azureOpenAIConfig ? await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, finalPayload) : await createChatCompletions(finalPayload, { initiator: initiatorOverride });
+	const response = await createChatCompletions(finalPayload, { initiator: initiatorOverride });
 	if (isNonStreaming(response)) {
 		logger$1.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 		const anthropicResponse = translateToAnthropic(response);
@@ -3407,7 +3346,8 @@ const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride)
 			logger$1.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);
+			const chunk = JSON.parse(rawEvent.data);
+			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				logger$1.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
@@ -3597,19 +3537,9 @@ modelRoutes.get("/", async (c) => {
 			owned_by: model.vendor,
 			display_name: model.name
 		})) ?? [];
-		const azureModels = state.azureOpenAIDeployments?.map((deployment) => ({
-			id: deployment.id,
-			object: "model",
-			type: "model",
-			created: deployment.created,
-			created_at: (/* @__PURE__ */ new Date(deployment.created * 1e3)).toISOString(),
-			owned_by: deployment.owned_by,
-			display_name: `${deployment.deploymentName} (${deployment.model})`
-		})) ?? [];
-		const allModels = [...copilotModels, ...azureModels];
 		return c.json({
 			object: "list",
-			data: allModels,
+			data: copilotModels,
 			has_more: false
 		});
 	} catch (error) {
@@ -3633,16 +3563,20 @@ replacementsRoute.post("/", async (c) => {
 	return c.json(rule, 201);
 });
 replacementsRoute.delete("/:id", async (c) => {
-	if (!await removeReplacement(c.req.param("id"))) return c.json({ error: "Replacement not found or is a system rule" }, 404);
+	const id = c.req.param("id");
+	if (!await removeReplacement(id)) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json({ success: true });
 });
 replacementsRoute.patch("/:id", async (c) => {
-	const rule = await updateReplacement(c.req.param("id"), await c.req.json());
+	const id = c.req.param("id");
+	const body = await c.req.json();
+	const rule = await updateReplacement(id, body);
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
 replacementsRoute.patch("/:id/toggle", async (c) => {
-	const rule = await toggleReplacement(c.req.param("id"));
+	const id = c.req.param("id");
+	const rule = await toggleReplacement(id);
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
@@ -3826,7 +3760,7 @@ server.route("/v1/messages", messageRoutes);
 //#endregion
 //#region src/start.ts
 async function runServer(options) {
-	consola.info(`copilot-api v${version}`);
+	consola.info(`copilot-api v${package_default.version}`);
 	if (options.insecure) {
 		process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 		consola.warn("SSL certificate verification disabled (insecure mode)");
@@ -3854,10 +3788,7 @@ async function runServer(options) {
 	} else await setupGitHubToken();
 	await setupCopilotToken();
 	await cacheModels();
-	await setupAzureOpenAI();
-	const copilotModelIds = state.models?.data.map((model) => model.id) ?? [];
-	const azureModelIds = state.azureOpenAIDeployments?.map((deployment) => deployment.id) ?? [];
-	const allModelIds = [...copilotModelIds, ...azureModelIds];
+	const allModelIds = state.models?.data.map((model) => model.id) ?? [];
 	consola.info(`Available models: \n${allModelIds.map((id) => `- ${id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
 	if (options.claudeCode) {
@@ -3990,10 +3921,10 @@ const start = defineCommand({
 
 //#endregion
 //#region src/main.ts
-await runMain(defineCommand({
+const main = defineCommand({
 	meta: {
 		name: "copilot-api",
-		version,
+		version: package_default.version,
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
 	},
 	subCommands: {
@@ -4003,7 +3934,8 @@ await runMain(defineCommand({
 		debug,
 		config
 	}
-}));
+});
+await runMain(main);
 
 //#endregion
 export {  };