@hemansubedi/aether-ai 1.0.0

package/src/server.ts

@@ -0,0 +1,242 @@
+import * as http from "node:http";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RouterEngine } from "./router-engine.js";
+import type { ChatChunk } from "./types.js";
+
+export interface ServerOptions {
+  port?: number;
+  host?: string;
+  engine?: RouterEngine;
+}
+
+function parseJsonBody(req: http.IncomingMessage): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (c: Buffer) => 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: http.ServerResponse, status: number, body: unknown): void {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(payload).toString(),
+  });
+  res.end(payload);
+}
+
+function sendSSE(res: http.ServerResponse, chunk: ChatChunk): void {
+  const data = JSON.stringify(chunk);
+  res.write(`data: ${data}\n\n`);
+}
+
+async function writeSSEStream(
+  res: http.ServerResponse,
+  gen: AsyncGenerator<ChatChunk>
+): Promise<void> {
+  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: Record<string, string[]>) {
+  const data: { id: string; object: string; owned_by?: string }[] = [];
+  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: ServerOptions = {}): http.Server {
+  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: any) => ({
+                      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 as Error).message;
+      sendJson(res, 500, { error: { message: msg, type: "internal_error" } });
+    }
+  });
+
+  return server;
+}
+
+export function startServer(opts: ServerOptions = {}): http.Server {
+  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: NodeJS.ErrnoException) => {
+      console.error("Failed to start server:", err);
+      process.exit(1);
+    });
+  } catch (err) {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  }
+}
+
+
+

package/src/session.ts

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { Message } from "./types.js";
+import { compressHistory } from "./tokensaver.js";
+
+const DEFAULT_SESSION_DIR = path.join(os.homedir(), ".aether", "sessions");
+
+export interface SessionData {
+  version: number;
+  createdAt: number;
+  updatedAt: number;
+  messages: Message[];
+}
+
+export class Session {
+  messages: Message[] = [];
+  createdAt: number = Date.now();
+  updatedAt: number = Date.now();
+
+  add(m: Message): void {
+    this.messages.push(m);
+    this.updatedAt = Date.now();
+  }
+
+  clear(): void {
+    this.messages = [];
+    this.updatedAt = Date.now();
+  }
+
+  get size(): number {
+    return this.messages.length;
+  }
+
+  toJSON(): SessionData {
+    return {
+      version: 1,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      messages: this.messages,
+    };
+  }
+
+  fromJSON(obj: SessionData): Session {
+    this.messages = obj.messages ?? [];
+    this.createdAt = obj.createdAt ?? Date.now();
+    this.updatedAt = obj.updatedAt ?? Date.now();
+    return this;
+  }
+
+  summarizeOld(router: any, keepRecent: number = 6): Message[] {
+    // 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: string): Session {
+    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: string, session: Session): void {
+    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: string = DEFAULT_SESSION_DIR): Array<{ file: string; mtime: number; size: number }> {
+    try {
+      if (!fs.existsSync(dir)) return [];
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const out: Array<{ file: string; mtime: number; size: number }> = [];
+      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 [];
+    }
+  }
+}
+
+

package/src/settings.ts

@@ -0,0 +1,125 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+export interface SettingsData {
+  theme: string;
+  streaming: boolean;
+  maxSteps: number;
+  temperature: number;
+  confirmTools: boolean;
+  autoSave: boolean;
+}
+
+const SETTINGS_DIR = path.join(os.homedir(), ".aether");
+const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");
+const SETTINGS_VERSION = 1;
+
+const DEFAULTS: SettingsData = {
+  theme: "dark",
+  streaming: true,
+  maxSteps: 15,
+  temperature: 0.7,
+  confirmTools: true,
+  autoSave: true,
+};
+
+interface SettingsSnapshot {
+  version: number;
+  settings: Partial<SettingsData>;
+}
+
+function isBool(v: unknown): v is boolean {
+  return typeof v === "boolean";
+}
+
+function isNum(v: unknown): v is number {
+  return typeof v === "number" && Number.isFinite(v);
+}
+
+function isStr(v: unknown): v is string {
+  return typeof v === "string";
+}
+
+function coerce(key: keyof SettingsData, v: unknown): any {
+  const def = DEFAULTS[key];
+  if (typeof def === "boolean") return isBool(v) ? v : def;
+  if (typeof def === "number") return isNum(v) ? v : def;
+  return isStr(v) ? v : def;
+}
+
+export class Settings {
+  private settings: SettingsData = { ...DEFAULTS };
+  private dirty = false;
+
+  constructor() {}
+
+  get(key: keyof SettingsData): SettingsData[keyof SettingsData] {
+    return this.settings[key];
+  }
+
+  set(key: keyof SettingsData, value: SettingsData[keyof SettingsData]): void {
+    (this.settings as any)[key] = coerce(key, value);
+    this.dirty = true;
+  }
+
+  getAll(): SettingsData {
+    return { ...this.settings };
+  }
+
+  reset(): void {
+    this.settings = { ...DEFAULTS };
+    this.dirty = true;
+  }
+
+  save(): void {
+    try {
+      if (!fs.existsSync(SETTINGS_DIR)) {
+        fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+      }
+      const snapshot: SettingsSnapshot = { version: SETTINGS_VERSION, settings: { ...this.settings } };
+      const tmp = SETTINGS_FILE + ".tmp";
+      fs.writeFileSync(tmp, JSON.stringify(snapshot, null, 2), "utf8");
+      fs.renameSync(tmp, SETTINGS_FILE);
+    } catch {
+      // best-effort persistence
+    }
+    this.dirty = false;
+  }
+
+  private restore(snapshot: SettingsSnapshot): void {
+    if (!snapshot || typeof snapshot !== "object") return;
+    const src = snapshot.settings ?? {};
+    for (const key of Object.keys(DEFAULTS) as (keyof SettingsData)[]) {
+      if (key in src) {
+        (this.settings as any)[key] = coerce(key, (src as any)[key]);
+      }
+    }
+  }
+
+  static load(): Settings {
+    const s = new Settings();
+    try {
+      if (fs.existsSync(SETTINGS_FILE)) {
+        const raw = fs.readFileSync(SETTINGS_FILE, "utf8");
+        s.restore(JSON.parse(raw));
+      }
+    } catch {
+      // ignore malformed settings file
+    }
+    return s;
+  }
+
+  private static instanceCache = new Map<string, Settings>();
+
+  static instance(name: string = "default"): Settings {
+    let s = Settings.instanceCache.get(name);
+    if (!s) {
+      s = name === "default" ? Settings.load() : new Settings();
+      Settings.instanceCache.set(name, s);
+    }
+    return s;
+  }
+}
+
+

package/src/skills.ts

@@ -0,0 +1,106 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+export interface Skill {
+  name: string;
+  description: string;
+  arguments: string[];
+  template: string;
+}
+
+export class Skills {
+  private dir: string;
+  private skills: Map<string, Skill>;
+
+  constructor(dir?: string) {
+    this.dir = dir ?? path.join(os.homedir(), ".aether", "skills");
+    this.skills = new Map();
+    this.load();
+  }
+
+  private load(): void {
+    try {
+      if (!fs.existsSync(this.dir)) {
+        this.ensureDefault();
+        return;
+      }
+      const files = fs.readdirSync(this.dir).filter((f) => f.endsWith(".md"));
+      for (const f of files) {
+        const skill = this.parseFile(path.join(this.dir, f));
+        if (skill) this.skills.set(skill.name, skill);
+      }
+      if (this.skills.size === 0) this.ensureDefault();
+    } catch {
+      this.ensureDefault();
+    }
+  }
+
+  private ensureDefault(): void {
+    const def: Skill = {
+      name: "explain",
+      description: "Explain a concept in simple terms",
+      arguments: ["topic"],
+      template: "Explain {{topic}} in simple terms with an analogy. Keep it under 200 words."
+    };
+    this.skills.set(def.name, def);
+    try {
+      fs.mkdirSync(this.dir, { recursive: true });
+      const file = path.join(this.dir, "explain.md");
+      if (!fs.existsSync(file)) {
+        fs.writeFileSync(file, `---\nname: explain\ndescription: Explain a concept in simple terms\narguments:\n  - topic\n---\n\nExplain {{topic}} in simple terms with an analogy. Keep it under 200 words.`, "utf8");
+      }
+    } catch {
+      // best effort
+    }
+  }
+
+  private parseFile(file: string): Skill | null {
+    try {
+      const raw = fs.readFileSync(file, "utf8");
+      const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+      if (!fmMatch) return null;
+      const fm = fmMatch[1];
+      const body = fmMatch[2].trim();
+      const name = fm.match(/^name:\s*(.+)$/m)?.[1].trim() ?? "";
+      const description = fm.match(/^description:\s*(.+)$/m)?.[1].trim() ?? "";
+      const argsSection = fm.match(/^arguments:\s*\n((?:\s+-\s*.+\n?)+)/m);
+      const args: string[] = [];
+      if (argsSection) {
+        const re = /^\s+-\s*(.+)$/gm;
+        let m;
+        while ((m = re.exec(argsSection[1])) !== null) args.push(m[1].trim());
+      }
+      if (!name) return null;
+      return { name, description, arguments: args, template: body };
+    } catch {
+      return null;
+    }
+  }
+
+  list(): Skill[] {
+    return Array.from(this.skills.values());
+  }
+
+  get(name: string): Skill | undefined {
+    return this.skills.get(name);
+  }
+
+  render(name: string, args: Record<string, string>): string {
+    const skill = this.skills.get(name);
+    if (!skill) return `ERROR: unknown skill "${name}"`;
+    let out = skill.template;
+    for (const [k, v] of Object.entries(args)) {
+      out = out.replace(new RegExp(`{{${k}}}`, "g"), v);
+    }
+    // Replace any remaining {{arg}} with the joined args string.
+    out = out.replace(/{{(\w+)}}/g, (_, k) => args[k] ?? "");
+    return out;
+  }
+
+  private static instance_: Skills | null = null;
+  static instance(): Skills {
+    if (!Skills.instance_) Skills.instance_ = new Skills();
+    return Skills.instance_;
+  }
+}

package/src/tokensaver.ts

@@ -0,0 +1,57 @@
+import type { Message } from "./types.js";
+
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.split(/\s+/).filter(Boolean).length * 1.3);
+}
+
+export function estimateMessageTokens(m: Message): number {
+  let n = estimateTokens(typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p.text : "").join(""));
+  if (m.tool_calls) {
+    for (const tc of m.tool_calls) {
+      n += estimateTokens(tc.function.name) + estimateTokens(tc.function.arguments);
+    }
+  }
+  return n + 4; // role/name overhead
+}
+
+export function compressText(text: string): string {
+  return text
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function compressHistory(
+  messages: Message[],
+  maxTokens: number
+): Message[] {
+  if (messages.length === 0) return [];
+
+  const system = messages.find((m) => m.role === "system");
+  const rest = system ? messages.slice(1) : messages;
+
+  let budget = maxTokens;
+  if (system) budget -= estimateMessageTokens(system);
+
+  const kept: Message[] = [];
+  let used = 0;
+  // Walk from the newest backwards.
+  for (let i = rest.length - 1; i >= 0; i--) {
+    const cost = estimateMessageTokens(rest[i]);
+    if (used + cost > budget) break;
+    kept.unshift(rest[i]);
+    used += cost;
+  }
+
+  const dropped = rest.length - kept.length;
+  const result: Message[] = [];
+  if (system) result.push(system);
+  if (dropped > 0) {
+    result.push({
+      role: "system",
+      content: `[${dropped} earlier message(s) omitted to fit context]`,
+    });
+  }
+  result.push(...kept);
+  return result;
+}