@hemansubedi/aether-ai 1.0.0

package/dist/router-engine.js

@@ -0,0 +1,200 @@
+import { HealthTracker } from "./health.js";
+import { createProvider } from "./providers/index.js";
+import { PROVIDER_REGISTRY } from "./providers/registry.js";
+import { KeyManager, ENV_MAP } from "./keys.js";
+export class RouterEngine {
+    health;
+    cache = new Map();
+    configs;
+    keyManager;
+    activeModel;
+    constructor(providers, health, keyManager) {
+        this.health = health ?? new HealthTracker();
+        this.keyManager = keyManager ?? KeyManager.instance();
+        this.configs = (providers ?? PROVIDER_REGISTRY).map((p) => ({
+            name: p.name,
+            type: p.type,
+            baseURL: p.baseURL,
+            apiKey: this.keyManager.get(p.name) ?? process.env[ENV_MAP[p.name] ?? ""],
+            models: p.models,
+            priority: p.priority,
+            enabled: p.enabled,
+            maxRetries: p.maxRetries,
+            timeoutMs: p.timeoutMs,
+        }));
+    }
+    get configs_() { return this.configs; }
+    get healthTracker() { return this.health; }
+    get keys() { return this.keyManager; }
+    /** Update the key for a provider and invalidate the cached provider so the
+     *  new credential takes effect on the next request. */
+    setKey(name, key) {
+        this.keyManager.set(name, key);
+        const cfg = this.configs.find((c) => c.name === name);
+        if (cfg)
+            cfg.apiKey = key.trim() || undefined;
+        this.cache.delete(name);
+    }
+    /** Activate a combo: rebuild the router's active provider list from the
+     *  combo's providers (in order), set the active model to the combo's first
+     *  model, and invalidate the provider cache so the new providers load. */
+    applyCombo(combo) {
+        this.configs = (combo.providers ?? [])
+            .map((name) => {
+            const p = PROVIDER_REGISTRY.find((x) => x.name === name);
+            if (!p)
+                return undefined;
+            return {
+                name: p.name,
+                type: p.type,
+                baseURL: p.baseURL,
+                apiKey: this.keyManager.get(p.name) ?? process.env[ENV_MAP[p.name] ?? ""],
+                models: p.models,
+                priority: p.priority,
+                enabled: p.enabled,
+                maxRetries: p.maxRetries,
+                timeoutMs: p.timeoutMs,
+            };
+        })
+            .filter((c) => Boolean(c));
+        this.cache.clear();
+        this.activeModel = combo.models?.[0];
+        const provs = this.configs.map((c) => c.name).join(", ") || "(none)";
+        return `Combo "${combo.name}" active: ${this.configs.length} provider(s) [${provs}], model: ${this.activeModel ?? "(none)"}`;
+    }
+    async getProvider(cfg) {
+        const cached = this.cache.get(cfg.name);
+        if (cached)
+            return cached;
+        const p = await createProvider(cfg);
+        this.cache.set(cfg.name, p);
+        return p;
+    }
+    sorted() {
+        return [...this.configs].filter((p) => p.enabled).sort((a, b) => a.priority - b.priority);
+    }
+    async *chatStream(messages, tools, opts) {
+        const order = this.sorted().filter((p) => !opts?.excludeProviders?.includes(p.name));
+        if (order.length === 0) {
+            yield { type: "error", error: "No providers configured" };
+            return;
+        }
+        let lastError = "";
+        for (const cfg of order) {
+            if (!this.health.isAvailable(cfg.name))
+                continue;
+            const provider = await this.getProvider(cfg);
+            const model = cfg.models[0] ?? "";
+            const start = Date.now();
+            try {
+                let usage;
+                for await (const chunk of provider.chat(messages, tools, {
+                    signal: opts?.signal,
+                    temperature: opts?.temperature,
+                    maxTokens: opts?.maxTokens,
+                })) {
+                    if (chunk.type === "done")
+                        usage = chunk.usage;
+                    if (chunk.type === "error" && chunk.error)
+                        throw new Error(chunk.error);
+                    yield chunk;
+                }
+                this.health.recordSuccess(cfg.name);
+                if (!usage)
+                    yield { type: "done", usage };
+                return;
+            }
+            catch (err) {
+                const msg = err.message;
+                lastError = msg;
+                this.health.recordFailure(cfg.name, msg);
+                if (opts?.signal?.aborted) {
+                    yield { type: "error", error: `Aborted: ${msg}` };
+                    return;
+                }
+                yield {
+                    type: "error",
+                    error: `Provider ${cfg.name} failed (${msg}); failing over...`,
+                };
+            }
+        }
+        yield {
+            type: "error",
+            error: `All ${order.length} providers failed. Last: ${lastError || "unknown"}`,
+        };
+    }
+    async chat(messages, tools, opts) {
+        const order = this.sorted().filter((p) => !opts?.excludeProviders?.includes(p.name));
+        const attempts = [];
+        let lastError = "";
+        for (const cfg of order) {
+            if (!this.health.isAvailable(cfg.name))
+                continue;
+            const provider = await this.getProvider(cfg);
+            const model = cfg.models[0] ?? "";
+            const start = Date.now();
+            try {
+                let text = "", toolCalls = [], usage;
+                for await (const chunk of provider.chat(messages, tools, { signal: opts?.signal, temperature: opts?.temperature, maxTokens: opts?.maxTokens })) {
+                    if (chunk.type === "text" && chunk.text)
+                        text += chunk.text;
+                    if (chunk.type === "tool_call" && chunk.tool_call)
+                        toolCalls.push(chunk.tool_call);
+                    if (chunk.type === "done")
+                        usage = chunk.usage;
+                    if (chunk.type === "error" && chunk.error)
+                        throw new Error(chunk.error);
+                }
+                this.health.recordSuccess(cfg.name);
+                attempts.push({ provider: cfg.name, model, ok: true, latencyMs: Date.now() - start });
+                return { text, toolCalls, usage, attempts, provider: cfg.name, model };
+            }
+            catch (err) {
+                const msg = err.message;
+                lastError = msg;
+                this.health.recordFailure(cfg.name, msg);
+                attempts.push({ provider: cfg.name, model, ok: false, error: msg, latencyMs: Date.now() - start });
+                if (opts?.signal?.aborted)
+                    break;
+            }
+        }
+        throw new Error(`All ${order.length} providers failed. Last: ${lastError}. Attempts: ${JSON.stringify(attempts)}`);
+    }
+    async listFreeModels() {
+        const out = {};
+        for (const cfg of this.sorted()) {
+            try {
+                const p = await this.getProvider(cfg);
+                out[cfg.name] = await p.listModels();
+            }
+            catch {
+                out[cfg.name] = cfg.models;
+            }
+        }
+        return out;
+    }
+    async healthAll() {
+        const out = [];
+        for (const cfg of this.configs) {
+            if (!cfg.enabled)
+                continue;
+            try {
+                const provider = await this.getProvider(cfg);
+                const status = await provider.health();
+                out.push({ provider: cfg.name, ...status });
+            }
+            catch {
+                out.push({
+                    provider: cfg.name,
+                    healthy: false,
+                    failures: 0,
+                    lastCheck: 0,
+                    circuitOpen: false,
+                    cooldownUntil: 0,
+                });
+            }
+        }
+        return out;
+    }
+    resetHealth() { this.health.resetAll(); }
+}

package/dist/router.js

@@ -0,0 +1,171 @@
+import { createProvider } from "./providers/index.js";
+export class Router {
+    configs;
+    health;
+    cache = new Map();
+    modelCache = new Map();
+    activeProvider;
+    activeModel;
+    constructor(providers, health) {
+        this.configs = providers;
+        this.health = health;
+    }
+    async getProvider(config) {
+        const cached = this.cache.get(config.name);
+        if (cached)
+            return cached;
+        const p = await createProvider(config);
+        this.cache.set(config.name, p);
+        return p;
+    }
+    sortedConfigs() {
+        return [...this.configs]
+            .filter((p) => p.enabled)
+            .sort((a, b) => a.priority - b.priority);
+    }
+    findConfig(name) {
+        if (!name)
+            return undefined;
+        return this.configs.find((c) => c.name === name);
+    }
+    resolveModel(modelId) {
+        const exact = this.configs.find((c) => c.models.includes(modelId));
+        if (exact)
+            return { provider: exact, model: modelId };
+        const first = this.sortedConfigs()[0];
+        return first ? { provider: first, model: modelId } : null;
+    }
+    async getModelProvider(modelId) {
+        const cached = this.modelCache.get(modelId);
+        if (cached)
+            return cached;
+        const cfg = this.configs.find((c) => c.models.includes(modelId)) || this.sortedConfigs()[0];
+        if (!cfg)
+            throw new Error(`No provider configured to serve model "${modelId}"`);
+        const override = { ...cfg, models: [modelId] };
+        const p = await createProvider(override);
+        this.modelCache.set(modelId, p);
+        return p;
+    }
+    select() {
+        const cfg = this.findConfig(this.activeProvider) || this.sortedConfigs()[0];
+        if (cfg && this.health.isAvailable(cfg.name)) {
+            return {
+                provider: cfg.name,
+                model: this.activeModel || cfg.models[0] || "",
+                reason: this.activeProvider ? `selected (active: ${this.activeProvider})` : `selected by priority ${cfg.priority}`,
+            };
+        }
+        for (const c of this.sortedConfigs()) {
+            if (this.health.isAvailable(c.name)) {
+                return { provider: c.name, model: this.activeModel || c.models[0] || "", reason: "fallback" };
+            }
+        }
+        return null;
+    }
+    setActiveProvider(name) {
+        this.activeProvider = name;
+    }
+    setActiveModel(model) {
+        this.activeModel = model;
+        const cfg = this.findConfig(this.activeProvider) || this.sortedConfigs()[0];
+        if (cfg) {
+            cfg.models = [model];
+        }
+    }
+    getActiveProvider() {
+        return this.activeProvider;
+    }
+    getActiveModel() {
+        return this.activeModel;
+    }
+    getProviderNames() {
+        return this.configs.filter((c) => c.enabled).map((c) => c.name);
+    }
+    getModelsFor(name) {
+        const cfg = name
+            ? this.configs.find((c) => c.name === name)
+            : this.activeProvider
+                ? this.configs.find((c) => c.name === this.activeProvider)
+                : this.sortedConfigs()[0];
+        return cfg?.models ?? [];
+    }
+    async *chat(messages, tools, opts) {
+        const order = this.sortedConfigs();
+        if (order.length === 0) {
+            yield { type: "error", error: "No providers configured" };
+            return;
+        }
+        let lastError = null;
+        for (const cfg of order) {
+            if (!this.health.isAvailable(cfg.name))
+                continue;
+            const provider = await this.getProvider(cfg);
+            try {
+                for await (const chunk of provider.chat(messages, tools, {
+                    signal: opts?.signal,
+                    temperature: opts?.temperature,
+                    maxTokens: opts?.maxTokens,
+                })) {
+                    if (chunk.type === "error" && chunk.error) {
+                        throw new Error(chunk.error);
+                    }
+                    yield chunk;
+                }
+                this.health.recordSuccess(cfg.name);
+                return;
+            }
+            catch (err) {
+                lastError = err;
+                this.health.recordFailure(cfg.name, lastError?.message);
+                if (opts?.signal?.aborted) {
+                    yield { type: "error", error: `Aborted: ${lastError.message}` };
+                    return;
+                }
+                yield {
+                    type: "error",
+                    error: `Provider ${cfg.name} failed (${lastError.message}); failing over...`,
+                };
+                continue;
+            }
+        }
+        yield {
+            type: "error",
+            error: `All providers failed. Last error: ${lastError?.message ?? "unknown"}`,
+        };
+    }
+    async listAllModels() {
+        const out = {};
+        for (const cfg of this.sortedConfigs()) {
+            try {
+                const provider = await this.getProvider(cfg);
+                out[cfg.name] = await provider.listModels();
+            }
+            catch {
+                out[cfg.name] = [];
+            }
+        }
+        return out;
+    }
+    async healthAll() {
+        const out = [];
+        for (const cfg of this.configs) {
+            try {
+                const provider = await this.getProvider(cfg);
+                const status = await provider.health();
+                out.push({ provider: cfg.name, ...status });
+            }
+            catch {
+                out.push({
+                    provider: cfg.name,
+                    healthy: false,
+                    failures: 0,
+                    lastCheck: 0,
+                    circuitOpen: false,
+                    cooldownUntil: 0,
+                });
+            }
+        }
+        return out;
+    }
+}

package/dist/server.js

@@ -0,0 +1,210 @@
+import * as http from "node:http";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RouterEngine } from "./router-engine.js";
+function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (c) => chunks.push(c));
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8").trim();
+            if (!raw)
+                return resolve({});
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload).toString(),
+    });
+    res.end(payload);
+}
+function sendSSE(res, chunk) {
+    const data = JSON.stringify(chunk);
+    res.write(`data: ${data}\n\n`);
+}
+async function writeSSEStream(res, gen) {
+    try {
+        for await (const chunk of gen) {
+            if (res.writableEnded)
+                break;
+            sendSSE(res, chunk);
+        }
+    }
+    finally {
+        if (!res.writableEnded) {
+            res.write("data: [DONE]\n\n");
+            res.end();
+        }
+    }
+}
+function modelsToList(models) {
+    const data = [];
+    for (const [provider, list] of Object.entries(models)) {
+        for (const id of list) {
+            data.push({ id, object: "model", owned_by: provider });
+        }
+    }
+    return { object: "list", data };
+}
+export function createServer(opts = {}) {
+    const engine = opts.engine ?? new RouterEngine();
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const path = url.pathname;
+        const method = req.method ?? "GET";
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        try {
+            if (method === "GET" && path === "/health") {
+                const [all, healthies] = await Promise.all([
+                    engine.listFreeModels(),
+                    engine.healthAll(),
+                ]);
+                const providerCount = Object.keys(all).length;
+                const healthyCount = healthies.filter((h) => h.healthy).length;
+                return sendJson(res, 200, {
+                    status: "ok",
+                    providers: providerCount,
+                    healthy: healthyCount,
+                });
+            }
+            if (method === "GET" && (path === "/v1/models" || path === "/models")) {
+                const models = await engine.listFreeModels();
+                return sendJson(res, 200, modelsToList(models));
+            }
+            if (method === "GET" && path === "/providers") {
+                const statuses = await engine.healthAll();
+                return sendJson(res, 200, statuses);
+            }
+            if (method === "POST" && path === "/reset-health") {
+                engine.resetHealth();
+                return sendJson(res, 200, { status: "ok", message: "Health state reset" });
+            }
+            if (method === "POST" && path === "/v1/chat/completions") {
+                const body = await parseJsonBody(req);
+                const { model, messages, tools, stream, temperature, max_tokens } = body ?? {};
+                if (!Array.isArray(messages)) {
+                    return sendJson(res, 400, { error: { message: "messages array is required", type: "invalid_request_error" } });
+                }
+                const opts = {
+                    temperature: typeof temperature === "number" ? temperature : undefined,
+                    maxTokens: typeof max_tokens === "number" ? max_tokens : undefined,
+                };
+                if (stream) {
+                    res.writeHead(200, {
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        Connection: "keep-alive",
+                    });
+                    const gen = engine.chatStream(messages, tools ?? [], opts);
+                    await writeSSEStream(res, gen);
+                    return;
+                }
+                const result = await engine.chat(messages, tools ?? [], opts);
+                const chosenModel = model || result.model;
+                return sendJson(res, 200, {
+                    id: `chatcmpl-${Date.now()}`,
+                    object: "chat.completion",
+                    created: Math.floor(Date.now() / 1000),
+                    model: chosenModel,
+                    choices: [
+                        {
+                            index: 0,
+                            message: {
+                                role: "assistant",
+                                content: result.text,
+                                ...(result.toolCalls.length
+                                    ? { tool_calls: result.toolCalls.map((tc) => ({
+                                            id: tc.id || `call_${Date.now()}`,
+                                            type: "function",
+                                            function: { name: tc.function.name, arguments: tc.function.arguments ?? "" },
+                                        })) }
+                                    : {}),
+                            },
+                            finish_reason: result.toolCalls.length ? "tool_calls" : "stop",
+                        },
+                    ],
+                    usage: result.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+                    _aether: {
+                        attempts: result.attempts,
+                        provider: result.provider,
+                    },
+                });
+            }
+            if (method === "POST" && path === "/v1/chat") {
+                const body = await parseJsonBody(req);
+                const { model, messages, tools, temperature, max_tokens } = body ?? {};
+                if (!Array.isArray(messages)) {
+                    return sendJson(res, 400, { error: "messages array is required" });
+                }
+                const result = await engine.chat(messages, tools ?? [], {
+                    temperature: typeof temperature === "number" ? temperature : undefined,
+                    maxTokens: typeof max_tokens === "number" ? max_tokens : undefined,
+                });
+                return sendJson(res, 200, {
+                    text: result.text,
+                    toolCalls: result.toolCalls,
+                    usage: result.usage,
+                    attempts: result.attempts,
+                    provider: result.provider,
+                    model: model || result.model,
+                });
+            }
+            sendJson(res, 404, { error: { message: `Not found: ${method} ${path}`, type: "not_found_error" } });
+        }
+        catch (err) {
+            const msg = err.message;
+            sendJson(res, 500, { error: { message: msg, type: "internal_error" } });
+        }
+    });
+    return server;
+}
+export function startServer(opts = {}) {
+    const envPort = Number(process.env.AETHER_PORT);
+    const port = opts.port ?? (Number.isFinite(envPort) && envPort > 0 ? envPort : 31415);
+    const host = opts.host ?? "0.0.0.0";
+    const engine = opts.engine ?? new RouterEngine();
+    const server = createServer({ ...opts, engine });
+    server.listen(port, host, () => {
+        const providerCount = engine.configs_.filter((c) => c.enabled).length;
+        console.log(`Aether free-model server running at http://localhost:${port}`);
+        console.log(`Endpoints:`);
+        console.log(`  GET  /health`);
+        console.log(`  GET  /v1/models`);
+        console.log(`  POST /v1/chat/completions`);
+        console.log(`  POST /v1/chat`);
+        console.log(`  GET  /providers`);
+        console.log(`  POST /reset-health`);
+        console.log(`Providers: ${providerCount} configured`);
+    });
+    return server;
+}
+if (process.argv[1] && path.resolve(fileURLToPath(import.meta.url)) === path.resolve(process.argv[1])) {
+    try {
+        const server = startServer();
+        server.on("error", (err) => {
+            console.error("Failed to start server:", err);
+            process.exit(1);
+        });
+    }
+    catch (err) {
+        console.error("Failed to start server:", err);
+        process.exit(1);
+    }
+}

package/dist/session.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { compressHistory } from "./tokensaver.js";
+const DEFAULT_SESSION_DIR = path.join(os.homedir(), ".aether", "sessions");
+export class Session {
+    messages = [];
+    createdAt = Date.now();
+    updatedAt = Date.now();
+    add(m) {
+        this.messages.push(m);
+        this.updatedAt = Date.now();
+    }
+    clear() {
+        this.messages = [];
+        this.updatedAt = Date.now();
+    }
+    get size() {
+        return this.messages.length;
+    }
+    toJSON() {
+        return {
+            version: 1,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            messages: this.messages,
+        };
+    }
+    fromJSON(obj) {
+        this.messages = obj.messages ?? [];
+        this.createdAt = obj.createdAt ?? Date.now();
+        this.updatedAt = obj.updatedAt ?? Date.now();
+        return this;
+    }
+    summarizeOld(router, keepRecent = 6) {
+        // Keep the most recent messages and compress older ones via tokensaver.
+        // If a router is available, a weak model could be asked to summarize the
+        // dropped tail; we keep it simple and fall back to compressHistory.
+        if (this.messages.length <= keepRecent) {
+            return this.messages.slice();
+        }
+        const recent = this.messages.slice(-keepRecent);
+        const older = this.messages.slice(0, -keepRecent);
+        const compressed = compressHistory(older, 4096);
+        return [...compressed, ...recent];
+    }
+    static load(filePath) {
+        const session = new Session();
+        try {
+            if (!fs.existsSync(filePath))
+                return session;
+            const raw = fs.readFileSync(filePath, "utf8");
+            const obj = JSON.parse(raw);
+            session.fromJSON(obj);
+        }
+        catch {
+            // ignore malformed sessions
+        }
+        return session;
+    }
+    static save(filePath, session) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const tmp = filePath + ".tmp";
+        fs.writeFileSync(tmp, JSON.stringify(session.toJSON(), null, 2), "utf8");
+        fs.renameSync(tmp, filePath);
+    }
+    static list(dir = DEFAULT_SESSION_DIR) {
+        try {
+            if (!fs.existsSync(dir))
+                return [];
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            const out = [];
+            for (const e of entries) {
+                if (!e.isFile())
+                    continue;
+                if (!e.name.endsWith(".json"))
+                    continue;
+                const full = path.join(dir, e.name);
+                try {
+                    const st = fs.statSync(full);
+                    out.push({ file: full, mtime: st.mtimeMs, size: st.size });
+                }
+                catch {
+                    // skip
+                }
+            }
+            out.sort((a, b) => b.mtime - a.mtime);
+            return out;
+        }
+        catch {
+            return [];
+        }
+    }
+}