@blockrun/franklin 3.2.4 → 3.3.1

package/dist/social/x.js

@@ -17,6 +17,8 @@ import { SocialBrowser } from './browser.js';
 import { findRefs, findStaticText, extractArticleBlocks, X_TIME_LINK_PATTERN } from './a11y.js';
 import { computePreKey, hasPreKey, commitPreKey, hasPosted, countPostedToday, logReply, } from './db.js';
 import { detectProduct, generateReply } from './ai.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
 /**
  * Main entry point. Iterates every search query in config.x.search_queries
  * and processes every visible candidate until the daily target is hit.
@@ -202,6 +204,12 @@ export async function runX(opts) {
                         cost_usd: gen.cost,
                     });
                     commitPreKey('x', handle, preKey);
+                    bus.emit(makeEvent({
+                        type: 'post.published',
+                        source: 'social',
+                        costUsd: gen.cost,
+                        data: { platform: 'x', url: canonicalUrl, text: gen.reply },
+                    }));
                     // Respect the rate-limit / anti-spam delay between successes
                     await browser.waitForTimeout(opts.config.x.min_delay_seconds * 1000);
                 }
@@ -238,7 +246,7 @@ export async function runX(opts) {
  * Enter+Enter), clicks the reply button, confirms the "Your post was sent"
  * banner.
  */
-async function postReply(browser, reply) {
+export async function postReply(browser, reply) {
     // Snapshot and find the reply textbox
     const tree = await browser.snapshot();
     const boxRefs = findRefs(tree, 'textbox', 'Post (your reply|text).*');

package/dist/stats/tracker.d.ts

@@ -2,6 +2,7 @@
  * Usage tracking for runcode
  * Records all requests with cost, tokens, and latency for stats display
  */
+export declare function getStatsFilePath(): string;
 export interface UsageRecord {
     timestamp: number;
     model: string;

package/dist/stats/tracker.js

@@ -6,7 +6,47 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { OPUS_PRICING } from '../pricing.js';
-const STATS_FILE = path.join(os.homedir(), '.blockrun', 'runcode-stats.json');
+import { BLOCKRUN_DIR } from '../config.js';
+let resolvedStatsFile = null;
+function preferredStatsFile() {
+    return path.join(BLOCKRUN_DIR, 'runcode-stats.json');
+}
+function fallbackStatsFile() {
+    return path.join(os.tmpdir(), 'runcode', 'runcode-stats.json');
+}
+export function getStatsFilePath() {
+    if (resolvedStatsFile)
+        return resolvedStatsFile;
+    for (const file of [preferredStatsFile(), fallbackStatsFile()]) {
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            resolvedStatsFile = file;
+            return file;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    resolvedStatsFile = preferredStatsFile();
+    return resolvedStatsFile;
+}
+function withWritableStatsFile(action) {
+    const preferred = preferredStatsFile();
+    const fallback = fallbackStatsFile();
+    try {
+        action(getStatsFilePath());
+    }
+    catch (err) {
+        const code = err.code;
+        const shouldFallback = (code === 'EACCES' || code === 'EPERM' || code === 'EROFS') &&
+            resolvedStatsFile === preferred;
+        if (!shouldFallback)
+            throw err;
+        fs.mkdirSync(path.dirname(fallback), { recursive: true });
+        resolvedStatsFile = fallback;
+        action(fallback);
+    }
+}
 const EMPTY_STATS = {
     version: 1,
     totalRequests: 0,
@@ -19,8 +59,9 @@ const EMPTY_STATS = {
 };
 export function loadStats() {
     try {
-        if (fs.existsSync(STATS_FILE)) {
-            const data = JSON.parse(fs.readFileSync(STATS_FILE, 'utf-8'));
+        const statsFile = getStatsFilePath();
+        if (fs.existsSync(statsFile)) {
+            const data = JSON.parse(fs.readFileSync(statsFile, 'utf-8'));
             // Migration: add missing fields
             return {
                 ...EMPTY_STATS,
@@ -36,10 +77,12 @@ export function loadStats() {
 }
 export function saveStats(stats) {
     try {
-        fs.mkdirSync(path.dirname(STATS_FILE), { recursive: true });
-        // Keep only last 1000 history records
-        stats.history = stats.history.slice(-1000);
-        fs.writeFileSync(STATS_FILE, JSON.stringify(stats, null, 2));
+        withWritableStatsFile((statsFile) => {
+            fs.mkdirSync(path.dirname(statsFile), { recursive: true });
+            // Keep only last 1000 history records
+            stats.history = stats.history.slice(-1000);
+            fs.writeFileSync(statsFile, JSON.stringify(stats, null, 2));
+        });
     }
     catch {
         /* ignore write errors */
@@ -51,13 +94,16 @@ export function clearStats() {
         clearTimeout(flushTimer);
         flushTimer = null;
     }
-    try {
-        if (fs.existsSync(STATS_FILE)) {
-            fs.unlinkSync(STATS_FILE);
+    resolvedStatsFile = null;
+    for (const statsFile of new Set([preferredStatsFile(), fallbackStatsFile()])) {
+        try {
+            if (fs.existsSync(statsFile)) {
+                fs.unlinkSync(statsFile);
+            }
+        }
+        catch {
+            /* ignore */
         }
-    }
-    catch {
-        /* ignore */
     }
 }
 // ─── In-memory stats cache with debounced write ─────────────────────────

package/dist/tools/bash.js

@@ -193,6 +193,7 @@ async function execute(input, ctx) {
         let outputBytes = 0;
         let truncated = false;
         let killed = false;
+        let abortedByUser = false;
         const timer = setTimeout(() => {
             killed = true;
             child.kill('SIGTERM');
@@ -206,6 +207,7 @@ async function execute(input, ctx) {
         // Handle abort signal
         const onAbort = () => {
             killed = true;
+            abortedByUser = true;
             child.kill('SIGTERM');
         };
         ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
@@ -293,8 +295,11 @@ async function execute(input, ctx) {
                 result = `... (${omitted.toLocaleString()} chars omitted from start)\n${trimmed}`;
             }
             if (killed) {
+                const reason = abortedByUser
+                    ? 'aborted by user'
+                    : `timeout after ${timeoutMs / 1000}s. Set timeout param up to 600000ms for longer.`;
                 resolve({
-                    output: result + `\n\n(command killed — timeout after ${timeoutMs / 1000}s. Set timeout param up to 600000ms for longer.)`,
+                    output: result + `\n\n(command killed — ${reason})`,
                     isError: true,
                 });
                 return;

package/dist/tools/index.js

@@ -12,6 +12,7 @@ import { webSearchCapability } from './websearch.js';
 import { taskCapability } from './task.js';
 import { imageGenCapability } from './imagegen.js';
 import { askUserCapability } from './askuser.js';
+import { tradingSignalCapability, tradingMarketCapability } from './trading.js';
 /** All capabilities available to the runcode agent (excluding sub-agent, which needs config). */
 export const allCapabilities = [
     readCapability,
@@ -25,6 +26,8 @@ export const allCapabilities = [
     taskCapability,
     imageGenCapability,
     askUserCapability,
+    tradingSignalCapability,
+    tradingMarketCapability,
 ];
 export { readCapability, writeCapability, editCapability, bashCapability, globCapability, grepCapability, webFetchCapability, webSearchCapability, taskCapability, };
 export { createSubAgentCapability } from './subagent.js';

package/dist/tools/posttox.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PostToX capability — post a reply to a tweet on X.
+ * The agent MUST confirm the reply text with the user before calling this tool.
+ * Requires the pre_key from a SearchX result.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const postToXCapability: CapabilityHandler;

package/dist/tools/posttox.js

@@ -0,0 +1,137 @@
+/**
+ * PostToX capability — post a reply to a tweet on X.
+ * The agent MUST confirm the reply text with the user before calling this tool.
+ * Requires the pre_key from a SearchX result.
+ */
+import { checkSocialReady } from '../social/preflight.js';
+import { browserPool } from '../social/browser-pool.js';
+import { extractArticleBlocks, findRefs, findStaticText, X_TIME_LINK_PATTERN, } from '../social/a11y.js';
+import { computePreKey, commitPreKey, hasPosted, logReply } from '../social/db.js';
+import { loadConfig } from '../social/config.js';
+import { postReply } from '../social/x.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
+async function execute(input, _ctx) {
+    const { pre_key, reply_text, search_query } = input;
+    if (!pre_key || !reply_text || !search_query) {
+        return {
+            output: 'Error: pre_key, reply_text, and search_query are all required',
+            isError: true,
+        };
+    }
+    // ── Preflight: config + login ──────────────────────────────────────────
+    const preflight = await checkSocialReady();
+    if (!preflight.ready) {
+        return {
+            output: `PostToX not ready: ${preflight.reason}`,
+            isError: true,
+        };
+    }
+    const config = loadConfig();
+    const handle = config.handle || 'unknown';
+    let browser;
+    try {
+        browser = await browserPool.getBrowser();
+        // ── Navigate to search results to re-find the target post ────────
+        const searchUrl = `https://x.com/search?q=${encodeURIComponent(search_query)}&src=typed_query&f=live`;
+        await browser.open(searchUrl);
+        await browser.waitForTimeout(3500);
+        const tree = await browser.snapshot();
+        // ── Find the article matching the given pre_key ──────────────────
+        const articles = extractArticleBlocks(tree);
+        let matchedTimeRef = null;
+        for (const article of articles) {
+            const timeRefs = findRefs(article.text, 'link', X_TIME_LINK_PATTERN);
+            if (timeRefs.length === 0)
+                continue;
+            const texts = findStaticText(article.text);
+            const snippet = texts.slice(0, 3).join(' ').trim();
+            if (!snippet)
+                continue;
+            const timeLinkMatch = new RegExp(`\\[${timeRefs[0]}\\]\\s+link:\\s*(.+)`).exec(article.text);
+            const timeText = timeLinkMatch ? timeLinkMatch[1].trim() : '';
+            const candidatePreKey = computePreKey({ snippet, time: timeText });
+            if (candidatePreKey === pre_key) {
+                matchedTimeRef = timeRefs[0];
+                break;
+            }
+        }
+        if (!matchedTimeRef) {
+            return {
+                output: 'Post not found in current results. It may have scrolled off or been deleted.',
+                isError: true,
+            };
+        }
+        // ── Click through to the tweet page ──────────────────────────────
+        await browser.click(matchedTimeRef);
+        await browser.waitForTimeout(3000);
+        const canonicalUrl = await browser.getUrl();
+        // ── Check if already posted to this URL ──────────────────────────
+        if (hasPosted('x', handle, canonicalUrl)) {
+            return {
+                output: `Already replied to this post: ${canonicalUrl}`,
+                isError: true,
+            };
+        }
+        // ── Post the reply ───────────────────────────────────────────────
+        await postReply(browser, reply_text);
+        // ── Record success ───────────────────────────────────────────────
+        commitPreKey('x', handle, pre_key);
+        logReply({
+            platform: 'x',
+            handle,
+            post_url: canonicalUrl,
+            post_title: '',
+            post_snippet: '',
+            reply_text,
+            status: 'posted',
+        });
+        // ── Emit post.published event ────────────────────────────────────
+        await bus.emit(makeEvent({
+            type: 'post.published',
+            source: 'social',
+            data: {
+                platform: 'x',
+                url: canonicalUrl,
+                text: reply_text,
+            },
+        }));
+        return {
+            output: `Reply posted successfully to ${canonicalUrl}`,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `PostToX error: ${msg}`, isError: true };
+    }
+    finally {
+        browserPool.releaseBrowser();
+    }
+}
+export const postToXCapability = {
+    spec: {
+        name: 'PostToX',
+        description: 'Post a reply to a tweet on X. The agent MUST confirm the reply text with ' +
+            'the user before calling this tool. Requires the pre_key from a SearchX result.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pre_key: {
+                    type: 'string',
+                    description: 'preKey of the target post (from SearchX results)',
+                },
+                reply_text: {
+                    type: 'string',
+                    description: 'The reply text to post',
+                },
+                search_query: {
+                    type: 'string',
+                    description: 'The original search query (to re-find the post)',
+                },
+            },
+            required: ['pre_key', 'reply_text', 'search_query'],
+        },
+    },
+    execute,
+    concurrent: false,
+};

package/dist/tools/searchx.d.ts

@@ -0,0 +1,7 @@
+/**
+ * SearchX capability — search X (Twitter) for posts matching a query.
+ * Returns candidate posts with snippets and product relevance scores.
+ * Requires social config and X login.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const searchXCapability: CapabilityHandler;

package/dist/tools/searchx.js

@@ -0,0 +1,111 @@
+/**
+ * SearchX capability — search X (Twitter) for posts matching a query.
+ * Returns candidate posts with snippets and product relevance scores.
+ * Requires social config and X login.
+ */
+import { checkSocialReady } from '../social/preflight.js';
+import { extractArticleBlocks, findRefs, findStaticText, X_TIME_LINK_PATTERN, } from '../social/a11y.js';
+import { computePreKey, hasPreKey } from '../social/db.js';
+import { detectProduct } from '../social/ai.js';
+import { loadConfig } from '../social/config.js';
+import { browserPool } from '../social/browser-pool.js';
+async function execute(input, _ctx) {
+    const { query, max_results } = input;
+    if (!query) {
+        return { output: 'Error: query is required', isError: true };
+    }
+    const maxResults = Math.min(Math.max(max_results ?? 10, 1), 50);
+    // ── Preflight: config + login ──────────────────────────────────────────
+    const preflight = await checkSocialReady();
+    if (!preflight.ready) {
+        return {
+            output: `SearchX not ready: ${preflight.reason}`,
+            isError: true,
+        };
+    }
+    const config = loadConfig();
+    const handle = config.handle || 'unknown';
+    let browser;
+    try {
+        browser = await browserPool.getBrowser();
+        // ── Navigate to X search ───────────────────────────────────────────
+        const searchUrl = `https://x.com/search?q=${encodeURIComponent(query)}&src=typed_query&f=live`;
+        await browser.open(searchUrl);
+        await browser.waitForTimeout(3500);
+        const tree = await browser.snapshot();
+        // ── Extract articles ───────────────────────────────────────────────
+        const articles = extractArticleBlocks(tree);
+        const candidates = [];
+        for (const article of articles) {
+            if (candidates.length >= maxResults)
+                break;
+            // Find time-link ref (permalink to the tweet)
+            const timeRefs = findRefs(article.text, 'link', X_TIME_LINK_PATTERN);
+            if (timeRefs.length === 0)
+                continue;
+            const timeRef = timeRefs[0];
+            // Extract snippet from static text (first 3 lines)
+            const texts = findStaticText(article.text);
+            const snippet = texts.slice(0, 3).join(' ').trim();
+            if (!snippet || snippet.length < 10)
+                continue;
+            // Extract time text from the ref line
+            const timeLinkMatch = new RegExp(`\\[${timeRef}\\]\\s+link:\\s*(.+)`).exec(article.text);
+            const timeText = timeLinkMatch ? timeLinkMatch[1].trim() : '';
+            // Compute pre-key for dedup
+            const preKey = computePreKey({ snippet, time: timeText });
+            const alreadySeen = hasPreKey('x', handle, preKey);
+            // Product routing (zero-cost keyword score)
+            const product = detectProduct(snippet, config.products);
+            candidates.push({
+                index: candidates.length + 1,
+                snippet,
+                timeText,
+                preKey,
+                productMatch: product?.name ?? null,
+                alreadySeen,
+            });
+        }
+        // ── Format output ──────────────────────────────────────────────────
+        if (candidates.length === 0) {
+            return { output: `No candidate posts found for query: "${query}"` };
+        }
+        const lines = candidates.map((c) => {
+            const seen = c.alreadySeen ? ' [SEEN]' : '';
+            const product = c.productMatch ? ` | product: ${c.productMatch}` : ' | product: none';
+            return (`${c.index}. ${c.snippet.slice(0, 200)}\n` +
+                `   time: ${c.timeText} | pre_key: ${c.preKey}${product}${seen}`);
+        });
+        return {
+            output: `SearchX results for "${query}" (${candidates.length} candidates):\n\n` +
+                lines.join('\n\n'),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `SearchX error: ${msg}`, isError: true };
+    }
+    finally {
+        browserPool.releaseBrowser();
+    }
+}
+export const searchXCapability = {
+    spec: {
+        name: 'SearchX',
+        description: 'Search X (Twitter) for posts matching a query. Returns candidate posts ' +
+            'with snippets and product relevance scores. Requires social config and X login.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                max_results: {
+                    type: 'number',
+                    description: 'Max posts to return (default 10)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    execute,
+    concurrent: false,
+};

package/dist/tools/trading.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const tradingSignalCapability: CapabilityHandler;
+export declare const tradingMarketCapability: CapabilityHandler;

package/dist/tools/trading.js

@@ -0,0 +1,168 @@
+import { getPrice, getOHLCV, getTrending, getMarketOverview } from '../trading/data.js';
+import { rsi, macd, bollingerBands, volatility } from '../trading/metrics.js';
+import { bus } from '../events/bus.js';
+import { makeEvent } from '../events/types.js';
+function formatUsd(n) {
+    if (n >= 1e12)
+        return `$${(n / 1e12).toFixed(2)}T`;
+    if (n >= 1e9)
+        return `$${(n / 1e9).toFixed(2)}B`;
+    if (n >= 1e6)
+        return `$${(n / 1e6).toFixed(2)}M`;
+    if (n >= 1e3)
+        return `$${(n / 1e3).toFixed(1)}K`;
+    return `$${n.toFixed(2)}`;
+}
+async function executeSignal(input, _ctx) {
+    const { ticker, days = 30 } = input;
+    if (!ticker) {
+        return { output: 'Error: ticker is required', isError: true };
+    }
+    const upper = ticker.toUpperCase();
+    const [priceResult, ohlcvResult] = await Promise.all([
+        getPrice(upper),
+        getOHLCV(upper, days),
+    ]);
+    if (typeof priceResult === 'string') {
+        return { output: `Error fetching price: ${priceResult}`, isError: true };
+    }
+    if (typeof ohlcvResult === 'string') {
+        return { output: `Error fetching OHLCV: ${ohlcvResult}`, isError: true };
+    }
+    const { closes } = ohlcvResult;
+    const rsiResult = rsi(closes);
+    const macdResult = macd(closes);
+    const bbResult = bollingerBands(closes);
+    const volResult = volatility(closes);
+    // Determine overall direction from indicators
+    let bullish = 0;
+    let bearish = 0;
+    if (rsiResult.interpretation === 'oversold')
+        bullish++;
+    if (rsiResult.interpretation === 'overbought')
+        bearish++;
+    if (macdResult.trend === 'bullish')
+        bullish++;
+    if (macdResult.trend === 'bearish')
+        bearish++;
+    if (bbResult.position === 'below')
+        bullish++;
+    if (bbResult.position === 'above')
+        bearish++;
+    const direction = bullish > bearish ? 'bullish' : bearish > bullish ? 'bearish' : 'neutral';
+    const confidence = Math.max(bullish, bearish) / 3;
+    bus.emit(makeEvent({
+        type: 'signal.detected',
+        source: 'trading',
+        data: {
+            asset: upper,
+            direction,
+            confidence,
+            indicators: {
+                rsi: rsiResult.value,
+                macd: macdResult.macd,
+                volatility: volResult.annualized,
+            },
+            summary: `${upper} ${direction} (confidence ${(confidence * 100).toFixed(0)}%)`,
+        },
+    }));
+    const { price, change24h, marketCap, volume24h } = priceResult;
+    const last5 = closes.slice(-5).map(c => c.toFixed(2)).join(', ');
+    const output = [
+        `## ${upper} Signal Report`,
+        '',
+        `**Price:** $${price.toLocaleString()} USD (${change24h > 0 ? '+' : ''}${change24h.toFixed(2)}% 24h)`,
+        `**Market Cap:** ${formatUsd(marketCap)}`,
+        `**24h Volume:** ${formatUsd(volume24h)}`,
+        '',
+        `### Technical Indicators (${days}d lookback)`,
+        `- **RSI(14):** ${rsiResult.value.toFixed(1)} — ${rsiResult.interpretation}`,
+        `- **MACD:** ${macdResult.macd.toFixed(4)} / Signal: ${macdResult.signal.toFixed(4)} / Histogram: ${macdResult.histogram.toFixed(4)} — ${macdResult.trend}`,
+        `- **Bollinger:** Upper ${bbResult.upper.toFixed(2)} / Middle ${bbResult.middle.toFixed(2)} / Lower ${bbResult.lower.toFixed(2)} — Price ${bbResult.position}`,
+        `- **Volatility:** ${(volResult.annualized * 100).toFixed(1)}% annualized — ${volResult.interpretation}`,
+        '',
+        `### Raw Data`,
+        `Closes (last 5): ${last5}`,
+    ].join('\n');
+    return { output };
+}
+export const tradingSignalCapability = {
+    spec: {
+        name: 'TradingSignal',
+        description: 'Get current price, technical indicators (RSI, MACD, Bollinger Bands, volatility), and a signal summary for a cryptocurrency. Returns raw data for the agent to analyze and interpret.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ticker: { type: 'string', description: 'Cryptocurrency ticker, e.g. "BTC", "ETH"' },
+                days: { type: 'number', description: 'Lookback period for indicators. Default: 30' },
+            },
+            required: ['ticker'],
+        },
+    },
+    execute: executeSignal,
+    concurrent: true,
+};
+async function executeMarket(input, _ctx) {
+    const { action, ticker } = input;
+    if (!action) {
+        return { output: 'Error: action is required', isError: true };
+    }
+    switch (action) {
+        case 'price': {
+            if (!ticker) {
+                return { output: 'Error: ticker is required for price action', isError: true };
+            }
+            const result = await getPrice(ticker.toUpperCase());
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const { price, change24h, marketCap, volume24h } = result;
+            return {
+                output: `${ticker.toUpperCase()}: $${price.toLocaleString()} (${change24h > 0 ? '+' : ''}${change24h.toFixed(2)}% 24h), Market Cap: ${formatUsd(marketCap)}, Volume: ${formatUsd(volume24h)}`,
+            };
+        }
+        case 'trending': {
+            const result = await getTrending();
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const lines = result.map((c, i) => `${i + 1}. ${c.name} (${c.symbol.toUpperCase()})${c.marketCapRank ? ` — #${c.marketCapRank}` : ''}`);
+            return { output: `Trending coins:\n${lines.join('\n')}` };
+        }
+        case 'overview': {
+            const result = await getMarketOverview();
+            if (typeof result === 'string') {
+                return { output: `Error: ${result}`, isError: true };
+            }
+            const header = 'Rank | Coin | Price | 24h Change | Market Cap';
+            const sep = '-----|------|-------|------------|----------';
+            const rows = result.map((c, i) => `${i + 1} | ${c.name} (${c.symbol.toUpperCase()}) | $${c.price.toLocaleString()} | ${c.change24h > 0 ? '+' : ''}${c.change24h.toFixed(2)}% | ${formatUsd(c.marketCap)}`);
+            return { output: `Top 20 by Market Cap:\n${header}\n${sep}\n${rows.join('\n')}` };
+        }
+        default:
+            return { output: `Error: unknown action "${action}". Use: price, trending, overview`, isError: true };
+    }
+}
+export const tradingMarketCapability = {
+    spec: {
+        name: 'TradingMarket',
+        description: 'Get cryptocurrency market data: price lookup, trending coins, or market overview (top 20 by market cap).',
+        input_schema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['price', 'trending', 'overview'],
+                    description: 'What to fetch: price lookup, trending coins, or market overview',
+                },
+                ticker: {
+                    type: 'string',
+                    description: 'Cryptocurrency ticker (required for price action), e.g. "BTC"',
+                },
+            },
+            required: ['action'],
+        },
+    },
+    execute: executeMarket,
+    concurrent: true,
+};