@averyyy/pi-agent-core 0.80.3-piclient.10

package/dist/harness/compaction/compaction.js

@@ -0,0 +1,618 @@
+import { isContextOverflow } from "@earendil-works/pi-ai";
+import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
+import { buildSessionContext } from "../session/session.js";
+import { CompactionError, err, ok } from "../types.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, } from "./utils.js";
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
+function extractFileOperations(messages, entries, prevCompactionIndex) {
+    const fileOps = createFileOps();
+    if (prevCompactionIndex >= 0) {
+        const prevCompaction = entries[prevCompactionIndex];
+        if (!prevCompaction.fromHook && prevCompaction.details) {
+            const details = prevCompaction.details;
+            if (Array.isArray(details.readFiles)) {
+                for (const f of details.readFiles)
+                    fileOps.read.add(f);
+            }
+            if (Array.isArray(details.modifiedFiles)) {
+                for (const f of details.modifiedFiles)
+                    fileOps.edited.add(f);
+            }
+        }
+    }
+    for (const msg of messages) {
+        extractFileOpsFromMessage(msg, fileOps);
+    }
+    return fileOps;
+}
+function getMessageFromEntry(entry) {
+    if (entry.type === "message") {
+        return entry.message;
+    }
+    if (entry.type === "custom_message") {
+        return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp);
+    }
+    if (entry.type === "branch_summary") {
+        return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
+    }
+    if (entry.type === "compaction") {
+        return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
+    }
+    return undefined;
+}
+function getMessageFromEntryForCompaction(entry) {
+    if (entry.type === "compaction") {
+        return undefined;
+    }
+    return getMessageFromEntry(entry);
+}
+/** Default compaction settings used by the harness. */
+export const DEFAULT_COMPACTION_SETTINGS = {
+    enabled: true,
+    reserveTokens: 16384,
+    keepRecentTokens: 20000,
+};
+/** Calculate total context tokens from provider usage. */
+export function calculateContextTokens(usage) {
+    return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function getAssistantUsage(msg) {
+    if (msg.role === "assistant" && "usage" in msg) {
+        const assistantMsg = msg;
+        if (assistantMsg.stopReason !== "aborted" &&
+            assistantMsg.stopReason !== "error" &&
+            assistantMsg.usage &&
+            calculateContextTokens(assistantMsg.usage) > 0) {
+            return assistantMsg.usage;
+        }
+    }
+    return undefined;
+}
+/** Return usage from the last valid assistant message in session entries. */
+export function getLastAssistantUsage(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "message") {
+            const usage = getAssistantUsage(entry.message);
+            if (usage)
+                return usage;
+        }
+    }
+    return undefined;
+}
+function getLastAssistantUsageInfo(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const usage = getAssistantUsage(messages[i]);
+        if (usage)
+            return { usage, index: i };
+    }
+    return undefined;
+}
+/** Estimate context tokens for messages using provider usage when available. */
+export function estimateContextTokens(messages) {
+    const usageInfo = getLastAssistantUsageInfo(messages);
+    if (!usageInfo) {
+        let estimated = 0;
+        for (const message of messages) {
+            estimated += estimateTokens(message);
+        }
+        return {
+            tokens: estimated,
+            usageTokens: 0,
+            trailingTokens: estimated,
+            lastUsageIndex: null,
+        };
+    }
+    const usageTokens = calculateContextTokens(usageInfo.usage);
+    let trailingTokens = 0;
+    for (let i = usageInfo.index + 1; i < messages.length; i++) {
+        trailingTokens += estimateTokens(messages[i]);
+    }
+    return {
+        tokens: usageTokens + trailingTokens,
+        usageTokens,
+        trailingTokens,
+        lastUsageIndex: usageInfo.index,
+    };
+}
+/** Return whether context usage exceeds the configured compaction threshold. */
+export function shouldCompact(contextTokens, contextWindow, settings) {
+    if (!settings.enabled)
+        return false;
+    return contextTokens > contextWindow - settings.reserveTokens;
+}
+const ESTIMATED_IMAGE_CHARS = 4800;
+function estimateTextAndImageContentChars(content) {
+    if (typeof content === "string") {
+        return content.length;
+    }
+    let chars = 0;
+    for (const block of content) {
+        if (block.type === "text" && block.text) {
+            chars += block.text.length;
+        }
+        else if (block.type === "image") {
+            chars += ESTIMATED_IMAGE_CHARS;
+        }
+    }
+    return chars;
+}
+/** Estimate token count for one message using a conservative character heuristic. */
+export function estimateTokens(message) {
+    let chars = 0;
+    switch (message.role) {
+        case "user": {
+            chars = estimateTextAndImageContentChars(message.content);
+            return Math.ceil(chars / 4);
+        }
+        case "assistant": {
+            const assistant = message;
+            for (const block of assistant.content) {
+                if (block.type === "text") {
+                    chars += block.text.length;
+                }
+                else if (block.type === "thinking") {
+                    chars += block.thinking.length;
+                }
+                else if (block.type === "toolCall") {
+                    chars += block.name.length + safeJsonStringify(block.arguments).length;
+                }
+            }
+            return Math.ceil(chars / 4);
+        }
+        case "custom":
+        case "toolResult": {
+            chars = estimateTextAndImageContentChars(message.content);
+            return Math.ceil(chars / 4);
+        }
+        case "bashExecution": {
+            chars = message.command.length + message.output.length;
+            return Math.ceil(chars / 4);
+        }
+        case "branchSummary":
+        case "compactionSummary": {
+            chars = message.summary.length;
+            return Math.ceil(chars / 4);
+        }
+    }
+    return 0;
+}
+function findValidCutPoints(entries, startIndex, endIndex) {
+    const cutPoints = [];
+    for (let i = startIndex; i < endIndex; i++) {
+        const entry = entries[i];
+        switch (entry.type) {
+            case "message": {
+                const role = entry.message.role;
+                switch (role) {
+                    case "bashExecution":
+                    case "custom":
+                    case "branchSummary":
+                    case "compactionSummary":
+                    case "user":
+                    case "assistant":
+                        cutPoints.push(i);
+                        break;
+                    case "toolResult":
+                        break;
+                }
+                break;
+            }
+            case "thinking_level_change":
+            case "model_change":
+            case "active_tools_change":
+            case "compaction":
+            case "branch_summary":
+            case "custom":
+            case "custom_message":
+            case "label":
+            case "session_info":
+            case "leaf":
+                break;
+        }
+        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+            cutPoints.push(i);
+        }
+    }
+    return cutPoints;
+}
+/** Find the user-visible message that starts the turn containing an entry. */
+export function findTurnStartIndex(entries, entryIndex, startIndex) {
+    for (let i = entryIndex; i >= startIndex; i--) {
+        const entry = entries[i];
+        if (entry.type === "branch_summary" || entry.type === "custom_message") {
+            return i;
+        }
+        if (entry.type === "message") {
+            const role = entry.message.role;
+            if (role === "user" || role === "bashExecution") {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+/** Find the compaction cut point that keeps approximately the requested recent-token budget. */
+export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
+    const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+    if (cutPoints.length === 0) {
+        return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+    }
+    let accumulatedTokens = 0;
+    let cutIndex = cutPoints[0];
+    for (let i = endIndex - 1; i >= startIndex; i--) {
+        const entry = entries[i];
+        if (entry.type !== "message")
+            continue;
+        const messageTokens = estimateTokens(entry.message);
+        accumulatedTokens += messageTokens;
+        if (accumulatedTokens >= keepRecentTokens) {
+            for (let c = 0; c < cutPoints.length; c++) {
+                if (cutPoints[c] >= i) {
+                    cutIndex = cutPoints[c];
+                    break;
+                }
+            }
+            break;
+        }
+    }
+    while (cutIndex > startIndex) {
+        const prevEntry = entries[cutIndex - 1];
+        if (prevEntry.type === "compaction") {
+            break;
+        }
+        if (prevEntry.type === "message") {
+            break;
+        }
+        cutIndex--;
+    }
+    const cutEntry = entries[cutIndex];
+    const isUserMessage = cutEntry.type === "message" && cutEntry.message.role === "user";
+    const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+    return {
+        firstKeptEntryIndex: cutIndex,
+        turnStartIndex,
+        isSplitTurn: !isUserMessage && turnStartIndex !== -1,
+    };
+}
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Operational State
+- Modified files: [Exact paths, or "(none)"]
+- Read files: [Exact paths, or "(none)"]
+- Open failures: [Current unresolved failures/errors, or "(none)"]
+- Last command: [Most recent test/build/shell command and exit code, or "(none)"]
+- Last failing assertion/error: [Exact assertion, stack frame, or failing lines if available, or "(none)"]
+- Pending TODO: [Concrete remaining work, or "(none)"]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Operational State
+- Modified files: [Preserve/update exact paths, or "(none)"]
+- Read files: [Preserve/update exact paths, or "(none)"]
+- Open failures: [Current unresolved failures/errors, or "(none)"]
+- Last command: [Most recent test/build/shell command and exit code, or "(none)"]
+- Last failing assertion/error: [Exact assertion, stack frame, or failing lines if available, or "(none)"]
+- Pending TODO: [Concrete remaining work, or "(none)"]
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+function getSummaryMaxTokens(model, reserveTokens) {
+    return Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+}
+function estimateTextTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function buildSummaryPrompt(conversationText, basePrompt, previousSummary) {
+    let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
+    if (previousSummary) {
+        promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
+    }
+    return promptText + basePrompt;
+}
+function getSummaryInputBudget(model, maxTokens, basePrompt, previousSummary) {
+    if (model.contextWindow <= 0)
+        return Number.POSITIVE_INFINITY;
+    const overheadTokens = estimateTextTokens(buildSummaryPrompt("", basePrompt, previousSummary));
+    return Math.max(1, Math.floor(model.contextWindow - maxTokens - overheadTokens));
+}
+function toSummarySegments(messages) {
+    return messages
+        .map((message) => serializeConversation(convertToLlm([message])))
+        .filter((segment) => segment.length > 0);
+}
+function takeSummaryChunk(segments, tokenBudget) {
+    if (!Number.isFinite(tokenBudget))
+        return { chunk: segments.join("\n\n"), remaining: [] };
+    const chunk = [];
+    let chunkTokens = 0;
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const messageTokens = Math.max(1, estimateTextTokens(segment));
+        if (chunk.length === 0 && messageTokens > tokenBudget) {
+            const chunkChars = Math.max(1, Math.floor(tokenBudget * 4));
+            const remainingSegment = segment.slice(chunkChars);
+            const remaining = remainingSegment ? [remainingSegment, ...segments.slice(i + 1)] : segments.slice(i + 1);
+            return { chunk: segment.slice(0, chunkChars), remaining };
+        }
+        if (chunk.length > 0 && chunkTokens + messageTokens > tokenBudget) {
+            return { chunk: chunk.join("\n\n"), remaining: segments.slice(i) };
+        }
+        chunk.push(segment);
+        chunkTokens += messageTokens;
+    }
+    return { chunk: chunk.join("\n\n"), remaining: [] };
+}
+function getResponseText(response) {
+    return response.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+}
+async function summarizeChunk(conversationText, models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, previousSummary) {
+    const basePrompt = previousSummary ? updatePrompt : initialPrompt;
+    const promptText = buildSummaryPrompt(conversationText, basePrompt, previousSummary);
+    const summarizationMessages = [
+        {
+            role: "user",
+            content: [{ type: "text", text: promptText }],
+            timestamp: Date.now(),
+        },
+    ];
+    const response = await models.completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, model.reasoning && thinkingLevel && thinkingLevel !== "off"
+        ? { maxTokens, signal, reasoning: thinkingLevel }
+        : { maxTokens, signal });
+    if (isContextOverflow(response, model.contextWindow) && conversationText.length > 1) {
+        const middle = Math.ceil(conversationText.length / 2);
+        const leftSummary = await summarizeChunk(conversationText.slice(0, middle), models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, previousSummary);
+        if (!leftSummary.ok)
+            return leftSummary;
+        return summarizeChunk(conversationText.slice(middle), models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, leftSummary.value);
+    }
+    if (response.stopReason === "aborted") {
+        return err(new CompactionError("aborted", response.errorMessage || "Summarization aborted"));
+    }
+    if (response.stopReason === "error") {
+        return err(new CompactionError("summarization_failed", `Summarization failed: ${response.errorMessage || "Unknown error"}`));
+    }
+    return ok(getResponseText(response));
+}
+async function summarizeMessages(messages, models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, previousSummary) {
+    let remaining = toSummarySegments(messages);
+    if (remaining.length === 0) {
+        return summarizeChunk("", models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, previousSummary);
+    }
+    let summary = previousSummary;
+    while (remaining.length > 0) {
+        const basePrompt = summary ? updatePrompt : initialPrompt;
+        const next = takeSummaryChunk(remaining, getSummaryInputBudget(model, maxTokens, basePrompt, summary));
+        const chunkSummary = await summarizeChunk(next.chunk, models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, summary);
+        if (!chunkSummary.ok)
+            return chunkSummary;
+        summary = chunkSummary.value;
+        remaining = next.remaining;
+    }
+    return ok(summary ?? "");
+}
+/** Generate or update a conversation summary for compaction. */
+export async function generateSummary(currentMessages, models, model, reserveTokens, signal, customInstructions, previousSummary, thinkingLevel) {
+    const maxTokens = getSummaryMaxTokens(model, reserveTokens);
+    let initialPrompt = SUMMARIZATION_PROMPT;
+    let updatePrompt = UPDATE_SUMMARIZATION_PROMPT;
+    if (customInstructions) {
+        initialPrompt = `${initialPrompt}\n\nAdditional focus: ${customInstructions}`;
+        updatePrompt = `${updatePrompt}\n\nAdditional focus: ${customInstructions}`;
+    }
+    return summarizeMessages(currentMessages, models, model, maxTokens, signal, thinkingLevel, initialPrompt, updatePrompt, previousSummary);
+}
+/** Prepare session entries for compaction, or return undefined when compaction is not applicable. */
+export function prepareCompaction(pathEntries, settings, options = {}) {
+    if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1].type === "compaction") {
+        return ok(undefined);
+    }
+    let prevCompactionIndex = -1;
+    for (let i = pathEntries.length - 1; i >= 0; i--) {
+        if (pathEntries[i].type === "compaction") {
+            prevCompactionIndex = i;
+            break;
+        }
+    }
+    let previousSummary;
+    let boundaryStart = 0;
+    if (prevCompactionIndex >= 0) {
+        const prevCompaction = pathEntries[prevCompactionIndex];
+        previousSummary = prevCompaction.summary;
+        const firstKeptEntryIndex = pathEntries.findIndex((entry) => entry.id === prevCompaction.firstKeptEntryId);
+        boundaryStart = firstKeptEntryIndex >= 0 ? firstKeptEntryIndex : prevCompactionIndex + 1;
+    }
+    const boundaryEnd = pathEntries.length;
+    const tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens;
+    const forcedFirstKeptEntryIndex = options.firstKeptEntryId
+        ? pathEntries.findIndex((entry) => entry.id === options.firstKeptEntryId)
+        : -1;
+    if (options.firstKeptEntryId &&
+        (forcedFirstKeptEntryIndex < boundaryStart || forcedFirstKeptEntryIndex >= boundaryEnd)) {
+        return err(new CompactionError("invalid_session", "Forced first kept entry was not found"));
+    }
+    const cutPoint = forcedFirstKeptEntryIndex >= boundaryStart && forcedFirstKeptEntryIndex < boundaryEnd
+        ? { firstKeptEntryIndex: forcedFirstKeptEntryIndex, turnStartIndex: -1, isSplitTurn: false }
+        : findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
+    const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
+    if (!firstKeptEntry?.id) {
+        return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
+    }
+    const firstKeptEntryId = firstKeptEntry.id;
+    const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
+    const messagesToSummarize = [];
+    for (let i = boundaryStart; i < historyEnd; i++) {
+        const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+        if (msg)
+            messagesToSummarize.push(msg);
+    }
+    const turnPrefixMessages = [];
+    if (cutPoint.isSplitTurn) {
+        for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
+            const msg = getMessageFromEntryForCompaction(pathEntries[i]);
+            if (msg)
+                turnPrefixMessages.push(msg);
+        }
+    }
+    const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
+    if (cutPoint.isSplitTurn) {
+        for (const msg of turnPrefixMessages) {
+            extractFileOpsFromMessage(msg, fileOps);
+        }
+    }
+    return ok({
+        firstKeptEntryId,
+        messagesToSummarize,
+        turnPrefixMessages,
+        isSplitTurn: cutPoint.isSplitTurn,
+        tokensBefore,
+        previousSummary,
+        fileOps,
+        settings,
+    });
+}
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
+const UPDATE_TURN_PREFIX_SUMMARIZATION_PROMPT = `The messages above are the next part of the same oversized turn prefix.
+
+Update the existing turn-prefix summary in <previous-summary> tags. Keep the same sections:
+
+## Original Request
+## Early Progress
+## Context for Suffix
+
+Be concise. Preserve exact file paths, function names, and error messages.`;
+export { serializeConversation } from "./utils.js";
+/** Generate compaction summary data from prepared session history. */
+export async function compact(preparation, models, model, customInstructions, signal, thinkingLevel) {
+    const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, settings, } = preparation;
+    if (!firstKeptEntryId) {
+        return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
+    }
+    let summary;
+    if (isSplitTurn && turnPrefixMessages.length > 0) {
+        const [historyResult, turnPrefixResult] = await Promise.all([
+            messagesToSummarize.length > 0
+                ? generateSummary(messagesToSummarize, models, model, settings.reserveTokens, signal, customInstructions, previousSummary, thinkingLevel)
+                : Promise.resolve(ok("No prior history.")),
+            generateTurnPrefixSummary(turnPrefixMessages, models, model, settings.reserveTokens, signal, thinkingLevel),
+        ]);
+        if (!historyResult.ok)
+            return err(historyResult.error);
+        if (!turnPrefixResult.ok)
+            return err(turnPrefixResult.error);
+        summary = `${historyResult.value}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult.value}`;
+    }
+    else {
+        const summaryResult = await generateSummary(messagesToSummarize, models, model, settings.reserveTokens, signal, customInstructions, previousSummary, thinkingLevel);
+        if (!summaryResult.ok)
+            return err(summaryResult.error);
+        summary = summaryResult.value;
+    }
+    const { readFiles, modifiedFiles } = computeFileLists(fileOps);
+    summary += formatFileOperations(readFiles, modifiedFiles);
+    return ok({
+        summary,
+        firstKeptEntryId,
+        tokensBefore,
+        details: { readFiles, modifiedFiles },
+    });
+}
+async function generateTurnPrefixSummary(messages, models, model, reserveTokens, signal, thinkingLevel) {
+    const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+    const result = await summarizeMessages(messages, models, model, maxTokens, signal, thinkingLevel, TURN_PREFIX_SUMMARIZATION_PROMPT, UPDATE_TURN_PREFIX_SUMMARIZATION_PROMPT, undefined);
+    if (!result.ok && result.error.code === "summarization_failed") {
+        return err(new CompactionError("summarization_failed", `Turn prefix summarization failed: ${result.error.message.replace(/^Summarization failed: /, "")}`));
+    }
+    return result;
+}
+//# sourceMappingURL=compaction.js.map