@jellyos/agent 0.1.4 → 0.1.6

package/dist/tools/MarketSentiment.d.ts

@@ -0,0 +1,166 @@
+/**
+ * MarketSentiment — free, no-key market data tools.
+ *
+ * #20: Fear & Greed Index (alternative.me)
+ * #19: BTC Mempool stats (mempool.space — free, no key)
+ * #19: ETH / EVM Gas prices (blocknative public — free)
+ * #19: Solana TPS (public RPC — no key)
+ * #19: DeFi TVL by chain (DeFiLlama — free, no key)
+ * #20: Binance perp funding rates (public endpoint — no key)
+ */
+import { type Static } from "@sinclair/typebox";
+export declare const fearGreedParams: import("@sinclair/typebox").TObject<{
+    days: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function getFearGreedTool(_id: string, params: Static<typeof fearGreedParams>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        current: number;
+        classification: string;
+        avg7: number;
+        trend: number[];
+        direction: string;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        current?: undefined;
+        classification?: undefined;
+        avg7?: undefined;
+        trend?: undefined;
+        direction?: undefined;
+    };
+}>;
+export declare const fundingRatesParams: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function getFundingRatesTool(_id: string, params: Static<typeof fundingRatesParams>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol: string;
+        currentRate: number;
+        annualizedPct: number;
+        sentiment: string;
+        history: {
+            fundingRate: string;
+            fundingTime: number;
+        }[];
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol?: undefined;
+        currentRate?: undefined;
+        annualizedPct?: undefined;
+        sentiment?: undefined;
+        history?: undefined;
+    };
+}>;
+export declare const btcMempoolParams: import("@sinclair/typebox").TObject<{}>;
+export declare function getBtcMempoolTool(): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        pendingTxs: number;
+        vsizeMB: number;
+        fees: {
+            fastestFee: number;
+            halfHourFee: number;
+            hourFee: number;
+            economyFee: number;
+        };
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        pendingTxs?: undefined;
+        vsizeMB?: undefined;
+        fees?: undefined;
+    };
+}>;
+export declare const defiTvlParams: import("@sinclair/typebox").TObject<{
+    chain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare function getDefiTvlTool(_id: string, params: Static<typeof defiTvlParams>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        chain: string;
+        tvl: number;
+        change7d: string | null;
+        chains?: undefined;
+        totalTvl?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        chains: {
+            name: string;
+            tvl: number;
+        }[];
+        totalTvl: number;
+        chain?: undefined;
+        tvl?: undefined;
+        change7d?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        chain?: undefined;
+        tvl?: undefined;
+        change7d?: undefined;
+        chains?: undefined;
+        totalTvl?: undefined;
+    };
+}>;
+export declare const solanaStatsParams: import("@sinclair/typebox").TObject<{}>;
+export declare function getSolanaStatsTool(): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        avgTps: number;
+        maxTps: number;
+        latestSlot: number;
+        samples: number[];
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        avgTps?: undefined;
+        maxTps?: undefined;
+        latestSlot?: undefined;
+        samples?: undefined;
+    };
+}>;
+//# sourceMappingURL=MarketSentiment.d.ts.map

package/dist/tools/MarketSentiment.js

@@ -0,0 +1,209 @@
+/**
+ * MarketSentiment — free, no-key market data tools.
+ *
+ * #20: Fear & Greed Index (alternative.me)
+ * #19: BTC Mempool stats (mempool.space — free, no key)
+ * #19: ETH / EVM Gas prices (blocknative public — free)
+ * #19: Solana TPS (public RPC — no key)
+ * #19: DeFi TVL by chain (DeFiLlama — free, no key)
+ * #20: Binance perp funding rates (public endpoint — no key)
+ */
+import { Type } from "@sinclair/typebox";
+// ── Fear & Greed Index ────────────────────────────────────────────────────────
+export const fearGreedParams = Type.Object({
+    days: Type.Optional(Type.Number({ description: "Number of historical days to return (default: 7, max: 30)" })),
+});
+export async function getFearGreedTool(_id, params) {
+    const days = Math.min(params.days ?? 7, 30);
+    try {
+        const res = await fetch(`https://api.alternative.me/fng/?limit=${days}`, { signal: AbortSignal.timeout(8_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        const items = data.data ?? [];
+        const current = items[0];
+        if (!current)
+            throw new Error("No data returned");
+        const val = parseInt(current.value);
+        const emoji = val >= 75 ? "😱 Extreme Greed" : val >= 55 ? "😀 Greed"
+            : val >= 45 ? "😐 Neutral" : val >= 25 ? "😨 Fear"
+                : "😱 Extreme Fear";
+        const trend = items.slice(0, 7).map(d => parseInt(d.value));
+        const avg7 = Math.round(trend.reduce((a, b) => a + b, 0) / trend.length);
+        const direction = trend.length > 1
+            ? (trend[0] > trend[trend.length - 1] ? "↑ rising" : trend[0] < trend[trend.length - 1] ? "↓ falling" : "→ flat")
+            : "";
+        const historyLine = items.slice(0, Math.min(days, 7))
+            .map(d => `${d.value}(${d.value_classification.slice(0, 4)})`)
+            .join(" → ");
+        const text = [
+            `Fear & Greed Index: ${val} — ${emoji}`,
+            `7-day avg: ${avg7}  Trend: ${direction}`,
+            `History: ${historyLine}`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text }],
+            details: { current: val, classification: current.value_classification, avg7, trend, direction },
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: `Fear & Greed fetch failed: ${msg}` }], details: {} };
+    }
+}
+// ── Binance Perp Funding Rates ────────────────────────────────────────────────
+export const fundingRatesParams = Type.Object({
+    symbol: Type.Optional(Type.String({ description: "Symbol e.g. BTC, ETH (default: BTC)" })),
+    limit: Type.Optional(Type.Number({ description: "Number of historical funding periods (default: 8)" })),
+});
+export async function getFundingRatesTool(_id, params) {
+    const sym = (params.symbol?.toUpperCase() ?? "BTC").replace(/USDT$/, "") + "USDT";
+    const limit = Math.min(params.limit ?? 8, 100);
+    try {
+        const res = await fetch(`https://fapi.binance.com/fapi/v1/fundingRate?symbol=${sym}&limit=${limit}`, { signal: AbortSignal.timeout(8_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        if (!data.length)
+            throw new Error("No data");
+        const current = data[data.length - 1];
+        const rate = parseFloat(current.fundingRate);
+        const annRate = rate * 3 * 365 * 100; // 3x daily → annual %
+        const sentiment = rate > 0.001 ? "Longs paying shorts (bullish bias)" :
+            rate < -0.001 ? "Shorts paying longs (bearish bias)" : "Neutral";
+        const history = data.map(d => (parseFloat(d.fundingRate) * 100).toFixed(4) + "%").join(", ");
+        const text = [
+            `${sym} Funding Rate: ${(rate * 100).toFixed(4)}% per 8h`,
+            `Annualized: ${annRate.toFixed(1)}%`,
+            `Sentiment: ${sentiment}`,
+            `History (${data.length} periods): ${history}`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text }],
+            details: { symbol: sym, currentRate: rate, annualizedPct: annRate, sentiment, history: data },
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: `Funding rate fetch failed for ${sym}: ${msg}` }], details: {} };
+    }
+}
+// ── BTC Mempool Stats ─────────────────────────────────────────────────────────
+export const btcMempoolParams = Type.Object({});
+export async function getBtcMempoolTool() {
+    try {
+        const [statsRes, feesRes] = await Promise.all([
+            fetch("https://mempool.space/api/mempool", { signal: AbortSignal.timeout(8_000), headers: { "User-Agent": "JellyOS/1.0" } }),
+            fetch("https://mempool.space/api/v1/fees/recommended", { signal: AbortSignal.timeout(8_000), headers: { "User-Agent": "JellyOS/1.0" } }),
+        ]);
+        if (!statsRes.ok || !feesRes.ok)
+            throw new Error("mempool.space API error");
+        const stats = await statsRes.json();
+        const fees = await feesRes.json();
+        const congestion = stats.count > 100_000 ? "🔴 HIGH" : stats.count > 50_000 ? "🟡 MEDIUM" : "🟢 LOW";
+        const text = [
+            `BTC Mempool`,
+            `Pending txs:  ${stats.count.toLocaleString()}  Size: ${(stats.vsize / 1_000_000).toFixed(1)} MB`,
+            `Congestion:   ${congestion}`,
+            `Fee rates (sat/vB):`,
+            `  Next block:  ${fees.fastestFee}`,
+            `  ~30 min:     ${fees.halfHourFee}`,
+            `  ~1 hour:     ${fees.hourFee}`,
+            `  Economy:     ${fees.economyFee}`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text }],
+            details: { pendingTxs: stats.count, vsizeMB: stats.vsize / 1_000_000, fees },
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: `BTC mempool fetch failed: ${msg}` }], details: {} };
+    }
+}
+// ── DeFi TVL ─────────────────────────────────────────────────────────────────
+export const defiTvlParams = Type.Object({
+    chain: Type.Optional(Type.String({ description: "Chain name e.g. ethereum, bsc, solana, arbitrum (omit for all chains)" })),
+});
+export async function getDefiTvlTool(_id, params) {
+    try {
+        const url = params.chain
+            ? `https://api.llama.fi/v2/historicalChainTvl/${encodeURIComponent(params.chain)}`
+            : "https://api.llama.fi/v2/chains";
+        const res = await fetch(url, { signal: AbortSignal.timeout(10_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        if (params.chain) {
+            // Historical TVL for one chain
+            const arr = data;
+            if (!arr.length)
+                throw new Error("No data for chain");
+            const latest = arr[arr.length - 1];
+            const prev7 = arr[Math.max(0, arr.length - 8)];
+            const chg7 = prev7 ? ((latest.tvl - prev7.tvl) / prev7.tvl * 100).toFixed(1) : null;
+            const text = [
+                `DeFi TVL — ${params.chain}`,
+                `Current TVL: $${(latest.tvl / 1e9).toFixed(2)}B`,
+                chg7 ? `7-day change: ${parseFloat(chg7) >= 0 ? "+" : ""}${chg7}%` : "",
+                `As of: ${new Date(latest.date * 1000).toLocaleDateString()}`,
+            ].filter(Boolean).join("\n");
+            return { content: [{ type: "text", text }], details: { chain: params.chain, tvl: latest.tvl, change7d: chg7 } };
+        }
+        else {
+            // All chains ranked by TVL
+            const chains = data
+                .filter(c => c.tvl > 100_000_000)
+                .sort((a, b) => b.tvl - a.tvl)
+                .slice(0, 15);
+            const totalTvl = chains.reduce((s, c) => s + c.tvl, 0);
+            const rows = chains.map((c, i) => `  ${String(i + 1).padStart(2)}. ${c.name.padEnd(16)} $${(c.tvl / 1e9).toFixed(2)}B`);
+            const text = [
+                `DeFi TVL by Chain (top 15)`,
+                `Total tracked: $${(totalTvl / 1e9).toFixed(1)}B`,
+                ...rows,
+            ].join("\n");
+            return { content: [{ type: "text", text }], details: { chains, totalTvl } };
+        }
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: `DeFi TVL fetch failed: ${msg}` }], details: {} };
+    }
+}
+// ── Solana Network Stats ──────────────────────────────────────────────────────
+export const solanaStatsParams = Type.Object({});
+export async function getSolanaStatsTool() {
+    try {
+        const res = await fetch("https://api.mainnet-beta.solana.com", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "User-Agent": "JellyOS/1.0" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getRecentPerformanceSamples", params: [5] }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const body = await res.json();
+        const samples = body.result ?? [];
+        if (!samples.length)
+            throw new Error("No samples");
+        const tpsArr = samples.map(s => Math.round(s.numTransactions / s.samplePeriodSecs));
+        const avgTps = Math.round(tpsArr.reduce((a, b) => a + b, 0) / tpsArr.length);
+        const maxTps = Math.max(...tpsArr);
+        const latestSlot = samples[0]?.slot ?? 0;
+        const health = avgTps > 3000 ? "🟢 Healthy" : avgTps > 1500 ? "🟡 Moderate" : "🔴 Degraded";
+        const text = [
+            `Solana Network Stats`,
+            `TPS (avg 5 samples): ${avgTps.toLocaleString()}`,
+            `TPS (peak sample):   ${maxTps.toLocaleString()}`,
+            `Latest slot:         ${latestSlot.toLocaleString()}`,
+            `Network health:      ${health}`,
+        ].join("\n");
+        return { content: [{ type: "text", text }], details: { avgTps, maxTps, latestSlot, samples: tpsArr } };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: `Solana stats fetch failed: ${msg}` }], details: {} };
+    }
+}
+//# sourceMappingURL=MarketSentiment.js.map

package/dist/tools/NewsSentiment.js

@@ -41,34 +41,61 @@ export function scoreSentiment(text) {
     return hits === 0 ? 0 : Math.max(-1, Math.min(1, score / hits));
 }
 // ── Fetch & parse ────────────────────────────────────────────────────────────
+/**
+ * Proper RSS item extractor — handles CDATA, encoded entities, attributes.
+ * No regex on the whole document; scans block by block.
+ */
+function extractTag(block, tag) {
+    // Try CDATA form first: <tag><![CDATA[...]]></tag>
+    const cdataRe = new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]>`, "i");
+    const cdataM = block.match(cdataRe);
+    if (cdataM?.[1])
+        return cdataM[1].trim();
+    // Plain text form: <tag ...>content</tag>
+    const plainRe = new RegExp(`<${tag}[^>]*>([^<]*)`, "i");
+    const plainM = block.match(plainRe);
+    if (plainM?.[1]) {
+        return plainM[1]
+            .replace(/&amp;/g, "&")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .trim();
+    }
+    return "";
+}
 async function fetchRSS(url, source) {
     try {
         const res = await fetch(url, {
             signal: AbortSignal.timeout(10_000),
-            headers: { "User-Agent": "JellyOS/1.0", "Accept": "application/rss+xml, application/xml, text/xml" },
+            headers: { "User-Agent": "JellyOS/1.0", "Accept": "application/rss+xml, application/xml, text/xml, */*" },
         });
         if (!res.ok)
             return [];
-        const text = await res.text();
-        // Parse RSS items with regex (no XML parser dependency)
+        const xml = await res.text();
+        // Find all <item>...</item> blocks (also handles <entry> for Atom feeds)
+        const TAG_RE = /<(?:item|entry)[^>]*>([\s\S]*?)<\/(?:item|entry)>/gi;
         const items = [];
-        const itemMatches = text.match(/<item[\s\S]*?<\/item>/gi) ?? [];
-        for (const item of itemMatches) {
-            const titleMatch = item.match(/<title[^>]*><!\[CDATA\[(.*?)\]\]><\/title>|<title[^>]*>(.*?)<\/title>/i);
-            const linkMatch = item.match(/<link[^>]*>(.*?)<\/link>/i);
-            const dateMatch = item.match(/<pubDate[^>]*>(.*?)<\/pubDate>/i);
-            const title = titleMatch?.[1] ?? titleMatch?.[2] ?? "";
-            if (!title.trim())
+        let match;
+        while ((match = TAG_RE.exec(xml)) !== null) {
+            const block = match[1] ?? "";
+            const title = extractTag(block, "title");
+            const link = extractTag(block, "link") || extractTag(block, "guid");
+            const pubDate = extractTag(block, "pubDate") || extractTag(block, "updated") || extractTag(block, "published");
+            if (!title)
                 continue;
             items.push({
                 title,
                 source,
-                url: linkMatch?.[1] ?? "",
-                published: dateMatch ? new Date(dateMatch[1]).getTime() : Date.now(),
+                url: link,
+                published: pubDate ? (new Date(pubDate).getTime() || Date.now()) : Date.now(),
                 sentiment: scoreSentiment(title),
             });
+            if (items.length >= 25)
+                break; // cap per feed
         }
-        return items.slice(0, 20);
+        return items;
     }
     catch {
         return [];

package/dist/tools/PriceFeed.d.ts

@@ -43,6 +43,8 @@ export declare class PriceFeed extends EventEmitter {
     /** Add symbols to track. IDs are auto-resolved from the symbol map. */
     track(...symbols: string[]): void;
     fetchAll(): Promise<void>;
+    private fetchBinance;
+    private fetchCoinGecko;
     get(symbol: string): PriceTick | undefined;
     getMultiple(symbols: string[]): PriceTick[];
     getAll(): PriceTick[];

package/dist/tools/PriceFeed.js

@@ -81,37 +81,89 @@ export class PriceFeed extends EventEmitter {
     }
     // ── Fetch ────────────────────────────────────────────────────────────────
     async fetchAll() {
+        // #17: Fan-out to Binance (primary) + CoinGecko (secondary)
+        // Binance: no rate limits on public endpoints, real-time order book prices
+        // CoinGecko: covers long-tail tokens Binance doesn't list, includes market cap
+        const [binanceResult, cgResult] = await Promise.allSettled([
+            this.fetchBinance(),
+            this.fetchCoinGecko(),
+        ]);
+        let updated = false;
+        // Binance wins for price precision on listed pairs
+        if (binanceResult.status === "fulfilled") {
+            for (const tick of binanceResult.value) {
+                this.prices.set(tick.symbol.toLowerCase(), tick);
+                updated = true;
+            }
+        }
+        // CoinGecko fills gaps (market cap data, unlisted tokens)
+        if (cgResult.status === "fulfilled") {
+            for (const tick of cgResult.value) {
+                const key = tick.symbol.toLowerCase();
+                const existing = this.prices.get(key);
+                if (!existing) {
+                    // Token not on Binance — add from CoinGecko
+                    this.prices.set(key, tick);
+                    updated = true;
+                }
+                else if (tick.marketCap > 0) {
+                    // Enrich Binance tick with market cap from CoinGecko
+                    existing.marketCap = tick.marketCap;
+                }
+            }
+        }
+        if (updated)
+            this.emit("prices", [...this.prices.values()]);
+    }
+    async fetchBinance() {
+        // Build list of USDT pairs for tracked symbols
+        const pairs = [...this.tracking]
+            .map(s => s.toUpperCase() + "USDT")
+            .filter(s => !s.startsWith("USDT") && !s.startsWith("DAI")); // skip stablecoins
+        if (!pairs.length)
+            return [];
+        const url = `https://api.binance.com/api/v3/ticker/24hr?symbols=${encodeURIComponent(JSON.stringify(pairs))}`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(8_000),
+            headers: { "User-Agent": "JellyOS/1.0" },
+        });
+        if (!res.ok)
+            throw new Error(`Binance ticker HTTP ${res.status}`);
+        const data = await res.json();
+        return data.map(d => ({
+            symbol: d.symbol.replace(/USDT$/, ""),
+            price: parseFloat(d.lastPrice),
+            change24h: parseFloat(d.priceChangePercent),
+            volume24h: parseFloat(d.quoteVolume),
+            marketCap: 0, // Binance doesn't provide market cap — CoinGecko fills this
+            high24h: parseFloat(d.highPrice),
+            low24h: parseFloat(d.lowPrice),
+            source: "binance",
+            timestamp: Date.now(),
+        }));
+    }
+    async fetchCoinGecko() {
         const ids = [...this.tracking]
             .map(s => SYMBOL_TO_ID[s])
-            .filter(Boolean)
+            .filter((id) => Boolean(id))
             .join(",");
         if (!ids)
-            return;
-        try {
-            const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${ids}&order=market_cap_desc&sparkline=false`, { signal: AbortSignal.timeout(10_000), headers: { "User-Agent": "JellyOS/1.0" } });
-            if (!res.ok)
-                return;
-            const data = (await res.json());
-            for (const coin of data) {
-                const symbol = coin.symbol.toUpperCase();
-                const tick = {
-                    symbol,
-                    price: coin.current_price,
-                    change24h: coin.price_change_percentage_24h ?? 0,
-                    volume24h: coin.total_volume ?? 0,
-                    marketCap: coin.market_cap ?? 0,
-                    high24h: coin.high_24h ?? 0,
-                    low24h: coin.low_24h ?? 0,
-                    source: "coingecko",
-                    timestamp: Date.now(),
-                };
-                this.prices.set(symbol.toLowerCase(), tick);
-            }
-            this.emit("prices", [...this.prices.values()]);
-        }
-        catch {
-            // Silent — will retry next interval
-        }
+            return [];
+        const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${ids}&order=market_cap_desc&sparkline=false`, { signal: AbortSignal.timeout(10_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok)
+            throw new Error(`CoinGecko HTTP ${res.status}`);
+        const data = await res.json();
+        return data.map(coin => ({
+            symbol: coin.symbol.toUpperCase(),
+            price: coin.current_price,
+            change24h: coin.price_change_percentage_24h ?? 0,
+            volume24h: coin.total_volume ?? 0,
+            marketCap: coin.market_cap ?? 0,
+            high24h: coin.high_24h ?? 0,
+            low24h: coin.low_24h ?? 0,
+            source: "coingecko",
+            timestamp: Date.now(),
+        }));
     }
     // ── Query ─────────────────────────────────────────────────────────────────
     get(symbol) {

package/dist/tools/TechnicalAnalysis.d.ts

@@ -5,6 +5,7 @@
  * All calculations are pure math on price arrays — no external API needed.
  * Designed to be exposed as tools the AI can call autonomously.
  */
+import { type Static } from "@sinclair/typebox";
 export interface OHLCV {
     timestamp: number;
     open: number;
@@ -70,4 +71,40 @@ export declare const macdParams: import("@sinclair/typebox").TObject<{
     slow: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     signal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
+export declare const getCandlesParams: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TString;
+    interval: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    analyze: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare function getCandlesTool(_id: string, params: Static<typeof getCandlesParams>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol?: undefined;
+        interval?: undefined;
+        candleCount?: undefined;
+        latest?: undefined;
+        priceChangePercent?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol: string;
+        interval: string;
+        candleCount: number;
+        latest: {
+            close: number;
+            high: number;
+            low: number;
+            volume: number;
+        };
+        priceChangePercent: number;
+    };
+}>;
 //# sourceMappingURL=TechnicalAnalysis.d.ts.map