squeezr-ai 1.81.2 → 1.99.2

package/dist/server.js

@@ -13,6 +13,29 @@ import { isAiCompressionEnabled, setAiCompression, toggleAiCompression } from '.
 import { circuitBreaker } from './circuitBreaker.js';
 import { injectExpandToolAnthropic, injectExpandToolOpenAI, injectExpandDirectiveAnthropic, injectExpandDirectiveOpenAI, handleAnthropicExpandCall, handleOpenAIExpandCall, retrieveOriginal, expandStoreSize, EXPAND_TOOL_ANTHROPIC_CHARS, } from './expand.js';
 import { compressSystemPrompt } from './systemPrompt.js';
+import { shapeRequest } from './outputShaper.js';
+import { warnIfVolatile } from './cacheAligner.js';
+import { echoRatio, extractAssistantTextFromSse, extractAssistantTextFromContent } from './outputSavings.js';
+// Concatenated text the model saw (capped), used as the echo-measurement context.
+function contextTextForEcho(messages) {
+    let out = '';
+    for (const m of messages) {
+        const c = m?.content;
+        if (typeof c === 'string')
+            out += c + '\n';
+        else if (Array.isArray(c)) {
+            for (const b of c) {
+                if (typeof b?.text === 'string')
+                    out += b.text + '\n';
+                else if (typeof b?.content === 'string')
+                    out += b.content + '\n';
+            }
+        }
+        if (out.length > 40000)
+            break;
+    }
+    return out;
+}
 import { captureRequest } from './requestCapture.js';
 import { dedupSkillBlocks } from './skillDedup.js';
 import { collapseStaleTurns } from './staleTurns.js';
@@ -199,20 +222,48 @@ async function proxyStream(upstream, body, headers, params) {
     });
 }
 export const app = new Hono();
-// ── CORS middleware (required for Cursor IDE and browser-based tools) ─────────
-// Cursor's Electron renderer sends OPTIONS preflight before every POST.
-// Without this the request is blocked and Cursor shows a network error.
+// ── CORS + CSRF guard middleware ─────────────────────────────────────────────
+// Cursor's Electron renderer sends OPTIONS preflight before every POST, so the
+// proxy endpoints (/v1, /v1beta) stay permissive for browser-based IDE tooling.
+// The control endpoints (/squeezr/*) are different: they change state and the
+// process holds the user's API keys, so they must NOT be reachable cross-origin.
+// Combined with the loopback bind, this kills the CSRF/DoS vector where a page
+// open in the user's browser POSTs to http://localhost:<port>/squeezr/control/*.
+// Only browser origins on loopback may touch the control endpoints.
+const LOOPBACK_ORIGIN = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i;
+const isLoopbackOrigin = (origin) => origin !== undefined && LOOPBACK_ORIGIN.test(origin);
 app.use('*', async (c, next) => {
+    const origin = c.req.header('origin');
+    const isControl = c.req.path.startsWith('/squeezr/');
+    const isMutation = !['GET', 'HEAD', 'OPTIONS'].includes(c.req.method);
+    // CSRF guard: a state-changing request to a control endpoint that carries a
+    // non-loopback browser Origin is a cross-site attack — reject it. Requests
+    // without an Origin (curl, MCP, native clients over loopback) are allowed;
+    // the loopback bind already limits those to processes on this machine.
+    if (isControl && isMutation && origin !== undefined && !isLoopbackOrigin(origin)) {
+        return c.json({ error: 'forbidden: cross-origin control request rejected' }, 403);
+    }
+    // CORS: control endpoints reflect ONLY loopback origins (never wildcard, so a
+    // malicious page cannot read control/state responses). Proxy endpoints keep
+    // the permissive wildcard that Cursor and other browser tools need.
+    const allowOrigin = isControl ? (isLoopbackOrigin(origin) ? origin : '') : '*';
     if (c.req.method === 'OPTIONS') {
-        return c.body(null, 204, {
-            'Access-Control-Allow-Origin': '*',
+        const headers = {
             'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
             'Access-Control-Allow-Headers': '*',
             'Access-Control-Max-Age': '86400',
-        });
+        };
+        if (allowOrigin)
+            headers['Access-Control-Allow-Origin'] = allowOrigin;
+        if (isControl)
+            headers['Vary'] = 'Origin';
+        return c.body(null, 204, headers);
     }
     await next();
-    c.res.headers.set('Access-Control-Allow-Origin', '*');
+    if (allowOrigin)
+        c.res.headers.set('Access-Control-Allow-Origin', allowOrigin);
+    if (isControl)
+        c.res.headers.set('Vary', 'Origin');
     c.res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
     c.res.headers.set('Access-Control-Allow-Headers', '*');
 });
@@ -289,6 +340,10 @@ app.post('/v1/messages', async (c) => {
     }
     // Extract project name BEFORE compressing system prompt (compression destroys <cwd> tags)
     const project = extractProjectName(body);
+    // Cache-aligner (detector-only): if the CLIENT's system prompt embeds volatile tokens
+    // (UUID/timestamp/JWT/hash) they may bust Anthropic's prompt cache. Warns once per
+    // distinct signature; never mutates the prompt.
+    warnIfVolatile(body.system);
     const messages = (body.messages ?? []);
     // Measure FULL request (messages + tools + system) before ANY compression
     const originalRequestChars = estimateFullRequestChars(body);
@@ -309,10 +364,12 @@ app.post('/v1/messages', async (c) => {
             savings,
         });
     }
-    // Bypass mode: skip all compression, still record request stats
+    // Bypass mode: skip all compression. Do NOT record processed/saved/cost stats — Squeezr
+    // did nothing to this traffic, and counting it (as it did before) inflated "processed"
+    // and dragged the savings ratio / cost to ~0 after a day spent bypassed. Track it in a
+    // separate bypassed-only counter instead.
     if (isBypassed()) {
-        stats.recordWithProject(project, originalRequestChars, originalRequestChars, emptySavings(), undefined, clientId, modelId);
-        recordRequest(project, 0, 0, [], originalRequestChars);
+        stats.recordBypassed();
         storeKey('anthropic', apiKey);
         const fwdHeaders = forwardHeaders(c.req.raw.headers);
         if (body.stream) {
@@ -455,6 +512,23 @@ app.post('/v1/messages', async (c) => {
     // the highest-weight channel (tool description alone was observed to be ignored).
     // Cache-safe: appends a new trailing block, never mutates cache_control blocks.
     injectExpandDirectiveAnthropic(body);
+    // Output-side token reduction (opt-in). Verbosity steering appends a byte-stable
+    // block to the system tail (same cache-safe append as the expand directive);
+    // effort routing lowers an EXISTING thinking budget on mechanical continuations.
+    // Runs LAST so the trailing steering block is deterministic per request.
+    if (config.outputShaperEnabled) {
+        const shaped = shapeRequest(body, {
+            enabled: true,
+            verbositySteering: config.outputVerbositySteering,
+            level: config.outputLevel,
+            effortRouting: config.outputEffortRouting,
+            mechanicalThinkingFloor: config.outputMechanicalThinkingFloor,
+        });
+        stats.recordShaping(shaped.steered, shaped.effortLowered);
+        if (shaped.effortLowered || shaped.steered) {
+            console.log(`[squeezr/output-shaper] turn=${shaped.turn} steered=${shaped.steered} effort-lowered=${shaped.effortLowered}`);
+        }
+    }
     // Attach per-feature savings to the savings object for accurate breakdown reporting
     savings.toolDescSavedChars = toolDescSaved;
     savings.mcpFilterSavedChars = mcpFilterSaved;
@@ -486,6 +560,8 @@ app.post('/v1/messages', async (c) => {
             if (!SKIP_RESP_HEADERS.has(k.toLowerCase()))
                 c.header(k, v);
         }
+        const measureEcho = config.outputShaperEnabled;
+        let sseBuf = '';
         return stream(c, async (s) => {
             const reader = upstream.body.getReader();
             const decoder = new TextDecoder();
@@ -495,7 +571,18 @@ app.post('/v1/messages', async (c) => {
                 if (done)
                     break;
                 await s.write(value);
-                sseParser(decoder.decode(value, { stream: true }));
+                const chunk = decoder.decode(value, { stream: true });
+                sseParser(chunk);
+                if (measureEcho)
+                    sseBuf += chunk;
+            }
+            if (measureEcho) {
+                const outText = extractAssistantTextFromSse(sseBuf);
+                if (outText.length > 40) {
+                    const echo = echoRatio(outText, contextTextForEcho(body.messages));
+                    stats.recordEcho(echo);
+                    console.log(`[squeezr/output] echo=${Math.round(echo * 100)}% of assistant output restated existing context (${outText.length} chars)`);
+                }
             }
         });
     }
@@ -511,6 +598,14 @@ app.post('/v1/messages', async (c) => {
         const u = respBody.usage;
         addAnthropicUsage(u.input_tokens ?? 0, u.output_tokens ?? 0, u.cache_creation_input_tokens ?? 0, u.cache_read_input_tokens ?? 0);
     }
+    if (config.outputShaperEnabled) {
+        const outText = extractAssistantTextFromContent(respBody.content);
+        if (outText.length > 40) {
+            const echo = echoRatio(outText, contextTextForEcho(body.messages));
+            stats.recordEcho(echo);
+            console.log(`[squeezr/output] echo=${Math.round(echo * 100)}% of assistant output restated existing context (${outText.length} chars)`);
+        }
+    }
     // Handle expand() call if model requested one (track expand rate)
     const expandCall = handleAnthropicExpandCall(respBody);
     if (expandCall) {

package/dist/stats.d.ts

@@ -35,6 +35,16 @@ export declare class Stats {
     private expandHits;
     private expandMisses;
     private expandPartial;
+    private outputEchoSamples;
+    private outputEchoSum;
+    private outputSteered;
+    private outputEffortLowered;
+    /** Record one measured assistant response's echo ratio (0..1). */
+    recordEcho(echo: number): void;
+    /** Record one shaped request: whether verbosity steering was applied / effort was lowered. */
+    recordShaping(steered: boolean, effortLowered: boolean): void;
+    private bypassedRequests;
+    recordBypassed(): void;
     record(originalChars: number, compressedChars: number, savings: Savings, latency?: LatencyInfo, client?: string, model?: string): void;
     /** @deprecated Pass savings.syspromptSavedChars instead */
     recordSystemPromptSaved(originalLen: number, compressedLen: number): void;
@@ -65,6 +75,7 @@ export declare class Stats {
         current_project: string;
         last_original_chars: number;
         last_compressed_chars: number;
+        bypassed_requests: number;
         breakdown: {
             tool_results_det: number;
             tool_results_ai: number;
@@ -103,6 +114,12 @@ export declare class Stats {
                 last: number;
             };
         };
+        output: {
+            echo_samples: number;
+            avg_echo_pct: number;
+            steered: number;
+            effort_lowered: number;
+        };
         expand: {
             calls: number;
             hits: number;

package/dist/stats.js

@@ -75,6 +75,46 @@ export class Stats {
     expandMisses = Stats.persistedNum('expand_misses');
     // Partial expands = squeezr_expand("<id>~i") (recover one segment) vs whole-block.
     expandPartial = Stats.persistedNum('expand_partial');
+    // Output-side metrics (output shaper + echo). Persisted via the main persist() snapshot
+    // (no per-call disk write). echoSum is the running sum of echo ratios (0..1); avg = sum/samples.
+    outputEchoSamples = Stats.persistedNum('output_echo_samples');
+    outputEchoSum = Stats.persistedNum('output_echo_sum');
+    outputSteered = Stats.persistedNum('output_steered');
+    outputEffortLowered = Stats.persistedNum('output_effort_lowered');
+    /** Record one measured assistant response's echo ratio (0..1). */
+    recordEcho(echo) {
+        this.outputEchoSamples++;
+        this.outputEchoSum += echo;
+    }
+    /** Record one shaped request: whether verbosity steering was applied / effort was lowered. */
+    recordShaping(steered, effortLowered) {
+        if (steered)
+            this.outputSteered++;
+        if (effortLowered)
+            this.outputEffortLowered++;
+    }
+    // Requests that passed through while BYPASSED. Tracked separately and NEVER added to
+    // processed/saved/cost totals — bypass means Squeezr did nothing, so counting that
+    // traffic as "processed, 0 saved" would drag the ratio to ~0 and inflate cost (the
+    // "$7048 processed / $0.55 saved after a bypass day" confusion). Throttled persist to
+    // avoid disk thrash under heavy bypass traffic.
+    bypassedRequests = Stats.persistedNum('bypassed_requests');
+    recordBypassed() {
+        this.bypassedRequests++;
+        if (this.bypassedRequests % 25 === 0) {
+            try {
+                const dir = join(homedir(), '.squeezr');
+                if (!existsSync(dir))
+                    mkdirSync(dir, { recursive: true });
+                const existing = Stats.loadGlobal();
+                existing.bypassed_requests = this.bypassedRequests;
+                const tmp = STATS_FILE + '.tmp';
+                writeFileSync(tmp, JSON.stringify(existing));
+                renameSync(tmp, STATS_FILE);
+            }
+            catch { /* ignore */ }
+        }
+    }
     record(originalChars, compressedChars, savings, latency, client, model) {
         this.requests++;
         this.totalOriginalChars += originalChars;
@@ -218,6 +258,7 @@ export class Stats {
             current_project: this.currentProject,
             last_original_chars: this.lastOriginalChars,
             last_compressed_chars: this.lastCompressedChars,
+            bypassed_requests: this.bypassedRequests,
             // Savings breakdown for honest dashboard reporting
             breakdown: {
                 tool_results_det: this.totalDetSaved,
@@ -237,6 +278,16 @@ export class Stats {
                 deterministic: this.latencyDet.summary(),
                 ai: this.latencyAi.summary(),
             },
+            // Output-side metrics (output shaper). avg_echo_pct = mean % of assistant output
+            // that merely restated existing context (lower is better; steering targets it).
+            output: {
+                echo_samples: this.outputEchoSamples,
+                avg_echo_pct: this.outputEchoSamples > 0
+                    ? Math.round((this.outputEchoSum / this.outputEchoSamples) * 1000) / 10
+                    : 0,
+                steered: this.outputSteered,
+                effort_lowered: this.outputEffortLowered,
+            },
             // Expand rate — key quality metric (high = compression too aggressive)
             expand: {
                 calls: this.expandCalls,
@@ -318,6 +369,10 @@ export class Stats {
             existing.expand_hits = this.expandHits;
             existing.expand_misses = this.expandMisses;
             existing.expand_partial = this.expandPartial;
+            existing.output_echo_samples = this.outputEchoSamples;
+            existing.output_echo_sum = this.outputEchoSum;
+            existing.output_steered = this.outputSteered;
+            existing.output_effort_lowered = this.outputEffortLowered;
             // Local AI calls (Zest/Ollama) — persisted separately, not added to cost counters
             if (savings.localAiCalls != null && savings.localAiCalls > 0) {
                 existing.local_ai_calls = (existing.local_ai_calls ?? 0) + savings.localAiCalls;

package/dist/systemPrompt.js

@@ -81,10 +81,11 @@ export async function compressSystemPrompt(prompt, apiKey, backend) {
             compressed = resp.choices[0].message.content ?? prompt;
         }
         else if (backend === 'gemini-flash') {
-            const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-8b:generateContent?key=${apiKey}`;
+            // Key in the x-goog-api-key header, never in the URL query (URLs leak to logs).
+            const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-8b: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: input }] }] }),
             });
             const data = (await resp.json());

package/dist/textCrusher.d.ts

@@ -0,0 +1,35 @@
+/**
+ * TextCrusher — deterministic, cache-safe extractive compression for large PROSE/LOG
+ * blocks. Squeezr's take on headroom's TextCrusher (their fast, no-model alternative to
+ * the ML compressor).
+ *
+ * Exact line-dedup (already in the base pipeline) only catches byte-identical repeats.
+ * A huge share of log spam is NOT byte-identical — it's the same line with a different
+ * number, timestamp or hex id ("processed record 1 in 2ms", "…record 2 in 4ms", …).
+ * TextCrusher collapses those NEAR-duplicates by normalizing volatile tokens, while:
+ *
+ *   - always keeping high-signal lines (error/warn/fail/exception/…),
+ *   - always keeping head + tail anchor lines (context),
+ *   - preserving original order,
+ *   - staying fully deterministic → byte-stable → prompt-cache safe.
+ *
+ * It never drops content irrecoverably: callers wrap the result with makeRecoverable so
+ * the full original is one squeezr_expand away.
+ */
+export interface CrushTextOpts {
+    maxLines: number;
+    headKeep: number;
+    tailKeep: number;
+    query: string;
+}
+/** Collapse volatile tokens so near-duplicate lines share a key. */
+export declare function normalizeLineKey(line: string): string;
+/** Word 3-gram shingles of a line (falls back to the word set for short lines). */
+export declare function wordShingles(line: string, k?: number): Set<string>;
+export declare function jaccard(a: Set<string>, b: Set<string>): number;
+export interface CrushResult {
+    text: string;
+    kept: number;
+    dropped: number;
+}
+export declare function crushText(text: string, opts?: Partial<CrushTextOpts>): CrushResult;

package/dist/textCrusher.js

@@ -0,0 +1,160 @@
+/**
+ * TextCrusher — deterministic, cache-safe extractive compression for large PROSE/LOG
+ * blocks. Squeezr's take on headroom's TextCrusher (their fast, no-model alternative to
+ * the ML compressor).
+ *
+ * Exact line-dedup (already in the base pipeline) only catches byte-identical repeats.
+ * A huge share of log spam is NOT byte-identical — it's the same line with a different
+ * number, timestamp or hex id ("processed record 1 in 2ms", "…record 2 in 4ms", …).
+ * TextCrusher collapses those NEAR-duplicates by normalizing volatile tokens, while:
+ *
+ *   - always keeping high-signal lines (error/warn/fail/exception/…),
+ *   - always keeping head + tail anchor lines (context),
+ *   - preserving original order,
+ *   - staying fully deterministic → byte-stable → prompt-cache safe.
+ *
+ * It never drops content irrecoverably: callers wrap the result with makeRecoverable so
+ * the full original is one squeezr_expand away.
+ */
+const DEFAULTS = { maxLines: 60, headKeep: 5, tailKeep: 5, query: '' };
+const SIGNAL_RE = /\b(error|err|warn|warning|fail|failed|failure|exception|fatal|panic|traceback|denied|refused|timeout|timed out|cannot|unable|missing|undefined|null pointer|segfault|assert)\b/i;
+/** Collapse volatile tokens so near-duplicate lines share a key. */
+export function normalizeLineKey(line) {
+    return line
+        .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?/g, '') // ISO timestamps
+        .replace(/\b\d{1,2}:\d{2}:\d{2}\b/g, '') // clock times
+        .replace(/0x[0-9a-fA-F]+/g, '#') // hex
+        .replace(/\b\d+\b/g, '#') // numbers
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function isSignal(line) {
+    return SIGNAL_RE.test(line);
+}
+// ── Shingle-based near-duplicate detection (catches REWORDED dups) ────────────
+// Bigram shingles (k=2) + a 0.6 Jaccard threshold: catches a 1-word rewording in a
+// typical log line while leaving genuinely different lines (Jaccard ~0) untouched.
+// (Sentence-level 0.85 like headroom is too strict for short log lines.)
+const SHINGLE_K = 2;
+const NEAR_DUP_JACCARD = 0.6;
+/** Word 3-gram shingles of a line (falls back to the word set for short lines). */
+export function wordShingles(line, k = SHINGLE_K) {
+    const words = (line.toLowerCase().match(/[a-z0-9_]+/g) ?? []);
+    const set = new Set();
+    if (words.length < k) {
+        for (const w of words)
+            set.add(w);
+        return set;
+    }
+    for (let i = 0; i + k <= words.length; i++)
+        set.add(words.slice(i, i + k).join(' '));
+    return set;
+}
+export function jaccard(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const x of a)
+        if (b.has(x))
+            inter++;
+    return inter / (a.size + b.size - inter);
+}
+import { bm25Scores } from './relevance.js';
+export function crushText(text, opts = {}) {
+    const o = { ...DEFAULTS, ...opts };
+    const lines = text.split('\n');
+    const n = lines.length;
+    // Nothing to gain below the budget.
+    if (n <= o.maxLines)
+        return { text, kept: n, dropped: 0 };
+    const headEnd = Math.min(o.headKeep, n);
+    const tailStart = Math.max(headEnd, n - o.tailKeep);
+    // Pass 1 — decide which indices to keep.
+    const keep = new Array(n).fill(false);
+    const seenKeys = new Set();
+    let budget = o.maxLines;
+    const tryKeep = (i, key) => {
+        if (keep[i])
+            return;
+        keep[i] = true;
+        seenKeys.add(key);
+        budget--;
+    };
+    // Anchors + signal lines first (highest priority), registering their normalized keys
+    // so later near-duplicates of them are suppressed.
+    for (let i = 0; i < n; i++) {
+        const key = normalizeLineKey(lines[i]);
+        const anchor = i < headEnd || i >= tailStart;
+        if (anchor || isSignal(lines[i]))
+            tryKeep(i, key);
+    }
+    // Candidate lines for the remaining budget: first occurrence of each not-yet-seen
+    // normalized key (so near-duplicates collapse to their first representative).
+    const candidates = [];
+    const candSeen = new Set(seenKeys);
+    for (let i = 0; i < n; i++) {
+        if (keep[i])
+            continue;
+        const key = normalizeLineKey(lines[i]);
+        if (key === '' || candSeen.has(key))
+            continue;
+        candSeen.add(key);
+        candidates.push(i);
+    }
+    // Order candidates: by BM25 relevance to the task when a query is given (keep the
+    // lines that matter for what the user is doing), else by original order. Relevance
+    // is only ever driven from OUTSIDE the cached prefix (see compressor), so this stays
+    // cache-safe. Kept lines are still emitted in original order below.
+    let ordered = candidates;
+    if (o.query.trim() !== '' && candidates.length > 0) {
+        const scores = bm25Scores(o.query, candidates.map(i => lines[i]));
+        ordered = candidates
+            .map((idx, k) => ({ idx, score: scores[k], k }))
+            .sort((a, b) => (b.score - a.score) || (a.k - b.k))
+            .map(x => x.idx);
+    }
+    // Keep candidates, but skip any that is a REWORDED near-duplicate (shingle Jaccard
+    // ≥ threshold) of a line already kept in this fill pass — catches dups that survived
+    // the exact normalized-key check because their wording differs.
+    // Seed with the shingles of lines already kept (anchors + signal) so a candidate that
+    // merely rewords an anchor/signal line is also dropped.
+    const keptShingles = [];
+    for (let i = 0; i < n; i++)
+        if (keep[i])
+            keptShingles.push(wordShingles(lines[i]));
+    for (const i of ordered) {
+        if (budget <= 0)
+            break;
+        const sh = wordShingles(lines[i]);
+        if (keptShingles.some(s => jaccard(sh, s) >= NEAR_DUP_JACCARD))
+            continue;
+        tryKeep(i, normalizeLineKey(lines[i]));
+        keptShingles.push(sh);
+    }
+    // Reconstruct in original order, summarizing runs of dropped lines with one marker.
+    const out = [];
+    let droppedRun = 0;
+    let dropped = 0;
+    const flush = () => {
+        if (droppedRun > 0) {
+            out.push(`... [${droppedRun} lines omitted]`);
+            dropped += droppedRun;
+            droppedRun = 0;
+        }
+    };
+    for (let i = 0; i < n; i++) {
+        if (keep[i]) {
+            flush();
+            out.push(lines[i]);
+        }
+        else
+            droppedRun++;
+    }
+    flush();
+    if (dropped === 0)
+        return { text, kept: n, dropped: 0 };
+    return { text: out.join('\n'), kept: n - dropped, dropped };
+}

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "squeezr-ai",
-  "version": "1.81.2",
-  "description": "AI proxy that compresses Claude Code, Claude Desktop, Codex, Codex Desktop, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
-  "keywords": [
-    "claude",
-    "claude-code",
-    "codex",
-    "ollama",
-    "aider",
-    "gemini",
-    "token",
-    "compression",
-    "proxy",
-    "llm",
-    "ai"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sergioramosv/Squeezr.git"
-  },
-  "homepage": "https://github.com/sergioramosv/Squeezr#readme",
-  "type": "module",
-  "bin": {
-    "squeezr": "bin/squeezr.js",
-    "squeezr-mcp": "dist/mcp.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "prepack": "node -e \"['dist/cursorMitm.js','dist/cursorMitm.d.ts','dist/__tests__/cursorMitm.test.js','dist/__tests__/cursorMitm.test.d.ts'].forEach(f=>{try{require('fs').unlinkSync(f)}catch{}})\"",
-    "dev": "tsx src/index.ts",
-    "start": "node dist/index.js",
-    "gain": "node dist/gain.js",
-    "discover": "node dist/discover.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:quality": "vitest run src/__tests__/qualityHarness.test.ts"
-  },
-  "files": [
-    "bin/",
-    "dist/",
-    "squeezr.toml"
-  ],
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@bufbuild/protobuf": "^2.11.0",
-    "@hono/node-server": "^1.13.7",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@types/diff": "^7.0.2",
-    "diff": "^9.0.0",
-    "hono": "^4.7.5",
-    "node-forge": "^1.4.0",
-    "openai": "^4.93.0",
-    "smol-toml": "^1.3.1",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.14.0",
-    "@types/node-forge": "^1.3.14",
-    "@vitest/coverage-v8": "^4.1.2",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "vitest": "^4.1.2"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "squeezr-ai",
+  "version": "1.99.2",
+  "description": "AI proxy that compresses Claude Code, Claude Desktop, Codex, Codex Desktop, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "ollama",
+    "aider",
+    "gemini",
+    "token",
+    "compression",
+    "proxy",
+    "llm",
+    "ai"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sergioramosv/Squeezr.git"
+  },
+  "homepage": "https://github.com/sergioramosv/Squeezr#readme",
+  "type": "module",
+  "bin": {
+    "squeezr": "bin/squeezr.js",
+    "squeezr-mcp": "dist/mcp.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepack": "node -e \"['dist/cursorMitm.js','dist/cursorMitm.d.ts','dist/__tests__/cursorMitm.test.js','dist/__tests__/cursorMitm.test.d.ts'].forEach(f=>{try{require('fs').unlinkSync(f)}catch{}})\"",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "gain": "node dist/gain.js",
+    "discover": "node dist/discover.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:quality": "vitest run src/__tests__/qualityHarness.test.ts"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "squeezr.toml"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@bufbuild/protobuf": "^2.11.0",
+    "@hono/node-server": "^1.13.7",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@types/diff": "^7.0.2",
+    "diff": "^9.0.0",
+    "hono": "^4.7.5",
+    "node-forge": "^1.4.0",
+    "openai": "^4.93.0",
+    "smol-toml": "^1.3.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "@types/node-forge": "^1.3.14",
+    "@vitest/coverage-v8": "^4.1.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}