@blockrun/runcode 2.2.7 → 2.4.0

package/dist/compression/layers/json-compact.js

@@ -0,0 +1,74 @@
+/**
+ * Layer 5: JSON Compaction
+ *
+ * Minifies JSON in tool_call arguments and tool results.
+ * Removes pretty-print whitespace from JSON strings.
+ *
+ * Safe for LLM: JSON semantics unchanged.
+ * Expected savings: 2-4%
+ */
+/**
+ * Compact a JSON string by parsing and re-stringifying without formatting.
+ */
+function compactJson(jsonString) {
+    try {
+        const parsed = JSON.parse(jsonString);
+        return JSON.stringify(parsed);
+    }
+    catch {
+        // Not valid JSON, return as-is
+        return jsonString;
+    }
+}
+/**
+ * Check if a string looks like JSON (starts with { or [).
+ */
+function looksLikeJson(str) {
+    const trimmed = str.trim();
+    return ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]")));
+}
+/**
+ * Compact tool_call arguments in a message.
+ */
+function compactToolCalls(toolCalls) {
+    return toolCalls.map((tc) => ({
+        ...tc,
+        function: {
+            ...tc.function,
+            arguments: compactJson(tc.function.arguments),
+        },
+    }));
+}
+/**
+ * Apply JSON compaction to all messages.
+ *
+ * Targets:
+ * - tool_call arguments (in assistant messages)
+ * - tool message content (often JSON)
+ */
+export function compactMessagesJson(messages) {
+    let charsSaved = 0;
+    const result = messages.map((message) => {
+        const newMessage = { ...message };
+        // Compact tool_calls arguments
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            const originalLength = JSON.stringify(message.tool_calls).length;
+            newMessage.tool_calls = compactToolCalls(message.tool_calls);
+            const newLength = JSON.stringify(newMessage.tool_calls).length;
+            charsSaved += originalLength - newLength;
+        }
+        // Compact tool message content if it looks like JSON
+        if (message.role === "tool" && message.content && typeof message.content === "string" && looksLikeJson(message.content)) {
+            const originalLength = message.content.length;
+            const compacted = compactJson(message.content);
+            charsSaved += originalLength - compacted.length;
+            newMessage.content = compacted;
+        }
+        return newMessage;
+    });
+    return {
+        messages: result,
+        charsSaved,
+    };
+}

package/dist/compression/layers/observation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * L6: Observation Compression (AGGRESSIVE)
+ *
+ * Inspired by claw-compactor's 97% compression on tool results.
+ * Tool call results (especially large ones) are summarized to key info only.
+ *
+ * This is the biggest compression win - tool outputs can be 10KB+ but
+ * only ~200 chars of actual useful information.
+ */
+import { NormalizedMessage } from "../types.js";
+interface ObservationResult {
+    messages: NormalizedMessage[];
+    charsSaved: number;
+    observationsCompressed: number;
+}
+/**
+ * Compress tool results in messages.
+ */
+export declare function compressObservations(messages: NormalizedMessage[]): ObservationResult;
+export {};

package/dist/compression/layers/observation.js

@@ -0,0 +1,126 @@
+/**
+ * L6: Observation Compression (AGGRESSIVE)
+ *
+ * Inspired by claw-compactor's 97% compression on tool results.
+ * Tool call results (especially large ones) are summarized to key info only.
+ *
+ * This is the biggest compression win - tool outputs can be 10KB+ but
+ * only ~200 chars of actual useful information.
+ */
+// Max length for tool results before compression kicks in
+const TOOL_RESULT_THRESHOLD = 500;
+// Max length to compress tool results down to
+const COMPRESSED_RESULT_MAX = 300;
+/**
+ * Extract key information from tool result.
+ * Keeps: errors, key values, status, first/last important lines.
+ */
+function compressToolResult(content) {
+    if (!content || content.length <= TOOL_RESULT_THRESHOLD) {
+        return content;
+    }
+    const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
+    // Priority 1: Error messages (always keep)
+    const errorLines = lines.filter((l) => /error|exception|failed|denied|refused|timeout|invalid/i.test(l) &&
+        l.length < 200);
+    // Priority 2: Status/result lines
+    const statusLines = lines.filter((l) => /success|complete|created|updated|found|result|status|total|count/i.test(l) &&
+        l.length < 150);
+    // Priority 3: Key JSON fields (extract important values)
+    const jsonMatches = [];
+    const jsonPattern = /"(id|name|status|error|message|count|total|url|path)":\s*"?([^",}\n]+)"?/gi;
+    let match;
+    while ((match = jsonPattern.exec(content)) !== null) {
+        jsonMatches.push(`${match[1]}: ${match[2].slice(0, 50)}`);
+    }
+    // Priority 4: First and last meaningful lines
+    const firstLine = lines[0]?.slice(0, 100);
+    const lastLine = lines.length > 1 ? lines[lines.length - 1]?.slice(0, 100) : "";
+    // Build compressed observation
+    const parts = [];
+    if (errorLines.length > 0) {
+        parts.push("[ERR] " + errorLines.slice(0, 3).join(" | "));
+    }
+    if (statusLines.length > 0) {
+        parts.push(statusLines.slice(0, 3).join(" | "));
+    }
+    if (jsonMatches.length > 0) {
+        parts.push(jsonMatches.slice(0, 5).join(", "));
+    }
+    if (parts.length === 0) {
+        // Fallback: keep first/last lines with truncation marker
+        parts.push(firstLine || "");
+        if (lines.length > 2) {
+            parts.push(`[...${lines.length - 2} lines...]`);
+        }
+        if (lastLine && lastLine !== firstLine) {
+            parts.push(lastLine);
+        }
+    }
+    let result = parts.join("\n");
+    // Final length cap
+    if (result.length > COMPRESSED_RESULT_MAX) {
+        result = result.slice(0, COMPRESSED_RESULT_MAX - 20) + "\n[...truncated]";
+    }
+    return result;
+}
+/**
+ * Compress large repeated content blocks.
+ * Detects when same large block appears multiple times.
+ */
+function deduplicateLargeBlocks(messages) {
+    const blockHashes = new Map(); // hash -> first occurrence index
+    let charsSaved = 0;
+    const result = messages.map((msg, idx) => {
+        if (!msg.content || typeof msg.content !== "string" || msg.content.length < 500) {
+            return msg;
+        }
+        // Hash first 200 chars as block identifier
+        const blockKey = msg.content.slice(0, 200);
+        if (blockHashes.has(blockKey)) {
+            const firstIdx = blockHashes.get(blockKey);
+            const original = msg.content;
+            const compressed = `[See message #${firstIdx + 1} - same content]`;
+            charsSaved += original.length - compressed.length;
+            return { ...msg, content: compressed };
+        }
+        blockHashes.set(blockKey, idx);
+        return msg;
+    });
+    return { messages: result, charsSaved };
+}
+/**
+ * Compress tool results in messages.
+ */
+export function compressObservations(messages) {
+    let charsSaved = 0;
+    let observationsCompressed = 0;
+    // First pass: compress individual tool results
+    let result = messages.map((msg) => {
+        // Only compress tool role messages (these are tool call results)
+        if (msg.role !== "tool" || !msg.content || typeof msg.content !== "string") {
+            return msg;
+        }
+        const original = msg.content;
+        if (original.length <= TOOL_RESULT_THRESHOLD) {
+            return msg;
+        }
+        const compressed = compressToolResult(original);
+        const saved = original.length - compressed.length;
+        if (saved > 50) {
+            charsSaved += saved;
+            observationsCompressed++;
+            return { ...msg, content: compressed };
+        }
+        return msg;
+    });
+    // Second pass: deduplicate large repeated blocks
+    const dedupResult = deduplicateLargeBlocks(result);
+    result = dedupResult.messages;
+    charsSaved += dedupResult.charsSaved;
+    return {
+        messages: result,
+        charsSaved,
+        observationsCompressed,
+    };
+}

package/dist/compression/layers/paths.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Layer 4: Path Shortening
+ *
+ * Detects common filesystem path prefixes and replaces them with short codes.
+ * Common in coding assistant contexts with repeated file paths.
+ *
+ * Safe for LLM: Lossless abbreviation with path map header.
+ * Expected savings: 1-3%
+ */
+import { NormalizedMessage } from "../types.js";
+export interface PathShorteningResult {
+    messages: NormalizedMessage[];
+    pathMap: Record<string, string>;
+    charsSaved: number;
+}
+/**
+ * Apply path shortening to all messages.
+ */
+export declare function shortenPaths(messages: NormalizedMessage[]): PathShorteningResult;
+/**
+ * Generate the path map header for the codebook.
+ */
+export declare function generatePathMapHeader(pathMap: Record<string, string>): string;

package/dist/compression/layers/paths.js

@@ -0,0 +1,107 @@
+/**
+ * Layer 4: Path Shortening
+ *
+ * Detects common filesystem path prefixes and replaces them with short codes.
+ * Common in coding assistant contexts with repeated file paths.
+ *
+ * Safe for LLM: Lossless abbreviation with path map header.
+ * Expected savings: 1-3%
+ */
+// Regex to match filesystem paths
+const PATH_REGEX = /(?:\/[\w.-]+){3,}/g;
+/**
+ * Extract all paths from messages and find common prefixes.
+ */
+function extractPaths(messages) {
+    const paths = [];
+    for (const message of messages) {
+        if (!message.content || typeof message.content !== "string")
+            continue;
+        const matches = message.content.match(PATH_REGEX);
+        if (matches) {
+            paths.push(...matches);
+        }
+    }
+    return paths;
+}
+/**
+ * Group paths by their common prefixes.
+ * Returns prefixes that appear at least 3 times.
+ */
+function findFrequentPrefixes(paths) {
+    const prefixCounts = new Map();
+    for (const path of paths) {
+        const parts = path.split("/").filter(Boolean);
+        // Try prefixes of different lengths
+        for (let i = 2; i < parts.length; i++) {
+            const prefix = "/" + parts.slice(0, i).join("/") + "/";
+            prefixCounts.set(prefix, (prefixCounts.get(prefix) || 0) + 1);
+        }
+    }
+    // Return prefixes that appear 3+ times, sorted by length (longest first)
+    return Array.from(prefixCounts.entries())
+        .filter(([, count]) => count >= 3)
+        .sort((a, b) => b[0].length - a[0].length)
+        .slice(0, 5) // Max 5 path codes
+        .map(([prefix]) => prefix);
+}
+/**
+ * Apply path shortening to all messages.
+ */
+export function shortenPaths(messages) {
+    const allPaths = extractPaths(messages);
+    if (allPaths.length < 5) {
+        // Not enough paths to benefit from shortening
+        return {
+            messages,
+            pathMap: {},
+            charsSaved: 0,
+        };
+    }
+    const prefixes = findFrequentPrefixes(allPaths);
+    if (prefixes.length === 0) {
+        return {
+            messages,
+            pathMap: {},
+            charsSaved: 0,
+        };
+    }
+    // Create path map
+    const pathMap = {};
+    prefixes.forEach((prefix, i) => {
+        pathMap[`$P${i + 1}`] = prefix;
+    });
+    // Replace paths in messages
+    let charsSaved = 0;
+    const result = messages.map((message) => {
+        if (!message.content || typeof message.content !== "string")
+            return message;
+        let content = message.content;
+        const originalLength = content.length;
+        // Replace prefixes (longest first to avoid partial replacements)
+        for (const [code, prefix] of Object.entries(pathMap)) {
+            content = content.split(prefix).join(code + "/");
+        }
+        charsSaved += originalLength - content.length;
+        return {
+            ...message,
+            content,
+        };
+    });
+    return {
+        messages: result,
+        pathMap,
+        charsSaved,
+    };
+}
+/**
+ * Generate the path map header for the codebook.
+ */
+export function generatePathMapHeader(pathMap) {
+    if (Object.keys(pathMap).length === 0)
+        return "";
+    const entries = Object.entries(pathMap)
+        .map(([code, path]) => `${code}=${path}`)
+        .join(", ");
+    return `[Paths: ${entries}]`;
+}

package/dist/compression/layers/whitespace.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Layer 2: Whitespace Normalization
+ *
+ * Reduces excessive whitespace without changing semantic meaning.
+ *
+ * Safe for LLM: Tokenizers normalize whitespace anyway.
+ * Expected savings: 3-8%
+ */
+import { NormalizedMessage } from "../types.js";
+export interface WhitespaceResult {
+    messages: NormalizedMessage[];
+    charsSaved: number;
+}
+/**
+ * Normalize whitespace in a string.
+ *
+ * - Max 2 consecutive newlines
+ * - Remove trailing whitespace from lines
+ * - Normalize tabs to spaces
+ * - Trim start/end
+ */
+export declare function normalizeWhitespace(content: string): string;
+/**
+ * Apply whitespace normalization to all messages.
+ */
+export declare function normalizeMessagesWhitespace(messages: NormalizedMessage[]): WhitespaceResult;

package/dist/compression/layers/whitespace.js

@@ -0,0 +1,57 @@
+/**
+ * Layer 2: Whitespace Normalization
+ *
+ * Reduces excessive whitespace without changing semantic meaning.
+ *
+ * Safe for LLM: Tokenizers normalize whitespace anyway.
+ * Expected savings: 3-8%
+ */
+/**
+ * Normalize whitespace in a string.
+ *
+ * - Max 2 consecutive newlines
+ * - Remove trailing whitespace from lines
+ * - Normalize tabs to spaces
+ * - Trim start/end
+ */
+export function normalizeWhitespace(content) {
+    if (!content)
+        return content;
+    return content
+        // Normalize line endings
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        // Max 2 consecutive newlines (preserve paragraph breaks)
+        .replace(/\n{3,}/g, "\n\n")
+        // Remove trailing whitespace from each line
+        .replace(/[ \t]+$/gm, "")
+        // Normalize multiple spaces to single (except at line start for indentation)
+        .replace(/([^\n]) {2,}/g, "$1 ")
+        // Reduce excessive indentation (more than 8 spaces → 2 spaces per level)
+        .replace(/^[ ]{8,}/gm, (match) => "  ".repeat(Math.ceil(match.length / 4)))
+        // Normalize tabs to 2 spaces
+        .replace(/\t/g, "  ")
+        // Trim
+        .trim();
+}
+/**
+ * Apply whitespace normalization to all messages.
+ */
+export function normalizeMessagesWhitespace(messages) {
+    let charsSaved = 0;
+    const result = messages.map((message) => {
+        if (!message.content || typeof message.content !== "string")
+            return message;
+        const originalLength = message.content.length;
+        const normalizedContent = normalizeWhitespace(message.content);
+        charsSaved += originalLength - normalizedContent.length;
+        return {
+            ...message,
+            content: normalizedContent,
+        };
+    });
+    return {
+        messages: result,
+        charsSaved,
+    };
+}

package/dist/compression/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LLM-Safe Context Compression Types
+ *
+ * Types for the 5-layer compression system that reduces token usage
+ * while preserving semantic meaning for LLM queries.
+ */
+export type ContentPart = {
+    type: string;
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: string;
+    };
+};
+export interface NormalizedMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentPart[] | null;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+    name?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface CompressionConfig {
+    enabled: boolean;
+    preserveRaw: boolean;
+    layers: {
+        deduplication: boolean;
+        whitespace: boolean;
+        dictionary: boolean;
+        paths: boolean;
+        jsonCompact: boolean;
+        observation: boolean;
+        dynamicCodebook: boolean;
+    };
+    dictionary: {
+        maxEntries: number;
+        minPhraseLength: number;
+        includeCodebookHeader: boolean;
+    };
+}
+export interface CompressionStats {
+    duplicatesRemoved: number;
+    whitespaceSavedChars: number;
+    dictionarySubstitutions: number;
+    pathsShortened: number;
+    jsonCompactedChars: number;
+    observationsCompressed: number;
+    observationCharsSaved: number;
+    dynamicSubstitutions: number;
+    dynamicCharsSaved: number;
+}
+export interface CompressionResult {
+    messages: NormalizedMessage[];
+    originalMessages: NormalizedMessage[];
+    originalChars: number;
+    compressedChars: number;
+    compressionRatio: number;
+    stats: CompressionStats;
+    codebook: Record<string, string>;
+    pathMap: Record<string, string>;
+    dynamicCodes: Record<string, string>;
+}
+export interface CompressionLogData {
+    enabled: boolean;
+    ratio: number;
+    original_chars: number;
+    compressed_chars: number;
+    stats: {
+        duplicates_removed: number;
+        whitespace_saved: number;
+        dictionary_subs: number;
+        paths_shortened: number;
+        json_compacted: number;
+    };
+}
+export declare const DEFAULT_COMPRESSION_CONFIG: CompressionConfig;

package/dist/compression/types.js

@@ -0,0 +1,26 @@
+/**
+ * LLM-Safe Context Compression Types
+ *
+ * Types for the 5-layer compression system that reduces token usage
+ * while preserving semantic meaning for LLM queries.
+ */
+// Default configuration - CONSERVATIVE settings for model compatibility
+// Only enable layers that don't require the model to decode anything
+export const DEFAULT_COMPRESSION_CONFIG = {
+    enabled: true,
+    preserveRaw: true,
+    layers: {
+        deduplication: true, // Safe: removes duplicate messages
+        whitespace: true, // Safe: normalizes whitespace
+        dictionary: false, // DISABLED: requires model to understand codebook
+        paths: false, // DISABLED: requires model to understand path codes
+        jsonCompact: true, // Safe: just removes JSON whitespace
+        observation: false, // DISABLED: may lose important context
+        dynamicCodebook: false, // DISABLED: requires model to understand codes
+    },
+    dictionary: {
+        maxEntries: 50,
+        minPhraseLength: 15,
+        includeCodebookHeader: false, // No codebook header needed
+    },
+};

package/package.json

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