@blockrun/franklin 3.0.0

package/dist/ui/model-picker.js

@@ -0,0 +1,161 @@
+/**
+ * Interactive model picker for runcode.
+ * Shows categorized model list, supports shortcuts and arrow-key selection.
+ */
+import readline from 'node:readline';
+import chalk from 'chalk';
+// ─── Model Shortcuts (same as proxy) ───────────────────────────────────────
+export const MODEL_SHORTCUTS = {
+    // Routing profiles
+    auto: 'blockrun/auto',
+    smart: 'blockrun/auto',
+    eco: 'blockrun/eco',
+    premium: 'blockrun/premium',
+    // Anthropic
+    sonnet: 'anthropic/claude-sonnet-4.6',
+    claude: 'anthropic/claude-sonnet-4.6',
+    opus: 'anthropic/claude-opus-4.6',
+    haiku: 'anthropic/claude-haiku-4.5-20251001',
+    // OpenAI
+    gpt: 'openai/gpt-5.4',
+    gpt5: 'openai/gpt-5.4',
+    'gpt-5': 'openai/gpt-5.4',
+    'gpt-5.4': 'openai/gpt-5.4',
+    'gpt-5.4-pro': 'openai/gpt-5.4-pro',
+    'gpt-5.3': 'openai/gpt-5.3',
+    'gpt-5.2': 'openai/gpt-5.2',
+    'gpt-5.2-pro': 'openai/gpt-5.2-pro',
+    'gpt-4.1': 'openai/gpt-4.1',
+    codex: 'openai/gpt-5.3-codex',
+    nano: 'openai/gpt-5-nano',
+    mini: 'openai/gpt-5-mini',
+    o3: 'openai/o3',
+    o4: 'openai/o4-mini',
+    'o4-mini': 'openai/o4-mini',
+    o1: 'openai/o1',
+    // Google
+    gemini: 'google/gemini-2.5-pro',
+    flash: 'google/gemini-2.5-flash',
+    'gemini-3': 'google/gemini-3.1-pro',
+    // xAI
+    grok: 'xai/grok-3',
+    'grok-4': 'xai/grok-4-0709',
+    'grok-fast': 'xai/grok-4-1-fast-reasoning',
+    // DeepSeek
+    deepseek: 'deepseek/deepseek-chat',
+    r1: 'deepseek/deepseek-reasoner',
+    // Free
+    free: 'nvidia/nemotron-ultra-253b',
+    nemotron: 'nvidia/nemotron-ultra-253b',
+    'deepseek-free': 'nvidia/deepseek-v3.2',
+    devstral: 'nvidia/devstral-2-123b',
+    'qwen-coder': 'nvidia/qwen3-coder-480b',
+    maverick: 'nvidia/llama-4-maverick',
+    // Others
+    minimax: 'minimax/minimax-m2.7',
+    glm: 'zai/glm-5.1',
+    'glm-turbo': 'zai/glm-5.1-turbo',
+    'glm5': 'zai/glm-5.1',
+    kimi: 'moonshot/kimi-k2.5',
+};
+/**
+ * Resolve a model name — supports shortcuts.
+ */
+export function resolveModel(input) {
+    const lower = input.trim().toLowerCase();
+    return MODEL_SHORTCUTS[lower] || input.trim();
+}
+const PICKER_MODELS = [
+    {
+        category: 'Popular',
+        models: [
+            { id: 'anthropic/claude-sonnet-4.6', shortcut: 'sonnet', label: 'Claude Sonnet 4.6', price: '$3/$15' },
+            { id: 'anthropic/claude-opus-4.6', shortcut: 'opus', label: 'Claude Opus 4.6', price: '$5/$25' },
+            { id: 'openai/gpt-5.4', shortcut: 'gpt', label: 'GPT-5.4', price: '$2.5/$15' },
+            { id: 'google/gemini-2.5-pro', shortcut: 'gemini', label: 'Gemini 2.5 Pro', price: '$1.25/$10' },
+            { id: 'deepseek/deepseek-chat', shortcut: 'deepseek', label: 'DeepSeek V3', price: '$0.28/$0.42' },
+        ],
+    },
+    {
+        category: 'Budget',
+        models: [
+            { id: 'google/gemini-2.5-flash', shortcut: 'flash', label: 'Gemini 2.5 Flash', price: '$0.15/$0.6' },
+            { id: 'openai/gpt-5-mini', shortcut: 'mini', label: 'GPT-5 Mini', price: '$0.25/$2' },
+            { id: 'anthropic/claude-haiku-4.5-20251001', shortcut: 'haiku', label: 'Claude Haiku 4.5', price: '$1/$5' },
+            { id: 'openai/gpt-5-nano', shortcut: 'nano', label: 'GPT-5 Nano', price: '$0.05/$0.4' },
+        ],
+    },
+    {
+        category: 'Reasoning',
+        models: [
+            { id: 'deepseek/deepseek-reasoner', shortcut: 'r1', label: 'DeepSeek R1', price: '$0.28/$0.42' },
+            { id: 'openai/o4-mini', shortcut: 'o4', label: 'O4 Mini', price: '$1.1/$4.4' },
+            { id: 'openai/o3', shortcut: 'o3', label: 'O3', price: '$2/$8' },
+        ],
+    },
+    {
+        category: 'Free (no USDC needed)',
+        models: [
+            { id: 'nvidia/nemotron-ultra-253b', shortcut: 'free', label: 'Nemotron Ultra 253B', price: 'FREE' },
+            { id: 'nvidia/qwen3-coder-480b', shortcut: 'qwen-coder', label: 'Qwen3 Coder 480B', price: 'FREE' },
+            { id: 'nvidia/devstral-2-123b', shortcut: 'devstral', label: 'Devstral 2 123B', price: 'FREE' },
+            { id: 'nvidia/llama-4-maverick', shortcut: 'maverick', label: 'Llama 4 Maverick', price: 'FREE' },
+        ],
+    },
+];
+/**
+ * Show interactive model picker. Returns the selected model ID.
+ * Falls back to text input if terminal doesn't support raw mode.
+ */
+export async function pickModel(currentModel) {
+    // Flatten for numbering
+    const allModels = [];
+    for (const cat of PICKER_MODELS) {
+        allModels.push(...cat.models);
+    }
+    // Display
+    console.error('');
+    console.error(chalk.bold('  Select a model:\n'));
+    let idx = 1;
+    for (const cat of PICKER_MODELS) {
+        console.error(chalk.dim(`  ── ${cat.category} ──`));
+        for (const m of cat.models) {
+            const current = m.id === currentModel ? chalk.green(' ←') : '';
+            const priceStr = m.price === 'FREE' ? chalk.green(m.price) : chalk.dim(m.price);
+            console.error(`  ${chalk.cyan(String(idx).padStart(2))}. ${m.label.padEnd(24)} ${chalk.dim(m.shortcut.padEnd(12))} ${priceStr}${current}`);
+            idx++;
+        }
+        console.error('');
+    }
+    console.error(chalk.dim('  Enter number, shortcut, or full model ID:'));
+    // Read input
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: process.stdin.isTTY ?? false,
+    });
+    return new Promise((resolve) => {
+        let answered = false;
+        rl.question(chalk.bold('  model> '), (answer) => {
+            answered = true;
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(null); // Keep current
+                return;
+            }
+            // Try number
+            const num = parseInt(trimmed, 10);
+            if (!isNaN(num) && num >= 1 && num <= allModels.length) {
+                resolve(allModels[num - 1].id);
+                return;
+            }
+            // Try shortcut or full ID
+            resolve(resolveModel(trimmed));
+        });
+        rl.on('close', () => {
+            if (!answered)
+                resolve(null);
+        });
+    });
+}

package/dist/ui/terminal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Terminal UI for runcode
+ * Raw terminal input/output with markdown rendering and diff display.
+ * No heavy dependencies — just chalk and readline.
+ */
+import type { StreamEvent } from '../agent/types.js';
+export declare class TerminalUI {
+    private spinner;
+    private activeCapabilities;
+    private totalInputTokens;
+    private totalOutputTokens;
+    private sessionModel;
+    private mdRenderer;
+    private lineQueue;
+    private lineWaiters;
+    private stdinEOF;
+    constructor();
+    /**
+     * Prompt the user for input. Returns null on EOF/exit.
+     * Uses a line-queue approach so piped input works across multiple calls.
+     */
+    promptUser(promptText?: string): Promise<string | null>;
+    private nextLine;
+    /** No-op kept for API compatibility — readline closes when stdin EOF. */
+    closeInput(): void;
+    /**
+     * Handle a stream event from the agent loop.
+     */
+    handleEvent(event: StreamEvent): void;
+    /** Check if input is a slash command. Returns true if handled locally (don't pass to agent). */
+    handleSlashCommand(input: string): boolean;
+    printWelcome(model: string, workDir: string): void;
+    printUsageSummary(): void;
+    printGoodbye(): void;
+}

package/dist/ui/terminal.js

@@ -0,0 +1,337 @@
+/**
+ * Terminal UI for runcode
+ * Raw terminal input/output with markdown rendering and diff display.
+ * No heavy dependencies — just chalk and readline.
+ */
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { estimateCost } from '../pricing.js';
+// ─── Spinner ───────────────────────────────────────────────────────────────
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+class Spinner {
+    interval = null;
+    frameIdx = 0;
+    label = '';
+    start(label) {
+        this.stop();
+        this.label = label;
+        this.frameIdx = 0;
+        this.interval = setInterval(() => {
+            const frame = SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length];
+            process.stderr.write(`\r${chalk.cyan(frame)} ${chalk.dim(this.label)}  `);
+            this.frameIdx++;
+        }, 80);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+            process.stderr.write('\r' + ' '.repeat(this.label.length + 10) + '\r');
+        }
+    }
+}
+// ─── Markdown Renderer ─────────────────────────────────────────────────────
+/**
+ * Simple streaming markdown renderer.
+ * Buffers content and renders when complete blocks are available.
+ */
+class MarkdownRenderer {
+    buffer = '';
+    inCodeBlock = false;
+    codeBlockLang = '';
+    /**
+     * Feed text delta and return rendered ANSI output.
+     */
+    feed(text) {
+        this.buffer += text;
+        let output = '';
+        // Process complete lines
+        while (this.buffer.includes('\n')) {
+            const nlIdx = this.buffer.indexOf('\n');
+            const line = this.buffer.slice(0, nlIdx);
+            this.buffer = this.buffer.slice(nlIdx + 1);
+            output += this.renderLine(line) + '\n';
+        }
+        return output;
+    }
+    /**
+     * Flush remaining buffer.
+     */
+    flush() {
+        if (this.buffer.length === 0)
+            return '';
+        const result = this.renderLine(this.buffer);
+        this.buffer = '';
+        return result;
+    }
+    renderLine(line) {
+        // Code block toggle
+        if (line.startsWith('```')) {
+            if (this.inCodeBlock) {
+                this.inCodeBlock = false;
+                this.codeBlockLang = '';
+                return chalk.dim('```');
+            }
+            else {
+                this.inCodeBlock = true;
+                this.codeBlockLang = line.slice(3).trim();
+                return chalk.dim('```' + this.codeBlockLang);
+            }
+        }
+        // Inside code block — render dim
+        if (this.inCodeBlock) {
+            return chalk.cyan(line);
+        }
+        // Headers
+        if (line.startsWith('### '))
+            return chalk.bold(line.slice(4));
+        if (line.startsWith('## '))
+            return chalk.bold.underline(line.slice(3));
+        if (line.startsWith('# '))
+            return chalk.bold.underline(line.slice(2));
+        // Horizontal rule
+        if (/^[-=]{3,}$/.test(line.trim()))
+            return chalk.dim('─'.repeat(40));
+        // Bullet points
+        if (line.match(/^(\s*)[-*] /)) {
+            return line.replace(/^(\s*)[-*] /, '$1• ');
+        }
+        // Numbered lists
+        if (/^\s*\d+\.\s/.test(line)) {
+            return this.renderInline(line);
+        }
+        // Blockquotes
+        if (line.startsWith('> ')) {
+            return chalk.dim('│ ') + chalk.italic(this.renderInline(line.slice(2)));
+        }
+        // Tables — leave as-is (chalk doesn't help much)
+        // Inline formatting
+        return this.renderInline(line);
+    }
+    renderInline(text) {
+        // Process in order: code first (to protect from other formatting), then bold, italic, links
+        return text
+            // Inline code (process first to protect contents)
+            .replace(/`([^`]+)`/g, (_, t) => `\x00CODE${chalk.cyan(t)}\x00END`)
+            // Bold (before italic to avoid ** being consumed by *)
+            .replace(/\*\*([^*]+)\*\*/g, (_, t) => chalk.bold(t))
+            // Italic (only single * not preceded/followed by *)
+            .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, t) => chalk.italic(t))
+            // Strikethrough
+            .replace(/~~([^~]+)~~/g, (_, t) => chalk.strikethrough(t))
+            // Links
+            .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => chalk.blue.underline(label) + chalk.dim(` (${url})`))
+            // Restore code markers
+            .replace(/\x00CODE/g, '').replace(/\x00END/g, '');
+    }
+}
+// ─── Terminal UI ───────────────────────────────────────────────────────────
+export class TerminalUI {
+    spinner = new Spinner();
+    activeCapabilities = new Map();
+    totalInputTokens = 0;
+    totalOutputTokens = 0;
+    sessionModel = '';
+    mdRenderer = new MarkdownRenderer();
+    // Line queue for piped (non-TTY) input — buffers all stdin lines eagerly
+    lineQueue = [];
+    lineWaiters = [];
+    stdinEOF = false;
+    constructor() {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stderr,
+            terminal: false, // Always treat as non-TTY so line events fire for piped input
+        });
+        rl.on('line', (line) => {
+            if (this.lineWaiters.length > 0) {
+                // Someone is already waiting — deliver immediately
+                const waiter = this.lineWaiters.shift();
+                waiter(line);
+            }
+            else {
+                // Buffer the line for the next promptUser() call
+                this.lineQueue.push(line);
+            }
+        });
+        rl.on('close', () => {
+            this.stdinEOF = true;
+            // Keep lineQueue intact — buffered lines should still drain before signaling EOF.
+            // If there are active waiters, queue is already empty (nextLine checks queue first),
+            // so it's safe to resolve them with null now.
+            for (const waiter of this.lineWaiters)
+                waiter(null);
+            this.lineWaiters = [];
+        });
+    }
+    /**
+     * Prompt the user for input. Returns null on EOF/exit.
+     * Uses a line-queue approach so piped input works across multiple calls.
+     */
+    async promptUser(promptText) {
+        const prompt = promptText ?? chalk.bold.green('> ');
+        process.stderr.write(prompt);
+        const raw = await this.nextLine();
+        if (raw === null)
+            return null;
+        const trimmed = raw.trim();
+        if (trimmed === '/exit' || trimmed === '/quit')
+            return null;
+        return trimmed;
+    }
+    nextLine() {
+        if (this.lineQueue.length > 0) {
+            return Promise.resolve(this.lineQueue.shift());
+        }
+        if (this.stdinEOF) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve) => {
+            this.lineWaiters.push(resolve);
+        });
+    }
+    /** No-op kept for API compatibility — readline closes when stdin EOF. */
+    closeInput() {
+        // Nothing to do — readline closes itself on stdin EOF
+    }
+    /**
+     * Handle a stream event from the agent loop.
+     */
+    handleEvent(event) {
+        switch (event.kind) {
+            case 'text_delta': {
+                this.spinner.stop();
+                // Render markdown
+                const rendered = this.mdRenderer.feed(event.text);
+                if (rendered)
+                    process.stdout.write(rendered);
+                break;
+            }
+            case 'thinking_delta':
+                this.spinner.stop();
+                process.stderr.write(chalk.dim(event.text));
+                break;
+            case 'capability_start': {
+                // Flush any pending markdown text before showing tool status
+                this.spinner.stop();
+                const flushed = this.mdRenderer.flush();
+                if (flushed)
+                    process.stdout.write(flushed + '\n');
+                this.activeCapabilities.set(event.id, {
+                    name: event.name,
+                    startTime: Date.now(),
+                });
+                this.spinner.start(`${event.name}...`);
+                break;
+            }
+            case 'capability_input_delta':
+                break;
+            case 'capability_done': {
+                this.spinner.stop();
+                const cap = this.activeCapabilities.get(event.id);
+                const capName = cap?.name || 'unknown';
+                const elapsed = cap ? Date.now() - cap.startTime : 0;
+                this.activeCapabilities.delete(event.id);
+                const timeStr = elapsed > 100 ? chalk.dim(` ${elapsed}ms`) : '';
+                if (event.result.isError) {
+                    console.error(chalk.red(`  ✗ ${capName}`) +
+                        timeStr +
+                        chalk.red(`: ${truncateOutput(event.result.output, 200)}`));
+                }
+                else {
+                    // Show diff-like output for Edit tool
+                    const output = event.result.output;
+                    if (capName === 'Edit' && output.includes('replacement')) {
+                        console.error(chalk.green(`  ✓ ${capName}`) + timeStr + chalk.dim(` — ${output}`));
+                    }
+                    else if (capName === 'Write') {
+                        console.error(chalk.green(`  ✓ ${capName}`) + timeStr + chalk.dim(` — ${output}`));
+                    }
+                    else if (capName === 'Bash') {
+                        // Show command output preview
+                        const preview = truncateOutput(output, 120);
+                        console.error(chalk.green(`  ✓ ${capName}`) + timeStr);
+                        if (preview && preview !== '(no output)') {
+                            const lines = output.split('\n').slice(0, 5);
+                            for (const line of lines) {
+                                console.error(chalk.dim(`    │ ${line.slice(0, 100)}`));
+                            }
+                            if (output.split('\n').length > 5) {
+                                console.error(chalk.dim(`    │ ... (${output.split('\n').length - 5} more lines)`));
+                            }
+                        }
+                    }
+                    else {
+                        const preview = truncateOutput(output, 120);
+                        console.error(chalk.green(`  ✓ ${capName}`) + timeStr + chalk.dim(` — ${preview}`));
+                    }
+                }
+                break;
+            }
+            case 'usage':
+                this.totalInputTokens += event.inputTokens;
+                this.totalOutputTokens += event.outputTokens;
+                if (event.model)
+                    this.sessionModel = event.model;
+                break;
+            case 'turn_done': {
+                this.spinner.stop();
+                // Flush any remaining markdown
+                const remaining = this.mdRenderer.flush();
+                if (remaining)
+                    process.stdout.write(remaining);
+                process.stdout.write('\n');
+                if (event.reason === 'error') {
+                    console.error(chalk.red(`\nAgent error: ${event.error}`));
+                }
+                else if (event.reason === 'max_turns') {
+                    console.error(chalk.yellow('\nMax turns reached.'));
+                }
+                // Reset renderer for next turn
+                this.mdRenderer = new MarkdownRenderer();
+                break;
+            }
+        }
+    }
+    /** Check if input is a slash command. Returns true if handled locally (don't pass to agent). */
+    handleSlashCommand(input) {
+        const parts = input.trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        switch (cmd) {
+            case '/cost':
+            case '/usage': {
+                const cost = this.sessionModel
+                    ? estimateCost(this.sessionModel, this.totalInputTokens, this.totalOutputTokens)
+                    : 0;
+                const costStr = cost > 0 ? `  ·  $${cost.toFixed(4)} USDC` : '';
+                console.error(chalk.dim(`\n  Tokens: ${this.totalInputTokens.toLocaleString()} in / ${this.totalOutputTokens.toLocaleString()} out${costStr}\n`));
+                return true;
+            }
+            default:
+                // All other slash commands pass through to the agent loop (commands.ts handles them)
+                return false;
+        }
+    }
+    printWelcome(model, workDir) {
+        console.error(chalk.dim(`Model: ${model}`));
+        console.error(chalk.dim(`Dir:   ${workDir}`));
+        console.error(chalk.dim(`Type /exit to quit, /help for commands.\n`));
+    }
+    printUsageSummary() {
+        if (this.totalInputTokens > 0 || this.totalOutputTokens > 0) {
+            console.error(chalk.dim(`\nTokens: ${this.totalInputTokens.toLocaleString()} in / ${this.totalOutputTokens.toLocaleString()} out`));
+        }
+    }
+    printGoodbye() {
+        this.closeInput();
+        this.printUsageSummary();
+        console.error(chalk.dim('\nGoodbye.\n'));
+    }
+}
+// ─── Helpers ───────────────────────────────────────────────────────────────
+function truncateOutput(text, maxLen) {
+    const oneLine = text.replace(/\n/g, ' ').trim();
+    if (oneLine.length <= maxLen)
+        return oneLine;
+    return oneLine.slice(0, maxLen - 3) + '...';
+}

package/dist/wallet/manager.d.ts

@@ -0,0 +1,10 @@
+export declare function walletExists(): boolean;
+export declare function setupWallet(): {
+    address: string;
+    isNew: boolean;
+};
+export declare function setupSolanaWallet(): Promise<{
+    address: string;
+    isNew: boolean;
+}>;
+export declare function getAddress(): string;

package/dist/wallet/manager.js

@@ -0,0 +1,23 @@
+import { getOrCreateWallet, scanWallets, getWalletAddress, getOrCreateSolanaWallet, scanSolanaWallets, } from '@blockrun/llm';
+import { loadChain } from '../config.js';
+export function walletExists() {
+    const chain = loadChain();
+    if (chain === 'solana') {
+        return scanSolanaWallets().length > 0;
+    }
+    return scanWallets().length > 0;
+}
+export function setupWallet() {
+    const { address, isNew } = getOrCreateWallet();
+    return { address, isNew };
+}
+export async function setupSolanaWallet() {
+    const { address, isNew } = await getOrCreateSolanaWallet();
+    return { address, isNew };
+}
+export function getAddress() {
+    const addr = getWalletAddress();
+    if (!addr)
+        throw new Error('No wallet found. Run `runcode setup` first.');
+    return addr;
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@blockrun/franklin",
+  "version": "3.0.0",
+  "description": "Franklin — The AI agent with a wallet. Marketing at franklin.run, trading at franklin.bet. Pay per action in USDC.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./plugin-sdk": {
+      "types": "./dist/plugin-sdk/index.d.ts",
+      "default": "./dist/plugin-sdk/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "franklin": "./dist/index.js",
+    "runcode": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/copy-plugin-assets.mjs",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "npm run build && node --test --test-reporter=spec test/local.mjs",
+    "test:e2e": "npm run build && node --test --test-reporter=spec test/e2e.mjs",
+    "test:all": "npm run test && npm run test:e2e",
+    "test:watch": "node --test --watch test/local.mjs",
+    "test:e2e:watch": "node --test --watch test/e2e.mjs"
+  },
+  "keywords": [
+    "franklin",
+    "autonomous-economic-agent",
+    "ai-agent",
+    "wallet-native",
+    "agent-with-wallet",
+    "x402",
+    "usdc",
+    "pay-per-action",
+    "multi-model",
+    "ai-marketing",
+    "ai-trading",
+    "crypto-native",
+    "blockrun",
+    "runcode"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlockRunAI/runcode"
+  },
+  "homepage": "https://franklin.run",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@blockrun/llm": "^1.4.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "@types/react": "^19.2.14",
+    "bs58": "^6.0.0",
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "ink": "^6.8.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}