@juspay/neurolink 9.5.2 → 9.6.0

package/dist/context/prompts/summarizationPrompt.js

@@ -0,0 +1,110 @@
+/**
+ * Summarization Prompt Builder
+ *
+ * Builds prompts for summarizing conversation context into a 9-section structure.
+ * Supports both initial summarization and incremental merging with existing summaries.
+ */
+const NINE_SECTIONS = [
+    "Primary Request and Intent",
+    "Key Technical Concepts",
+    "Files and Code Sections",
+    "Problem Solving",
+    "Pending Tasks",
+    "Task Evolution",
+    "Current Work",
+    "Next Step",
+    "Required Files",
+];
+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 9-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?${fileContext}
+
+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 9-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
+6. Keep the summary concise but comprehensive
+7. Maintain the 9-section format${fileContext}
+
+Output the updated summary following the same 9-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 { NINE_SECTIONS };

package/dist/context/stages/fileReadDeduplicator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stage 2: File Read Deduplication
+ *
+ * Detect multiple reads of the same file path, keep only the latest,
+ * replace earlier reads with a notice.
+ */
+import type { ChatMessage } from "../../types/conversation.js";
+import type { DeduplicationResult } from "../../types/contextTypes.js";
+export type { DeduplicationResult } from "../../types/contextTypes.js";
+export declare function deduplicateFileReads(messages: ChatMessage[]): DeduplicationResult;

package/dist/context/stages/fileReadDeduplicator.js

@@ -0,0 +1,66 @@
+/**
+ * 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/context/stages/slidingWindowTruncator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import type { ChatMessage } from "../../types/conversation.js";
+import type { TruncationConfig, TruncationResult } from "../../types/contextTypes.js";
+export type { TruncationConfig, TruncationResult, } from "../../types/contextTypes.js";
+export declare function truncateWithSlidingWindow(messages: ChatMessage[], config?: TruncationConfig): TruncationResult;

package/dist/context/stages/slidingWindowTruncator.js

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+import { randomUUID } from "crypto";
+const TRUNCATION_MARKER_CONTENT = "[Earlier conversation history was truncated to fit within context limits]";
+export function truncateWithSlidingWindow(messages, config) {
+    const fraction = config?.fraction ?? 0.5;
+    if (messages.length <= 4) {
+        return { truncated: false, messages, messagesRemoved: 0 };
+    }
+    // Always preserve first user-assistant pair
+    const firstPair = messages.slice(0, 2);
+    // Calculate how many messages to remove from the middle
+    const remainingMessages = messages.slice(2);
+    const removeCount = Math.floor(remainingMessages.length * fraction);
+    // Ensure we remove an even number to maintain role alternation
+    const evenRemoveCount = removeCount - (removeCount % 2);
+    if (evenRemoveCount <= 0) {
+        return { truncated: false, messages, messagesRemoved: 0 };
+    }
+    const keptAfterTruncation = remainingMessages.slice(evenRemoveCount);
+    // Create truncation marker
+    const truncationMarker = {
+        id: `truncation-${randomUUID()}`,
+        role: "system",
+        content: TRUNCATION_MARKER_CONTENT,
+        timestamp: new Date().toISOString(),
+        metadata: {
+            isSummary: false,
+            truncated: true,
+        },
+    };
+    return {
+        truncated: true,
+        messages: [...firstPair, truncationMarker, ...keptAfterTruncation],
+        messagesRemoved: evenRemoveCount,
+    };
+}

package/dist/context/stages/structuredSummarizer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stage 3: Structured LLM Summarization
+ *
+ * Uses the structured 9-section prompt to summarize older messages
+ * while preserving recent ones.
+ */
+import type { ChatMessage } from "../../types/conversation.js";
+import type { SummarizeConfig, SummarizeResult } from "../../types/contextTypes.js";
+export type { SummarizeConfig, SummarizeResult, } from "../../types/contextTypes.js";
+export declare function summarizeMessages(messages: ChatMessage[], config?: SummarizeConfig): Promise<SummarizeResult>;

package/dist/context/stages/structuredSummarizer.js

@@ -0,0 +1,49 @@
+/**
+ * Stage 3: Structured LLM Summarization
+ *
+ * Uses the structured 9-section prompt to summarize older messages
+ * while preserving recent ones.
+ */
+import { generateSummary } from "../../utils/conversationMemory.js";
+import { randomUUID } from "crypto";
+export async function summarizeMessages(messages, config) {
+    const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
+    if (messages.length <= 4) {
+        return { summarized: false, messages };
+    }
+    // Keep the most recent messages unsummarized
+    const keepCount = Math.max(4, Math.ceil(messages.length * keepRecentRatio));
+    const splitIndex = messages.length - keepCount;
+    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;
+    // Use memory config for summarization if available
+    if (config?.memoryConfig) {
+        const summaryText = await generateSummary(messagesToSummarize, config.memoryConfig, "[ContextCompactor]", previousSummary);
+        if (!summaryText) {
+            return { summarized: false, messages };
+        }
+        const summaryMessage = {
+            id: `summary-${randomUUID()}`,
+            role: "system",
+            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,
+        };
+    }
+    // Without memory config, we can't call LLM
+    return { summarized: false, messages };
+}

package/dist/context/stages/toolOutputPruner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stage 1: Tool Output Pruning
+ *
+ * Walk messages backwards, protect recent tool output tokens,
+ * replace older tool results with "[Tool result cleared]".
+ */
+import type { ChatMessage } from "../../types/conversation.js";
+import type { PruneConfig, PruneResult } from "../../types/contextTypes.js";
+export type { PruneConfig, PruneResult } from "../../types/contextTypes.js";
+export declare function pruneToolOutputs(messages: ChatMessage[], config?: PruneConfig): PruneResult;

package/dist/context/stages/toolOutputPruner.js

@@ -0,0 +1,52 @@
+/**
+ * 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/context/summarizationEngine.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared Summarization Engine
+ *
+ * Extracted from ConversationMemoryManager and RedisConversationMemoryManager
+ * to eliminate code duplication. Both managers delegate to this engine.
+ */
+import type { ChatMessage, ConversationMemoryConfig, SessionMemory } from "../types/conversation.js";
+/**
+ * Centralized summarization engine for conversation memory.
+ * Handles token counting, threshold checking, and summary generation.
+ */
+export declare 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
+     */
+    checkAndSummarize(session: SessionMemory, threshold: number, config: Partial<ConversationMemoryConfig>, logPrefix?: string): Promise<boolean>;
+    /**
+     * 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
+     */
+    summarizeSession(session: SessionMemory, threshold: number, config: Partial<ConversationMemoryConfig>, logPrefix?: string): Promise<void>;
+    /**
+     * Estimate total tokens for a message array.
+     * @param messages - Array of chat messages
+     * @returns Estimated token count
+     */
+    estimateTokens(messages: ChatMessage[]): number;
+    /**
+     * 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: ChatMessage[], targetRecentTokens: number): number;
+}

package/dist/context/summarizationEngine.js

@@ -0,0 +1,110 @@
+/**
+ * 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]") {
+        const contextMessages = buildContextFromPointer(session);
+        const tokenCount = this.estimateTokens(contextMessages);
+        session.lastTokenCount = tokenCount;
+        session.lastCountedAt = Date.now();
+        logger.debug(`${logPrefix} Token count check`, {
+            sessionId: session.sessionId,
+            tokenCount,
+            threshold,
+            needsSummarization: tokenCount >= threshold,
+        });
+        if (tokenCount >= threshold) {
+            await this.summarizeSession(session, threshold, config, logPrefix);
+            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]") {
+        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 summary = await generateSummary(messagesToSummarize, config, logPrefix, session.summarizedMessage);
+        if (!summary) {
+            logger.warn(`${logPrefix} Summary generation failed`, {
+                sessionId: session.sessionId,
+            });
+            return;
+        }
+        const lastSummarized = messagesToSummarize[messagesToSummarize.length - 1];
+        session.summarizedUpToMessageId = lastSummarized.id;
+        session.summarizedMessage = summary;
+        logger.info(`${logPrefix} Summarization complete`, {
+            sessionId: session.sessionId,
+            summarizedCount: messagesToSummarize.length,
+            totalMessages: session.messages.length,
+        });
+    }
+    /**
+     * 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);
+    }
+}

package/dist/context/toolOutputLimits.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tool Output Size Limits
+ *
+ * Truncates tool outputs exceeding size limits.
+ * Can save full output to disk with a pointer.
+ * Modeled on OpenCode's approach.
+ */
+/** Maximum tool output size in bytes (50KB) */
+export declare const MAX_TOOL_OUTPUT_BYTES: number;
+/** Maximum tool output lines */
+export declare const MAX_TOOL_OUTPUT_LINES = 2000;
+import type { TruncateOptions, TruncateResult } from "../types/contextTypes.js";
+export type { TruncateOptions, TruncateResult } from "../types/contextTypes.js";
+/**
+ * Truncate tool output if it exceeds size limits.
+ */
+export declare function truncateToolOutput(output: string, options?: TruncateOptions): TruncateResult;

package/dist/context/toolOutputLimits.js

@@ -0,0 +1,84 @@
+/**
+ * Tool Output Size Limits
+ *
+ * Truncates tool outputs exceeding size limits.
+ * Can save full output to disk with a pointer.
+ * Modeled on OpenCode's approach.
+ */
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { tmpdir } from "os";
+/** Maximum tool output size in bytes (50KB) */
+export const MAX_TOOL_OUTPUT_BYTES = 50 * 1024;
+/** Maximum tool output lines */
+export const MAX_TOOL_OUTPUT_LINES = 2_000;
+/**
+ * Truncate tool output if it exceeds size limits.
+ */
+export function truncateToolOutput(output, options) {
+    const maxBytes = options?.maxBytes ?? MAX_TOOL_OUTPUT_BYTES;
+    const maxLines = options?.maxLines ?? MAX_TOOL_OUTPUT_LINES;
+    const direction = options?.direction ?? "tail";
+    const saveToDisk = options?.saveToDisk ?? false;
+    const originalSize = Buffer.byteLength(output, "utf-8");
+    // Check byte limit
+    const exceedsBytes = originalSize > maxBytes;
+    // Check line limit
+    const lines = output.split("\n");
+    const exceedsLines = lines.length > maxLines;
+    if (!exceedsBytes && !exceedsLines) {
+        return { content: output, truncated: false, originalSize };
+    }
+    // Save to disk if requested
+    let savedPath;
+    if (saveToDisk) {
+        try {
+            const saveDir = options?.saveDir ?? join(tmpdir(), "neurolink-tool-output");
+            mkdirSync(saveDir, { recursive: true });
+            savedPath = join(saveDir, `tool-output-${randomUUID()}.txt`);
+            writeFileSync(savedPath, output, "utf-8");
+        }
+        catch {
+            // Silently fail disk save
+        }
+    }
+    // Apply truncation
+    let truncated;
+    if (exceedsLines) {
+        if (direction === "head") {
+            truncated = lines.slice(0, maxLines).join("\n");
+        }
+        else {
+            truncated = lines.slice(-maxLines).join("\n");
+        }
+    }
+    else {
+        truncated = output;
+    }
+    // Apply byte limit
+    if (Buffer.byteLength(truncated, "utf-8") > maxBytes) {
+        if (direction === "head") {
+            truncated = truncated.slice(0, maxBytes);
+        }
+        else {
+            truncated = truncated.slice(-maxBytes);
+        }
+    }
+    // Add truncation notice
+    const notice = savedPath
+        ? `\n\n[Output truncated from ${originalSize} bytes to ${Buffer.byteLength(truncated, "utf-8")} bytes. Full output saved to: ${savedPath}]`
+        : `\n\n[Output truncated from ${originalSize} bytes to ${Buffer.byteLength(truncated, "utf-8")} bytes]`;
+    if (direction === "head") {
+        truncated = truncated + notice;
+    }
+    else {
+        truncated = notice + "\n" + truncated;
+    }
+    return {
+        content: truncated,
+        truncated: true,
+        savedPath,
+        originalSize,
+    };
+}

package/dist/context/toolPairRepair.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool Use/Result Pair Repair
+ *
+ * After compaction, validates that every tool_use (tool_call) has a
+ * corresponding tool_result and vice versa. Inserts synthetic
+ * placeholders for orphaned entries.
+ */
+import type { ChatMessage } from "../types/conversation.js";
+import type { RepairResult } from "../types/contextTypes.js";
+export type { RepairResult } from "../types/contextTypes.js";
+/**
+ * Repair orphaned tool_use/tool_result pairs in a message array.
+ *
+ * Ensures every tool_call has a following tool_result and vice versa.
+ */
+export declare function repairToolPairs(messages: ChatMessage[]): RepairResult;