@archimonde12/llm-proxy 1.0.0

package/dist/cli/commands/doctor.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const commander_1 = require("commander");
+const load_1 = require("../../config/load");
+const node_net_1 = __importDefault(require("node:net"));
+async function checkPortFree(host, port) {
+    return await new Promise((resolve) => {
+        const srv = node_net_1.default
+            .createServer()
+            .once("error", () => resolve(false))
+            .once("listening", () => srv.close(() => resolve(true)))
+            .listen(port, host);
+    });
+}
+async function pingUrl(url, timeoutMs) {
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { method: "GET", signal: controller.signal });
+        return { ok: res.ok, status: res.status };
+    }
+    catch (err) {
+        return { ok: false, status: 0, error: err?.message ?? String(err) };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+async function checkUpstreams(modelsFile) {
+    const results = [];
+    for (const m of modelsFile.models) {
+        const base = m.baseUrl.replace(/\/+$/, "");
+        const r = await pingUrl(base, Math.min(m.timeoutMs ?? 1500, 5000));
+        results.push({
+            id: m.id,
+            baseUrl: base,
+            ok: r.ok,
+            detail: r.ok ? `HTTP ${r.status}` : r.error ? `ERROR ${r.error}` : `HTTP ${r.status}`,
+        });
+    }
+    return results;
+}
+function doctorCommand() {
+    const cmd = new commander_1.Command("doctor");
+    cmd
+        .description("Run quick diagnostics (config parse, port check, upstream reachability).")
+        .option("--models <path>", "Path to models.json")
+        .option("--host <host>", "Host to bind for port check (default: 127.0.0.1)")
+        .option("--port <port>", "Port to check (default: 8787)")
+        .option("--deep", "Ping upstream baseUrl for each model", false)
+        .action(async (opts) => {
+        const host = String(opts.host ?? "127.0.0.1");
+        const port = Number(opts.port ?? 8787);
+        let modelsFile;
+        let sourcePath;
+        try {
+            const loaded = await (0, load_1.loadModelsFile)({
+                cliFlagPath: opts.models,
+                envPath: process.env.MODELS_PATH,
+            });
+            modelsFile = loaded.modelsFile;
+            sourcePath = loaded.source.path;
+            if (loaded.createdDefaultFile) {
+                // eslint-disable-next-line no-console
+                console.log(`note: created starter models.json (example Ollama model) at ${sourcePath}`);
+            }
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error((0, load_1.formatConfigError)(err));
+            process.exitCode = 1;
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(`config: OK (${sourcePath})`);
+        const portFree = await checkPortFree(host, port);
+        // eslint-disable-next-line no-console
+        console.log(`port: ${host}:${port} ${portFree ? "available" : "IN USE"}`);
+        const warnings = [];
+        const ids = new Set();
+        for (const m of modelsFile.models) {
+            if (ids.has(m.id))
+                warnings.push(`duplicate id: ${m.id}`);
+            ids.add(m.id);
+            if (!/^https?:\/\//.test(m.baseUrl))
+                warnings.push(`baseUrl missing protocol for ${m.id}: ${m.baseUrl}`);
+        }
+        for (const w of warnings) {
+            // eslint-disable-next-line no-console
+            console.warn(`warn: ${w}`);
+        }
+        if (opts.deep) {
+            const upstreams = await checkUpstreams(modelsFile);
+            for (const u of upstreams) {
+                // eslint-disable-next-line no-console
+                console.log(`upstream: ${u.id} ${u.baseUrl} ${u.ok ? "OK" : "FAIL"} (${u.detail})`);
+            }
+            if (upstreams.some((u) => !u.ok))
+                process.exitCode = 1;
+        }
+    });
+    return cmd;
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const commander_1 = require("commander");
+const prompts_1 = __importDefault(require("prompts"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const defaultModelsFile_1 = require("../../config/defaultModelsFile");
+const paths_1 = require("../../config/paths");
+function defaultModelsTemplate(args) {
+    const file = (0, defaultModelsFile_1.createDefaultModelsFile)();
+    if (args.includeOpenAICompatible) {
+        file.models.push({
+            id: "openai-compatible",
+            adapter: "openai_compatible",
+            baseUrl: "http://localhost:8000",
+            model: "your-model-name",
+        });
+    }
+    return file;
+}
+function initCommand() {
+    const cmd = new commander_1.Command("init");
+    cmd
+        .description("Create a starter models.json config (wizard if interactive).")
+        .option("--file <path>", "Where to write the config")
+        .option("-y, --yes", "Non-interactive (use defaults)", false)
+        .action(async (opts) => {
+        const isInteractive = Boolean(process.stdin.isTTY && !opts.yes);
+        const defaultPath = (await (0, paths_1.fileExists)((0, paths_1.defaultProjectModelsPath)()))
+            ? (0, paths_1.defaultUserModelsPath)()
+            : (0, paths_1.defaultProjectModelsPath)();
+        const targetPath = node_path_1.default.resolve(opts.file ?? defaultPath);
+        let includeOpenAICompatible = true;
+        if (isInteractive) {
+            const answers = await (0, prompts_1.default)([
+                {
+                    type: "confirm",
+                    name: "includeOpenAICompatible",
+                    message: "Include an OpenAI-compatible upstream example?",
+                    initial: true,
+                },
+            ], {
+                onCancel: () => {
+                    process.exitCode = 1;
+                    throw new Error("Cancelled");
+                },
+            });
+            includeOpenAICompatible = Boolean(answers.includeOpenAICompatible);
+        }
+        const content = JSON.stringify(defaultModelsTemplate({ includeOpenAICompatible }), null, 2);
+        await (0, paths_1.ensureParentDir)(targetPath);
+        await promises_1.default.writeFile(targetPath, content + "\n", { encoding: "utf8", flag: "wx" }).catch(async (err) => {
+            if (err?.code === "EEXIST") {
+                throw new Error(`Refusing to overwrite existing file: ${targetPath}`);
+            }
+            throw err;
+        });
+        // eslint-disable-next-line no-console
+        console.log(`Wrote config to ${targetPath}`);
+        // eslint-disable-next-line no-console
+        console.log(`Next: llm-proxy start --models "${targetPath}"`);
+    });
+    return cmd;
+}

package/dist/cli/commands/start.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCommand = startCommand;
+const commander_1 = require("commander");
+const server_1 = require("../../server");
+const load_1 = require("../../config/load");
+const startupLog_1 = require("../../startupLog");
+function startCommand() {
+    const cmd = new commander_1.Command("start");
+    cmd
+        .description("Start the llm-proxy server.")
+        .option("--models <path>", "Path to models.json")
+        .option("--port <port>", "Port to listen on (default: 8787)")
+        .option("--host <host>", "Host to bind (default: 127.0.0.1)")
+        .action(async (opts) => {
+        const port = Number(opts.port ?? process.env.PORT ?? 8787);
+        const host = String(opts.host ?? process.env.HOST ?? "127.0.0.1");
+        const loaded = await (0, load_1.loadModelsFile)({
+            cliFlagPath: opts.models,
+            envPath: process.env.MODELS_PATH,
+        }).catch((err) => {
+            throw new Error((0, load_1.formatConfigError)(err));
+        });
+        (0, startupLog_1.logStartupPreamble)({
+            nodeVersion: process.version,
+            nodeEnv: process.env.NODE_ENV ?? "development",
+            host,
+            port,
+            modelsPath: loaded.source.path,
+            modelsSourceKind: loaded.source.kind,
+            createdDefaultModelsFile: loaded.createdDefaultFile,
+        });
+        const app = await (0, server_1.buildServer)({ bindHost: host, initial: loaded });
+        const address = await app.listen({ port, host });
+        (0, startupLog_1.logListenBanner)({ address: String(address), port });
+    });
+    return cmd;
+}

package/dist/cli/commands/status.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const commander_1 = require("commander");
+function statusCommand() {
+    const cmd = new commander_1.Command("status");
+    cmd
+        .description("Check server health (GET /healthz).")
+        .option("--url <baseUrl>", "Base URL of llm-proxy (default: http://127.0.0.1:8787)")
+        .action(async (opts) => {
+        const baseUrl = (opts.url ?? "http://127.0.0.1:8787").replace(/\/+$/, "");
+        const res = await fetch(`${baseUrl}/healthz`, {
+            method: "GET",
+            headers: { accept: "application/json" },
+        });
+        const body = await res.text();
+        // eslint-disable-next-line no-console
+        console.log(`status=${res.status} url=${baseUrl}/healthz`);
+        // eslint-disable-next-line no-console
+        console.log(body);
+    });
+    return cmd;
+}

package/dist/cli/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const start_1 = require("./commands/start");
+const status_1 = require("./commands/status");
+const doctor_1 = require("./commands/doctor");
+const config_1 = require("./commands/config");
+async function runCli(argv = process.argv) {
+    const program = new commander_1.Command();
+    program
+        .name("llm-proxy")
+        .description("A lightweight proxy to route requests to local LLMs via an OpenAI-compatible API.")
+        .version(process.env.npm_package_version ?? "0.0.0");
+    program.addCommand((0, init_1.initCommand)());
+    program.addCommand((0, start_1.startCommand)());
+    program.addCommand((0, status_1.statusCommand)());
+    program.addCommand((0, doctor_1.doctorCommand)());
+    program.addCommand((0, config_1.configCommand)());
+    await program.parseAsync(argv);
+}

package/dist/config/defaultModelsFile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultModelsFile = createDefaultModelsFile;
+/** Minimal valid config used by `llm-proxy init -y` and auto-create on first start. */
+function createDefaultModelsFile() {
+    return {
+        models: [
+            {
+                id: "ollama-llama3",
+                adapter: "ollama",
+                baseUrl: "http://localhost:11434",
+                model: "llama3",
+            },
+        ],
+    };
+}

package/dist/config/load.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidationError = void 0;
+exports.resolveModelsPath = resolveModelsPath;
+exports.resolveExistingModelsPath = resolveExistingModelsPath;
+exports.loadModelsFileFromPath = loadModelsFileFromPath;
+exports.loadModelsFileFromPathAsStored = loadModelsFileFromPathAsStored;
+exports.loadModelsFile = loadModelsFile;
+exports.isConfigValidationError = isConfigValidationError;
+exports.formatConfigError = formatConfigError;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const defaultModelsFile_1 = require("./defaultModelsFile");
+const paths_1 = require("./paths");
+const schema_1 = require("./schema");
+function resolveModelsPath(input) {
+    const cliFlagPath = input?.cliFlagPath?.trim();
+    if (cliFlagPath) {
+        return { kind: "cli_flag", path: node_path_1.default.resolve(cliFlagPath) };
+    }
+    const envPath = input?.envPath?.trim();
+    if (envPath) {
+        return { kind: "env", path: node_path_1.default.resolve(envPath) };
+    }
+    const project = (0, paths_1.defaultProjectModelsPath)(input?.cwd);
+    return { kind: "project_default", path: project };
+}
+async function resolveExistingModelsPath(input) {
+    const resolved = resolveModelsPath(input);
+    if (resolved.kind === "project_default") {
+        if (await (0, paths_1.fileExists)(resolved.path))
+            return resolved;
+        // Check canonical user path first, then legacy (backward compat)
+        const canonical = (0, paths_1.canonicalUserModelsPath)();
+        if (await (0, paths_1.fileExists)(canonical))
+            return { kind: "user_default", path: canonical };
+        const legacy = (0, paths_1.legacyUserModelsPath)();
+        if (await (0, paths_1.fileExists)(legacy))
+            return { kind: "user_default", path: legacy };
+        return { kind: "user_default", path: canonical };
+    }
+    return resolved;
+}
+class ConfigValidationError extends Error {
+    issues;
+    filePath;
+    constructor(args) {
+        super(`Invalid config at ${args.filePath}\n` +
+            args.issues.map((i) => `- ${i.path}: ${i.message}`).join("\n"));
+        this.name = "ConfigValidationError";
+        this.issues = args.issues;
+        this.filePath = args.filePath;
+    }
+}
+exports.ConfigValidationError = ConfigValidationError;
+function zodPathToString(p) {
+    if (p.length === 0)
+        return "<root>";
+    let out = "";
+    for (const seg of p) {
+        if (typeof seg === "number")
+            out += `[${seg}]`;
+        else
+            out += out ? `.${seg}` : seg;
+    }
+    return out;
+}
+async function loadModelsFileFromPath(filePath) {
+    let raw;
+    try {
+        raw = await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        const e = new Error(`Failed to read models file at ${filePath}: ${err?.message ?? String(err)}`);
+        e.statusCode = 500;
+        throw e;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new ConfigValidationError({
+            filePath,
+            issues: [{ path: "<file>", message: `Invalid JSON: ${err?.message ?? String(err)}` }],
+        });
+    }
+    // Allow secrets to be referenced as ${ENV_VAR} in config without committing raw keys.
+    // If the env var is missing, the field is removed so validation can still succeed.
+    if (parsed && typeof parsed === "object") {
+        const maybeModels = parsed.models;
+        if (Array.isArray(maybeModels)) {
+            for (const m of maybeModels) {
+                if (!m || typeof m !== "object")
+                    continue;
+                const ak = m.apiKey;
+                if (typeof ak === "string") {
+                    const match = /^\$\{([A-Z0-9_]+)\}$/.exec(ak.trim());
+                    if (match) {
+                        const envName = match[1];
+                        const envVal = process.env[envName];
+                        if (typeof envVal === "string" && envVal.trim())
+                            m.apiKey = envVal.trim();
+                        else
+                            delete m.apiKey;
+                    }
+                }
+            }
+        }
+    }
+    const res = schema_1.ModelsFileSchema.safeParse(parsed);
+    if (!res.success) {
+        throw new ConfigValidationError({
+            filePath,
+            issues: res.error.issues.map((i) => ({
+                path: zodPathToString(i.path.map((seg) => typeof seg === "symbol" ? String(seg) : seg)),
+                message: i.message,
+            })),
+        });
+    }
+    return res.data;
+}
+/**
+ * Same as {@link loadModelsFileFromPath} but does not substitute `${ENV_VAR}` in apiKey.
+ * Use for admin UI so secrets stay referenced as in models.json.
+ */
+async function loadModelsFileFromPathAsStored(filePath) {
+    let raw;
+    try {
+        raw = await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        const e = new Error(`Failed to read models file at ${filePath}: ${err?.message ?? String(err)}`);
+        e.statusCode = 500;
+        throw e;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new ConfigValidationError({
+            filePath,
+            issues: [{ path: "<file>", message: `Invalid JSON: ${err?.message ?? String(err)}` }],
+        });
+    }
+    const res = schema_1.ModelsFileSchema.safeParse(parsed);
+    if (!res.success) {
+        throw new ConfigValidationError({
+            filePath,
+            issues: res.error.issues.map((i) => ({
+                path: zodPathToString(i.path.map((seg) => typeof seg === "symbol" ? String(seg) : seg)),
+                message: i.message,
+            })),
+        });
+    }
+    return res.data;
+}
+async function ensureMockModelsFileAtPath(filePath) {
+    if (await (0, paths_1.fileExists)(filePath))
+        return false;
+    await (0, paths_1.ensureParentDir)(filePath);
+    const body = JSON.stringify((0, defaultModelsFile_1.createDefaultModelsFile)(), null, 2) + "\n";
+    await promises_1.default.writeFile(filePath, body, "utf8");
+    return true;
+}
+async function loadModelsFile(input) {
+    const cwd = input?.cwd ?? process.cwd();
+    const cliFlagPath = input?.cliFlagPath?.trim();
+    const envPath = input?.envPath?.trim();
+    let source;
+    let createdDefaultFile = false;
+    if (cliFlagPath) {
+        const p = node_path_1.default.resolve(cliFlagPath);
+        createdDefaultFile = await ensureMockModelsFileAtPath(p);
+        source = { kind: "cli_flag", path: p };
+    }
+    else if (envPath) {
+        const p = node_path_1.default.resolve(envPath);
+        createdDefaultFile = await ensureMockModelsFileAtPath(p);
+        source = { kind: "env", path: p };
+    }
+    else {
+        const project = (0, paths_1.defaultProjectModelsPath)(cwd);
+        if (await (0, paths_1.fileExists)(project)) {
+            source = { kind: "project_default", path: project };
+        }
+        else {
+            // Resolve order: canonical user path → legacy user path → create at project path
+            const canonical = (0, paths_1.canonicalUserModelsPath)();
+            if (await (0, paths_1.fileExists)(canonical)) {
+                source = { kind: "user_default", path: canonical };
+            }
+            else {
+                const legacy = (0, paths_1.legacyUserModelsPath)();
+                if (await (0, paths_1.fileExists)(legacy)) {
+                    source = { kind: "user_default", path: legacy };
+                }
+                else {
+                    createdDefaultFile = await ensureMockModelsFileAtPath(project);
+                    source = { kind: "project_default", path: project };
+                }
+            }
+        }
+    }
+    const modelsFile = await loadModelsFileFromPath(source.path);
+    return { modelsFile, source, createdDefaultFile };
+}
+function isConfigValidationError(err) {
+    return err instanceof ConfigValidationError;
+}
+function formatConfigError(err) {
+    if (isConfigValidationError(err))
+        return err.message;
+    if (err && typeof err === "object" && "message" in err)
+        return String(err.message);
+    return String(err);
+}

package/dist/config/mergeHeaders.js

@@ -0,0 +1,33 @@
+"use strict";
+// Explanation of this code:
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeModelOutboundHeaders = mergeModelOutboundHeaders;
+/**
+ * This function merges outbound headers for upstream model API calls.
+ *
+ * - The input is a config object with: apiKey (an optional token string),
+ *   apiKeyHeader (the header name to use for the key, if custom), and headers (an object of additional custom headers).
+ * - If apiKey is present:
+ *    + If apiKeyHeader is unset, or is "authorization" (case-insensitive), it sets the "Authorization" header as "Bearer <apiKey>".
+ *    + Otherwise, it sets a header with the name specified in apiKeyHeader (lowercased), with its value exactly apiKey (no "Bearer" prefix).
+ * - Then, any additional key-value pairs from config.headers (if present) are merged in, overwriting previous values for the same key.
+ * - Returns the merged headers object, or undefined if there are no headers to send.
+ */
+function mergeModelOutboundHeaders(cfg) {
+    const out = {};
+    // Handle apiKey (if present) and determine the authentication header to add
+    const key = typeof cfg.apiKey === "string" ? cfg.apiKey.trim() : "";
+    if (key) {
+        const rawName = typeof cfg.apiKeyHeader === "string" ? cfg.apiKeyHeader.trim() : "";
+        if (!rawName || /^authorization$/i.test(rawName)) {
+            out.authorization = `Bearer ${key}`;
+        }
+        else {
+            out[rawName.toLowerCase()] = key;
+        }
+    }
+    // Merge in any custom headers from config.headers (if present)
+    const merged = { ...out, ...(cfg.headers ?? {}) };
+    // If any headers are set, return the object; otherwise, return undefined
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}

package/dist/config/paths.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultProjectModelsPath = defaultProjectModelsPath;
+exports.canonicalUserModelsPath = canonicalUserModelsPath;
+exports.legacyUserModelsPath = legacyUserModelsPath;
+exports.defaultUserModelsPath = defaultUserModelsPath;
+exports.fileExists = fileExists;
+exports.ensureParentDir = ensureParentDir;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+function defaultProjectModelsPath(cwd = process.cwd()) {
+    return node_path_1.default.resolve(cwd, "models.json");
+}
+/** Canonical user-level config path: ~/.config/llm-proxy/models.json */
+function canonicalUserModelsPath() {
+    return node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "llm-proxy", "models.json");
+}
+/**
+ * Legacy user-level config path kept for backward compatibility with
+ * installs that used the old package name "llm-open-gateway".
+ * ~/.config/llm-open-gateway/models.json
+ */
+function legacyUserModelsPath() {
+    return node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "llm-open-gateway", "models.json");
+}
+/** @deprecated Use {@link canonicalUserModelsPath} instead. */
+function defaultUserModelsPath() {
+    return canonicalUserModelsPath();
+}
+async function fileExists(p) {
+    try {
+        await promises_1.default.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureParentDir(filePath) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+}

package/dist/config/schema.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelsFileSchema = exports.ModelConfigSchema = exports.ModelAdapterTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.ModelAdapterTypeSchema = zod_1.z.enum(["ollama", "openai_compatible", "deepseek"]);
+exports.ModelConfigSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1, "Required"),
+    adapter: exports.ModelAdapterTypeSchema,
+    baseUrl: zod_1.z
+        .string()
+        .min(1, "Required")
+        .refine((v) => {
+        try {
+            // eslint-disable-next-line no-new
+            new URL(v);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, { message: "Invalid URL (must include protocol, e.g. http://localhost:11434)" }),
+    model: zod_1.z.string().min(1, "Required"),
+    apiKey: zod_1.z.string().min(1).optional(),
+    apiKeyHeader: zod_1.z.string().min(1).optional(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    timeoutMs: zod_1.z.number().int().positive().optional(),
+})
+    .superRefine((val, ctx) => {
+    if (val.apiKeyHeader && !val.apiKey) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["apiKey"],
+            message: "Required when apiKeyHeader is set",
+        });
+    }
+});
+exports.ModelsFileSchema = zod_1.z
+    .object({
+    models: zod_1.z.array(exports.ModelConfigSchema).min(1, "Must include at least 1 model"),
+})
+    .superRefine((val, ctx) => {
+    const seen = new Map();
+    for (let i = 0; i < val.models.length; i++) {
+        const id = val.models[i]?.id;
+        if (!id)
+            continue;
+        const prev = seen.get(id);
+        if (prev !== undefined) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ["models", i, "id"],
+                message: `Duplicate id '${id}' (also at models[${prev}].id)`,
+            });
+        }
+        else {
+            seen.set(id, i);
+        }
+    }
+});

package/dist/config.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModelsFile = loadModelsFile;
+exports.resolveModelConfig = resolveModelConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const load_1 = require("./config/load");
+async function loadModelsFile(modelsPath) {
+    const resolved = modelsPath
+        ? node_path_1.default.resolve(modelsPath)
+        : node_path_1.default.resolve(process.cwd(), "models.json");
+    return (await (0, load_1.loadModelsFileFromPath)(resolved));
+}
+function resolveModelConfig(modelsFile, requestedModelId) {
+    const match = modelsFile.models.find((m) => m.id === requestedModelId);
+    if (!match) {
+        const available = modelsFile.models.map((m) => m.id).sort();
+        const err = new Error(`Unknown model '${requestedModelId}'. Available: ${available.join(", ")}`);
+        err.statusCode = 400;
+        throw err;
+    }
+    return match;
+}