zonemeen-cc-api 1.0.2

package/dist/main.js

@@ -0,0 +1,1849 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import consola from "consola";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { serve } from "srvx";
+import invariant from "tiny-invariant";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
+import { execSync } from "node:child_process";
+import process$1 from "node:process";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
+import { randomUUID } from "node:crypto";
+
+//#region src/auth.ts
+function runAuth() {
+	consola.info("Using custom API backend. No GitHub authentication needed.\nConfigure via environment variables:\n  XYBOT_USER - xybot-user header JSON\n  CUSTOM_API_URL - custom API URL\n  CUSTOM_BIZ_CODE - business code\n  CUSTOM_BIZ_TYPE - business type\n  CUSTOM_DEFAULT_CHANNEL - default model channel");
+}
+const auth = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Show authentication configuration help"
+	},
+	args: { verbose: {
+		alias: "v",
+		type: "boolean",
+		default: false,
+		description: "Enable verbose logging"
+	} },
+	run() {
+		runAuth();
+	}
+});
+
+//#endregion
+//#region src/check-usage.ts
+const checkUsage = defineCommand({
+	meta: {
+		name: "check-usage",
+		description: "Show current usage/quota information"
+	},
+	run() {
+		consola.info("Usage tracking is not available with custom API backend.\nPlease check your custom API dashboard for usage information.");
+	}
+});
+
+//#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 PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH
+};
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+}
+async function ensureFile(filePath) {
+	try {
+		await fs.access(filePath, fs.constants.W_OK);
+	} catch {
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/debug.ts
+async function getPackageVersion() {
+	try {
+		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
+		return JSON.parse(await fs.readFile(packageJsonPath)).version;
+	} catch {
+		return "unknown";
+	}
+}
+function getRuntimeInfo() {
+	return {
+		name: "node",
+		version: process.version.slice(1),
+		platform: os.platform(),
+		arch: os.arch()
+	};
+}
+async function checkTokenExists() {
+	try {
+		if (!(await fs.stat(PATHS.GITHUB_TOKEN_PATH)).isFile()) return false;
+		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function getDebugInfo() {
+	const [version, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
+	return {
+		version,
+		runtime: getRuntimeInfo(),
+		paths: {
+			APP_DIR: PATHS.APP_DIR,
+			GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH
+		},
+		tokenExists
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`copilot-api debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
+
+Token exists: ${info.tokenExists ? "Yes" : "No"}`);
+}
+function printDebugInfoJson(info) {
+	console.log(JSON.stringify(info, null, 2));
+}
+async function runDebug(options) {
+	const debugInfo = await getDebugInfo();
+	if (options.json) printDebugInfoJson(debugInfo);
+	else printDebugInfoPlain(debugInfo);
+}
+const debug = defineCommand({
+	meta: {
+		name: "debug",
+		description: "Print debug information about the application"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output debug information as JSON"
+	} },
+	run({ args }) {
+		return runDebug({ json: args.json });
+	}
+});
+
+//#endregion
+//#region src/lib/proxy.ts
+function initProxyFromEnv() {
+	if (typeof Bun !== "undefined") return;
+	try {
+		const direct = new Agent();
+		const proxies = /* @__PURE__ */ new Map();
+		setGlobalDispatcher({
+			dispatch(options, handler) {
+				try {
+					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
+					const raw = getProxyForUrl(origin.toString());
+					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
+					if (!proxyUrl) {
+						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+						return direct.dispatch(options, handler);
+					}
+					let agent = proxies.get(proxyUrl);
+					if (!agent) {
+						agent = new ProxyAgent(proxyUrl);
+						proxies.set(proxyUrl, agent);
+					}
+					let label = proxyUrl;
+					try {
+						const u = new URL(proxyUrl);
+						label = `${u.protocol}//${u.host}`;
+					} catch {}
+					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
+					return agent.dispatch(options, handler);
+				} catch {
+					return direct.dispatch(options, handler);
+				}
+			},
+			close() {
+				return direct.close();
+			},
+			destroy() {
+				return direct.destroy();
+			}
+		});
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
+	}
+}
+
+//#endregion
+//#region src/lib/shell.ts
+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";
+		} catch {
+			return "cmd";
+		}
+		return "cmd";
+	} else {
+		const shellPath = env.SHELL;
+		if (shellPath) {
+			if (shellPath.endsWith("zsh")) return "zsh";
+			if (shellPath.endsWith("fish")) return "fish";
+			if (shellPath.endsWith("bash")) return "bash";
+		}
+		return "sh";
+	}
+}
+/**
+* Generates a copy-pasteable script to set multiple environment variables
+* and run a subsequent command.
+* @param {EnvVars} envVars - An object of environment variables to set.
+* @param {string} commandToRun - The command to run after setting the variables.
+* @returns {string} The formatted script string.
+*/
+function generateEnvScript(envVars, commandToRun = "") {
+	const shell = getShell();
+	const filteredEnvVars = Object.entries(envVars).filter(([, value]) => value !== void 0);
+	let commandBlock;
+	switch (shell) {
+		case "powershell":
+			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${value}`).join("; ");
+			break;
+		case "cmd":
+			commandBlock = filteredEnvVars.map(([key, value]) => `set ${key}=${value}`).join(" & ");
+			break;
+		case "fish":
+			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${value}`).join("; ");
+			break;
+		default: {
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${value}`).join(" ");
+			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
+			break;
+		}
+	}
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
+	return commandBlock || commandToRun;
+}
+
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	accountType: "individual",
+	manualApprove: false,
+	rateLimitWait: false,
+	showToken: false,
+	customApiUrl: "http://xybot-appreciation:8080/api/appreciation/v1/inner/completions/conversation",
+	xybotUser: {
+		organizationUuid: "bb86844a-1e14-4baf-87ed-7c6619c9c383",
+		tenantUuid: "bb86844a-1e14-4baf-87ed-7c6619c9c383",
+		uuid: "923484698036051968"
+	},
+	bizCode: "ai-power",
+	bizType: "copilot-api"
+};
+
+//#endregion
+//#region src/lib/token.ts
+function setupCustomApi(options) {
+	if (options.xybotUser) state.xybotUser = options.xybotUser;
+	if (options.customApiUrl) state.customApiUrl = options.customApiUrl;
+	if (options.bizCode) state.bizCode = options.bizCode;
+	if (options.bizType) state.bizType = options.bizType;
+	if (options.defaultChannel) state.defaultChannel = options.defaultChannel;
+	consola.info("Custom API configured:");
+	consola.info(`  URL: ${state.customApiUrl}`);
+	consola.info(`  bizCode: ${state.bizCode}`);
+	consola.info(`  bizType: ${state.bizType}`);
+	if (state.xybotUser) consola.info(`  xybot-user: configured`);
+	if (state.defaultChannel) consola.info(`  Default channel: ${state.defaultChannel}`);
+}
+
+//#endregion
+//#region src/services/copilot/get-models.ts
+const getModels = () => {
+	return {
+		object: "list",
+		data: CUSTOM_MODELS
+	};
+};
+function buildModel(id, vendor, opts) {
+	return {
+		id,
+		name: id,
+		object: "model",
+		vendor,
+		version: "1.0",
+		preview: false,
+		model_picker_enabled: true,
+		capabilities: {
+			family: id,
+			type: "chat",
+			object: "model_capabilities",
+			tokenizer: opts?.tokenizer ?? "o200k_base",
+			limits: {
+				max_context_window_tokens: opts?.maxContext ?? 128e3,
+				max_output_tokens: opts?.maxOutput ?? 16384
+			},
+			supports: {
+				tool_calls: opts?.toolCalls ?? true,
+				parallel_tool_calls: opts?.toolCalls ?? true
+			}
+		}
+	};
+}
+const CUSTOM_MODELS = [
+	buildModel("gpt-4o", "azure", {
+		maxContext: 128e3,
+		maxOutput: 16384
+	}),
+	buildModel("gpt-4o-mini", "azure", {
+		maxContext: 128e3,
+		maxOutput: 16384
+	}),
+	buildModel("gpt-4.1", "azure", {
+		maxContext: 1047576,
+		maxOutput: 32768
+	}),
+	buildModel("gpt-4.1-mini", "azure", {
+		maxContext: 1047576,
+		maxOutput: 32768
+	}),
+	buildModel("gpt-4.1-nano", "azure", {
+		maxContext: 1047576,
+		maxOutput: 32768
+	}),
+	buildModel("o3-mini", "azure", {
+		maxContext: 2e5,
+		maxOutput: 1e5
+	}),
+	buildModel("o3", "azure", {
+		maxContext: 2e5,
+		maxOutput: 1e5
+	}),
+	buildModel("gpt-5.2", "azure", {
+		maxContext: 1047576,
+		maxOutput: 32768
+	}),
+	buildModel("claude-sonnet-4", "claude", {
+		maxContext: 2e5,
+		maxOutput: 64e3,
+		tokenizer: "o200k_base"
+	}),
+	buildModel("claude-opus-4", "claude", {
+		maxContext: 2e5,
+		maxOutput: 32e3,
+		tokenizer: "o200k_base"
+	}),
+	buildModel("claude-v3.7-sonnet", "claude", {
+		maxContext: 2e5,
+		maxOutput: 64e3,
+		tokenizer: "o200k_base"
+	}),
+	buildModel("claude-v3.5-sonnet", "claude", {
+		maxContext: 2e5,
+		maxOutput: 8192,
+		tokenizer: "o200k_base"
+	}),
+	buildModel("claude-v3.5-haiku", "claude", {
+		maxContext: 2e5,
+		maxOutput: 8192,
+		tokenizer: "o200k_base"
+	}),
+	buildModel("deepseek-chat", "deepseek", {
+		maxContext: 65536,
+		maxOutput: 8192
+	}),
+	buildModel("deepseek-reasoner", "deepseek", {
+		maxContext: 65536,
+		maxOutput: 8192
+	}),
+	buildModel("qwen-max", "qwen", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("qwen-plus", "qwen", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("qwen-turbo", "qwen", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("qwq-plus", "qwen", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("gemini-2.5-pro", "gemini", {
+		maxContext: 1048576,
+		maxOutput: 65536
+	}),
+	buildModel("gemini-2.5-flash", "gemini", {
+		maxContext: 1048576,
+		maxOutput: 65536
+	}),
+	buildModel("gemini-2.0-flash", "gemini", {
+		maxContext: 1048576,
+		maxOutput: 8192
+	}),
+	buildModel("gemini-3-flash", "gemini", {
+		maxContext: 1048576,
+		maxOutput: 65536
+	}),
+	buildModel("Doubao-1.5-pro-256k", "doubao", {
+		maxContext: 256e3,
+		maxOutput: 16384
+	}),
+	buildModel("Doubao-seed-1.6", "doubao", {
+		maxContext: 131072,
+		maxOutput: 16384
+	}),
+	buildModel("Doubao-seed-1.6-thinking", "doubao", {
+		maxContext: 131072,
+		maxOutput: 16384
+	}),
+	buildModel("Doubao-seed-1.8", "doubao", {
+		maxContext: 131072,
+		maxOutput: 16384
+	}),
+	buildModel("kimi-k2", "moonshot", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("moonshot-v1-128k", "moonshot", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("glm-4.7", "chatglm", {
+		maxContext: 131072,
+		maxOutput: 8192
+	}),
+	buildModel("glm-4", "chatglm", {
+		maxContext: 128e3,
+		maxOutput: 4096
+	}),
+	buildModel("morph-v2", "morph", {
+		maxContext: 128e3,
+		maxOutput: 8192
+	}),
+	buildModel("MiniMax-M2.1", "Minimax", {
+		maxContext: 1048576,
+		maxOutput: 16384
+	})
+];
+
+//#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+function cacheModels() {
+	state.models = getModels();
+}
+
+//#endregion
+//#region src/lib/error.ts
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+async function forwardError(c, error) {
+	consola.error("Error occurred:", error);
+	if (error instanceof HTTPError) {
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = errorText;
+		}
+		consola.error("HTTP error:", errorJson);
+		return c.json({ error: {
+			message: errorText,
+			type: "error"
+		} }, error.response.status);
+	}
+	return c.json({ error: {
+		message: error.message,
+		type: "error"
+	} }, 500);
+}
+
+//#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 }));
+};
+
+//#endregion
+//#region src/lib/rate-limit.ts
+async function checkRateLimit(state$1) {
+	if (state$1.rateLimitSeconds === void 0) return;
+	const now = Date.now();
+	if (!state$1.lastRequestTimestamp) {
+		state$1.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsedSeconds = (now - state$1.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state$1.rateLimitSeconds) {
+		state$1.lastRequestTimestamp = now;
+		return;
+	}
+	const waitTimeSeconds = Math.ceil(state$1.rateLimitSeconds - elapsedSeconds);
+	if (!state$1.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.lastRequestTimestamp = now;
+	consola.info("Rate limit wait completed, proceeding with request");
+}
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
+/**
+* Calculate tokens for tool calls
+*/
+const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+	}
+	tokens += constants.funcEnd;
+	return tokens;
+};
+/**
+* Calculate tokens for content parts
+*/
+const calculateContentPartsTokens = (contentParts, encoder) => {
+	let tokens = 0;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder.encode(part.text).length;
+	return tokens;
+};
+/**
+* Calculate tokens for a single message
+*/
+const calculateMessageTokens = (message, encoder, constants) => {
+	const tokensPerMessage = 3;
+	const tokensPerName = 1;
+	let tokens = tokensPerMessage;
+	for (const [key, value] of Object.entries(message)) {
+		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (key === "name") tokens += tokensPerName;
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+	}
+	return tokens;
+};
+/**
+* Calculate tokens using custom algorithm
+*/
+const 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;
+	return numTokens;
+};
+/**
+* Get the corresponding encoder module based on encoding type
+*/
+const getEncodeChatFunction = async (encoding) => {
+	if (encodingCache.has(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();
+		encodingCache.set(encoding, fallbackModule);
+		return fallbackModule;
+	}
+	const encodingModule = await ENCODING_MAP[supportedEncoding]();
+	encodingCache.set(encoding, encodingModule);
+	return encodingModule;
+};
+/**
+* Get tokenizer type from model information
+*/
+const getTokenizerFromModel = (model) => {
+	return model.capabilities.tokenizer || "o200k_base";
+};
+/**
+* Get model-specific constants for token calculation
+*/
+const 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
+	};
+};
+/**
+* Calculate tokens for a single parameter
+*/
+const calculateParameterTokens = (key, prop, context) => {
+	const { encoder, constants } = context;
+	let tokens = constants.propKey;
+	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;
+		for (const item of param.enum) {
+			tokens += constants.enumItem;
+			tokens += encoder.encode(String(item)).length;
+		}
+	}
+	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
+	const line = `${paramName}:${paramType}:${paramDesc}`;
+	tokens += encoder.encode(line).length;
+	const excludedKeys = new Set([
+		"type",
+		"description",
+		"enum"
+	]);
+	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
+		const propertyValue = param[propertyName];
+		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for function parameters
+*/
+const calculateParametersTokens = (parameters, encoder, constants) => {
+	if (!parameters || typeof parameters !== "object") return 0;
+	const params = parameters;
+	let tokens = 0;
+	for (const [key, value] of Object.entries(params)) if (key === "properties") {
+		const properties = value;
+		if (Object.keys(properties).length > 0) {
+			tokens += constants.propInit;
+			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
+				encoder,
+				constants
+			});
+		}
+	} else {
+		const paramText = typeof value === "string" ? value : JSON.stringify(value);
+		tokens += encoder.encode(`${key}:${paramText}`).length;
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for a single tool
+*/
+const calculateToolTokens = (tool, encoder, constants) => {
+	let tokens = constants.funcInit;
+	const func = tool.function;
+	const fName = func.name;
+	let fDesc = func.description || "";
+	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
+	const line = fName + ":" + fDesc;
+	tokens += encoder.encode(line).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	return tokens;
+};
+/**
+* Calculate token count for tools based on model
+*/
+const numTokensForTools = (tools, encoder, constants) => {
+	let funcTokenCount = 0;
+	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	funcTokenCount += constants.funcEnd;
+	return funcTokenCount;
+};
+/**
+* Calculate the token count of messages, supporting multiple GPT encoders
+*/
+const getTokenCount = async (payload, model) => {
+	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
+	const simplifiedMessages = payload.messages;
+	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = simplifiedMessages.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);
+	const outputTokens = calculateTokens(outputMessages, encoder, constants);
+	return {
+		input: inputTokens,
+		output: outputTokens
+	};
+};
+
+//#endregion
+//#region src/lib/api-config.ts
+const customApiUrl = (state$1) => state$1.customApiUrl;
+const customApiHeaders = (state$1) => {
+	const headers = { "Content-Type": "application/json" };
+	if (state$1.xybotUser) headers["xybot-user"] = JSON.stringify(state$1.xybotUser);
+	return headers;
+};
+const MODEL_PREFIX_TO_CHANNEL = [
+	["gpt-", "azure"],
+	["o3", "azure"],
+	["o-", "azure"],
+	["o1", "azure"],
+	["text-embedding-v", "qwen"],
+	["text-embedding-", "azure"],
+	["ernie", "ernie"],
+	["nova-", "sensenova"],
+	["sensechat", "sensenova"],
+	["general", "sparkai"],
+	["pro-128k", "sparkai"],
+	["claude", "claude"],
+	["baichuan", "baichuan"],
+	["qwen", "qwen"],
+	["qwq", "qwen"],
+	["glm", "chatglm"],
+	["chatglm", "chatglm"],
+	["moonshot", "moonshot"],
+	["kimi", "moonshot"],
+	["deepseek", "deepseek"],
+	["doubao", "doubao"],
+	["gemini", "gemini"],
+	["morph", "morph"],
+	["minimax", "Minimax"],
+	["bge-", "azure"]
+];
+function getChannelFromModel(model) {
+	const m = model.toLowerCase();
+	return MODEL_PREFIX_TO_CHANNEL.find(([prefix]) => m.startsWith(prefix))?.[1] ?? "azure";
+}
+const CUSTOM_EMBEDDING_URL = "http://xybot-appreciation:8080/api/appreciation/v1/inner/langchain/rag/textEmbedding";
+const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+
+//#endregion
+//#region src/services/copilot/create-chat-completions.ts
+const UNSUPPORTED_SCHEMA_KEYS = new Set([
+	"$schema",
+	"additionalProperties",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"propertyNames",
+	"patternProperties",
+	"$id",
+	"$ref",
+	"$comment",
+	"$defs",
+	"definitions",
+	"if",
+	"then",
+	"else",
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"not",
+	"dependentRequired",
+	"dependentSchemas",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"contentEncoding",
+	"contentMediaType"
+]);
+function sanitizeSchema(obj) {
+	if (typeof obj !== "object" || obj === null) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (UNSUPPORTED_SCHEMA_KEYS.has(key)) continue;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) result[key] = sanitizeSchema(value);
+		else if (Array.isArray(value)) result[key] = value.map((item) => typeof item === "object" && item !== null && !Array.isArray(item) ? sanitizeSchema(item) : item);
+		else result[key] = value;
+	}
+	return result;
+}
+function isGeminiModel(model) {
+	return model.toLowerCase().startsWith("gemini");
+}
+/**
+* In-memory cache mapping tool_call id → thought_signature.
+* Gemini 3+ models return a `model_result.thought_signature` with each
+* function call. Subsequent requests MUST echo the signature back in the
+* assistant message's tool_calls, otherwise the API returns a 400 error.
+*/
+const thoughtSignatureCache = /* @__PURE__ */ new Map();
+function extractSignaturesFromToolCalls(toolCalls) {
+	for (const tc of toolCalls) {
+		const id = tc.id;
+		const modelResult = tc.model_result ?? tc.modelResult;
+		const sig = modelResult?.thought_signature ?? modelResult?.thoughtSignature;
+		if (id && sig) thoughtSignatureCache.set(id, sig);
+	}
+}
+function captureThoughtSignatures(rawData) {
+	if (typeof rawData !== "object" || rawData === null) return;
+	const raw = rawData;
+	const choices = (raw.data ?? raw).choices;
+	if (!choices) return;
+	for (const choice of choices) {
+		const src = choice.message ?? choice.delta;
+		if (!src) continue;
+		const toolCalls = src.tool_calls ?? src.toolCalls;
+		if (toolCalls) extractSignaturesFromToolCalls(toolCalls);
+	}
+}
+function prepareMessagesForGemini(messages) {
+	return messages.map((msg) => {
+		if (msg.role !== "assistant" || !msg.tool_calls?.length) return msg;
+		const toolCalls = msg.tool_calls.map((tc) => {
+			const sig = thoughtSignatureCache.get(tc.id);
+			if (!sig) return tc;
+			return {
+				...tc,
+				model_result: { thought_signature: sig }
+			};
+		});
+		return {
+			...msg,
+			tool_calls: toolCalls
+		};
+	});
+}
+function buildCustomPayload(payload) {
+	const channel = state.defaultChannel ?? getChannelFromModel(payload.model);
+	const messages = isGeminiModel(payload.model) ? prepareMessagesForGemini(payload.messages) : payload.messages;
+	const customPayload = {
+		bizId: randomUUID(),
+		bizCode: state.bizCode,
+		bizType: state.bizType,
+		stream: payload.stream ?? false,
+		channel,
+		model: payload.model,
+		messages,
+		temperature: payload.temperature
+	};
+	if (payload.tools) customPayload.tools = payload.tools.map((tool) => ({
+		...tool,
+		function: {
+			...tool.function,
+			parameters: sanitizeSchema(tool.function.parameters)
+		}
+	}));
+	if (payload.tool_choice !== void 0 && payload.tool_choice !== null) customPayload.toolChoice = payload.tool_choice;
+	if (payload.response_format) customPayload.responseFormat = payload.response_format;
+	if (payload.max_tokens !== void 0 && payload.max_tokens !== null) customPayload.maxTokens = payload.max_tokens;
+	return customPayload;
+}
+function normalizeNonStreamResponse(raw) {
+	const { data } = raw;
+	return {
+		id: data.id,
+		object: "chat.completion",
+		created: data.created,
+		model: data.model,
+		choices: data.choices.map((choice) => {
+			const legacyFc = choice.message.function_call ?? choice.message.functionCall;
+			const toolCalls = choice.message.tool_calls ?? choice.message.toolCalls ?? (legacyFc ? [{
+				id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+				type: "function",
+				function: legacyFc
+			}] : void 0);
+			return {
+				index: choice.index,
+				message: {
+					role: "assistant",
+					content: choice.message.content ?? choice.message.c ?? null,
+					tool_calls: toolCalls
+				},
+				logprobs: null,
+				finish_reason: normalizeFinishReason(choice.finishReason ?? choice.finish_reason) ?? "stop"
+			};
+		}),
+		usage: {
+			prompt_tokens: data.requestCost ?? 0,
+			completion_tokens: data.responseCost ?? 0,
+			total_tokens: (data.requestCost ?? 0) + (data.responseCost ?? 0)
+		}
+	};
+}
+function normalizeStreamChunk(raw) {
+	const choices = raw.choices;
+	return {
+		id: typeof raw.id === "string" ? raw.id : "",
+		object: "chat.completion.chunk",
+		created: typeof raw.created === "number" ? raw.created : 0,
+		model: typeof raw.model === "string" ? raw.model : "",
+		choices: choices?.map((c) => {
+			const delta = c.delta ?? {};
+			const rawFinish = c.finish_reason ?? c.finishReason;
+			const rawToolCalls = delta.tool_calls ?? delta.toolCalls;
+			const legacyFnCall = delta.function_call ?? delta.functionCall;
+			const toolCalls = rawToolCalls ?? (legacyFnCall ? [{
+				index: 0,
+				function: legacyFnCall
+			}] : void 0);
+			return {
+				index: typeof c.index === "number" ? c.index : 0,
+				delta: {
+					content: delta.content,
+					role: delta.role,
+					tool_calls: toolCalls
+				},
+				finish_reason: normalizeFinishReason(rawFinish),
+				logprobs: null
+			};
+		}) ?? []
+	};
+}
+function normalizeFinishReason(reason) {
+	if (!reason || reason === "") return null;
+	return {
+		stop: "stop",
+		length: "length",
+		max_tokens: "length",
+		tool_calls: "tool_calls",
+		function_call: "tool_calls",
+		functioncall: "tool_calls",
+		content_filter: "content_filter",
+		safety: "content_filter"
+	}[reason.toLowerCase()] ?? null;
+}
+async function* transformStream(stream) {
+	for await (const event of stream) {
+		if (event.data === "[DONE]") {
+			yield event;
+			continue;
+		}
+		if (!event.data) {
+			yield event;
+			continue;
+		}
+		try {
+			const raw = JSON.parse(event.data);
+			captureThoughtSignatures(raw);
+			const normalized = normalizeStreamChunk(raw);
+			yield {
+				...event,
+				data: JSON.stringify(normalized)
+			};
+		} catch {
+			yield event;
+		}
+	}
+}
+const createChatCompletions = async (payload) => {
+	const customPayload = buildCustomPayload(payload);
+	consola.debug("Custom API payload:", JSON.stringify(customPayload));
+	const response = await fetch(customApiUrl(state), {
+		method: "POST",
+		headers: customApiHeaders(state),
+		body: JSON.stringify(customPayload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat completions", response);
+		throw new HTTPError("Failed to create chat completions", response);
+	}
+	if (payload.stream) return transformStream(events(response));
+	const raw = await response.json();
+	captureThoughtSignatures(raw);
+	if (!raw.success) {
+		consola.error("Custom API returned error:", raw.msg);
+		throw new Error(`Custom API error: ${raw.msg ?? "Unknown error"}`);
+	}
+	return normalizeNonStreamResponse(raw);
+};
+
+//#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 selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	try {
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(payload, selectedModel);
+			consola.info("Current token count:", tokenCount);
+		} else consola.warn("No model selected, skipping token count calculation");
+	} 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));
+	}
+	const response = await createChatCompletions(payload);
+	if (isNonStreaming$1(response)) {
+		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));
+			await stream.writeSSE(chunk);
+		}
+	});
+}
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion$1(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/services/copilot/create-embeddings.ts
+const createEmbeddings = async (payload) => {
+	const inputs = typeof payload.input === "string" ? [payload.input] : payload.input;
+	const channel = state.defaultChannel ?? getChannelFromModel(payload.model);
+	const embeddings = [];
+	let index = 0;
+	for (const text of inputs) {
+		const customPayload = {
+			bizId: randomUUID(),
+			bizCode: state.bizCode,
+			bizType: state.bizType,
+			channel,
+			model: payload.model,
+			text
+		};
+		consola.debug("Custom embedding payload:", JSON.stringify(customPayload));
+		const response = await fetch(CUSTOM_EMBEDDING_URL, {
+			method: "POST",
+			headers: customApiHeaders(state),
+			body: JSON.stringify(customPayload)
+		});
+		if (!response.ok) throw new Error(`Embedding request failed with status ${response.status}`);
+		const raw = await response.json();
+		if (!raw.success || !raw.data) throw new Error(`Embedding API error: ${raw.msg ?? "Unknown error"} (code: ${raw.code})`);
+		embeddings.push({
+			object: "embedding",
+			embedding: raw.data.embedding,
+			index
+		});
+		index++;
+	}
+	const totalTokens = inputs.reduce((sum, text) => sum + text.length, 0);
+	return {
+		object: "list",
+		data: embeddings,
+		model: payload.model,
+		usage: {
+			prompt_tokens: totalTokens,
+			total_tokens: totalTokens
+		}
+	};
+};
+
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		const response = await createEmbeddings(await c.req.json());
+		return c.json(response);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#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) {
+	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)
+	};
+}
+function translateModelName(model) {
+	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
+	else if (model.startsWith("claude-opus-4-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
+	else if (model.startsWith("claude-3-7-sonnet") || model.startsWith("claude-3.7-sonnet")) return "claude-v3.7-sonnet";
+	else if (model.startsWith("claude-3-5-sonnet") || model.startsWith("claude-3.5-sonnet")) return "claude-v3.5-sonnet";
+	else if (model.startsWith("claude-3-5-haiku") || model.startsWith("claude-3.5-haiku")) return "claude-v3.5-haiku";
+	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)
+	});
+	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
+		}
+	}));
+}
+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;
+	}
+}
+function buildAnthropicUsage(response) {
+	return {
+		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 }
+	};
+}
+function translateToAnthropic(response) {
+	const allTextBlocks = [];
+	const allToolUseBlocks = [];
+	let stopReason = response.choices[0]?.finish_reason ?? null;
+	for (const choice of response.choices) {
+		allTextBlocks.push(...getAnthropicTextBlocks(choice.message.content));
+		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls));
+		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
+	}
+	const anthropicStopReason = allToolUseBlocks.length > 0 ? "tool_use" : mapOpenAIStopReasonToAnthropic(stopReason);
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [...allTextBlocks, ...allToolUseBlocks],
+		stop_reason: anthropicStopReason,
+		stop_sequence: null,
+		usage: buildAnthropicUsage(response)
+	};
+}
+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 || `toolu_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+		name: toolCall.function.name,
+		input: JSON.parse(toolCall.function.arguments)
+	}));
+}
+
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+/**
+* Handles token counting for Anthropic messages
+*/
+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) {
+		const toolName = toolCall.function?.name;
+		if (toolName && !(toolCall.index in state$1.toolCalls)) {
+			if (state$1.contentBlockOpen) {
+				events$1.push({
+					type: "content_block_stop",
+					index: state$1.contentBlockIndex
+				});
+				state$1.contentBlockIndex++;
+				state$1.contentBlockOpen = false;
+			}
+			const toolId = toolCall.id || `toolu_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
+			const anthropicBlockIndex = state$1.contentBlockIndex;
+			state$1.toolCalls[toolCall.index] = {
+				id: toolId,
+				name: toolName,
+				anthropicBlockIndex
+			};
+			events$1.push({
+				type: "content_block_start",
+				index: anthropicBlockIndex,
+				content_block: {
+					type: "tool_use",
+					id: toolId,
+					name: toolName,
+					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;
+		}
+		const stopReason = Object.keys(state$1.toolCalls).length > 0 ? "tool_use" : mapOpenAIStopReasonToAnthropic(choice.finish_reason);
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: stopReason,
+				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" });
+		state$1.messageFinishSent = true;
+	}
+	return events$1;
+}
+/**
+* Generate closing events for streams that ended without a `finish_reason`
+* chunk. Some providers (e.g. Gemini via the custom API) may close the stream
+* or send `[DONE]` without ever emitting a chunk with `finish_reason`, leaving
+* the Anthropic SSE stream without `message_delta` / `message_stop`.
+*/
+function getStreamClosingEvents(state$1) {
+	if (!state$1.messageStartSent || state$1.messageFinishSent) return [];
+	const events$1 = [];
+	if (state$1.contentBlockOpen) events$1.push({
+		type: "content_block_stop",
+		index: state$1.contentBlockIndex
+	});
+	const hasToolCalls = Object.keys(state$1.toolCalls).length > 0;
+	events$1.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: hasToolCalls ? "tool_use" : "end_turn",
+			stop_sequence: null
+		},
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		}
+	}, { type: "message_stop" });
+	return events$1;
+}
+
+//#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));
+	if (state.manualApprove) await awaitApproval();
+	const response = await createChatCompletions(openAIPayload);
+	if (isNonStreaming(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,
+			messageFinishSent: 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 closingEvents = getStreamClosingEvents(streamState);
+		for (const event of closingEvents) {
+			consola.debug("Stream closing event:", JSON.stringify(event));
+			await stream.writeSSE({
+				event: event.type,
+				data: JSON.stringify(event)
+			});
+		}
+	});
+}
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/messages/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+messageRoutes.post("/count_tokens", async (c) => {
+	try {
+		return await handleCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	try {
+		if (!state.models) await cacheModels();
+		const models = state.models?.data.map((model) => ({
+			id: model.id,
+			object: "model",
+			type: "model",
+			created: 0,
+			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+			owned_by: model.vendor,
+			display_name: model.name
+		}));
+		return c.json({
+			object: "list",
+			data: models,
+			has_more: false
+		});
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/token/route.ts
+const tokenRoute = new Hono();
+tokenRoute.get("/", (c) => {
+	return c.json({
+		token: "custom-api-mode",
+		message: "Using custom API backend, no Copilot token in use"
+	});
+});
+
+//#endregion
+//#region src/routes/usage/route.ts
+const usageRoute = new Hono();
+usageRoute.get("/", (c) => {
+	return c.json({
+		message: "Usage tracking is not available with custom API backend",
+		copilot_plan: "custom",
+		quota_snapshots: {
+			chat: {
+				entitlement: 0,
+				remaining: 0,
+				percent_remaining: 0,
+				unlimited: true,
+				overage_count: 0,
+				overage_permitted: false,
+				quota_id: "",
+				quota_remaining: 0
+			},
+			completions: {
+				entitlement: 0,
+				remaining: 0,
+				percent_remaining: 0,
+				unlimited: true,
+				overage_count: 0,
+				overage_permitted: false,
+				quota_id: "",
+				quota_remaining: 0
+			},
+			premium_interactions: {
+				entitlement: 0,
+				remaining: 0,
+				percent_remaining: 0,
+				unlimited: true,
+				overage_count: 0,
+				overage_permitted: false,
+				quota_id: "",
+				quota_remaining: 0
+			}
+		},
+		quota_reset_date: "",
+		access_type_sku: "custom",
+		analytics_tracking_id: "",
+		assigned_date: "",
+		can_signup_for_limited: false,
+		chat_enabled: true,
+		organization_login_list: [],
+		organization_list: []
+	});
+});
+
+//#endregion
+//#region src/server.ts
+const server = new Hono();
+server.use(logger());
+server.use(cors());
+server.get("/", (c) => c.text("Server running"));
+server.route("/chat/completions", completionRoutes);
+server.route("/models", modelRoutes);
+server.route("/embeddings", embeddingRoutes);
+server.route("/usage", usageRoute);
+server.route("/token", tokenRoute);
+server.route("/v1/chat/completions", completionRoutes);
+server.route("/v1/models", modelRoutes);
+server.route("/v1/embeddings", embeddingRoutes);
+server.route("/v1/messages", messageRoutes);
+
+//#endregion
+//#region src/start.ts
+async function runServer(options) {
+	if (options.proxyEnv) initProxyFromEnv();
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.accountType = options.accountType;
+	state.manualApprove = options.manual;
+	state.rateLimitSeconds = options.rateLimit;
+	state.rateLimitWait = options.rateLimitWait;
+	state.showToken = options.showToken;
+	await ensurePaths();
+	let xybotUser;
+	const xybotUserStr = options.xybotUser ?? process.env.XYBOT_USER;
+	if (xybotUserStr) try {
+		xybotUser = JSON.parse(xybotUserStr);
+	} catch {
+		consola.error("Failed to parse xybot-user JSON:", xybotUserStr);
+		throw new Error("Invalid xybot-user JSON format");
+	}
+	const customUuid = options.uuid ?? process.env.XYBOT_UUID;
+	if (customUuid) if (xybotUser) xybotUser.uuid = customUuid;
+	else state.xybotUser = {
+		...state.xybotUser,
+		uuid: customUuid
+	};
+	setupCustomApi({
+		xybotUser,
+		customApiUrl: options.customApiUrl ?? process.env.CUSTOM_API_URL,
+		bizCode: options.bizCode ?? process.env.CUSTOM_BIZ_CODE,
+		bizType: options.bizType ?? process.env.CUSTOM_BIZ_TYPE,
+		defaultChannel: options.defaultChannel ?? process.env.CUSTOM_DEFAULT_CHANNEL
+	});
+	cacheModels();
+	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	const serverUrl = `http://localhost:${options.port}`;
+	if (options.claudeCode) {
+		invariant(state.models, "Models should be loaded by now");
+		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.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)
+		});
+		const command = generateEnvScript({
+			ANTHROPIC_BASE_URL: serverUrl,
+			ANTHROPIC_AUTH_TOKEN: "dummy",
+			ANTHROPIC_MODEL: selectedModel,
+			ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
+			ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
+			ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedSmallModel,
+			DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+			CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+		}, "claude");
+		try {
+			const { default: clipboard } = await import("clipboardy");
+			clipboard.writeSync(command);
+			consola.success("Copied Claude Code command to clipboard!");
+		} catch {
+			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
+			consola.log(command);
+		}
+	}
+	consola.box(`Server running at ${serverUrl}`);
+	serve({
+		fetch: server.fetch,
+		port: options.port
+	});
+}
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the API proxy server"
+	},
+	args: {
+		port: {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port to listen on"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			description: "Account type (individual, business, enterprise)"
+		},
+		manual: {
+			type: "boolean",
+			default: false,
+			description: "Enable manual request approval"
+		},
+		"rate-limit": {
+			alias: "r",
+			type: "string",
+			description: "Rate limit in seconds between requests"
+		},
+		wait: {
+			alias: "w",
+			type: "boolean",
+			default: false,
+			description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
+		},
+		"claude-code": {
+			alias: "c",
+			type: "boolean",
+			default: false,
+			description: "Generate a command to launch Claude Code with this API config"
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Show tokens on fetch and refresh"
+		},
+		"proxy-env": {
+			type: "boolean",
+			default: false,
+			description: "Initialize proxy from environment variables"
+		},
+		"custom-api-url": {
+			type: "string",
+			description: "Custom API URL (env: CUSTOM_API_URL)"
+		},
+		"xybot-user": {
+			type: "string",
+			description: "xybot-user header JSON, e.g. '{\"organizationUuid\":\"...\",\"tenantUuid\":\"...\",\"uuid\":\"...\"}' (env: XYBOT_USER)"
+		},
+		uuid: {
+			alias: "u",
+			type: "string",
+			description: "Custom user UUID for xybot-user, overrides the uuid field in default/provided xybot-user (env: XYBOT_UUID)"
+		},
+		"biz-code": {
+			type: "string",
+			description: "Business code for custom API (env: CUSTOM_BIZ_CODE)"
+		},
+		"biz-type": {
+			type: "string",
+			description: "Business type for custom API (env: CUSTOM_BIZ_TYPE)"
+		},
+		"default-channel": {
+			type: "string",
+			description: "Default model channel, e.g. azure, claude, deepseek (env: CUSTOM_DEFAULT_CHANNEL)"
+		}
+	},
+	run({ args }) {
+		const rateLimitRaw = args["rate-limit"];
+		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		return runServer({
+			port: Number.parseInt(args.port, 10),
+			verbose: args.verbose,
+			accountType: args["account-type"],
+			manual: args.manual,
+			rateLimit,
+			rateLimitWait: args.wait,
+			claudeCode: args["claude-code"],
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"],
+			customApiUrl: args["custom-api-url"],
+			xybotUser: args["xybot-user"],
+			uuid: args.uuid,
+			bizCode: args["biz-code"],
+			bizType: args["biz-type"],
+			defaultChannel: args["default-channel"]
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+await runMain(defineCommand({
+	meta: {
+		name: "copilot-api",
+		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
+	},
+	subCommands: {
+		auth,
+		start,
+		"check-usage": checkUsage,
+		debug
+	}
+}));
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map