squeezr-ai 1.90.0 → 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;

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 };
+}