@aexol/spectral 0.9.230 → 0.9.231

package/dist/sdk/coding-agent/core/compaction/compaction.js

@@ -4,11 +4,18 @@
  * Pure functions for compaction logic. The session manager handles I/O,
  * and after compaction the session is reloaded.
  */
-import { completeSimple } from "../../../ai/index.js";
-import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
+import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
 import { buildSessionContext } from "../session-manager.js";
-import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
-import { CONTEXT_LIMIT_RATIO, DEFAULT_COMPACTION_POLICY, normalizeManualKeepRecentTokens, } from "./policy.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, } from "./utils.js";
+import { DEFAULT_COMPACTION_POLICY, normalizeManualKeepRecentTokens, } from "./policy.js";
+import { estimateCompactionTokenMetrics, estimateContextTokens, } from "./tokens.js";
+import { findCutPoint } from "./cut-points.js";
+import { generateSummary, generateTurnPrefixSummary } from "./summarize.js";
+import { deduplicateToolCalls } from "./dedupe.js";
+export { calculateContextTokens, estimateCompactionTokenMetrics, estimateContextTokens, estimateTextTokens, estimateTokens, getLastAssistantUsage, shouldCompact, } from "./tokens.js";
+export { findCutPoint, findTurnStartIndex, } from "./cut-points.js";
+export { generateSummary } from "./summarize.js";
+export { deduplicateToolCalls } from "./dedupe.js";
 /**
  * Extract file operations from messages and previous compaction entries.
  */
@@ -79,481 +86,6 @@ export function getManualCompactionSettings(settings, manualPolicy = DEFAULT_COM
         return settings;
     return { ...settings, keepRecentTokens: manualKeepRecentTokens };
 }
-// ============================================================================
-// 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;
-        if (assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error" && assistantMsg.usage) {
-            return assistantMsg.usage;
-        }
-    }
-    return undefined;
-}
-/**
- * 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];
-        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 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) {
-        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,
-    };
-}
-/**
- * Check if compaction should trigger based on context usage.
- */
-export function shouldCompact(contextTokens, contextWindow, settings) {
-    if (!settings.enabled)
-        return false;
-    if (!Number.isFinite(contextWindow) || contextWindow <= 0)
-        return false;
-    if (!Number.isFinite(contextTokens) || contextTokens < 0)
-        return false;
-    return contextTokens >= contextWindow * CONTEXT_LIMIT_RATIO;
-}
-// ============================================================================
-// Cut point detection
-// ============================================================================
-/**
- * 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) {
-        case "user": {
-            const content = message.content;
-            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;
-                    }
-                }
-            }
-            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 + JSON.stringify(block.arguments).length;
-                }
-            }
-            return Math.ceil(chars / 4);
-        }
-        case "custom":
-        case "toolResult": {
-            if (typeof message.content === "string") {
-                chars = message.content.length;
-            }
-            else {
-                for (const block of message.content) {
-                    if (block.type === "text" && block.text) {
-                        chars += block.text.length;
-                    }
-                    if (block.type === "image") {
-                        chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
-                    }
-                }
-            }
-            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;
-}
-/**
- * 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++) {
-        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 "compaction":
-            case "branch_summary":
-            case "custom":
-            case "custom_message":
-            case "label":
-            case "session_info":
-                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 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;
-        }
-        if (entry.type === "message") {
-            const role = entry.message.role;
-            if (role === "user" || role === "bashExecution") {
-                return i;
-            }
-        }
-    }
-    return -1;
-}
-function isTurnBoundaryEntry(entry) {
-    if (!entry)
-        return false;
-    if (entry.type === "branch_summary" || entry.type === "custom_message")
-        return true;
-    if (entry.type !== "message")
-        return false;
-    const role = entry.message.role;
-    return role === "user" ||
-        role === "bashExecution" ||
-        role === "custom" ||
-        role === "branchSummary" ||
-        role === "compactionSummary";
-}
-/**
- * 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, options = {}) {
-    if (options.anchorEntryId) {
-        const anchorIndex = entries.findIndex((entry) => entry.id === options.anchorEntryId);
-        if (anchorIndex >= startIndex && anchorIndex < endIndex) {
-            return { firstKeptEntryIndex: anchorIndex, turnStartIndex: -1, isSplitTurn: false };
-        }
-    }
-    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.
-    // Phase-boundary callers provide an explicit marker, so the newest valid
-    // boundary is the desired cut point and the usual recent-token suffix is not
-    // retained raw.
-    let accumulatedTokens = 0;
-    let cutIndex = options.phaseBoundary
-        ? cutPoints[cutPoints.length - 1]
-        : cutPoints[0]; // Default: keep from first message (not header)
-    if (!options.phaseBoundary) {
-        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];
-                        break;
-                    }
-                }
-                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--;
-    }
-    // Pin latest user message: never fold the most recent user message into the
-    // compaction summary. If the computed cut point lands after the latest user
-    // message, pull it back so that message (and everything after) survives
-    // verbatim. This protects the current task/brief from truncation mid-run.
-    if (options.pinLatestUserMessage) {
-        let latestUserIndex = -1;
-        for (let i = endIndex - 1; i >= startIndex; i--) {
-            const entry = entries[i];
-            if (entry.type === "message" && entry.message.role === "user") {
-                latestUserIndex = i;
-                break;
-            }
-        }
-        if (latestUserIndex >= 0 && cutIndex > latestUserIndex) {
-            cutIndex = latestUserIndex;
-            // Re-include any non-message entries (bash, settings, etc.) immediately
-            // before the pinned user message, so we don't lose adjacent context.
-            while (cutIndex > startIndex) {
-                const prevEntry = entries[cutIndex - 1];
-                if (prevEntry.type === "compaction" || prevEntry.type === "message")
-                    break;
-                cutIndex--;
-            }
-        }
-    }
-    // Determine if this is a split turn
-    const cutEntry = entries[cutIndex];
-    const isTurnBoundary = isTurnBoundaryEntry(cutEntry);
-    const turnStartIndex = isTurnBoundary ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
-    return {
-        firstKeptEntryIndex: cutIndex,
-        turnStartIndex,
-        isSplitTurn: !isTurnBoundary && turnStartIndex !== -1,
-    };
-}
-// ============================================================================
-// Summarization
-// ============================================================================
-// Legacy LLM summarization path. AgentSession now builds persisted compaction
-// entries with deterministic DCP-lite (`compactDcpLite`) and lets
-// `session_before_compact` hooks provide memory details. Keep these exports for
-// compatibility with external SDK callers and older harness code, but do not
-// route new session compaction work through this model-generated fallback.
-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]
-
-## 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)
-
-## 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 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.
- *
- * @deprecated The active coding-agent session path uses deterministic DCP-lite
- * (`compactDcpLite`) plus `session_before_compact` hook details. This legacy
- * LLM summarizer remains exported for compatibility with older callers only.
- */
-export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn) {
-    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);
-    // 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`;
-    }
-    promptText += basePrompt;
-    const summarizationMessages = [
-        {
-            role: "user",
-            content: [{ type: "text", text: promptText }],
-            timestamp: Date.now(),
-        },
-    ];
-    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") {
-        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 textContent;
-}
 export function prepareCompaction(pathEntries, settings, options = {}) {
     if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
         return undefined;
@@ -630,239 +162,9 @@ export function prepareCompaction(pathEntries, settings, options = {}) {
         compactionNumber,
     };
 }
-export function estimateTextTokens(text) {
-    if (!text.trim())
-        return 0;
-    return Math.ceil(text.length / 4);
-}
-function estimateMessagesTokens(messages) {
-    let tokens = 0;
-    for (const message of messages) {
-        tokens += estimateTokens(message);
-    }
-    return tokens;
-}
-export function estimateCompactionTokenMetrics(preparation, summary) {
-    const tokensCompacted = estimateMessagesTokens(preparation.messagesToSummarize) +
-        estimateMessagesTokens(preparation.turnPrefixMessages);
-    const summaryTokens = estimateTextTokens(summary);
-    const tokensRemoved = Math.max(0, tokensCompacted - summaryTokens);
-    const reductionPercent = tokensCompacted > 0
-        ? Math.round((tokensRemoved / tokensCompacted) * 10_000) / 100
-        : 0;
-    return {
-        tokensCompacted,
-        tokensRemoved,
-        summaryTokens,
-        reductionPercent,
-        compactionNumber: preparation.compactionNumber,
-        largestTokenSources: collectLargestTokenSources(preparation.messagesToSummarize, preparation.turnPrefixMessages),
-    };
-}
-function addBucket(buckets, bucket) {
-    const key = `${bucket.type}:${bucket.name}`;
-    const previous = buckets.get(key);
-    buckets.set(key, {
-        ...bucket,
-        tokens: (previous?.tokens ?? 0) + bucket.tokens,
-    });
-}
-function collectLargestTokenSources(messagesToSummarize, turnPrefixMessages) {
-    const buckets = new Map();
-    const collect = (messages, source) => {
-        for (const message of messages) {
-            const messageTokens = estimateTokens(message);
-            addBucket(buckets, { type: "source", name: source, tokens: messageTokens });
-            addBucket(buckets, { type: "role", name: message.role, tokens: messageTokens });
-            if (message.role === "toolResult") {
-                addBucket(buckets, { type: "tool", name: message.toolName, tokens: messageTokens });
-                continue;
-            }
-            if (message.role === "assistant") {
-                for (const block of message.content) {
-                    if (block.type !== "toolCall")
-                        continue;
-                    const toolTokens = estimateTextTokens(`${block.name} ${JSON.stringify(block.arguments)}`);
-                    addBucket(buckets, { type: "tool", name: block.name, tokens: toolTokens });
-                }
-            }
-        }
-    };
-    collect(messagesToSummarize, "history");
-    collect(turnPrefixMessages, "turn_prefix");
-    return [...buckets.values()]
-        .filter((bucket) => bucket.tokens > 0)
-        .sort((a, b) => b.tokens - a.tokens || a.type.localeCompare(b.type) || a.name.localeCompare(b.name))
-        .slice(0, 5);
-}
-// ============================================================================
-// Tool Call Deduplication
-// ============================================================================
-/**
- * Tools that always return the same result for the same arguments.
- * Same (name, args) from any point in the session = duplicate.
- * Only the most recent call is kept.
- */
-const IDEMPOTENT_READ_TOOLS = new Set(["read"]);
-/**
- * Tools whose output may differ between calls with the same arguments.
- * Deduplication requires comparing actual outputs to determine equivalence.
- */
-const OUTPUT_DEPENDENT_TOOLS = new Set(["bash"]);
-/**
- * Tools that mutate state. Never deduplicated — chronological ordering matters.
- */
-const MUTABLE_TOOLS = new Set(["edit", "write"]);
-/**
- * Build a stable string key from a Record's sorted keys.
- * Ensures {a:1, b:2} and {b:2, a:1} produce the same key.
- */
-function stableArgs(args) {
-    const sortedKeys = Object.keys(args).sort();
-    const sorted = {};
-    for (const key of sortedKeys) {
-        sorted[key] = args[key];
-    }
-    return JSON.stringify(sorted);
-}
-/**
- * Compute the deduplication key for a tool call.
- * - Idempotent-read tools: keyed by (name, args) — same args always same result
- * - Output-dependent tools: keyed by (name, args, output) — output comparison needed
- */
-function toolCallDedupKey(toolName, args, toolCallId, resultMap) {
-    const argsKey = stableArgs(args);
-    if (OUTPUT_DEPENDENT_TOOLS.has(toolName)) {
-        const output = resultMap.get(toolCallId) ?? "";
-        return `${toolName}:${argsKey}:${output}`;
-    }
-    return `${toolName}:${argsKey}`;
-}
-/**
- * Check whether a tool should be excluded from deduplication.
- * Mutating tools and unknown tools are never deduplicated (conservative).
- */
-function isMutableOrUnknownTool(toolName) {
-    if (MUTABLE_TOOLS.has(toolName))
-        return true;
-    if (IDEMPOTENT_READ_TOOLS.has(toolName))
-        return false;
-    if (OUTPUT_DEPENDENT_TOOLS.has(toolName))
-        return false;
-    // Unknown tools: conservative — never deduplicate
-    return true;
-}
-/**
- * Deduplicate repeated tool calls in a message array by keeping only the
- * most recent occurrence of each (tool, args) pair.
- *
- * Strategy:
- * - **Idempotent-read tools** (read, grep, glob): same (name, args) → keep last only.
- *   These tools return the same content for the same arguments.
- * - **Output-dependent tools** (bash): same (name, args, output) → keep last only.
- *   Two bash calls with same command but different output are NOT duplicates.
- * - **Mutating tools** (edit, write): never deduplicated. Chronological ordering
- *   of mutations matters for correctness.
- * - **Unknown tools** (extensions, MCP, custom): never deduplicated. Conservative
- *   by default — only tools in the known sets above participate.
- *
- * Deduplication removes both the ToolCall block from the assistant message
- * and the corresponding ToolResultMessage from the array.
- *
- * Recalculated each time compaction runs — prompt cache is only impacted
- * alongside compression, not on every turn.
- */
-export function deduplicateToolCalls(messages) {
-    if (messages.length === 0)
-        return messages;
-    // Phase 1: Build result lookup for output-dependent tools
-    const resultMap = new Map();
-    for (const msg of messages) {
-        if (msg.role === "toolResult" && Array.isArray(msg.content)) {
-            const text = msg.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            resultMap.set(msg.toolCallId, text);
-        }
-    }
-    // Phase 2: Walk newest→oldest, collect keys. The first encounter
-    // (newest) wins; all earlier tool calls with the same key are duplicates.
-    const seen = new Map(); // key → toolCallId (keep newest)
-    const duplicateIds = new Set();
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role !== "assistant")
-            continue;
-        if (!("content" in msg) || !Array.isArray(msg.content))
-            continue;
-        // Iterate blocks newest-first: within a single assistant message,
-        // the rightmost tool call is the "most recent" one.
-        for (let j = msg.content.length - 1; j >= 0; j--) {
-            const block = msg.content[j];
-            if (typeof block !== "object" || block === null)
-                continue;
-            if (!("type" in block) || block.type !== "toolCall")
-                continue;
-            const toolBlock = block;
-            if (isMutableOrUnknownTool(toolBlock.name))
-                continue;
-            const key = toolCallDedupKey(toolBlock.name, toolBlock.arguments, toolBlock.id, resultMap);
-            if (seen.has(key)) {
-                duplicateIds.add(toolBlock.id);
-            }
-            else {
-                seen.set(key, toolBlock.id);
-            }
-        }
-    }
-    if (duplicateIds.size === 0)
-        return messages;
-    // Phase 3: Filter out duplicate tool results and strip duplicate
-    // ToolCall blocks from assistant messages.
-    const deduped = [];
-    let modified = false;
-    for (const msg of messages) {
-        if (msg.role === "toolResult" && duplicateIds.has(msg.toolCallId)) {
-            modified = true;
-            continue;
-        }
-        if (msg.role === "assistant" && "content" in msg && Array.isArray(msg.content)) {
-            const originalLength = msg.content.length;
-            const filteredContent = msg.content.filter((block) => {
-                if (typeof block !== "object" || block === null)
-                    return true;
-                if (!("type" in block) || block.type !== "toolCall")
-                    return true;
-                return !duplicateIds.has(block.id);
-            });
-            if (filteredContent.length < originalLength) {
-                modified = true;
-                deduped.push({ ...msg, content: filteredContent });
-                continue;
-            }
-        }
-        deduped.push(msg);
-    }
-    return modified ? deduped : messages;
-}
 // ============================================================================
 // 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:
-
-## 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.`;
 /**
  * Generate summaries for compaction using prepared data.
  * Returns CompactionResult - SessionManager adds uuid/parentUuid when saving.
@@ -912,27 +214,3 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         details: { readFiles, modifiedFiles },
     };
 }
-/**
- * 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}`;
-    const summarizationMessages = [
-        {
-            role: "user",
-            content: [{ type: "text", text: promptText }],
-            timestamp: Date.now(),
-        },
-    ];
-    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, signal, thinkingLevel), streamFn);
-    if (response.stopReason === "error") {
-        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
-    }
-    return response.content
-        .filter((c) => c.type === "text")
-        .map((c) => c.text)
-        .join("\n");
-}