@psiclawops/hypermem 0.8.5 → 0.9.1

package/dist/hybrid-retrieval.js

@@ -1,344 +0,0 @@
-/**
- * hypermem Hybrid Retrieval — FTS5 + KNN Score Fusion
- *
- * Merges keyword (FTS5/BM25) and semantic (KNN/vector) results into a
- * single ranked list using Reciprocal Rank Fusion (RRF). This avoids
- * vocabulary mismatch (KNN-only misses exact terms) and semantic gap
- * (FTS5-only misses paraphrases).
- *
- * Architecture:
- *   - FTS5 results from library.db (facts_fts, knowledge_fts, episodes_fts)
- *   - KNN results from vectors.db via VectorStore
- *   - RRF merges both ranked lists with configurable k constant
- *   - Deduplication by (sourceTable, sourceId)
- *   - Token-budgeted output for compositor consumption
- */
-// ─── FTS5 Query Building ───────────────────────────────────────
-/** Stop words to exclude from FTS5 queries */
-const STOP_WORDS = new Set([
-    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'shall', 'can', 'need', 'dare', 'ought',
-    'used', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from',
-    'as', 'into', 'through', 'during', 'before', 'after', 'above', 'below',
-    'between', 'out', 'off', 'over', 'under', 'again', 'further', 'then',
-    'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'each',
-    'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such', 'no',
-    'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very',
-    'just', 'don', 'now', 'and', 'but', 'or', 'if', 'it', 'its', 'this',
-    'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
-    'he', 'him', 'his', 'she', 'her', 'they', 'them', 'their', 'what',
-    'which', 'who', 'whom', 'about', 'up',
-]);
-/**
- * Build an FTS5 query from a natural language string.
- * Extracts meaningful words, removes stop words, uses OR conjunction.
- */
-export function buildFtsQuery(input) {
-    const words = input
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, ' ') // strip punctuation except hyphens
-        .split(/\s+/)
-        .filter(w => w.length >= 3 && !STOP_WORDS.has(w));
-    if (words.length === 0)
-        return '';
-    // Deduplicate, sort by length descending (more specific terms first),
-    // cap at 8 terms to keep queries reasonable
-    const unique = [...new Set(words)]
-        .sort((a, b) => b.length - a.length)
-        .slice(0, 8);
-    // Use prefix matching (*) and OR so any term can match
-    return unique.map(w => `"${w}"*`).join(' OR ');
-}
-/**
- * Search facts via FTS5.
- */
-function searchFactsFts(db, query, agentId, limit = 20) {
-    // Two-phase query: FTS runs first in subquery (fast), then filters on
-    // the small result set.  Joining FTS + non-FTS predicates + ORDER BY rank
-    // in one pass forces SQLite to materialise the full FTS match set before
-    // applying LIMIT — O(matches) instead of O(limit).  See data-access-bench.
-    const innerLimit = agentId ? limit * 4 : limit; // over-fetch to survive filter
-    let sql = `
-    SELECT f.id, sub.rank, f.content, f.domain, f.agent_id
-    FROM (
-      SELECT rowid, rank FROM facts_fts WHERE facts_fts MATCH ? ORDER BY rank LIMIT ?
-    ) sub
-    JOIN facts f ON f.id = sub.rowid
-    WHERE f.superseded_by IS NULL
-    AND f.decay_score < 0.8
-  `;
-    const params = [query, innerLimit];
-    if (agentId) {
-        sql += ' AND f.agent_id = ?';
-        params.push(agentId);
-    }
-    sql += ' ORDER BY sub.rank LIMIT ?';
-    params.push(limit);
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(r => ({
-        id: r.id,
-        rank: r.rank,
-        content: r.content,
-        domain: r.domain,
-        agentId: r.agent_id,
-    }));
-}
-/**
- * Search knowledge via FTS5.
- */
-function searchKnowledgeFts(db, query, agentId, limit = 20) {
-    const innerLimit = agentId ? limit * 4 : limit;
-    let sql = `
-    SELECT k.id, sub.rank, k.content, k.domain, k.agent_id, k.key
-    FROM (
-      SELECT rowid, rank FROM knowledge_fts WHERE knowledge_fts MATCH ? ORDER BY rank LIMIT ?
-    ) sub
-    JOIN knowledge k ON k.id = sub.rowid
-    WHERE k.superseded_by IS NULL
-  `;
-    const params = [query, innerLimit];
-    if (agentId) {
-        sql += ' AND k.agent_id = ?';
-        params.push(agentId);
-    }
-    sql += ' ORDER BY sub.rank LIMIT ?';
-    params.push(limit);
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(r => ({
-        id: r.id,
-        rank: r.rank,
-        content: r.content,
-        domain: r.domain,
-        agentId: r.agent_id,
-        metadata: r.key,
-    }));
-}
-/**
- * Search episodes via FTS5.
- */
-function searchEpisodesFts(db, query, agentId, limit = 20) {
-    let sql;
-    let params;
-    if (agentId) {
-        // Agent-scoped: use WHERE IN (FTS5 subquery) instead of FTS5→JOIN→filter.
-        // SQLite uses the agent_id index to narrow first, then checks FTS5 membership.
-        // Benchmarked: 2.3ms avg vs 8.5ms avg for the post-join approach (13k+ episodes).
-        sql = `
-      SELECT e.id, 0 as rank, e.summary, e.event_type, e.agent_id, e.participants, e.created_at
-      FROM episodes e
-      WHERE e.agent_id = ?
-        AND e.decay_score < 0.8
-        AND e.id IN (SELECT rowid FROM episodes_fts WHERE episodes_fts MATCH ?)
-      ORDER BY e.created_at DESC
-      LIMIT ?
-    `;
-        params = [agentId, query, limit];
-    }
-    else {
-        sql = `
-      SELECT e.id, sub.rank, e.summary, e.event_type, e.agent_id, e.participants, e.created_at
-      FROM (
-        SELECT rowid, rank FROM episodes_fts WHERE episodes_fts MATCH ? ORDER BY rank LIMIT ?
-      ) sub
-      JOIN episodes e ON e.id = sub.rowid
-      WHERE e.decay_score < 0.8
-      ORDER BY sub.rank LIMIT ?
-    `;
-        params = [query, limit, limit];
-    }
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(r => ({
-        id: r.id,
-        rank: r.rank,
-        content: r.summary,
-        domain: r.event_type,
-        agentId: r.agent_id,
-        metadata: r.participants || undefined,
-        createdAt: r.created_at || undefined,
-    }));
-}
-function resultKey(table, id) {
-    return `${table}:${id}`;
-}
-/**
- * Merge FTS5 and KNN results using Reciprocal Rank Fusion.
- *
- * RRF score = Σ (weight / (k + rank)) for each result list the item appears in.
- * k is a constant (default 60) that dampens the effect of high rank positions.
- */
-function fuseResults(ftsResults, knnResults, k, ftsWeight, knnWeight) {
-    const merged = new Map();
-    // Add FTS results
-    for (const [key, entry] of ftsResults) {
-        const score = ftsWeight / (k + (entry.ftsRank || 1));
-        merged.set(key, { ...entry, score, sources: ['fts'] });
-    }
-    // Merge KNN results
-    for (const [key, entry] of knnResults) {
-        const knnScore = knnWeight / (k + (entry.knnRank || 1));
-        const existing = merged.get(key);
-        if (existing) {
-            // Item found by both — boost score
-            existing.score += knnScore;
-            existing.knnRank = entry.knnRank;
-            existing.knnDistance = entry.knnDistance;
-            existing.sources = ['fts', 'knn'];
-        }
-        else {
-            merged.set(key, { ...entry, score: knnScore, sources: ['knn'] });
-        }
-    }
-    // Sort by fused score descending
-    return [...merged.values()].sort((a, b) => b.score - a.score);
-}
-// ─── Public API ────────────────────────────────────────────────
-/**
- * Hybrid search combining FTS5 keyword search and KNN vector search.
- *
- * When vectorStore is null, falls back to FTS5-only.
- * When FTS5 query is empty (all stop words), falls back to KNN-only.
- */
-export async function hybridSearch(libraryDb, vectorStore, query, opts) {
-    const tables = opts?.tables || ['facts', 'knowledge', 'episodes'];
-    const limit = opts?.limit || 10;
-    const maxKnnDistance = opts?.maxKnnDistance || 1.2;
-    const rrfK = opts?.rrfK || 60;
-    const ftsWeight = opts?.ftsWeight || 1.0;
-    const knnWeight = opts?.knnWeight || 1.0;
-    const minFtsTerms = opts?.minFtsTerms || 1;
-    // ── FTS5 retrieval ──
-    const ftsQuery = buildFtsQuery(query);
-    const ftsMap = new Map();
-    if (ftsQuery && ftsQuery.split(' OR ').length >= minFtsTerms) {
-        try {
-            const perTableLimit = Math.ceil(limit * 1.5); // Over-fetch for fusion
-            if (tables.includes('facts')) {
-                const results = searchFactsFts(libraryDb, ftsQuery, opts?.agentId, perTableLimit);
-                results.forEach((r, i) => {
-                    const key = resultKey('facts', r.id);
-                    ftsMap.set(key, {
-                        sourceTable: 'facts',
-                        sourceId: r.id,
-                        content: r.content,
-                        domain: r.domain,
-                        agentId: r.agentId,
-                        ftsRank: i + 1,
-                        score: 0,
-                        sources: ['fts'],
-                    });
-                });
-            }
-            if (tables.includes('knowledge')) {
-                const results = searchKnowledgeFts(libraryDb, ftsQuery, opts?.agentId, perTableLimit);
-                results.forEach((r, i) => {
-                    const key = resultKey('knowledge', r.id);
-                    ftsMap.set(key, {
-                        sourceTable: 'knowledge',
-                        sourceId: r.id,
-                        content: r.content,
-                        domain: r.domain,
-                        agentId: r.agentId,
-                        metadata: r.metadata,
-                        ftsRank: i + 1,
-                        score: 0,
-                        sources: ['fts'],
-                    });
-                });
-            }
-            if (tables.includes('episodes')) {
-                const results = searchEpisodesFts(libraryDb, ftsQuery, opts?.agentId, perTableLimit);
-                results.forEach((r, i) => {
-                    const key = resultKey('episodes', r.id);
-                    ftsMap.set(key, {
-                        sourceTable: 'episodes',
-                        sourceId: r.id,
-                        content: r.content,
-                        domain: r.domain,
-                        agentId: r.agentId,
-                        metadata: r.metadata,
-                        createdAt: r.createdAt,
-                        ftsRank: i + 1,
-                        score: 0,
-                        sources: ['fts'],
-                    });
-                });
-            }
-        }
-        catch {
-            // FTS5 failure is non-fatal — fall through to KNN-only
-        }
-    }
-    // ── KNN retrieval ──
-    const knnMap = new Map();
-    if (vectorStore) {
-        try {
-            const knnResults = await vectorStore.search(query, {
-                tables,
-                limit: Math.ceil(limit * 1.5),
-                maxDistance: maxKnnDistance,
-                precomputedEmbedding: opts?.precomputedEmbedding,
-            });
-            knnResults.forEach((r, i) => {
-                const key = resultKey(r.sourceTable, r.sourceId);
-                knnMap.set(key, {
-                    sourceTable: r.sourceTable,
-                    sourceId: r.sourceId,
-                    content: r.content,
-                    domain: r.domain,
-                    agentId: r.agentId,
-                    metadata: r.metadata,
-                    knnRank: i + 1,
-                    knnDistance: r.distance,
-                    score: 0,
-                    sources: ['knn'],
-                });
-            });
-        }
-        catch {
-            // KNN failure is non-fatal — use FTS-only
-        }
-    }
-    // ── Fusion ──
-    if (ftsMap.size === 0 && knnMap.size === 0) {
-        return [];
-    }
-    // If only one source has results, skip fusion overhead but assign scores
-    if (ftsMap.size === 0) {
-        // KNN-only: score by inverse distance
-        return [...knnMap.values()]
-            .sort((a, b) => (a.knnDistance || 99) - (b.knnDistance || 99))
-            .slice(0, limit)
-            .map((entry, i) => toHybridResult({
-            ...entry,
-            score: knnWeight / (rrfK + i + 1),
-        }));
-    }
-    if (knnMap.size === 0) {
-        // FTS-only: score by rank position
-        return [...ftsMap.values()]
-            .sort((a, b) => (a.ftsRank || 99) - (b.ftsRank || 99))
-            .slice(0, limit)
-            .map((entry, i) => toHybridResult({
-            ...entry,
-            score: ftsWeight / (rrfK + i + 1),
-        }));
-    }
-    // Both sources present — RRF fusion
-    const fused = fuseResults(ftsMap, knnMap, rrfK, ftsWeight, knnWeight);
-    return fused.slice(0, limit).map(toHybridResult);
-}
-function toHybridResult(entry) {
-    return {
-        sourceTable: entry.sourceTable,
-        sourceId: entry.sourceId,
-        content: entry.content,
-        domain: entry.domain,
-        agentId: entry.agentId,
-        metadata: entry.metadata,
-        createdAt: entry.createdAt,
-        score: entry.score,
-        sources: entry.sources,
-    };
-}
-//# sourceMappingURL=hybrid-retrieval.js.map

package/dist/image-eviction.d.ts

@@ -1,49 +0,0 @@
-/**
- * Image and heavy-content eviction pre-pass.
- *
- * Runs before the LLM call inside assemble(). Scans the live messages array
- * for stale image payloads and large tool results, replaces them with compact
- * text descriptors. This frees tokens before pressure tiers fire, so compaction
- * runs less often.
- *
- * Works on the raw OpenClaw message format (AgentMessage / content arrays),
- * not on hypermem's internal NeutralMessage format.
- *
- * What gets evicted:
- *   - Base64 image blocks (OpenAI image_url / Anthropic image source) older than imageAgeTurns
- *   - Tool results larger than minTokensToEvict, older than toolResultAgeTurns
- *
- * What is never touched:
- *   - User text content
- *   - Assistant text responses
- *   - Recent messages (within staleness thresholds)
- *   - Tool call structure (type, id, name preserved — required for API pairing)
- *   - Small tool results (below minTokensToEvict)
- *   - Thinking blocks
- */
-export interface ImageEvictionConfig {
-    /** Turns after which images are evicted. Default: 1 */
-    imageAgeTurns: number;
-    /** Turns after which large tool results are evicted. Default: 1 */
-    toolResultAgeTurns: number;
-    /** Minimum estimated tokens to bother evicting a tool result. Default: 200 */
-    minTokensToEvict: number;
-    /** Characters of preview to keep from evicted tool result content. Default: 120 */
-    keepPreviewChars: number;
-}
-export interface EvictionStats {
-    imagesEvicted: number;
-    toolResultsEvicted: number;
-    tokensFreed: number;
-}
-export interface EvictionResult {
-    messages: unknown[];
-    stats: EvictionStats;
-}
-export declare const DEFAULT_EVICTION_CONFIG: ImageEvictionConfig;
-/**
- * Evict stale images and large tool results from the messages array.
- * Returns a new array (original is not mutated) plus eviction stats.
- */
-export declare function evictStaleContent(messages: unknown[], config?: Partial<ImageEvictionConfig>): EvictionResult;
-//# sourceMappingURL=image-eviction.d.ts.map

package/dist/image-eviction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image-eviction.d.ts","sourceRoot":"","sources":["../src/image-eviction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,aAAa,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED,eAAO,MAAM,uBAAuB,EAAE,mBAKrC,CAAC;AAqJF;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,OAAO,EAAE,EACnB,MAAM,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACxC,cAAc,CAqFhB"}

package/dist/image-eviction.js

@@ -1,251 +0,0 @@
-/**
- * Image and heavy-content eviction pre-pass.
- *
- * Runs before the LLM call inside assemble(). Scans the live messages array
- * for stale image payloads and large tool results, replaces them with compact
- * text descriptors. This frees tokens before pressure tiers fire, so compaction
- * runs less often.
- *
- * Works on the raw OpenClaw message format (AgentMessage / content arrays),
- * not on hypermem's internal NeutralMessage format.
- *
- * What gets evicted:
- *   - Base64 image blocks (OpenAI image_url / Anthropic image source) older than imageAgeTurns
- *   - Tool results larger than minTokensToEvict, older than toolResultAgeTurns
- *
- * What is never touched:
- *   - User text content
- *   - Assistant text responses
- *   - Recent messages (within staleness thresholds)
- *   - Tool call structure (type, id, name preserved — required for API pairing)
- *   - Small tool results (below minTokensToEvict)
- *   - Thinking blocks
- */
-export const DEFAULT_EVICTION_CONFIG = {
-    imageAgeTurns: 1,
-    toolResultAgeTurns: 1,
-    minTokensToEvict: 200,
-    keepPreviewChars: 120,
-};
-// ── Token estimation ─────────────────────────────────────────────────────────
-/**
- * Attempt to read image dimensions from the first few bytes of a base64-encoded image.
- * Supports PNG, JPEG, GIF, WebP. Returns null if format is unrecognized or parse fails.
- */
-function tryReadImageDimensions(base64) {
-    try {
-        // PNG: decode 32 bytes — magic at 0-7, IHDR at 8-15, width at 16-19, height at 20-23
-        const hdrBuf = Buffer.from(base64.slice(0, 44), 'base64');
-        if (hdrBuf[0] === 0x89 && hdrBuf[1] === 0x50 && hdrBuf[2] === 0x4e && hdrBuf[3] === 0x47) {
-            const w = hdrBuf.readUInt32BE(16);
-            const h = hdrBuf.readUInt32BE(20);
-            if (w > 0 && h > 0 && w <= 16384 && h <= 16384)
-                return { width: w, height: h };
-        }
-        // GIF: 6-byte header, then width/height as little-endian 16-bit at offsets 6-7, 8-9
-        if (hdrBuf[0] === 0x47 && hdrBuf[1] === 0x49 && hdrBuf[2] === 0x46) {
-            const w = hdrBuf.readUInt16LE(6);
-            const h = hdrBuf.readUInt16LE(8);
-            if (w > 0 && h > 0)
-                return { width: w, height: h };
-        }
-        // JPEG: SOI is \xff\xd8 — scan a larger chunk for SOF0 (\xff\xc0) or SOF2 (\xff\xc2)
-        if (hdrBuf[0] === 0xff && hdrBuf[1] === 0xd8) {
-            const jpegBuf = Buffer.from(base64.slice(0, 680), 'base64');
-            for (let i = 2; i < jpegBuf.length - 8; i++) {
-                if (jpegBuf[i] === 0xff && (jpegBuf[i + 1] === 0xc0 || jpegBuf[i + 1] === 0xc2)) {
-                    const h = jpegBuf.readUInt16BE(i + 5);
-                    const w = jpegBuf.readUInt16BE(i + 7);
-                    if (w > 0 && h > 0 && w <= 16384 && h <= 16384)
-                        return { width: w, height: h };
-                }
-            }
-        }
-        // WebP: RIFF....WEBP — VP8L (lossless) has readable dimensions quickly
-        if (hdrBuf[0] === 0x52 && hdrBuf[1] === 0x49 && hdrBuf[2] === 0x46 && hdrBuf[3] === 0x46 &&
-            hdrBuf[8] === 0x57 && hdrBuf[9] === 0x45 && hdrBuf[10] === 0x42 && hdrBuf[11] === 0x50 &&
-            hdrBuf[12] === 0x56 && hdrBuf[13] === 0x50 && hdrBuf[14] === 0x38 && hdrBuf[15] === 0x4c) {
-            if (hdrBuf[20] === 0x2f) {
-                const bits = hdrBuf.readUInt32LE(21);
-                const w = (bits & 0x3fff) + 1;
-                const h = ((bits >> 14) & 0x3fff) + 1;
-                if (w > 0 && h > 0)
-                    return { width: w, height: h };
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Estimate virtual tokens for a base64-encoded image using provider-appropriate math.
- * Uses Claude's formula (w×h / 750, capped at 1600) as the canonical estimate —
- * GPT-4o and Gemini are in the same ballpark for typical screenshots.
- * Falls back to a conservative 1200-token default when dimensions cannot be read.
- *
- * NOTE: Base64 string length is irrelevant — providers decode the image and run it
- * through a vision encoder. Only pixel dimensions determine token cost.
- */
-function estimateBase64Tokens(base64) {
-    const dims = tryReadImageDimensions(base64);
-    if (dims) {
-        return Math.min(Math.ceil((dims.width * dims.height) / 750), 1600);
-    }
-    // Fallback: typical tool screenshot ~1000-1600 tokens; use midpoint
-    return 1200;
-}
-/** Standard prose/JSON estimation. */
-function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-// ── Message turn-age calculation ─────────────────────────────────────────────
-/**
- * Returns the turn age of a message at index `i` in the array.
- * Turn age = number of assistant messages between position i and the end.
- * (Each assistant message marks the end of one turn.)
- */
-function getTurnAge(messages, index) {
-    let age = 0;
-    for (let j = index + 1; j < messages.length; j++) {
-        const m = messages[j];
-        if (m.role === 'assistant')
-            age++;
-    }
-    return age;
-}
-// ── Content-block helpers ─────────────────────────────────────────────────────
-/** Detect OpenAI-style image_url block or Anthropic-style image block. */
-function isImageBlock(block) {
-    if (block.type === 'image_url')
-        return true;
-    if (block.type === 'image')
-        return true;
-    return false;
-}
-/**
- * Extract base64 data from an image block regardless of provider format.
- * Returns null if the image is a plain URL (not base64-encoded — not worth evicting).
- */
-function extractBase64(block) {
-    // OpenAI format: { type: 'image_url', image_url: { url: 'data:image/png;base64,...' } }
-    if (block.type === 'image_url') {
-        const imageUrl = block.image_url;
-        const url = typeof imageUrl?.url === 'string' ? imageUrl.url : null;
-        if (url?.startsWith('data:')) {
-            const commaIdx = url.indexOf(',');
-            return commaIdx >= 0 ? url.slice(commaIdx + 1) : null;
-        }
-        return null; // plain URL, not base64
-    }
-    // Anthropic format: { type: 'image', source: { type: 'base64', data: '...' } }
-    if (block.type === 'image') {
-        const source = block.source;
-        if (source?.type === 'base64' && typeof source.data === 'string') {
-            return source.data;
-        }
-        return null;
-    }
-    return null;
-}
-/** Infer media type string from an image block for the descriptor. */
-function inferMediaType(block) {
-    if (block.type === 'image_url') {
-        const imageUrl = block.image_url;
-        const url = typeof imageUrl?.url === 'string' ? imageUrl.url : '';
-        const match = url.match(/^data:(image\/[^;]+)/);
-        return match ? match[1] : 'image';
-    }
-    if (block.type === 'image') {
-        const source = block.source;
-        return typeof source?.media_type === 'string' ? source.media_type : 'image';
-    }
-    return 'image';
-}
-// ── Main eviction pass ────────────────────────────────────────────────────────
-/**
- * Evict stale images and large tool results from the messages array.
- * Returns a new array (original is not mutated) plus eviction stats.
- */
-export function evictStaleContent(messages, config = {}) {
-    const cfg = { ...DEFAULT_EVICTION_CONFIG, ...config };
-    const stats = { imagesEvicted: 0, toolResultsEvicted: 0, tokensFreed: 0 };
-    const result = messages.map((msg, i) => {
-        const m = msg;
-        const role = m.role;
-        // Only touch user messages (images) and tool messages (tool results).
-        // Never touch assistant text, system prompts, or thinking blocks.
-        if (role !== 'user' && role !== 'tool')
-            return msg;
-        const turnAge = getTurnAge(messages, i);
-        // ── Image eviction (user messages with content arrays) ──────────────────
-        if (role === 'user' && Array.isArray(m.content)) {
-            if (turnAge <= cfg.imageAgeTurns)
-                return msg;
-            let changed = false;
-            let newContent = m.content.map(block => {
-                const b = block;
-                if (!isImageBlock(b))
-                    return block;
-                const base64 = extractBase64(b);
-                if (!base64)
-                    return block; // plain URL — don't touch
-                const tokens = estimateBase64Tokens(base64);
-                if (tokens < cfg.minTokensToEvict)
-                    return block;
-                // Replace with a text descriptor
-                const mediaType = inferMediaType(b);
-                const dims = tryReadImageDimensions(base64);
-                const dimStr = dims ? ` ${dims.width}×${dims.height}` : '';
-                const descriptor = `[${mediaType}${dimStr} evicted — ~${tokens.toLocaleString()} tokens, ${turnAge} turns ago]`;
-                stats.imagesEvicted++;
-                stats.tokensFreed += tokens;
-                changed = true;
-                return { type: 'text', text: descriptor };
-            });
-            if (!changed)
-                return msg;
-            return { ...m, content: newContent };
-        }
-        // ── Tool result eviction (tool-role messages or toolResults arrays) ──────
-        if (role === 'tool' && typeof m.content === 'string') {
-            if (turnAge <= cfg.toolResultAgeTurns)
-                return msg;
-            const tokens = estimateTokens(m.content);
-            if (tokens < cfg.minTokensToEvict)
-                return msg;
-            const preview = m.content.slice(0, cfg.keepPreviewChars).replace(/\s+/g, ' ').trim();
-            const toolName = typeof m.name === 'string' ? m.name : 'tool_result';
-            const descriptor = `[${toolName} result evicted — ~${tokens.toLocaleString()} tokens, ${turnAge} turns ago. Preview: ${preview}${preview.length < m.content.length ? '...' : ''}]`;
-            stats.toolResultsEvicted++;
-            stats.tokensFreed += tokens - estimateTokens(descriptor);
-            return { ...m, content: descriptor };
-        }
-        // NeutralMessage format — toolResults as array on assistant/user messages
-        if (Array.isArray(m.toolResults) && turnAge > cfg.toolResultAgeTurns) {
-            let changed = false;
-            const newToolResults = m.toolResults.map(tr => {
-                const r = tr;
-                if (typeof r.content !== 'string')
-                    return tr;
-                const tokens = estimateTokens(r.content);
-                if (tokens < cfg.minTokensToEvict)
-                    return tr;
-                const preview = r.content.slice(0, cfg.keepPreviewChars).replace(/\s+/g, ' ').trim();
-                const name = typeof r.name === 'string' ? r.name : 'tool_result';
-                const descriptor = `[${name} evicted — ~${tokens.toLocaleString()} tokens, ${turnAge} turns ago. Preview: ${preview}${preview.length < r.content.length ? '...' : ''}]`;
-                stats.toolResultsEvicted++;
-                stats.tokensFreed += tokens - estimateTokens(descriptor);
-                changed = true;
-                return { ...r, content: descriptor };
-            });
-            if (!changed)
-                return msg;
-            return { ...m, toolResults: newToolResults };
-        }
-        return msg;
-    });
-    return { messages: result, stats };
-}
-//# sourceMappingURL=image-eviction.js.map