@albalink/agent 1.0.0

package/dist/index.js

@@ -0,0 +1,41 @@
+/**
+ * @alba/agent — public API
+ *
+ * Extension files import from here:
+ *   import { Type } from "@alba/agent"
+ *   import type { ExtensionAPI } from "@alba/agent"
+ */
+// Re-export TypeBox Type builder — drop-in for Pi's @earendil-works/pi-ai
+export { Type } from "@sinclair/typebox";
+// text() helper — same as what Pi provides
+export { text } from "./api/ExtensionAPI.js";
+// Registry (for advanced use / testing)
+export { Registry } from "./api/Registry.js";
+// Runner components
+export { AgentRunner } from "./runner/AgentRunner.js";
+export { ModelClient, resolveModelConfig } from "./runner/ModelClient.js";
+export { ToolDispatcher } from "./runner/ToolDispatcher.js";
+// Loader (for embedding the agent in other tools)
+export { loadExtension } from "./loader.js";
+// Theme
+export { makeTheme, T, ALBA_COLORS } from "./tui/theme.js";
+// Model intelligence
+export { ModelRegistry, modelRegistry, classifyModel } from "./models/ModelRegistry.js";
+export { CostTracker } from "./models/CostTracker.js";
+// Tools
+export { fullAnalysis, rsi, macd, ema, sma, bollingerBands, atr, getCandlesTool, getCandlesParams } from "./tools/TechnicalAnalysis.js";
+export { PriceFeed, priceFeed, getPricesTool, topMoversTool, marketOverviewTool } from "./tools/PriceFeed.js";
+export { NewsFeed, newsFeed, getNewsTool, scoreSentiment } from "./tools/NewsSentiment.js";
+export { getFearGreedTool, fundingRatesParams, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "./tools/MarketSentiment.js";
+// Session / Memory / Goals / Context
+export { SessionManager } from "./session/SessionManager.js";
+export { MemoryStore, memoryStore } from "./session/MemoryStore.js";
+export { GoalManager, goalManager } from "./session/GoalManager.js";
+export { ContextStore, contextStore } from "./session/ContextStore.js";
+// MCP server
+export { MCPServer } from "./mcp/server.js";
+// Scheduler
+export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
+// Telemetry
+export { Tracer } from "./telemetry/Tracer.js";
+//# sourceMappingURL=index.js.map

package/dist/loader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * loader.ts — loads an extension file and wires it to a Registry.
+ *
+ * Implements the full ExtensionAPI including Pi compat methods:
+ *   ui.setStatus, ui.setTheme, ui.setHeader, ctx.hasUI,
+ *   session_shutdown, before_agent_start
+ */
+import { Registry } from "./api/Registry.js";
+export interface LoaderOptions {
+    onStatusUpdate?: (key: string, value: string) => void;
+    onNotify?: (message: string) => void;
+    /** Called when the extension calls ui.showModelSelector(query). */
+    onShowModelSelector?: (query?: string) => void;
+}
+export declare function loadExtension(extensionPath: string, registry: Registry, opts?: LoaderOptions): Promise<void>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.js

@@ -0,0 +1,89 @@
+/**
+ * loader.ts — loads an extension file and wires it to a Registry.
+ *
+ * Implements the full ExtensionAPI including Pi compat methods:
+ *   ui.setStatus, ui.setTheme, ui.setHeader, ctx.hasUI,
+ *   session_shutdown, before_agent_start
+ */
+import { pathToFileURL } from "node:url";
+import { resolve, extname } from "node:path";
+import { existsSync } from "node:fs";
+import { makeTheme } from "./tui/theme.js";
+export async function loadExtension(extensionPath, registry, opts = {}) {
+    const abs = resolve(extensionPath);
+    if (!existsSync(abs)) {
+        throw new Error(`Extension file not found: ${abs}`);
+    }
+    const theme = makeTheme();
+    let _notify = opts.onNotify ?? ((_msg) => { });
+    let _setStatus = opts.onStatusUpdate ?? ((_k, _v) => { });
+    let _showModelSelector = opts.onShowModelSelector ?? ((_q) => { });
+    const ui = {
+        notify(message) { _notify(message); },
+        setStatus(key, value) { _setStatus(key, value); },
+        setTheme(_name) { },
+        setHeader(_factory) { },
+        showModelSelector(query) { _showModelSelector(query); },
+        theme,
+    };
+    const api = {
+        registerCommand(name, def) {
+            registry.addCommand(name, def);
+        },
+        registerTool(def) {
+            registry.addTool(def);
+        },
+        registerSkill(def) {
+            registry.addSkill(def);
+        },
+        on(event, handler) {
+            registry.addHook(event, handler);
+        },
+        setSystemPrompt(prompt) {
+            registry.setSystemPrompt(prompt);
+        },
+        ui,
+    };
+    const ext = extname(abs).toLowerCase();
+    let mod;
+    if (ext === ".ts") {
+        // In packaged (dist) mode Node.js cannot natively import TypeScript.
+        const jsPath = abs.replace(/\.ts$/, ".js");
+        if (existsSync(jsPath)) {
+            mod = await import(pathToFileURL(jsPath).href);
+        }
+        else {
+            throw new Error(`Cannot import TypeScript extension "${abs}" in packaged mode.\n` +
+                `Ensure the extension is compiled or run: npm run build`);
+        }
+    }
+    else {
+        mod = await import(pathToFileURL(abs).href);
+    }
+    const fn = mod.default ?? mod;
+    if (typeof fn !== "function") {
+        throw new Error(`Extension must export a default function. Got: ${typeof fn} from ${abs}`);
+    }
+    // Intercept console.log/error/warn during extension load so that any
+    // stray prints in the extension (e.g. loadSkills logging) are routed
+    // through ui.notify instead of raw stdout writes that corrupt the TUI.
+    const _origLog = console.log;
+    const _origError = console.error;
+    const _origWarn = console.warn;
+    const _extLog = (...args) => {
+        const msg = args.map(a => (typeof a === "string" ? a : String(a))).join(" ");
+        ui.notify(msg);
+    };
+    console.log = _extLog;
+    console.error = _extLog;
+    console.warn = _extLog;
+    try {
+        await fn(api);
+    }
+    finally {
+        console.log = _origLog;
+        console.error = _origError;
+        console.warn = _origWarn;
+    }
+}
+//# sourceMappingURL=loader.js.map

package/dist/mcp/entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entry.d.ts.map

package/dist/mcp/entry.js

@@ -0,0 +1,71 @@
+/**
+ * MCP server entry — bootstraps the Registry with built-in tools
+ * and starts the MCP stdio server.
+ */
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { config as loadDotenv } from "dotenv";
+import { Registry } from "../api/Registry.js";
+import { loadExtension } from "../loader.js";
+import { MCPServer } from "./server.js";
+import { modelRegistry } from "../models/ModelRegistry.js";
+import { getPricesTool, topMoversTool, marketOverviewTool, getPricesParams, topMoversParams, marketOverviewParams, priceFeed, } from "../tools/PriceFeed.js";
+import { getNewsTool, getNewsParams, newsFeed } from "../tools/NewsSentiment.js";
+import { getCandlesParams, getCandlesTool, analyzeTAParams, fullAnalysis } from "../tools/TechnicalAnalysis.js";
+import { getFearGreedTool, fearGreedParams, getFundingRatesTool, fundingRatesParams, getBtcMempoolTool, btcMempoolParams, getDefiTvlTool, defiTvlParams, getSolanaStatsTool, solanaStatsParams, } from "../tools/MarketSentiment.js";
+const ALBA_HOME = process.env.ALBA_HOME ?? join(homedir(), ".alba");
+const envPath = join(ALBA_HOME, ".env");
+if (existsSync(envPath))
+    loadDotenv({ path: envPath, override: false });
+const registry = new Registry();
+// Load optional extension from --extension arg
+const extIdx = process.argv.indexOf("--extension");
+const extPath = extIdx >= 0 ? process.argv[extIdx + 1] : null;
+if (extPath && existsSync(extPath)) {
+    try {
+        await loadExtension(extPath, registry);
+    }
+    catch (e) {
+        process.stderr.write(`[MCP] Extension load failed: ${e}\n`);
+    }
+}
+// Register all built-in tools
+await modelRegistry.initialise();
+const mk = modelRegistry;
+registry.addTool({ name: "list_models", label: "List Models", description: "Search available AI models.", parameters: mk["listModelsParams"], execute: (id, p) => mk["listModelsTool"](id, p) });
+registry.addTool({ name: "get_prices", label: "Get Prices", description: "Get live crypto prices.", parameters: getPricesParams, execute: (id, p) => getPricesTool(id, p) });
+registry.addTool({ name: "get_top_movers", label: "Top Movers", description: "Top 24h price movers.", parameters: topMoversParams, execute: (id, p) => topMoversTool(id, p) });
+registry.addTool({ name: "market_overview", label: "Market Overview", description: "Aggregated market data.", parameters: marketOverviewParams, execute: () => marketOverviewTool() });
+registry.addTool({ name: "get_news", label: "Get News", description: "Crypto news + sentiment.", parameters: getNewsParams, execute: (id, p) => getNewsTool(id, p) });
+registry.addTool({ name: "get_candles", label: "Get Candles", description: "OHLCV + TA analysis from Binance.", parameters: getCandlesParams, execute: (id, p) => getCandlesTool(id, p) });
+registry.addTool({ name: "get_fear_greed", label: "Fear & Greed", description: "Crypto fear & greed index.", parameters: fearGreedParams, execute: (id, p) => getFearGreedTool(id, p) });
+registry.addTool({ name: "get_funding_rates", label: "Funding Rates", description: "Perp funding rates.", parameters: fundingRatesParams, execute: (id, p) => getFundingRatesTool(id, p) });
+registry.addTool({ name: "get_btc_mempool", label: "BTC Mempool", description: "BTC mempool + fees.", parameters: btcMempoolParams, execute: () => getBtcMempoolTool() });
+registry.addTool({ name: "get_defi_tvl", label: "DeFi TVL", description: "DeFiLlama TVL.", parameters: defiTvlParams, execute: (id, p) => getDefiTvlTool(id, p) });
+registry.addTool({ name: "get_solana_stats", label: "Solana Stats", description: "Solana TPS + health.", parameters: solanaStatsParams, execute: () => getSolanaStatsTool() });
+registry.addTool({
+    name: "analyze_ta", label: "Technical Analysis", description: "RSI, MACD, Bollinger on price arrays.",
+    parameters: analyzeTAParams,
+    execute: async (_id, p) => {
+        const params = p;
+        const closes = params.prices;
+        const candles = closes.map((c, i) => ({
+            timestamp: i, open: c, high: (params.highs?.[i] ?? c), low: (params.lows?.[i] ?? c), close: c, volume: (params.volumes?.[i] ?? 0),
+        }));
+        const results = fullAnalysis(candles);
+        const text = results.map(r => {
+            const s = r.signal === "bullish" ? "🟢" : r.signal === "bearish" ? "🔴" : "⚪";
+            return `${s} ${r.indicator}: ${typeof r.value === "number" ? r.value.toFixed(2) : String(r.value)}`;
+        }).join("\n");
+        return { content: [{ type: "text", text: `Technical Analysis:\n${text}` }], details: {} };
+    },
+});
+// Start price + news feeds
+priceFeed.track("btc", "eth", "sol", "bnb", "matic", "arb", "op", "avax");
+priceFeed.start();
+newsFeed.start();
+// Start MCP server
+const server = new MCPServer(registry);
+await server.run();
+//# sourceMappingURL=entry.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCPServer — Model Context Protocol server over stdio. (#28)
+ *
+ * Exposes all ALBA registered tools as MCP tools so they can be used
+ * by Claude Desktop, Cursor, Continue, and any MCP-compatible client.
+ *
+ * Protocol: JSON-RPC 2.0 over stdin/stdout (MCP stdio transport).
+ *
+ * Usage:
+ *   alba-mcp                        # exposes built-in tools
+ *   alba-mcp --extension ./my.ts    # includes extension tools
+ *
+ * Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "alba": {
+ *         "command": "alba-mcp",
+ *         "env": { "OPENROUTER_API_KEY": "sk-or-..." }
+ *       }
+ *     }
+ *   }
+ */
+import type { Registry } from "../api/Registry.js";
+export declare class MCPServer {
+    private registry;
+    constructor(registry: Registry);
+    run(): Promise<void>;
+    private respond;
+    private handle;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,128 @@
+/**
+ * MCPServer — Model Context Protocol server over stdio. (#28)
+ *
+ * Exposes all ALBA registered tools as MCP tools so they can be used
+ * by Claude Desktop, Cursor, Continue, and any MCP-compatible client.
+ *
+ * Protocol: JSON-RPC 2.0 over stdin/stdout (MCP stdio transport).
+ *
+ * Usage:
+ *   alba-mcp                        # exposes built-in tools
+ *   alba-mcp --extension ./my.ts    # includes extension tools
+ *
+ * Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "alba": {
+ *         "command": "alba-mcp",
+ *         "env": { "OPENROUTER_API_KEY": "sk-or-..." }
+ *       }
+ *     }
+ *   }
+ */
+import { createInterface } from "node:readline";
+export class MCPServer {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async run() {
+        const rl = createInterface({ input: process.stdin, terminal: false });
+        // MCP uses newline-delimited JSON-RPC 2.0
+        rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let req;
+            try {
+                req = JSON.parse(trimmed);
+            }
+            catch {
+                this.respond({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+                return;
+            }
+            const response = await this.handle(req);
+            this.respond(response);
+        });
+        rl.on("close", () => process.exit(0));
+        // MCP servers send an initialization notification on stderr
+        process.stderr.write("[ALBA MCP] Server ready\n");
+    }
+    respond(res) {
+        process.stdout.write(JSON.stringify(res) + "\n");
+    }
+    async handle(req) {
+        try {
+            switch (req.method) {
+                case "initialize":
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        result: {
+                            protocolVersion: "2024-11-05",
+                            capabilities: { tools: {} },
+                            serverInfo: { name: "alba", version: "0.1.5" },
+                        },
+                    };
+                case "notifications/initialized":
+                    // No response needed for notifications
+                    return { jsonrpc: "2.0", id: req.id, result: null };
+                case "tools/list":
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        result: {
+                            tools: this.registry.listTools().map(t => ({
+                                name: t.name,
+                                description: t.description,
+                                inputSchema: {
+                                    ...t.parameters,
+                                    type: "object", // MCP requires explicit type
+                                },
+                            })),
+                        },
+                    };
+                case "tools/call": {
+                    const { name, arguments: args } = (req.params ?? {});
+                    if (!name) {
+                        return { jsonrpc: "2.0", id: req.id, error: { code: -32602, message: "Missing tool name" } };
+                    }
+                    const tool = this.registry.getTool(name);
+                    if (!tool) {
+                        return { jsonrpc: "2.0", id: req.id, error: { code: -32601, message: `Tool not found: ${name}` } };
+                    }
+                    try {
+                        const result = await tool.execute("mcp", (args ?? {}));
+                        return {
+                            jsonrpc: "2.0", id: req.id,
+                            result: {
+                                content: result.content.map(c => ({ type: "text", text: c.text })),
+                                isError: false,
+                            },
+                        };
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        return {
+                            jsonrpc: "2.0", id: req.id,
+                            result: {
+                                content: [{ type: "text", text: `Tool error: ${msg}` }],
+                                isError: true,
+                            },
+                        };
+                    }
+                }
+                case "ping":
+                    return { jsonrpc: "2.0", id: req.id, result: {} };
+                default:
+                    return {
+                        jsonrpc: "2.0", id: req.id,
+                        error: { code: -32601, message: `Method not found: ${req.method}` },
+                    };
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { jsonrpc: "2.0", id: req.id, error: { code: -32603, message: `Internal error: ${msg}` } };
+        }
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/models/CostTracker.d.ts

@@ -0,0 +1,67 @@
+/**
+ * CostTracker — tracks per-session and lifetime token usage and cost.
+ *
+ * Uses OpenRouter response headers (x-credit-used) when available,
+ * otherwise estimates from the model registry's pricing data.
+ * Emits budget warnings and provides cost reports via tool/command.
+ */
+import type { ModelRegistry } from "./ModelRegistry.js";
+export interface UsageEntry {
+    model: string;
+    timestamp: number;
+    promptTokens: number;
+    completionTokens: number;
+    /** Estimated cost in nano-dollars (billionths of a dollar) */
+    estimatedCost: number;
+    /** Duration in ms */
+    duration: number;
+}
+export interface SessionUsage {
+    promptTokens: number;
+    completionTokens: number;
+    estimatedCost: number;
+    calls: number;
+    errors: number;
+}
+export interface LifetimeUsage {
+    promptTokens: number;
+    completionTokens: number;
+    estimatedCost: number;
+    calls: number;
+    modelsUsed: Set<string>;
+}
+export declare class CostTracker {
+    private modelReg;
+    private session;
+    private lifetime;
+    private budgetSession;
+    private budgetLifetime;
+    private _albaHome;
+    private budgetWarned;
+    constructor(modelReg: ModelRegistry);
+    record(modelId: string, promptTokens: number, completionTokens: number, duration: number): void;
+    recordError(): void;
+    private maybeWarnBudget;
+    getBudgetStatus(): {
+        session: SessionUsage;
+        lifetime: LifetimeUsage;
+        warnings: string[];
+    };
+    /** True if the next call would exceed the session budget. */
+    wouldExceed(estimatedCallCost: number): boolean;
+    private loadLifetime;
+    saveLifetime(): void;
+    private formatNano;
+    statusLine(): string;
+    report(): string;
+    readonly costReportParams: import("@sinclair/typebox").TObject<{}>;
+    costReportTool(): Promise<{
+        content: Array<{
+            type: "text";
+            text: string;
+        }>;
+        details: Record<string, unknown>;
+    }>;
+    resetSession(): void;
+}
+//# sourceMappingURL=CostTracker.d.ts.map

package/dist/models/CostTracker.js

@@ -0,0 +1,151 @@
+/**
+ * CostTracker — tracks per-session and lifetime token usage and cost.
+ *
+ * Uses OpenRouter response headers (x-credit-used) when available,
+ * otherwise estimates from the model registry's pricing data.
+ * Emits budget warnings and provides cost reports via tool/command.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { Type } from "@sinclair/typebox";
+const ALBA_HOME = process.env.ALBA_HOME ?? join(homedir(), ".alba");
+const COST_FILE = join(ALBA_HOME, "usage.json");
+// ── CostTracker class ─────────────────────────────────────────────────────────
+const DEFAULT_BUDGET_PER_SESSION = 1_000_000_000_000; // $1.00 in nano-dollars
+const DEFAULT_BUDGET_LIFETIME = 25_000_000_000_000; // $25.00
+export class CostTracker {
+    modelReg;
+    session = { promptTokens: 0, completionTokens: 0, estimatedCost: 0, calls: 0, errors: 0 };
+    lifetime = { promptTokens: 0, completionTokens: 0, estimatedCost: 0, calls: 0, modelsUsed: new Set() };
+    budgetSession;
+    budgetLifetime;
+    _albaHome;
+    budgetWarned = false;
+    constructor(modelReg) {
+        this.modelReg = modelReg;
+        this.budgetSession = parseInt(process.env.ALBA_BUDGET_SESSION ?? String(DEFAULT_BUDGET_PER_SESSION));
+        this.budgetLifetime = parseInt(process.env.ALBA_BUDGET_LIFETIME ?? String(DEFAULT_BUDGET_LIFETIME));
+        this._albaHome = ALBA_HOME;
+        this.loadLifetime();
+    }
+    // ── Recording ─────────────────────────────────────────────────────────────
+    record(modelId, promptTokens, completionTokens, duration) {
+        const tm = this.modelReg.getModelEntry(modelId);
+        const costPer1K = tm?.costPer1K ?? 50_000; // fallback: 50 nano-dollars/1K (=$0.00005/1K)
+        const estimatedCost = Math.round(costPer1K * (promptTokens + completionTokens) / 1000);
+        const entry = { model: modelId, timestamp: Date.now(), promptTokens, completionTokens, estimatedCost, duration };
+        // Session
+        this.session.promptTokens += promptTokens;
+        this.session.completionTokens += completionTokens;
+        this.session.estimatedCost += estimatedCost;
+        this.session.calls++;
+        // Lifetime
+        this.lifetime.promptTokens += promptTokens;
+        this.lifetime.completionTokens += completionTokens;
+        this.lifetime.estimatedCost += estimatedCost;
+        this.lifetime.calls++;
+        this.lifetime.modelsUsed.add(modelId);
+        this.maybeWarnBudget();
+    }
+    recordError() {
+        this.session.errors++;
+        this.lifetime.calls++;
+    }
+    // ── Budget ────────────────────────────────────────────────────────────────
+    maybeWarnBudget() {
+        if (this.session.estimatedCost > this.budgetSession * 0.8 && !this.budgetWarned) {
+            this.budgetWarned = true;
+            // Budget warning is surfaced via getBudgetStatus() — callers can check
+        }
+    }
+    getBudgetStatus() {
+        const warnings = [];
+        const pctSession = this.session.estimatedCost / this.budgetSession * 100;
+        const pctLifetime = this.lifetime.estimatedCost / this.budgetLifetime * 100;
+        if (pctSession >= 90)
+            warnings.push(`⚠ Session budget at ${pctSession.toFixed(0)}% — near limit`);
+        else if (pctSession >= 75)
+            warnings.push(`⚡ Session budget at ${pctSession.toFixed(0)}%`);
+        if (pctLifetime >= 90)
+            warnings.push(`⚠ Lifetime budget at ${pctLifetime.toFixed(0)}% — near limit`);
+        else if (pctLifetime >= 75)
+            warnings.push(`⚡ Lifetime budget at ${pctLifetime.toFixed(0)}%`);
+        return { session: { ...this.session }, lifetime: { ...this.lifetime, modelsUsed: new Set(this.lifetime.modelsUsed) }, warnings };
+    }
+    /** True if the next call would exceed the session budget. */
+    wouldExceed(estimatedCallCost) {
+        return this.session.estimatedCost + estimatedCallCost > this.budgetSession;
+    }
+    // ── Persistence ────────────────────────────────────────────────────────────
+    loadLifetime() {
+        try {
+            mkdirSync(this._albaHome, { recursive: true });
+            if (!existsSync(COST_FILE))
+                return;
+            const raw = JSON.parse(readFileSync(COST_FILE, "utf-8"));
+            this.lifetime.promptTokens = raw.promptTokens ?? 0;
+            this.lifetime.completionTokens = raw.completionTokens ?? 0;
+            this.lifetime.estimatedCost = raw.estimatedCost ?? 0;
+            this.lifetime.calls = raw.calls ?? 0;
+            this.lifetime.modelsUsed = new Set(raw.modelsUsed ?? []);
+        }
+        catch { /* best effort */ }
+    }
+    saveLifetime() {
+        try {
+            mkdirSync(this._albaHome, { recursive: true });
+            writeFileSync(COST_FILE, JSON.stringify({
+                promptTokens: this.lifetime.promptTokens,
+                completionTokens: this.lifetime.completionTokens,
+                estimatedCost: this.lifetime.estimatedCost,
+                calls: this.lifetime.calls,
+                modelsUsed: [...this.lifetime.modelsUsed],
+            }));
+        }
+        catch { /* best effort */ }
+    }
+    // ── Formatting ─────────────────────────────────────────────────────────────
+    formatNano(cost) {
+        return `$${(cost / 1_000_000_000).toFixed(4)}`;
+    }
+    statusLine() {
+        return `${this.formatNano(this.session.estimatedCost)} · ${this.session.calls}calls`;
+    }
+    report() {
+        const s = this.session;
+        return [
+            `Session: ${s.calls} calls · ${s.errors} errors · ${this.formatNano(s.estimatedCost)}`,
+            `  Prompt:      ${s.promptTokens.toLocaleString()} tokens`,
+            `  Completion:  ${s.completionTokens.toLocaleString()} tokens`,
+            `Lifetime: ${this.lifetime.calls} calls · ${this.formatNano(this.lifetime.estimatedCost)}`,
+            `  Models used: ${this.lifetime.modelsUsed.size}`,
+        ].join("\n");
+    }
+    // ── Tool: cost_report ──────────────────────────────────────────────────────
+    costReportParams = Type.Object({});
+    async costReportTool() {
+        const status = this.getBudgetStatus();
+        let text = this.report();
+        if (status.warnings.length > 0) {
+            text += "\n\n" + status.warnings.join("\n");
+        }
+        return {
+            content: [{ type: "text", text }],
+            details: {
+                session_cost_nano: status.session.estimatedCost,
+                lifetime_cost_nano: status.lifetime.estimatedCost,
+                session_calls: status.session.calls,
+                lifetime_calls: status.lifetime.calls,
+                models_used: status.lifetime.modelsUsed.size,
+                warnings: status.warnings,
+            },
+        };
+    }
+    // ── Reset ──────────────────────────────────────────────────────────────────
+    resetSession() {
+        this.session = { promptTokens: 0, completionTokens: 0, estimatedCost: 0, calls: 0, errors: 0 };
+        this.budgetWarned = false;
+    }
+}
+//# sourceMappingURL=CostTracker.js.map