proxitor 0.3.0 → 0.5.0

package/dist/proxy.cjs

@@ -1,656 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let node_fs = require("node:fs");
-let node_os = require("node:os");
-let node_path = require("node:path");
-let js_yaml = require("js-yaml");
-js_yaml = __toESM(js_yaml, 1);
-let zod = require("zod");
-let consola = require("consola");
-let _hono_node_server = require("@hono/node-server");
-let hono = require("hono");
-//#region src/config-schema.ts
-/** Percentile cutoffs for performance thresholds */
-const percentileCutoffsSchema = zod.z.object({
-	p50: zod.z.number().positive().optional(),
-	p75: zod.z.number().positive().optional(),
-	p90: zod.z.number().positive().optional(),
-	p99: zod.z.number().positive().optional()
-}).strict();
-/** Provider sorting options */
-const providerSortSchema = zod.z.union([zod.z.enum([
-	"price",
-	"throughput",
-	"latency"
-]), zod.z.object({
-	by: zod.z.enum([
-		"price",
-		"throughput",
-		"latency"
-	]),
-	partition: zod.z.enum(["model", "none"]).optional()
-}).strict()]);
-/** Maximum pricing for a request */
-const maxPriceSchema = zod.z.object({
-	prompt: zod.z.number().nonnegative().optional(),
-	completion: zod.z.number().nonnegative().optional(),
-	request: zod.z.number().nonnegative().optional(),
-	image: zod.z.number().nonnegative().optional()
-}).strict();
-/** Provider routing configuration */
-const providerConfigSchema = zod.z.object({
-	only: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	order: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	ignore: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	allowFallbacks: zod.z.boolean().optional(),
-	sort: providerSortSchema.optional(),
-	quantizations: zod.z.array(zod.z.string()).optional(),
-	maxPrice: maxPriceSchema.optional(),
-	requireParameters: zod.z.boolean().optional(),
-	dataCollection: zod.z.enum(["allow", "deny"]).optional(),
-	zdr: zod.z.boolean().optional(),
-	enforceDistillableText: zod.z.boolean().optional(),
-	preferredMinThroughput: zod.z.union([zod.z.number().positive(), percentileCutoffsSchema]).optional(),
-	preferredMaxLatency: zod.z.union([zod.z.number().positive(), percentileCutoffsSchema]).optional()
-}).strict();
-/** Per-model override: layers on top of global config */
-const modelOverrideSchema = zod.z.object({
-	provider: providerConfigSchema.optional(),
-	headers: zod.z.record(zod.z.string(), zod.z.string()).optional()
-}).strict();
-/** Schema for validating raw file content — all top-level keys optional */
-const proxyConfigFileSchema = zod.z.object({
-	host: zod.z.string().min(1),
-	port: zod.z.number().int().min(1).max(65535),
-	openrouterKey: zod.z.string(),
-	openrouterBaseUrl: zod.z.string().url(),
-	verbose: zod.z.boolean(),
-	bodyLimit: zod.z.string().min(1),
-	provider: providerConfigSchema.optional(),
-	attributionReferer: zod.z.string().min(1),
-	attributionTitle: zod.z.string().min(1),
-	headers: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-	modelOverrides: zod.z.record(zod.z.string().min(1), modelOverrideSchema).optional()
-}).strict().partial();
-/** Wraps YAML/JSON parse errors with the config file path */
-var ConfigParseError = class extends Error {
-	constructor(filePath, cause) {
-		super(`Failed to parse config file ${filePath}: ${cause?.message ?? "unknown error"}`, { cause });
-		this.name = "ConfigParseError";
-	}
-};
-/** Formats zod validation issues into a readable multi-line message */
-var ConfigValidationError = class extends Error {
-	constructor(filePath, zodError) {
-		const lines = zodError.issues.map((issue) => {
-			return `  ${issue.path.length > 0 ? issue.path.join(".") : "(root)"}: ${issue.message}`;
-		});
-		super(`Invalid config in ${filePath}:\n${lines.join("\n")}`);
-		this.name = "ConfigValidationError";
-	}
-};
-//#endregion
-//#region src/utils.ts
-/** Normalize a single string or array of strings to an array. Returns undefined for empty arrays. */
-function toArray(value) {
-	if (value === void 0) return void 0;
-	const arr = Array.isArray(value) ? [...value] : [value];
-	return arr.length > 0 ? arr : void 0;
-}
-/** Try to parse an ArrayBuffer as JSON. Returns undefined on failure or empty body. */
-function tryParseBody(raw) {
-	if (raw.byteLength === 0) return void 0;
-	try {
-		return JSON.parse(new TextDecoder().decode(raw));
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/config.ts
-const DEFAULT_CONFIG = {
-	host: "0.0.0.0",
-	port: 8080,
-	openrouterKey: "",
-	openrouterBaseUrl: "https://openrouter.ai/api/v1",
-	verbose: false,
-	bodyLimit: "50mb",
-	attributionReferer: "http://localhost",
-	attributionTitle: "proxitor"
-};
-/** Fields that need toArray normalization (string | string[] → string[] | undefined) */
-const ARRAY_FIELDS = [
-	{
-		key: "only",
-		apiName: "only"
-	},
-	{
-		key: "order",
-		apiName: "order"
-	},
-	{
-		key: "ignore",
-		apiName: "ignore"
-	},
-	{
-		key: "quantizations",
-		apiName: "quantizations"
-	}
-];
-/** Direct camelCase → snake_case field mappings */
-const DIRECT_FIELDS = [
-	{
-		key: "sort",
-		apiName: "sort"
-	},
-	{
-		key: "maxPrice",
-		apiName: "max_price"
-	},
-	{
-		key: "requireParameters",
-		apiName: "require_parameters"
-	},
-	{
-		key: "dataCollection",
-		apiName: "data_collection"
-	},
-	{
-		key: "zdr",
-		apiName: "zdr"
-	},
-	{
-		key: "enforceDistillableText",
-		apiName: "enforce_distillable_text"
-	},
-	{
-		key: "preferredMinThroughput",
-		apiName: "preferred_min_throughput"
-	},
-	{
-		key: "preferredMaxLatency",
-		apiName: "preferred_max_latency"
-	}
-];
-/** Build the provider routing object for OpenRouter request body injection */
-function buildProviderRouting(provider) {
-	if (!provider) return void 0;
-	const result = {};
-	for (const { key, apiName } of ARRAY_FIELDS) {
-		const value = provider[key];
-		if (value !== void 0) {
-			const normalized = toArray(value);
-			if (normalized) result[apiName] = normalized;
-		}
-	}
-	for (const { key, apiName } of DIRECT_FIELDS) {
-		const value = provider[key];
-		if (value !== void 0) result[apiName] = value;
-	}
-	if (result.order) result.allow_fallbacks = provider.allowFallbacks ?? true;
-	return Object.keys(result).length > 0 ? result : void 0;
-}
-/** Score a pattern against a model name. Higher = better match. -1 = no match. */
-function matchScore(pattern, modelName) {
-	if (pattern === modelName) return modelName.length + 1e3;
-	if (pattern.endsWith("*") && modelName.startsWith(pattern.slice(0, -1))) return pattern.length;
-	return -1;
-}
-/** Resolve the effective config for a given model by merging global defaults with the best-matching override */
-function resolveModelConfig(config, modelName) {
-	const result = {
-		provider: config.provider,
-		headers: config.headers ? { ...config.headers } : void 0
-	};
-	if (!modelName || !config.modelOverrides) return result;
-	let bestPattern = null;
-	let bestScore = -1;
-	for (const pattern of Object.keys(config.modelOverrides)) {
-		const score = matchScore(pattern, modelName);
-		if (score > bestScore) {
-			bestScore = score;
-			bestPattern = pattern;
-		}
-	}
-	if (bestPattern) {
-		const override = config.modelOverrides[bestPattern];
-		if (override?.provider !== void 0) result.provider = override.provider;
-		if (override?.headers) result.headers = {
-			...result.headers ?? {},
-			...override.headers
-		};
-	}
-	return result;
-}
-async function loadConfig(options) {
-	const config = { ...DEFAULT_CONFIG };
-	if (!options.noConfig) {
-		const configPath = findConfigFile(options.configPath);
-		if (configPath) {
-			const fileConfig = readConfigFile(configPath);
-			Object.assign(config, fileConfig);
-		}
-	}
-	if (options.host) config.host = options.host;
-	if (options.port) config.port = options.port;
-	if (options.verbose) config.verbose = options.verbose;
-	if (options.openrouterKey) config.openrouterKey = options.openrouterKey;
-	else if (!config.openrouterKey) config.openrouterKey = process.env.OPENROUTER_API_KEY ?? "";
-	if (!config.openrouterKey) throw new Error("OpenRouter API key is required. Set OPENROUTER_API_KEY env var, pass --openrouter-key flag, or set it in config file.");
-	return config;
-}
-/** Resolve XDG config directory: $XDG_CONFIG_HOME/proxitor or ~/.config/proxitor */
-function getXdgConfigDir() {
-	const xdgHome = process.env.XDG_CONFIG_HOME;
-	return xdgHome ? (0, node_path.resolve)(xdgHome, "proxitor") : (0, node_path.join)((0, node_os.homedir)(), ".config", "proxitor");
-}
-function findConfigFile(explicitPath) {
-	if (explicitPath) {
-		if (!(0, node_fs.existsSync)(explicitPath)) throw new Error(`Config file not found: ${explicitPath}`);
-		return (0, node_path.resolve)(explicitPath);
-	}
-	for (const candidate of [
-		"proxitor.config.yaml",
-		"proxitor.config.yml",
-		"proxitor.config.json",
-		".proxitor.yaml",
-		".proxitor.yml",
-		".proxitor.json"
-	]) {
-		const fullPath = (0, node_path.resolve)(candidate);
-		if ((0, node_fs.existsSync)(fullPath)) return fullPath;
-	}
-	const xdgDir = getXdgConfigDir();
-	for (const candidate of [
-		"config.yaml",
-		"config.yml",
-		"config.json"
-	]) {
-		const fullPath = (0, node_path.join)(xdgDir, candidate);
-		if ((0, node_fs.existsSync)(fullPath)) return fullPath;
-	}
-	return null;
-}
-function readConfigFile(filePath) {
-	const content = (0, node_fs.readFileSync)(filePath, "utf-8");
-	let raw;
-	try {
-		raw = filePath.endsWith(".json") ? JSON.parse(content) : js_yaml.load(content);
-	} catch (err) {
-		throw new ConfigParseError(filePath, err instanceof Error ? err : void 0);
-	}
-	const result = proxyConfigFileSchema.safeParse(raw);
-	if (!result.success) throw new ConfigValidationError(filePath, result.error);
-	return result.data;
-}
-//#endregion
-//#region src/logger.ts
-const logger = consola.consola.withTag("proxitor");
-//#endregion
-//#region src/proxy/headers.ts
-const HOP_BY_HOP = new Set([
-	"connection",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade"
-]);
-/** Headers to strip from client request before forwarding */
-const STRIP_REQUEST = new Set([
-	"authorization",
-	"x-api-key",
-	"host",
-	"content-length"
-]);
-/** Headers to strip from upstream response before forwarding */
-const STRIP_RESPONSE = new Set(["content-length", "content-encoding"]);
-/** Filter headers by removing hop-by-hop and an additional blocklist */
-function filterHeaders(incoming, blocklist) {
-	const headers = {};
-	for (const [key, value] of incoming.entries()) {
-		const lower = key.toLowerCase();
-		if (HOP_BY_HOP.has(lower)) continue;
-		if (blocklist.has(lower)) continue;
-		headers[key] = value;
-	}
-	return headers;
-}
-/** Build request headers for upstream fetch */
-function buildRequestHeaders(incoming, config, inject, extraHeaders) {
-	const headers = filterHeaders(incoming, STRIP_REQUEST);
-	headers.Authorization = `Bearer ${config.openrouterKey}`;
-	headers["HTTP-Referer"] = config.attributionReferer;
-	headers["X-Title"] = config.attributionTitle;
-	headers["Accept-Encoding"] = "identity";
-	if (extraHeaders) Object.assign(headers, extraHeaders);
-	if (inject) headers["Content-Type"] = "application/json";
-	return headers;
-}
-/** Filter response headers and add SSE-friendly defaults */
-function buildResponseHeaders(from) {
-	const headers = filterHeaders(from, STRIP_RESPONSE);
-	headers["Cache-Control"] = "no-cache";
-	headers["X-Accel-Buffering"] = "no";
-	return headers;
-}
-//#endregion
-//#region src/proxy/inject.ts
-/** Extract the model name from a raw request body. Returns undefined if not parseable or absent. */
-function extractModel(rawBody) {
-	const json = tryParseBody(rawBody);
-	return typeof json?.model === "string" ? json.model : void 0;
-}
-/** Inject provider routing into request body, always overwriting existing value */
-function injectProvider(rawBody, providerRouting) {
-	if (rawBody.byteLength === 0) throw new Error("Request body is empty; cannot inject provider");
-	let json;
-	try {
-		json = JSON.parse(new TextDecoder().decode(rawBody));
-	} catch (parseError) {
-		throw new Error("Request body is not valid JSON; cannot inject provider", { cause: parseError });
-	}
-	const modified = {
-		...json,
-		provider: providerRouting
-	};
-	return new TextEncoder().encode(JSON.stringify(modified)).buffer;
-}
-//#endregion
-//#region src/proxy/paths.ts
-/**
-* Paths where provider routing is injected into the request body.
-* All three are OpenRouter-supported endpoints:
-*   /v1/chat/completions — OpenAI Chat Completions
-*   /v1/responses        — OpenAI Responses API
-*   /v1/messages         — Anthropic Messages API
-*/
-const INJECT_PATHS = new Set([
-	"/v1/chat/completions",
-	"/v1/responses",
-	"/v1/messages"
-]);
-/** Check if this request should have provider routing injected */
-function shouldInject(method, path) {
-	return method === "POST" && INJECT_PATHS.has(path);
-}
-/** Strip /v1 prefix from path: /v1/chat/completions → /chat/completions */
-function toUpstreamPath(pathname) {
-	if (pathname.startsWith("/v1")) return pathname.slice(3);
-	return pathname;
-}
-/** Build full upstream URL from request and config */
-function buildUpstreamUrl(requestUrl, config) {
-	const { pathname } = new URL(requestUrl);
-	return `${config.openrouterBaseUrl}${toUpstreamPath(pathname)}`;
-}
-//#endregion
-//#region src/proxy.ts
-function readRequestBody(method, raw, inject, providerRouting) {
-	if (["GET", "HEAD"].includes(method)) return void 0;
-	if (inject) return injectProvider(raw, providerRouting);
-	return raw.byteLength > 0 ? raw : void 0;
-}
-async function fetchUpstream(url, method, headers, body, signal) {
-	return fetch(url, {
-		method,
-		headers,
-		body,
-		signal,
-		duplex: body ? "half" : void 0
-	});
-}
-function buildUpstreamResponse(upstream, method) {
-	const headers = buildResponseHeaders(upstream.headers);
-	if (method === "HEAD" || !upstream.body) return new Response(null, {
-		status: upstream.status,
-		headers
-	});
-	return new Response(upstream.body, {
-		status: upstream.status,
-		headers
-	});
-}
-/** Read and process the request body, returning an error response on failure */
-async function readRawBody(request) {
-	try {
-		return {
-			ok: true,
-			body: await request.arrayBuffer()
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : "Failed to read request body";
-		logger.error(message);
-		return {
-			ok: false,
-			response: Response.json({ error: {
-				message,
-				type: "proxy_request_error"
-			} }, { status: 400 })
-		};
-	}
-}
-/** Resolve per-request config: extract model, resolve overrides, build routing and body */
-function resolveRequest(rawBody, config, method, path) {
-	const modelName = extractModel(rawBody);
-	const resolved = resolveModelConfig(config, modelName);
-	const providerRouting = buildProviderRouting(resolved.provider);
-	const inject = shouldInject(method, path) && providerRouting !== void 0;
-	let body;
-	try {
-		body = readRequestBody(method, rawBody, inject, providerRouting);
-	} catch (err) {
-		const message = err instanceof Error ? err.message : "Failed to process request body";
-		logger.error(message);
-		return {
-			inject,
-			body: void 0,
-			modelName,
-			headers: resolved.headers,
-			error: new Response(JSON.stringify({ error: {
-				message,
-				type: "proxy_request_error"
-			} }), {
-				status: 400,
-				headers: { "Content-Type": "application/json" }
-			})
-		};
-	}
-	return {
-		inject,
-		body,
-		modelName,
-		headers: resolved.headers
-	};
-}
-/** Execute upstream fetch, returning appropriate error responses on failure */
-async function executeUpstream(upstreamUrl, method, headers, body, signal, path, startedAt) {
-	let upstream;
-	try {
-		upstream = await fetchUpstream(upstreamUrl, method, headers, body, signal);
-	} catch (err) {
-		if (err instanceof DOMException && err.name === "AbortError") {
-			logger.warn(`Aborted: ${method} ${path}`);
-			return new Response(null, { status: 499 });
-		}
-		logger.error("Upstream fetch error:", err);
-		return Response.json({ error: {
-			message: "Proxy failed to reach upstream",
-			type: "proxy_upstream_error"
-		} }, { status: 502 });
-	}
-	logger.info(`${method} ${path} ← ${upstream.status} (${Date.now() - startedAt}ms)`);
-	return buildUpstreamResponse(upstream, method);
-}
-function createProxyServer(config, onReady) {
-	const app = new hono.Hono();
-	app.get("/health", (c) => {
-		const globalRouting = buildProviderRouting(config.provider);
-		return c.json({
-			ok: true,
-			upstream: config.openrouterBaseUrl,
-			provider: globalRouting ?? "not configured",
-			modelOverrides: config.modelOverrides ? Object.keys(config.modelOverrides) : []
-		});
-	});
-	app.all("*", async (c) => {
-		const method = c.req.method;
-		const path = new URL(c.req.url).pathname;
-		const upstreamUrl = buildUpstreamUrl(c.req.url, config);
-		const startedAt = Date.now();
-		const raw = await readRawBody(c.req.raw);
-		if (!raw.ok) return raw.response;
-		const resolved = resolveRequest(raw.body, config, method, path);
-		if (resolved.error) return resolved.error;
-		const headers = buildRequestHeaders(c.req.raw.headers, config, resolved.inject, resolved.headers);
-		const controller = new AbortController();
-		c.req.raw.signal.addEventListener("abort", () => controller.abort());
-		const modelLog = resolved.modelName ? ` model=${resolved.modelName}` : "";
-		logger.info(`${method} ${path} → ${upstreamUrl}${resolved.inject ? " [inject]" : ""}${modelLog}`);
-		return executeUpstream(upstreamUrl, method, headers, resolved.body, controller.signal, path, startedAt);
-	});
-	return (0, _hono_node_server.serve)({
-		fetch: app.fetch,
-		port: config.port,
-		hostname: config.host
-	}, onReady);
-}
-/** Shutdown deadline: force-close after this many ms */
-const SHUTDOWN_TIMEOUT_MS = 1e4;
-/** Start the proxy with graceful shutdown on SIGTERM/SIGINT */
-function startProxyServer(config, onReady) {
-	const server = createProxyServer(config, onReady);
-	let shuttingDown = false;
-	function shutdown(signal) {
-		if (shuttingDown) return;
-		shuttingDown = true;
-		logger.info(`${signal} received — draining active connections…`);
-		const timer = setTimeout(() => {
-			logger.warn("Forcing shutdown — drain timeout exceeded");
-			process.exit(1);
-		}, SHUTDOWN_TIMEOUT_MS);
-		server.close(() => {
-			clearTimeout(timer);
-			logger.info("All connections drained — goodbye");
-			process.exit(0);
-		});
-	}
-	process.on("SIGTERM", () => shutdown("SIGTERM"));
-	process.on("SIGINT", () => shutdown("SIGINT"));
-	return server;
-}
-//#endregion
-Object.defineProperty(exports, "ConfigParseError", {
-	enumerable: true,
-	get: function() {
-		return ConfigParseError;
-	}
-});
-Object.defineProperty(exports, "ConfigValidationError", {
-	enumerable: true,
-	get: function() {
-		return ConfigValidationError;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "buildProviderRouting", {
-	enumerable: true,
-	get: function() {
-		return buildProviderRouting;
-	}
-});
-Object.defineProperty(exports, "createProxyServer", {
-	enumerable: true,
-	get: function() {
-		return createProxyServer;
-	}
-});
-Object.defineProperty(exports, "extractModel", {
-	enumerable: true,
-	get: function() {
-		return extractModel;
-	}
-});
-Object.defineProperty(exports, "findConfigFile", {
-	enumerable: true,
-	get: function() {
-		return findConfigFile;
-	}
-});
-Object.defineProperty(exports, "loadConfig", {
-	enumerable: true,
-	get: function() {
-		return loadConfig;
-	}
-});
-Object.defineProperty(exports, "logger", {
-	enumerable: true,
-	get: function() {
-		return logger;
-	}
-});
-Object.defineProperty(exports, "matchScore", {
-	enumerable: true,
-	get: function() {
-		return matchScore;
-	}
-});
-Object.defineProperty(exports, "readConfigFile", {
-	enumerable: true,
-	get: function() {
-		return readConfigFile;
-	}
-});
-Object.defineProperty(exports, "resolveModelConfig", {
-	enumerable: true,
-	get: function() {
-		return resolveModelConfig;
-	}
-});
-Object.defineProperty(exports, "startProxyServer", {
-	enumerable: true,
-	get: function() {
-		return startProxyServer;
-	}
-});
-Object.defineProperty(exports, "toArray", {
-	enumerable: true,
-	get: function() {
-		return toArray;
-	}
-});
-Object.defineProperty(exports, "tryParseBody", {
-	enumerable: true,
-	get: function() {
-		return tryParseBody;
-	}
-});
-
-//# sourceMappingURL=proxy.cjs.map