@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/context/prompts/summarizationPrompt.js

@@ -1,117 +0,0 @@
-/**
- * Summarization Prompt Builder
- *
- * Builds prompts for summarizing conversation context into a 10-section structure.
- * Supports both initial summarization and incremental merging with existing summaries.
- */
-const SUMMARY_SECTIONS = [
-    "Primary Request and Intent",
-    "Key Technical Concepts",
-    "Files and Code Sections",
-    "Problem Solving",
-    "Pending Tasks",
-    "Task Evolution",
-    "Current Work",
-    "Next Step",
-    "Required Files",
-    "Constraints and Established Rules",
-];
-function buildFileContextSection(filesRead, filesModified) {
-    const hasFiles = (filesRead && filesRead.length > 0) ||
-        (filesModified && filesModified.length > 0);
-    if (!hasFiles) {
-        return "";
-    }
-    let section = "\n\nFile Context:\n";
-    if (filesRead && filesRead.length > 0) {
-        section += "Files Read:\n";
-        for (const file of filesRead) {
-            section += `- ${file}\n`;
-        }
-    }
-    if (filesModified && filesModified.length > 0) {
-        section += "Files Modified:\n";
-        for (const file of filesModified) {
-            section += `- ${file}\n`;
-        }
-    }
-    return section;
-}
-function buildInitialPrompt(options) {
-    const fileContext = buildFileContextSection(options.filesRead, options.filesModified);
-    return `You are a context summarization assistant. Your task is to analyze the conversation and create a structured summary following a 10-section format.
-
-Create a summary with the following sections:
-
-### 1. Primary Request and Intent
-What is the user's main goal or request? What are they trying to accomplish?
-
-### 2. Key Technical Concepts
-What technologies, frameworks, patterns, or concepts are central to this conversation?
-
-### 3. Files and Code Sections
-What specific files, functions, or code sections have been discussed or modified?
-
-### 4. Problem Solving
-What problems were identified? What solutions were attempted or implemented?
-
-### 5. Pending Tasks
-What tasks remain incomplete or need follow-up?
-
-### 6. Task Evolution
-How has the task changed or evolved during the conversation?
-
-### 7. Current Work
-What is being actively worked on right now?
-
-### 8. Next Step
-What is the immediate next action to take?
-
-### 9. Required Files
-What files will need to be accessed or modified to continue?
-
-### 10. Constraints and Established Rules
-What user-imposed constraints, behavioral directives, coding standards, agreed-upon decisions, or established rules must persist across the conversation? Include any "always do X", "never do Y", naming conventions, architectural patterns, or preferences the user has stated.${fileContext}
-
-IMPORTANT: Section 10 (Constraints and Established Rules) must ALWAYS be preserved in full. User constraints and established agreements are never "no longer relevant" — they remain in effect for the entire session unless the user explicitly revokes them.
-
-Analyze the conversation thoroughly and fill in each section with relevant information. If a section is not applicable, write "N/A" for that section.`;
-}
-function buildIncrementalPrompt(options) {
-    const fileContext = buildFileContextSection(options.filesRead, options.filesModified);
-    return `You are a context summarization assistant. Your task is to MERGE new conversation content with an existing summary.
-
-Existing Summary:
----
-${options.previousSummary}
----
-
-Update sections with new information while preserving important context from the existing summary. Maintain the same 10-section structure.
-
-Instructions:
-1. Review the existing summary above
-2. Analyze the new conversation content
-3. MERGE the new information into the appropriate sections
-4. Update sections with relevant new information
-5. Remove information that is no longer relevant EXCEPT for Section 10 (Constraints and Established Rules) — user constraints and established agreements must ALWAYS be preserved unless the user explicitly revoked them
-6. Keep the summary concise but comprehensive
-7. Maintain the 10-section format
-8. Always carry forward ALL entries from Section 10 of the existing summary, adding any new constraints found in the new content${fileContext}
-
-Output the updated summary following the same 10-section structure.`;
-}
-/**
- * Builds a summarization prompt based on the provided options.
- *
- * @param options - Configuration for the prompt builder
- * @returns The constructed prompt string
- */
-export function buildSummarizationPrompt(options) {
-    // For incremental mode, we need a previous summary to merge with
-    // If no previous summary is provided, fall back to initial prompt
-    if (options.isIncremental && options.previousSummary) {
-        return buildIncrementalPrompt(options);
-    }
-    return buildInitialPrompt(options);
-}
-export { SUMMARY_SECTIONS };

package/dist/client/context/stages/fileReadDeduplicator.js

@@ -1,66 +0,0 @@
-/**
- * Stage 2: File Read Deduplication
- *
- * Detect multiple reads of the same file path, keep only the latest,
- * replace earlier reads with a notice.
- */
-const FILE_READ_PATTERN = /(?:read|reading|read_file|readFile|Read file|cat)\s+['"`]?([^\s'"`\n]+)/i;
-const DEDUP_NOTICE = (filePath) => `[File ${filePath} - refer to latest read below]`;
-const DEDUP_THRESHOLD = 0.3; // Need 30% savings to declare success
-export function deduplicateFileReads(messages) {
-    // Track file read positions: filePath -> array of message indices
-    const fileReadMap = new Map();
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (msg.role !== "tool_result" && msg.role !== "assistant") {
-            continue;
-        }
-        const match = msg.content.match(FILE_READ_PATTERN);
-        if (match) {
-            const filePath = match[1];
-            const existing = fileReadMap.get(filePath) || [];
-            existing.push(i);
-            fileReadMap.set(filePath, existing);
-        }
-    }
-    // Find files read multiple times
-    const duplicates = new Map();
-    for (const [filePath, indices] of fileReadMap) {
-        if (indices.length > 1) {
-            duplicates.set(filePath, indices);
-        }
-    }
-    if (duplicates.size === 0) {
-        return { deduplicated: false, messages, filesDeduped: 0 };
-    }
-    const result = [...messages];
-    let totalOriginalChars = 0;
-    let totalReplacedChars = 0;
-    for (const [filePath, indices] of duplicates) {
-        // Keep the latest (last index), replace all earlier ones
-        const latestIndex = indices[indices.length - 1];
-        for (const idx of indices) {
-            if (idx === latestIndex) {
-                continue;
-            }
-            const original = result[idx];
-            totalOriginalChars += original.content.length;
-            const notice = DEDUP_NOTICE(filePath);
-            totalReplacedChars += notice.length;
-            result[idx] = {
-                ...original,
-                content: notice,
-                metadata: { ...original.metadata, truncated: true },
-            };
-        }
-    }
-    const savings = totalOriginalChars > 0
-        ? (totalOriginalChars - totalReplacedChars) / totalOriginalChars
-        : 0;
-    const deduplicated = savings >= DEDUP_THRESHOLD;
-    return {
-        deduplicated,
-        messages: deduplicated ? result : messages,
-        filesDeduped: deduplicated ? duplicates.size : 0,
-    };
-}

package/dist/client/context/stages/slidingWindowTruncator.js

@@ -1,190 +0,0 @@
-/**
- * Stage 4: Sliding Window Truncation
- *
- * Non-destructive fallback: tags oldest messages as truncated
- * instead of deleting them. Always preserves first message pair.
- * Removes messages in pairs to maintain role alternation.
- *
- * Features:
- * - Adaptive truncation (PERF-001): calculates fraction from actual overage
- *   instead of fixed 50%, with iterative refinement up to 3 passes.
- * - Small conversation handling (BUG-005): for <= 4 messages, truncates
- *   message content proportionally instead of returning no-op.
- */
-import { estimateTokens, estimateMessagesTokens, truncateToTokenBudget, } from "../../utils/tokenEstimation.js";
-import { logger } from "../../utils/logger.js";
-import { randomUUID } from "crypto";
-const TRUNCATION_MARKER_CONTENT = "[Earlier conversation history was truncated to fit within context limits]";
-function validateRoleAlternation(messages) {
-    for (let i = 1; i < messages.length; i++) {
-        if (messages[i].role === messages[i - 1].role &&
-            messages[i].role !== "system") {
-            logger.warn(`[SlidingWindowTruncator] Role alternation broken at index ${i}: consecutive "${messages[i].role}" messages`);
-        }
-    }
-}
-/**
- * For conversations with <= 4 messages that exceed token budget,
- * truncate the CONTENT of the longest messages rather than removing messages.
- *
- * Strategy:
- * 1. Calculate each message's proportional share of the token budget
- * 2. Truncate messages that exceed their share using truncateToTokenBudget()
- * 3. Never truncate messages below 200 tokens (preserve minimum context)
- */
-function truncateSmallConversation(messages, config) {
-    // If no target tokens provided, we can't do content truncation
-    if (!config?.targetTokens) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    const provider = config.provider;
-    const targetTokens = config.targetTokens;
-    const currentTokens = estimateMessagesTokens(messages, provider);
-    if (currentTokens <= targetTokens) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    const MINIMUM_MSG_TOKENS = 200;
-    const FRAMING_OVERHEAD = 24 + messages.length * 4; // conversation + per-message overhead
-    // Available budget for actual content
-    const contentBudget = targetTokens - FRAMING_OVERHEAD;
-    if (contentBudget <= 0) {
-        return { truncated: false, messages, messagesRemoved: 0 };
-    }
-    // Calculate current content tokens per message
-    const msgTokens = messages.map((msg) => estimateTokens(msg.content, provider));
-    const totalContentTokens = msgTokens.reduce((sum, t) => sum + t, 0);
-    // Each message gets a proportional share of the content budget
-    const result = [...messages];
-    let totalSaved = 0;
-    for (let i = 0; i < result.length; i++) {
-        const msg = result[i];
-        // Don't truncate system/summary messages
-        if (msg.role === "system" || msg.metadata?.isSummary) {
-            continue;
-        }
-        const proportionalBudget = Math.floor((msgTokens[i] / totalContentTokens) * contentBudget);
-        const msgBudget = Math.max(MINIMUM_MSG_TOKENS, proportionalBudget);
-        if (msgTokens[i] > msgBudget) {
-            const truncated = truncateToTokenBudget(msg.content, msgBudget, provider);
-            if (truncated.truncated) {
-                totalSaved += msgTokens[i] - estimateTokens(truncated.text, provider);
-                result[i] = {
-                    ...msg,
-                    content: truncated.text,
-                    metadata: { ...msg.metadata, truncated: true },
-                };
-            }
-        }
-    }
-    if (totalSaved > 0) {
-        const finalTokens = estimateMessagesTokens(result, provider);
-        logger.info("[Truncation] Small conversation content truncated", {
-            messageCount: messages.length,
-            tokensSaved: totalSaved,
-            targetTokens,
-            finalTokens,
-        });
-        return {
-            truncated: finalTokens <= targetTokens,
-            messages: result,
-            messagesRemoved: 0, // No messages removed, only content truncated
-        };
-    }
-    return { truncated: false, messages, messagesRemoved: 0 };
-}
-export function truncateWithSlidingWindow(messages, config) {
-    if (messages.length <= 4) {
-        // Delegate to content truncation for small conversations (BUG-005)
-        return truncateSmallConversation(messages, config);
-    }
-    // ADAPTIVE MODE: calculate fraction from actual overage (PERF-001)
-    let fraction;
-    if (config?.currentTokens &&
-        config?.targetTokens &&
-        config.currentTokens > config.targetTokens) {
-        const overageRatio = (config.currentTokens - config.targetTokens) / config.currentTokens;
-        const buffer = config?.adaptiveBuffer ?? 0.15;
-        // Required fraction = overage ratio + buffer, clamped to [0.1, 0.9]
-        fraction = Math.min(0.9, Math.max(0.1, overageRatio + buffer));
-        logger.info("[Truncation] Adaptive fraction calculated", {
-            currentTokens: config.currentTokens,
-            targetTokens: config.targetTokens,
-            overageRatio: Math.round(overageRatio * 100),
-            fraction: Math.round(fraction * 100),
-        });
-    }
-    else {
-        // Fallback to configured or default fraction
-        fraction = config?.fraction ?? 0.5;
-    }
-    // Always preserve first user-assistant pair
-    const firstPair = messages.slice(0, 2);
-    const remainingMessages = messages.slice(2);
-    // ITERATIVE: if first pass isn't enough, increase fraction
-    const maxIterations = config?.maxIterations ?? 3;
-    let currentFraction = fraction;
-    for (let iteration = 0; iteration < maxIterations; iteration++) {
-        const removeCount = Math.floor(remainingMessages.length * currentFraction);
-        const evenRemoveCount = removeCount - (removeCount % 2);
-        if (evenRemoveCount <= 0) {
-            break;
-        }
-        const keptAfterTruncation = remainingMessages.slice(evenRemoveCount);
-        // Insert a truncation marker with machine-readable metadata so
-        // effectiveHistory.ts can detect it via isTruncationMarker /
-        // truncationId and removeTruncationTags can rewind it.
-        const truncId = randomUUID();
-        const marker = {
-            id: `truncation-marker-${truncId}`,
-            role: "user",
-            content: TRUNCATION_MARKER_CONTENT,
-            isTruncationMarker: true,
-            truncationId: truncId,
-        };
-        const candidateMessages = [...firstPair, marker, ...keptAfterTruncation];
-        validateRoleAlternation(candidateMessages);
-        // If we have token targets, verify the result fits
-        if (config?.targetTokens) {
-            const candidateTokens = estimateMessagesTokens(candidateMessages, config.provider);
-            if (candidateTokens <= config.targetTokens) {
-                return {
-                    truncated: true,
-                    messages: candidateMessages,
-                    messagesRemoved: evenRemoveCount,
-                };
-            }
-            // Not enough -- increase fraction by 25% for next iteration
-            currentFraction = Math.min(0.95, currentFraction + 0.25);
-            continue;
-        }
-        // No token targets -- single-pass with calculated fraction
-        return {
-            truncated: true,
-            messages: candidateMessages,
-            messagesRemoved: evenRemoveCount,
-        };
-    }
-    // All iterations exhausted -- return best effort (most aggressive truncation)
-    const maxRemove = Math.floor(remainingMessages.length * 0.95);
-    const evenMaxRemove = maxRemove - (maxRemove % 2);
-    if (evenMaxRemove > 0) {
-        const keptMessages = remainingMessages.slice(evenMaxRemove);
-        // Insert a truncation marker (see iterative block above)
-        const fallbackTruncId = randomUUID();
-        const fallbackMarker = {
-            id: `truncation-marker-${fallbackTruncId}`,
-            role: "user",
-            content: TRUNCATION_MARKER_CONTENT,
-            isTruncationMarker: true,
-            truncationId: fallbackTruncId,
-        };
-        const fallbackMessages = [...firstPair, fallbackMarker, ...keptMessages];
-        validateRoleAlternation(fallbackMessages);
-        return {
-            truncated: true,
-            messages: fallbackMessages,
-            messagesRemoved: evenMaxRemove,
-        };
-    }
-    return { truncated: false, messages, messagesRemoved: 0 };
-}

package/dist/client/context/stages/structuredSummarizer.js

@@ -1,99 +0,0 @@
-/**
- * Stage 3: Structured LLM Summarization
- *
- * Uses the structured 10-section prompt to summarize older messages
- * while preserving recent ones.
- */
-import { randomUUID } from "crypto";
-import { generateSummary } from "../../utils/conversationMemory.js";
-import { estimateTokens } from "../../utils/tokenEstimation.js";
-import { logger } from "../../utils/logger.js";
-/**
- * Find the split index using token counting — walk backward from the end,
- * accumulating token counts until we've reserved `targetRecentTokens` worth
- * of recent content. Everything before the split index gets summarized.
- */
-function findSplitIndexByTokens(messages, targetRecentTokens, provider) {
-    let recentTokens = 0;
-    let splitIndex = messages.length;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const content = typeof messages[i].content === "string"
-            ? messages[i].content
-            : JSON.stringify(messages[i].content);
-        const msgTokens = estimateTokens(content, provider);
-        if (recentTokens + msgTokens > targetRecentTokens) {
-            splitIndex = i + 1;
-            break;
-        }
-        recentTokens += msgTokens;
-    }
-    // Ensure at least one message is summarized
-    return Math.max(1, splitIndex);
-}
-export async function summarizeMessages(messages, config) {
-    const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
-    if (messages.length <= 4) {
-        return { summarized: false, messages };
-    }
-    // Determine split point: prefer token-based when a target budget is available,
-    // fall back to message-count-based split for backward compatibility.
-    let splitIndex;
-    if (config?.targetTokens && config.targetTokens > 0) {
-        // Keep `keepRecentRatio` fraction of the target budget as recent context
-        const targetRecentTokens = Math.floor(config.targetTokens * keepRecentRatio);
-        // NOTE: config.provider is the summarization provider, not the generation
-        // provider. Ideally we'd use the generation/budget provider for accurate
-        // token estimation, but SummarizeConfig doesn't carry a separate
-        // budgetProvider field. This is a known design limitation.
-        splitIndex = findSplitIndexByTokens(messages, targetRecentTokens, config.provider);
-    }
-    else {
-        // Legacy: message-count-based split
-        const keepCount = Math.max(4, Math.ceil(messages.length * keepRecentRatio));
-        splitIndex = messages.length - keepCount;
-    }
-    // Clamp so at least the last message is always preserved (never summarize everything)
-    splitIndex = Math.min(splitIndex, messages.length - 1);
-    if (splitIndex <= 0) {
-        return { summarized: false, messages };
-    }
-    const messagesToSummarize = messages.slice(0, splitIndex);
-    const recentMessages = messages.slice(splitIndex);
-    // Find previous summary if exists
-    const previousSummary = messagesToSummarize.find((m) => m.metadata?.isSummary)?.content;
-    // Build effective memory config: use provided memoryConfig, or construct from provider/model
-    const effectiveMemoryConfig = config?.memoryConfig ? { ...config.memoryConfig } : {};
-    // Fill in summarization provider/model from compactor config if not already set
-    if (!effectiveMemoryConfig.summarizationProvider && config?.provider) {
-        effectiveMemoryConfig.summarizationProvider = config.provider;
-    }
-    if (!effectiveMemoryConfig.summarizationModel && config?.model) {
-        effectiveMemoryConfig.summarizationModel = config.model;
-    }
-    // Only skip if there's genuinely no provider available
-    if (!effectiveMemoryConfig.summarizationProvider &&
-        !effectiveMemoryConfig.summarizationModel) {
-        logger.debug("[ContextCompactor] Stage 3 skipped: no summarization provider or model available");
-        return { summarized: false, messages };
-    }
-    const summaryText = await generateSummary(messagesToSummarize, effectiveMemoryConfig, "[ContextCompactor]", previousSummary);
-    if (!summaryText) {
-        return { summarized: false, messages };
-    }
-    const summaryMessage = {
-        id: `summary-${randomUUID()}`,
-        role: "user",
-        content: `[Previous conversation summary]:\n\n${summaryText}`,
-        timestamp: new Date().toISOString(),
-        metadata: {
-            isSummary: true,
-            summarizesFrom: messagesToSummarize[0]?.id,
-            summarizesTo: messagesToSummarize[messagesToSummarize.length - 1]?.id,
-        },
-    };
-    return {
-        summarized: true,
-        messages: [summaryMessage, ...recentMessages],
-        summaryText,
-    };
-}

package/dist/client/context/stages/toolOutputPruner.js

@@ -1,52 +0,0 @@
-/**
- * Stage 1: Tool Output Pruning
- *
- * Walk messages backwards, protect recent tool output tokens,
- * replace older tool results with "[Tool result cleared]".
- */
-import { estimateTokens } from "../../utils/tokenEstimation.js";
-const CLEARED_PLACEHOLDER = "[Tool result cleared]";
-const DEFAULT_PROTECT_TOKENS = 40_000;
-const DEFAULT_MINIMUM_SAVINGS = 20_000;
-export function pruneToolOutputs(messages, config) {
-    const protectTokens = config?.protectTokens ?? DEFAULT_PROTECT_TOKENS;
-    const minimumSavings = config?.minimumSavings ?? DEFAULT_MINIMUM_SAVINGS;
-    const protectedTools = new Set(config?.protectedTools ?? ["skill"]);
-    const provider = config?.provider;
-    const result = [...messages];
-    let recentToolTokens = 0;
-    let totalSaved = 0;
-    // Walk backwards to protect recent tool outputs
-    for (let i = result.length - 1; i >= 0; i--) {
-        const msg = result[i];
-        if (msg.role !== "tool_result") {
-            continue;
-        }
-        // Skip protected tools
-        if (msg.tool && protectedTools.has(msg.tool)) {
-            continue;
-        }
-        const contentTokens = estimateTokens(msg.content, provider);
-        if (recentToolTokens < protectTokens) {
-            // This tool output is within the protection window
-            recentToolTokens += contentTokens;
-            continue;
-        }
-        // This tool output is old enough to prune
-        if (msg.content !== CLEARED_PLACEHOLDER) {
-            totalSaved +=
-                contentTokens - estimateTokens(CLEARED_PLACEHOLDER, provider);
-            result[i] = {
-                ...msg,
-                content: CLEARED_PLACEHOLDER,
-                metadata: { ...msg.metadata, truncated: true },
-            };
-        }
-    }
-    const pruned = totalSaved >= minimumSavings;
-    return {
-        pruned,
-        messages: pruned ? result : messages,
-        tokensSaved: pruned ? totalSaved : 0,
-    };
-}

package/dist/client/context/summarizationEngine.js

@@ -1,136 +0,0 @@
-/**
- * Shared Summarization Engine
- *
- * Extracted from ConversationMemoryManager and RedisConversationMemoryManager
- * to eliminate code duplication. Both managers delegate to this engine.
- */
-import { TokenUtils } from "../constants/tokens.js";
-import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
-import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
-import { logger } from "../utils/logger.js";
-/**
- * Centralized summarization engine for conversation memory.
- * Handles token counting, threshold checking, and summary generation.
- */
-export class SummarizationEngine {
-    /**
-     * Check if a session needs summarization and perform it if so.
-     * @param session - Session memory to check and potentially summarize
-     * @param threshold - Token threshold that triggers summarization
-     * @param config - Conversation memory configuration (partial allowed)
-     * @param logPrefix - Prefix for log messages
-     * @returns True if summarization was performed
-     */
-    async checkAndSummarize(session, threshold, config, logPrefix = "[SummarizationEngine]", requestId) {
-        const contextMessages = buildContextFromPointer(session, requestId);
-        const tokenCount = this.estimateTokens(contextMessages);
-        session.lastTokenCount = tokenCount;
-        session.lastCountedAt = Date.now();
-        logger.info("[Summarization] Check", {
-            requestId,
-            sessionId: session.sessionId,
-            tokenCount,
-            threshold,
-            willSummarize: tokenCount >= threshold,
-        });
-        if (tokenCount >= threshold) {
-            await this.summarizeSession(session, threshold, config, logPrefix, requestId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Perform token-based summarization on a session.
-     * Uses pointer-based, non-destructive approach.
-     * @param session - Session memory to summarize
-     * @param threshold - Token threshold for calculating split point
-     * @param config - Conversation memory configuration (partial allowed)
-     * @param logPrefix - Prefix for log messages
-     */
-    async summarizeSession(session, threshold, config, logPrefix = "[SummarizationEngine]", requestId) {
-        const startTime = Date.now();
-        const startIndex = session.summarizedUpToMessageId
-            ? session.messages.findIndex((m) => m.id === session.summarizedUpToMessageId) + 1
-            : 0;
-        const recentMessages = session.messages.slice(startIndex);
-        if (recentMessages.length === 0) {
-            return;
-        }
-        const targetRecentTokens = threshold * RECENT_MESSAGES_RATIO;
-        const splitIndex = this.findSplitIndexByTokens(recentMessages, targetRecentTokens);
-        const messagesToSummarize = recentMessages.slice(0, splitIndex);
-        if (messagesToSummarize.length === 0) {
-            return;
-        }
-        const recentToKeep = recentMessages.length - messagesToSummarize.length;
-        logger.info("[Summarization] Starting", {
-            requestId,
-            sessionId: session.sessionId,
-            messagesToSummarize: messagesToSummarize.length,
-            recentToKeep,
-            hasPreviousSummary: !!session.summarizedMessage,
-        });
-        try {
-            const summary = await generateSummary(messagesToSummarize, config, logPrefix, session.summarizedMessage, requestId);
-            if (!summary) {
-                logger.warn(`${logPrefix} Summary generation failed`, {
-                    requestId,
-                    sessionId: session.sessionId,
-                    durationMs: Date.now() - startTime,
-                });
-                return;
-            }
-            const lastSummarized = messagesToSummarize[messagesToSummarize.length - 1];
-            session.summarizedUpToMessageId = lastSummarized.id;
-            session.summarizedMessage = summary;
-            logger.info("[Summarization] Complete", {
-                requestId,
-                sessionId: session.sessionId,
-                summaryChars: summary.length,
-                newPointerId: lastSummarized.id,
-                durationMs: Date.now() - startTime,
-            });
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            logger.error("[Summarization] Error", {
-                requestId,
-                sessionId: session.sessionId,
-                error: errorMessage,
-                durationMs: Date.now() - startTime,
-            });
-            throw err;
-        }
-    }
-    /**
-     * Estimate total tokens for a message array.
-     * @param messages - Array of chat messages
-     * @returns Estimated token count
-     */
-    estimateTokens(messages) {
-        return messages.reduce((total, msg) => {
-            return total + TokenUtils.estimateTokenCount(msg.content);
-        }, 0);
-    }
-    /**
-     * Find split index to keep recent messages within target token count.
-     * Works backwards from the most recent message to find the split point.
-     * @param messages - Array of messages to analyze
-     * @param targetRecentTokens - Target token count for recent messages
-     * @returns Index at which to split (messages before this index will be summarized)
-     */
-    findSplitIndexByTokens(messages, targetRecentTokens) {
-        let recentTokens = 0;
-        let splitIndex = messages.length;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const msgTokens = TokenUtils.estimateTokenCount(messages[i].content);
-            if (recentTokens + msgTokens > targetRecentTokens) {
-                splitIndex = i + 1;
-                break;
-            }
-            recentTokens += msgTokens;
-        }
-        // Ensure at least one message is summarized
-        return Math.max(1, splitIndex);
-    }
-}