@sema-agent/core 1.279.0

package/dist/engine/compaction/compaction.js

@@ -0,0 +1,770 @@
+import { resolveAgentCoreCompleteFn, } from "../loop/runtime-deps.js";
+import { asAgentMessage, convertToLlm, createCompactionSummaryMessage, createCustomMessage, } from "../harness/messages.js";
+import { buildSessionContext } from "../session/session.js";
+import { CompactionError, err, ok, } from "../harness/types.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, stripFileOperationsFooter, } 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);
+                }
+                const prevRecency = details.modifiedFilesByRecency;
+                if (Array.isArray(prevRecency)) {
+                    for (const f of prevRecency.toReversed()) {
+                        fileOps.modifiedOrder.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 asAgentMessage(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
+    }
+    if (entry.type === "compaction") {
+        return asAgentMessage(createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp));
+    }
+    return undefined;
+}
+function getMessageFromEntryForCompaction(entry) {
+    if (entry.type === "compaction") {
+        return undefined;
+    }
+    return getMessageFromEntry(entry);
+}
+export const DEFAULT_COMPACTION_SETTINGS = {
+    enabled: true,
+    reserveTokens: 16384,
+    keepRecentTokens: 20000,
+};
+export const DEFAULT_CHARS_PER_TOKEN = 4;
+const IMAGE_TOKEN_ESTIMATE = 2000;
+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.usage &&
+            calculateContextTokens(assistantMsg.usage) > 0) {
+            return assistantMsg.usage;
+        }
+    }
+    return undefined;
+}
+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;
+}
+export function estimateContextTokens(messages, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+    const usageInfo = getLastAssistantUsageInfo(messages);
+    if (!usageInfo) {
+        let estimated = 0;
+        for (const message of messages) {
+            estimated += estimateTokens(message, charsPerToken);
+        }
+        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], charsPerToken);
+    }
+    return {
+        tokens: usageTokens + trailingTokens,
+        usageTokens,
+        trailingTokens,
+        lastUsageIndex: usageInfo.index,
+    };
+}
+export function shouldCompact(contextTokens, contextWindow, settings) {
+    if (!settings.enabled) {
+        return false;
+    }
+    return contextTokens > contextWindow - settings.reserveTokens;
+}
+export function estimateTokens(message, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+    let chars = 0;
+    const harnessMessage = message;
+    switch (harnessMessage.role) {
+        case "user": {
+            const content = harnessMessage.content;
+            let imageTokens = 0;
+            if (typeof content === "string") {
+                chars = content.length;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === "text" && block.text) {
+                        chars += block.text.length;
+                    }
+                    if (block.type === "image") {
+                        imageTokens += IMAGE_TOKEN_ESTIMATE;
+                    }
+                    if (block.type === "document" && typeof block.data === "string") {
+                        imageTokens += Math.max(IMAGE_TOKEN_ESTIMATE, Math.ceil(block.data.length / 36));
+                    }
+                }
+            }
+            return Math.ceil(chars / charsPerToken) + imageTokens;
+        }
+        case "assistant": {
+            const assistant = harnessMessage;
+            for (const block of assistant.content) {
+                if (block.type === "text") {
+                    chars += block.text.length;
+                }
+                else if (block.type === "thinking") {
+                    chars += block.thinking.length + (block.thinkingSignature?.length ?? 0);
+                }
+                else if (block.type === "toolCall") {
+                    chars += block.name.length + safeJsonStringify(block.arguments).length;
+                }
+            }
+            return Math.ceil(chars / charsPerToken);
+        }
+        case "custom":
+        case "toolResult": {
+            let imageTokens = 0;
+            if (typeof harnessMessage.content === "string") {
+                chars = harnessMessage.content.length;
+            }
+            else {
+                for (const block of harnessMessage.content) {
+                    if (block.type === "text" && block.text) {
+                        chars += block.text.length;
+                    }
+                    if (block.type === "image") {
+                        imageTokens += IMAGE_TOKEN_ESTIMATE;
+                    }
+                    if (block.type === "document" && typeof block.data === "string") {
+                        imageTokens += Math.max(IMAGE_TOKEN_ESTIMATE, Math.ceil(block.data.length / 36));
+                    }
+                }
+            }
+            return Math.ceil(chars / charsPerToken) + imageTokens;
+        }
+        case "bashExecution": {
+            chars = harnessMessage.command.length + harnessMessage.output.length;
+            return Math.ceil(chars / charsPerToken);
+        }
+        case "compactionSummary": {
+            chars = harnessMessage.summary.length;
+            return Math.ceil(chars / charsPerToken);
+        }
+    }
+    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 "compactionSummary":
+                    case "user":
+                    case "assistant":
+                        cutPoints.push(i);
+                        break;
+                    case "toolResult":
+                        break;
+                }
+                break;
+            }
+            case "custom_message":
+                cutPoints.push(i);
+                break;
+            case "thinking_level_change":
+            case "model_change":
+            case "compaction":
+            case "custom":
+            case "label":
+            case "session_info":
+            case "leaf":
+                break;
+        }
+    }
+    return cutPoints;
+}
+export function findTurnStartIndex(entries, entryIndex, startIndex) {
+    for (let i = entryIndex; i >= startIndex; i--) {
+        const entry = entries[i];
+        if (entry.type === "custom_message") {
+            return i;
+        }
+        if (entry.type === "message") {
+            const role = entry.message.role;
+            if (role === "user" || role === "bashExecution") {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+    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, charsPerToken);
+        accumulatedTokens += messageTokens;
+        if (accumulatedTokens >= keepRecentTokens) {
+            let found = false;
+            for (const cutPoint of cutPoints) {
+                if (cutPoint >= i) {
+                    cutIndex = cutPoint;
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                for (let c = cutPoints.length - 1; c >= 0; 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 coding 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. Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.
+This summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing development work without losing context. Another LLM will use it to continue the work.
+
+Before providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. This analysis is scratch work — it will be stripped and NOT kept, so it is only to help you write a faithful summary. In your analysis process:
+
+1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:
+   - The user's explicit requests and intents
+   - Your approach to addressing the user's requests
+   - Key decisions, technical concepts and code patterns
+   - Specific details like:
+     - file names
+     - full code snippets
+     - function signatures
+     - file edits
+   - Errors that you ran into and how you fixed them
+   - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+   - Note any security-relevant instructions or constraints the user stated (e.g., sensitive files or data to avoid, operations that must not be performed, credential or secret handling rules). These MUST be preserved verbatim in the summary so they continue to apply after compaction.
+2. Double-check for technical accuracy and completeness, addressing each required element thoroughly.
+
+Then, after </analysis>, write the summary. Your summary should include the following sections:
+
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.
+7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+8. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+9. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests or really old requests that were already completed without confirming with the user first.
+   If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.
+
+Please provide your summary based on the conversation so far, following this structure and ensuring precision and thoroughness in your response.
+
+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 "Pending Tasks" and "Current Work" based on what was accomplished
+- UPDATE "Optional Next Step" based on the most recent work
+- PRESERVE exact file paths, function names, and error messages
+- Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction
+- If something is no longer relevant, you may remove it
+
+First, inside an <analysis>...</analysis> block, note what is new since the previous summary and what must change. This analysis is scratch work — it will be stripped and NOT kept. Then, after </analysis>, write the updated summary with the following sections:
+
+1. Primary Request and Intent: [Preserve existing requests and intents, add new ones if the task expanded]
+2. Key Technical Concepts: [Preserve existing, add newly discussed concepts, technologies, and frameworks]
+3. Files and Code Sections: [Preserve entries still relevant; add newly examined, modified, or created files with full code snippets where applicable]
+4. Errors and fixes: [Preserve previous errors and fixes and add new ones; keep any user correction or "change of approach" feedback verbatim.]
+5. Problem Solving: [Update problems solved and any ongoing troubleshooting efforts]
+6. All user messages: [Preserve previously-recorded user messages VERBATIM and append any new ones that are not tool results, in order. To bound growth across repeated compactions, keep roughly the most recent 20 messages verbatim; older ones beyond that may be condensed to a single line each — but NEVER drop or paraphrase a user correction or change of direction. The exact words of recent messages are the strongest anti-drift signal. Preserve any security-relevant instructions or constraints verbatim so they remain in effect after compaction.]
+7. Pending Tasks: [Update based on progress — remove completed tasks, add newly requested ones]
+8. Current Work: [Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant]
+9. Optional Next Step: [Update based on current state. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request — include a direct verbatim quote of that request. Do not start on tangential requests or really old requests that were already completed.]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+function createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel) {
+    const options = { maxTokens, signal, apiKey, headers };
+    if (model.reasoning && thinkingLevel && thinkingLevel !== "off") {
+        options.reasoning = thinkingLevel;
+    }
+    return options;
+}
+async function completeSummarization(model, context, options, streamFn, runtime) {
+    if (streamFn) {
+        return (await streamFn(model, context, options)).result();
+    }
+    return await resolveAgentCoreCompleteFn(runtime)(model, context, options);
+}
+const SUMMARY_REASONING_FLOOR = 2048;
+const SUMMARY_MAX_ESCALATIONS = 2;
+const SUMMARY_WINDOW_MARGIN = 256;
+function estimateSummarizationInputTokens(context, charsPerToken) {
+    let chars = context.systemPrompt?.length ?? 0;
+    for (const m of context.messages) {
+        const content = m.content;
+        if (typeof content === "string") {
+            chars += content.length;
+        }
+        else if (Array.isArray(content)) {
+            for (const c of content) {
+                chars += c.text?.length ?? 0;
+            }
+        }
+    }
+    return Math.ceil(chars / charsPerToken);
+}
+const SUMMARY_INPUT_HEAD_RATIO = 0.25;
+const SUMMARY_INPUT_MIN_KEEP_CHARS = 1024;
+const SUMMARY_INPUT_MARKER_RESERVE = 200;
+function clampSummarizationConversation(conversationText, model, charsPerToken, fixedPromptChars, baseMaxTokens, budgetCapChars) {
+    let budgetChars = Number.POSITIVE_INFINITY;
+    if (model.contextWindow > 0) {
+        const outputReserve = Math.max(baseMaxTokens, SUMMARY_REASONING_FLOOR);
+        budgetChars =
+            (model.contextWindow - outputReserve - 2 * SUMMARY_WINDOW_MARGIN) * charsPerToken - fixedPromptChars;
+    }
+    if (budgetCapChars !== undefined) {
+        budgetChars = Math.min(budgetChars, budgetCapChars);
+    }
+    if (!Number.isFinite(budgetChars) || conversationText.length <= budgetChars) {
+        return { text: conversationText, droppedChars: 0, keptChars: conversationText.length };
+    }
+    const keep = Math.max(budgetChars - SUMMARY_INPUT_MARKER_RESERVE, SUMMARY_INPUT_MIN_KEEP_CHARS);
+    const headChars = Math.floor(keep * SUMMARY_INPUT_HEAD_RATIO);
+    const tailChars = keep - headChars;
+    const elided = conversationText.length - headChars - tailChars;
+    const text = conversationText.slice(0, headChars) +
+        `\n\n[... ${elided} characters of the conversation elided so the summarization request fits the compaction model's context window ...]\n\n` +
+        conversationText.slice(conversationText.length - tailChars);
+    return { text, droppedChars: elided, keptChars: headChars + tailChars };
+}
+const COMPACTION_PTL_MAX_RETRIES = 3;
+export const COMPACTION_PTL_RETRY_MARKER = "[earlier conversation truncated for compaction retry]";
+const PTL_NO_GAP_DROP_FRACTION = 0.2;
+const PTL_GAP_SAFETY = 1.2;
+const PTL_CC_GAP_RE = /prompt is too long[^0-9]*(\d+) tokens? > (\d+)/i;
+const PTL_OPENAI_GAP_RE = /maximum context length is (\d+) tokens?[^0-9]*?(\d+) tokens?/i;
+const PTL_CLASS_RE = /prompt is too long|too many tokens|input is too long|context[ _-]?length|context window|exceeds? the (?:model'?s? )?context/i;
+const PTL_DENY_RE = /internal (?:server )?error|http 5\d\d|status(?: code)?[: ]5\d\d|invalid (?:api key|request)|configuration|unauthorized|permission/i;
+function parsePromptTooLong(message) {
+    if (!message) {
+        return { isPtl: false };
+    }
+    const cc = PTL_CC_GAP_RE.exec(message);
+    if (cc) {
+        const actual = Number(cc[1]);
+        const limit = Number(cc[2]);
+        return { isPtl: true, ...(actual > limit ? { gapTokens: actual - limit } : {}) };
+    }
+    const oa = PTL_OPENAI_GAP_RE.exec(message);
+    if (oa) {
+        const limit = Number(oa[1]);
+        const requested = Number(oa[2]);
+        return { isPtl: true, ...(requested > limit ? { gapTokens: requested - limit } : {}) };
+    }
+    return { isPtl: PTL_CLASS_RE.test(message) && !PTL_DENY_RE.test(message) };
+}
+function splitMessageGroups(messages) {
+    const groups = [];
+    let current = [];
+    let sawAssistant = false;
+    for (const m of messages) {
+        if (sawAssistant && m.role !== "toolResult") {
+            groups.push(current);
+            current = [];
+            sawAssistant = false;
+        }
+        current.push(m);
+        if (m.role === "assistant") {
+            sawAssistant = true;
+        }
+    }
+    if (current.length > 0) {
+        groups.push(current);
+    }
+    return groups;
+}
+async function summarizeWithPtlRetry(req) {
+    const disclose = (droppedChars, keptChars) => {
+        if (droppedChars <= 0) {
+            return;
+        }
+        try {
+            req.onInputTruncated?.({ label: req.truncationLabel, droppedChars, keptChars });
+        }
+        catch {
+        }
+    };
+    let groups = splitMessageGroups(req.llmMessages);
+    let droppedForRetry = false;
+    let budgetCapChars;
+    for (let retry = 0;; retry++) {
+        const serialized = serializeConversation(groups.flat());
+        const conversationText = droppedForRetry
+            ? `${COMPACTION_PTL_RETRY_MARKER}\n\n${serialized}`
+            : serialized;
+        const clamped = clampSummarizationConversation(conversationText, req.model, req.cpt, req.fixedPromptChars, req.baseMaxTokens, budgetCapChars);
+        disclose(clamped.droppedChars, clamped.keptChars);
+        const context = {
+            systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+            messages: [
+                {
+                    role: "user",
+                    content: [{ type: "text", text: req.buildPromptText(clamped.text) }],
+                    timestamp: Date.now(),
+                },
+            ],
+        };
+        let result;
+        let thrown;
+        let didThrow = false;
+        try {
+            result = await summarizeWithLengthRecovery(req.label, req.model, context, req.baseMaxTokens, req.apiKey, req.headers, req.signal, req.thinkingLevel, req.streamFn, req.runtime, req.charsPerToken);
+        }
+        catch (e) {
+            didThrow = true;
+            thrown = e;
+        }
+        if (!didThrow && result && result.ok) {
+            return result;
+        }
+        const failureMessage = didThrow
+            ? thrown instanceof Error
+                ? thrown.message
+                : String(thrown)
+            : result && !result.ok
+                ? result.error.message
+                : "";
+        const ptl = parsePromptTooLong(failureMessage);
+        if (!ptl.isPtl || retry >= COMPACTION_PTL_MAX_RETRIES || req.signal?.aborted) {
+            if (didThrow) {
+                throw thrown;
+            }
+            return result;
+        }
+        const sentChars = clamped.text.length;
+        const gapChars = ptl.gapTokens !== undefined
+            ? Math.ceil(ptl.gapTokens * req.cpt * PTL_GAP_SAFETY)
+            : Math.ceil(sentChars * PTL_NO_GAP_DROP_FRACTION);
+        budgetCapChars = Math.max(SUMMARY_INPUT_MIN_KEEP_CHARS, sentChars - Math.max(gapChars, 1));
+        const beforeChars = serialized.length;
+        const rollbackTargetChars = Math.max(SUMMARY_INPUT_MIN_KEEP_CHARS, beforeChars - Math.max(gapChars, 1));
+        let remainingChars = beforeChars;
+        while (groups.length > 1 && remainingChars > rollbackTargetChars) {
+            const dropped = groups.shift();
+            remainingChars -= serializeConversation(dropped).length + 2;
+        }
+        droppedForRetry = true;
+        disclose(beforeChars - Math.max(remainingChars, 0), Math.max(remainingChars, 0));
+    }
+}
+function stripAnalysisScratch(text, lengthTruncated) {
+    let out = text.replace(/<analysis>[\s\S]*?<\/analysis>\s*/gi, "");
+    if (lengthTruncated) {
+        out = out.replace(/(?:^|\n)<analysis>[\s\S]*$/i, "");
+    }
+    return out;
+}
+async function summarizeWithLengthRecovery(label, model, context, baseMaxTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken) {
+    const cpt = charsPerToken ?? model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
+    const modelCap = model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY;
+    const windowCap = model.contextWindow > 0
+        ? Math.max(baseMaxTokens, model.contextWindow - estimateSummarizationInputTokens(context, cpt) - SUMMARY_WINDOW_MARGIN)
+        : Number.POSITIVE_INFINITY;
+    const cap = Math.min(modelCap, windowCap);
+    let maxTokens = Math.min(cap, model.reasoning ? Math.max(baseMaxTokens, SUMMARY_REASONING_FLOOR) : baseMaxTokens);
+    for (let attempt = 0;; attempt++) {
+        const canEscalate = attempt < SUMMARY_MAX_ESCALATIONS && maxTokens < cap;
+        const response = await completeSummarization(model, context, createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel), streamFn, runtime);
+        if (response.stopReason === "aborted") {
+            return err(new CompactionError("aborted", response.errorMessage || `${label} aborted`));
+        }
+        if (response.stopReason === "error") {
+            if (response.errorKind === "length_empty") {
+                if (canEscalate) {
+                    maxTokens = Math.min(cap, Math.max(maxTokens * 2, SUMMARY_REASONING_FLOOR));
+                    continue;
+                }
+                return err(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=error, max_tokens exhausted by reasoning ` +
+                    `after ${attempt + 1} attempt(s): ${response.errorMessage || "no detail"})`));
+            }
+            return err(new CompactionError("summarization_failed", `${label} failed: ${response.errorMessage || "Unknown error"}`));
+        }
+        const lengthTruncated = response.stopReason === "length";
+        const raw = response.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+        const usable = stripAnalysisScratch(raw, lengthTruncated);
+        if (usable.trim() !== "") {
+            return ok(lengthTruncated ? usable : raw);
+        }
+        if (lengthTruncated && canEscalate) {
+            maxTokens = Math.min(cap, Math.max(maxTokens * 2, SUMMARY_REASONING_FLOOR));
+            continue;
+        }
+        return err(new CompactionError("summarization_failed", `${label} produced an empty summary (stopReason=${response.stopReason}` +
+            `${lengthTruncated ? ", the output was analysis scratch cut at max_tokens" : ""})`));
+    }
+}
+export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated) {
+    let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
+    if (customInstructions) {
+        basePrompt = `${basePrompt}\n\nAdditional Instructions:\n${customInstructions}`;
+    }
+    const llmMessages = convertToLlm(currentMessages);
+    return summarizeWithPtlRetry({
+        label: "Summarization",
+        truncationLabel: "history",
+        llmMessages,
+        buildPromptText: (conversationText) => {
+            let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
+            if (previousSummary) {
+                promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
+            }
+            promptText += basePrompt;
+            return promptText;
+        },
+        model,
+        cpt: charsPerToken ?? model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN,
+        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + basePrompt.length + (previousSummary?.length ?? 0) + 128,
+        baseMaxTokens: Math.floor(0.8 * reserveTokens),
+        apiKey,
+        headers,
+        signal,
+        thinkingLevel,
+        streamFn,
+        runtime,
+        charsPerToken,
+        onInputTruncated,
+    });
+}
+export function prepareCompaction(pathEntries, settings, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+    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, charsPerToken).tokens;
+    const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens, charsPerToken);
+    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);
+            }
+        }
+    }
+    if (messagesToSummarize.length === 0 && (!cutPoint.isSplitTurn || turnPrefixMessages.length === 0)) {
+        return ok(undefined);
+    }
+    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.`;
+export { computeFileLists, serializeConversation } from "./utils.js";
+export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated) {
+    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"));
+    }
+    if (messagesToSummarize.length === 0 && (!isSplitTurn || turnPrefixMessages.length === 0)) {
+        return err(new CompactionError("summarization_failed", "Nothing to summarize (empty preparation)"));
+    }
+    let summary;
+    if (isSplitTurn && turnPrefixMessages.length > 0) {
+        const [historyResult, turnPrefixResult] = await Promise.all([
+            messagesToSummarize.length > 0
+                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated)
+                :
+                    Promise.resolve(ok(previousSummary ? stripFileOperationsFooter(previousSummary) : "No prior history.")),
+            generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated),
+        ]);
+        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, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated);
+        if (!summaryResult.ok) {
+            return err(summaryResult.error);
+        }
+        summary = summaryResult.value;
+    }
+    const { readFiles, modifiedFiles, modifiedFilesByRecency } = computeFileLists(fileOps);
+    summary += formatFileOperations(readFiles, modifiedFiles);
+    return ok({
+        summary,
+        firstKeptEntryId,
+        tokensBefore,
+        details: { readFiles, modifiedFiles, modifiedFilesByRecency },
+    });
+}
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn, runtime, charsPerToken, onInputTruncated) {
+    const llmMessages = convertToLlm(messages);
+    return summarizeWithPtlRetry({
+        label: "Turn prefix summarization",
+        truncationLabel: "turn_prefix",
+        llmMessages,
+        buildPromptText: (conversationText) => `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`,
+        model,
+        cpt: charsPerToken ?? model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN,
+        fixedPromptChars: SUMMARIZATION_SYSTEM_PROMPT.length + TURN_PREFIX_SUMMARIZATION_PROMPT.length + 128,
+        baseMaxTokens: Math.floor(0.5 * reserveTokens),
+        apiKey,
+        headers,
+        signal,
+        thinkingLevel,
+        streamFn,
+        runtime,
+        charsPerToken,
+        onInputTruncated,
+    });
+}
+//# sourceMappingURL=compaction.js.map