@blockrun/runcode 2.2.7 → 2.4.0

package/dist/agent/commands.js

@@ -71,6 +71,42 @@ const DIRECT_COMMANDS = {
             ctx.onEvent({ kind: 'text_delta', text: 'Last commit undone. Changes preserved in staging.\n' });
         emitDone(ctx);
     },
+    '/tokens': (ctx) => {
+        const { estimated, apiAnchored } = getAnchoredTokenCount(ctx.history);
+        const contextWindow = getContextWindow(ctx.config.model);
+        const pct = (estimated / contextWindow) * 100;
+        // Count tool results and thinking blocks
+        let toolResults = 0;
+        let thinkingBlocks = 0;
+        let totalToolChars = 0;
+        for (const msg of ctx.history) {
+            if (typeof msg.content === 'string')
+                continue;
+            if (!Array.isArray(msg.content))
+                continue;
+            for (const part of msg.content) {
+                if ('type' in part) {
+                    if (part.type === 'tool_result') {
+                        toolResults++;
+                        const c = typeof part.content === 'string' ? part.content : JSON.stringify(part.content);
+                        totalToolChars += c.length;
+                    }
+                    if (part.type === 'thinking')
+                        thinkingBlocks++;
+                }
+            }
+        }
+        ctx.onEvent({ kind: 'text_delta', text: `**Token Usage**\n` +
+                `  Estimated:  ~${estimated.toLocaleString()} tokens ${apiAnchored ? '(API-anchored)' : '(estimated)'}\n` +
+                `  Context:    ${(contextWindow / 1000).toFixed(0)}k window (${pct.toFixed(1)}% used)\n` +
+                `  Messages:   ${ctx.history.length}\n` +
+                `  Tool results: ${toolResults} (${(totalToolChars / 1024).toFixed(0)}KB)\n` +
+                `  Thinking:   ${thinkingBlocks} blocks\n` +
+                (pct > 80 ? '  ⚠ Near limit — run /compact\n' : '') +
+                (pct > 60 ? '' : '  ✓ Healthy\n')
+        });
+        emitDone(ctx);
+    },
     '/help': (ctx) => {
         ctx.onEvent({ kind: 'text_delta', text: `**RunCode Commands**\n\n` +
                 `  **Coding:** /commit /review /test /fix /debug /explain /search /find /refactor /scaffold\n` +

package/dist/agent/compact.js

@@ -204,15 +204,19 @@ function formatForSummarization(messages) {
  * Pick a cheaper/faster model for compaction to save cost.
  */
 function pickCompactionModel(primaryModel) {
-    // Use a fast model for summarization — no need for the expensive primary
-    if (primaryModel.includes('opus') || primaryModel.includes('gpt-5.4-pro')) {
+    // Use cheapest capable model for summarization to save cost
+    // Tier down: opus/pro → sonnet, sonnet → haiku, everything else → flash (cheapest capable)
+    if (primaryModel.includes('opus') || primaryModel.includes('pro')) {
         return 'anthropic/claude-sonnet-4.6';
     }
-    if (primaryModel.includes('sonnet')) {
+    if (primaryModel.includes('sonnet') || primaryModel.includes('gpt-5.4') || primaryModel.includes('gemini-2.5-pro')) {
         return 'anthropic/claude-haiku-4.5-20251001';
     }
-    // For cheaper models, just use the same one
-    return primaryModel;
+    if (primaryModel.includes('haiku') || primaryModel.includes('mini') || primaryModel.includes('nano')) {
+        return 'google/gemini-2.5-flash'; // Cheapest capable model
+    }
+    // Free/unknown models — use flash
+    return 'google/gemini-2.5-flash';
 }
 /**
  * Emergency fallback: drop oldest messages until under threshold.

package/dist/agent/loop.js

@@ -7,9 +7,10 @@ import { ModelClient } from './llm.js';
 import { autoCompactIfNeeded, microCompact } from './compact.js';
 import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
 import { handleSlashCommand } from './commands.js';
+import { compressHistory } from '../compression/adapter.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
-import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS } from './optimize.js';
+import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS, getMaxOutputTokens } from './optimize.js';
 import { recordUsage } from '../stats/tracker.js';
 import { estimateCost } from '../pricing.js';
 import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, } from '../session/storage.js';
@@ -237,13 +238,14 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         onAbortReady?.(() => abort.abort());
         let loopCount = 0;
         let recoveryAttempts = 0;
+        let compactFailures = 0;
         let maxTokensOverride;
         let lastActivity = Date.now();
         // Agent loop for this user message
         while (loopCount < maxTurns) {
             loopCount++;
             // ── Token optimization pipeline ──
-            // 1. Strip thinking, budget tool results, time-based cleanup
+            // 1. Strip thinking, budget tool results, time-based cleanup (always — cheap)
             const optimized = optimizeHistory(history, {
                 debug: config.debug,
                 lastActivityTimestamp: lastActivity,
@@ -252,24 +254,47 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 history.length = 0;
                 history.push(...optimized);
             }
-            // 2. Microcompact: clear old tool results to save tokens
-            const microCompacted = microCompact(history, 8);
-            if (microCompacted !== history) {
-                history.length = 0;
-                history.push(...microCompacted);
+            // 2. Microcompact: only when history has >15 messages (skip for short conversations)
+            if (history.length > 15) {
+                const microCompacted = microCompact(history, 8);
+                if (microCompacted !== history) {
+                    history.length = 0;
+                    history.push(...microCompacted);
+                }
             }
-            // Auto-compact: summarize history if approaching context limit
-            const { history: compacted, compacted: didCompact } = await autoCompactIfNeeded(history, config.model, client, config.debug);
-            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`);
+            // 3. Context compression: 7-layer compression for 15-40% token savings
+            if (history.length > 10) {
+                const compressed = await compressHistory(history, config.debug);
+                if (compressed) {
+                    history.length = 0;
+                    history.push(...compressed.history);
+                }
+            }
+            // 4. Auto-compact: summarize history if approaching context limit
+            // Circuit breaker: stop retrying after 3 consecutive failures
+            if (compactFailures < 3) {
+                try {
+                    const { history: compacted, compacted: didCompact } = await autoCompactIfNeeded(history, config.model, client, config.debug);
+                    if (didCompact) {
+                        history.length = 0;
+                        history.push(...compacted);
+                        resetTokenAnchor();
+                        compactFailures = 0;
+                        if (config.debug) {
+                            console.error(`[runcode] History compacted: ~${estimateHistoryTokens(history)} tokens`);
+                        }
+                    }
+                }
+                catch (compactErr) {
+                    compactFailures++;
+                    if (config.debug) {
+                        console.error(`[runcode] Compaction failed (${compactFailures}/3): ${compactErr.message}`);
+                    }
                 }
             }
             const systemPrompt = config.systemInstructions.join('\n\n');
-            let maxTokens = maxTokensOverride ?? CAPPED_MAX_TOKENS;
+            const modelMaxOut = getMaxOutputTokens(config.model);
+            let maxTokens = Math.min(maxTokensOverride ?? CAPPED_MAX_TOKENS, modelMaxOut);
             let responseParts = [];
             let usage;
             let stopReason;

package/dist/agent/optimize.d.ts

@@ -9,21 +9,18 @@
  * 5. Pre-compact stripping — remove images/docs before summarization
  */
 import type { Dialogue } from './types.js';
-/** Default max_tokens (low to save slot reservation) */
-export declare const CAPPED_MAX_TOKENS = 8192;
+/** Default max_tokens (low to save output slot reservation) */
+export declare const CAPPED_MAX_TOKENS = 16384;
 /** Escalated max_tokens after hitting the cap */
 export declare const ESCALATED_MAX_TOKENS = 65536;
+/** Get max output tokens for a model */
+export declare function getMaxOutputTokens(model: string): number;
 /**
  * Cap tool result sizes to prevent context bloat.
  * Large results (>50K chars) are truncated with a preview.
  * Per-message aggregate is also capped at 200K chars.
  */
 export declare function budgetToolResults(history: Dialogue[]): Dialogue[];
-/**
- * Remove thinking blocks from older assistant messages.
- * Keeps thinking only in the most recent assistant message.
- * Thinking blocks are large and not needed for context after the decision is made.
- */
 export declare function stripOldThinking(history: Dialogue[]): Dialogue[];
 /**
  * After an idle gap (>60 min), clear old tool results.

package/dist/agent/optimize.js

@@ -15,10 +15,25 @@ const MAX_TOOL_RESULT_CHARS = 50_000;
 const MAX_TOOL_RESULTS_PER_MESSAGE_CHARS = 200_000;
 /** Preview size when truncating */
 const PREVIEW_CHARS = 2_000;
-/** Default max_tokens (low to save slot reservation) */
-export const CAPPED_MAX_TOKENS = 8_192;
+/** Default max_tokens (low to save output slot reservation) */
+export const CAPPED_MAX_TOKENS = 16_384;
 /** Escalated max_tokens after hitting the cap */
 export const ESCALATED_MAX_TOKENS = 65_536;
+/** Per-model max output tokens — prevents requesting more than the model supports */
+const MODEL_MAX_OUTPUT = {
+    'anthropic/claude-opus-4.6': 32_000,
+    'anthropic/claude-sonnet-4.6': 64_000,
+    'anthropic/claude-haiku-4.5-20251001': 16_384,
+    'openai/gpt-5.4': 32_768,
+    'openai/gpt-5-mini': 16_384,
+    'google/gemini-2.5-pro': 65_536,
+    'google/gemini-2.5-flash': 65_536,
+    'deepseek/deepseek-chat': 8_192,
+};
+/** Get max output tokens for a model */
+export function getMaxOutputTokens(model) {
+    return MODEL_MAX_OUTPUT[model] ?? 16_384;
+}
 /** Idle gap (minutes) after which old tool results are cleared */
 const IDLE_GAP_THRESHOLD_MINUTES = 60;
 /** Number of recent tool results to keep during time-based cleanup */
@@ -86,26 +101,29 @@ export function budgetToolResults(history) {
 // ─── 2. Thinking Block Stripping ───────────────────────────────────────────
 /**
  * Remove thinking blocks from older assistant messages.
- * Keeps thinking only in the most recent assistant message.
- * Thinking blocks are large and not needed for context after the decision is made.
+ * Keeps thinking only in the most recent N assistant messages (default: last 2 turns).
+ * Older thinking blocks are large and not needed after the decision is made.
  */
+const KEEP_THINKING_TURNS = 2;
 export function stripOldThinking(history) {
-    // Find the last assistant message index
-    let lastAssistantIdx = -1;
+    // Find the last N assistant message indices to preserve their thinking
+    const assistantIndices = [];
     for (let i = history.length - 1; i >= 0; i--) {
         if (history[i].role === 'assistant') {
-            lastAssistantIdx = i;
-            break;
+            assistantIndices.push(i);
+            if (assistantIndices.length >= KEEP_THINKING_TURNS)
+                break;
         }
     }
-    if (lastAssistantIdx <= 0)
+    if (assistantIndices.length === 0)
         return history;
+    const keepSet = new Set(assistantIndices);
     const result = [];
     let modified = false;
     for (let i = 0; i < history.length; i++) {
         const msg = history[i];
-        // Only strip from older assistant messages (not the latest)
-        if (msg.role === 'assistant' && i < lastAssistantIdx && Array.isArray(msg.content)) {
+        // Strip thinking from assistant messages NOT in the keep set
+        if (msg.role === 'assistant' && !keepSet.has(i) && Array.isArray(msg.content)) {
             const filtered = msg.content.filter((part) => part.type !== 'thinking');
             if (filtered.length < msg.content.length) {
                 modified = true;

package/dist/agent/tokens.js

@@ -64,7 +64,8 @@ export function resetTokenAnchor() {
  * JSON-heavy content uses 2 bytes/token; general text uses 4.
  */
 export function estimateTokens(text, bytesPerToken = DEFAULT_BYTES_PER_TOKEN) {
-    return Math.ceil(Buffer.byteLength(text, 'utf-8') / bytesPerToken);
+    // Pad by 4/3 (~33%) for conservative estimation — better to over-count than under-count
+    return Math.ceil(Buffer.byteLength(text, 'utf-8') / bytesPerToken * 1.33);
 }
 /**
  * Estimate tokens for a content part.

package/dist/compression/adapter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adapter between brcc's Dialogue type and the compression lib's NormalizedMessage type.
+ */
+import type { Dialogue } from '../agent/types.js';
+/**
+ * Compress conversation history to reduce token usage.
+ * Returns compressed Dialogue[] with stats.
+ */
+export declare function compressHistory(history: Dialogue[], debug?: boolean): Promise<{
+    history: Dialogue[];
+    saved: number;
+    ratio: number;
+} | null>;

package/dist/compression/adapter.js

@@ -0,0 +1,104 @@
+/**
+ * Adapter between brcc's Dialogue type and the compression lib's NormalizedMessage type.
+ */
+import { compressContext, shouldCompress } from './index.js';
+/**
+ * Convert brcc Dialogue[] to NormalizedMessage[] for compression.
+ */
+function dialogueToNormalized(history) {
+    return history.map(msg => {
+        if (typeof msg.content === 'string') {
+            return { role: msg.role, content: msg.content };
+        }
+        // Convert content parts to string representation
+        const parts = [];
+        const toolCalls = [];
+        for (const part of msg.content) {
+            if ('type' in part) {
+                if (part.type === 'text') {
+                    parts.push(part.text);
+                }
+                else if (part.type === 'tool_use') {
+                    const inv = part;
+                    toolCalls.push({
+                        id: inv.id,
+                        type: 'function',
+                        function: { name: inv.name, arguments: JSON.stringify(inv.input) },
+                    });
+                }
+                else if (part.type === 'tool_result') {
+                    const res = part;
+                    const content = typeof res.content === 'string' ? res.content : JSON.stringify(res.content);
+                    parts.push(`[Tool result: ${content}]`);
+                }
+                else if (part.type === 'thinking') {
+                    // Skip thinking in compression (already handled by stripOldThinking)
+                }
+            }
+        }
+        const normalized = {
+            role: msg.role,
+            content: parts.join('\n') || null,
+        };
+        if (toolCalls.length > 0) {
+            normalized.tool_calls = toolCalls;
+        }
+        return normalized;
+    });
+}
+/**
+ * Compress conversation history to reduce token usage.
+ * Returns compressed Dialogue[] with stats.
+ */
+export async function compressHistory(history, debug) {
+    // Convert to NormalizedMessage format
+    const normalized = dialogueToNormalized(history);
+    // Check if compression is worthwhile
+    if (!shouldCompress(normalized)) {
+        return null;
+    }
+    try {
+        const result = await compressContext(normalized);
+        const savedPct = Math.round((1 - result.compressionRatio) * 100);
+        if (debug) {
+            console.error(`[runcode] Compressed context: ${result.originalChars} → ${result.compressedChars} chars (${savedPct}% saved)`);
+            if (result.stats) {
+                const layers = Object.entries(result.stats)
+                    .filter(([, v]) => typeof v === 'number' && v > 0)
+                    .map(([k, v]) => `${k}: ${v}`)
+                    .join(', ');
+                if (layers)
+                    console.error(`[runcode] Compression layers: ${layers}`);
+            }
+        }
+        // Convert compressed messages back to Dialogue format
+        // We only compress the string content, keeping the original structure
+        const compressed = [];
+        for (let i = 0; i < history.length && i < result.messages.length; i++) {
+            const original = history[i];
+            const comp = result.messages[i];
+            if (typeof original.content === 'string' && typeof comp.content === 'string') {
+                compressed.push({ role: original.role, content: comp.content });
+            }
+            else {
+                // Keep complex content as-is (tool_use/tool_result structure can't be modified)
+                compressed.push(original);
+            }
+        }
+        // Append any remaining original messages
+        for (let i = result.messages.length; i < history.length; i++) {
+            compressed.push(history[i]);
+        }
+        return {
+            history: compressed,
+            saved: result.originalChars - result.compressedChars,
+            ratio: result.compressionRatio,
+        };
+    }
+    catch (err) {
+        if (debug) {
+            console.error(`[runcode] Compression failed: ${err.message}`);
+        }
+        return null;
+    }
+}

package/dist/compression/codebook.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Dictionary Codebook
+ *
+ * Static dictionary of frequently repeated phrases observed in LLM prompts.
+ * Built from analysis of BlockRun production logs.
+ *
+ * Format: Short code ($XX) -> Long phrase
+ * The LLM receives a codebook header and decodes in-context.
+ */
+export declare const STATIC_CODEBOOK: Record<string, string>;
+/**
+ * Get the inverse codebook for decompression.
+ */
+export declare function getInverseCodebook(): Record<string, string>;
+/**
+ * Generate the codebook header for inclusion in system message.
+ * LLMs can decode in-context using this header.
+ */
+export declare function generateCodebookHeader(usedCodes: Set<string>, pathMap?: Record<string, string>): string;
+/**
+ * Decompress a string using the codebook (for logging).
+ */
+export declare function decompressContent(content: string, codebook?: Record<string, string>): string;

package/dist/compression/codebook.js

@@ -0,0 +1,118 @@
+/**
+ * Dictionary Codebook
+ *
+ * Static dictionary of frequently repeated phrases observed in LLM prompts.
+ * Built from analysis of BlockRun production logs.
+ *
+ * Format: Short code ($XX) -> Long phrase
+ * The LLM receives a codebook header and decodes in-context.
+ */
+// Static codebook - common patterns from system prompts
+// Ordered by expected frequency and impact
+export const STATIC_CODEBOOK = {
+    // High-impact: OpenClaw/Agent system prompt patterns (very common)
+    "$OC01": "unbrowse_", // Common prefix in tool names
+    "$OC02": "<location>",
+    "$OC03": "</location>",
+    "$OC04": "<name>",
+    "$OC05": "</name>",
+    "$OC06": "<description>",
+    "$OC07": "</description>",
+    "$OC08": "(may need login)",
+    "$OC09": "API skill for OpenClaw",
+    "$OC10": "endpoints",
+    // Skill/tool markers
+    "$SK01": "<available_skills>",
+    "$SK02": "</available_skills>",
+    "$SK03": "<skill>",
+    "$SK04": "</skill>",
+    // Schema patterns (very common in tool definitions)
+    "$T01": 'type: "function"',
+    "$T02": '"type": "function"',
+    "$T03": '"type": "string"',
+    "$T04": '"type": "object"',
+    "$T05": '"type": "array"',
+    "$T06": '"type": "boolean"',
+    "$T07": '"type": "number"',
+    // Common descriptions
+    "$D01": "description:",
+    "$D02": '"description":',
+    // Common instructions
+    "$I01": "You are a personal assistant",
+    "$I02": "Tool names are case-sensitive",
+    "$I03": "Call tools exactly as listed",
+    "$I04": "Use when",
+    "$I05": "without asking",
+    // Safety phrases
+    "$S01": "Do not manipulate or persuade",
+    "$S02": "Prioritize safety and human oversight",
+    "$S03": "unless explicitly requested",
+    // JSON patterns
+    "$J01": '"required": ["',
+    "$J02": '"properties": {',
+    "$J03": '"additionalProperties": false',
+    // Heartbeat patterns
+    "$H01": "HEARTBEAT_OK",
+    "$H02": "Read HEARTBEAT.md if it exists",
+    // Role markers
+    "$R01": '"role": "system"',
+    "$R02": '"role": "user"',
+    "$R03": '"role": "assistant"',
+    "$R04": '"role": "tool"',
+    // Common endings/phrases
+    "$E01": "would you like to",
+    "$E02": "Let me know if you",
+    "$E03": "internal APIs",
+    "$E04": "session cookies",
+    // BlockRun model aliases (common in prompts)
+    "$M01": "blockrun/",
+    "$M02": "openai/",
+    "$M03": "anthropic/",
+    "$M04": "google/",
+    "$M05": "xai/",
+};
+/**
+ * Get the inverse codebook for decompression.
+ */
+export function getInverseCodebook() {
+    const inverse = {};
+    for (const [code, phrase] of Object.entries(STATIC_CODEBOOK)) {
+        inverse[phrase] = code;
+    }
+    return inverse;
+}
+/**
+ * Generate the codebook header for inclusion in system message.
+ * LLMs can decode in-context using this header.
+ */
+export function generateCodebookHeader(usedCodes, pathMap = {}) {
+    if (usedCodes.size === 0 && Object.keys(pathMap).length === 0) {
+        return "";
+    }
+    const parts = [];
+    // Add used dictionary codes
+    if (usedCodes.size > 0) {
+        const codeEntries = Array.from(usedCodes)
+            .map((code) => `${code}=${STATIC_CODEBOOK[code]}`)
+            .join(", ");
+        parts.push(`[Dict: ${codeEntries}]`);
+    }
+    // Add path map
+    if (Object.keys(pathMap).length > 0) {
+        const pathEntries = Object.entries(pathMap)
+            .map(([code, path]) => `${code}=${path}`)
+            .join(", ");
+        parts.push(`[Paths: ${pathEntries}]`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Decompress a string using the codebook (for logging).
+ */
+export function decompressContent(content, codebook = STATIC_CODEBOOK) {
+    let result = content;
+    for (const [code, phrase] of Object.entries(codebook)) {
+        result = result.split(code).join(phrase);
+    }
+    return result;
+}

package/dist/compression/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LLM-Safe Context Compression
+ *
+ * Reduces token usage by 15-40% while preserving semantic meaning.
+ * Implements 7 compression layers inspired by claw-compactor.
+ *
+ * Usage:
+ *   const result = await compressContext(messages);
+ *   // result.messages -> compressed version to send to provider
+ *   // result.originalMessages -> original for logging
+ */
+import { NormalizedMessage, CompressionConfig, CompressionResult } from "./types.js";
+export * from "./types.js";
+export { STATIC_CODEBOOK } from "./codebook.js";
+/**
+ * Main compression function.
+ *
+ * Applies 5 layers in sequence:
+ * 1. Deduplication - Remove exact duplicate messages
+ * 2. Whitespace - Normalize excessive whitespace
+ * 3. Dictionary - Replace common phrases with codes
+ * 4. Paths - Shorten repeated file paths
+ * 5. JSON - Compact JSON in tool calls
+ *
+ * Then prepends a codebook header for the LLM to decode in-context.
+ */
+export declare function compressContext(messages: NormalizedMessage[], config?: Partial<CompressionConfig>): Promise<CompressionResult>;
+/**
+ * Quick check if compression would benefit these messages.
+ * Returns true if messages are large enough to warrant compression.
+ */
+export declare function shouldCompress(messages: NormalizedMessage[]): boolean;