@aiaiaichain/agent 0.1.2 → 0.1.4

package/README.md

@@ -17,7 +17,7 @@
 [![Node](https://img.shields.io/badge/node-%3E%3D20-brightgreen?style=flat-square)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=flat-square)](LICENSE)
 
-[X / Twitter](https://x.com/aiaiaisol)
+[X / Twitter](https://x.com/aiaiaisol) · [aiaiaichain.xyz](https://aiaiaichain.xyz)
 
 </div>
 
@@ -149,7 +149,7 @@ Get an OpenRouter key at https://openrouter.ai/keys
 
 ## Links
 
-- [X / Twitter](https://x.com/aiaiaisol)
+- [X / Twitter](https://x.com/aiaiaisol) · [aiaiaichain.xyz](https://aiaiaichain.xyz)
 - [npm](https://www.npmjs.com/package/@aiaiaichain/agent)
 
 ## License

package/dist/cli.js

@@ -6,6 +6,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
 import { render } from "ink";
 import React from "react";
 import { config as loadDotenv } from "dotenv";
@@ -22,6 +23,10 @@ import { makeTheme } from "./tui/theme.js";
 import { AgentDir } from "./core/AgentDir.js";
 import { priceFeed } from "./tools/PriceFeed.js";
 import { agentWallet, DEPOSIT_WALLET, ACTION_WALLET, SIGNER } from "./wallet/AgentWallet.js";
+import { PROVIDERS, getConfigured, getUnconfigured } from "./providers/ProviderRegistry.js";
+import { env } from "./core/EnvLoader.js";
+import { gmgnHelp, gmgnStatus, saveGmgnApiKey } from "./tools/GmgnIntegration.js";
+import { sessionStore } from "./session/SessionStore.js";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 const envPath = join(AIAIAI_HOME, ".env");
 if (existsSync(envPath))
@@ -191,6 +196,260 @@ if (subcmd === "actions" || subcmd === "activity") {
     })();
     await new Promise(() => { });
 }
+if (subcmd === "fees") {
+    (async () => {
+        const { actionFeed } = await import("./wallet/ActionFeed.js");
+        const result = await actionFeed.getFeesTool();
+        console.log(result.content[0].text);
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
+if (subcmd === "keys" || subcmd === "providers") {
+    (async () => {
+        const readline = await import("node:readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((res) => rl.question(prompt, res));
+        const allEnv = env.getAll();
+        const configured = getConfigured(allEnv);
+        const unconfigured = getUnconfigured(allEnv);
+        console.log(T.accent("\n  🔑 AI Model Providers\n"));
+        console.log(T.muted(`  Configure AI model providers. Add at least one API key to get started.`));
+        console.log(T.muted(`  ${configured.length}/${PROVIDERS.length} configured\n`));
+        // Show configured
+        if (configured.length > 0) {
+            console.log(T.success("  Configured (" + configured.length + ")"));
+            for (const p of configured) {
+                const key = allEnv[p.envVar] || "";
+                const masked = key.slice(0, 6) + "••••" + key.slice(-4);
+                console.log(T.success(`    ✓ ${p.name.padEnd(28)} ${masked}`));
+            }
+        }
+        // Show unconfigured
+        console.log("\n" + T.warn("  Unconfigured (" + unconfigured.length + ")"));
+        for (let i = 0; i < unconfigured.length; i++) {
+            const p = unconfigured[i];
+            console.log(T.muted(`    ${String(i + 1).padStart(2)}. ${p.name}`));
+        }
+        // Add key flow
+        console.log("\n" + T.muted("  Enter number to add a key, 'r' to refresh models, or 'q' to quit:"));
+        const input = (await ask("  > ")).trim();
+        if (input === "q") {
+            rl.close();
+            process.exit(0);
+        }
+        if (input === "r") {
+            console.log(T.muted("\n  Refreshing models from configured providers..."));
+            await modelRegistry.initialise();
+            console.log(T.success(`  ✓ ${modelRegistry.modelCount} models available from ${modelRegistry.getProviderCount()} providers`));
+            rl.close();
+            process.exit(0);
+        }
+        const idx = parseInt(input) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= unconfigured.length) {
+            console.log(T.error("  Invalid selection."));
+            rl.close();
+            process.exit(1);
+        }
+        const provider = unconfigured[idx];
+        console.log(T.accent(`\n  ${provider.name}`));
+        console.log(T.muted(`  ${provider.docsUrl}`));
+        console.log(T.muted(`  Env var: ${provider.envVar}\n`));
+        const key = (await ask(`  Enter ${provider.name} API key: `)).trim();
+        if (!key) {
+            console.log(T.error("  Key is required."));
+            rl.close();
+            process.exit(1);
+        }
+        // Save to .env
+        env.set(provider.envVar, key);
+        console.log(T.success(`\n  ✓ ${provider.name} key saved to ~/.aiaiai/.env`));
+        // Fetch models from this provider
+        console.log(T.muted("  Fetching models from " + provider.name + "..."));
+        try {
+            await modelRegistry.initialise();
+            const providerModels = modelRegistry.getProviderModels(provider.id);
+            console.log(T.success(`  ✓ ${providerModels.length} models available from ${provider.name}`));
+            console.log(T.success(`  ✓ ${modelRegistry.modelCount} total models from ${modelRegistry.getProviderCount()} providers`));
+        }
+        catch (e) {
+            console.log(T.warn(`  ⚠ Could not fetch models: ${e instanceof Error ? e.message : String(e)}`));
+        }
+        rl.close();
+        process.exit(0);
+    })().catch(e => { console.error(T.error(`Error: ${e.message}`)); process.exit(1); });
+    await new Promise(() => { });
+}
+if (subcmd === "gmgn" || subcmd === "gmgnhelp") {
+    const gmgnArgs = args.slice(1);
+    if (gmgnArgs.length === 0 || gmgnArgs[0] === "help" || gmgnArgs[0] === "--help") {
+        console.log(gmgnHelp());
+        process.exit(0);
+    }
+    if (gmgnArgs[0] === "setup" || gmgnArgs[0] === "config" || gmgnArgs[0] === "key") {
+        (async () => {
+            const readline = await import("node:readline");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const ask = (prompt) => new Promise((res) => rl.question(prompt, res));
+            console.log(T.accent("\n  🔍 GMGN API Key Setup\n"));
+            console.log(T.muted("  Get your API key at https://gmgn.ai/ai\n"));
+            const key = (await ask("  Enter GMGN_API_KEY: ")).trim();
+            if (!key) {
+                console.log(T.error("  Key is required."));
+                rl.close();
+                process.exit(1);
+            }
+            saveGmgnApiKey(key);
+            console.log(T.success("\n  ✓ GMGN_API_KEY saved to ~/.config/gmgn/.env"));
+            console.log(T.muted("  All GMGN commands are now available.\n"));
+            rl.close();
+            process.exit(0);
+        })().catch(e => { console.error(T.error(`Error: ${e.message}`)); process.exit(1); });
+        await new Promise(() => { });
+    }
+    if (gmgnArgs[0] === "status") {
+        console.log(gmgnStatus());
+        process.exit(0);
+    }
+    // Forward to gmgn-cli
+    try {
+        const fullArgs = ["gmgn-cli", ...gmgnArgs];
+        const gmgnEnv = {};
+        try {
+            const f = readFileSync(join(homedir(), ".config", "gmgn", ".env"), "utf-8");
+            for (const l of f.split("\n")) {
+                const m = l.trim().match(/^([A-Z_]+)=(.*)$/);
+                if (m)
+                    gmgnEnv[m[1]] = m[2];
+            }
+        }
+        catch { /* no gmgn env */ }
+        const output = execSync(fullArgs.join(" "), {
+            env: { ...process.env, ...gmgnEnv },
+            encoding: "utf-8",
+            timeout: 30_000,
+        });
+        process.stdout.write(output);
+    }
+    catch (e) {
+        const msg = e.stderr?.toString() || e.message || "";
+        process.stderr.write(`gmgn-cli: ${msg.slice(0, 500)}\n`);
+        process.exit(e.status ?? 1);
+    }
+    process.exit(0);
+}
+if (subcmd === "update" || subcmd === "upgrade") {
+    (async () => {
+        const pkgName = "@aiaiaichain/agent";
+        console.log(T.accent("\n  🤖 AIAIAI Update Check\n"));
+        // Get current version
+        const __filename = fileURLToPath(import.meta.url);
+        const __dir = dirname(__filename);
+        const currentPkg = JSON.parse(readFileSync(resolve(__dir, "..", "package.json"), "utf-8"));
+        const current = currentPkg.version;
+        console.log(T.muted(`  Current version: v${current}`));
+        // Check npm for latest
+        let latest = null;
+        let changelog = "";
+        try {
+            const viewOutput = execSync(`npm view ${pkgName} version`, {
+                encoding: "utf-8",
+                timeout: 15_000,
+            }).trim();
+            latest = viewOutput.split("\n").pop() || null;
+            // Try to get changelog from npm
+            try {
+                const changelogOutput = execSync(`npm view ${pkgName} --json`, {
+                    encoding: "utf-8",
+                    timeout: 15_000,
+                });
+                const pkgData = JSON.parse(changelogOutput);
+                if (pkgData.gitHead) {
+                    changelog = `Git: ${pkgData.gitHead.slice(0, 8)}`;
+                }
+            }
+            catch { /* no changelog available */ }
+        }
+        catch {
+            console.log(T.error("  Could not reach npm registry. Check your connection."));
+            process.exit(1);
+        }
+        if (!latest) {
+            console.log(T.error("  Could not determine latest version."));
+            process.exit(1);
+        }
+        console.log(T.muted(`  Latest version:  v${latest}`));
+        if (changelog)
+            console.log(T.muted(`  ${changelog}`));
+        if (latest === current) {
+            console.log(T.success("\n  ✅ You're on the latest version!\n"));
+            process.exit(0);
+        }
+        console.log(T.accent(`\n  ⚡ Update available: v${current} → v${latest}\n`));
+        // Ask to update
+        const readline = await import("node:readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((res) => rl.question(prompt, res));
+        const confirm = (await ask("  Install update now? (y/n): ")).trim().toLowerCase();
+        if (confirm !== "y" && confirm !== "yes") {
+            console.log(T.muted("\n  Skipped. Run `aiaiai update` anytime to update.\n"));
+            rl.close();
+            process.exit(0);
+        }
+        console.log(T.muted("\n  Installing update..."));
+        try {
+            execSync(`npm install -g ${pkgName}`, {
+                stdio: "inherit",
+                timeout: 120_000,
+            });
+            console.log(T.success(`\n  ✅ Updated to v${latest}!`));
+            console.log(T.muted("  Run `aiaiai` to restart with new features.\n"));
+        }
+        catch (e) {
+            console.log(T.error(`\n  ❌ Update failed: ${e.message}`));
+            console.log(T.muted("  Try manually: npm install -g @aiaiaichain/agent\n"));
+        }
+        rl.close();
+        process.exit(0);
+    })().catch(e => { console.error(T.error(`Error: ${e.message}`)); process.exit(1); });
+    await new Promise(() => { });
+}
+if (subcmd === "sessions") {
+    const sessions = sessionStore.list();
+    if (sessions.length === 0) {
+        console.log(T.muted("  No saved sessions."));
+        process.exit(0);
+    }
+    console.log(T.accent("\n  📂 Saved Sessions\n"));
+    sessions.slice(0, 15).forEach((s, i) => {
+        const date = new Date(s.updatedAt).toLocaleDateString();
+        console.log(T.muted(`  ${String(i + 1).padStart(2)}. ${s.title} (${s.messageCount} msgs, ${s.model}, ${date})`));
+    });
+    console.log("");
+    process.exit(0);
+}
+if (subcmd === "resume") {
+    const sessions = sessionStore.list();
+    if (sessions.length === 0) {
+        console.log(T.muted("  No saved sessions."));
+        process.exit(0);
+    }
+    const idx = parseInt(process.argv[3]) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+        console.log(T.error("  Invalid session number."));
+        process.exit(1);
+    }
+    const session = sessionStore.load(sessions[idx].id);
+    if (!session) {
+        console.log(T.error("  Session not found."));
+        process.exit(1);
+    }
+    console.log(T.accent(`\n  📂 Resumed: ${session.title}\n`));
+    console.log(T.muted(`  Messages: ${session.messages.length}`));
+    console.log(T.muted(`  Model: ${session.model}`));
+    console.log("");
+    process.exit(0);
+}
 // ── Resolve extension + prompt ────────────────────────────────────────────────
 let extensionPath = null;
 let promptPath = null;

package/dist/core/EnvLoader.d.ts

@@ -1,5 +1,5 @@
 /**
- * EnvLoader — loads environment variables from ~/.aiaiai/.env and process.env
+ * EnvLoader — loads/writes environment variables from ~/.aiaiai/.env
  */
 export declare class EnvLoader {
     private cache;
@@ -9,6 +9,9 @@ export declare class EnvLoader {
     get(key: string, defaultValue?: string): string | undefined;
     getRequired(key: string): string;
     has(key: string): boolean;
+    /** Write a key=value to the .env file and update cache */
+    set(key: string, value: string): void;
+    getAll(): Record<string, string>;
     reload(): void;
 }
 export declare const env: EnvLoader;

package/dist/core/EnvLoader.js

@@ -1,40 +1,37 @@
 /**
- * EnvLoader — loads environment variables from ~/.aiaiai/.env and process.env
+ * EnvLoader — loads/writes environment variables from ~/.aiaiai/.env
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { homedir } from 'node:os';
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
 export class EnvLoader {
     cache = {};
     envPath;
     constructor() {
         const home = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
-        this.envPath = resolve(home, '.env');
+        this.envPath = resolve(home, ".env");
         this.load();
     }
     load() {
-        // Load from .env file
         if (existsSync(this.envPath)) {
-            const content = readFileSync(this.envPath, 'utf-8');
-            for (const line of content.split('\n')) {
+            const content = readFileSync(this.envPath, "utf-8");
+            for (const line of content.split("\n")) {
                 const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#'))
+                if (!trimmed || trimmed.startsWith("#"))
                     continue;
-                const eqIdx = trimmed.indexOf('=');
+                const eqIdx = trimmed.indexOf("=");
                 if (eqIdx === -1)
                     continue;
                 const key = trimmed.slice(0, eqIdx).trim();
-                const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+                const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
                 if (key)
                     this.cache[key] = value;
             }
         }
-        // Process.env overrides file
         for (const key of Object.keys(process.env)) {
             const value = process.env[key];
-            if (value !== undefined) {
+            if (value !== undefined)
                 this.cache[key] = value;
-            }
         }
     }
     get(key, defaultValue) {
@@ -47,7 +44,42 @@ export class EnvLoader {
         return value;
     }
     has(key) {
-        return this.cache[key] !== undefined;
+        return this.cache[key] !== undefined && this.cache[key].trim() !== "";
+    }
+    /** Write a key=value to the .env file and update cache */
+    set(key, value) {
+        const content = existsSync(this.envPath) ? readFileSync(this.envPath, "utf-8") : "";
+        const lines = content.split("\n");
+        let found = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith(`${key}=`)) {
+                lines[i] = `${key}=${value}`;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            if (content && !content.endsWith("\n"))
+                lines.push("");
+            lines.push(`${key}=${value}`);
+        }
+        const newContent = lines.join("\n") + "\n";
+        writeFileSync(this.envPath, newContent, "utf-8");
+        try {
+            chmodSync(this.envPath, 0o600);
+        }
+        catch { /* non-fatal */ }
+        this.cache[key] = value;
+        process.env[key] = value;
+    }
+    getAll() {
+        const result = {};
+        for (const [key, value] of Object.entries(this.cache)) {
+            if (value !== undefined)
+                result[key] = value;
+        }
+        return result;
     }
     reload() {
         this.cache = {};

package/dist/core/SystemMonitor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SystemMonitor — tracks CPU, RAM, network, and agent stats.
+ * Uses Node.js built-in modules only (no external deps).
+ */
+export interface SystemStats {
+    cpuPercent: number;
+    ramPercent: number;
+    ramUsed: string;
+    ramTotal: string;
+    uptime: string;
+    netUp: string;
+    netDown: string;
+    apiCallsPerMin: number;
+    tokensUsed: number;
+}
+export declare class SystemMonitor {
+    private apiCallCount;
+    private lastNetStats;
+    constructor();
+    private initNetStats;
+    /** Track an API call */
+    trackApiCall(): void;
+    /** Get current system stats */
+    getStats(tokenCount?: number): SystemStats;
+    private getCpuPercent;
+    private getRamPercent;
+    private getNetStats;
+    private getRawNetStats;
+    private formatBytes;
+    private formatUptime;
+    /** Reset API call counter (call every minute) */
+    resetApiCounter(): number;
+}
+export declare const systemMonitor: SystemMonitor;
+//# sourceMappingURL=SystemMonitor.d.ts.map

package/dist/core/SystemMonitor.js

@@ -0,0 +1,115 @@
+/**
+ * SystemMonitor — tracks CPU, RAM, network, and agent stats.
+ * Uses Node.js built-in modules only (no external deps).
+ */
+import { cpus, totalmem, freemem, uptime, networkInterfaces } from 'node:os';
+export class SystemMonitor {
+    apiCallCount = 0;
+    lastNetStats = { rx: 0, tx: 0, time: Date.now() };
+    constructor() {
+        this.initNetStats();
+    }
+    initNetStats() {
+        try {
+            const stats = this.getRawNetStats();
+            this.lastNetStats = { rx: stats.rx, tx: stats.tx, time: Date.now() };
+        }
+        catch { /* non-fatal */ }
+    }
+    /** Track an API call */
+    trackApiCall() {
+        this.apiCallCount++;
+    }
+    /** Get current system stats */
+    getStats(tokenCount = 0) {
+        return {
+            cpuPercent: this.getCpuPercent(),
+            ramPercent: this.getRamPercent(),
+            ramUsed: this.formatBytes(totalmem() - freemem()),
+            ramTotal: this.formatBytes(totalmem()),
+            uptime: this.formatUptime(uptime()),
+            ...this.getNetStats(),
+            apiCallsPerMin: this.apiCallCount,
+            tokensUsed: tokenCount,
+        };
+    }
+    getCpuPercent() {
+        try {
+            const cpuInfo = cpus();
+            let totalIdle = 0, totalTick = 0;
+            for (const cpu of cpuInfo) {
+                for (const type in cpu.times) {
+                    totalTick += cpu.times[type];
+                }
+                totalIdle += cpu.times.idle;
+            }
+            const idle = totalIdle / cpuInfo.length;
+            const total = totalTick / cpuInfo.length;
+            return Math.round((1 - idle / total) * 100);
+        }
+        catch {
+            return 0;
+        }
+    }
+    getRamPercent() {
+        const used = totalmem() - freemem();
+        return Math.round((used / totalmem()) * 100);
+    }
+    getNetStats() {
+        try {
+            const current = this.getRawNetStats();
+            const elapsed = (Date.now() - this.lastNetStats.time) / 1000;
+            if (elapsed < 1)
+                return { netUp: '0 B/s', netDown: '0 B/s' };
+            const rxPerSec = Math.max(0, (current.rx - this.lastNetStats.rx) / elapsed);
+            const txPerSec = Math.max(0, (current.tx - this.lastNetStats.tx) / elapsed);
+            this.lastNetStats = { rx: current.rx, tx: current.tx, time: Date.now() };
+            return {
+                netUp: this.formatBytes(txPerSec) + '/s',
+                netDown: this.formatBytes(rxPerSec) + '/s',
+            };
+        }
+        catch {
+            return { netUp: 'N/A', netDown: 'N/A' };
+        }
+    }
+    getRawNetStats() {
+        let rx = 0, tx = 0;
+        const interfaces = networkInterfaces();
+        for (const name of Object.keys(interfaces)) {
+            const iface = interfaces[name];
+            if (!iface)
+                continue;
+            for (const info of iface) {
+                if (info.internal)
+                    continue;
+                // Node.js doesn't expose per-interface bytes by default
+                // This is a best-effort approximation
+            }
+        }
+        return { rx, tx };
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+    }
+    formatUptime(seconds) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        if (h > 0)
+            return `${h}h ${m}m`;
+        return `${m}m`;
+    }
+    /** Reset API call counter (call every minute) */
+    resetApiCounter() {
+        const count = this.apiCallCount;
+        this.apiCallCount = 0;
+        return count;
+    }
+}
+export const systemMonitor = new SystemMonitor();
+//# sourceMappingURL=SystemMonitor.js.map

package/dist/index.d.ts

@@ -17,13 +17,13 @@ export { loadExtension } from "./loader.js";
 export { makeTheme, T, AIAIAI_COLORS } from "./tui/theme.js";
 export { ModelRegistry, modelRegistry, classifyModel } from "./models/ModelRegistry.js";
 export { CostTracker } from "./models/CostTracker.js";
-export type { OpenRouterModel, TieredModel, TieredPool, ModelTier } from "./models/ModelRegistry.js";
+export type { ModelInfo, TieredModel, ModelTier } from "./models/ModelRegistry.js";
 export { fullAnalysis, rsi, macd, ema, sma, bollingerBands, atr, getCandlesTool, getCandlesParams } from "./tools/TechnicalAnalysis.js";
 export { PriceFeed, priceFeed } from "./tools/PriceFeed.js";
 export { NewsFeed, newsFeed, getNewsTool, scoreSentiment } from "./tools/NewsSentiment.js";
 export { getFearGreedTool, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "./tools/MarketSentiment.js";
 export type { OHLCV, AnalysisResult } from "./tools/TechnicalAnalysis.js";
-export type { PriceResult, DexScreenerPair } from "./tools/PriceFeed.js";
+export type { PriceResult, DexScreenerPair as DexScreenerData } from "./tools/PriceFeed.js";
 export type { NewsItem, SentimentReport } from "./tools/NewsSentiment.js";
 export { SessionManager } from "./session/SessionManager.js";
 export { MemoryStore, memoryStore } from "./session/MemoryStore.js";
@@ -37,6 +37,12 @@ export { agentWallet, COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET, SIGNER, AIAIAI
 export { actionFeed } from "./wallet/ActionFeed.js";
 export type { WalletBalance, AgentWallets } from "./wallet/AgentWallet.js";
 export type { AgentAction, ActionType, FeeTracker } from "./wallet/ActionFeed.js";
+export { gmgnTool, gmgnMarketTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+export { watchTokenTool, removeWatchTool, listWatchTool, addAlertTool, checkAlertsTool, compareTokensTool, portfolioTool, portfolioParams, getWatchList, checkAlerts, addAlert, getActiveAlerts, } from "./tools/CrossTools.js";
+export { sessionStore } from "./session/SessionStore.js";
+export type { Session, SessionMeta } from "./session/SessionStore.js";
+export { systemMonitor } from "./core/SystemMonitor.js";
+export type { SystemStats } from "./core/SystemMonitor.js";
 export { MCPServer } from "./mcp/server.js";
 export { AgentDir } from "./core/AgentDir.js";
 export { EnvLoader, env } from "./core/EnvLoader.js";

package/dist/index.js

@@ -36,6 +36,14 @@ export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
 // Wallet
 export { agentWallet, COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET, SIGNER, AIAIAI_MINT } from "./wallet/AgentWallet.js";
 export { actionFeed } from "./wallet/ActionFeed.js";
+// GMGN
+export { gmgnTool, gmgnMarketTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+// Cross tools
+export { watchTokenTool, removeWatchTool, listWatchTool, addAlertTool, checkAlertsTool, compareTokensTool, portfolioTool, portfolioParams, getWatchList, checkAlerts, addAlert, getActiveAlerts, } from "./tools/CrossTools.js";
+// Session
+export { sessionStore } from "./session/SessionStore.js";
+// System
+export { systemMonitor } from "./core/SystemMonitor.js";
 // MCP
 export { MCPServer } from "./mcp/server.js";
 // Core

package/dist/models/CostTracker.js

@@ -23,14 +23,8 @@ export class CostTracker {
         this.sessionEntry.totalCost += cost;
         this.sessionEntry.totalTokens += promptTokens + completionTokens;
     }
-    estimateCost(model, prompt, completion) {
-        const all = this.registry.getAllModels();
-        const m = all.find(m => m.id === model);
-        if (!m)
-            return (prompt + completion) * 0.000001;
-        const p = parseFloat(m.pricing.prompt) || DEFAULT_RATES.prompt;
-        const c = parseFloat(m.pricing.completion) || DEFAULT_RATES.completion;
-        return (prompt * p) + (completion * c);
+    estimateCost(_model, prompt, completion) {
+        return (prompt * DEFAULT_RATES.prompt) + (completion * DEFAULT_RATES.completion);
     }
     statusLine() {
         return `$${this.sessionEntry.totalCost.toFixed(4)}`;