@hemansubedi/aether-ai 1.0.0

package/dist/config.js

@@ -0,0 +1,104 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".aether");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+// Real, locally-installed Ollama models (verified 2026-09-02):
+//   - goekdenizguelmez/JOSIEFIED-Qwen3:8b        (tool-capable, default)
+//   - hf.co/OBLITERATUS/Qwen3.8-27B-OBLITERATED:Q4_K_M (vision, no tools)
+export const DEFAULT_OLLAMA_MODELS = [
+    "goekdenizguelmez/JOSIEFIED-Qwen3:8b",
+    "hf.co/OBLITERATUS/Qwen3.8-27B-OBLITERATED:Q4_K_M",
+];
+export const DEFAULT_PROVIDERS = [
+    {
+        name: "ollama-local",
+        type: "ollama",
+        baseURL: process.env.AETHER_BASE_URL || "http://localhost:11434",
+        apiKey: undefined,
+        models: [...DEFAULT_OLLAMA_MODELS],
+        priority: 1,
+        enabled: true,
+        maxRetries: 2,
+        timeoutMs: 120000,
+    },
+    {
+        name: "openrouter-free",
+        type: "openrouter",
+        baseURL: "https://openrouter.ai/api/v1",
+        apiKey: process.env.OPENROUTER_API_KEY || process.env.AETHER_API_KEY,
+        models: [],
+        priority: 2,
+        enabled: true,
+        maxRetries: 2,
+        timeoutMs: 120000,
+    },
+    {
+        name: "openai-compatible",
+        type: "openai-compatible",
+        baseURL: process.env.AETHER_BASE_URL || "https://api.openai.com/v1",
+        apiKey: process.env.OPENAI_API_KEY || process.env.AETHER_API_KEY,
+        models: [],
+        priority: 3,
+        enabled: true,
+        maxRetries: 1,
+        timeoutMs: 120000,
+    },
+];
+export function loadConfig() {
+    let fileConfig = {};
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+            fileConfig = JSON.parse(raw);
+        }
+    }
+    catch {
+        // ignore malformed config; fall back to defaults
+    }
+    const envModel = process.env.AETHER_MODEL;
+    const envProvider = process.env.AETHER_PROVIDER;
+    let providers;
+    if (Array.isArray(fileConfig.providers) && fileConfig.providers.length > 0) {
+        providers = fileConfig.providers;
+    }
+    else {
+        providers = DEFAULT_PROVIDERS.map((p) => ({ ...p }));
+    }
+    // Apply env overrides on top of file config.
+    if (envProvider) {
+        providers = providers.map((p) => p.name === envProvider ? { ...p, enabled: true } : p);
+    }
+    const defaultModel = envModel || fileConfig.defaultModel || DEFAULT_OLLAMA_MODELS[0];
+    const activeProvider = envProvider || fileConfig.activeProvider;
+    return { providers, defaultModel, activeProvider };
+}
+export function saveConfig(cfg) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf8");
+    }
+    catch (err) {
+        throw new Error(`Failed to save config to ${CONFIG_FILE}: ${err.message}`);
+    }
+}
+export function getConfig() {
+    return loadConfig();
+}
+export function getActiveProvider() {
+    const cfg = loadConfig();
+    if (cfg.activeProvider) {
+        const match = cfg.providers.find((p) => p.name === cfg.activeProvider);
+        if (match)
+            return match;
+    }
+    const sorted = [...cfg.providers]
+        .filter((p) => p.enabled)
+        .sort((a, b) => a.priority - b.priority);
+    return sorted[0];
+}
+export function configPath() {
+    return CONFIG_FILE;
+}

package/dist/cost.js

@@ -0,0 +1,176 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+// Per-token pricing in USD. Defaults are conservative estimates for free/cheap
+// endpoints; callers may override via CostTracker.setPrice().
+const DEFAULT_INPUT_PRICE = {
+    "openrouter-free": 0,
+    "openai-compatible": 0.000002,
+    ollama: 0,
+};
+const DEFAULT_OUTPUT_PRICE = {
+    "openrouter-free": 0,
+    "openai-compatible": 0.000006,
+    ollama: 0,
+};
+const COST_DIR = path.join(os.homedir(), ".aether");
+const COST_FILE = path.join(COST_DIR, "cost.json");
+const COST_VERSION = 1;
+function key(provider, model) {
+    return `${provider}::${model}`;
+}
+function pad(s, width) {
+    if (s.length >= width)
+        return s;
+    return s + " ".repeat(width - s.length);
+}
+function formatUSD(value) {
+    if (!isFinite(value))
+        return "0.000000";
+    if (Math.abs(value) < 1e-6 && value !== 0)
+        return value.toExponential(3);
+    return value.toFixed(6);
+}
+export class CostTracker {
+    records = new Map();
+    inputPrice = { ...DEFAULT_INPUT_PRICE };
+    outputPrice = { ...DEFAULT_OUTPUT_PRICE };
+    constructor() { }
+    setPrice(provider, inputPerToken, outputPerToken) {
+        this.inputPrice[provider] = inputPerToken;
+        this.outputPrice[provider] = outputPerToken;
+    }
+    record(provider, model, inputTokens, outputTokens) {
+        const k = key(provider, model);
+        let r = this.records.get(k);
+        if (!r) {
+            r = { provider, model, inputTokens: 0, outputTokens: 0, requests: 0, cost: 0 };
+            this.records.set(k, r);
+        }
+        const safeIn = Number.isFinite(inputTokens) ? Math.max(0, inputTokens) : 0;
+        const safeOut = Number.isFinite(outputTokens) ? Math.max(0, outputTokens) : 0;
+        r.inputTokens += safeIn;
+        r.outputTokens += safeOut;
+        r.requests += 1;
+        const inPrice = this.inputPrice[provider] ?? DEFAULT_INPUT_PRICE[provider] ?? 0;
+        const outPrice = this.outputPrice[provider] ?? DEFAULT_OUTPUT_PRICE[provider] ?? 0;
+        r.cost += safeIn * inPrice + safeOut * outPrice;
+    }
+    list() {
+        return Array.from(this.records.values()).sort((a, b) => b.cost - a.cost);
+    }
+    getSummary() {
+        return this.list();
+    }
+    getTotal() {
+        let total = 0;
+        for (const r of this.records.values())
+            total += r.cost;
+        return total;
+    }
+    formatSummary() {
+        const rows = this.list();
+        const total = this.getTotal();
+        const headers = ["Provider", "Model", "Requests", "Input Tok", "Output Tok", "Cost (USD)"];
+        const data = [];
+        for (const r of rows) {
+            data.push([
+                r.provider,
+                r.model,
+                String(r.requests),
+                String(r.inputTokens),
+                String(r.outputTokens),
+                formatUSD(r.cost),
+            ]);
+        }
+        if (rows.length === 0) {
+            data.push(["-", "-", "-", "-", "-", "-"]);
+        }
+        data.push(["", "", "", "", "Total", formatUSD(total)]);
+        const widths = headers.map((h, i) => {
+            let w = h.length;
+            for (const row of data) {
+                if (row[i] && row[i].length > w)
+                    w = row[i].length;
+            }
+            return w;
+        });
+        const lines = [];
+        lines.push(headers.map((h, i) => pad(h, widths[i])).join("  "));
+        lines.push(widths.map((w) => "-".repeat(w)).join("  "));
+        for (const row of data) {
+            lines.push(row.map((c, i) => pad(c, widths[i])).join("  "));
+        }
+        return lines.join("\n");
+    }
+    reset() {
+        this.records.clear();
+    }
+    snapshot() {
+        const out = {};
+        for (const [k, r] of this.records) {
+            out[k] = {
+                inputTokens: r.inputTokens,
+                outputTokens: r.outputTokens,
+                requests: r.requests,
+                cost: r.cost,
+            };
+        }
+        return { version: COST_VERSION, records: out };
+    }
+    restore(snapshot) {
+        this.records.clear();
+        if (!snapshot || typeof snapshot !== "object")
+            return;
+        for (const [k, v] of Object.entries(snapshot.records ?? {})) {
+            const parts = k.split("::");
+            const provider = parts[0] ?? "";
+            const model = parts.slice(1).join("::");
+            const r = {
+                provider,
+                model,
+                inputTokens: v?.inputTokens ?? 0,
+                outputTokens: v?.outputTokens ?? 0,
+                requests: v?.requests ?? 0,
+                cost: v?.cost ?? 0,
+            };
+            this.records.set(k, r);
+        }
+    }
+    static load() {
+        const tracker = new CostTracker();
+        try {
+            if (fs.existsSync(COST_FILE)) {
+                const raw = fs.readFileSync(COST_FILE, "utf8");
+                const parsed = JSON.parse(raw);
+                tracker.restore(parsed);
+            }
+        }
+        catch {
+            // ignore malformed cost file
+        }
+        return tracker;
+    }
+    static save(tracker) {
+        try {
+            if (!fs.existsSync(COST_DIR)) {
+                fs.mkdirSync(COST_DIR, { recursive: true });
+            }
+            const tmp = COST_FILE + ".tmp";
+            fs.writeFileSync(tmp, JSON.stringify(tracker.snapshot(), null, 2), "utf8");
+            fs.renameSync(tmp, COST_FILE);
+        }
+        catch {
+            // best-effort persistence
+        }
+    }
+    static instanceCache = new Map();
+    static instance(name = "default") {
+        let t = CostTracker.instanceCache.get(name);
+        if (!t) {
+            t = name === "default" ? CostTracker.load() : new CostTracker();
+            CostTracker.instanceCache.set(name, t);
+        }
+        return t;
+    }
+}

package/dist/git.js

@@ -0,0 +1,52 @@
+import * as cp from "node:child_process";
+export class GitTool {
+    static isRepo(rootDir) {
+        try {
+            cp.execSync("git rev-parse --is-inside-work-tree", { cwd: rootDir, stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async status(rootDir) {
+        const out = cp.execSync("git status --short", { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+        const results = [];
+        for (const line of out.split("\n")) {
+            if (!line.trim())
+                continue;
+            const status = line.slice(0, 2).trim();
+            const file = line.slice(3).trim();
+            results.push({ file, status });
+        }
+        return results;
+    }
+    static async diff(rootDir, file) {
+        const args = file ? `-- "${file}"` : "";
+        return cp.execSync(`git diff ${args}`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+    }
+    static async commit(rootDir, message) {
+        if (!message || message.trim().length === 0) {
+            throw new Error("Commit message is required");
+        }
+        if (message.includes("\n") || message.includes("'") || message.includes('"')) {
+            throw new Error("Commit message must be a single line without quotes");
+        }
+        return cp.execSync(`git commit -am "${message.replace(/"/g, "")}"`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+    }
+    static async branch(rootDir) {
+        return cp.execSync("git rev-parse --abbrev-ref HEAD", { cwd: rootDir, encoding: "utf8", maxBuffer: 1024 * 1024 }).trim();
+    }
+    static async log(rootDir, count = 5) {
+        const fmt = "%H%x1f%s%x1f%ci";
+        const out = cp.execSync(`git log -n ${count} --format="${fmt}"`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+        const commits = [];
+        for (const line of out.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [hash, message, date] = line.split("\x1f");
+            commits.push({ hash: hash.slice(0, 7), message, date });
+        }
+        return commits;
+    }
+}

package/dist/health.js

@@ -0,0 +1,81 @@
+const FAILURE_THRESHOLD = 3;
+const COOLDOWN_MS = 60000;
+export class HealthTracker {
+    map = new Map();
+    ensure(provider) {
+        let s = this.map.get(provider);
+        if (!s) {
+            s = {
+                provider,
+                healthy: true,
+                failures: 0,
+                lastCheck: 0,
+                circuitOpen: false,
+                cooldownUntil: 0,
+            };
+            this.map.set(provider, s);
+        }
+        return s;
+    }
+    recordSuccess(provider) {
+        const s = this.ensure(provider);
+        s.healthy = true;
+        s.failures = 0;
+        s.circuitOpen = false;
+        s.cooldownUntil = 0;
+        s.lastError = undefined;
+        s.lastCheck = Date.now();
+    }
+    recordFailure(provider, error) {
+        const s = this.ensure(provider);
+        s.failures += 1;
+        s.healthy = false;
+        s.lastError = error;
+        s.lastCheck = Date.now();
+        if (s.failures >= FAILURE_THRESHOLD) {
+            s.circuitOpen = true;
+            s.cooldownUntil = Date.now() + COOLDOWN_MS;
+        }
+    }
+    getStatus(provider) {
+        const s = this.ensure(provider);
+        const now = Date.now();
+        if (s.circuitOpen) {
+            if (now >= s.cooldownUntil) {
+                // half-open: allow one probe
+                s.circuitOpen = false;
+                s.cooldownUntil = 0;
+            }
+            else {
+                return { ...s };
+            }
+        }
+        s.lastCheck = now;
+        return { ...s };
+    }
+    isAvailable(provider) {
+        const s = this.ensure(provider);
+        if (!s.circuitOpen)
+            return true;
+        if (Date.now() >= s.cooldownUntil) {
+            s.circuitOpen = false;
+            s.cooldownUntil = 0;
+            return true;
+        }
+        return false;
+    }
+    getAll() {
+        return Array.from(this.map.values()).map((s) => ({ ...s }));
+    }
+    reset(provider) {
+        const s = this.ensure(provider);
+        s.healthy = true;
+        s.failures = 0;
+        s.circuitOpen = false;
+        s.cooldownUntil = 0;
+        s.lastError = undefined;
+    }
+    resetAll() {
+        this.map.clear();
+    }
+}

package/dist/index.js

@@ -0,0 +1,272 @@
+import * as path from "node:path";
+import * as os from "node:os";
+import { RouterEngine } from "./router-engine.js";
+import { HealthTracker } from "./health.js";
+import { getConfig } from "./config.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool } from "./tools/filesystem.js";
+import { makeGlobTool } from "./tools/glob.js";
+import { makeGrepTool } from "./tools/grep.js";
+import { makeWebSearchTool } from "./tools/websearch.js";
+import { makeVisionTool } from "./tools/vision.js";
+import { makeGitTool } from "./tools/git.js";
+import { Agent } from "./agent.js";
+import { Session } from "./session.js";
+import { Arena } from "./arena.js";
+import { Memory } from "./memory.js";
+import { ModeManager } from "./modes.js";
+import { CostTracker } from "./cost.js";
+import { Settings } from "./settings.js";
+import { createTUI } from "./tui.js";
+import { FreeRouterClient } from "./client.js";
+import { KeyManager } from "./keys.js";
+export async function runChat(messages, tools = [], opts) {
+    const cfg = getConfig();
+    const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+    let text = "";
+    const toolCalls = [];
+    let usage;
+    try {
+        const result = await engine.chat(messages, tools, opts);
+        text = result.text;
+        toolCalls.push(...result.toolCalls);
+        usage = result.usage;
+    }
+    catch (err) {
+        throw new Error(err.message);
+    }
+    return { text, toolCalls, usage };
+}
+function makeRouterAdapter(engine) {
+    const adapter = {
+        configs: engine.configs_,
+        activeProvider: undefined,
+        activeModel: undefined,
+        chat: (messages, tools, opts) => engine.chatStream(messages, tools, opts),
+        select: () => null,
+        setActiveProvider: (n) => { adapter.activeProvider = n; },
+        setActiveModel: (m) => { adapter.activeModel = m; },
+        getActiveProvider: () => adapter.activeProvider,
+        getActiveModel: () => adapter.activeModel,
+        getProviderNames: () => engine.configs_.filter((c) => c.enabled).map((c) => c.name),
+        getModelsFor: (name) => {
+            const c = engine.configs_.find((cfg) => cfg.name === (name ?? adapter.activeProvider));
+            return c?.models ?? [];
+        },
+        listAllModels: () => engine.listFreeModels(),
+        healthAll: () => engine.healthAll(),
+        resetHealth: () => engine.resetHealth(),
+        keys: engine.keys,
+        setKey: (name, key) => engine.setKey(name, key),
+    };
+    return adapter;
+}
+export function createAgent(rootDir = process.cwd()) {
+    const cfg = getConfig();
+    const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+    const router = makeRouterAdapter(engine);
+    const registry = new ToolRegistry();
+    const factories = [
+        makeReadFileTool,
+        makeWriteFileTool,
+        makeEditFileTool,
+        makeListDirTool,
+        makeBashTool,
+        makeGlobTool,
+        makeGrepTool,
+        makeWebSearchTool,
+        makeVisionTool,
+        makeGitTool,
+    ];
+    for (const make of factories) {
+        const tool = make(rootDir);
+        registry.register(tool.def, tool.execute);
+    }
+    const memory = new Memory();
+    const modeManager = new ModeManager();
+    return new Agent(router, registry, { memory, modeManager });
+}
+export function createAgentFromServer(baseURL) {
+    const client = new FreeRouterClient(baseURL);
+    const adapter = {
+        configs: [],
+        activeProvider: undefined,
+        activeModel: undefined,
+        select: () => null,
+        setActiveProvider: (n) => { adapter.activeProvider = n; },
+        setActiveModel: (m) => { adapter.activeModel = m; },
+        getActiveProvider: () => adapter.activeProvider,
+        getActiveModel: () => adapter.activeModel,
+        getProviderNames: async () => {
+            const statuses = await client.providers();
+            return statuses.map((s) => s.provider);
+        },
+        getModelsFor: async (_name) => {
+            const list = await client.listModels();
+            return list.data.map((m) => m.id);
+        },
+        listAllModels: async () => {
+            const list = await client.listModels();
+            const out = {};
+            for (const m of list.data) {
+                const owner = m.owned_by || "server";
+                (out[owner] ??= []).push(m.id);
+            }
+            return out;
+        },
+        healthAll: async () => client.providers(),
+        resetHealth: async () => { await client.resetHealth(); },
+    };
+    adapter.chat = async function* (messages, tools, opts) {
+        const result = await client.chat(messages, {
+            model: opts?.model,
+            tools,
+            temperature: opts?.temperature,
+            maxTokens: opts?.maxTokens,
+            stream: false,
+        });
+        adapter.activeProvider = result.provider;
+        adapter.activeModel = result.model;
+        if (result.text)
+            yield { type: "text", text: result.text };
+        for (const tc of result.toolCalls ?? []) {
+            yield { type: "tool_call", tool_call: tc };
+        }
+        yield { type: "done", usage: result.usage };
+    };
+    const registry = new ToolRegistry();
+    const factories = [
+        makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool,
+        makeGlobTool, makeGrepTool, makeWebSearchTool, makeVisionTool, makeGitTool,
+    ];
+    for (const make of factories) {
+        const tool = make(process.cwd());
+        registry.register(tool.def, tool.execute);
+    }
+    return new Agent(adapter, registry, { memory: new Memory(), modeManager: new ModeManager() });
+}
+export function createTUIContext(rootDir = process.cwd()) {
+    const cfg = getConfig();
+    const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+    const router = makeRouterAdapter(engine);
+    const registry = new ToolRegistry();
+    for (const make of [makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool, makeGlobTool, makeGrepTool, makeWebSearchTool, makeVisionTool, makeGitTool]) {
+        const tool = make(rootDir);
+        registry.register(tool.def, tool.execute);
+    }
+    const agent = new Agent(router, registry, { memory: new Memory(), modeManager: new ModeManager() });
+    const session = new Session();
+    const arena = new Arena(router);
+    const costTracker = CostTracker.load();
+    const settings = Settings.load();
+    const skills = Skills.instance();
+    const checkpoint = Checkpoint.instance();
+    const tui = createTUI({ agent, router, session, arena, costTracker, settings, skills, checkpoint });
+    return { agent, router, session, arena, costTracker, settings, tui };
+}
+export { RouterEngine, HealthTracker, KeyManager, getConfig, Agent, ToolRegistry, Session, Arena, createTUI, Memory, ModeManager, CostTracker, GitTool, Checkpoint, Skills, FreeRouterClient };
+import { GitTool } from "./git.js";
+import { Checkpoint } from "./checkpoint.js";
+import { Skills } from "./skills.js";
+// CLI entrypoint
+function isMainModule() {
+    // Robust across tsx/Node and Windows path formatting.
+    const self = import.meta.url.replace(/\/$/g, "");
+    const argv1 = "file://" + path.resolve(process.argv[1] ?? "");
+    if (self === argv1)
+        return true;
+    // Also match when invoked via `tsx` where argv may be a .ts source file.
+    try {
+        const selfPath = new URL(self).pathname;
+        const argvPath = path.resolve(process.argv[1] ?? "");
+        const norm = (p) => p.toLowerCase().replace(/\\/g, "/").replace(/^\//, "");
+        if (norm(selfPath) === norm(argvPath))
+            return true;
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+if (isMainModule()) {
+    // Parse CLI flags: --plan and --yolo set the agent mode and are stripped
+    // from the prompt args.
+    let modeFlag = null;
+    const promptArgs = [];
+    for (const arg of process.argv.slice(2)) {
+        if (arg === "--plan") {
+            modeFlag = "plan";
+        }
+        else if (arg === "--yolo") {
+            modeFlag = "yolo";
+        }
+        else {
+            promptArgs.push(arg);
+        }
+    }
+    const prompt = promptArgs.join(" ").trim();
+    if (!prompt) {
+        // Interactive TUI mode.
+        const { tui } = createTUIContext();
+        tui.start();
+    }
+    else if (prompt.startsWith("/")) {
+        // A single command in non-interactive mode.
+        const { tui } = createTUIContext();
+        tui.handleCommand(prompt).then(() => process.exit(0)).catch((err) => {
+            process.stderr.write(`error: ${err.message}\n`);
+            process.exit(1);
+        });
+    }
+    else {
+        // One-shot prompt: run the agent, print the answer, save the session.
+        (async () => {
+            try {
+                const agent = createAgent();
+                // Honor AETHER_MODEL / AETHER_PROVIDER env vars in one-shot mode so
+                // local Ollama models can be selected without an interactive TUI.
+                if (process.env.AETHER_PROVIDER) {
+                    agent.router.setActiveProvider(process.env.AETHER_PROVIDER);
+                }
+                if (process.env.AETHER_MODEL) {
+                    agent.router.setActiveModel(process.env.AETHER_MODEL);
+                }
+                const session = new Session();
+                const costTracker = CostTracker.load();
+                const settings = Settings.load();
+                const provider = agent.router.getActiveProvider() ?? "unknown";
+                const model = agent.router.getActiveModel() ?? "default";
+                if (modeFlag)
+                    agent.setMode(modeFlag);
+                let assistantText = "";
+                for await (const chunk of agent.run(prompt, session.messages)) {
+                    if (chunk.type === "text" && chunk.text) {
+                        process.stdout.write(chunk.text);
+                        assistantText += chunk.text;
+                    }
+                    if (chunk.type === "tool_call" && chunk.tool_call) {
+                        process.stderr.write(`\n[Tool: ${chunk.tool_call.function.name}]\n`);
+                    }
+                    if (chunk.type === "error" && chunk.error) {
+                        process.stderr.write(`\n[error] ${chunk.error}\n`);
+                    }
+                    if (chunk.type === "done" && chunk.usage) {
+                        costTracker.record(provider, model, chunk.usage.input_tokens, chunk.usage.output_tokens);
+                    }
+                }
+                CostTracker.save(costTracker);
+                if (agent.lastMessages.length > 0) {
+                    session.messages = agent.lastMessages.filter((m) => m.role !== "system");
+                }
+                const sessions = Session.list();
+                const file = sessions[0]?.file ?? path.join(os.homedir(), ".aether", "sessions", "session.json");
+                Session.save(file, session);
+                process.stdout.write("\n");
+            }
+            catch (err) {
+                process.stderr.write(`error: ${err.message}\n`);
+                process.exit(1);
+            }
+        })();
+    }
+}