@caupulican/pi-agent-core 0.80.103 → 0.81.0

package/dist/{harness/compaction → compaction}/compaction.js

@@ -1,21 +1,23 @@
+/**
+ * Context compaction for long sessions.
+ *
+ * Pure functions for compaction logic. The session manager handles I/O,
+ * and after compaction the session is reloaded.
+ */
 import { completeSimple } from "@caupulican/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]";
-    }
-}
+import { buildSessionContext } from "../session/session-manager.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
+/**
+ * Extract file operations from messages and previous compaction entries.
+ */
 function extractFileOperations(messages, entries, prevCompactionIndex) {
     const fileOps = createFileOps();
+    // Collect from previous compaction's details (if pi-generated)
     if (prevCompactionIndex >= 0) {
         const prevCompaction = entries[prevCompactionIndex];
         if (!prevCompaction.fromHook && prevCompaction.details) {
+            // fromHook field kept for session file compatibility
             const details = prevCompaction.details;
             if (Array.isArray(details.readFiles)) {
                 for (const f of details.readFiles)
@@ -27,11 +29,19 @@ function extractFileOperations(messages, entries, prevCompactionIndex) {
             }
         }
     }
+    // Extract from tool calls in messages
     for (const msg of messages) {
         extractFileOpsFromMessage(msg, fileOps);
     }
     return fileOps;
 }
+// ============================================================================
+// Message Extraction
+// ============================================================================
+/**
+ * Extract AgentMessage from an entry if it produces one.
+ * Returns undefined for entries that don't contribute to LLM context.
+ */
 function getMessageFromEntry(entry) {
     if (entry.type === "message") {
         return entry.message;
@@ -53,16 +63,26 @@ function getMessageFromEntryForCompaction(entry) {
     }
     return getMessageFromEntry(entry);
 }
-/** Default compaction settings used by the harness. */
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
     reserveTokens: 16384,
     keepRecentTokens: 20000,
+    triggerPercent: 0.7,
 };
-/** Calculate total context tokens from provider usage. */
+// ============================================================================
+// Token calculation
+// ============================================================================
+/**
+ * Calculate total context tokens from usage.
+ * Uses the native totalTokens field when available, falls back to computing from components.
+ */
 export function calculateContextTokens(usage) {
     return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
 }
+/**
+ * Get usage from an assistant message if available.
+ * Skips aborted and error messages as they don't have valid usage data.
+ */
 function getAssistantUsage(msg) {
     if (msg.role === "assistant" && "usage" in msg) {
         const assistantMsg = msg;
@@ -72,7 +92,9 @@ function getAssistantUsage(msg) {
     }
     return undefined;
 }
-/** Return usage from the last successful assistant message in session entries. */
+/**
+ * Find the last non-aborted assistant message usage from session entries.
+ */
 export function getLastAssistantUsage(entries) {
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
@@ -92,7 +114,10 @@ function getLastAssistantUsageInfo(messages) {
     }
     return undefined;
 }
-/** Estimate context tokens for messages using provider usage when available. */
+/**
+ * Estimate context tokens from messages, using the last assistant usage when available.
+ * If there are messages after the last usage, estimate their tokens with estimateTokens.
+ */
 export function estimateContextTokens(messages) {
     const usageInfo = getLastAssistantUsageInfo(messages);
     if (!usageInfo) {
@@ -119,12 +144,46 @@ export function estimateContextTokens(messages) {
         lastUsageIndex: usageInfo.index,
     };
 }
-/** Return whether context usage exceeds the configured compaction threshold. */
-export function shouldCompact(contextTokens, contextWindow, settings) {
+/**
+ * Minimum projected space saving for the EARLY (fractional) compaction trigger to fire. Anti-thrashing
+ * (cost guard, #30): an early compaction whose summary would barely shrink the context (mostly recent,
+ * protected content) just burns a summarization call for little gain — skip it and let the context grow
+ * until either the saving is worthwhile or the hard (near-full) trigger forces it. Does NOT gate the
+ * hard trigger, so overflow is always avoided.
+ */
+export const MIN_COMPACTION_SAVINGS = 0.12;
+/**
+ * Check if compaction should trigger based on context usage.
+ *
+ * Two triggers:
+ * - HARD: context exceeds `contextWindow - reserveTokens` (near-full) or an explicit `triggerTokens`
+ *   override — always compact (prevents overflow).
+ * - EARLY (fractional, cost guard): context exceeds `contextWindow * triggerPercent` — compact only if
+ *   the summary would actually save enough (`MIN_COMPACTION_SAVINGS`), so we don't thrash for tiny gains.
+ */
+export function shouldCompact(contextTokens, contextWindow, settings, triggerTokens) {
     if (!settings.enabled)
         return false;
-    return contextTokens > contextWindow - settings.reserveTokens;
+    // Hard trigger: near-full, or a caller-supplied lower override. Always compacts (avoid overflow).
+    const reserveTrigger = contextWindow - settings.reserveTokens;
+    const hardTrigger = triggerTokens === undefined ? reserveTrigger : Math.min(reserveTrigger, triggerTokens);
+    if (contextTokens > hardTrigger)
+        return true;
+    // Early fractional trigger: bounds per-turn input cost on large-window models, gated by anti-thrashing.
+    const pct = settings.triggerPercent ?? 0;
+    if (pct > 0 && pct < 1) {
+        const fractionalTrigger = Math.floor(contextWindow * pct);
+        if (contextTokens > fractionalTrigger) {
+            // Projected saving ≈ the non-protected fraction (everything but the recent tail we keep).
+            const projectedSavings = contextTokens > 0 ? 1 - settings.keepRecentTokens / contextTokens : 0;
+            return projectedSavings >= MIN_COMPACTION_SAVINGS;
+        }
+    }
+    return false;
 }
+// ============================================================================
+// Cut point detection
+// ============================================================================
 const ESTIMATED_IMAGE_CHARS = 4800;
 function estimateTextAndImageContentChars(content) {
     if (typeof content === "string") {
@@ -141,7 +200,10 @@ function estimateTextAndImageContentChars(content) {
     }
     return chars;
 }
-/** Estimate token count for one message using a conservative character heuristic. */
+/**
+ * Estimate token count for a message using chars/4 heuristic.
+ * This is conservative (overestimates tokens).
+ */
 export function estimateTokens(message) {
     let chars = 0;
     switch (message.role) {
@@ -159,7 +221,7 @@ export function estimateTokens(message) {
                     chars += block.thinking.length;
                 }
                 else if (block.type === "toolCall") {
-                    chars += block.name.length + safeJsonStringify(block.arguments).length;
+                    chars += block.name.length + JSON.stringify(block.arguments).length;
                 }
             }
             return Math.ceil(chars / 4);
@@ -181,6 +243,13 @@ export function estimateTokens(message) {
     }
     return 0;
 }
+/**
+ * Find valid cut points: indices of user, assistant, custom, or bashExecution messages.
+ * Never cut at tool results (they must follow their tool call).
+ * When we cut at an assistant message with tool calls, its tool results follow it
+ * and will be kept.
+ * BashExecutionMessage is treated like a user message (user-initiated context).
+ */
 function findValidCutPoints(entries, startIndex, endIndex) {
     const cutPoints = [];
     for (let i = startIndex; i < endIndex; i++) {
@@ -204,26 +273,30 @@ function findValidCutPoints(entries, startIndex, endIndex) {
             }
             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;
         }
+        // branch_summary and custom_message are user-role messages, valid cut points
         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. */
+/**
+ * Find the user message (or bashExecution) that starts the turn containing the given entry index.
+ * Returns -1 if no turn start found before the index.
+ * BashExecutionMessage is treated like a user message for turn boundaries.
+ */
 export function findTurnStartIndex(entries, entryIndex, startIndex) {
     for (let i = entryIndex; i >= startIndex; i--) {
         const entry = entries[i];
+        // branch_summary and custom_message are user-role messages, can start a turn
         if (entry.type === "branch_summary" || entry.type === "custom_message") {
             return i;
         }
@@ -236,21 +309,40 @@ export function findTurnStartIndex(entries, entryIndex, startIndex) {
     }
     return -1;
 }
-/** Find the compaction cut point that keeps approximately the requested recent-token budget. */
+/**
+ * Find the cut point in session entries that keeps approximately `keepRecentTokens`.
+ *
+ * Algorithm: Walk backwards from newest, accumulating estimated message sizes.
+ * Stop when we've accumulated >= keepRecentTokens. Cut at that point.
+ *
+ * Can cut at user OR assistant messages (never tool results). When cutting at an
+ * assistant message with tool calls, its tool results come after and will be kept.
+ *
+ * Returns CutPointResult with:
+ * - firstKeptEntryIndex: the entry index to start keeping from
+ * - turnStartIndex: if cutting mid-turn, the user message that started that turn
+ * - isSplitTurn: whether we're cutting in the middle of a turn
+ *
+ * Only considers entries between `startIndex` and `endIndex` (exclusive).
+ */
 export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
     const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
     if (cutPoints.length === 0) {
         return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
     }
+    // Walk backwards from newest, accumulating estimated message sizes
     let accumulatedTokens = 0;
-    let cutIndex = cutPoints[0];
+    let cutIndex = cutPoints[0]; // Default: keep from first message (not header)
     for (let i = endIndex - 1; i >= startIndex; i--) {
         const entry = entries[i];
         if (entry.type !== "message")
             continue;
+        // Estimate this message's size
         const messageTokens = estimateTokens(entry.message);
         accumulatedTokens += messageTokens;
+        // Check if we've exceeded the budget
         if (accumulatedTokens >= keepRecentTokens) {
+            // Find the closest valid cut point at or after this entry
             for (let c = 0; c < cutPoints.length; c++) {
                 if (cutPoints[c] >= i) {
                     cutIndex = cutPoints[c];
@@ -260,16 +352,21 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
             break;
         }
     }
+    // Scan backwards from cutIndex to include any non-message entries (bash, settings, etc.)
     while (cutIndex > startIndex) {
         const prevEntry = entries[cutIndex - 1];
+        // Stop at session header or compaction boundaries
         if (prevEntry.type === "compaction") {
             break;
         }
         if (prevEntry.type === "message") {
+            // Stop if we hit any message
             break;
         }
+        // Include this non-message entry (bash, settings change, etc.)
         cutIndex--;
     }
+    // Determine if this is a split turn
     const cutEntry = entries[cutIndex];
     const isUserMessage = cutEntry.type === "message" && cutEntry.message.role === "user";
     const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
@@ -279,9 +376,9 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
         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.`;
+// ============================================================================
+// Summarization
+// ============================================================================
 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:
@@ -352,15 +449,46 @@ Use this EXACT format:
 - [Preserve important context, add new if needed]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
-/** Generate or update a conversation summary for compaction. */
-export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel) {
+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) {
+    if (!streamFn) {
+        return completeSimple(model, context, options);
+    }
+    const stream = await streamFn(model, context, options);
+    return stream.result();
+}
+/**
+ * Generate a summary of the conversation using the LLM.
+ * If previousSummary is provided, uses the update prompt to merge.
+ */
+export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, preDigest) {
     const maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+    // Use update prompt if we have a previous summary, otherwise initial prompt
     let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
     if (customInstructions) {
         basePrompt = `${basePrompt}\n\nAdditional focus: ${customInstructions}`;
     }
+    // Serialize conversation to text so model doesn't try to continue it
+    // Convert to LLM messages first (handles custom types like bashExecution, custom, etc.)
     const llmMessages = convertToLlm(currentMessages);
-    const conversationText = serializeConversation(llmMessages);
+    let conversationText = serializeConversation(llmMessages);
+    // Brain-curation surface 3 (opt-in, injected by the session): pre-digest old chunks locally
+    // before the frontier summarization call. Best-effort — failure keeps the verbatim text.
+    if (preDigest) {
+        try {
+            conversationText = await preDigest(conversationText, signal);
+        }
+        catch {
+            // verbatim fallback
+        }
+    }
+    // Build the prompt with conversation wrapped in tags
     let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
     if (previousSummary) {
         promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
@@ -373,26 +501,20 @@ export async function generateSummary(currentMessages, model, reserveTokens, api
             timestamp: Date.now(),
         },
     ];
-    const completionOptions = model.reasoning && thinkingLevel && thinkingLevel !== "off"
-        ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
-        : { maxTokens, signal, apiKey, headers };
-    const response = await completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions);
-    if (response.stopReason === "aborted") {
-        return err(new CompactionError("aborted", response.errorMessage || "Summarization aborted"));
-    }
+    const completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel);
+    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions, streamFn);
     if (response.stopReason === "error") {
-        return err(new CompactionError("summarization_failed", `Summarization failed: ${response.errorMessage || "Unknown error"}`));
+        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
     }
     const textContent = response.content
         .filter((c) => c.type === "text")
         .map((c) => c.text)
         .join("\n");
-    return ok(textContent);
+    return textContent;
 }
-/** Prepare session entries for compaction, or return undefined when compaction is not applicable. */
 export function prepareCompaction(pathEntries, settings) {
-    if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1].type === "compaction") {
-        return ok(undefined);
+    if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
+        return undefined;
     }
     let prevCompactionIndex = -1;
     for (let i = pathEntries.length - 1; i >= 0; i--) {
@@ -412,18 +534,21 @@ export function prepareCompaction(pathEntries, settings) {
     const boundaryEnd = pathEntries.length;
     const tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens;
     const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
+    // Get UUID of first kept entry
     const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
     if (!firstKeptEntry?.id) {
-        return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
+        return undefined; // Session needs migration
     }
     const firstKeptEntryId = firstKeptEntry.id;
     const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
+    // Messages to summarize (will be discarded after summary)
     const messagesToSummarize = [];
     for (let i = boundaryStart; i < historyEnd; i++) {
         const msg = getMessageFromEntryForCompaction(pathEntries[i]);
         if (msg)
             messagesToSummarize.push(msg);
     }
+    // Messages for turn prefix summary (if splitting a turn)
     const turnPrefixMessages = [];
     if (cutPoint.isSplitTurn) {
         for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
@@ -432,13 +557,15 @@ export function prepareCompaction(pathEntries, settings) {
                 turnPrefixMessages.push(msg);
         }
     }
+    // Extract file operations from messages and previous compaction
     const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
+    // Also extract file ops from turn prefix if splitting
     if (cutPoint.isSplitTurn) {
         for (const msg of turnPrefixMessages) {
             extractFileOpsFromMessage(msg, fileOps);
         }
     }
-    return ok({
+    return {
         firstKeptEntryId,
         messagesToSummarize,
         turnPrefixMessages,
@@ -447,8 +574,11 @@ export function prepareCompaction(pathEntries, settings) {
         previousSummary,
         fileOps,
         settings,
-    });
+    };
 }
+// ============================================================================
+// Main compaction function
+// ============================================================================
 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:
@@ -463,44 +593,50 @@ Summarize the prefix to provide context for the retained suffix:
 - [Information needed to understand the retained recent work]
 
 Be concise. Focus on what's needed to understand the kept suffix.`;
-export { serializeConversation } from "./utils.js";
-/** Generate compaction summary data from prepared session history. */
-export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel) {
+/**
+ * Generate summaries for compaction using prepared data.
+ * Returns CompactionResult - SessionManager adds uuid/parentUuid when saving.
+ *
+ * @param preparation - Pre-calculated preparation from prepareCompaction()
+ * @param customInstructions - Optional custom focus for the summary
+ */
+export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, preDigest) {
     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"));
-    }
+    // Generate summaries (can be parallel if both needed) and merge into one
     let summary;
     if (isSplitTurn && turnPrefixMessages.length > 0) {
+        // Generate both summaries in parallel
         const [historyResult, turnPrefixResult] = await Promise.all([
             messagesToSummarize.length > 0
-                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel)
-                : Promise.resolve(ok("No prior history.")),
-            generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel),
+                ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, preDigest)
+                : Promise.resolve("No prior history."),
+            generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn),
         ]);
-        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}`;
+        // Merge into single summary
+        summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
     }
     else {
-        const summaryResult = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel);
-        if (!summaryResult.ok)
-            return err(summaryResult.error);
-        summary = summaryResult.value;
+        // Just generate history summary
+        summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, preDigest);
     }
+    // Compute file lists and append to summary
     const { readFiles, modifiedFiles } = computeFileLists(fileOps);
     summary += formatFileOperations(readFiles, modifiedFiles);
-    return ok({
+    if (!firstKeptEntryId) {
+        throw new Error("First kept entry has no UUID - session may need migration");
+    }
+    return {
         summary,
         firstKeptEntryId,
         tokensBefore,
         details: { readFiles, modifiedFiles },
-    });
+    };
 }
-async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel) {
-    const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
+/**
+ * Generate a summary for a turn prefix (when splitting a turn).
+ */
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel, streamFn) {
+    const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY); // Smaller budget for turn prefix
     const llmMessages = convertToLlm(messages);
     const conversationText = serializeConversation(llmMessages);
     const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
@@ -511,18 +647,13 @@ async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey,
             timestamp: Date.now(),
         },
     ];
-    const response = await completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, model.reasoning && thinkingLevel && thinkingLevel !== "off"
-        ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
-        : { maxTokens, signal, apiKey, headers });
-    if (response.stopReason === "aborted") {
-        return err(new CompactionError("aborted", response.errorMessage || "Turn prefix summarization aborted"));
-    }
+    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel), streamFn);
     if (response.stopReason === "error") {
-        return err(new CompactionError("summarization_failed", `Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`));
+        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
     }
-    return ok(response.content
+    return response.content
         .filter((c) => c.type === "text")
         .map((c) => c.text)
-        .join("\n"));
+        .join("\n");
 }
 //# sourceMappingURL=compaction.js.map