@blockrun/runcode 2.4.0 → 2.5.0

package/dist/compression/layers/dynamic-codebook.js

@@ -1,145 +0,0 @@
-/**
- * L7: Dynamic Codebook Builder
- *
- * Inspired by claw-compactor's frequency-based codebook.
- * Builds codebook from actual content being compressed,
- * rather than relying on static patterns.
- *
- * Finds phrases that appear 3+ times and replaces with short codes.
- */
-// Config
-const MIN_PHRASE_LENGTH = 20;
-const MAX_PHRASE_LENGTH = 200;
-const MIN_FREQUENCY = 3;
-const MAX_ENTRIES = 100;
-const CODE_PREFIX = "$D"; // Dynamic codes: $D01, $D02, etc.
-/**
- * Find repeated phrases in content.
- */
-function findRepeatedPhrases(allContent) {
-    const phrases = new Map();
-    // Split by sentence-like boundaries
-    const segments = allContent.split(/(?<=[.!?\n])\s+/);
-    for (const segment of segments) {
-        const trimmed = segment.trim();
-        if (trimmed.length >= MIN_PHRASE_LENGTH &&
-            trimmed.length <= MAX_PHRASE_LENGTH) {
-            phrases.set(trimmed, (phrases.get(trimmed) || 0) + 1);
-        }
-    }
-    // Also find repeated lines
-    const lines = allContent.split("\n");
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.length >= MIN_PHRASE_LENGTH &&
-            trimmed.length <= MAX_PHRASE_LENGTH) {
-            phrases.set(trimmed, (phrases.get(trimmed) || 0) + 1);
-        }
-    }
-    return phrases;
-}
-/**
- * Build dynamic codebook from message content.
- */
-function buildDynamicCodebook(messages) {
-    // Combine all content
-    let allContent = "";
-    for (const msg of messages) {
-        if (msg.content) {
-            allContent += msg.content + "\n";
-        }
-    }
-    // Find repeated phrases
-    const phrases = findRepeatedPhrases(allContent);
-    // Filter by frequency and sort by savings potential
-    const candidates = [];
-    for (const [phrase, count] of phrases.entries()) {
-        if (count >= MIN_FREQUENCY) {
-            // Savings = (phrase length - code length) * occurrences
-            const codeLength = 4; // e.g., "$D01"
-            const savings = (phrase.length - codeLength) * count;
-            if (savings > 50) {
-                candidates.push({ phrase, count, savings });
-            }
-        }
-    }
-    // Sort by savings (descending) and take top entries
-    candidates.sort((a, b) => b.savings - a.savings);
-    const topCandidates = candidates.slice(0, MAX_ENTRIES);
-    // Build codebook
-    const codebook = {};
-    topCandidates.forEach((c, i) => {
-        const code = `${CODE_PREFIX}${String(i + 1).padStart(2, "0")}`;
-        codebook[code] = c.phrase;
-    });
-    return codebook;
-}
-/**
- * Escape special regex characters.
- */
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/**
- * Apply dynamic codebook to messages.
- */
-export function applyDynamicCodebook(messages) {
-    // Build codebook from content
-    const codebook = buildDynamicCodebook(messages);
-    if (Object.keys(codebook).length === 0) {
-        return {
-            messages,
-            charsSaved: 0,
-            dynamicCodes: {},
-            substitutions: 0,
-        };
-    }
-    // Create inverse map for replacement
-    const phraseToCode = {};
-    for (const [code, phrase] of Object.entries(codebook)) {
-        phraseToCode[phrase] = code;
-    }
-    // Sort phrases by length (longest first) to avoid partial replacements
-    const sortedPhrases = Object.keys(phraseToCode).sort((a, b) => b.length - a.length);
-    let charsSaved = 0;
-    let substitutions = 0;
-    // Apply replacements
-    const result = messages.map((msg) => {
-        if (!msg.content || typeof msg.content !== "string")
-            return msg;
-        let content = msg.content;
-        for (const phrase of sortedPhrases) {
-            const code = phraseToCode[phrase];
-            const regex = new RegExp(escapeRegex(phrase), "g");
-            const matches = content.match(regex);
-            if (matches) {
-                content = content.replace(regex, code);
-                charsSaved += (phrase.length - code.length) * matches.length;
-                substitutions += matches.length;
-            }
-        }
-        return { ...msg, content };
-    });
-    return {
-        messages: result,
-        charsSaved,
-        dynamicCodes: codebook,
-        substitutions,
-    };
-}
-/**
- * Generate header for dynamic codes (to include in system message).
- */
-export function generateDynamicCodebookHeader(codebook) {
-    if (Object.keys(codebook).length === 0)
-        return "";
-    const entries = Object.entries(codebook)
-        .slice(0, 20) // Limit header size
-        .map(([code, phrase]) => {
-        // Truncate long phrases in header
-        const displayPhrase = phrase.length > 40 ? phrase.slice(0, 37) + "..." : phrase;
-        return `${code}=${displayPhrase}`;
-    })
-        .join(", ");
-    return `[DynDict: ${entries}]`;
-}

package/dist/compression/layers/json-compact.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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%
- */
-import { NormalizedMessage } from "../types.js";
-export interface JsonCompactResult {
-    messages: NormalizedMessage[];
-    charsSaved: number;
-}
-/**
- * Apply JSON compaction to all messages.
- *
- * Targets:
- * - tool_call arguments (in assistant messages)
- * - tool message content (often JSON)
- */
-export declare function compactMessagesJson(messages: NormalizedMessage[]): JsonCompactResult;

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

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

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

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

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

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

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

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

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