@spfunctions/cli 1.4.3 → 1.4.5

package/dist/commands/dashboard.js

@@ -1,17 +1,19 @@
 "use strict";
 /**
- * sf dashboard — Portfolio overview
+ * sf dashboard — Commander entry point
  *
- * One-screen summary: theses, positions, risk exposure, top unpositioned edges.
- * Uses existing APIs + local Kalshi positions.
+ * Three modes:
+ *   --json   → dump current state as JSON
+ *   --once   → one-time formatted print (no interactive TUI)
+ *   default  → launch interactive TUI dashboard
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dashboardCommand = dashboardCommand;
 const client_js_1 = require("../client.js");
 const kalshi_js_1 = require("../kalshi.js");
 const topics_js_1 = require("../topics.js");
+const dashboard_js_1 = require("../tui/dashboard.js");
 function categorize(ticker) {
-    // Match longest prefix first
     const sorted = Object.keys(topics_js_1.RISK_CATEGORIES).sort((a, b) => b.length - a.length);
     for (const prefix of sorted) {
         if (ticker.startsWith(prefix))
@@ -31,8 +33,13 @@ function timeAgo(dateStr) {
     return `${days}d ago`;
 }
 async function dashboardCommand(opts) {
+    // ── Default: interactive TUI ──
+    if (!opts?.json && !opts?.once) {
+        await (0, dashboard_js_1.startDashboard)();
+        return;
+    }
+    // ── JSON or one-time print modes (legacy behavior) ──
     const client = new client_js_1.SFClient(opts?.apiKey, opts?.apiUrl);
-    // ── Fetch data in parallel ─────────────────────────────────────────────────
     const [thesesResult, positions] = await Promise.all([
         client.listTheses(),
         (0, kalshi_js_1.getPositions)().catch(() => null),
@@ -59,7 +66,7 @@ async function dashboardCommand(opts) {
             }
         }
     }
-    // ── Collect all edges across all theses ────────────────────────────────────
+    // Collect all edges across all theses
     const allEdges = [];
     for (const ctx of contexts) {
         if (!ctx?.edges)
@@ -78,26 +85,22 @@ async function dashboardCommand(opts) {
     }
     // Find positioned tickers
     const positionedTickers = new Set(positions?.map((p) => p.ticker) || []);
-    // Unpositioned edges = edges where no position exists on that marketId
+    // Unpositioned edges
     const unpositionedEdges = [...edgeMap.values()]
         .filter(e => !positionedTickers.has(e.marketId))
         .sort((a, b) => Math.abs(b.edge) - Math.abs(a.edge))
         .slice(0, 10);
-    // ── JSON output ────────────────────────────────────────────────────────────
+    // ── JSON output ──
     if (opts?.json) {
-        console.log(JSON.stringify({
-            theses,
-            positions,
-            unpositionedEdges,
-        }, null, 2));
+        console.log(JSON.stringify({ theses, positions, unpositionedEdges }, null, 2));
         return;
     }
-    // ── Formatted output ───────────────────────────────────────────────────────
+    // ── One-time formatted output ──
     console.log();
     console.log('  SimpleFunctions Dashboard');
-    console.log('  ' + '─'.repeat(50));
+    console.log('  ' + '\u2500'.repeat(50));
     console.log();
-    // ── Theses ─────────────────────────────────────────────────────────────────
+    // Theses
     console.log('  Theses');
     if (theses.length === 0) {
         console.log('    (none)');
@@ -115,7 +118,7 @@ async function dashboardCommand(opts) {
         }
     }
     console.log();
-    // ── Positions ──────────────────────────────────────────────────────────────
+    // Positions
     console.log('  Positions');
     if (!positions || positions.length === 0) {
         console.log('    (no Kalshi positions or Kalshi not configured)');
@@ -126,8 +129,8 @@ async function dashboardCommand(opts) {
         for (const p of positions) {
             const ticker = (p.ticker || '').padEnd(22);
             const qty = String(p.quantity || 0).padStart(5);
-            const avg = `${p.average_price_paid || 0}¢`;
-            const now = typeof p.current_value === 'number' ? `${p.current_value}¢` : '?¢';
+            const avg = `${p.average_price_paid || 0}\u00A2`;
+            const now = typeof p.current_value === 'number' ? `${p.current_value}\u00A2` : '?\u00A2';
             const pnlCents = p.unrealized_pnl || 0;
             const pnlDollars = (pnlCents / 100).toFixed(2);
             const pnlStr = pnlCents >= 0 ? `+$${pnlDollars}` : `-$${Math.abs(parseFloat(pnlDollars)).toFixed(2)}`;
@@ -136,14 +139,14 @@ async function dashboardCommand(opts) {
             totalPnl += pnlCents;
             console.log(`    ${ticker} ${qty} @ ${avg.padEnd(5)} now ${now.padEnd(5)}  ${pnlStr}`);
         }
-        console.log('    ' + '─'.repeat(45));
+        console.log('    ' + '\u2500'.repeat(45));
         const totalCostDollars = (totalCost / 100).toFixed(0);
         const totalPnlDollars = (totalPnl / 100).toFixed(2);
         const pnlDisplay = totalPnl >= 0 ? `+$${totalPnlDollars}` : `-$${Math.abs(parseFloat(totalPnlDollars)).toFixed(2)}`;
         console.log(`    Total cost: $${totalCostDollars}  |  P&L: ${pnlDisplay}`);
     }
     console.log();
-    // ── Risk Exposure ──────────────────────────────────────────────────────────
+    // Risk Exposure
     if (positions && positions.length > 0) {
         console.log('  Risk Exposure');
         const riskGroups = new Map();
@@ -157,7 +160,6 @@ async function dashboardCommand(opts) {
                 existing.tickers.push(p.ticker);
             riskGroups.set(cat, existing);
         }
-        // Sort by cost descending
         const sorted = [...riskGroups.entries()].sort((a, b) => b[1].cost - a[1].cost);
         for (const [category, data] of sorted) {
             const costDollars = `$${(data.cost / 100).toFixed(0)}`;
@@ -168,16 +170,16 @@ async function dashboardCommand(opts) {
         }
         console.log();
     }
-    // ── Top Unpositioned Edges ─────────────────────────────────────────────────
+    // Top Unpositioned Edges
     if (unpositionedEdges.length > 0) {
         console.log('  Top Unpositioned Edges');
         for (const e of unpositionedEdges) {
             const name = (e.market || e.marketId || '').slice(0, 25).padEnd(25);
-            const mkt = `${e.marketPrice}¢`;
-            const thesis = `${e.thesisPrice}¢`;
+            const mkt = `${e.marketPrice}\u00A2`;
+            const thesis = `${e.thesisPrice}\u00A2`;
             const edge = e.edge > 0 ? `+${e.edge}` : `${e.edge}`;
             const liq = e.orderbook?.liquidityScore || '?';
-            console.log(`    ${name} ${mkt.padStart(5)} → ${thesis.padStart(5)}  edge ${edge.padStart(4)}  ${liq}`);
+            console.log(`    ${name} ${mkt.padStart(5)} \u2192 ${thesis.padStart(5)}  edge ${edge.padStart(4)}  ${liq}`);
         }
         console.log();
     }

package/dist/commands/performance.js

@@ -56,15 +56,22 @@ async function performanceCommand(opts) {
         if (!ticker)
             continue;
         const action = fill.action || 'buy';
+        const side = fill.side || 'yes';
         const count = Math.round(parseFloat(fill.count_fp || fill.count || '0'));
         const yesPrice = Math.round(parseFloat(fill.yes_price_dollars || '0') * 100);
+        // buy yes = +count, sell yes = -count
+        // buy no = -count (short yes), sell no = +count (close short)
         let delta = count;
         if (action === 'sell')
-            delta = -count;
+            delta = -delta;
+        if (side === 'no')
+            delta = -delta;
         const info = tickerMap.get(ticker) || { ticker, netQty: 0, totalCostCents: 0, totalContracts: 0, earliestFillTs: Infinity };
         info.netQty += delta;
         if (delta > 0) {
-            info.totalCostCents += yesPrice * count;
+            // Entering a position — accumulate cost
+            const costPerContract = side === 'no' ? (100 - yesPrice) : yesPrice;
+            info.totalCostCents += costPerContract * count;
             info.totalContracts += count;
         }
         const fillTime = fill.created_time || fill.ts || fill.created_at;

package/dist/commands/telegram.d.ts

@@ -0,0 +1,15 @@
+/**
+ * sf telegram — Start Telegram bot
+ *
+ * Token is saved to ~/.sf/config.json on first use.
+ * --daemon: fork to background, write PID to ~/.sf/telegram.pid
+ * --stop: kill running daemon
+ * --status: check if daemon is running
+ */
+export declare function telegramCommand(opts: {
+    token?: string;
+    chatId?: string;
+    daemon?: boolean;
+    stop?: boolean;
+    status?: boolean;
+}): Promise<void>;

package/dist/commands/telegram.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * sf telegram — Start Telegram bot
+ *
+ * Token is saved to ~/.sf/config.json on first use.
+ * --daemon: fork to background, write PID to ~/.sf/telegram.pid
+ * --stop: kill running daemon
+ * --status: check if daemon is running
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramCommand = telegramCommand;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const config_js_1 = require("../config.js");
+const PID_FILE = path_1.default.join(os_1.default.homedir(), '.sf', 'telegram.pid');
+const LOG_FILE = path_1.default.join(os_1.default.homedir(), '.sf', 'telegram.log');
+function readPid() {
+    try {
+        const pid = parseInt(fs_1.default.readFileSync(PID_FILE, 'utf-8').trim());
+        if (isNaN(pid))
+            return null;
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve token: --token flag > config > env var. Save to config if new. */
+function resolveToken(flagToken) {
+    const config = (0, config_js_1.loadConfig)();
+    // Flag takes priority
+    if (flagToken) {
+        // Save to config for future use
+        const file = (0, config_js_1.loadFileConfig)();
+        if (file.telegramBotToken !== flagToken) {
+            (0, config_js_1.saveConfig)({ ...file, telegramBotToken: flagToken });
+        }
+        return flagToken;
+    }
+    return config.telegramBotToken || null;
+}
+async function telegramCommand(opts) {
+    // ── sf telegram --stop ──
+    if (opts.stop) {
+        const pid = readPid();
+        if (pid) {
+            process.kill(pid, 'SIGTERM');
+            try {
+                fs_1.default.unlinkSync(PID_FILE);
+            }
+            catch { }
+            console.log(`  Telegram bot stopped (PID ${pid})`);
+        }
+        else {
+            console.log('  No running Telegram bot found.');
+        }
+        return;
+    }
+    // ── sf telegram --status ──
+    if (opts.status) {
+        const pid = readPid();
+        if (pid) {
+            console.log(`  Telegram bot running (PID ${pid})`);
+            console.log(`  Log: ${LOG_FILE}`);
+        }
+        else {
+            console.log('  Telegram bot not running.');
+        }
+        return;
+    }
+    // Resolve token (saves to config on first use)
+    const token = resolveToken(opts.token);
+    if (!token) {
+        console.log('  No Telegram bot token configured.\n');
+        console.log('  Setup:');
+        console.log('    1. Message @BotFather on Telegram → /newbot');
+        console.log('    2. Copy the token');
+        console.log('    3. Run: sf telegram --token YOUR_TOKEN\n');
+        console.log('  The token will be saved to ~/.sf/config.json for future use.');
+        return;
+    }
+    // ── sf telegram --daemon ──
+    if (opts.daemon) {
+        const existing = readPid();
+        if (existing) {
+            console.log(`  Bot already running (PID ${existing}). Use --stop first.`);
+            return;
+        }
+        // Daemon doesn't need --token since it's in config now
+        const args = ['telegram'];
+        if (opts.chatId)
+            args.push('--chat-id', opts.chatId);
+        const sfBin = process.argv[1];
+        fs_1.default.mkdirSync(path_1.default.dirname(PID_FILE), { recursive: true });
+        const logStream = fs_1.default.openSync(LOG_FILE, 'a');
+        const child = (0, child_process_1.spawn)(process.execPath, [sfBin, ...args], {
+            detached: true,
+            stdio: ['ignore', logStream, logStream],
+            env: { ...process.env },
+        });
+        child.unref();
+        fs_1.default.writeFileSync(PID_FILE, String(child.pid));
+        console.log(`  Telegram bot started in background (PID ${child.pid})`);
+        console.log(`  Log: ${LOG_FILE}`);
+        console.log(`  Stop: sf telegram --stop`);
+        return;
+    }
+    // ── sf telegram (foreground) ──
+    const { startBot } = await import('../telegram/bot.js');
+    await startBot({
+        token,
+        chatId: opts.chatId ? parseInt(opts.chatId) : undefined,
+    });
+}

package/dist/config.d.ts

@@ -16,6 +16,7 @@ export interface SFConfig {
     tavilyKey?: string;
     model?: string;
     tradingEnabled?: boolean;
+    telegramBotToken?: string;
     configuredAt?: string;
 }
 /**

package/dist/config.js

@@ -53,6 +53,7 @@ function loadConfig() {
         tavilyKey: process.env.TAVILY_API_KEY || file.tavilyKey,
         model: process.env.SF_MODEL || file.model || DEFAULT_MODEL,
         tradingEnabled: file.tradingEnabled || false,
+        telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || file.telegramBotToken,
     };
 }
 /**

package/dist/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config.test.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('fs', () => ({
+    default: {
+        existsSync: vitest_1.vi.fn(),
+        readFileSync: vitest_1.vi.fn(),
+        writeFileSync: vitest_1.vi.fn(),
+        mkdirSync: vitest_1.vi.fn(),
+        unlinkSync: vitest_1.vi.fn(),
+    },
+    existsSync: vitest_1.vi.fn(),
+    readFileSync: vitest_1.vi.fn(),
+    writeFileSync: vitest_1.vi.fn(),
+    mkdirSync: vitest_1.vi.fn(),
+    unlinkSync: vitest_1.vi.fn(),
+}));
+const fs_1 = __importDefault(require("fs"));
+const config_js_1 = require("./config.js");
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.mocked(fs_1.default.existsSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.readFileSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.writeFileSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.mkdirSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.unlinkSync).mockReset();
+    // Clear env vars
+    delete process.env.SF_API_KEY;
+    delete process.env.SF_API_URL;
+    delete process.env.OPENROUTER_API_KEY;
+    delete process.env.KALSHI_API_KEY_ID;
+    delete process.env.KALSHI_PRIVATE_KEY_PATH;
+    delete process.env.TAVILY_API_KEY;
+    delete process.env.SF_MODEL;
+    delete process.env.TELEGRAM_BOT_TOKEN;
+});
+(0, vitest_1.describe)('loadFileConfig', () => {
+    (0, vitest_1.it)('returns empty object when no config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({});
+    });
+    (0, vitest_1.it)('reads and parses config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({ apiKey: 'sf_live_test' }));
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({ apiKey: 'sf_live_test' });
+    });
+    (0, vitest_1.it)('returns empty object on corrupt file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue('not json');
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({});
+    });
+});
+(0, vitest_1.describe)('loadConfig', () => {
+    (0, vitest_1.it)('returns defaults when no file and no env', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiUrl).toBe('https://simplefunctions.dev');
+        (0, vitest_1.expect)(config.model).toBe('anthropic/claude-sonnet-4.6');
+        (0, vitest_1.expect)(config.tradingEnabled).toBe(false);
+    });
+    (0, vitest_1.it)('env vars override file values', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            model: 'file_model',
+        }));
+        process.env.SF_API_KEY = 'env_key';
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('env_key');
+        (0, vitest_1.expect)(config.model).toBe('file_model');
+    });
+    (0, vitest_1.it)('file values fill gaps', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            tavilyKey: 'tavily123',
+        }));
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('file_key');
+        (0, vitest_1.expect)(config.tavilyKey).toBe('tavily123');
+    });
+});
+(0, vitest_1.describe)('saveConfig', () => {
+    (0, vitest_1.it)('writes JSON with configuredAt', () => {
+        (0, config_js_1.saveConfig)({ apiKey: 'test_key' });
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.mkdirSync)).toHaveBeenCalled();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.writeFileSync)).toHaveBeenCalled();
+        const written = JSON.parse(vitest_1.vi.mocked(fs_1.default.writeFileSync).mock.calls[0][1]);
+        (0, vitest_1.expect)(written.apiKey).toBe('test_key');
+        (0, vitest_1.expect)(written.configuredAt).toBeDefined();
+    });
+});
+(0, vitest_1.describe)('applyConfig', () => {
+    (0, vitest_1.it)('sets env vars from file when not already set', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            openrouterKey: 'or_key',
+        }));
+        (0, config_js_1.applyConfig)();
+        (0, vitest_1.expect)(process.env.SF_API_KEY).toBe('file_key');
+        (0, vitest_1.expect)(process.env.OPENROUTER_API_KEY).toBe('or_key');
+    });
+    (0, vitest_1.it)('does not override existing env vars', () => {
+        process.env.SF_API_KEY = 'existing_key';
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+        }));
+        (0, config_js_1.applyConfig)();
+        (0, vitest_1.expect)(process.env.SF_API_KEY).toBe('existing_key');
+    });
+});
+(0, vitest_1.describe)('isConfigured', () => {
+    (0, vitest_1.it)('returns true when apiKey is set', () => {
+        process.env.SF_API_KEY = 'test';
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.isConfigured)()).toBe(true);
+    });
+    (0, vitest_1.it)('returns false when no apiKey', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.isConfigured)()).toBe(false);
+    });
+});
+(0, vitest_1.describe)('resetConfig', () => {
+    (0, vitest_1.it)('deletes config file if exists', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        (0, config_js_1.resetConfig)();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.unlinkSync)).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('does nothing if no config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, config_js_1.resetConfig)();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.unlinkSync)).not.toHaveBeenCalled();
+    });
+});

package/dist/index.js

@@ -52,6 +52,7 @@ const announcements_js_1 = require("./commands/announcements.js");
 const history_js_1 = require("./commands/history.js");
 const performance_js_1 = require("./commands/performance.js");
 const liquidity_js_1 = require("./commands/liquidity.js");
+const telegram_js_1 = require("./commands/telegram.js");
 const utils_js_1 = require("./utils.js");
 // ── Apply ~/.sf/config.json to process.env BEFORE any command ────────────────
 // This means client.ts, kalshi.ts, agent.ts keep reading process.env and just work.
@@ -238,11 +239,12 @@ program
 // ── sf dashboard ──────────────────────────────────────────────────────────────
 program
     .command('dashboard')
-    .description('Portfolio overview — theses, positions, risk, unpositioned edges')
+    .description('Portfolio overview — interactive TUI (default), or one-shot with --once/--json')
     .option('--json', 'JSON output')
+    .option('--once', 'One-time print (no interactive mode)')
     .action(async (opts, cmd) => {
     const g = cmd.optsWithGlobals();
-    await run(() => (0, dashboard_js_1.dashboardCommand)({ json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+    await run(() => (0, dashboard_js_1.dashboardCommand)({ json: opts.json, once: opts.once, apiKey: g.apiKey, apiUrl: g.apiUrl }));
 });
 // ── sf milestones ────────────────────────────────────────────────────────────
 program
@@ -409,6 +411,18 @@ program
     .action(async (opts) => {
     await run(() => (0, liquidity_js_1.liquidityCommand)(opts));
 });
+// ── sf telegram ──────────────────────────────────────────────────────────────
+program
+    .command('telegram')
+    .description('Start Telegram bot for monitoring and trading')
+    .option('--token <token>', 'Telegram bot token (or set TELEGRAM_BOT_TOKEN)')
+    .option('--chat-id <id>', 'Restrict to specific chat ID')
+    .option('--daemon', 'Run in background')
+    .option('--stop', 'Stop background bot')
+    .option('--status', 'Check if bot is running')
+    .action(async (opts) => {
+    await run(() => (0, telegram_js_1.telegramCommand)(opts));
+});
 // ── sf strategies ─────────────────────────────────────────────────────────────
 (0, strategies_js_1.registerStrategies)(program);
 // ── Error wrapper ─────────────────────────────────────────────────────────────

package/dist/telegram/agent-bridge.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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).
+ */
+import { SFClient } from '../client.js';
+interface SessionState {
+    thesisId: string | null;
+    agentMessages: any[];
+    agent?: any;
+}
+export declare function getOrCreateAgent(sfClient: SFClient, session: SessionState): Promise<any>;
+export declare function runAgentMessage(client: SFClient, session: SessionState, userMessage: string): Promise<string>;
+export {};