squeezr-ai 1.81.2 → 1.99.2

package/dist/compressor.js

@@ -206,10 +206,12 @@ async function compressWithGptMini(text, apiKey, extra) {
     return resp.choices[0].message.content ?? '';
 }
 async function compressWithGeminiFlash(text, apiKey, extra) {
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_FLASH_MODEL}:generateContent?key=${apiKey}`;
+    // Pass the key in the x-goog-api-key header, never in the URL query string:
+    // URLs leak into logs, proxies and error traces where a secret must not appear.
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_FLASH_MODEL}:generateContent`;
     const resp = await fetch(url, {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', 'x-goog-api-key': apiKey },
         body: JSON.stringify({
             contents: [{ role: 'user', parts: [{ text: `${promptWith(extra)}\n\n---\n${text.slice(0, OLLAMA_SAFE_INPUT)}` }] }],
         }),
@@ -663,6 +665,25 @@ function buildAnthropicToolIdMap(messages) {
     }
     return { nameMap, skipIds };
 }
+// Most recent user-typed text across the conversation (skips tool-result-only turns),
+// used as the relevance query for deterministic crushing. Capped so it stays cheap.
+function lastUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'user')
+            continue;
+        if (typeof m.content === 'string')
+            return m.content.slice(0, 2000);
+        if (Array.isArray(m.content)) {
+            const texts = m.content
+                .filter(b => b && b.type === 'text' && typeof b.text === 'string')
+                .map(b => b.text);
+            if (texts.length > 0)
+                return texts.join(' ').slice(0, 2000);
+        }
+    }
+    return '';
+}
 export async function compressAnthropicMessages(messages, apiKey, config, systemExtraChars = 0) {
     if (config.disabled)
         return [messages, emptySavings()];
@@ -792,12 +813,19 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     // changes every turn = cache miss = the 2026-06-04 over-bill). One cache miss
     // happens the first time the level changes; stable forever after.
     const DET_PRESSURE = 0;
+    // BM25 relevance in the deterministic pass is QUERY-dependent → it changes when the
+    // user's task changes. That is ONLY cache-safe where the output is not part of a
+    // byte-stable cached prefix. So we feed a query ONLY when there are NO cache markers
+    // (non-caching clients); for cache-marker clients (Claude Code) query = '' keeps the
+    // pass byte-identical between requests. (Relevance for the cached path needs per-block
+    // content-hash freezing — a follow-up.)
+    const detQuery = hasCacheMarkers ? '' : lastUserText(messages);
     const detT0 = Date.now();
     let detSaved = 0;
     for (const { index, subIndex, text, tool } of allResults) {
         if (dedupedSet.has(`${index}:${subIndex}`))
             continue; // already replaced by dedup
-        const det = preprocessForTool(text, tool, DET_PRESSURE);
+        const det = preprocessForTool(text, tool, DET_PRESSURE, detQuery);
         if (det !== text) {
             ;
             msgs[index].content[subIndex].content = det;
@@ -886,7 +914,17 @@ export async function compressAnthropicMessages(messages, apiKey, config, system
     // Write's content. These are huge and previously unprocessed. Skip the most
     // recent N assistant turns (`keepRecentAssistant`) so the live tool call
     // stays intact.
-    if (config.compressConversation) {
+    //
+    // DEFAULT OFF (compressToolInputs = false). Unlike tool RESULTS, tool INPUTS are
+    // model-authored code that must survive verbatim: Write.content is written to disk
+    // byte-for-byte, and Edit.old_string must byte-match the file for the edit to apply.
+    // The deterministic pipeline (line dedup, whitespace collapse+trim, JSON minify,
+    // timestamp strip) mutates those bytes. Because Squeezr rewrites history, the model
+    // then sees its OWN past Write as "body: ... [repeated 4 more times]" with dropped
+    // braces/`>`, and propagates that corruption to disk on the next edit. Old-turn
+    // bloat is reclaimed safely by stale_turns (whole-turn collapse) instead. Opt back
+    // in with compression.compress_tool_inputs = true only if you accept that risk.
+    if (config.compressConversation && config.compressToolInputs) {
         const toolUses = extractAnthropicAssistantToolUses(msgs, config.keepRecentAssistant);
         let tuSaved = 0;
         let tuCount = 0;

package/dist/config.d.ts

@@ -9,6 +9,7 @@ export declare class Config {
     readonly aiCompression: boolean;
     readonly compressSystemPrompt: boolean;
     readonly compressConversation: boolean;
+    readonly compressToolInputs: boolean;
     readonly captureRequests: boolean;
     readonly captureLimit: number;
     readonly staleTurns: boolean;
@@ -42,6 +43,11 @@ export declare class Config {
     readonly localUpstreamUrl: string;
     readonly localCompressionModel: string;
     readonly localDummyKeys: Set<string>;
+    readonly outputShaperEnabled: boolean;
+    readonly outputVerbositySteering: boolean;
+    readonly outputLevel: 1 | 2 | 3 | 4;
+    readonly outputEffortRouting: boolean;
+    readonly outputMechanicalThinkingFloor: number;
     constructor();
     thresholdForPressure(pressure: number): number;
     shouldSkipTool(toolName: string): boolean;

package/dist/config.js

@@ -87,6 +87,7 @@ export class Config {
     aiCompression;
     compressSystemPrompt;
     compressConversation;
+    compressToolInputs;
     captureRequests;
     captureLimit;
     staleTurns;
@@ -120,6 +121,11 @@ export class Config {
     localUpstreamUrl;
     localCompressionModel;
     localDummyKeys;
+    outputShaperEnabled;
+    outputVerbositySteering;
+    outputLevel;
+    outputEffortRouting;
+    outputMechanicalThinkingFloor;
     constructor() {
         const t = loadToml();
         const p = t.proxy ?? {};
@@ -127,6 +133,7 @@ export class Config {
         const ca = t.cache ?? {};
         const ad = t.adaptive ?? {};
         const lo = t.local ?? {};
+        const ou = t.output ?? {};
         this.port = parseInt(env('SQUEEZR_PORT', String(p.port ?? 8080)));
         this.mitmPort = parseInt(env('SQUEEZR_MITM_PORT', String(p.mitm_port ?? this.port + 1)));
         this.threshold = parseInt(env('SQUEEZR_THRESHOLD', String(c.threshold ?? 800)));
@@ -140,6 +147,13 @@ export class Config {
         // compress_system_prompt also makes a Haiku call — gate it behind aiCompression too.
         this.compressSystemPrompt = (c.compress_system_prompt ?? true) && this.aiCompression;
         this.compressConversation = c.compress_conversation ?? true; // safe by default — only deterministic on assistant msgs
+        // Lossy-clean OLD tool_use INPUTS (Write.content, Edit.old/new_string, Bash.command).
+        // DEFAULT FALSE: these are model-authored code that round-trips to disk verbatim
+        // (Write) or must byte-match disk (Edit old_string). Running dedup/whitespace/JSON
+        // minify over them folded repeated lines into "... [repeated N more times]", dropped
+        // braces and JSX `>`, and .trim()'d file bodies — corruption that reached disk when
+        // the model later re-edited from its now-mangled view of its own past writes.
+        this.compressToolInputs = c.compress_tool_inputs ?? false;
         this.captureRequests = c.capture_requests ?? false;
         this.captureLimit = c.capture_limit ?? 20;
         this.staleTurns = c.stale_turns ?? true;
@@ -183,6 +197,17 @@ export class Config {
         this.localCompressionModel = env('SQUEEZR_LOCAL_MODEL', lo.compression_model ?? 'qwen2.5-coder:1.5b');
         const rawDummies = lo.dummy_keys ?? ['ollama', 'lm-studio', 'sk-no-key-required', 'local', 'none', ''];
         this.localDummyKeys = new Set(rawDummies.map(k => k.toLowerCase()));
+        // Output-side token reduction. DEFAULT OFF — opt-in, like all levers that
+        // reshape behaviour rather than just clean tool output. Enable via TOML
+        // [output] enabled = true, or env SQUEEZR_OUTPUT_SHAPER=1. Both sub-levers
+        // (verbosity steering, effort routing) default ON once the master is on.
+        this.outputShaperEnabled =
+            env('SQUEEZR_OUTPUT_SHAPER', '') === '1' || env('SQUEEZR_OUTPUT_SHAPER', '') === 'true' || (ou.enabled ?? false);
+        this.outputVerbositySteering = ou.verbosity_steering ?? true;
+        const lvl = ou.level ?? 2;
+        this.outputLevel = (lvl >= 1 && lvl <= 4 ? lvl : 2);
+        this.outputEffortRouting = ou.effort_routing ?? true;
+        this.outputMechanicalThinkingFloor = ou.mechanical_thinking_floor ?? 1024;
     }
     thresholdForPressure(pressure) {
         if (!this.adaptiveEnabled)

package/dist/contentRouter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Content router — extends the JSON crusher's reach from "the WHOLE tool result is a JSON
+ * array" to "a JSON array appears ANYWHERE inside the tool result". Squeezr's take on the
+ * routing idea behind headroom's ContentRouter.
+ *
+ * A lot of structured data arrives wrapped: `gh api` with a status line, an MCP tool that
+ * returns a labelled envelope, a bash command that echoes a header then the JSON. Before,
+ * jsonCrush only fired on a pure-JSON result, so those were missed. This locates embedded
+ * arrays-of-objects and crushes each in place, leaving the surrounding text untouched.
+ *
+ * Safety: candidate spans are found by balanced-bracket scanning (string/escape aware),
+ * but the real safety net is that each span is handed to crushJsonArrays, which JSON.parses
+ * it — a false-positive span that isn't valid JSON simply doesn't crush and is left verbatim.
+ * Deterministic → cache-safe. Each crushed span is self-recoverable via its own expand id.
+ */
+import { TABLE_MARKER_RE } from './jsonCrush.js';
+export { TABLE_MARKER_RE };
+/** Non-overlapping, top-level spans of `[ {...`-style arrays (arrays of objects). */
+export declare function findObjectArraySpans(text: string): Array<{
+    start: number;
+    end: number;
+}>;
+/**
+ * Crush every embedded array-of-objects in `text`, splicing each crushed table back in and
+ * leaving the surrounding text verbatim. Returns the new text and total chars saved.
+ */
+export declare function crushEmbeddedJson(text: string): {
+    text: string;
+    savedChars: number;
+};

package/dist/contentRouter.js

@@ -0,0 +1,112 @@
+/**
+ * Content router — extends the JSON crusher's reach from "the WHOLE tool result is a JSON
+ * array" to "a JSON array appears ANYWHERE inside the tool result". Squeezr's take on the
+ * routing idea behind headroom's ContentRouter.
+ *
+ * A lot of structured data arrives wrapped: `gh api` with a status line, an MCP tool that
+ * returns a labelled envelope, a bash command that echoes a header then the JSON. Before,
+ * jsonCrush only fired on a pure-JSON result, so those were missed. This locates embedded
+ * arrays-of-objects and crushes each in place, leaving the surrounding text untouched.
+ *
+ * Safety: candidate spans are found by balanced-bracket scanning (string/escape aware),
+ * but the real safety net is that each span is handed to crushJsonArrays, which JSON.parses
+ * it — a false-positive span that isn't valid JSON simply doesn't crush and is left verbatim.
+ * Deterministic → cache-safe. Each crushed span is self-recoverable via its own expand id.
+ */
+import { crushJsonArrays, TABLE_MARKER_RE } from './jsonCrush.js';
+export { TABLE_MARKER_RE };
+/** Scan from an opening '[' to its matching ']' (exclusive end), string/escape aware.
+ *  Returns -1 if unbalanced. */
+function scanArray(text, start) {
+    let depth = 0;
+    let inStr = false;
+    for (let i = start; i < text.length; i++) {
+        const c = text[i];
+        if (inStr) {
+            if (c === '\\') {
+                i++;
+                continue;
+            }
+            if (c === '"')
+                inStr = false;
+            continue;
+        }
+        if (c === '"') {
+            inStr = true;
+            continue;
+        }
+        if (c === '[')
+            depth++;
+        else if (c === ']') {
+            depth--;
+            if (depth === 0)
+                return i + 1;
+        }
+    }
+    return -1;
+}
+/** Non-overlapping, top-level spans of `[ {...`-style arrays (arrays of objects). */
+export function findObjectArraySpans(text) {
+    const spans = [];
+    const n = text.length;
+    let i = 0;
+    let inStr = false;
+    while (i < n) {
+        const c = text[i];
+        if (inStr) {
+            if (c === '\\') {
+                i += 2;
+                continue;
+            }
+            if (c === '"')
+                inStr = false;
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            inStr = true;
+            i++;
+            continue;
+        }
+        if (c === '[') {
+            // peek past whitespace for '{' → array of objects
+            let j = i + 1;
+            while (j < n && /\s/.test(text[j]))
+                j++;
+            if (text[j] === '{') {
+                const end = scanArray(text, i);
+                if (end > i) {
+                    spans.push({ start: i, end });
+                    i = end;
+                    continue;
+                }
+            }
+        }
+        i++;
+    }
+    return spans;
+}
+/**
+ * Crush every embedded array-of-objects in `text`, splicing each crushed table back in and
+ * leaving the surrounding text verbatim. Returns the new text and total chars saved.
+ */
+export function crushEmbeddedJson(text) {
+    const spans = findObjectArraySpans(text);
+    if (spans.length === 0)
+        return { text, savedChars: 0 };
+    let out = '';
+    let last = 0;
+    let saved = 0;
+    for (const { start, end } of spans) {
+        out += text.slice(last, start);
+        const sub = text.slice(start, end);
+        const crushed = crushJsonArrays(sub);
+        out += crushed.text;
+        saved += crushed.savedChars;
+        last = end;
+    }
+    out += text.slice(last);
+    if (saved <= 0)
+        return { text, savedChars: 0 };
+    return { text: out, savedChars: saved };
+}