@spfunctions/cli 1.7.19 → 1.7.22

package/dist/telegram/agent-bridge.js

@@ -1,573 +0,0 @@
-"use strict";
-/**
- * Agent bridge — connects Telegram to pi-agent-core
- *
- * Uses the SAME tools as sf agent --plain. Multi-turn tool calling
- * is handled by pi-agent-core's Agent class (not manual OpenRouter calls).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrCreateAgent = getOrCreateAgent;
-exports.runAgentMessage = runAgentMessage;
-const config_js_1 = require("../config.js");
-let piModules = null;
-async function loadPiModules() {
-    if (piModules)
-        return piModules;
-    const [piAgent, piAi] = await Promise.all([
-        import('@mariozechner/pi-agent-core'),
-        import('@mariozechner/pi-ai'),
-    ]);
-    const typebox = await import('@sinclair/typebox');
-    piModules = { Agent: piAgent.Agent, streamSimple: piAi.streamSimple, Type: typebox.Type };
-    return piModules;
-}
-async function buildTools(sfClient, thesisId, latestContext) {
-    const { Type } = await loadPiModules();
-    const config = (0, config_js_1.loadConfig)();
-    const emptyParams = Type.Object({});
-    // Import Kalshi functions
-    const kalshi = await import('../kalshi.js');
-    const { kalshiFetchAllSeries, kalshiFetchMarketsBySeries, kalshiFetchMarket } = await import('../client.js');
-    const tools = [
-        {
-            name: 'get_context', label: 'Context',
-            description: 'Get thesis snapshot with causal tree, edges, evaluation',
-            parameters: emptyParams,
-            execute: async () => {
-                const ctx = await sfClient.getContext(thesisId);
-                return { content: [{ type: 'text', text: JSON.stringify(ctx, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'global_context', label: 'Snapshot',
-            description: 'Global market snapshot — movers, expiring, milestones, liquidity, signals. No thesis needed.',
-            parameters: emptyParams,
-            execute: async () => {
-                const { fetchGlobalContext } = await import('../client.js');
-                const data = await fetchGlobalContext();
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'query', label: 'Query',
-            description: 'LLM-enhanced prediction market search. Returns answer, live prices, key factors.',
-            parameters: Type.Object({ q: Type.String({ description: 'Question' }) }),
-            execute: async (_id, p) => {
-                const { fetchQuery } = await import('../client.js');
-                const data = await fetchQuery(p.q);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_markets', label: 'Markets',
-            description: 'Traditional market prices: SPY, VIX, Treasury, Gold, Oil.',
-            parameters: emptyParams,
-            execute: async () => {
-                const { fetchTraditionalMarkets } = await import('../client.js');
-                const data = await fetchTraditionalMarkets();
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'inject_signal', label: 'Signal',
-            description: 'Inject a signal (news, note, observation) into the thesis',
-            parameters: Type.Object({
-                content: Type.String({ description: 'Signal content' }),
-                type: Type.Optional(Type.String({ description: 'news | user_note | external' })),
-            }),
-            execute: async (_id, p) => {
-                await sfClient.injectSignal(thesisId, p.type || 'user_note', p.content, 'telegram');
-                return { content: [{ type: 'text', text: 'Signal injected.' }], details: {} };
-            },
-        },
-        {
-            name: 'trigger_evaluation', label: 'Evaluate',
-            description: 'Trigger a deep evaluation cycle',
-            parameters: emptyParams,
-            execute: async () => {
-                await sfClient.evaluate(thesisId);
-                return { content: [{ type: 'text', text: 'Evaluation triggered. Results in ~2 minutes.' }], details: {} };
-            },
-        },
-        {
-            name: 'scan_markets', label: 'Scan',
-            description: 'Search Kalshi markets by keyword, series, or ticker',
-            parameters: Type.Object({
-                query: Type.Optional(Type.String({ description: 'Keyword search' })),
-                series: Type.Optional(Type.String({ description: 'Series ticker' })),
-                market: Type.Optional(Type.String({ description: 'Market ticker' })),
-            }),
-            execute: async (_id, p) => {
-                let result;
-                if (p.market) {
-                    result = await kalshiFetchMarket(p.market);
-                }
-                else if (p.series) {
-                    result = await kalshiFetchMarketsBySeries(p.series);
-                }
-                else if (p.query) {
-                    const series = await kalshiFetchAllSeries();
-                    const kws = p.query.toLowerCase().split(/\s+/);
-                    result = series.filter((s) => kws.every((k) => ((s.title || '') + (s.ticker || '')).toLowerCase().includes(k)))
-                        .filter((s) => parseFloat(s.volume_fp || '0') > 1000)
-                        .sort((a, b) => parseFloat(b.volume_fp || '0') - parseFloat(a.volume_fp || '0'))
-                        .slice(0, 10);
-                }
-                else {
-                    result = { error: 'Provide query, series, or market' };
-                }
-                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'list_theses', label: 'List',
-            description: 'List all theses',
-            parameters: emptyParams,
-            execute: async () => {
-                const theses = await sfClient.listTheses();
-                return { content: [{ type: 'text', text: JSON.stringify(theses, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_positions', label: 'Positions',
-            description: 'Get Kalshi positions with live prices and P&L',
-            parameters: emptyParams,
-            execute: async () => {
-                const positions = await kalshi.getPositions();
-                if (!positions)
-                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
-                for (const pos of positions) {
-                    const price = await kalshi.getMarketPrice(pos.ticker);
-                    if (price != null) {
-                        pos.current_value = price;
-                        pos.unrealized_pnl = Math.round((price - pos.average_price_paid) * pos.quantity);
-                    }
-                }
-                const formatted = positions.map((p) => ({
-                    ticker: p.ticker, qty: p.quantity,
-                    avg_price: `${p.average_price_paid}¢`, current: `${p.current_value}¢`,
-                    pnl: `$${((p.unrealized_pnl || 0) / 100).toFixed(2)}`,
-                }));
-                return { content: [{ type: 'text', text: JSON.stringify(formatted, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_balance', label: 'Balance',
-            description: 'Get Kalshi account balance',
-            parameters: emptyParams,
-            execute: async () => {
-                const bal = await kalshi.getBalance();
-                if (!bal)
-                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
-                return { content: [{ type: 'text', text: JSON.stringify(bal, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_orders', label: 'Orders',
-            description: 'Get resting orders on Kalshi',
-            parameters: emptyParams,
-            execute: async () => {
-                const result = await kalshi.getOrders({ status: 'resting', limit: 50 });
-                if (!result)
-                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
-                return { content: [{ type: 'text', text: JSON.stringify(result.orders, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_fills', label: 'Fills',
-            description: 'Get recent trade fills',
-            parameters: Type.Object({ ticker: Type.Optional(Type.String()) }),
-            execute: async (_id, p) => {
-                const result = await kalshi.getFills({ ticker: p.ticker, limit: 20 });
-                if (!result)
-                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
-                return { content: [{ type: 'text', text: JSON.stringify(result.fills, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_settlements', label: 'Settlements',
-            description: 'Get settled contracts with P&L',
-            parameters: emptyParams,
-            execute: async () => {
-                const result = await kalshi.getSettlements({ limit: 50 });
-                if (!result)
-                    return { content: [{ type: 'text', text: 'Kalshi not configured.' }], details: {} };
-                return { content: [{ type: 'text', text: JSON.stringify(result.settlements, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_edges', label: 'Edges',
-            description: 'Top 10 edges across all active theses',
-            parameters: emptyParams,
-            execute: async () => {
-                const { theses } = await sfClient.listTheses();
-                const active = (theses || []).filter((t) => t.status === 'active');
-                const results = await Promise.allSettled(active.map(async (t) => {
-                    const ctx = await sfClient.getContext(t.id);
-                    return (ctx.edges || []).map((e) => ({ ...e, thesisId: t.id }));
-                }));
-                const allEdges = [];
-                for (const r of results) {
-                    if (r.status === 'fulfilled')
-                        allEdges.push(...r.value);
-                }
-                allEdges.sort((a, b) => Math.abs(b.edge || 0) - Math.abs(a.edge || 0));
-                return { content: [{ type: 'text', text: JSON.stringify(allEdges.slice(0, 10), null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_schedule', label: 'Schedule',
-            description: 'Exchange status (open/closed) and trading hours',
-            parameters: emptyParams,
-            execute: async () => {
-                const res = await fetch('https://api.elections.kalshi.com/trade-api/v2/exchange/status', { headers: { 'Accept': 'application/json' } });
-                if (!res.ok)
-                    return { content: [{ type: 'text', text: `API error: ${res.status}` }], details: {} };
-                const data = await res.json();
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'get_feed', label: 'Feed',
-            description: 'Recent evaluation history',
-            parameters: Type.Object({ hours: Type.Optional(Type.Number({ description: 'Hours of history (default 24)' })) }),
-            execute: async (_id, p) => {
-                const data = await sfClient.getFeed(p.hours || 24);
-                return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-            },
-        },
-        {
-            name: 'web_search', label: 'Search',
-            description: 'Search the web for latest news',
-            parameters: Type.Object({ query: Type.String({ description: 'Search query' }) }),
-            execute: async (_id, p) => {
-                const tavilyKey = process.env.TAVILY_API_KEY || config.tavilyKey;
-                const tgSfKey = config.apiKey || process.env.SF_API_KEY;
-                const tgSfUrl = config.apiUrl || process.env.SF_API_URL || 'https://simplefunctions.dev';
-                const canProxySearch = !tavilyKey && tgSfKey;
-                if (!tavilyKey && !canProxySearch)
-                    return { content: [{ type: 'text', text: 'Web search not available. Run sf login or set TAVILY_API_KEY.' }], details: {} };
-                let res;
-                if (tavilyKey) {
-                    res = await fetch('https://api.tavily.com/search', {
-                        method: 'POST', headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ api_key: tavilyKey, query: p.query, max_results: 3, search_depth: 'basic', include_answer: true }),
-                    });
-                }
-                else {
-                    res = await fetch(`${tgSfUrl}/api/proxy/search`, {
-                        method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${tgSfKey}` },
-                        body: JSON.stringify({ query: p.query, max_results: 3, search_depth: 'basic', include_answer: true }),
-                    });
-                }
-                if (!res.ok)
-                    return { content: [{ type: 'text', text: `Search failed: ${res.status}` }], details: {} };
-                const data = await res.json();
-                const answer = data.answer ? `Summary: ${data.answer}\n\n` : '';
-                const results = (data.results || []).map((r) => `${r.title}: ${(r.content || '').slice(0, 150)}`).join('\n\n');
-                return { content: [{ type: 'text', text: `${answer}${results}` }], details: {} };
-            },
-        },
-        {
-            name: 'create_thesis', label: 'Create',
-            description: 'Create a new thesis',
-            parameters: Type.Object({ rawThesis: Type.String({ description: 'Thesis statement' }) }),
-            execute: async (_id, p) => {
-                const result = await sfClient.createThesis(p.rawThesis, true);
-                return { content: [{ type: 'text', text: `Created: ${result.id}\nConfidence: ${Math.round((result.confidence || 0.5) * 100)}%` }], details: {} };
-            },
-        },
-        {
-            name: 'what_if', label: 'What-If',
-            description: 'Override causal tree node probabilities and see how edges change. Zero LLM cost.',
-            parameters: Type.Object({
-                overrides: Type.Array(Type.Object({
-                    nodeId: Type.String({ description: 'Node ID (e.g. n1, n3.1)' }),
-                    newProbability: Type.Number({ description: 'New probability 0-1' }),
-                })),
-            }),
-            execute: async (_id, p) => {
-                const ctx = latestContext;
-                const allNodes = [];
-                function flatten(nodes) { for (const n of nodes) {
-                    allNodes.push(n);
-                    if (n.children?.length)
-                        flatten(n.children);
-                } }
-                flatten(ctx?.causalTree?.nodes || []);
-                const overrideMap = new Map(p.overrides.map((o) => [o.nodeId, o.newProbability]));
-                const topNodes = (ctx?.causalTree?.nodes || []).filter((n) => !n.parentId || n.depth === 0);
-                const oldConf = topNodes.reduce((s, n) => s + (n.probability || 0.5), 0) / Math.max(topNodes.length, 1);
-                for (const n of allNodes) {
-                    if (overrideMap.has(n.id))
-                        n.probability = overrideMap.get(n.id);
-                }
-                const newConf = topNodes.reduce((s, n) => s + (n.probability || 0.5), 0) / Math.max(topNodes.length, 1);
-                const edges = (ctx?.edges || []).slice(0, 10).map((e) => {
-                    const node = allNodes.find((n) => n.id === e.relatedNodeId);
-                    if (!node || !overrideMap.has(node.id))
-                        return { market: e.market, oldEdge: e.edge, newEdge: e.edge, signal: 'unchanged' };
-                    const scale = node.probability / (e.confidence || 0.5);
-                    const newThesis = Math.round(e.thesisPrice * scale);
-                    const newEdge = newThesis - e.marketPrice;
-                    return { market: e.market, oldEdge: e.edge, newEdge, signal: Math.abs(newEdge - e.edge) < 1 ? 'unchanged' : 'changed' };
-                }).filter((e) => e.signal !== 'unchanged');
-                return { content: [{ type: 'text', text: JSON.stringify({ confidence: { old: Math.round(oldConf * 100), new: Math.round(newConf * 100) }, edges }, null, 2) }], details: {} };
-            },
-        },
-    ];
-    // ── X (Twitter) tools ──
-    tools.push({
-        name: 'search_x', label: 'X Search',
-        description: 'Search X (Twitter) for recent discussions. Returns posts, sentiment, themes.',
-        parameters: Type.Object({
-            query: Type.String({ description: 'Search query' }),
-            mode: Type.Optional(Type.String({ description: '"summary" or "raw"' })),
-            hours: Type.Optional(Type.Number({ description: 'Hours (default 24)' })),
-        }),
-        execute: async (_id, p) => {
-            const data = await sfClient.searchX(p.query, { mode: p.mode, hours: p.hours });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-        },
-    }, {
-        name: 'x_volume', label: 'X Volume',
-        description: 'X discussion volume trend — total posts, velocity, peak time.',
-        parameters: Type.Object({
-            query: Type.String({ description: 'Search query' }),
-            hours: Type.Optional(Type.Number({ description: 'Hours (default 72)' })),
-        }),
-        execute: async (_id, p) => {
-            const data = await sfClient.getXVolume(p.query, { hours: p.hours });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-        },
-    }, {
-        name: 'x_news', label: 'X News',
-        description: 'News stories trending on X — titles, summaries, tickers.',
-        parameters: Type.Object({
-            query: Type.String({ description: 'Search query' }),
-            limit: Type.Optional(Type.Number({ description: 'Max stories (default 10)' })),
-        }),
-        execute: async (_id, p) => {
-            const data = await sfClient.searchXNews(p.query, { limit: p.limit });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-        },
-    }, {
-        name: 'x_account', label: 'X Account',
-        description: 'Recent posts from a specific X account.',
-        parameters: Type.Object({
-            username: Type.String({ description: 'X username (with or without @)' }),
-            hours: Type.Optional(Type.Number({ description: 'Hours (default 24)' })),
-        }),
-        execute: async (_id, p) => {
-            const data = await sfClient.getXAccount(p.username, { hours: p.hours });
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-        },
-    }, {
-        name: 'heartbeat_config', label: 'Heartbeat Config',
-        description: 'View or update heartbeat settings: scan intervals, model tier, budget cap, pause/resume. Shows cost breakdown.',
-        parameters: Type.Object({
-            thesisId: Type.String({ description: 'Thesis ID' }),
-            newsIntervalMin: Type.Optional(Type.Number({ description: 'News scan interval (15-1440 min)' })),
-            xIntervalMin: Type.Optional(Type.Number({ description: 'X scan interval (60-1440 min)' })),
-            evalModelTier: Type.Optional(Type.String({ description: 'cheap, medium, or heavy' })),
-            monthlyBudgetUsd: Type.Optional(Type.Number({ description: 'Monthly budget (0 = unlimited)' })),
-            paused: Type.Optional(Type.Boolean({ description: 'Pause or resume heartbeat' })),
-        }),
-        execute: async (_id, p) => {
-            const hasUp = p.newsIntervalMin || p.xIntervalMin || p.evalModelTier || p.monthlyBudgetUsd !== undefined || p.paused !== undefined;
-            if (hasUp) {
-                const u = {};
-                if (p.newsIntervalMin)
-                    u.newsIntervalMin = p.newsIntervalMin;
-                if (p.xIntervalMin)
-                    u.xIntervalMin = p.xIntervalMin;
-                if (p.evalModelTier)
-                    u.evalModelTier = p.evalModelTier;
-                if (p.monthlyBudgetUsd !== undefined)
-                    u.monthlyBudgetUsd = p.monthlyBudgetUsd;
-                if (p.paused !== undefined)
-                    u.paused = p.paused;
-                await sfClient.updateHeartbeatConfig(p.thesisId, u);
-            }
-            const data = await sfClient.getHeartbeatConfig(p.thesisId);
-            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], details: {} };
-        },
-    });
-    // Trading tools (only if enabled)
-    if (config.tradingEnabled) {
-        tools.push({
-            name: 'place_order',
-            label: 'Place Order',
-            description: 'Place a buy or sell order on Kalshi. Requires trading to be enabled. Always confirm with user before placing.',
-            parameters: Type.Object({
-                ticker: Type.String({ description: 'Market ticker (e.g. KXWTIMAX-26DEC31-T135)' }),
-                side: Type.String({ description: 'yes or no' }),
-                action: Type.String({ description: 'buy or sell' }),
-                count: Type.Number({ description: 'Number of contracts' }),
-                yes_price: Type.Number({ description: 'Price in cents (1-99)' }),
-            }),
-            execute: async (_id, p) => {
-                try {
-                    const result = await kalshi.createOrder({
-                        ticker: p.ticker,
-                        side: p.side,
-                        action: p.action,
-                        type: 'limit',
-                        count: p.count,
-                        yes_price: p.yes_price,
-                    });
-                    return { content: [{ type: 'text', text: `✓ Order placed: ${(result.order || result).order_id || 'OK'}\n${p.action.toUpperCase()} ${p.count}x ${p.ticker} ${p.side.toUpperCase()} @ ${p.yes_price}¢` }], details: {} };
-                }
-                catch (err) {
-                    return { content: [{ type: 'text', text: `✗ Order failed: ${err.message}` }], details: {} };
-                }
-            },
-        }, {
-            name: 'cancel_order',
-            label: 'Cancel Order',
-            description: 'Cancel a resting order on Kalshi.',
-            parameters: Type.Object({
-                orderId: Type.String({ description: 'Order ID to cancel' }),
-            }),
-            execute: async (_id, p) => {
-                try {
-                    await kalshi.cancelOrder(p.orderId);
-                    return { content: [{ type: 'text', text: `✓ Order ${p.orderId} cancelled.` }], details: {} };
-                }
-                catch (err) {
-                    return { content: [{ type: 'text', text: `✗ Cancel failed: ${err.message}` }], details: {} };
-                }
-            },
-        });
-    }
-    return tools;
-}
-async function getOrCreateAgent(sfClient, session) {
-    if (session.agent)
-        return session.agent;
-    const { Agent, streamSimple } = await loadPiModules();
-    const piAi = await import('@mariozechner/pi-ai');
-    const { getModel } = piAi;
-    const config = (0, config_js_1.loadConfig)();
-    const directOrKey = config.openrouterKey || process.env.OPENROUTER_API_KEY;
-    const sfApiKey = config.apiKey || process.env.SF_API_KEY;
-    const sfApiUrl = config.apiUrl || process.env.SF_API_URL || 'https://simplefunctions.dev';
-    const tgUseProxy = !directOrKey && !!sfApiKey;
-    const openrouterKey = directOrKey || sfApiKey;
-    if (!openrouterKey)
-        throw new Error('Need API key. Run sf login or sf setup.');
-    const ctx = await sfClient.getContext(session.thesisId);
-    const conf = typeof ctx.confidence === 'number' ? Math.round(ctx.confidence * 100) : 50;
-    const tools = await buildTools(sfClient, session.thesisId, ctx);
-    // Resolve model object (not just a string — pi-ai needs api/provider/baseUrl)
-    const modelName = config.model || 'anthropic/claude-sonnet-4.6';
-    let model;
-    try {
-        model = getModel('openrouter', modelName);
-    }
-    catch {
-        model = {
-            modelId: modelName, provider: 'openrouter', api: 'openai-completions',
-            baseUrl: 'https://openrouter.ai/api/v1', id: modelName, name: modelName,
-            inputPrice: 0, outputPrice: 0, contextWindow: 200000,
-            supportsImages: true, supportsTools: true,
-        };
-    }
-    if (tgUseProxy)
-        model.baseUrl = `${sfApiUrl}/api/proxy`;
-    const edgesSummary = (ctx.edges || [])
-        .sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge))
-        .slice(0, 5)
-        .map((e) => `  ${(e.market || '').slice(0, 35)} | ${e.venue || 'kalshi'} | mkt ${e.marketPrice}¢ → thesis ${e.thesisPrice}¢ | edge ${e.edge > 0 ? '+' : ''}${e.edge}`)
-        .join('\n') || '  (no edges)';
-    const nodesSummary = (ctx.causalTree?.nodes || [])
-        .filter((n) => n.depth === 0 || !n.depth)
-        .slice(0, 5)
-        .map((n) => `  ${n.id} ${(n.label || '').slice(0, 35)} — ${Math.round((n.probability || 0.5) * 100)}%`)
-        .join('\n') || '  (no causal tree)';
-    const systemPrompt = `You are a prediction market trading assistant on Telegram. Your job is to help the user see reality clearly and make correct trading decisions.
-
-## Framework
-Edge = thesis price - market price. Positive = market underprices.
-Edge types: [consensus] depth>=500 real opponents, [attention] depth<100 illusory, [timing] market lags, [risk_premium] platform risk. Tag when reporting.
-Price: depth >= 500 = consensus, < 100 = unreliable, spread > 5 = noisy.
-
-## Rules
-- When reporting an edge, tag it: [consensus] [attention] [timing] [risk_premium].
-- If any kill condition is triggered or approaching, lead with that.
-- If nothing material to do, say "quiet — no action needed." Don't pad.
-- Keep Telegram messages SHORT — bullet points, no walls of text.
-- Prices in cents (¢). P&L in dollars ($). Don't re-convert tool output units.
-- Call tools for fresh data. Never guess prices or P&L from this prompt.
-- Use search_x for X/Twitter sentiment. Use x_volume for discussion spikes. Use x_account to track key people.
-- Use heartbeat_config to view/adjust scan intervals, model tier, budget cap, or check cost breakdown.
-- You don't know user's positions. Call get_positions before discussing trades.
-- If user mentions news, inject_signal immediately. Don't ask "should I?"
-- If user says "evaluate" or "run it", trigger immediately.
-- Don't end with "anything else?" — user will ask.
-- Use Chinese if user writes Chinese, English if English.
-${config.tradingEnabled ? '- Trading ENABLED. You have place_order and cancel_order. ALWAYS confirm before placing.' : '- Trading DISABLED. Tell user: sf setup --enable-trading'}
-
-## Current State
-Thesis: ${(ctx.thesis || ctx.rawThesis || 'N/A').slice(0, 200)}
-ID: ${session.thesisId.slice(0, 8)} | Confidence: ${conf}%
-
-Causal nodes:
-${nodesSummary}
-
-Top edges:
-${edgesSummary}
-
-${ctx.lastEvaluation?.summary ? `Latest eval: ${ctx.lastEvaluation.summary.slice(0, 200)}` : ''}`;
-    const agent = new Agent({
-        initialState: {
-            systemPrompt,
-            model,
-            tools,
-            thinkingLevel: 'off',
-        },
-        streamFn: streamSimple,
-        getApiKey: (provider) => provider === 'openrouter' ? openrouterKey : undefined,
-    });
-    // Restore session messages if available
-    if (session.agentMessages.length > 0) {
-        try {
-            agent.replaceMessages(session.agentMessages);
-        }
-        catch { /* start fresh */ }
-    }
-    session.agent = agent;
-    return agent;
-}
-async function runAgentMessage(client, session, userMessage) {
-    const agent = await getOrCreateAgent(client, session);
-    return new Promise((resolve, reject) => {
-        let response = '';
-        let toolLog = '';
-        const timeout = setTimeout(() => {
-            resolve(response || toolLog || 'Response timeout (45s). Try a simpler question.');
-        }, 45_000);
-        const unsub = agent.subscribe((event) => {
-            if (event.type === 'message_update') {
-                const e = event.assistantMessageEvent;
-                if (e.type === 'text_delta')
-                    response += e.delta;
-            }
-            if (event.type === 'tool_execution_start') {
-                toolLog += `⚡ ${event.toolName}\n`;
-            }
-            if (event.type === 'agent_end') {
-                clearTimeout(timeout);
-                unsub?.();
-                // Save messages for session continuity
-                session.agentMessages = agent.state.messages || [];
-                resolve(response || toolLog || '(no response)');
-            }
-        });
-        agent.prompt(userMessage).catch((err) => {
-            clearTimeout(timeout);
-            unsub?.();
-            reject(err);
-        });
-    });
-}

package/dist/telegram/bot.d.ts

@@ -1,10 +0,0 @@
-/**
- * Telegram Bot — main entry point
- *
- * Handles slash commands (zero LLM) and free text (via pi-agent-core).
- * Polls delta API for push notifications.
- */
-export declare function startBot(opts: {
-    token?: string;
-    chatId?: number;
-}): Promise<void>;