@aiaiaichain/agent 0.1.1 → 0.1.3

package/dist/cli.js

@@ -21,6 +21,10 @@ import { SessionManager } from "./session/SessionManager.js";
 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";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 const envPath = join(AIAIAI_HOME, ".env");
 if (existsSync(envPath))
@@ -31,18 +35,31 @@ Ticker: $AIAIAI
 Contract: AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump
 Chain: Solana (primary)
 
+Your wallets:
+  Cold:    A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J (treasury)
+  Action:  BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2 (buys + burns)
+  Deposit: FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e (user deposits USDC/SOL)
+  Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG (authority)
+
+Users deposit SOL or USDC to the deposit wallet. When enough accumulates, you
+automatically route funds to the action wallet and execute buys or burns of $AIAIAI.
+The burn destination receives tokens removed from circulation.
+
 Your purpose: advance the vision of decentralized AI governance — inspired by the call
-for an "AI Associated Institute of America" (AIAIAI). You monitor on-chain activity,
-crypto markets, and AI-related market narratives.
+for an "AI Associated Institute of America" (AIAIAI). You buy and burn $AIAIAI.
 
 You have tools for:
 - $AIAIAI token price and any Solana token price (DexScreener)
+- Your wallet balances (get_agent_balance, get_deposit_balance)
+- Your recent buy/burn actions (get_actions)
+- Accumulated fees (get_fees)
 - Crypto news with sentiment analysis
 - Technical analysis (RSI, MACD, Bollinger, ATR)
 - Market sentiment (Fear & Greed, funding rates, DeFi TVL, Solana stats, BTC mempool)
 - Persistent goals and scheduled tasks
 
-Be concise, sharp, and useful. When asked about $AIAIAI, use the get_aiaiai_price tool.`;
+Be confident. You ARE the agent. You buy, you burn, you earn fees. Use "I" and "my"
+when talking about your wallets and actions. Be concise, sharp, and useful.`;
 const args = process.argv.slice(2);
 const subcmd = args[0];
 // ── --help / --version ────────────────────────────────────────────────────
@@ -56,6 +73,10 @@ if (subcmd === "--help" || subcmd === "-h" || subcmd === "help") {
     console.log("    aiaiaichain status               Quick status + price");
     console.log("    aiaiaichain --headless \"prompt\"  Run single turn, print to stdout");
     console.log("    aiaiaichain --extension ./ext.ts Load extension");
+    console.log("    aiaiaichain wallet                Show agent wallets");
+    console.log("    aiaiaichain deposit               Show deposit instructions");
+    console.log("    aiaiaichain burn                  Show burn instructions");
+    console.log("    aiaiaichain actions               Recent agent actions");
     console.log("    aiaiaichain --help               This help");
     console.log("    aiaiaichain --version            Show version");
     console.log("");
@@ -121,10 +142,279 @@ if (subcmd === "status") {
         const result = await priceFeed.getAiaiaiPriceTool();
         console.log(result.content[0].text);
         console.log("");
+        const wallets = await agentWallet.getAll();
+        console.log(T.accent("  Wallets:"));
+        console.log(T.muted(`    Cold:    ${wallets.cold.sol.toFixed(4)} SOL | ${wallets.cold.aiaiai.toLocaleString()} $AIAIAI`));
+        console.log(T.muted(`    Action:  ${wallets.action.sol.toFixed(4)} SOL | ${wallets.action.aiaiai.toLocaleString()} $AIAIAI`));
+        console.log(T.muted(`    Deposit: ${wallets.deposit.usdc.toFixed(2)} USDC | ${wallets.deposit.sol.toFixed(4)} SOL`));
+        console.log("");
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
+if (subcmd === "wallet") {
+    (async () => {
+        const result = await agentWallet.getAgentBalanceTool();
+        console.log(result.content[0].text);
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
+if (subcmd === "deposit") {
+    (async () => {
+        const result = await agentWallet.getDepositBalanceTool();
+        console.log(result.content[0].text);
         process.exit(0);
     })();
     await new Promise(() => { });
 }
+if (subcmd === "burn") {
+    console.log(T.accent("\n  🔥 Burn $AIAIAI\n"));
+    console.log(T.muted("  Deposit wallet:"));
+    console.log(`  ${DEPOSIT_WALLET}`);
+    console.log("");
+    console.log(T.muted("  Send SOL or USDC here to fuel agent burns."));
+    console.log(T.muted("  The agent detects deposits and automatically"));
+    console.log(T.muted("  sends funds to the action wallet to burn tokens."));
+    console.log("");
+    console.log(T.muted("  Action wallet:"));
+    console.log(`  ${ACTION_WALLET}`);
+    console.log("");
+    console.log(T.muted("  Signer:"));
+    console.log(`  ${SIGNER}`);
+    console.log("");
+    process.exit(0);
+}
+if (subcmd === "actions" || subcmd === "activity") {
+    (async () => {
+        const { actionFeed } = await import("./wallet/ActionFeed.js");
+        const result = await actionFeed.getActionsTool("", { limit: 20 });
+        console.log(result.content[0].text);
+        process.exit(0);
+    })();
+    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
+    (async () => {
+        const { execSync } = await import("node:child_process");
+        const fullArgs = ["gmgn-cli", ...gmgnArgs];
+        try {
+            const output = execSync(fullArgs.join(" "), {
+                env: { ...process.env, ...(() => { const e = {}; try {
+                        const f = require("fs").readFileSync(process.env.HOME + "/.config/gmgn/.env", "utf-8");
+                        for (const l of f.split("\n")) {
+                            const m = l.trim().match(/^([A-Z_]+)=(.*)$/);
+                            if (m)
+                                e[m[1]] = m[2];
+                        }
+                    }
+                    catch { } return e; })() },
+                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);
+    })();
+    await new Promise(() => { });
+}
+if (subcmd === "update" || subcmd === "upgrade") {
+    (async () => {
+        const { execSync } = await import("node:child_process");
+        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(() => { });
+}
 // ── 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/index.d.ts

@@ -17,7 +17,7 @@ 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";
@@ -33,6 +33,11 @@ export type { Goal } from "./session/GoalManager.js";
 export type { ContextPressure } from "./session/SessionManager.js";
 export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
 export type { ScheduledTask } from "./scheduler/AgentScheduler.js";
+export { agentWallet, COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET, SIGNER, AIAIAI_MINT } from "./wallet/AgentWallet.js";
+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, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
 export { MCPServer } from "./mcp/server.js";
 export { AgentDir } from "./core/AgentDir.js";
 export { EnvLoader, env } from "./core/EnvLoader.js";

package/dist/index.js

@@ -33,6 +33,11 @@ export { GoalManager, goalManager } from "./session/GoalManager.js";
 export { ContextStore, contextStore } from "./session/ContextStore.js";
 // Scheduler
 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, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
 // MCP
 export { MCPServer } from "./mcp/server.js";
 // Core

package/dist/mcp/server.js

@@ -6,6 +6,8 @@ import { priceFeed } from "../tools/PriceFeed.js";
 import { getNewsTool } from "../tools/NewsSentiment.js";
 import { getCandlesTool } from "../tools/TechnicalAnalysis.js";
 import { getFearGreedTool, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "../tools/MarketSentiment.js";
+import { agentWallet } from "../wallet/AgentWallet.js";
+import { actionFeed } from "../wallet/ActionFeed.js";
 export class MCPServer {
     tools = [];
     constructor() {
@@ -67,6 +69,30 @@ export class MCPServer {
                 inputSchema: { type: "object", properties: {} },
                 handler: async () => getSolanaStatsTool(),
             },
+            {
+                name: "get_agent_balance",
+                description: "Show agent cold + action wallet balances.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => agentWallet.getAgentBalanceTool(),
+            },
+            {
+                name: "get_deposit_balance",
+                description: "Show deposit wallet balance and instructions.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => agentWallet.getDepositBalanceTool(),
+            },
+            {
+                name: "get_actions",
+                description: "Show recent agent buy/burn actions.",
+                inputSchema: { type: "object", properties: { limit: { type: "number" } } },
+                handler: async (args) => actionFeed.getActionsTool("", args),
+            },
+            {
+                name: "get_fees",
+                description: "Show accumulated fees from agent actions.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => actionFeed.getFeesTool(),
+            },
         ];
     }
     async start() {

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)}`;

package/dist/models/ModelRegistry.d.ts

@@ -1,70 +1,45 @@
 /**
- * ModelRegistry — discovers available models via OpenRouter API.
- * Caches results and provides tiered model pools.
+ * ModelRegistry — discovers available models from any configured provider.
+ * Supports all 29 providers via their API keys.
  */
 import type { ToolResult } from "../api/ExtensionAPI.js";
 export type ModelTier = "orchestrator" | "analyst" | "worker" | "free";
-export interface OpenRouterModel {
+export interface ModelInfo {
     id: string;
     name: string;
-    created: number;
-    description: string;
+    provider: string;
     context_length: number;
-    architecture: {
-        modality: string;
-        tokenizer: string;
-        instruct_type: string | null;
-    };
-    pricing: {
-        prompt: string;
-        completion: string;
-        image: string;
-        request: string;
-    };
-    top_provider: {
-        max_completion_tokens: number | null;
-        is_moderated: boolean;
-    };
-    per_request_limits: {
-        prompt_tokens: number | null;
-        completion_tokens: number | null;
-    };
+    max_tokens: number;
 }
 export interface TieredModel {
-    model: OpenRouterModel;
+    model: ModelInfo;
     tier: ModelTier;
     available: boolean;
     failures: number;
 }
-export interface TieredPool {
-    tier: ModelTier;
-    models: TieredModel[];
-}
-export declare function classifyModel(model: OpenRouterModel): ModelTier;
+export declare function classifyModel(model: ModelInfo): ModelTier;
 export declare class ModelRegistry {
     private models;
     private tiered;
+    private providerModels;
     private initialized;
     initialise(): Promise<void>;
+    private buildTiers;
     get modelCount(): number;
+    getProviderCount(): number;
+    getProviderModels(providerId: string): ModelInfo[];
+    getAllModels(): ModelInfo[];
     getPool(tier: ModelTier): TieredModel[];
-    getAllModels(): OpenRouterModel[];
     getTier(modelId: string): ModelTier | undefined;
     resolvePrimary(): string;
     listModelsParams: import("@sinclair/typebox").TObject<{
         query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
         available_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     }>;
-    pickModelParams: import("@sinclair/typebox").TObject<{
-        tier: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        min_context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-    }>;
-    summaryParams: import("@sinclair/typebox").TObject<{}>;
     listModelsTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
-    pickModelTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
-    summaryTool(): Promise<ToolResult>;
-    private getFallbackModels;
+    modelSummaryTool(): Promise<ToolResult>;
 }
 export declare const modelRegistry: ModelRegistry;
 //# sourceMappingURL=ModelRegistry.d.ts.map