@cgh567/agent 2.4.1 → 2.4.2

package/lib/compression/dist/ccr-store.js

@@ -0,0 +1,74 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CcrStore = void 0;
+exports.getCcrStore = getCcrStore;
+class CcrStore {
+    store = new Map();
+    ttlMs;
+    cleanupInterval = null;
+    constructor(ttlSeconds = 7200) {
+        this.ttlMs = ttlSeconds * 1000;
+        // Cleanup every 10 minutes
+        this.cleanupInterval = setInterval(() => this._cleanup(), 10 * 60 * 1000);
+        // Don't hold the event loop open
+        if (this.cleanupInterval.unref)
+            this.cleanupInterval.unref();
+    }
+    set(hash, data) {
+        this.store.set(hash, {
+            data,
+            expiresAt: Date.now() + this.ttlMs,
+            originalBytes: data.length,
+        });
+    }
+    get(hash) {
+        const entry = this.store.get(hash);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(hash);
+            return null;
+        }
+        return entry.data;
+    }
+    delete(hash) {
+        this.store.delete(hash);
+    }
+    has(hash) {
+        return this.get(hash) !== null;
+    }
+    stats() {
+        let totalOriginalBytes = 0;
+        const now = Date.now();
+        let entries = 0;
+        for (const [, entry] of this.store) {
+            if (now <= entry.expiresAt) {
+                totalOriginalBytes += entry.originalBytes;
+                entries++;
+            }
+        }
+        return { entries, totalOriginalBytes };
+    }
+    _cleanup() {
+        const now = Date.now();
+        for (const [hash, entry] of this.store) {
+            if (now > entry.expiresAt)
+                this.store.delete(hash);
+        }
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.store.clear();
+    }
+}
+exports.CcrStore = CcrStore;
+// Singleton for the daemon process
+let _singleton = null;
+function getCcrStore(ttlSeconds = 7200) {
+    if (!_singleton)
+        _singleton = new CcrStore(ttlSeconds);
+    return _singleton;
+}

package/lib/compression/dist/content-router.js

@@ -0,0 +1,115 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentRouter = void 0;
+exports.detectContentType = detectContentType;
+/**
+ * lib/compression/content-router.ts
+ *
+ * ContentRouter: detects content type in a message block and routes to the
+ * appropriate compressor.
+ *
+ * Current compressors:
+ *   JSON_ARRAY    → SmartCrusher (70–92% reduction)
+ *   PLAIN_TEXT    → Passthrough (Kompress-base ML model not available in TS)
+ *   SOURCE_CODE   → Passthrough (CodeCompressor not yet implemented)
+ *   other         → Passthrough
+ *
+ * The passthrough path is correct behavior — we improve compression as we
+ * add more compressors. SmartCrusher alone covers the dominant HBO payload
+ * type (arrays of lead/signal/task/goal objects).
+ *
+ * Protection rules (content never compressed):
+ *   - User messages (content might be misinterpreted if rewritten)
+ *   - Error outputs ≤ 8000 chars (must be preserved exactly)
+ *   - Tool outputs named 'headroom_retrieve' (infinite loop prevention)
+ *   - Content shorter than 500 chars (overhead > savings)
+ */
+const smart_crusher_js_1 = require("./smart-crusher.js");
+const CHARS_PER_TOKEN = 3.5; // Claude/Bedrock heuristic
+function estimateTokens(s) {
+    return Math.ceil(s.length / CHARS_PER_TOKEN);
+}
+/**
+ * Detect content type from a string block.
+ */
+function detectContentType(text) {
+    const trimmed = text.trim();
+    // JSON array: starts with [
+    if (trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed))
+                return 'JSON_ARRAY';
+        }
+        catch { /* not valid JSON */ }
+    }
+    // JSON object: starts with {
+    if (trimmed.startsWith('{')) {
+        try {
+            JSON.parse(trimmed);
+            return 'JSON_OBJECT';
+        }
+        catch { /* not valid JSON */ }
+    }
+    // Source code heuristics (backtick code blocks, common keywords)
+    if (trimmed.startsWith('```') ||
+        trimmed.includes('\ndef ') ||
+        trimmed.includes('\nfunction ') ||
+        trimmed.includes('\nconst ') ||
+        trimmed.includes('\nclass ') ||
+        trimmed.includes('\nimport ')) {
+        return 'SOURCE_CODE';
+    }
+    return 'PLAIN_TEXT';
+}
+class ContentRouter {
+    crusher;
+    constructor(crusherConfig = {}) {
+        this.crusher = new smart_crusher_js_1.SmartCrusher(crusherConfig);
+    }
+    /**
+     * Route a single text block to the appropriate compressor.
+     * Returns the (possibly compressed) text plus metadata.
+     */
+    route(text, toolId, ccrStore) {
+        const passthrough = {
+            output: text,
+            contentType: 'UNKNOWN',
+            strategy: 'passthrough',
+            compressed: false,
+            ccrHash: null,
+            tokensSaved: 0,
+            rowsDropped: 0,
+        };
+        // Protection: too short
+        if (text.length < 500)
+            return passthrough;
+        // Protection: never re-compress CCR retrieve results
+        if (toolId === 'headroom_retrieve')
+            return passthrough;
+        // Protection: small error outputs
+        if (text.length <= 8000 &&
+            (text.toLowerCase().includes('"error"') || text.toLowerCase().includes('"traceback"'))) {
+            return passthrough;
+        }
+        const contentType = detectContentType(text);
+        switch (contentType) {
+            case 'JSON_ARRAY': {
+                const result = this.crusher.compress(text, ccrStore);
+                const tokensSaved = estimateTokens(text) - estimateTokens(result.output);
+                return {
+                    output: result.output,
+                    contentType,
+                    strategy: result.strategy,
+                    compressed: result.compressed,
+                    ccrHash: result.ccrHash,
+                    tokensSaved: Math.max(0, tokensSaved),
+                    rowsDropped: result.rowsDropped,
+                };
+            }
+            default:
+                return { ...passthrough, contentType };
+        }
+    }
+}
+exports.ContentRouter = ContentRouter;

package/lib/compression/dist/pipeline.js

@@ -0,0 +1,113 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionPipeline = void 0;
+/**
+ * lib/compression/pipeline.ts
+ *
+ * Message compression pipeline.
+ *
+ * Processes a messages array (Anthropic or OpenAI format) through the
+ * ContentRouter for each tool_result block.
+ *
+ * The pipeline mirrors what the headroom Python proxy does:
+ *   1. Skip system messages (cache prefix must stay stable)
+ *   2. Skip user messages (content must be preserved)
+ *   3. For each assistant + tool_result message: run ContentRouter
+ *   4. Collect total tokens saved and CCR hashes
+ *
+ * This runs inside the helios-agent daemon process — no HTTP round-trip.
+ * Every company's HBO tool results (signals, leads, pipeline, tasks) are
+ * compressed before they reach the LLM.
+ */
+const content_router_js_1 = require("./content-router.js");
+/**
+ * Deep-copy a messages array (shallow copy of each message, deep copy of
+ * content arrays so we don't mutate the caller's data).
+ */
+function deepCopyMessages(messages) {
+    return messages.map((msg) => ({
+        ...msg,
+        content: Array.isArray(msg.content)
+            ? msg.content.map((b) => ({ ...b }))
+            : msg.content,
+    }));
+}
+function extractText(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    for (const block of content) {
+        if (typeof block.content === 'string')
+            return block.content;
+        if (typeof block.text === 'string')
+            return block.text;
+    }
+    return '';
+}
+function originalLength(messages) {
+    return JSON.stringify(messages).length;
+}
+class CompressionPipeline {
+    router;
+    constructor() {
+        this.router = new content_router_js_1.ContentRouter();
+    }
+    /**
+     * Compress a messages array.
+     *
+     * Compresses tool_result blocks in ALL messages (user and assistant).
+     * In Anthropic format, tool_result blocks appear in user messages (they
+     * are the response to the assistant's tool_use calls). These are the
+     * dominant source of large payloads — HBO signals, leads, pipeline data.
+     *
+     * What we do NOT compress:
+     *   - Plain text content in user messages (user intent must be preserved)
+     *   - System messages (prompt cache stability)
+     *   - Anything shorter than 500 chars
+     */
+    compress(messages, ccrStore) {
+        const origLen = originalLength(messages);
+        const copied = deepCopyMessages(messages);
+        let totalTokensSaved = 0;
+        const ccrHashes = [];
+        const transformsApplied = new Set();
+        for (const msg of copied) {
+            // Skip system messages (preserve prompt cache prefix exactly)
+            if (msg.role === 'system')
+                continue;
+            if (!Array.isArray(msg.content))
+                continue;
+            for (const block of msg.content) {
+                // Only process tool_result blocks — this is where HBO data lives
+                // (tool_result appears in user messages in Anthropic format)
+                if (block.type !== 'tool_result')
+                    continue;
+                const text = typeof block.content === 'string'
+                    ? block.content
+                    : extractText(block.content);
+                if (!text)
+                    continue;
+                const toolId = block.tool_use_id;
+                const result = this.router.route(text, toolId, ccrStore);
+                if (result.compressed) {
+                    block.content = result.output;
+                    totalTokensSaved += result.tokensSaved;
+                    transformsApplied.add(result.strategy);
+                    if (result.ccrHash)
+                        ccrHashes.push(result.ccrHash);
+                }
+            }
+        }
+        const newLen = originalLength(copied);
+        const compressionRatio = origLen > 0 ? newLen / origLen : 1;
+        return {
+            messages: copied,
+            tokensSaved: totalTokensSaved,
+            ccrHashes,
+            compressionRatio,
+            transformsApplied: [...transformsApplied],
+        };
+    }
+}
+exports.CompressionPipeline = CompressionPipeline;

package/lib/compression/dist/server.js

@@ -0,0 +1,265 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompressionServer = createCompressionServer;
+/**
+ * lib/compression/server.ts
+ *
+ * Helios Compression Server — TypeScript implementation of the Headroom proxy
+ * HTTP interface.
+ *
+ * Replaces the Python headroom proxy entirely. Starts in milliseconds (no ML
+ * model loading), works natively on Windows and macOS.
+ *
+ * Endpoints (headroom proxy compatible):
+ *   GET  /health                         → { status, version, uptime }
+ *   GET  /stats                          → compression statistics
+ *   POST /v1/messages                    → compress Anthropic message array
+ *   POST /v1/chat/completions            → compress OpenAI message array
+ *   GET  /v1/retrieve/:hash              → retrieve original CCR content
+ *   POST /headroom/compress              → direct compress endpoint
+ *
+ * All endpoints are cross-company — there is no tenant scoping in the
+ * compression layer. Compression is a pure function of content shape,
+ * not company identity.
+ */
+const http_1 = __importDefault(require("http"));
+const pipeline_js_1 = require("./pipeline.js");
+const ccr_store_js_1 = require("./ccr-store.js");
+const VERSION = '1.0.0-helios';
+const startedAt = Date.now();
+// Singleton pipeline and CCR store
+const pipeline = new pipeline_js_1.CompressionPipeline();
+const ccrStore = (0, ccr_store_js_1.getCcrStore)(7200);
+// Compression telemetry (process-lifetime counters)
+const stats = {
+    requests: { total: 0, compressed: 0, passthrough: 0, failed: 0 },
+    tokens: { saved: 0 },
+    ccrStore: { puts: 0 },
+};
+// ── HTTP helpers ──────────────────────────────────────────────────────────────
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'X-Headroom-Version': VERSION,
+    });
+    res.end(payload);
+}
+function error(res, status, message) {
+    json(res, status, { error: message });
+}
+// ── Route handlers ────────────────────────────────────────────────────────────
+function handleHealth(_req, res) {
+    json(res, 200, {
+        status: 'healthy',
+        version: VERSION,
+        uptime: (Date.now() - startedAt) / 1000,
+        available: true,
+    });
+}
+function handleStats(_req, res) {
+    const ccrStats = ccrStore.stats();
+    json(res, 200, {
+        available: true,
+        requests: stats.requests,
+        tokens: {
+            saved: stats.tokens.saved,
+            savingsPercent: stats.requests.total > 0
+                ? Math.round((stats.tokens.saved / Math.max(stats.tokens.saved + (stats.requests.total * 100), 1)) * 100)
+                : 0,
+        },
+        ccr: {
+            items: ccrStats.entries,
+            totalOriginalBytes: ccrStats.totalOriginalBytes,
+        },
+        uptime: (Date.now() - startedAt) / 1000,
+    });
+}
+async function handleCompressMessages(req, res) {
+    stats.requests.total++;
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        stats.requests.failed++;
+        return error(res, 400, 'Invalid JSON body');
+    }
+    const messages = body.messages;
+    if (!Array.isArray(messages)) {
+        // Not a messages request — passthrough
+        stats.requests.passthrough++;
+        json(res, 200, body);
+        return;
+    }
+    try {
+        const result = pipeline.compress(messages, ccrStore);
+        stats.tokens.saved += result.tokensSaved;
+        if (result.ccrHashes.length > 0)
+            stats.ccrStore.puts += result.ccrHashes.length;
+        if (result.transformsApplied.length > 0) {
+            stats.requests.compressed++;
+        }
+        else {
+            stats.requests.passthrough++;
+        }
+        // Return in same shape as input, with compressed messages
+        const responseBody = {
+            ...body,
+            messages: result.messages,
+        };
+        // Attach headroom metadata in response headers
+        res.setHeader('X-Headroom-Saved', String(result.tokensSaved));
+        res.setHeader('X-Headroom-Ratio', result.compressionRatio.toFixed(3));
+        if (result.ccrHashes.length > 0) {
+            res.setHeader('X-Headroom-CCR', result.ccrHashes.join(','));
+        }
+        if (result.transformsApplied.length > 0) {
+            res.setHeader('X-Headroom-Transforms', result.transformsApplied.join(','));
+        }
+        json(res, 200, responseBody);
+    }
+    catch (e) {
+        stats.requests.failed++;
+        const msg = e instanceof Error ? e.message : String(e);
+        error(res, 500, `Compression failed: ${msg}`);
+    }
+}
+async function handleDirectCompress(req, res) {
+    stats.requests.total++;
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        stats.requests.failed++;
+        return error(res, 400, 'Invalid JSON body');
+    }
+    const messages = body.messages;
+    if (!Array.isArray(messages)) {
+        stats.requests.passthrough++;
+        json(res, 200, { messages: body, tokensSaved: 0, compressionRatio: 1, transformsApplied: [], ccrHashes: [] });
+        return;
+    }
+    try {
+        const result = pipeline.compress(messages, ccrStore);
+        stats.tokens.saved += result.tokensSaved;
+        if (result.ccrHashes.length > 0)
+            stats.ccrStore.puts += result.ccrHashes.length;
+        if (result.transformsApplied.length > 0)
+            stats.requests.compressed++;
+        else
+            stats.requests.passthrough++;
+        json(res, 200, {
+            messages: result.messages,
+            tokensSaved: result.tokensSaved,
+            compressionRatio: result.compressionRatio,
+            transformsApplied: result.transformsApplied,
+            ccrHashes: result.ccrHashes,
+        });
+    }
+    catch (e) {
+        stats.requests.failed++;
+        const msg = e instanceof Error ? e.message : String(e);
+        error(res, 500, `Compression failed: ${msg}`);
+    }
+}
+function handleRetrieve(_req, res, hash) {
+    if (!hash || !/^[a-f0-9]{8,64}$/.test(hash)) {
+        return error(res, 400, 'Invalid hash format');
+    }
+    const data = ccrStore.get(hash);
+    if (!data) {
+        return error(res, 404, `CCR hash not found or expired: ${hash}`);
+    }
+    json(res, 200, {
+        hash,
+        data: JSON.parse(data),
+        originalBytes: data.length,
+    });
+}
+// ── Server ────────────────────────────────────────────────────────────────────
+function createCompressionServer() {
+    return http_1.default.createServer(async (req, res) => {
+        const url = req.url ?? '/';
+        const method = req.method ?? 'GET';
+        // CORS preflight
+        if (method === 'OPTIONS') {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization, x-api-key, anthropic-version',
+            });
+            res.end();
+            return;
+        }
+        try {
+            // Health
+            if (url === '/health' || url === '/livez' || url === '/readyz') {
+                return handleHealth(req, res);
+            }
+            // Stats
+            if (url === '/stats' || url === '/metrics') {
+                return handleStats(req, res);
+            }
+            // Direct compress (used by helios-agent internals and context-compaction.ts)
+            if (url === '/headroom/compress' && method === 'POST') {
+                return await handleDirectCompress(req, res);
+            }
+            // headroom-ai SDK compress endpoint — the SDK calls POST /v1/compress
+            // with { messages, model, config } and expects the same shape back.
+            // We map this to handleDirectCompress which is identical in behavior.
+            if (url === '/v1/compress' && method === 'POST') {
+                return await handleDirectCompress(req, res);
+            }
+            // Anthropic messages endpoint (intercept + compress)
+            if (url === '/v1/messages' && method === 'POST') {
+                return await handleCompressMessages(req, res);
+            }
+            // OpenAI chat completions endpoint (intercept + compress)
+            if (url === '/v1/chat/completions' && method === 'POST') {
+                return await handleCompressMessages(req, res);
+            }
+            // CCR retrieval
+            const ccrMatch = url.match(/^\/v1\/retrieve\/([a-f0-9]{8,64})$/);
+            if (ccrMatch && method === 'GET') {
+                return handleRetrieve(req, res, ccrMatch[1]);
+            }
+            // 404
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Unknown endpoint: ${method} ${url}` }));
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Server error: ${msg}` }));
+        }
+    });
+}
+// ── Standalone entry point ────────────────────────────────────────────────────
+if (require.main === module) {
+    const port = parseInt(process.env.HEADROOM_PORT ?? '8787', 10);
+    const server = createCompressionServer();
+    server.listen(port, '127.0.0.1', () => {
+        process.stdout.write(JSON.stringify({ event: 'ready', port, version: VERSION }) + '\n');
+    });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            process.stderr.write(`[compression-server] Port ${port} already in use\n`);
+            process.exit(1);
+        }
+        throw err;
+    });
+}