@blockrun/runcode 2.4.0 → 2.5.0

package/dist/agent/commands.js

@@ -108,13 +108,16 @@ const DIRECT_COMMANDS = {
         emitDone(ctx);
     },
     '/help': (ctx) => {
+        const ultrathinkOn = ctx.config.ultrathink;
         ctx.onEvent({ kind: 'text_delta', text: `**RunCode Commands**\n\n` +
                 `  **Coding:** /commit /review /test /fix /debug /explain /search /find /refactor /scaffold\n` +
                 `  **Git:** /push /pr /undo /status /diff /log /branch /stash /unstash\n` +
                 `  **Analysis:** /security /lint /optimize /todo /deps /clean /migrate /doc\n` +
-                `  **Session:** /plan /execute /compact /retry /sessions /resume /context /tasks\n` +
-                `  **Info:** /model /wallet /cost /mcp /doctor /version /bug /help\n` +
-                `  **UI:** /clear /exit\n`
+                `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /context /tasks\n` +
+                `  **Power:** /ultrathink [query] /ultraplan /dump\n` +
+                `  **Info:** /model /wallet /cost /tokens /mcp /doctor /version /bug /help\n` +
+                `  **UI:** /clear /exit\n` +
+                (ultrathinkOn ? `\n  Ultrathink: ON\n` : '')
         });
         emitDone(ctx);
     },
@@ -201,6 +204,27 @@ const DIRECT_COMMANDS = {
         }
         emitDone(ctx);
     },
+    '/ultrathink': (ctx) => {
+        const cfg = ctx.config;
+        cfg.ultrathink = !cfg.ultrathink;
+        if (cfg.ultrathink) {
+            ctx.onEvent({ kind: 'text_delta', text: '**Ultrathink mode ON.** Extended reasoning active — the model will think deeply before responding.\n' +
+                    'Use `/ultrathink` again to disable, or `/ultrathink <query>` to send a one-shot deep analysis.\n'
+            });
+        }
+        else {
+            ctx.onEvent({ kind: 'text_delta', text: '**Ultrathink mode OFF.** Normal response mode restored.\n' });
+        }
+        emitDone(ctx);
+    },
+    '/dump': (ctx) => {
+        const instructions = ctx.config.systemInstructions;
+        const joined = instructions.join('\n\n---\n\n');
+        ctx.onEvent({ kind: 'text_delta', text: `**System Prompt** (${instructions.length} section${instructions.length !== 1 ? 's' : ''}):\n\n` +
+                `\`\`\`\n${joined.slice(0, 4000)}${joined.length > 4000 ? `\n... (${joined.length - 4000} chars truncated)` : ''}\n\`\`\`\n`
+        });
+        emitDone(ctx);
+    },
     '/execute': (ctx) => {
         if (ctx.config.permissionMode !== 'plan') {
             ctx.onEvent({ kind: 'text_delta', text: 'Not in plan mode. Use /plan to enter.\n' });
@@ -264,9 +288,19 @@ const REWRITE_COMMANDS = {
     '/migrate': 'Check for pending database migrations, outdated dependencies, or breaking changes that need addressing. List required migration steps.',
     '/clean': 'Find and remove dead code: unused imports, unreachable code, commented-out blocks, unused variables and functions. Show what would be removed before making changes.',
     '/tasks': 'List all current tasks using the Task tool.',
+    '/ultraplan': 'Enter ultraplan mode: create a detailed, step-by-step implementation plan before writing any code. ' +
+        'First, thoroughly read ALL relevant files. Map out every dependency and potential side effect. ' +
+        'Identify edge cases, security considerations, and performance implications. ' +
+        'Then produce a numbered implementation plan with specific file paths, function names, and code changes. ' +
+        'Do NOT write any code yet — only the plan.',
 };
 // Commands with arguments (prefix match → rewrite)
 const ARG_COMMANDS = [
+    { prefix: '/ultrathink ', rewrite: (a) => `Think deeply, carefully, and thoroughly before responding. ` +
+            `Consider multiple approaches, check edge cases, reason through implications step by step, ` +
+            `and challenge your initial assumptions. Take your time — quality of reasoning matters more than speed. ` +
+            `Now respond to: ${a}`
+    },
     { prefix: '/explain ', rewrite: (a) => `Read and explain the code in ${a}. Cover: what it does, key functions/classes, how it connects to the rest of the codebase.` },
     { prefix: '/search ', rewrite: (a) => `Search the codebase for "${a}" using Grep. Show the matching files and relevant code context.` },
     { prefix: '/find ', rewrite: (a) => `Find files matching the pattern "${a}" using Glob. Show the results.` },

package/dist/agent/context.js

@@ -50,8 +50,9 @@ You have access to tools for reading, writing, editing files, running shell comm
 # Slash Commands Available
 The user can type these shortcuts: /commit, /review, /test, /fix, /debug, /explain <file>,
 /search <query>, /find <pattern>, /refactor <desc>, /init, /todo, /deps, /diff, /status,
-/log, /branch, /stash, /plan, /execute, /compact, /retry, /sessions, /resume, /tasks,
-/context, /doctor, /model, /cost, /clear, /help, /exit.`;
+/log, /branch, /stash, /plan, /ultraplan, /execute, /compact, /retry, /sessions, /resume,
+/tasks, /context, /doctor, /tokens, /model, /cost, /dump, /ultrathink [query], /clear,
+/help, /exit.`;
 /**
  * Build the full system instructions array for a session.
  */

package/dist/agent/loop.js

@@ -5,9 +5,9 @@
  */
 import { ModelClient } from './llm.js';
 import { autoCompactIfNeeded, microCompact } from './compact.js';
-import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor } from './tokens.js';
+import { estimateHistoryTokens, updateActualTokens, resetTokenAnchor, getAnchoredTokenCount, getContextWindow } from './tokens.js';
 import { handleSlashCommand } from './commands.js';
-import { compressHistory } from '../compression/adapter.js';
+import { reduceTokens } from './reduce.js';
 import { PermissionManager } from './permissions.js';
 import { StreamingExecutor } from './streaming-executor.js';
 import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS, getMaxOutputTokens } from './optimize.js';
@@ -214,6 +214,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     // Session persistence
     const sessionId = createSessionId();
     let turnCount = 0;
+    let tokenBudgetWarned = false; // Emit token budget warning at most once per session
     pruneOldSessions(sessionId); // Cleanup old sessions on start, protect current
     while (true) {
         let input = await getUserInput();
@@ -254,7 +255,13 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 history.length = 0;
                 history.push(...optimized);
             }
-            // 2. Microcompact: only when history has >15 messages (skip for short conversations)
+            // 2. Token reduction: age old results, normalize whitespace, trim verbose messages
+            const reduced = reduceTokens(history, config.debug);
+            if (reduced !== history) {
+                history.length = 0;
+                history.push(...reduced);
+            }
+            // 3. Microcompact: only when history has >15 messages (skip for short conversations)
             if (history.length > 15) {
                 const microCompacted = microCompact(history, 8);
                 if (microCompacted !== history) {
@@ -262,15 +269,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     history.push(...microCompacted);
                 }
             }
-            // 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
+            // 3. Auto-compact: summarize history if approaching context limit
             // Circuit breaker: stop retrying after 3 consecutive failures
             if (compactFailures < 3) {
                 try {
@@ -292,7 +291,18 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     }
                 }
             }
-            const systemPrompt = config.systemInstructions.join('\n\n');
+            // Inject ultrathink instruction when mode is active
+            const systemParts = [...config.systemInstructions];
+            if (config.ultrathink) {
+                systemParts.push('# Ultrathink Mode\n' +
+                    'You are in deep reasoning mode. Before responding to any request:\n' +
+                    '1. Thoroughly analyze the problem from multiple angles\n' +
+                    '2. Consider edge cases, failure modes, and second-order effects\n' +
+                    '3. Challenge your initial assumptions before committing to an approach\n' +
+                    '4. Think step by step — show your reasoning explicitly when it adds value\n' +
+                    'Prioritize correctness and thoroughness over speed.');
+            }
+            const systemPrompt = systemParts.join('\n\n');
             const modelMaxOut = getMaxOutputTokens(config.model);
             let maxTokens = Math.min(maxTokensOverride ?? CAPPED_MAX_TOKENS, modelMaxOut);
             let responseParts = [];
@@ -435,6 +445,19 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     turnCount,
                     messageCount: history.length,
                 });
+                // Token budget warning — emit once per session when crossing 70%
+                if (!tokenBudgetWarned) {
+                    const { estimated } = getAnchoredTokenCount(history);
+                    const contextWindow = getContextWindow(config.model);
+                    const pct = (estimated / contextWindow) * 100;
+                    if (pct >= 70) {
+                        tokenBudgetWarned = true;
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `\n\n> **Token budget: ${pct.toFixed(0)}% used** (~${estimated.toLocaleString()} / ${(contextWindow / 1000).toFixed(0)}k tokens). Run \`/compact\` to free up space.\n`,
+                        });
+                    }
+                }
                 onEvent({ kind: 'turn_done', reason: 'completed' });
                 break;
             }

package/dist/agent/reduce.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Token Reduction for runcode.
+ * Original implementation — reduces context size through intelligent pruning.
+ *
+ * Strategy: instead of compression/encoding, we PRUNE redundant content.
+ * The model doesn't need verbose tool outputs from 20 turns ago.
+ *
+ * Three reduction passes:
+ * 1. Tool result aging — progressively shorten old tool results
+ * 2. Whitespace normalization — remove excessive blank lines and indentation
+ * 3. Stale context removal — drop system info that's been superseded
+ */
+import type { Dialogue } from './types.js';
+/**
+ * Progressively shorten tool results based on age.
+ * Recent results: keep full. Older results: keep summary. Very old: keep one line.
+ *
+ * This is the biggest token saver — a 10KB bash output from 20 turns ago
+ * can be reduced to "✓ Bash: ran npm test (exit 0)" saving ~2500 tokens.
+ */
+export declare function ageToolResults(history: Dialogue[]): Dialogue[];
+/**
+ * Normalize whitespace in text messages.
+ * - Collapse 3+ blank lines to 2
+ * - Remove trailing spaces
+ * - Reduce indentation beyond 8 spaces to 8
+ */
+export declare function normalizeWhitespace(history: Dialogue[]): Dialogue[];
+/**
+ * Trim very long assistant text messages from old turns.
+ * Recent messages: keep full. Old long messages: keep first 1000 chars.
+ */
+export declare function trimOldAssistantMessages(history: Dialogue[]): Dialogue[];
+/**
+ * Remove consecutive duplicate messages (same role + same content).
+ */
+export declare function deduplicateMessages(history: Dialogue[]): Dialogue[];
+/**
+ * Run all token reduction passes on conversation history.
+ * Returns same reference if nothing changed (cheap identity check).
+ */
+export declare function reduceTokens(history: Dialogue[], debug?: boolean): Dialogue[];

package/dist/agent/reduce.js

@@ -0,0 +1,258 @@
+/**
+ * Token Reduction for runcode.
+ * Original implementation — reduces context size through intelligent pruning.
+ *
+ * Strategy: instead of compression/encoding, we PRUNE redundant content.
+ * The model doesn't need verbose tool outputs from 20 turns ago.
+ *
+ * Three reduction passes:
+ * 1. Tool result aging — progressively shorten old tool results
+ * 2. Whitespace normalization — remove excessive blank lines and indentation
+ * 3. Stale context removal — drop system info that's been superseded
+ */
+// ─── 1. Tool Result Aging ─────────────────────────────────────────────────
+/**
+ * Progressively shorten tool results based on age.
+ * Recent results: keep full. Older results: keep summary. Very old: keep one line.
+ *
+ * This is the biggest token saver — a 10KB bash output from 20 turns ago
+ * can be reduced to "✓ Bash: ran npm test (exit 0)" saving ~2500 tokens.
+ */
+export function ageToolResults(history) {
+    // Find all tool_result positions
+    const toolPositions = [];
+    for (let i = 0; i < history.length; i++) {
+        const msg = history[i];
+        if (msg.role === 'user' &&
+            Array.isArray(msg.content) &&
+            msg.content.some(p => p.type === 'tool_result')) {
+            toolPositions.push(i);
+        }
+    }
+    if (toolPositions.length <= 3)
+        return history; // Nothing to age
+    const result = [...history];
+    const totalResults = toolPositions.length;
+    for (let idx = 0; idx < toolPositions.length; idx++) {
+        const pos = toolPositions[idx];
+        const age = totalResults - idx; // Higher = older
+        const msg = result[pos];
+        if (!Array.isArray(msg.content))
+            continue;
+        const parts = msg.content;
+        let modified = false;
+        const aged = parts.map(part => {
+            if (part.type !== 'tool_result')
+                return part;
+            const content = typeof part.content === 'string'
+                ? part.content
+                : JSON.stringify(part.content);
+            const charLen = content.length;
+            // Recent 3 results: keep full
+            if (age <= 3)
+                return part;
+            // Age 4-8: keep first 500 chars
+            if (age <= 8 && charLen > 500) {
+                modified = true;
+                const truncated = content.slice(0, 500);
+                const lastNl = truncated.lastIndexOf('\n');
+                const clean = lastNl > 250 ? truncated.slice(0, lastNl) : truncated;
+                return {
+                    ...part,
+                    content: `${clean}\n... (${charLen - clean.length} chars omitted, ${age} turns ago)`,
+                };
+            }
+            // Age 9-15: keep first 200 chars
+            if (age <= 15 && charLen > 200) {
+                modified = true;
+                const firstLine = content.split('\n')[0].slice(0, 150);
+                return {
+                    ...part,
+                    content: `${firstLine}\n... (${charLen} chars, ${age} turns ago)`,
+                };
+            }
+            // Age 16+: one line summary
+            if (age > 15 && charLen > 80) {
+                modified = true;
+                const summary = content.split('\n')[0].slice(0, 60);
+                return {
+                    ...part,
+                    content: part.is_error
+                        ? `[Error: ${summary}...]`
+                        : `[Result: ${summary}...]`,
+                };
+            }
+            return part;
+        });
+        if (modified) {
+            result[pos] = { role: 'user', content: aged };
+        }
+    }
+    return result;
+}
+// ─── 2. Whitespace Normalization ──────────────────────────────────────────
+/**
+ * Normalize whitespace in text messages.
+ * - Collapse 3+ blank lines to 2
+ * - Remove trailing spaces
+ * - Reduce indentation beyond 8 spaces to 8
+ */
+export function normalizeWhitespace(history) {
+    let modified = false;
+    const result = history.map(msg => {
+        if (typeof msg.content !== 'string')
+            return msg;
+        const original = msg.content;
+        const cleaned = original
+            .replace(/[ \t]+$/gm, '') // Trailing spaces
+            .replace(/\n{4,}/g, '\n\n\n') // Max 3 consecutive newlines
+            .replace(/^( {9,})/gm, '        '); // Cap indentation at 8 spaces
+        if (cleaned !== original) {
+            modified = true;
+            return { ...msg, content: cleaned };
+        }
+        return msg;
+    });
+    return modified ? result : history;
+}
+// ─── 3. Verbose Assistant Message Trimming ────────────────────────────────
+/**
+ * Trim very long assistant text messages from old turns.
+ * Recent messages: keep full. Old long messages: keep first 1000 chars.
+ */
+export function trimOldAssistantMessages(history) {
+    const MAX_OLD_ASSISTANT_CHARS = 1500;
+    const KEEP_RECENT = 4; // Keep last 4 assistant messages full
+    let assistantCount = 0;
+    for (const msg of history) {
+        if (msg.role === 'assistant')
+            assistantCount++;
+    }
+    if (assistantCount <= KEEP_RECENT)
+        return history;
+    let seenAssistant = 0;
+    let modified = false;
+    const result = history.map(msg => {
+        if (msg.role !== 'assistant')
+            return msg;
+        seenAssistant++;
+        // Keep recent messages full
+        if (assistantCount - seenAssistant < KEEP_RECENT)
+            return msg;
+        if (typeof msg.content === 'string' && msg.content.length > MAX_OLD_ASSISTANT_CHARS) {
+            modified = true;
+            const truncated = msg.content.slice(0, MAX_OLD_ASSISTANT_CHARS);
+            const lastNl = truncated.lastIndexOf('\n');
+            const clean = lastNl > MAX_OLD_ASSISTANT_CHARS / 2 ? truncated.slice(0, lastNl) : truncated;
+            return { ...msg, content: clean + '\n... (response truncated)' };
+        }
+        // Also handle content array with text parts
+        if (Array.isArray(msg.content)) {
+            const parts = msg.content;
+            let totalChars = 0;
+            for (const p of parts) {
+                if (p.type === 'text')
+                    totalChars += p.text.length;
+            }
+            if (totalChars > MAX_OLD_ASSISTANT_CHARS) {
+                modified = true;
+                const trimmedParts = parts.map(p => {
+                    if (p.type !== 'text' || p.text.length <= 500)
+                        return p;
+                    return { ...p, text: p.text.slice(0, 500) + '\n... (trimmed)' };
+                });
+                return { ...msg, content: trimmedParts };
+            }
+        }
+        return msg;
+    });
+    return modified ? result : history;
+}
+// ─── 4. Deduplication ────────────���────────────────────────────────────────
+/**
+ * Remove consecutive duplicate messages (same role + same content).
+ */
+export function deduplicateMessages(history) {
+    if (history.length < 3)
+        return history;
+    const result = [history[0]];
+    let modified = false;
+    for (let i = 1; i < history.length; i++) {
+        const prev = history[i - 1];
+        const curr = history[i];
+        if (curr.role === prev.role && typeof curr.content === 'string' && curr.content === prev.content) {
+            modified = true;
+            continue;
+        }
+        result.push(curr);
+    }
+    return modified ? result : history;
+}
+// ─── Pipeline ───────���───────────────────���─────────────────────────────────
+/**
+ * Run all token reduction passes on conversation history.
+ * Returns same reference if nothing changed (cheap identity check).
+ */
+export function reduceTokens(history, debug) {
+    if (history.length < 8)
+        return history; // Skip for short conversations
+    let current = history;
+    let totalSaved = 0;
+    // Pass 1: Age old tool results
+    const aged = ageToolResults(current);
+    if (aged !== current) {
+        const before = estimateChars(current);
+        current = aged;
+        const saved = before - estimateChars(current);
+        totalSaved += saved;
+    }
+    // Pass 2: Normalize whitespace
+    const normalized = normalizeWhitespace(current);
+    if (normalized !== current) {
+        const before = estimateChars(current);
+        current = normalized;
+        totalSaved += before - estimateChars(current);
+    }
+    // Pass 3: Trim old verbose assistant messages
+    const trimmed = trimOldAssistantMessages(current);
+    if (trimmed !== current) {
+        const before = estimateChars(current);
+        current = trimmed;
+        totalSaved += before - estimateChars(current);
+    }
+    // Pass 4: Remove consecutive duplicate messages
+    const deduped = deduplicateMessages(current);
+    if (deduped !== current) {
+        const before = estimateChars(current);
+        current = deduped;
+        totalSaved += before - estimateChars(current);
+    }
+    if (debug && totalSaved > 500) {
+        const tokensSaved = Math.round(totalSaved / 4);
+        console.error(`[runcode] Token reduction: ~${tokensSaved} tokens saved`);
+    }
+    return current;
+}
+function estimateChars(history) {
+    let total = 0;
+    for (const msg of history) {
+        if (typeof msg.content === 'string') {
+            total += msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const p of msg.content) {
+                if ('type' in p) {
+                    if (p.type === 'text')
+                        total += p.text.length;
+                    else if (p.type === 'tool_result') {
+                        total += typeof p.content === 'string' ? p.content.length : JSON.stringify(p.content).length;
+                    }
+                    else if (p.type === 'tool_use') {
+                        total += JSON.stringify(p.input).length;
+                    }
+                }
+            }
+        }
+    }
+    return total;
+}

package/dist/agent/types.d.ts

@@ -101,4 +101,6 @@ export interface AgentConfig {
     permissionMode?: 'default' | 'trust' | 'deny-all' | 'plan';
     onEvent?: (event: StreamEvent) => void;
     debug?: boolean;
+    /** Ultrathink mode: inject deep-reasoning instruction into every prompt */
+    ultrathink?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {

package/dist/compression/adapter.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,104 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-/**
- * 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;