@qearlyao/familiar 0.2.2 → 0.2.4

package/dist/memory/index/chunk-indexer.js

@@ -15,8 +15,11 @@ export class ChunkIndexer {
     async replaceSource(corpus, sourceId, inputs, signal) {
         const prepared = this.prepare(inputs.map((input) => ({ ...input, corpus, sourceId })));
         const keepMappings = prepared.map((item) => ({ contentHash: item.contentHash, chunkIndex: item.chunkIndex }));
-        this.store.deleteBySourceExceptMappings(corpus, sourceId, keepMappings);
-        const result = await this.insertPrepared(prepared, inputs.length - prepared.length, signal);
+        const result = await this.insertPrepared(prepared, inputs.length - prepared.length, signal, {
+            corpus,
+            sourceId,
+            keepMappings,
+        });
         return result;
     }
     prepare(inputs) {
@@ -46,10 +49,14 @@ export class ChunkIndexer {
         }
         return prepared;
     }
-    async insertPrepared(prepared, skipped, signal) {
+    async insertPrepared(prepared, skipped, signal, replaceSource) {
         const startedAt = Date.now();
-        if (prepared.length === 0)
+        if (prepared.length === 0) {
+            if (replaceSource) {
+                this.store.deleteBySourceExceptMappings(replaceSource.corpus, replaceSource.sourceId, []);
+            }
             return { ids: [], embedded: 0, reused: 0, skipped };
+        }
         const present = this.store.whichHashesPresent(prepared.map((item) => item.contentHash));
         for (const item of prepared)
             item.existingId = present.get(item.contentHash) ?? null;
@@ -92,10 +99,13 @@ export class ChunkIndexer {
         const toInsert = [];
         const insertPositions = [];
         const existingMappings = [];
+        const existingMappingIds = new Map();
+        const insertKnownMissing = new Set();
         for (let resultIndex = 0; resultIndex < prepared.length; resultIndex++) {
             const item = prepared[resultIndex];
             if (item.existingId !== null) {
                 ids[resultIndex] = item.existingId;
+                existingMappingIds.set(item.contentHash, item.existingId);
                 existingMappings.push({
                     corpus: item.input.corpus,
                     sourceId: item.sourceId,
@@ -113,6 +123,7 @@ export class ChunkIndexer {
             if (!embedding)
                 throw new Error("Missing embedding for memory chunk");
             insertPositions.push(resultIndex);
+            insertKnownMissing.add(item.contentHash);
             toInsert.push({
                 corpus: item.input.corpus,
                 sourceId: item.sourceId,
@@ -125,8 +136,18 @@ export class ChunkIndexer {
                 embedding,
             });
         }
-        this.store.recordSourceMappings(existingMappings);
-        const insertedIds = this.store.insertChunks(toInsert);
+        let insertedIds = [];
+        const writeChunks = () => {
+            if (replaceSource) {
+                this.store.deleteBySourceExceptMappings(replaceSource.corpus, replaceSource.sourceId, replaceSource.keepMappings);
+            }
+            this.store.recordSourceMappings(existingMappings, existingMappingIds);
+            insertedIds = this.store.insertChunks(toInsert, undefined, insertKnownMissing);
+        };
+        if (replaceSource && !this.store.db.inTransaction)
+            this.store.db.transaction(writeChunks).immediate();
+        else
+            writeChunks();
         for (let index = 0; index < insertPositions.length; index++) {
             ids[insertPositions[index]] = insertedIds[index];
         }

package/dist/memory/index/retrieval.js

@@ -1,3 +1,4 @@
+import { positiveIntegerOrDefault } from "../util.js";
 const DEFAULT_LIMIT = 8;
 const DEFAULT_CANDIDATE_MULTIPLIER = 4;
 const RRF_K = 60;
@@ -241,6 +242,3 @@ function chunkSources(chunk) {
 function uniqueStrings(values) {
     return Array.from(new Set(values?.filter((value) => value.trim()) ?? []));
 }
-function positiveIntegerOrDefault(value, fallback) {
-    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
-}

package/dist/memory/index/store.js

@@ -55,25 +55,31 @@ export class MemoryIndexStore {
     insertChunk(input) {
         return this.insertChunks([input])[0];
     }
-    insertChunks(inputs) {
+    insertChunks(inputs, preloadedIds, knownMissingHashes) {
         if (inputs.length === 0)
             return [];
         const rows = inputs.map((input) => this.normalizeInput(input));
+        const knownIds = new Map(preloadedIds);
         const out = [];
         const insert = this.db.transaction((items) => {
             for (const item of items)
-                out.push(this.insertNormalized(item));
+                out.push(this.insertNormalized(item, knownIds, knownMissingHashes));
         });
         insert.immediate(rows);
         return out;
     }
-    recordSourceMappings(inputs) {
+    recordSourceMappings(inputs, preloadedIds) {
         if (inputs.length === 0)
             return;
         const rows = inputs.map((input) => this.normalizeInput(input));
         this.db
             .transaction((items) => {
             for (const item of items) {
+                const preloadedId = preloadedIds?.get(item.contentHash);
+                if (preloadedId !== undefined) {
+                    this.insertSourceMapping(preloadedId, item);
+                    continue;
+                }
                 const existing = this.db
                     .prepare("SELECT id FROM memory_chunks WHERE content_hash = ?")
                     .get(item.contentHash);
@@ -88,8 +94,9 @@ export class MemoryIndexStore {
         const out = [];
         const replace = this.db.transaction(() => {
             this.deleteBySourceInternal(corpus, sourceId);
+            const knownIds = new Map();
             for (const item of rows)
-                out.push(this.insertNormalized(item));
+                out.push(this.insertNormalized(item, knownIds));
         });
         replace.immediate();
         return out;
@@ -168,19 +175,19 @@ export class MemoryIndexStore {
         return rows.map((row) => ({ id: row.id, score: row.score, chunk: rowToChunk(row) }));
     }
     searchSemanticLinear(query, normalized) {
-        const rows = this.db
-            .prepare(normalized.corpus
+        const stmt = this.db.prepare(normalized.corpus
             ? `SELECT c.*, ${sourcesJsonSelect("c.id")} FROM memory_chunks c WHERE c.corpus = ?`
-            : `SELECT c.*, ${sourcesJsonSelect("c.id")} FROM memory_chunks c`)
-            .all(...(normalized.corpus ? [normalized.corpus] : []));
-        return rows
-            .map((row) => ({
-            id: row.id,
-            score: cosineDistance(query, decodeVector(row.embedding, row.embedding_dimensions)),
-            chunk: rowToChunk(row),
-        }))
-            .sort((a, b) => a.score - b.score)
-            .slice(0, normalized.limit);
+            : `SELECT c.*, ${sourcesJsonSelect("c.id")} FROM memory_chunks c`);
+        const best = [];
+        for (const row of stmt.iterate(...(normalized.corpus ? [normalized.corpus] : []))) {
+            const hit = {
+                id: row.id,
+                score: cosineDistance(query, decodeVector(row.embedding, row.embedding_dimensions)),
+                chunk: rowToChunk(row),
+            };
+            insertBoundedHit(best, hit, normalized.limit);
+        }
+        return best;
     }
     deleteChunk(id) {
         const remove = this.db.transaction(() => {
@@ -243,6 +250,7 @@ export class MemoryIndexStore {
             this.deleteBySource(corpus, sourceId);
             return;
         }
+        const keptHashes = new Set(kept.map((item) => item.contentHash));
         this.db
             .transaction(() => {
             const rows = this.db
@@ -259,7 +267,8 @@ export class MemoryIndexStore {
                 this.db
                     .prepare("DELETE FROM memory_index_sources WHERE corpus = ? AND source_id = ? AND chunk_index = ?")
                     .run(corpus, sourceId, row.chunk_index);
-                this.deleteOrphanChunk(row.id);
+                if (!keptHashes.has(row.content_hash))
+                    this.deleteOrphanChunk(row.id);
             }
         })
             .immediate();
@@ -362,9 +371,15 @@ export class MemoryIndexStore {
             }),
         };
     }
-    insertNormalized(item) {
-        const existing = this.db.prepare("SELECT id FROM memory_chunks WHERE content_hash = ?").get(item.contentHash);
+    insertNormalized(item, knownIds, knownMissingHashes) {
+        const knownId = knownIds.get(item.contentHash);
+        const existing = knownId !== undefined
+            ? { id: knownId }
+            : knownMissingHashes?.has(item.contentHash)
+                ? undefined
+                : this.db.prepare("SELECT id FROM memory_chunks WHERE content_hash = ?").get(item.contentHash);
         if (existing) {
+            knownIds.set(item.contentHash, existing.id);
             this.insertSourceMapping(existing.id, item);
             return existing.id;
         }
@@ -383,6 +398,7 @@ export class MemoryIndexStore {
                 .prepare("INSERT INTO memory_vec(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)")
                 .run(id, encodeVector(item.embedding));
         }
+        knownIds.set(item.contentHash, id);
         this.insertSourceMapping(id, item);
         return id;
     }
@@ -434,6 +450,18 @@ function normalizeSearchOptions(options) {
         corpus: options.corpus,
     };
 }
+function insertBoundedHit(best, hit, limit) {
+    if (limit <= 0)
+        return;
+    let index = best.findIndex((candidate) => hit.score < candidate.score);
+    if (index < 0)
+        index = best.length;
+    if (index >= limit)
+        return;
+    best.splice(index, 0, hit);
+    if (best.length > limit)
+        best.length = limit;
+}
 function sourcesJsonSelect(chunkIdExpr) {
     return `(SELECT json_group_array(json_object(
 		'corpus', s.corpus,

package/dist/memory/lcm/backfill.js

@@ -2,7 +2,6 @@ import { readdir, readFile } from "node:fs/promises";
 import { relative, resolve } from "node:path";
 import { indexLcmRecords } from "./indexer.js";
 import { normalizeChatRecords } from "./normalize.js";
-import { computeLcmRecordKey } from "./store.js";
 const DEFAULT_YIELD_EVERY_N = 1024;
 const INDEX_BATCH_SIZE = 32;
 export async function backfillFromChatLogs(deps, options) {
@@ -66,15 +65,12 @@ export async function backfillFromChatLogs(deps, options) {
                 }
                 const inserted = [];
                 for (const record of batch.records) {
-                    if (recordExists(deps.lcmStore, record)) {
+                    const result = deps.lcmStore.insertRecordReturningStored(record);
+                    if (!result.inserted) {
                         report.recordsSkippedDuplicate += 1;
                         continue;
                     }
-                    const id = deps.lcmStore.insertRecord(record);
-                    const stored = deps.lcmStore.getRecord(id);
-                    if (!stored)
-                        throw new Error(`Failed to read backfilled LCM record: ${id}`);
-                    inserted.push(stored);
+                    inserted.push(result.record);
                     report.recordsInserted += 1;
                     if (inserted.length >= INDEX_BATCH_SIZE) {
                         report.indexedChunks += (await indexLcmRecords({ indexer: deps.indexer, records: inserted, signal: options.signal })).ids.length;
@@ -225,17 +221,24 @@ function countMissingSegments(lcmStore, segmentIds) {
     return missing;
 }
 function countExistingRecords(lcmStore, records) {
-    let existing = 0;
-    for (const record of records) {
-        if (recordExists(lcmStore, record))
-            existing += 1;
+    if (records.length === 0)
+        return 0;
+    const keys = records.map((record) => lcmStore.computeRecordKey(record));
+    const existingKeys = new Set();
+    for (const chunk of chunks([...new Set(keys)], 256)) {
+        const rows = lcmStore.db
+            .prepare(`SELECT record_key FROM lcm_records WHERE record_key IN (${chunk.map(() => "?").join(",")})`)
+            .all(...chunk);
+        for (const row of rows)
+            existingKeys.add(row.record_key);
     }
-    return existing;
+    return keys.reduce((total, key) => total + (existingKeys.has(key) ? 1 : 0), 0);
 }
-function recordExists(lcmStore, record) {
-    return !!lcmStore.db
-        .prepare("SELECT 1 FROM lcm_records WHERE record_key = ? LIMIT 1")
-        .get(computeLcmRecordKey(record));
+function chunks(items, size) {
+    const out = [];
+    for (let index = 0; index < items.length; index += size)
+        out.push(items.slice(index, index + size));
+    return out;
 }
 function errorCode(error) {
     return error && typeof error === "object" && "code" in error

package/dist/memory/lcm/context-transformer.js

@@ -1,5 +1,5 @@
 import { condense } from "./condense.js";
-import { createRawContextItems, estimateAgentMessageTokens, lcmRecordToAgentMessage, renderLcmRecordPartsForSummary, resolveFreshTailStartIndex, selectLcmCompactionCandidatePromptAware, } from "./context.js";
+import { createRawContextItems, estimateAgentMessageTokens, renderLcmRecordPartsForSummary, resolveFreshTailStartIndex, selectLcmCompactionCandidatePromptAware, } from "./context.js";
 import { indexLcmSummaries } from "./indexer.js";
 import { createSyntheticLcmSummaryMessage } from "./summarizer.js";
 const LCM_SUMMARY_OPEN_TAG = "<from_earlier>";
@@ -48,6 +48,7 @@ export class LcmContextTransformer {
                     signal,
                     model: options.model,
                     promptText,
+                    initialPressure: pressure,
                 });
             }
         }
@@ -76,7 +77,9 @@ export class LcmContextTransformer {
     }
     async serviceCompactionDebtForState(input) {
         for (let round = 0; input.state.compactionDebt > 0 && round < this.settings.maxRounds; round += 1) {
-            const pressure = this.evaluateCompactionPressure(input.state, input.model, input.promptText ?? "");
+            const pressure = round === 0 && input.initialPressure
+                ? input.initialPressure
+                : this.evaluateCompactionPressure(input.state, input.model, input.promptText ?? "");
             if (!pressure.candidate.shouldCompact) {
                 if (pressure.thresholdOverflowTokens > 0) {
                     const condensed = await this.condenseRuntimeSummaries({
@@ -149,19 +152,15 @@ export class LcmContextTransformer {
                 mode: candidate.reasons.includes("context_threshold") ? "aggressive" : "normal",
                 previousSummary,
             }, input.signal);
-            const summaryId = `${input.sessionKey}:summary-${++state.summaryCounter}`;
             const message = createSyntheticLcmSummaryMessage(renderLcmSummaryMessage(summaryText), this.now());
             const summaryItem = {
                 type: "summary",
-                id: summaryId,
+                id: "",
                 sourceIds: chunkItems.map((item) => item.id),
                 depth: 1,
                 message,
                 tokens: estimateAgentMessageTokens(message),
             };
-            state.items.splice(startIndex, removeCount, summaryItem);
-            compacted = true;
-            tokensSaved = Math.max(0, candidate.chunkTokens - summaryItem.tokens);
             const persisted = await this.persistRuntimeSummary({
                 text: summaryText,
                 sourceItems: chunkItems,
@@ -169,8 +168,12 @@ export class LcmContextTransformer {
                 sessionId: input.sessionId,
                 signal: input.signal,
             });
+            summaryItem.id = `${input.sessionKey}:summary-${++state.summaryCounter}`;
             if (persisted?.summaryId !== undefined)
                 summaryItem.persistedSummaryId = persisted.summaryId;
+            state.items.splice(startIndex, removeCount, summaryItem);
+            compacted = true;
+            tokensSaved = Math.max(0, candidate.chunkTokens - summaryItem.tokens);
             await this.condenseRuntimeSummaries({ state, sessionKey: input.sessionKey, signal: input.signal });
         };
         input.state.compactionQueue = input.state.compactionQueue.then(run, run);
@@ -262,8 +265,9 @@ export class LcmContextTransformer {
         this.lcmStore.db
             .transaction(() => {
             for (const insert of inserts) {
-                insert.item.recordId = this.lcmStore.insertRecord(insert.input);
-                insert.item.record = this.lcmStore.getRecord(insert.item.recordId);
+                const result = this.lcmStore.insertRecordReturningStored(insert.input);
+                insert.item.recordId = result.record.id;
+                insert.item.record = result.record;
             }
         })
             .immediate();
@@ -275,20 +279,7 @@ export class LcmContextTransformer {
         const items = [];
         for (const row of rows) {
             if (row.type === "raw") {
-                const record = this.lcmStore.getRecord(row.recordId);
-                if (!record) {
-                    console.error(`memory LCM context item dropped because record ${row.recordId} is missing`);
-                    continue;
-                }
-                const message = lcmRecordToAgentMessage(record);
-                items.push({
-                    type: "raw",
-                    id: row.fingerprint,
-                    recordId: record.id,
-                    record,
-                    message,
-                    tokens: estimateAgentMessageTokens(message),
-                });
+                // Raw history is owned by transcripts; legacy raw context rows must not replay it.
                 continue;
             }
             const summary = this.lcmStore.getSummary(row.summaryId);
@@ -359,8 +350,6 @@ function syncContextState(state, messages) {
         const replacement = rawById.get(item.id);
         if (replacement && !covered.has(item.id))
             next.push(replacement);
-        else if (item.recordId !== null && !covered.has(item.id))
-            next.push(item);
     }
     for (const item of rawItems) {
         if (!covered.has(item.id) && !next.some((existing) => existing.type === "raw" && existing.id === item.id)) {
@@ -390,8 +379,6 @@ function contextItemsForStorage(items) {
         const timestamp = item.message.timestamp;
         const happenedAt = typeof timestamp === "number" && Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
         if (item.type === "raw") {
-            if (item.recordId !== null)
-                stored.push({ type: "raw", recordId: item.recordId, fingerprint: item.id, happenedAt });
             continue;
         }
         if (item.persistedSummaryId !== undefined) {
@@ -522,9 +509,10 @@ function assembleWithinBudget(state, settings, model) {
     const freshTail = state.items.slice(resolveFreshTailStartIndexForState(state.items, settings));
     const selected = new Set(freshTail);
     let tokens = sumItemTokens(freshTail);
+    const originalIndexes = new Map(state.items.map((item, index) => [item, index]));
     const summaries = state.items
         .filter((item) => item.type === "summary" && !selected.has(item))
-        .sort((a, b) => b.depth - a.depth || state.items.indexOf(b) - state.items.indexOf(a));
+        .sort((a, b) => b.depth - a.depth || (originalIndexes.get(b) ?? 0) - (originalIndexes.get(a) ?? 0));
     for (const item of summaries) {
         if (tokens + item.tokens > budget && selected.size > 0)
             continue;
@@ -587,7 +575,7 @@ function lcmRecordPartsFromAgentMessage(message) {
                 kind: "tool_result",
                 toolCallId: toolResult.toolCallId ?? "",
                 toolName: toolResult.toolName ?? "tool",
-                output: toolResult.details ?? textFromContent(toolResult.content),
+                output: textFromContent(toolResult.content),
                 ...(toolResult.isError ? { isError: true } : {}),
             },
         ];

package/dist/memory/lcm/context.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { scoreEvictable, tokenBag } from "./eviction-score.js";
+import { buildEvictionScoreContext, scoreEvictable, tokenBag } from "./eviction-score.js";
 const MESSAGE_OVERHEAD_TOKENS = 6;
 const RECORD_OVERHEAD_TOKENS = 4;
 const IMAGE_TOKEN_ESTIMATE = 1200;
@@ -167,9 +167,12 @@ function selectLeafChunk(items, leafChunkTokens, promptText, config) {
     const records = items.map((item) => item.record).filter((record) => !!record);
     if (records.length === 0)
         return selectOldestLeafChunk(items, leafChunkTokens);
+    const scoreContext = buildEvictionScoreContext(promptText, records);
+    if (!scoreContext)
+        return selectOldestLeafChunk(items, leafChunkTokens);
     const scored = targetRanges.map((range) => ({
         ...range,
-        score: range.items.reduce((total, item) => total + (item.record ? scoreEvictable(item.record, promptText, records) : 0), 0),
+        score: range.items.reduce((total, item) => total + (item.record ? scoreEvictable(item.record, promptText, records, scoreContext) : 0), 0),
     }));
     scored.sort((a, b) => a.score - b.score || a.startIndex - b.startIndex);
     return scored[0]?.items ?? [];
@@ -179,7 +182,7 @@ function createValidLeafRanges(items, leafChunkTokens) {
     for (let startIndex = 0; startIndex < items.length; startIndex += 1) {
         if (isToolResultContinuingPreviousToolCall(items, startIndex))
             continue;
-        const chunk = selectOldestLeafChunk(items.slice(startIndex), leafChunkTokens);
+        const chunk = selectOldestLeafChunkFromIndex(items, startIndex, leafChunkTokens);
         if (chunk.length === 0)
             continue;
         const chunkTokens = chunk.reduce((total, item) => total + item.tokens, 0);
@@ -194,9 +197,12 @@ function createValidLeafRanges(items, leafChunkTokens) {
     return ranges;
 }
 function selectOldestLeafChunk(items, leafChunkTokens) {
+    return selectOldestLeafChunkFromIndex(items, 0, leafChunkTokens);
+}
+function selectOldestLeafChunkFromIndex(items, startIndex, leafChunkTokens) {
     const chunk = [];
     let tokens = 0;
-    for (let index = 0; index < items.length; index += 1) {
+    for (let index = startIndex; index < items.length; index += 1) {
         const item = items[index];
         if (!item)
             continue;

package/dist/memory/lcm/eviction-score.js

@@ -4,34 +4,46 @@ export function tokenBag(text) {
         .split(/[^a-z0-9]+/)
         .filter((token) => token.length >= 2);
 }
-export function scoreEvictable(record, prompt, allRecords) {
+export function buildEvictionScoreContext(prompt, allRecords) {
     const promptTerms = tokenBag(prompt);
     if (promptTerms.length === 0)
-        return 0;
-    const recordTerms = tokenBag(record.text);
-    if (recordTerms.length === 0)
-        return 0;
-    const recordFreq = new Map();
-    for (const term of recordTerms)
-        recordFreq.set(term, (recordFreq.get(term) ?? 0) + 1);
+        return null;
     const promptUniqueTerms = new Set(promptTerms);
     const documentFrequencies = new Map();
+    const recordTerms = new Map();
     for (const candidate of allRecords) {
-        const candidateTerms = new Set(tokenBag(candidate.text));
+        const terms = tokenBag(candidate.text);
+        recordTerms.set(candidate, terms);
+        const candidateTerms = new Set(terms);
         for (const term of promptUniqueTerms) {
             if (candidateTerms.has(term))
                 documentFrequencies.set(term, (documentFrequencies.get(term) ?? 0) + 1);
         }
     }
-    const candidateCount = Math.max(0, allRecords.length);
+    return {
+        promptUniqueTerms,
+        documentFrequencies,
+        recordTerms,
+        candidateCount: Math.max(0, allRecords.length),
+    };
+}
+export function scoreEvictable(record, prompt, allRecords, context = buildEvictionScoreContext(prompt, allRecords)) {
+    if (!context)
+        return 0;
+    const recordTerms = context.recordTerms.get(record) ?? tokenBag(record.text);
+    if (recordTerms.length === 0)
+        return 0;
+    const recordFreq = new Map();
+    for (const term of recordTerms)
+        recordFreq.set(term, (recordFreq.get(term) ?? 0) + 1);
     let score = 0;
-    for (const term of promptUniqueTerms) {
+    for (const term of context.promptUniqueTerms) {
         const tf = recordFreq.get(term) ?? 0;
         if (tf <= 0)
             continue;
         const normalizedTf = tf / recordTerms.length;
-        const df = documentFrequencies.get(term) ?? 0;
-        const idf = Math.log((candidateCount + 1) / (df + 1) + 1);
+        const df = context.documentFrequencies.get(term) ?? 0;
+        const idf = Math.log((context.candidateCount + 1) / (df + 1) + 1);
         score += normalizedTf * idf;
     }
     return score;

package/dist/memory/lcm/indexer.js

@@ -8,11 +8,7 @@ export async function projectNormalizedLcmBatch(options) {
     }
     const storedRecords = [];
     for (const record of options.batch.records) {
-        const id = options.lcmStore.insertRecord(record);
-        const stored = options.lcmStore.getRecord(id);
-        if (!stored)
-            throw new Error(`Failed to read projected LCM record: ${id}`);
-        storedRecords.push(stored);
+        storedRecords.push(options.lcmStore.insertRecordReturningStored(record).record);
     }
     return {
         segmentIds,

package/dist/memory/lcm/normalize.js

@@ -59,7 +59,7 @@ export function normalizeChatRecords(chatRecords, options) {
                     kind: "tool_result",
                     toolCallId: record.event.toolCallId,
                     toolName: record.event.toolName,
-                    output: record.event.result,
+                    output: toolResultVisibleOutput(record.event.result),
                     ...(record.event.isError ? { isError: true } : {}),
                 },
             ];
@@ -191,6 +191,27 @@ function briefJson(value, maxLength = 160) {
     const compact = text.replace(/\s+/g, " ").trim();
     return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}...` : compact;
 }
+function toolResultVisibleOutput(result) {
+    if (!result || typeof result !== "object" || !("content" in result))
+        return result;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return result;
+    return textFromToolResultContent(content);
+}
+function textFromToolResultContent(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content
+        .map((item) => {
+        if (item && typeof item === "object" && item.type === "text") {
+            return item.text;
+        }
+        return "";
+    })
+        .filter((item) => typeof item === "string" && item.length > 0)
+        .join("\n");
+}
 function chatRecordSource(record, sourcePath) {
     const messageId = "messageId" in record && typeof record.messageId === "string"
         ? record.messageId