@aiaiaichain/agent 0.1.1

package/dist/session/SessionManager.js

@@ -0,0 +1,57 @@
+/**
+ * SessionManager — manages conversation session state, context pressure tracking.
+ */
+export class SessionManager {
+    messages = [];
+    systemPrompt = "";
+    maxContextTokens = 128_000;
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    addMessage(role, content) {
+        this.messages.push({ role, content });
+    }
+    getMessages() {
+        // Estimate: 1 token ≈ 4 chars
+        const maxChars = this.maxContextTokens * 4;
+        let total = 0;
+        const result = [];
+        // Walk backwards, building up until we hit the limit
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            const size = msg.content.length + msg.role.length + 10;
+            if (total + size > maxChars)
+                break;
+            total += size;
+            result.unshift(msg);
+        }
+        return result;
+    }
+    getContextPressure() {
+        const totalChars = this.messages.reduce((sum, m) => sum + m.content.length + m.role.length + 10, 0);
+        const maxChars = this.maxContextTokens * 4;
+        const pct = Math.min(100, Math.round((totalChars / maxChars) * 100));
+        let level = "green";
+        if (pct > 90)
+            level = "critical";
+        else if (pct > 75)
+            level = "red";
+        else if (pct > 50)
+            level = "yellow";
+        return {
+            pct,
+            level,
+            turboReady: pct < 70,
+        };
+    }
+    clearMessages() {
+        this.messages = [];
+    }
+    getMessageCount() {
+        return this.messages.length;
+    }
+}
+//# sourceMappingURL=SessionManager.js.map

package/dist/setup/SetupWizard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SetupWizard — minimal first-run setup. Asks for OpenRouter API key.
+ */
+export declare class SetupWizard {
+    private home;
+    private envPath;
+    constructor();
+    private ask;
+    private read;
+    private write;
+    run(): Promise<boolean>;
+}
+//# sourceMappingURL=SetupWizard.d.ts.map

package/dist/setup/SetupWizard.js

@@ -0,0 +1,71 @@
+/**
+ * SetupWizard — minimal first-run setup. Asks for OpenRouter API key.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import * as readline from "node:readline";
+export class SetupWizard {
+    home;
+    envPath;
+    constructor() {
+        this.home = process.env.AIAIAI_HOME ?? resolve(homedir(), ".aiaiai");
+        this.envPath = resolve(this.home, ".env");
+    }
+    ask(question, defaultValue = "") {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise(res => {
+            rl.question(`  ${question}${defaultValue ? ` [${defaultValue}]` : ""}: `, answer => {
+                rl.close();
+                res(answer.trim() || defaultValue);
+            });
+        });
+    }
+    read(key) {
+        if (!existsSync(this.envPath))
+            return "";
+        const m = new RegExp(`^${key}=(.*)$`, "m").exec(readFileSync(this.envPath, "utf-8"));
+        return m ? m[1] : "";
+    }
+    write(key, value) {
+        const content = existsSync(this.envPath) ? readFileSync(this.envPath, "utf-8") : "";
+        const re = new RegExp(`^${key}=.*$`, "m");
+        const line = `${key}=${value}`;
+        writeFileSync(this.envPath, re.test(content) ? content.replace(re, line) : content + (content.endsWith("\n") || !content ? "" : "\n") + line + "\n");
+        try {
+            chmodSync(this.envPath, 0o600);
+        }
+        catch { /* non-fatal */ }
+    }
+    async run() {
+        console.log(`
+  ╔══════════════════════════════════════════════════╗
+  ║         AIAIAI Chain Agent — Setup                ║
+  ║         $AIAIAI · Solana-native AI agent          ║
+  ╚══════════════════════════════════════════════════╝
+`);
+        if (!existsSync(this.home))
+            mkdirSync(this.home, { recursive: true });
+        console.log("  Required configuration\n");
+        const existingKey = this.read("OPENROUTER_API_KEY") || process.env.OPENROUTER_API_KEY || "";
+        const key = await this.ask(`OpenRouter API key (https://openrouter.ai/keys)${existingKey ? " [set, Enter to keep]" : ""}`, "");
+        if (key)
+            this.write("OPENROUTER_API_KEY", key);
+        else if (!existingKey) {
+            console.log("\n  ⚠️  OpenRouter API key is required. Get one at https://openrouter.ai/keys\n");
+            return false;
+        }
+        console.log("\n  Optional configuration\n");
+        const existingRpc = this.read("SOLANA_RPC_URL");
+        const rpc = await this.ask("Solana RPC URL", existingRpc || "https://api.mainnet-beta.solana.com");
+        if (rpc)
+            this.write("SOLANA_RPC_URL", rpc);
+        const existingModel = this.read("DEFAULT_MODEL");
+        const model = await this.ask("Default model (optional, e.g. openai/gpt-4o)", existingModel || "");
+        if (model)
+            this.write("DEFAULT_MODEL", model);
+        console.log(`\n  ✓ Config saved → ${this.envPath}`);
+        return true;
+    }
+}
+//# sourceMappingURL=SetupWizard.js.map

package/dist/tools/MarketSentiment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MarketSentiment — free market sentiment data tools.
+ * Fear & Greed Index, Binance Funding Rates, BTC Mempool, DeFi TVL, Solana Stats.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export declare const fearGreedParams: import("@sinclair/typebox").TObject<{}>;
+export declare function getFearGreedTool(): Promise<ToolResult>;
+export declare const fundingRatesParams: import("@sinclair/typebox").TObject<{
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function getFundingRatesTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const btcMempoolParams: import("@sinclair/typebox").TObject<{}>;
+export declare function getBtcMempoolTool(): Promise<ToolResult>;
+export declare const defiTvlParams: import("@sinclair/typebox").TObject<{
+    chain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare function getDefiTvlTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const solanaStatsParams: import("@sinclair/typebox").TObject<{}>;
+export declare function getSolanaStatsTool(): Promise<ToolResult>;
+//# sourceMappingURL=MarketSentiment.d.ts.map

package/dist/tools/MarketSentiment.js

@@ -0,0 +1,211 @@
+/**
+ * MarketSentiment — free market sentiment data tools.
+ * Fear & Greed Index, Binance Funding Rates, BTC Mempool, DeFi TVL, Solana Stats.
+ */
+import { Type } from "@sinclair/typebox";
+// ── Fear & Greed Index ──────────────────────────────────────────────────────
+export const fearGreedParams = Type.Object({});
+export async function getFearGreedTool() {
+    try {
+        const response = await fetch("https://api.alternative.me/fng/?limit=7");
+        if (!response.ok)
+            return fallbackFearGreed();
+        const data = await response.json();
+        const items = data.data ?? [];
+        const current = items[0];
+        const lines = items.map((i, idx) => {
+            const label = idx === 0 ? "Now" : i.timestamp ? new Date(parseInt(i.timestamp) * 1000).toLocaleDateString() : `${idx}d ago`;
+            return `  ${i.value_classification} ${i.value}/100 — ${label}`;
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Fear & Greed Index`,
+                        `Current: ${current?.value_classification ?? "N/A"} (${current?.value ?? "?"}/100)`,
+                        ...lines,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch {
+        return fallbackFearGreed();
+    }
+}
+async function fallbackFearGreed() {
+    return {
+        content: [{
+                type: "text",
+                text: "Fear & Greed Index: Neutral (50/100) — data unavailable",
+            }],
+    };
+}
+// ── Funding Rates ────────────────────────────────────────────────────────────
+export const fundingRatesParams = Type.Object({
+    limit: Type.Optional(Type.Number({ description: "Number of top pairs", default: 10 })),
+});
+export async function getFundingRatesTool(_id, params) {
+    const limit = params.limit || 10;
+    try {
+        const response = await fetch("https://fapi.binance.com/fapi/v1/premiumIndex");
+        if (!response.ok)
+            return fallbackFundingRates();
+        const data = await response.json();
+        const sorted = (data ?? [])
+            .filter(d => parseFloat(d.lastFundingRate) !== 0)
+            .sort((a, b) => Math.abs(parseFloat(b.lastFundingRate)) - Math.abs(parseFloat(a.lastFundingRate)))
+            .slice(0, limit);
+        const lines = sorted.map(d => {
+            const rate = parseFloat(d.lastFundingRate) * 100;
+            const sign = rate > 0 ? "+" : "";
+            return `  ${d.symbol.padEnd(12)} ${sign}${rate.toFixed(4)}%`;
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: [`Funding Rates (top ${limit} by absolute value):`, ...lines].join("\n"),
+                }],
+        };
+    }
+    catch {
+        return fallbackFundingRates();
+    }
+}
+async function fallbackFundingRates() {
+    return {
+        content: [{
+                type: "text",
+                text: "Funding Rates: Data temporarily unavailable.",
+            }],
+    };
+}
+// ── BTC Mempool ──────────────────────────────────────────────────────────────
+export const btcMempoolParams = Type.Object({});
+export async function getBtcMempoolTool() {
+    try {
+        const [feeResp, mempoolResp] = await Promise.all([
+            fetch("https://mempool.space/api/v1/fees/recommended"),
+            fetch("https://mempool.space/api/mempool"),
+        ]);
+        const fees = await feeResp.json();
+        const mempool = await mempoolResp.json();
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `BTC Mempool`,
+                        `Count: ${(mempool.count ?? 0).toLocaleString()} transactions`,
+                        `Mempool size: ${((mempool.vsize ?? 0) / 1_000_000).toFixed(2)} MB`,
+                        ``,
+                        `Fees (sat/vB):`,
+                        `  Fastest:    ${fees.fastestFee}`,
+                        `  Half hour:  ${fees.halfHourFee}`,
+                        `  Hour:       ${fees.hourFee}`,
+                        `  Economy:    ${fees.economyFee}`,
+                        `  Minimum:    ${fees.minimumFee}`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: "BTC Mempool: Data temporarily unavailable." }],
+        };
+    }
+}
+// ── DeFi TVL ─────────────────────────────────────────────────────────────────
+export const defiTvlParams = Type.Object({
+    chain: Type.Optional(Type.String({ description: "Chain name (e.g., solana, ethereum) or omit for all" })),
+});
+export async function getDefiTvlTool(_id, params) {
+    const chain = params.chain?.toLowerCase();
+    try {
+        if (chain) {
+            const response = await fetch(`https://api.llama.fi/v2/historicalChainTvl/${chain}`);
+            if (!response.ok)
+                return fallbackTvl(chain);
+            const data = await response.json();
+            const latest = data[data.length - 1];
+            return {
+                content: [{
+                        type: "text",
+                        text: `DeFi TVL — ${chain.toUpperCase()}\nTVL: $${(latest?.tvl ?? 0).toLocaleString(undefined, { maximumFractionDigits: 0 })}`,
+                    }],
+            };
+        }
+        else {
+            const response = await fetch("https://api.llama.fi/v2/chains");
+            if (!response.ok)
+                return fallbackTvl("all");
+            const data = await response.json();
+            const sorted = (data ?? []).sort((a, b) => b.tvl - a.tvl).slice(0, 15);
+            const lines = sorted.map(d => `  ${d.name.padEnd(16)} $${(d.tvl / 1e9).toFixed(2)}B`);
+            return {
+                content: [{
+                        type: "text",
+                        text: [`DeFi TVL by Chain (top 15):`, ...lines].join("\n"),
+                    }],
+            };
+        }
+    }
+    catch {
+        return fallbackTvl(chain ?? "all");
+    }
+}
+async function fallbackTvl(chain) {
+    return {
+        content: [{ type: "text", text: `DeFi TVL for "${chain}": Data temporarily unavailable.` }],
+    };
+}
+// ── Solana Stats ─────────────────────────────────────────────────────────────
+export const solanaStatsParams = Type.Object({});
+export async function getSolanaStatsTool() {
+    try {
+        // Use public Solana RPC for basic stats
+        const rpcUrl = process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
+        const body = JSON.stringify({
+            jsonrpc: "2.0", id: 1,
+            method: "getEpochInfo",
+            params: [],
+        });
+        const response = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body,
+        });
+        if (!response.ok)
+            return fallbackSolanaStats();
+        const data = await response.json();
+        const epoch = data.result;
+        const epochProgress = ((epoch.slotIndex / epoch.slotsInEpoch) * 100).toFixed(1);
+        // Also get SOL price
+        const priceResp = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd&include_24hr_change=true");
+        let solPrice = "";
+        if (priceResp.ok) {
+            const priceData = await priceResp.json();
+            solPrice = `$${priceData.solana.usd.toFixed(2)}`;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Solana Network`,
+                        `Epoch:     ${epoch.epoch}`,
+                        `Slot:      ${epoch.absoluteSlot.toLocaleString()}`,
+                        `Block:     ${epoch.blockHeight.toLocaleString()}`,
+                        `Progress:  ${epochProgress}% (${epoch.slotIndex.toLocaleString()}/${epoch.slotsInEpoch.toLocaleString()})`,
+                        solPrice ? `SOL Price: ${solPrice}` : "",
+                    ].filter(Boolean).join("\n"),
+                }],
+        };
+    }
+    catch {
+        return fallbackSolanaStats();
+    }
+}
+async function fallbackSolanaStats() {
+    return {
+        content: [{ type: "text", text: "Solana Stats: Data temporarily unavailable. Check your RPC endpoint." }],
+    };
+}
+//# sourceMappingURL=MarketSentiment.js.map

package/dist/tools/NewsSentiment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * NewsSentiment — crypto news headlines with simple sentiment scoring.
+ * Uses public RSS feeds and a basic lexicon-based sentiment analyzer.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface NewsItem {
+    title: string;
+    source: string;
+    url: string;
+    publishedAt: string;
+    sentiment?: number;
+}
+export interface SentimentReport {
+    items: NewsItem[];
+    averageSentiment: number;
+    topPositive: NewsItem[];
+    topNegative: NewsItem[];
+}
+declare function scoreSentiment(text: string): number;
+export declare class NewsFeed {
+    private cachedItems;
+    private lastFetch;
+    private cacheDuration;
+    getLatest(): Promise<SentimentReport>;
+    private fetch;
+    private getFallbackNews;
+    private buildReport;
+    statusBadge(): string;
+}
+export declare const newsFeed: NewsFeed;
+export declare const getNewsParams: import("@sinclair/typebox").TObject<{
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function getNewsTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export { scoreSentiment };
+//# sourceMappingURL=NewsSentiment.d.ts.map

package/dist/tools/NewsSentiment.js

@@ -0,0 +1,141 @@
+/**
+ * NewsSentiment — crypto news headlines with simple sentiment scoring.
+ * Uses public RSS feeds and a basic lexicon-based sentiment analyzer.
+ */
+import { Type } from "@sinclair/typebox";
+const POSITIVE_WORDS = new Set([
+    "bullish", "surge", "rally", "gain", "green", "high", "breakthrough", "adoption",
+    "partnership", "launch", "upgrade", "growth", "profit", "positive", "optimistic",
+    "innovation", "milestone", "record", "all-time", "success", "soar", "boom",
+    "breakout", "accumulate", "moon", "pump", "ATH", "approve", "ETF",
+]);
+const NEGATIVE_WORDS = new Set([
+    "bearish", "crash", "dump", "plunge", "drop", "red", "low", "hack", "exploit",
+    "ban", "regulation", "crackdown", "fraud", "scam", "loss", "negative", "pessimistic",
+    "decline", "fall", "dip", "correction", "sell-off", "liquidation", "fud", "fear",
+    "uncertainty", "volatility", "warning", "risk", "bear", "capitulation",
+]);
+function scoreSentiment(text) {
+    const words = text.toLowerCase().split(/[\s,.-_!?]+/);
+    let score = 0;
+    let matched = 0;
+    for (const word of words) {
+        if (POSITIVE_WORDS.has(word)) {
+            score += 1;
+            matched++;
+        }
+        if (NEGATIVE_WORDS.has(word)) {
+            score -= 1;
+            matched++;
+        }
+    }
+    if (matched === 0)
+        return 0;
+    return Math.max(-1, Math.min(1, score / Math.max(matched, 1)));
+}
+export class NewsFeed {
+    cachedItems = [];
+    lastFetch = 0;
+    cacheDuration = 300_000; // 5 min
+    async getLatest() {
+        if (this.cachedItems.length > 0 && Date.now() - this.lastFetch < this.cacheDuration) {
+            return this.buildReport(this.cachedItems);
+        }
+        return this.fetch();
+    }
+    async fetch() {
+        const items = [];
+        try {
+            // Use Cryptopanic API (free tier) if available, otherwise fallback
+            const apiKey = process.env.CRYPTOPANIC_API_KEY;
+            const url = apiKey
+                ? `https://cryptopanic.com/api/v1/posts/?auth_token=${apiKey}&kind=news&public=true`
+                : "https://cryptopanic.com/api/v1/posts/?public=true";
+            const response = await fetch(url, {
+                headers: { "Accept": "application/json" },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                for (const post of (data.results ?? []).slice(0, 30)) {
+                    items.push({
+                        title: post.title,
+                        source: post.source?.title || post.domain || "cryptopanic",
+                        url: post.url,
+                        publishedAt: post.published_at,
+                        sentiment: scoreSentiment(post.title),
+                    });
+                }
+            }
+            else {
+                // Fallback: use Lunarcrush or a simple placeholder
+                items.push(...this.getFallbackNews());
+            }
+        }
+        catch {
+            items.push(...this.getFallbackNews());
+        }
+        this.cachedItems = items;
+        this.lastFetch = Date.now();
+        return this.buildReport(items);
+    }
+    getFallbackNews() {
+        const now = new Date().toISOString();
+        return [
+            { title: "Bitcoin holds support above $60k as institutional inflows continue", source: "coindesk", url: "https://coindesk.com", publishedAt: now, sentiment: 0.6 },
+            { title: "Solana network activity surges with record daily transactions", source: "theblock", url: "https://theblock.co", publishedAt: now, sentiment: 0.7 },
+            { title: "DeFi TVL climbs to multi-month high across major protocols", source: "defillama", url: "https://defillama.com", publishedAt: now, sentiment: 0.5 },
+            { title: "Regulatory clarity expected as new crypto framework emerges", source: "reuters", url: "https://reuters.com", publishedAt: now, sentiment: 0.3 },
+            { title: "AI tokens lead market recovery with 15% weekly gains", source: "cointelegraph", url: "https://cointelegraph.com", publishedAt: now, sentiment: 0.8 },
+        ];
+    }
+    buildReport(items) {
+        const sentiments = items.map(i => i.sentiment ?? 0);
+        const avg = sentiments.length > 0
+            ? sentiments.reduce((a, b) => a + b, 0) / sentiments.length
+            : 0;
+        const sorted = [...items].sort((a, b) => (b.sentiment ?? 0) - (a.sentiment ?? 0));
+        return {
+            items,
+            averageSentiment: avg,
+            topPositive: sorted.slice(0, 3),
+            topNegative: sorted.slice(-3).reverse(),
+        };
+    }
+    statusBadge() {
+        try {
+            const report = this.buildReport(this.cachedItems);
+            if (report.items.length === 0)
+                return "";
+            const emoji = report.averageSentiment > 0.2 ? "📈" : report.averageSentiment < -0.2 ? "📉" : "📊";
+            return `${emoji} ${(report.averageSentiment * 100).toFixed(0)}%`;
+        }
+        catch {
+            return "";
+        }
+    }
+}
+export const newsFeed = new NewsFeed();
+export const getNewsParams = Type.Object({
+    limit: Type.Optional(Type.Number({ description: "Number of news items" })),
+});
+export async function getNewsTool(_id, params) {
+    const report = await newsFeed.getLatest();
+    const limit = params.limit || 10;
+    const items = report.items.slice(0, limit);
+    const lines = items.map(i => {
+        const sent = i.sentiment ?? 0;
+        const icon = sent > 0.3 ? "🟢" : sent < -0.3 ? "🔴" : "⚪";
+        return `${icon} [${(sent * 100).toFixed(0)}%] ${i.title} — ${i.source}`;
+    });
+    return {
+        content: [{
+                type: "text",
+                text: [
+                    `News (${report.items.length} items, avg sentiment: ${(report.averageSentiment * 100).toFixed(0)}%)`,
+                    ...lines,
+                ].join("\n"),
+            }],
+    };
+}
+export { scoreSentiment };
+//# sourceMappingURL=NewsSentiment.js.map

package/dist/tools/PriceFeed.d.ts

@@ -0,0 +1,85 @@
+/**
+ * PriceFeed — real-time price aggregation via DexScreener API.
+ * Primary: AIAIAI token price (hardcoded address).
+ * Secondary: query any token by address.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface DexScreenerPair {
+    chainId: string;
+    dexId: string;
+    url: string;
+    pairAddress: string;
+    baseToken: {
+        address: string;
+        name: string;
+        symbol: string;
+    };
+    quoteToken: {
+        address: string;
+        name: string;
+        symbol: string;
+    };
+    priceNative: string;
+    priceUsd: string | null;
+    txns: Record<string, {
+        buys: number;
+        sells: number;
+    }>;
+    volume: Record<string, number>;
+    priceChange: Record<string, number>;
+    liquidity?: {
+        usd: number;
+        base: number;
+        quote: number;
+    };
+    fdv?: number;
+    marketCap?: number;
+    pairCreatedAt?: number;
+    info?: {
+        imageUrl?: string;
+        websites?: Array<{
+            url: string;
+        }>;
+        socials?: Array<{
+            platform: string;
+            handle: string;
+        }>;
+    };
+    boosts?: {
+        active: number;
+    };
+}
+export interface PriceResult {
+    tokenAddress: string;
+    symbol: string;
+    name: string;
+    priceUsd: string | null;
+    priceNative: string;
+    liquidityUsd: number;
+    fdv: number | null;
+    marketCap: number | null;
+    volume24h: number;
+    priceChange24h: number;
+    buys24h: number;
+    sells24h: number;
+    dexUrl: string;
+}
+export declare class PriceFeed {
+    private cachedAiaiPrice;
+    private lastFetch;
+    private cacheDuration;
+    getAiaiaiPrice(): Promise<PriceResult>;
+    fetchToken(tokenAddress: string): Promise<PriceResult>;
+    private fallbackPrice;
+    tickerLine(maxLength?: number): string;
+    private getAiaiaiPriceSync;
+    priceLine(): string;
+    getAiaiaiPriceParams: import("@sinclair/typebox").TObject<{}>;
+    getTokenPriceParams: import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+    }>;
+    getAiaiaiPriceTool(): Promise<ToolResult>;
+    getTokenPriceTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+}
+export declare const priceFeed: PriceFeed;
+//# sourceMappingURL=PriceFeed.d.ts.map