@aiaiaichain/agent 0.1.4 → 0.1.5

package/dist/runner/ModelClient.js

@@ -3,6 +3,14 @@
  * Handles streaming and non-streaming calls.
  */
 import { env } from "../core/EnvLoader.js";
+import { logger } from "../util/logger.js";
+import { resilientFetch } from "../util/resilientFetch.js";
+const MAX_RETRIES = 2;
+const RETRY_BACKOFF_MS = 1000;
+const REQUEST_TIMEOUT = 60_000;
+function isRetryable(status) {
+    return status === 429 || status >= 500;
+}
 export function resolveModelConfig(registry) {
     const apiKey = env.get("OPENROUTER_API_KEY");
     const defaultModel = env.get("DEFAULT_MODEL");
@@ -24,61 +32,114 @@ export class ModelClient {
             stream: true,
             max_tokens: 4096,
         };
-        try {
-            const response = await fetch(`${config.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Authorization: `Bearer ${config.apiKey}`,
-                    "HTTP-Referer": "https://aiaiaichain.dev",
-                    "X-Title": "AIAIAI Chain Agent",
-                },
-                body: JSON.stringify(body),
-                signal,
-            });
-            if (!response.ok) {
-                const err = await response.text().catch(() => "unknown error");
-                onEvent({ type: "error", message: `API error ${response.status}: ${err}` });
-                return;
-            }
-            const reader = response.body?.getReader();
-            if (!reader) {
-                onEvent({ type: "error", message: "No response body" });
-                return;
-            }
-            const decoder = new TextDecoder();
-            let buffer = "";
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    const trimmed = line.trim();
-                    if (!trimmed || trimmed === "data: [DONE]")
-                        continue;
-                    if (!trimmed.startsWith("data: "))
+        let lastError = "";
+        let lastStatus = 0;
+        let timer;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = RETRY_BACKOFF_MS * Math.pow(2, attempt - 1);
+                    logger.info('ModelClient', `Retry attempt ${attempt}/${MAX_RETRIES} after ${delay}ms`);
+                    await new Promise(r => setTimeout(r, delay));
+                }
+                const controller = new AbortController();
+                timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+                if (signal?.aborted) {
+                    onEvent({ type: "error", message: "Request aborted" });
+                    return;
+                }
+                const combinedSignal = signal ?? controller.signal;
+                const response = await resilientFetch(`${config.baseUrl}/chat/completions`, {
+                    timeout: REQUEST_TIMEOUT,
+                    retries: 0,
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${config.apiKey}`,
+                        "HTTP-Referer": "https://aiaiaichain.dev",
+                        "X-Title": "AIAIAI Chain Agent",
+                    },
+                    body: JSON.stringify(body),
+                    signal: combinedSignal,
+                });
+                clearTimeout(timer);
+                if (!response.ok) {
+                    const err = await response.text().catch(() => "unknown error");
+                    lastError = err;
+                    lastStatus = response.status;
+                    if (isRetryable(response.status) && attempt < MAX_RETRIES) {
+                        logger.warn('ModelClient', `Retryable error ${response.status}`, { attempt });
                         continue;
-                    try {
-                        const json = JSON.parse(trimmed.slice(6));
-                        const delta = json.choices?.[0]?.delta?.content;
-                        if (delta)
-                            onEvent({ type: "text_delta", text: delta });
                     }
-                    catch { /* skip malformed lines */ }
+                    if (response.status === 401) {
+                        onEvent({ type: "error", message: `API auth failed: OpenRouter key is missing or invalid.\nRun: aiaiai setup\nGet a key: https://openrouter.ai/keys` });
+                    }
+                    else {
+                        onEvent({ type: "error", message: `API error ${response.status}: ${err}` });
+                    }
+                    return;
+                }
+                const reader = response.body?.getReader();
+                if (!reader) {
+                    onEvent({ type: "error", message: "No response body" });
+                    return;
+                }
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() || "";
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === "data: [DONE]")
+                            continue;
+                        if (!trimmed.startsWith("data: "))
+                            continue;
+                        try {
+                            const json = JSON.parse(trimmed.slice(6));
+                            const delta = json.choices?.[0]?.delta?.content;
+                            if (delta)
+                                onEvent({ type: "text_delta", text: delta });
+                        }
+                        catch {
+                            logger.debug('ModelClient', 'Skipped malformed SSE line', { line: trimmed.slice(0, 100) });
+                        }
+                    }
                 }
-            }
-            onEvent({ type: "turn_done" });
-        }
-        catch (e) {
-            if (e instanceof Error && e.name === "AbortError") {
                 onEvent({ type: "turn_done" });
+                return; // Success — exit retry loop
+            }
+            catch (e) {
+                clearTimeout(timer);
+                if (e instanceof Error && e.name === "AbortError") {
+                    if (signal?.aborted) {
+                        onEvent({ type: "turn_done" });
+                        return;
+                    }
+                    // Timeout
+                    lastError = "Request timed out";
+                    if (attempt < MAX_RETRIES) {
+                        logger.warn('ModelClient', `Timeout, retrying`, { attempt });
+                        continue;
+                    }
+                    onEvent({ type: "error", message: "Request timed out" });
+                    return;
+                }
+                lastError = e instanceof Error ? e.message : String(e);
+                if (attempt < MAX_RETRIES) {
+                    logger.warn('ModelClient', `Error, retrying`, { attempt, error: lastError });
+                    continue;
+                }
+                onEvent({ type: "error", message: `ModelClient error (${lastStatus || 'offline'}): ${lastError}` });
                 return;
             }
-            onEvent({ type: "error", message: e instanceof Error ? e.message : String(e) });
         }
+        // Exhausted retries
+        onEvent({ type: "error", message: `ModelClient failed after ${MAX_RETRIES + 1} attempts: ${lastError}` });
     }
 }
 //# sourceMappingURL=ModelClient.js.map

package/dist/session/SessionManager.d.ts

@@ -10,6 +10,7 @@ export declare class SessionManager {
     private messages;
     private systemPrompt;
     private maxContextTokens;
+    private _cachedChars;
     setSystemPrompt(prompt: string): void;
     getSystemPrompt(): string;
     addMessage(role: string, content: string): void;

package/dist/session/SessionManager.js

@@ -5,6 +5,7 @@ export class SessionManager {
     messages = [];
     systemPrompt = "";
     maxContextTokens = 128_000;
+    _cachedChars = 0;
     setSystemPrompt(prompt) {
         this.systemPrompt = prompt;
     }
@@ -13,13 +14,18 @@ export class SessionManager {
     }
     addMessage(role, content) {
         this.messages.push({ role, content });
+        this._cachedChars += content.length + role.length + 10;
     }
     getMessages() {
         // Estimate: 1 token ≈ 4 chars
         const maxChars = this.maxContextTokens * 4;
+        // Fast path: if total is under limit, return all
+        if (this._cachedChars <= maxChars) {
+            return [...this.messages];
+        }
+        // Slow path: walk backwards until we hit the limit
         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;
@@ -31,7 +37,7 @@ export class SessionManager {
         return result;
     }
     getContextPressure() {
-        const totalChars = this.messages.reduce((sum, m) => sum + m.content.length + m.role.length + 10, 0);
+        const totalChars = this._cachedChars || 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";

package/dist/session/SessionStore.js

@@ -5,6 +5,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
+import { logger } from '../util/logger.js';
 const SESSIONS_DIR = resolve(homedir(), '.aiaiai', 'sessions');
 function ensureDir() {
     if (!existsSync(SESSIONS_DIR))
@@ -63,7 +64,8 @@ export class SessionStore {
                 return null;
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
-        catch {
+        catch (error) {
+            logger.debug('SessionStore', 'Failed to load session', { error: error.message });
             return null;
         }
     }
@@ -85,11 +87,14 @@ export class SessionStore {
                         model: data.model,
                     });
                 }
-                catch { /* skip bad files */ }
+                catch (error) {
+                    logger.debug('SessionStore', 'Skipped bad session file', { error: error.message });
+                }
             }
             return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
         }
-        catch {
+        catch (error) {
+            logger.warn('SessionStore', 'Failed to list sessions', { error: error.message });
             return [];
         }
     }

package/dist/tools/CrossTools.js

@@ -5,6 +5,7 @@
 import { Type } from "@sinclair/typebox";
 import { priceFeed } from "../tools/PriceFeed.js";
 import { AIAIAI_TOKEN, agentWallet } from "../wallet/AgentWallet.js";
+import { logger } from "../util/logger.js";
 const alerts = [];
 export function addAlert(token, type, price) {
     const alert = {
@@ -111,7 +112,8 @@ export async function compareTokensTool(_id, params) {
             price1 = await priceFeed.fetchToken(addr1);
         }
     }
-    catch {
+    catch (error) {
+        logger.warn('CrossTools', 'compareTokens: failed to fetch price1', { address: addr1, error: error.message });
         price1 = null;
     }
     try {
@@ -122,7 +124,8 @@ export async function compareTokensTool(_id, params) {
             price2 = await priceFeed.fetchToken(addr2);
         }
     }
-    catch {
+    catch (error) {
+        logger.warn('CrossTools', 'compareTokens: failed to fetch price2', { address: addr2, error: error.message });
         price2 = null;
     }
     const lines = [
@@ -159,16 +162,21 @@ export async function portfolioTool(_id, params) {
         else if (address === DEPOSIT_WALLET)
             result = all.deposit;
     }
-    catch { }
+    catch (error) {
+        logger.warn('CrossTools', 'portfolioTool: wallet lookup failed', { address, error: error.message });
+    }
     if (result) {
+        let solPrice = await new Promise(res => {
+            agentWallet.getSolPrice().then(res).catch(() => res(150));
+        });
         const lines = [
             `📊 Portfolio: ${address.slice(0, 8)}…${address.slice(-6)}`,
             '',
-            `  SOL:   ${result.sol.toFixed(4)} ($${(result.sol * 150).toFixed(2)} est)`,
+            `  SOL:   ${result.sol.toFixed(4)} ($${(result.sol * solPrice).toFixed(2)} est)`,
             `  $AIAIAI: ${result.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 0 })}`,
             `  USDC:  ${result.usdc.toFixed(2)}`,
             '',
-            `  Total value (est): $${(result.sol * 150 + result.usdc).toFixed(2)} + $AIAIAI`,
+            `  Total value (est): $${(result.sol * solPrice + result.usdc).toFixed(2)} + $AIAIAI`,
         ];
         return { content: [{ type: "text", text: lines.join("\n") }] };
     }

package/dist/tools/MarketSentiment.js

@@ -3,11 +3,13 @@
  * Fear & Greed Index, Binance Funding Rates, BTC Mempool, DeFi TVL, Solana Stats.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 // ── Fear & Greed Index ──────────────────────────────────────────────────────
 export const fearGreedParams = Type.Object({});
 export async function getFearGreedTool() {
     try {
-        const response = await fetch("https://api.alternative.me/fng/?limit=7");
+        const response = await resilientFetch("https://api.alternative.me/fng/?limit=7", { timeout: 10_000, retries: 1 });
         if (!response.ok)
             return fallbackFearGreed();
         const data = await response.json();
@@ -28,7 +30,8 @@ export async function getFearGreedTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Fear & Greed fetch failed', { error: error.message });
         return fallbackFearGreed();
     }
 }
@@ -47,7 +50,7 @@ export const fundingRatesParams = Type.Object({
 export async function getFundingRatesTool(_id, params) {
     const limit = params.limit || 10;
     try {
-        const response = await fetch("https://fapi.binance.com/fapi/v1/premiumIndex");
+        const response = await resilientFetch("https://fapi.binance.com/fapi/v1/premiumIndex", { timeout: 10_000, retries: 1 });
         if (!response.ok)
             return fallbackFundingRates();
         const data = await response.json();
@@ -67,7 +70,8 @@ export async function getFundingRatesTool(_id, params) {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Funding rates fetch failed', { error: error.message });
         return fallbackFundingRates();
     }
 }
@@ -84,8 +88,8 @@ 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"),
+            resilientFetch("https://mempool.space/api/v1/fees/recommended", { timeout: 10_000 }),
+            resilientFetch("https://mempool.space/api/mempool", { timeout: 10_000 }),
         ]);
         const fees = await feeResp.json();
         const mempool = await mempoolResp.json();
@@ -107,7 +111,8 @@ export async function getBtcMempoolTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'BTC mempool fetch failed', { error: error.message });
         return {
             content: [{ type: "text", text: "BTC Mempool: Data temporarily unavailable." }],
         };
@@ -121,7 +126,7 @@ 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}`);
+            const response = await resilientFetch(`https://api.llama.fi/v2/historicalChainTvl/${chain}`, { timeout: 10_000 });
             if (!response.ok)
                 return fallbackTvl(chain);
             const data = await response.json();
@@ -134,7 +139,7 @@ export async function getDefiTvlTool(_id, params) {
             };
         }
         else {
-            const response = await fetch("https://api.llama.fi/v2/chains");
+            const response = await resilientFetch("https://api.llama.fi/v2/chains", { timeout: 10_000 });
             if (!response.ok)
                 return fallbackTvl("all");
             const data = await response.json();
@@ -148,7 +153,8 @@ export async function getDefiTvlTool(_id, params) {
             };
         }
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'DeFi TVL fetch failed', { chain, error: error.message });
         return fallbackTvl(chain ?? "all");
     }
 }
@@ -168,7 +174,9 @@ export async function getSolanaStatsTool() {
             method: "getEpochInfo",
             params: [],
         });
-        const response = await fetch(rpcUrl, {
+        const response = await resilientFetch(rpcUrl, {
+            timeout: 10_000,
+            retries: 1,
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body,
@@ -179,7 +187,7 @@ export async function getSolanaStatsTool() {
         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");
+        const priceResp = await resilientFetch("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd&include_24hr_change=true", { timeout: 8_000 });
         let solPrice = "";
         if (priceResp.ok) {
             const priceData = await priceResp.json();
@@ -199,7 +207,8 @@ export async function getSolanaStatsTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Solana stats fetch failed', { error: error.message });
         return fallbackSolanaStats();
     }
 }

package/dist/tools/NewsSentiment.js

@@ -3,6 +3,8 @@
  * Uses public RSS feeds and a basic lexicon-based sentiment analyzer.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 const POSITIVE_WORDS = new Set([
     "bullish", "surge", "rally", "gain", "green", "high", "breakthrough", "adoption",
     "partnership", "launch", "upgrade", "growth", "profit", "positive", "optimistic",
@@ -51,7 +53,9 @@ export class NewsFeed {
             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, {
+            const response = await resilientFetch(url, {
+                timeout: 10_000,
+                retries: 1,
                 headers: { "Accept": "application/json" },
             });
             if (response.ok) {
@@ -71,7 +75,8 @@ export class NewsFeed {
                 items.push(...this.getFallbackNews());
             }
         }
-        catch {
+        catch (error) {
+            logger.warn('NewsSentiment', 'Failed to fetch news', { error: error.message });
             items.push(...this.getFallbackNews());
         }
         this.cachedItems = items;
@@ -109,7 +114,8 @@ export class NewsFeed {
             const emoji = report.averageSentiment > 0.2 ? "📈" : report.averageSentiment < -0.2 ? "📉" : "📊";
             return `${emoji} ${(report.averageSentiment * 100).toFixed(0)}%`;
         }
-        catch {
+        catch (error) {
+            logger.debug('NewsSentiment', 'statusBadge failed', { error: error.message });
             return "";
         }
     }

package/dist/tools/PriceFeed.js

@@ -4,6 +4,8 @@
  * Secondary: query any token by address.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 const AIAIAI_TOKEN = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export class PriceFeed {
     cachedAiaiPrice = null;
@@ -18,7 +20,7 @@ export class PriceFeed {
     async fetchToken(tokenAddress) {
         const url = `https://api.dexscreener.com/tokens/v1/solana/${tokenAddress}`;
         try {
-            const response = await fetch(url);
+            const response = await resilientFetch(url, { timeout: 10_000, retries: 1 });
             if (!response.ok) {
                 return this.fallbackPrice(tokenAddress);
             }
@@ -48,7 +50,8 @@ export class PriceFeed {
             }
             return result;
         }
-        catch {
+        catch (error) {
+            logger.warn('PriceFeed', 'fetchToken failed', { tokenAddress, error: error.message });
             return this.fallbackPrice(tokenAddress);
         }
     }
@@ -71,7 +74,7 @@ export class PriceFeed {
     }
     tickerLine(maxLength = 6) {
         try {
-            const p = this.cachedAiaiPrice ?? this.getAiaiaiPriceSync();
+            const p = this.cachedAiaiPrice;
             if (!p || !p.priceUsd)
                 return "";
             const price = parseFloat(p.priceUsd).toFixed(6);
@@ -79,7 +82,9 @@ export class PriceFeed {
             const arrow = change > 0 ? "▲" : change < 0 ? "▼" : "─";
             return `$AIAIAI $${price} ${arrow}${Math.abs(change).toFixed(2)}%`.slice(0, 40);
         }
-        catch {
+        catch (error) {
+            // Log error in case of debug needed
+            console.error('Error in tickerLine:', error);
             return "";
         }
     }
@@ -131,4 +136,6 @@ export class PriceFeed {
     }
 }
 export const priceFeed = new PriceFeed();
+// Eagerly initialize the price cache so sidebar shows price immediately
+priceFeed.getAiaiaiPrice().catch(() => { });
 //# sourceMappingURL=PriceFeed.js.map

package/dist/tools/TechnicalAnalysis.js

@@ -3,6 +3,7 @@
  * Works with OHLCV candle data. Tools for the agent to query.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
 // ── SMA ──────────────────────────────────────────────────────────────────────
 export function sma(data, period) {
     const result = [];
@@ -197,7 +198,7 @@ export async function getCandlesTool(_id, params) {
     const interval = params.interval || "1d";
     const limit = params.limit || 50;
     try {
-        const response = await fetch(`https://api.binance.com/api/v3/klines?symbol=${symbol}&interval=${interval}&limit=${limit}`);
+        const response = await resilientFetch(`https://api.binance.com/api/v3/klines?symbol=${symbol}&interval=${interval}&limit=${limit}`, { timeout: 10_000, retries: 1 });
         if (!response.ok) {
             return { content: [{ type: "text", text: `Failed to fetch candles for ${symbol}: ${response.status}` }] };
         }

package/dist/tools/TokenCalendar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * src/tools/TokenCalendar.ts — Token launch calendar tracker.
+ * Uses DexScreener's latest tokens endpoint to find recent launches.
+ * Caches results for 5 minutes.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface LaunchEvent {
+    address: string;
+    symbol: string;
+    name: string;
+    priceUsd: string | null;
+    volume24h: number;
+    liquidityUsd: number;
+    age: string;
+    chain: string;
+}
+export declare const launchCalendarParams: import("@sinclair/typebox").TObject<{
+    chain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function launchCalendarTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+/** Get sidebar-ready summary */
+export declare function getLaunchSummary(): string;
+//# sourceMappingURL=TokenCalendar.d.ts.map

package/dist/tools/TokenCalendar.js

@@ -0,0 +1,81 @@
+/**
+ * src/tools/TokenCalendar.ts — Token launch calendar tracker.
+ * Uses DexScreener's latest tokens endpoint to find recent launches.
+ * Caches results for 5 minutes.
+ */
+import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
+export const launchCalendarParams = Type.Object({
+    chain: Type.Optional(Type.String({ description: "Chain: solana, ethereum, bsc, base", default: "solana" })),
+    limit: Type.Optional(Type.Number({ description: "Max entries", default: 10 })),
+});
+let cachedLaunches = [];
+let lastFetch = 0;
+const CACHE_DURATION = 300_000; // 5 min
+export async function launchCalendarTool(_id, params) {
+    const chain = params.chain || "solana";
+    const limit = params.limit || 10;
+    if (Date.now() - lastFetch < CACHE_DURATION && cachedLaunches.length > 0) {
+        const filtered = cachedLaunches.filter(l => l.chain === chain).slice(0, limit);
+        return formatResult(filtered, chain);
+    }
+    try {
+        // DexScreener "latest" endpoint per chain
+        const url = `https://api.dexscreener.com/latest/dex/tokens/${chain}`;
+        const response = await resilientFetch(url, { timeout: 10_000, retries: 1 });
+        if (!response.ok) {
+            return { content: [{ type: "text", text: `Token launch calendar unavailable for ${chain}.` }] };
+        }
+        const data = await response.json();
+        const pairs = data?.pairs ?? [];
+        cachedLaunches = pairs.map((p) => {
+            const createdAt = p.pairCreatedAt ? new Date(p.pairCreatedAt) : null;
+            const now = Date.now();
+            const diffMs = createdAt ? now - createdAt.getTime() : Infinity;
+            const age = createdAt
+                ? diffMs < 3600000 ? `${Math.floor(diffMs / 60000)}m ago`
+                    : diffMs < 86400000 ? `${Math.floor(diffMs / 3600000)}h ago`
+                        : `${Math.floor(diffMs / 86400000)}d ago`
+                : "unknown";
+            return {
+                address: p.baseToken?.address ?? "",
+                symbol: p.baseToken?.symbol ?? "???",
+                name: p.baseToken?.name ?? "Unknown",
+                priceUsd: p.priceUsd ?? null,
+                volume24h: p.volume?.h24 ?? 0,
+                liquidityUsd: p.liquidity?.usd ?? 0,
+                age,
+                chain,
+            };
+        });
+        lastFetch = Date.now();
+        const filtered = cachedLaunches.slice(0, limit);
+        return formatResult(filtered, chain);
+    }
+    catch (error) {
+        logger.warn("TokenCalendar", "Failed to fetch launches", { chain, error: error.message });
+        return { content: [{ type: "text", text: `Token launch calendar: Data temporarily unavailable.` }] };
+    }
+}
+function formatResult(launches, chain) {
+    if (launches.length === 0) {
+        return { content: [{ type: "text", text: `No recent launches found on ${chain}.` }] };
+    }
+    const lines = [`🚀 Recent Token Launches — ${chain.toUpperCase()}`, ""];
+    for (const l of launches.slice(0, 10)) {
+        const price = l.priceUsd ? `$${parseFloat(l.priceUsd).toFixed(8)}` : "N/A";
+        const vol = l.volume24h > 0 ? `$${(l.volume24h / 1000).toFixed(1)}k` : "no vol";
+        const liq = l.liquidityUsd > 0 ? `$${(l.liquidityUsd / 1000).toFixed(1)}k` : "no liq";
+        lines.push(`  ${l.symbol.padEnd(10)} ${price.padEnd(16)} ${vol.padEnd(10)} ${l.age.padEnd(10)} ${l.address.slice(0, 6)}…`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], details: { launches } };
+}
+/** Get sidebar-ready summary */
+export function getLaunchSummary() {
+    if (cachedLaunches.length === 0)
+        return "Loading…";
+    const recent = cachedLaunches.slice(0, 3);
+    return recent.map(l => l.symbol).join(" · ");
+}
+//# sourceMappingURL=TokenCalendar.js.map