@jellyos/agent 0.1.4 → 0.1.5

package/dist/tests/ModelRegistry.test.js

@@ -0,0 +1,69 @@
+/**
+ * ModelRegistry tests — tier classification + temperature profiles.
+ */
+import { describe, it, expect } from "vitest";
+import { classifyModel } from "../models/ModelRegistry.js";
+function makeModel(id, promptPrice = "0.000005") {
+    return {
+        id,
+        name: id,
+        created: Date.now(),
+        description: "",
+        context_length: 128_000,
+        architecture: { modality: "text", tokenizer: "cl100k", instruct_type: null },
+        pricing: { prompt: promptPrice, completion: "0.000015" },
+        top_provider: { context_length: 128_000, max_completion_tokens: 4096, is_moderated: false },
+    };
+}
+describe("classifyModel() — 2025 models", () => {
+    // Orchestrator tier
+    it("classifies claude-opus-4.7 as orchestrator", () => {
+        expect(classifyModel(makeModel("anthropic/claude-opus-4.7"))).toBe("orchestrator");
+    });
+    it("classifies claude-opus-4.6 as orchestrator", () => {
+        expect(classifyModel(makeModel("anthropic/claude-opus-4.6"))).toBe("orchestrator");
+    });
+    it("classifies gpt-5.5 as orchestrator", () => {
+        expect(classifyModel(makeModel("openai/gpt-5.5"))).toBe("orchestrator");
+    });
+    it("classifies gpt-5.5-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("openai/gpt-5.5-pro"))).toBe("orchestrator");
+    });
+    it("classifies gemini-3.1-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("google/gemini-3.1-pro-preview"))).toBe("orchestrator");
+    });
+    it("classifies deepseek-v4-pro as orchestrator", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-pro"))).toBe("orchestrator");
+    });
+    it("classifies grok-4.0 as orchestrator", () => {
+        expect(classifyModel(makeModel("x-ai/grok-4.0"))).toBe("orchestrator");
+    });
+    // Analyst tier
+    it("classifies claude-sonnet-4.6 as analyst", () => {
+        expect(classifyModel(makeModel("anthropic/claude-sonnet-4.6"))).toBe("analyst");
+    });
+    it("classifies claude-sonnet-4.5 as analyst", () => {
+        expect(classifyModel(makeModel("anthropic/claude-sonnet-4.5"))).toBe("analyst");
+    });
+    it("classifies gemini-3.5-flash as analyst", () => {
+        expect(classifyModel(makeModel("google/gemini-3.5-flash"))).toBe("analyst");
+    });
+    it("classifies deepseek-v4 (non-pro) as analyst", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-flash"))).toBe("analyst");
+    });
+    // Free tier
+    it("classifies :free models as free", () => {
+        expect(classifyModel(makeModel("deepseek/deepseek-v4-flash:free", "0"))).toBe("free");
+    });
+    it("classifies free-priced models as free", () => {
+        expect(classifyModel(makeModel("meta-llama/llama-3.1-8b-instruct:free", "0"))).toBe("free");
+    });
+    // Worker fallback
+    it("classifies unknown model as worker", () => {
+        expect(classifyModel(makeModel("some-unknown/model-v1"))).toBe("worker");
+    });
+    it("classifies small llama as worker", () => {
+        expect(classifyModel(makeModel("meta-llama/llama-3.1-8b-instruct", "0.0002"))).toBe("worker");
+    });
+});
+//# sourceMappingURL=ModelRegistry.test.js.map

package/dist/tests/SessionManager.test.d.ts

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

package/dist/tests/SessionManager.test.js

@@ -0,0 +1,108 @@
+/**
+ * SessionManager tests — atomic compaction, context pressure, semantic anchors.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { SessionManager } from "../session/SessionManager.js";
+function makeUserTurn(userContent, assistantContent) {
+    return [
+        { role: "user", content: userContent },
+        { role: "assistant", content: assistantContent },
+    ];
+}
+function makeToolTurn(userContent, toolContent) {
+    const tc_id = `call_${Math.random().toString(36).slice(2)}`;
+    return [
+        { role: "user", content: userContent },
+        { role: "assistant", content: null, tool_calls: [{ id: tc_id, type: "function", function: { name: "get_prices", arguments: "{}" } }] },
+        { role: "tool", content: toolContent, name: "get_prices", tool_call_id: tc_id },
+    ];
+}
+describe("SessionManager", () => {
+    let session;
+    beforeEach(() => {
+        session = new SessionManager();
+        session.setSystemPrompt("You are JellyOS.");
+    });
+    it("getMessages() prepends system prompt", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        const msgs = session.getMessages();
+        expect(msgs[0]?.role).toBe("system");
+        expect(msgs[0]?.content).toContain("JellyOS");
+        expect(msgs.length).toBe(2);
+    });
+    it("charCount() counts history chars", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        expect(session.charCount()).toBe(5);
+    });
+    it("getContextPressure() returns green for small history", () => {
+        session.addMessage({ role: "user", content: "hi" });
+        const p = session.getContextPressure();
+        expect(p.level).toBe("green");
+        expect(p.turboReady).toBe(true);
+        expect(p.pct).toBeLessThan(50);
+    });
+    it("getContextPressure() reports yellow at 60%", () => {
+        // Add ~48KB of content (60% of 80KB)
+        const bigMsg = "x".repeat(48_000);
+        session.addMessage({ role: "user", content: bigMsg });
+        const p = session.getContextPressure();
+        expect(p.pct).toBeGreaterThanOrEqual(50);
+    });
+    it("turboReady is false when context >70%", () => {
+        const bigMsg = "x".repeat(60_000);
+        session.addMessage({ role: "user", content: bigMsg });
+        const p = session.getContextPressure();
+        expect(p.turboReady).toBe(false);
+    });
+    it("compaction never orphans tool_call_id pairs", () => {
+        // Add enough turns to trigger compaction
+        for (let i = 0; i < 20; i++) {
+            for (const msg of makeToolTurn(`question ${i}`, `tool result ${i} — ${"data".repeat(200)}`)) {
+                session.addMessage(msg);
+            }
+        }
+        const history = session.getHistory();
+        // Find all assistant messages with tool_calls
+        const toolCallMsgs = history.filter(m => m.tool_calls && m.tool_calls.length > 0);
+        for (const tcMsg of toolCallMsgs) {
+            for (const tc of tcMsg.tool_calls) {
+                // Every tool_call_id must have a corresponding tool result
+                const hasResult = history.some(m => m.role === "tool" && m.tool_call_id === tc.id);
+                expect(hasResult).toBe(true);
+            }
+        }
+    });
+    it("forceCompact() reduces history", () => {
+        for (let i = 0; i < 30; i++) {
+            for (const msg of makeUserTurn(`q${i}`, `a${i}`)) {
+                session.addMessage(msg);
+            }
+        }
+        const before = session.getHistory().length;
+        session.forceCompact();
+        const after = session.getHistory().length;
+        expect(after).toBeLessThanOrEqual(before);
+    });
+    it("clear() empties history", () => {
+        session.addMessage({ role: "user", content: "hello" });
+        session.clear();
+        expect(session.getHistory().length).toBe(0);
+    });
+});
+describe("SessionManager — SwarmRouter integration", () => {
+    it("scoreComplexity returns low score for simple price check", async () => {
+        const { scoreComplexity } = await import("../runner/SwarmRouter.js");
+        expect(scoreComplexity("what is the price of ETH")).toBeLessThan(40);
+    });
+    it("scoreComplexity returns high score for complex multi-chain analysis", async () => {
+        const { scoreComplexity } = await import("../runner/SwarmRouter.js");
+        const score = scoreComplexity("analyze ETH and BTC then compare their RSI and predict which will pump first");
+        expect(score).toBeGreaterThanOrEqual(40);
+    });
+    it("decomposeHeuristic splits on conjunctions", async () => {
+        const { decomposeHeuristic } = await import("../runner/SwarmRouter.js");
+        const tasks = decomposeHeuristic("analyze ETH and check BTC mempool and get SOL TPS", 5);
+        expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+});
+//# sourceMappingURL=SessionManager.test.js.map

package/dist/tests/TechnicalAnalysis.test.d.ts

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

package/dist/tests/TechnicalAnalysis.test.js

@@ -0,0 +1,109 @@
+/**
+ * TechnicalAnalysis tests — pure math functions, no network calls.
+ */
+import { describe, it, expect } from "vitest";
+import { rsi, macd, ema, sma, bollingerBands, rsiSignal, macdSignal } from "../tools/TechnicalAnalysis.js";
+// Generate price series for testing
+const risingPrices = Array.from({ length: 60 }, (_, i) => 100 + i * 2); // 100→218
+const fallingPrices = Array.from({ length: 60 }, (_, i) => 220 - i * 2); // 220→102
+const flatPrices = Array.from({ length: 60 }, () => 150);
+describe("sma()", () => {
+    it("returns empty array when insufficient data", () => {
+        expect(sma([100, 99], 14)).toEqual([]);
+    });
+    it("calculates correct 3-period SMA", () => {
+        const result = sma([10, 20, 30, 40], 3);
+        expect(result[0]).toBeCloseTo(20, 2); // (10+20+30)/3
+        expect(result[1]).toBeCloseTo(30, 2); // (20+30+40)/3
+    });
+    it("result length = prices.length - period + 1", () => {
+        const result = sma(risingPrices, 20);
+        expect(result.length).toBe(risingPrices.length - 20 + 1);
+    });
+});
+describe("ema()", () => {
+    it("returns first price as first EMA value", () => {
+        const result = ema([100, 110, 120], 3);
+        expect(result[0]).toBe(100);
+    });
+    it("EMA tracks price direction", () => {
+        const result = ema(risingPrices, 12);
+        expect(result[result.length - 1]).toBeGreaterThan(result[0]);
+    });
+});
+describe("rsi()", () => {
+    it("returns empty array when insufficient data", () => {
+        expect(rsi([100, 99], 14)).toEqual([]);
+    });
+    it("returns oversold (<30) for falling prices", () => {
+        const result = rsi(fallingPrices, 14);
+        expect(result[result.length - 1]).toBeLessThan(30);
+    });
+    it("returns overbought (>70) for rising prices", () => {
+        const result = rsi(risingPrices, 14);
+        expect(result[result.length - 1]).toBeGreaterThan(70);
+    });
+    it("returns neutral (~50) for flat prices", () => {
+        // RSI is undefined for perfectly flat — but should handle gracefully
+        const result = rsi(flatPrices, 14);
+        // avgLoss = 0, so RSI = 100 (no change)
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it("all values are in [0, 100]", () => {
+        const result = rsi(risingPrices, 14);
+        for (const v of result) {
+            expect(v).toBeGreaterThanOrEqual(0);
+            expect(v).toBeLessThanOrEqual(100);
+        }
+    });
+});
+describe("rsiSignal()", () => {
+    it("returns bearish for overbought RSI", () => {
+        const sig = rsiSignal([75]);
+        expect(sig.signal).toBe("bearish");
+        expect(sig.metadata?.condition).toBe("overbought");
+    });
+    it("returns bullish for oversold RSI", () => {
+        const sig = rsiSignal([25]);
+        expect(sig.signal).toBe("bullish");
+        expect(sig.metadata?.condition).toBe("oversold");
+    });
+    it("returns neutral for mid-range RSI", () => {
+        const sig = rsiSignal([50]);
+        expect(sig.signal).toBe("neutral");
+    });
+});
+describe("macd()", () => {
+    it("returns empty arrays for insufficient data", () => {
+        const result = macd([100, 99], 12, 26, 9);
+        expect(result.signal).toEqual([]);
+    });
+    it("produces histogram for sufficient data", () => {
+        const result = macd(risingPrices, 12, 26, 9);
+        expect(result.macd.length).toBeGreaterThan(0);
+        expect(result.histogram.length).toBeGreaterThan(0);
+    });
+});
+describe("macdSignal()", () => {
+    it("returns neutral for empty histogram", () => {
+        expect(macdSignal({ macd: [], signal: [], histogram: [] }).signal).toBe("neutral");
+    });
+    it("returns bullish when histogram crosses above zero", () => {
+        const sig = macdSignal({ macd: [0.1], signal: [0], histogram: [-0.1, 0.1] });
+        expect(sig.signal).toBe("bullish");
+    });
+});
+describe("bollingerBands()", () => {
+    it("upper band > middle > lower band", () => {
+        const bands = bollingerBands(risingPrices, 20, 2);
+        const last = bands.upper.length - 1;
+        expect(bands.upper[last]).toBeGreaterThan(bands.middle[last]);
+        expect(bands.middle[last]).toBeGreaterThan(bands.lower[last]);
+    });
+    it("flat prices produce narrow bands", () => {
+        const bands = bollingerBands(flatPrices, 20, 2);
+        const last = bands.width.length - 1;
+        expect(bands.width[last]).toBeLessThan(1); // near-zero width for flat prices
+    });
+});
+//# sourceMappingURL=TechnicalAnalysis.test.js.map

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