@blockrun/runcode 1.8.0 → 2.0.0

package/dist/agent/loop.js

@@ -5,7 +5,7 @@
  */
 import { ModelClient } from './llm.js';
 import { autoCompactIfNeeded, forceCompact, microCompact } from './compact.js';
-import { estimateHistoryTokens } from './tokens.js';
+import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
 import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS } from './optimize.js';
@@ -287,6 +287,26 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             onEvent({ kind: 'turn_done', reason: 'completed' });
             continue;
         }
+        // Handle /mcp — show connected MCP servers
+        if (input === '/mcp') {
+            const { listMcpServers } = await import('../mcp/client.js');
+            const servers = listMcpServers();
+            if (servers.length === 0) {
+                onEvent({ kind: 'text_delta', text: 'No MCP servers connected.\nAdd servers to `~/.blockrun/mcp.json` or `.mcp.json` in your project.\n' });
+            }
+            else {
+                let text = `**${servers.length} MCP server(s) connected:**\n\n`;
+                for (const s of servers) {
+                    text += `  **${s.name}** — ${s.toolCount} tools\n`;
+                    for (const t of s.tools) {
+                        text += `    · ${t}\n`;
+                    }
+                }
+                onEvent({ kind: 'text_delta', text });
+            }
+            onEvent({ kind: 'turn_done', reason: 'completed' });
+            continue;
+        }
         // Handle /bug — open issue tracker
         if (input === '/bug') {
             onEvent({ kind: 'text_delta', text: 'Report issues at: https://github.com/BlockRunAI/runcode/issues\n' });
@@ -480,7 +500,10 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         }
         // Handle /context — show current session context info
         if (input === '/context') {
-            const tokens = estimateHistoryTokens(history);
+            const { getAnchoredTokenCount, getContextWindow } = await import('./tokens.js');
+            const { estimated, apiAnchored } = getAnchoredTokenCount(history);
+            const contextWindow = getContextWindow(config.model);
+            const usagePct = ((estimated / contextWindow) * 100).toFixed(1);
             const msgs = history.length;
             const model = config.model;
             const dir = config.workingDir || process.cwd();
@@ -489,7 +512,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     `  Model:      ${model}\n` +
                     `  Mode:       ${mode}\n` +
                     `  Messages:   ${msgs}\n` +
-                    `  Tokens:     ~${tokens.toLocaleString()}\n` +
+                    `  Tokens:     ~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k (${usagePct}%)${apiAnchored ? ' ✓' : ' ~'}\n` +
                     `  Session:    ${sessionId}\n` +
                     `  Directory:  ${dir}\n`
             });
@@ -605,6 +628,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             if (didCompact) {
                 history.length = 0;
                 history.push(...compacted);
+                resetTokenAnchor(); // Reset anchor after compaction — estimates will be used
                 if (config.debug) {
                     console.error(`[runcode] History compacted: ~${estimateHistoryTokens(history)} tokens`);
                 }
@@ -696,6 +720,8 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 onEvent({ kind: 'turn_done', reason: 'error', error: errMsg + suggestion });
                 break;
             }
+            // Anchor token tracking to actual API counts
+            updateActualTokens(usage.inputTokens, usage.outputTokens, history.length);
             onEvent({
                 kind: 'usage',
                 inputTokens: usage.inputTokens,

package/dist/agent/tokens.d.ts

@@ -1,8 +1,27 @@
 /**
  * Token estimation for runcode.
  * Uses byte-based heuristic (no external tokenizer dependency).
+ * Anchors to actual API counts when available, estimates on top for new messages.
  */
 import type { Dialogue } from './types.js';
+/**
+ * Update with actual token counts from API response.
+ * This anchors our estimates to reality.
+ */
+export declare function updateActualTokens(inputTokens: number, outputTokens: number, messageCount: number): void;
+/**
+ * Get token count using API anchor + estimation for new messages.
+ * More accurate than pure estimation because it's grounded in actual API counts.
+ */
+export declare function getAnchoredTokenCount(history: Dialogue[]): {
+    estimated: number;
+    apiAnchored: boolean;
+    contextUsagePct: number;
+};
+/**
+ * Reset anchor (e.g., after compaction).
+ */
+export declare function resetTokenAnchor(): void;
 /**
  * Estimate token count for a string using byte-length heuristic.
  * JSON-heavy content uses 2 bytes/token; general text uses 4.

package/dist/agent/tokens.js

@@ -1,8 +1,57 @@
 /**
  * Token estimation for runcode.
  * Uses byte-based heuristic (no external tokenizer dependency).
+ * Anchors to actual API counts when available, estimates on top for new messages.
  */
 const DEFAULT_BYTES_PER_TOKEN = 4;
+// ─── API-anchored token tracking ───────────────────────���──────────────────
+/** Last known actual token count from API response */
+let lastApiInputTokens = 0;
+let lastApiOutputTokens = 0;
+let lastApiMessageCount = 0;
+/**
+ * Update with actual token counts from API response.
+ * This anchors our estimates to reality.
+ */
+export function updateActualTokens(inputTokens, outputTokens, messageCount) {
+    lastApiInputTokens = inputTokens;
+    lastApiOutputTokens = outputTokens;
+    lastApiMessageCount = messageCount;
+}
+/**
+ * Get token count using API anchor + estimation for new messages.
+ * More accurate than pure estimation because it's grounded in actual API counts.
+ */
+export function getAnchoredTokenCount(history) {
+    if (lastApiInputTokens > 0 && history.length >= lastApiMessageCount) {
+        // Anchor to API count, estimate only new messages
+        const newMessages = history.slice(lastApiMessageCount);
+        let newTokens = 0;
+        for (const msg of newMessages) {
+            newTokens += estimateDialogueTokens(msg);
+        }
+        const total = lastApiInputTokens + newTokens;
+        return {
+            estimated: total,
+            apiAnchored: true,
+            contextUsagePct: 0, // Will be calculated by caller with model context window
+        };
+    }
+    // No anchor — pure estimation
+    return {
+        estimated: estimateHistoryTokens(history),
+        apiAnchored: false,
+        contextUsagePct: 0,
+    };
+}
+/**
+ * Reset anchor (e.g., after compaction).
+ */
+export function resetTokenAnchor() {
+    lastApiInputTokens = 0;
+    lastApiOutputTokens = 0;
+    lastApiMessageCount = 0;
+}
 /**
  * Estimate token count for a string using byte-length heuristic.
  * JSON-heavy content uses 2 bytes/token; general text uses 4.

package/dist/commands/start.js

@@ -9,6 +9,8 @@ import { interactiveSession } from '../agent/loop.js';
 import { allCapabilities, createSubAgentCapability } from '../tools/index.js';
 import { launchInkUI } from '../ui/app.js';
 import { pickModel, resolveModel } from '../ui/model-picker.js';
+import { loadMcpConfig } from '../mcp/config.js';
+import { connectMcpServers, disconnectMcpServers } from '../mcp/client.js';
 export async function startCommand(options) {
     const version = options.version ?? '1.0.0';
     const chain = loadChain();
@@ -92,9 +94,26 @@ export async function startCommand(options) {
     })();
     // Assemble system instructions
     const systemInstructions = assembleInstructions(workDir);
-    // Build capabilities
+    // Connect MCP servers (non-blocking — add tools if servers are available)
+    const mcpConfig = loadMcpConfig(workDir);
+    let mcpTools = [];
+    const mcpServerCount = Object.keys(mcpConfig.mcpServers).filter(k => !mcpConfig.mcpServers[k].disabled).length;
+    if (mcpServerCount > 0) {
+        try {
+            mcpTools = await connectMcpServers(mcpConfig, options.debug);
+            if (mcpTools.length > 0) {
+                console.log(chalk.dim(`  MCP:    ${mcpTools.length} tools from ${mcpServerCount} server(s)`));
+            }
+        }
+        catch (err) {
+            if (options.debug) {
+                console.error(chalk.yellow(`  MCP error: ${err.message}`));
+            }
+        }
+    }
+    // Build capabilities (built-in + MCP + sub-agent)
     const subAgent = createSubAgentCapability(apiUrl, chain, allCapabilities);
-    const capabilities = [...allCapabilities, subAgent];
+    const capabilities = [...allCapabilities, ...mcpTools, subAgent];
     // Agent config
     const agentConfig = {
         model,
@@ -149,6 +168,7 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     }
     ui.cleanup();
     flushStats();
+    await disconnectMcpServers();
     console.log(chalk.dim('\nGoodbye.\n'));
     process.exit(0);
 }

package/dist/mcp/client.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MCP Client for runcode.
+ * Connects to MCP servers, discovers tools, and wraps them as CapabilityHandlers.
+ * Supports stdio and HTTP (SSE) transports.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export interface McpServerConfig {
+    /** Transport type */
+    transport: 'stdio' | 'http';
+    /** For stdio: command to run */
+    command?: string;
+    /** For stdio: arguments */
+    args?: string[];
+    /** For stdio: environment variables */
+    env?: Record<string, string>;
+    /** For http: server URL */
+    url?: string;
+    /** For http: headers */
+    headers?: Record<string, string>;
+    /** Human-readable label */
+    label?: string;
+    /** Disable this server */
+    disabled?: boolean;
+}
+export interface McpConfig {
+    mcpServers: Record<string, McpServerConfig>;
+}
+/**
+ * Connect to all configured MCP servers and return discovered tools.
+ */
+export declare function connectMcpServers(config: McpConfig, debug?: boolean): Promise<CapabilityHandler[]>;
+/**
+ * Disconnect all MCP servers.
+ */
+export declare function disconnectMcpServers(): Promise<void>;
+/**
+ * List connected MCP servers and their tools.
+ */
+export declare function listMcpServers(): Array<{
+    name: string;
+    toolCount: number;
+    tools: string[];
+}>;

package/dist/mcp/client.js

@@ -0,0 +1,132 @@
+/**
+ * MCP Client for runcode.
+ * Connects to MCP servers, discovers tools, and wraps them as CapabilityHandlers.
+ * Supports stdio and HTTP (SSE) transports.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+// ─── Connection Management ────────────────────────────────────────────────
+const connections = new Map();
+/**
+ * Connect to an MCP server via stdio transport.
+ * Discovers tools and returns them as CapabilityHandlers.
+ */
+async function connectStdio(name, config) {
+    if (!config.command) {
+        throw new Error(`MCP server "${name}" missing command`);
+    }
+    const transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args || [],
+        env: { ...process.env, ...(config.env || {}) },
+    });
+    const client = new Client({ name: `runcode-mcp-${name}`, version: '1.0.0' }, { capabilities: {} });
+    await client.connect(transport);
+    // Discover tools
+    const { tools: mcpTools } = await client.listTools();
+    const capabilities = [];
+    for (const tool of mcpTools) {
+        const toolName = `mcp__${name}__${tool.name}`;
+        const toolDescription = (tool.description || '').slice(0, 2048);
+        capabilities.push({
+            spec: {
+                name: toolName,
+                description: toolDescription || `MCP tool from ${name}`,
+                input_schema: tool.inputSchema || {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            execute: async (input, _ctx) => {
+                try {
+                    const result = await client.callTool({
+                        name: tool.name,
+                        arguments: input,
+                    });
+                    // Extract text content from MCP response
+                    const output = result.content
+                        ?.filter(c => c.type === 'text')
+                        ?.map(c => c.text)
+                        ?.join('\n') || JSON.stringify(result.content);
+                    return {
+                        output,
+                        isError: result.isError === true,
+                    };
+                }
+                catch (err) {
+                    return {
+                        output: `MCP tool error (${name}/${tool.name}): ${err.message}`,
+                        isError: true,
+                    };
+                }
+            },
+            concurrent: true, // MCP tools are safe to run concurrently
+        });
+    }
+    const connected = { name, client, transport, tools: capabilities };
+    connections.set(name, connected);
+    return connected;
+}
+/**
+ * Connect to all configured MCP servers and return discovered tools.
+ */
+export async function connectMcpServers(config, debug) {
+    const allTools = [];
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        if (serverConfig.disabled)
+            continue;
+        try {
+            if (debug) {
+                console.error(`[runcode] Connecting to MCP server: ${name}...`);
+            }
+            let connected;
+            if (serverConfig.transport === 'stdio') {
+                connected = await connectStdio(name, serverConfig);
+            }
+            else {
+                // HTTP transport — TODO: implement SSE/HTTP transport
+                if (debug) {
+                    console.error(`[runcode] MCP HTTP transport not yet supported for ${name}`);
+                }
+                continue;
+            }
+            allTools.push(...connected.tools);
+            if (debug) {
+                console.error(`[runcode] MCP ${name}: ${connected.tools.length} tools discovered`);
+            }
+        }
+        catch (err) {
+            // Graceful degradation — log and continue without this server
+            console.error(`[runcode] MCP ${name} failed: ${err.message}`);
+        }
+    }
+    return allTools;
+}
+/**
+ * Disconnect all MCP servers.
+ */
+export async function disconnectMcpServers() {
+    for (const [name, conn] of connections) {
+        try {
+            await conn.client.close();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        connections.delete(name);
+    }
+}
+/**
+ * List connected MCP servers and their tools.
+ */
+export function listMcpServers() {
+    const result = [];
+    for (const [name, conn] of connections) {
+        result.push({
+            name,
+            toolCount: conn.tools.length,
+            tools: conn.tools.map(t => t.spec.name),
+        });
+    }
+    return result;
+}

package/dist/mcp/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MCP configuration management for runcode.
+ * Loads MCP server configs from:
+ * 1. Global: ~/.blockrun/mcp.json
+ * 2. Project: .mcp.json in working directory
+ */
+import type { McpConfig, McpServerConfig } from './client.js';
+/**
+ * Load MCP server configurations from global + project files.
+ * Project config overrides global for same server name.
+ */
+export declare function loadMcpConfig(workDir: string): McpConfig;
+/**
+ * Save a server config to the global MCP config.
+ */
+export declare function saveMcpServer(name: string, config: McpServerConfig): void;
+/**
+ * Remove a server from the global MCP config.
+ */
+export declare function removeMcpServer(name: string): boolean;

package/dist/mcp/config.js

@@ -0,0 +1,74 @@
+/**
+ * MCP configuration management for runcode.
+ * Loads MCP server configs from:
+ * 1. Global: ~/.blockrun/mcp.json
+ * 2. Project: .mcp.json in working directory
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { BLOCKRUN_DIR } from '../config.js';
+const GLOBAL_MCP_FILE = path.join(BLOCKRUN_DIR, 'mcp.json');
+/**
+ * Load MCP server configurations from global + project files.
+ * Project config overrides global for same server name.
+ */
+export function loadMcpConfig(workDir) {
+    const servers = {};
+    // 1. Global config
+    try {
+        if (fs.existsSync(GLOBAL_MCP_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(GLOBAL_MCP_FILE, 'utf-8'));
+            if (raw.mcpServers && typeof raw.mcpServers === 'object') {
+                Object.assign(servers, raw.mcpServers);
+            }
+        }
+    }
+    catch {
+        // Ignore corrupt global config
+    }
+    // 2. Project config (.mcp.json in working directory)
+    const projectMcpFile = path.join(workDir, '.mcp.json');
+    try {
+        if (fs.existsSync(projectMcpFile)) {
+            const raw = JSON.parse(fs.readFileSync(projectMcpFile, 'utf-8'));
+            if (raw.mcpServers && typeof raw.mcpServers === 'object') {
+                // Project overrides global for same name
+                Object.assign(servers, raw.mcpServers);
+            }
+        }
+    }
+    catch {
+        // Ignore corrupt project config
+    }
+    return { mcpServers: servers };
+}
+/**
+ * Save a server config to the global MCP config.
+ */
+export function saveMcpServer(name, config) {
+    const existing = loadGlobalMcpConfig();
+    existing.mcpServers[name] = config;
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+    fs.writeFileSync(GLOBAL_MCP_FILE, JSON.stringify(existing, null, 2) + '\n');
+}
+/**
+ * Remove a server from the global MCP config.
+ */
+export function removeMcpServer(name) {
+    const existing = loadGlobalMcpConfig();
+    if (!(name in existing.mcpServers))
+        return false;
+    delete existing.mcpServers[name];
+    fs.writeFileSync(GLOBAL_MCP_FILE, JSON.stringify(existing, null, 2) + '\n');
+    return true;
+}
+function loadGlobalMcpConfig() {
+    try {
+        if (fs.existsSync(GLOBAL_MCP_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(GLOBAL_MCP_FILE, 'utf-8'));
+            return { mcpServers: raw.mcpServers || {} };
+        }
+    }
+    catch { /* fresh */ }
+    return { mcpServers: {} };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {
@@ -43,6 +43,7 @@
   },
   "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",