@qearlyao/familiar 0.1.0

package/dist/memory/lcm/context.js

@@ -0,0 +1,421 @@
+import { createHash } from "node:crypto";
+import { scoreEvictable, tokenBag } from "./eviction-score.js";
+const MESSAGE_OVERHEAD_TOKENS = 6;
+const RECORD_OVERHEAD_TOKENS = 4;
+const IMAGE_TOKEN_ESTIMATE = 1200;
+export function estimateTextTokens(text) {
+    if (!text)
+        return 0;
+    let ascii = 0;
+    let nonAscii = 0;
+    for (const char of text) {
+        const codePoint = char.codePointAt(0) ?? 0;
+        if (codePoint <= 0x7f)
+            ascii += 1;
+        else
+            nonAscii += 1;
+    }
+    return Math.ceil(ascii / 3) + nonAscii;
+}
+export function estimateLcmRecordTokens(recordOrText) {
+    const text = typeof recordOrText === "string" ? recordOrText : recordOrText.text;
+    const attachments = typeof recordOrText === "string" ? null : recordOrText.attachments;
+    const attachmentText = attachments?.map(renderAttachmentForEstimate).filter(Boolean).join("\n") ?? "";
+    const contentTokens = estimateTextTokens([text, attachmentText].filter(Boolean).join("\n"));
+    return contentTokens > 0 ? contentTokens + RECORD_OVERHEAD_TOKENS : 0;
+}
+export function estimateAgentMessageTokens(message) {
+    const role = message.role;
+    switch (role) {
+        case "user":
+            return estimateUserMessageTokens(message);
+        case "assistant":
+            return estimateAssistantMessageTokens(message);
+        case "toolResult":
+            return estimateToolResultMessageTokens(message);
+        default:
+            return estimateFallbackMessageTokens(message);
+    }
+}
+export function createAgentMessageFingerprint(message, _index) {
+    const timestamp = message.timestamp;
+    const id = message.id;
+    const text = messageTextForFingerprint(message);
+    const payload = typeof timestamp === "number" && Number.isFinite(timestamp)
+        ? { role: message.role ?? null, timestamp, text }
+        : typeof id === "string" && id.trim()
+            ? { role: message.role ?? null, id, text }
+            : { text };
+    return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+export function createRawContextItems(messages) {
+    return messages.map((message, index) => ({
+        id: createAgentMessageFingerprint(message, index),
+        message,
+        tokens: estimateAgentMessageTokens(message),
+    }));
+}
+export function lcmRecordToAgentMessage(record) {
+    const timestamp = Date.parse(record.happenedAt);
+    const messageTimestamp = Number.isFinite(timestamp) ? timestamp : Date.now();
+    if (record.parts?.length)
+        return structuredLcmRecordToAgentMessage(record, messageTimestamp);
+    if (record.kind === "assistant")
+        return fallbackAssistantMessage(record.text, messageTimestamp);
+    if (record.kind === "tool")
+        return fallbackAssistantMessage(record.text, messageTimestamp);
+    return { role: "user", content: record.text, timestamp: messageTimestamp };
+}
+export function renderLcmRecordPartsForSummary(parts) {
+    return parts
+        .map((part) => {
+        if (part.kind === "text")
+            return part.text.trim();
+        if (part.kind === "thinking")
+            return part.text.trim() ? `<thinking>${part.text.trim()}</thinking>` : "";
+        if (part.kind === "tool_call") {
+            return `<tool_call name="${escapeXmlAttribute(part.toolName)}">${formatJsonForSummary(part.arguments)}</tool_call>`;
+        }
+        return `<tool_result name="${escapeXmlAttribute(part.toolName)}">${truncateForSummary(formatJsonForSummary(part.output))}</tool_result>`;
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+export function selectLcmCompactionCandidate(items, config, tokenBudget, additionalContextTokens = 0) {
+    return selectLcmCompactionCandidatePromptAware(items, config, tokenBudget, "", additionalContextTokens);
+}
+export function selectLcmCompactionCandidatePromptAware(items, config, tokenBudget, promptText, additionalContextTokens = 0) {
+    const freshTailStartIndex = resolveFreshTailStartIndex(items, config);
+    const compactable = items.slice(0, freshTailStartIndex);
+    const rawTokensOutsideTail = compactable.reduce((total, item) => total + item.tokens, 0);
+    const totalTokens = items.reduce((total, item) => total + item.tokens, 0) + Math.max(0, additionalContextTokens);
+    const contextThresholdTokens = Math.max(1, Math.floor(config.contextThreshold * tokenBudget));
+    const reasons = [];
+    if (rawTokensOutsideTail >= config.leafChunkTokens)
+        reasons.push("leaf_chunk");
+    if (totalTokens > contextThresholdTokens && compactable.length > 0)
+        reasons.push("context_threshold");
+    const chunk = reasons.length > 0 ? selectLeafChunk(compactable, config.leafChunkTokens, promptText, config) : [];
+    const chunkTokens = chunk.reduce((total, item) => total + item.tokens, 0);
+    return {
+        shouldCompact: chunk.length > 0,
+        reasons,
+        chunk,
+        chunkTokens,
+        rawTokensOutsideTail,
+        freshTailStartIndex,
+        totalTokens,
+        contextThresholdTokens,
+    };
+}
+function estimateUserMessageTokens(message) {
+    return MESSAGE_OVERHEAD_TOKENS + estimateContentTokens(message.content);
+}
+function estimateAssistantMessageTokens(message) {
+    let tokens = MESSAGE_OVERHEAD_TOKENS;
+    for (const block of message.content) {
+        if (block.type === "text")
+            tokens += estimateTextTokens(block.text);
+        else if (block.type === "thinking")
+            tokens += estimateTextTokens(block.thinking);
+        else if (block.type === "toolCall") {
+            tokens += estimateTextTokens(block.name);
+            tokens += estimateJsonTokens(block.arguments);
+        }
+    }
+    return tokens;
+}
+function estimateToolResultMessageTokens(message) {
+    return MESSAGE_OVERHEAD_TOKENS + estimateTextTokens(message.toolName) + estimateContentTokens(message.content);
+}
+function estimateFallbackMessageTokens(message) {
+    const text = JSON.stringify(message) ?? "";
+    return text ? MESSAGE_OVERHEAD_TOKENS + estimateTextTokens(text) : 0;
+}
+export function resolveFreshTailStartIndex(items, config) {
+    const protectedByCountStart = Math.max(0, items.length - Math.max(0, config.freshTailCount));
+    if (config.freshTailMaxTokens === undefined)
+        return protectedByCountStart;
+    let tokenStart = items.length;
+    let tokens = 0;
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+        const item = items[index];
+        if (!item)
+            continue;
+        if (tokens + item.tokens > config.freshTailMaxTokens)
+            break;
+        tokens += item.tokens;
+        tokenStart = index;
+    }
+    return Math.max(protectedByCountStart, tokenStart);
+}
+function selectLeafChunk(items, leafChunkTokens, promptText, config) {
+    if (config.promptAwareEvictionEnabled === false || tokenBag(promptText).length === 0) {
+        return selectOldestLeafChunk(items, leafChunkTokens);
+    }
+    const ranges = createValidLeafRanges(items, leafChunkTokens);
+    if (ranges.length === 0)
+        return [];
+    if (!ranges.some((range) => range.tokens >= leafChunkTokens))
+        return selectOldestLeafChunk(items, leafChunkTokens);
+    const targetRanges = ranges.filter((range) => range.tokens >= leafChunkTokens);
+    const records = items.map((item) => item.record).filter((record) => !!record);
+    if (records.length === 0)
+        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),
+    }));
+    scored.sort((a, b) => a.score - b.score || a.startIndex - b.startIndex);
+    return scored[0]?.items ?? [];
+}
+function createValidLeafRanges(items, leafChunkTokens) {
+    const ranges = [];
+    for (let startIndex = 0; startIndex < items.length; startIndex += 1) {
+        if (isToolResultContinuingPreviousToolCall(items, startIndex))
+            continue;
+        const chunk = selectOldestLeafChunk(items.slice(startIndex), leafChunkTokens);
+        if (chunk.length === 0)
+            continue;
+        const chunkTokens = chunk.reduce((total, item) => total + item.tokens, 0);
+        const endIndex = startIndex + chunk.length - 1;
+        const next = items[endIndex + 1];
+        if (chunkTokens < leafChunkTokens && next && chunkTokens + next.tokens <= leafChunkTokens)
+            continue;
+        if (splitsFollowingToolResult(items, chunk, endIndex))
+            continue;
+        ranges.push({ startIndex, items: chunk, tokens: chunkTokens });
+    }
+    return ranges;
+}
+function selectOldestLeafChunk(items, leafChunkTokens) {
+    const chunk = [];
+    let tokens = 0;
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (!item)
+            continue;
+        if (chunk.length > 0 && tokens + item.tokens > leafChunkTokens && !continuesSelectedToolCall(chunk, item)) {
+            break;
+        }
+        chunk.push(item);
+        tokens += item.tokens;
+        const next = items[index + 1];
+        if (tokens >= leafChunkTokens && (!next || !continuesSelectedToolCall(chunk, next)))
+            break;
+    }
+    return chunk;
+}
+function isToolResultContinuingPreviousToolCall(items, index) {
+    const item = items[index];
+    if (!item)
+        return false;
+    const toolCallId = item.message.toolCallId;
+    if (item.message.role !== "toolResult" || !toolCallId)
+        return false;
+    return items.slice(0, index).some((previous) => hasAssistantToolCall(previous.message, toolCallId));
+}
+function splitsFollowingToolResult(items, chunk, endIndex) {
+    const next = items[endIndex + 1];
+    if (!next)
+        return false;
+    return continuesSelectedToolCall(chunk, next);
+}
+function continuesSelectedToolCall(chunk, item) {
+    const toolCallId = item.message.toolCallId;
+    if (item.message.role !== "toolResult" || !toolCallId)
+        return false;
+    return chunk.some((chunkItem) => hasAssistantToolCall(chunkItem.message, toolCallId));
+}
+function hasAssistantToolCall(message, toolCallId) {
+    if (message.role !== "assistant" || !("content" in message))
+        return false;
+    const content = message.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((item) => item.type === "toolCall" && item.id === toolCallId);
+}
+function estimateContentTokens(content) {
+    if (typeof content === "string")
+        return estimateTextTokens(content);
+    let tokens = 0;
+    for (const block of content) {
+        if (block.type === "text")
+            tokens += estimateTextTokens(block.text);
+        else if (block.type === "image")
+            tokens += IMAGE_TOKEN_ESTIMATE;
+    }
+    return tokens;
+}
+function estimateJsonTokens(value) {
+    return estimateTextTokens(JSON.stringify(value) ?? "");
+}
+function renderAttachmentForEstimate(attachment) {
+    return [attachment.name, attachment.kind, attachment.mimeType, attachment.text, attachment.note]
+        .filter((part) => typeof part === "string" && part.length > 0)
+        .join(" ");
+}
+export function selectRetainedSummaries(summaries) {
+    const ready = summaries
+        .filter((summary) => summary.status === "ready" && summary.text.trim().length > 0)
+        .sort(compareSummaries);
+    const covered = new Set();
+    const selected = [];
+    for (const summary of ready) {
+        if (covered.has(summary.id))
+            continue;
+        selected.push(summary);
+        coverSummaryParents(summary, ready, covered);
+    }
+    return selected;
+}
+function coverSummaryParents(summary, summaries, covered) {
+    for (const parentId of summary.parents) {
+        if (covered.has(parentId))
+            continue;
+        covered.add(parentId);
+        const parent = summaries.find((candidate) => candidate.id === parentId);
+        if (parent)
+            coverSummaryParents(parent, summaries, covered);
+    }
+}
+function compareSummaries(a, b) {
+    return (Number(b.pinned) - Number(a.pinned) ||
+        a.segmentId.localeCompare(b.segmentId) ||
+        b.depth - a.depth ||
+        (a.coversFromRecordId ?? Number.MAX_SAFE_INTEGER) - (b.coversFromRecordId ?? Number.MAX_SAFE_INTEGER) ||
+        a.id - b.id);
+}
+function structuredLcmRecordToAgentMessage(record, timestamp) {
+    if (record.kind === "tool") {
+        const result = record.parts?.find((part) => {
+            return part.kind === "tool_result";
+        });
+        if (!result)
+            return fallbackAssistantMessage(record.text, timestamp);
+        return {
+            role: "toolResult",
+            toolCallId: result.toolCallId,
+            toolName: result.toolName,
+            content: [{ type: "text", text: stringifyPartValue(result.output) }],
+            details: result.output,
+            isError: result.isError ?? false,
+            timestamp,
+        };
+    }
+    if (record.kind === "assistant") {
+        return {
+            ...fallbackAssistantMessage("", timestamp),
+            content: structuredAssistantContent(record.parts ?? []),
+            stopReason: record.parts?.some((part) => part.kind === "tool_call") ? "toolUse" : "stop",
+        };
+    }
+    return {
+        role: "user",
+        content: structuredUserContent(record.parts ?? [], record.text),
+        timestamp,
+    };
+}
+function structuredAssistantContent(parts) {
+    const content = [];
+    for (const part of parts) {
+        if (part.kind === "text" && part.text)
+            content.push({ type: "text", text: part.text });
+        else if (part.kind === "thinking" && part.text) {
+            content.push({
+                type: "thinking",
+                thinking: part.text,
+                ...(part.signature ? { thinkingSignature: part.signature } : {}),
+            });
+        }
+        else if (part.kind === "tool_call") {
+            content.push({
+                type: "toolCall",
+                id: part.toolCallId,
+                name: part.toolName,
+                arguments: normalizeToolArguments(part.arguments),
+            });
+        }
+    }
+    return content.length ? content : [{ type: "text", text: "" }];
+}
+function structuredUserContent(parts, fallback) {
+    const text = parts
+        .filter((part) => part.kind === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+    return text || fallback;
+}
+function fallbackAssistantMessage(text, timestamp) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text }],
+        api: "lcm",
+        provider: "familiar",
+        model: "lcm-record",
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "stop",
+        timestamp,
+    };
+}
+function normalizeToolArguments(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringifyPartValue(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function formatJsonForSummary(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function truncateForSummary(text, maxLength = 2_000) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxLength)
+        return trimmed;
+    return `${trimmed.slice(0, maxLength)}\n...[truncated]`;
+}
+function escapeXmlAttribute(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function messageTextForFingerprint(message) {
+    if (!("content" in message))
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((item) => {
+        if (item.type === "text")
+            return item.text;
+        if (item.type === "thinking")
+            return item.thinking;
+        if (item.type === "toolCall")
+            return `${item.name}\n${JSON.stringify(item.arguments)}`;
+        if (item.type === "image")
+            return item.mimeType;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}

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

@@ -0,0 +1,38 @@
+export function tokenBag(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length >= 2);
+}
+export function scoreEvictable(record, 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);
+    const promptUniqueTerms = new Set(promptTerms);
+    const documentFrequencies = new Map();
+    for (const candidate of allRecords) {
+        const candidateTerms = new Set(tokenBag(candidate.text));
+        for (const term of promptUniqueTerms) {
+            if (candidateTerms.has(term))
+                documentFrequencies.set(term, (documentFrequencies.get(term) ?? 0) + 1);
+        }
+    }
+    const candidateCount = Math.max(0, allRecords.length);
+    let score = 0;
+    for (const term of 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);
+        score += normalizedTf * idf;
+    }
+    return score;
+}

package/dist/memory/lcm/index.js

@@ -0,0 +1,6 @@
+export * from "./condense.js";
+export * from "./indexer.js";
+export * from "./normalize.js";
+export * from "./schema.js";
+export * from "./store.js";
+export * from "./types.js";

package/dist/memory/lcm/indexer.js

@@ -0,0 +1,200 @@
+import { lcmRecordIndexSourceId, lcmSummaryIndexSourceId } from "./store.js";
+export const LCM_RECORD_CORPUS = "lcm_record";
+export const LCM_SUMMARY_CORPUS = "lcm_summary";
+export async function projectNormalizedLcmBatch(options) {
+    const segmentIds = [];
+    for (const segment of options.batch.segments) {
+        segmentIds.push(options.lcmStore.ensureSegment(segment).id);
+    }
+    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);
+    }
+    return {
+        segmentIds,
+        recordIds: storedRecords.map((record) => record.id),
+        recordIndex: await indexLcmRecords({ indexer: options.indexer, records: storedRecords, signal: options.signal }),
+    };
+}
+export async function indexLcmRecords(options) {
+    return options.indexer.indexChunks(lcmRecordsToIndexInputs(options.records), options.signal);
+}
+export async function indexLcmSummaries(options) {
+    return options.indexer.indexChunks(lcmSummariesToIndexInputs(options.summaries), options.signal);
+}
+export function lcmRecordsToIndexInputs(records) {
+    return records.map(lcmRecordToIndexInput).filter((input) => input !== null);
+}
+export function lcmSummariesToIndexInputs(summaries) {
+    return summaries.map(lcmSummaryToIndexInput).filter((input) => input !== null);
+}
+export function lcmRecordToIndexInput(record) {
+    const text = memoryTextForLcmRecord(record);
+    if (!text)
+        return null;
+    return {
+        corpus: LCM_RECORD_CORPUS,
+        sourceId: lcmRecordIndexSourceId(record.id),
+        sourceRef: record.source.sourceRef ?? null,
+        chunkIndex: 0,
+        text,
+        snippet: lcmRecordSnippet(record),
+        metadata: {
+            id: record.id,
+            kind: record.kind,
+            segmentId: record.segmentId,
+            timestamp: record.happenedAt,
+            happenedAt: record.happenedAt,
+            sessionId: record.sessionId,
+            channelKey: record.channelKey,
+            channelId: record.channelId,
+            jobId: record.jobId,
+            source: record.source,
+        },
+    };
+}
+export function lcmSummaryToIndexInput(summary) {
+    const text = summary.text.trim();
+    if (!text || summary.status !== "ready")
+        return null;
+    return {
+        corpus: LCM_SUMMARY_CORPUS,
+        sourceId: lcmSummaryIndexSourceId(summary.id),
+        sourceRef: summary.source.sourceRef ?? null,
+        chunkIndex: 0,
+        text,
+        snippet: lcmSummarySnippet(summary),
+        metadata: {
+            id: summary.id,
+            segmentId: summary.segmentId,
+            depth: summary.depth,
+            status: summary.status,
+            pinned: summary.pinned,
+            coversFromRecordId: summary.coversFromRecordId,
+            coversToRecordId: summary.coversToRecordId,
+            ...summaryCoverageMetadata(summary),
+            source: summary.source,
+        },
+    };
+}
+function lcmRecordSnippet(record) {
+    return `[${record.kind}] ${memoryTextForLcmRecord(record)}`.slice(0, 280);
+}
+function lcmSummarySnippet(summary) {
+    return `[d${summary.depth}] ${summary.text}`.slice(0, 280);
+}
+function summaryCoverageMetadata(summary) {
+    const existingFrom = metadataString(summary.metadata?.coverageFromHappenedAt);
+    const existingTo = metadataString(summary.metadata?.coverageToHappenedAt) ?? metadataString(summary.metadata?.timestamp);
+    const from = existingFrom ?? firstSnapshotHappenedAt(summary.snapshot);
+    const to = existingTo ?? lastSnapshotHappenedAt(summary.snapshot);
+    return {
+        ...(from ? { coverageFromHappenedAt: from } : {}),
+        ...(to ? { coverageToHappenedAt: to, timestamp: to } : {}),
+    };
+}
+function metadataString(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value)) ? value : null;
+}
+function firstSnapshotHappenedAt(snapshot) {
+    if (!Array.isArray(snapshot))
+        return null;
+    for (const item of snapshot) {
+        if (isSnapshotRecord(item) && isIsoTimeString(item.happened_at))
+            return item.happened_at;
+        const nested = isParentSnapshot(item) ? firstSnapshotHappenedAt(item.snapshot) : null;
+        if (nested)
+            return nested;
+    }
+    return null;
+}
+function lastSnapshotHappenedAt(snapshot) {
+    if (!Array.isArray(snapshot))
+        return null;
+    for (let index = snapshot.length - 1; index >= 0; index -= 1) {
+        const item = snapshot[index];
+        if (isSnapshotRecord(item) && isIsoTimeString(item.happened_at))
+            return item.happened_at;
+        const nested = isParentSnapshot(item) ? lastSnapshotHappenedAt(item.snapshot) : null;
+        if (nested)
+            return nested;
+    }
+    return null;
+}
+function isSnapshotRecord(item) {
+    return typeof item === "object" && item !== null && "happened_at" in item;
+}
+function isParentSnapshot(item) {
+    return typeof item === "object" && item !== null && "snapshot" in item;
+}
+function isIsoTimeString(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function memoryTextForLcmRecord(record) {
+    if (record.kind === "user")
+        return visibleTextFromRecord(record);
+    if (record.kind === "assistant")
+        return visibleTextFromRecord(record);
+    if (record.kind === "note" || record.kind === "boundary")
+        return record.text.trim();
+    return "";
+}
+function visibleTextFromRecord(record) {
+    if (!record.parts?.length)
+        return normalizeVisibleText(record.text, record.kind).trim();
+    const text = record.parts
+        .filter((part) => part.kind === "text")
+        .map((part) => part.text.trim())
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+    return normalizeVisibleText(text, record.kind).trim();
+}
+function normalizeVisibleText(text, kind) {
+    const visible = kind === "assistant" ? stripNoisyRecordMarkers(text) : text;
+    return collapseDuplicatedVisibleText(visible);
+}
+function stripNoisyRecordMarkers(text) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => !isNoisyRecordMarkerLine(line))
+        .join("\n");
+}
+function isNoisyRecordMarkerLine(line) {
+    const trimmed = line.trim();
+    if (/^\[(?:thinking|tool_call|tool_result)\]$/.test(trimmed))
+        return true;
+    if (/^\[thinking\]\s*\S/.test(trimmed))
+        return true;
+    if (/^\[tool_call:\s*[\w.-]+\s*\(.*\)\]$/.test(trimmed))
+        return true;
+    if (/^\[tool_result:\s*[\w.-]+\s*->\s*.*\]$/.test(trimmed))
+        return true;
+    return false;
+}
+function collapseDuplicatedVisibleText(text) {
+    let normalized = text.trim();
+    for (let iteration = 0; iteration < 4; iteration += 1) {
+        const collapsed = collapseOnce(normalized);
+        if (collapsed === normalized)
+            return normalized;
+        normalized = collapsed;
+    }
+    return normalized;
+}
+function collapseOnce(text) {
+    for (let split = Math.floor(text.length / 2); split >= 24; split -= 1) {
+        const left = text.slice(0, split).trim();
+        const right = text.slice(split).trim();
+        if (left && normalizeComparableText(left) === normalizeComparableText(right))
+            return left;
+    }
+    return text;
+}
+function normalizeComparableText(text) {
+    return text.replace(/\s+/g, " ").trim().toLowerCase();
+}