@juspay/neurolink 9.5.2 → 9.6.0

package/dist/context/contextCompactor.js

@@ -0,0 +1,106 @@
+/**
+ * ContextCompactor
+ *
+ * Orchestrates multi-stage context reduction:
+ *
+ * Stage 1: Tool Output Pruning (cheapest -- no LLM call)
+ * Stage 2: File Read Deduplication (cheap -- no LLM call)
+ * Stage 3: LLM Summarization (expensive -- requires LLM call)
+ * Stage 4: Sliding Window Truncation (fallback -- no LLM call)
+ */
+import { estimateMessagesTokens } from "../utils/tokenEstimation.js";
+import { pruneToolOutputs } from "./stages/toolOutputPruner.js";
+import { deduplicateFileReads } from "./stages/fileReadDeduplicator.js";
+import { summarizeMessages } from "./stages/structuredSummarizer.js";
+import { truncateWithSlidingWindow } from "./stages/slidingWindowTruncator.js";
+const DEFAULT_CONFIG = {
+    enablePrune: true,
+    enableDeduplicate: true,
+    enableSummarize: true,
+    enableTruncate: true,
+    pruneProtectTokens: 40_000,
+    pruneMinimumSavings: 20_000,
+    pruneProtectedTools: ["skill"],
+    summarizationProvider: "vertex",
+    summarizationModel: "gemini-2.5-flash",
+    keepRecentRatio: 0.3,
+    truncationFraction: 0.5,
+    provider: "",
+};
+export class ContextCompactor {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Run the multi-stage compaction pipeline until messages fit within budget.
+     */
+    async compact(messages, targetTokens, memoryConfig) {
+        const provider = this.config.provider || undefined;
+        const tokensBefore = estimateMessagesTokens(messages, provider);
+        const stagesUsed = [];
+        let currentMessages = [...messages];
+        // Stage 1: Tool Output Pruning
+        if (this.config.enablePrune &&
+            estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+            const pruneResult = pruneToolOutputs(currentMessages, {
+                protectTokens: this.config.pruneProtectTokens,
+                minimumSavings: this.config.pruneMinimumSavings,
+                protectedTools: this.config.pruneProtectedTools,
+                provider,
+            });
+            if (pruneResult.pruned) {
+                currentMessages = pruneResult.messages;
+                stagesUsed.push("prune");
+            }
+        }
+        // Stage 2: File Read Deduplication
+        if (this.config.enableDeduplicate &&
+            estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+            const dedupResult = deduplicateFileReads(currentMessages);
+            if (dedupResult.deduplicated) {
+                currentMessages = dedupResult.messages;
+                stagesUsed.push("deduplicate");
+            }
+        }
+        // Stage 3: LLM Summarization
+        if (this.config.enableSummarize &&
+            estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+            try {
+                const summarizeResult = await summarizeMessages(currentMessages, {
+                    provider: this.config.summarizationProvider,
+                    model: this.config.summarizationModel,
+                    keepRecentRatio: this.config.keepRecentRatio,
+                    memoryConfig,
+                });
+                if (summarizeResult.summarized) {
+                    currentMessages = summarizeResult.messages;
+                    stagesUsed.push("summarize");
+                }
+            }
+            catch {
+                // Summarization failed, fall through to truncation
+            }
+        }
+        // Stage 4: Sliding Window Truncation (fallback)
+        if (this.config.enableTruncate &&
+            estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+            const truncResult = truncateWithSlidingWindow(currentMessages, {
+                fraction: this.config.truncationFraction,
+            });
+            if (truncResult.truncated) {
+                currentMessages = truncResult.messages;
+                stagesUsed.push("truncate");
+            }
+        }
+        const tokensAfter = estimateMessagesTokens(currentMessages, provider);
+        return {
+            compacted: stagesUsed.length > 0,
+            stagesUsed,
+            tokensBefore,
+            tokensAfter,
+            tokensSaved: tokensBefore - tokensAfter,
+            messages: currentMessages,
+        };
+    }
+}

package/dist/context/effectiveHistory.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Effective History Filter
+ *
+ * Filters message arrays to return only "visible" messages,
+ * excluding those tagged by condensation or truncation.
+ * Supports non-destructive context management where messages
+ * are tagged instead of deleted.
+ */
+import type { ChatMessage } from "../types/conversation.js";
+/**
+ * Get the effective (visible) history from a message array.
+ *
+ * Filters out:
+ * - Messages with a condenseParent (replaced by a summary)
+ * - Messages with a truncationParent (hidden by truncation)
+ *
+ * Keeps:
+ * - Summary messages (isSummary = true)
+ * - Truncation markers (isTruncationMarker = true)
+ * - All other untagged messages
+ */
+export declare function getEffectiveHistory(messages: ChatMessage[]): ChatMessage[];
+/**
+ * Tag messages for condensation (non-destructive summary).
+ *
+ * @param messages - Full message array
+ * @param fromIndex - Start index of messages to condense
+ * @param toIndex - End index (exclusive) of messages to condense
+ * @param condenseId - UUID for this condensation group
+ * @returns Updated message array with tags applied
+ */
+export declare function tagForCondensation(messages: ChatMessage[], fromIndex: number, toIndex: number, condenseId: string): ChatMessage[];
+/**
+ * Tag messages for truncation (non-destructive hiding).
+ *
+ * @param messages - Full message array
+ * @param fromIndex - Start index of messages to truncate
+ * @param toIndex - End index (exclusive) of messages to truncate
+ * @param truncationId - UUID for this truncation group
+ * @returns Updated message array with tags applied
+ */
+export declare function tagForTruncation(messages: ChatMessage[], fromIndex: number, toIndex: number, truncationId: string): ChatMessage[];
+/**
+ * Remove condensation tags (rewind).
+ * Makes previously condensed messages visible again.
+ */
+export declare function removeCondensationTags(messages: ChatMessage[], condenseId: string): ChatMessage[];
+/**
+ * Remove truncation tags (rewind).
+ * Makes previously truncated messages visible again.
+ */
+export declare function removeTruncationTags(messages: ChatMessage[], truncationId: string): ChatMessage[];

package/dist/context/effectiveHistory.js

@@ -0,0 +1,105 @@
+/**
+ * Effective History Filter
+ *
+ * Filters message arrays to return only "visible" messages,
+ * excluding those tagged by condensation or truncation.
+ * Supports non-destructive context management where messages
+ * are tagged instead of deleted.
+ */
+/**
+ * Get the effective (visible) history from a message array.
+ *
+ * Filters out:
+ * - Messages with a condenseParent (replaced by a summary)
+ * - Messages with a truncationParent (hidden by truncation)
+ *
+ * Keeps:
+ * - Summary messages (isSummary = true)
+ * - Truncation markers (isTruncationMarker = true)
+ * - All other untagged messages
+ */
+export function getEffectiveHistory(messages) {
+    return messages.filter((msg) => {
+        // Exclude messages that have been condensed (replaced by summary)
+        if (msg.condenseParent) {
+            return false;
+        }
+        // Exclude messages that have been truncated (hidden by marker)
+        if (msg.truncationParent) {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Tag messages for condensation (non-destructive summary).
+ *
+ * @param messages - Full message array
+ * @param fromIndex - Start index of messages to condense
+ * @param toIndex - End index (exclusive) of messages to condense
+ * @param condenseId - UUID for this condensation group
+ * @returns Updated message array with tags applied
+ */
+export function tagForCondensation(messages, fromIndex, toIndex, condenseId) {
+    return messages.map((msg, i) => {
+        if (i >= fromIndex && i < toIndex) {
+            return { ...msg, condenseParent: condenseId };
+        }
+        return msg;
+    });
+}
+/**
+ * Tag messages for truncation (non-destructive hiding).
+ *
+ * @param messages - Full message array
+ * @param fromIndex - Start index of messages to truncate
+ * @param toIndex - End index (exclusive) of messages to truncate
+ * @param truncationId - UUID for this truncation group
+ * @returns Updated message array with tags applied
+ */
+export function tagForTruncation(messages, fromIndex, toIndex, truncationId) {
+    return messages.map((msg, i) => {
+        if (i >= fromIndex && i < toIndex) {
+            return { ...msg, truncationParent: truncationId };
+        }
+        return msg;
+    });
+}
+/**
+ * Remove condensation tags (rewind).
+ * Makes previously condensed messages visible again.
+ */
+export function removeCondensationTags(messages, condenseId) {
+    return messages
+        .map((msg) => {
+        if (msg.condenseParent === condenseId) {
+            const { condenseParent, ...rest } = msg;
+            return rest;
+        }
+        // Also remove the summary message itself
+        if (msg.condenseId === condenseId && msg.metadata?.isSummary) {
+            return null;
+        }
+        return msg;
+    })
+        .filter((msg) => msg !== null);
+}
+/**
+ * Remove truncation tags (rewind).
+ * Makes previously truncated messages visible again.
+ */
+export function removeTruncationTags(messages, truncationId) {
+    return messages
+        .map((msg) => {
+        if (msg.truncationParent === truncationId) {
+            const { truncationParent, ...rest } = msg;
+            return rest;
+        }
+        // Also remove the truncation marker itself
+        if (msg.truncationId === truncationId && msg.isTruncationMarker) {
+            return null;
+        }
+        return msg;
+    })
+        .filter((msg) => msg !== null);
+}

package/dist/context/errorDetection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Context Overflow Error Detection
+ *
+ * Cross-provider regex patterns to detect context window overflow errors.
+ * Modeled on Cline + pi-mono patterns.
+ */
+/**
+ * Check if an error is a context overflow error from any provider.
+ */
+export declare function isContextOverflowError(error: unknown): boolean;
+/**
+ * Identify which provider produced the context overflow error.
+ */
+export declare function getContextOverflowProvider(error: unknown): string | null;

package/dist/context/errorDetection.js

@@ -0,0 +1,124 @@
+/**
+ * Context Overflow Error Detection
+ *
+ * Cross-provider regex patterns to detect context window overflow errors.
+ * Modeled on Cline + pi-mono patterns.
+ */
+/**
+ * Provider-specific error patterns for context overflow.
+ *
+ * IMPORTANT: Order matters for getContextOverflowProvider - more specific
+ * patterns should be checked first. OpenAI patterns are very specific
+ * (e.g., "This model's maximum context length is") so they come first.
+ */
+const OVERFLOW_PATTERNS = [
+    {
+        provider: "openai",
+        patterns: [
+            /This model's maximum context length is/i,
+            /tokens\. However, (?:your messages|you requested)/i,
+            /reduce the length of the messages/i,
+            /Please reduce the length/i,
+        ],
+    },
+    {
+        provider: "azure",
+        patterns: [/content_length_exceeded/i],
+    },
+    {
+        provider: "google",
+        patterns: [
+            /RESOURCE_EXHAUSTED/i,
+            /exceeds the maximum number of tokens/i,
+            /content is too long/i,
+            /request payload size exceeds/i,
+            /input token limit/i,
+        ],
+    },
+    {
+        provider: "bedrock",
+        patterns: [
+            /ValidationException.*token/i,
+            /Input is too long/i,
+            /exceeds the model's maximum/i,
+        ],
+    },
+    {
+        provider: "mistral",
+        patterns: [/context length exceeded/i, /maximum number of tokens/i],
+    },
+    {
+        provider: "openrouter",
+        patterns: [/context_length_exceeded/i],
+    },
+    {
+        provider: "anthropic",
+        patterns: [
+            /prompt is too long/i,
+            /input is too long/i,
+            /too many tokens/i,
+            /maximum context length/i,
+        ],
+    },
+];
+/**
+ * Check if an error is a context overflow error from any provider.
+ */
+export function isContextOverflowError(error) {
+    const errorMessage = extractErrorMessage(error);
+    if (!errorMessage) {
+        return false;
+    }
+    return OVERFLOW_PATTERNS.some(({ patterns }) => patterns.some((pattern) => pattern.test(errorMessage)));
+}
+/**
+ * Identify which provider produced the context overflow error.
+ */
+export function getContextOverflowProvider(error) {
+    const errorMessage = extractErrorMessage(error);
+    if (!errorMessage) {
+        return null;
+    }
+    for (const { provider, patterns } of OVERFLOW_PATTERNS) {
+        if (patterns.some((pattern) => pattern.test(errorMessage))) {
+            return provider;
+        }
+    }
+    return null;
+}
+/**
+ * Extract error message from various error formats.
+ */
+function extractErrorMessage(error) {
+    if (!error) {
+        return null;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (error instanceof Error) {
+        // Check nested error messages too
+        const msg = error.message;
+        const cause = error?.cause;
+        if (cause instanceof Error) {
+            return `${msg} ${cause.message}`;
+        }
+        return msg;
+    }
+    if (typeof error === "object") {
+        const obj = error;
+        if (typeof obj.message === "string") {
+            return obj.message;
+        }
+        if (typeof obj.error === "string") {
+            return obj.error;
+        }
+        if (typeof obj.error === "object" && obj.error !== null) {
+            const nested = obj.error;
+            if (typeof nested.message === "string") {
+                return nested.message;
+            }
+        }
+    }
+    return null;
+}

package/dist/context/fileSummarizationService.d.ts

@@ -0,0 +1,54 @@
+/**
+ * File Summarization Service
+ *
+ * Orchestrates the end-to-end file summarization pipeline:
+ *  1. Accept raw file inputs (strings or Buffers)
+ *  2. Extract readable text and estimate tokens
+ *  3. Use `planFileSummarization()` to decide which files to summarize
+ *  4. Call an LLM to produce context-aware summaries of the largest files
+ *  5. Fall back to truncation when the LLM call fails
+ *
+ * The LLM is instantiated via a *dynamic import* of NeuroLink to avoid
+ * circular dependency issues (NeuroLink → fileSummarizationService → NeuroLink).
+ */
+import { type FileForSummarization, type FileSummarizationCheckParams, type SummarizedFile } from "./fileSummarizer.js";
+import type { RawFileInput } from "../types/contextTypes.js";
+export type { RawFileInput } from "../types/contextTypes.js";
+/** Constructor options. */
+type FileSummarizationServiceOptions = {
+    /** Provider used for the summarization LLM call (default: "vertex") */
+    provider?: string;
+    /** Model used for the summarization LLM call (default: "gemini-2.5-flash") */
+    model?: string;
+};
+export declare class FileSummarizationService {
+    private readonly provider;
+    private readonly model;
+    constructor(options?: FileSummarizationServiceOptions);
+    /**
+     * Extract readable text from a file's content.
+     *
+     * - Strings are returned as-is.
+     * - Buffers are decoded as UTF-8 when the MIME type is textual.
+     * - Known-binary types (image/*, audio/*, video/*) return a placeholder.
+     */
+    extractFileText(content: string | Buffer, mimeType: string, fileName: string): string;
+    /**
+     * Map a MIME type (and filename for fallback) to a human-readable label.
+     */
+    getFileTypeLabel(mimeType: string, fileName: string): string;
+    /**
+     * Convert an array of raw file inputs into `FileForSummarization` objects.
+     *
+     * Extracts text and estimates token count for each file.
+     */
+    prepareFilesForSummarization(files: RawFileInput[], provider?: string): FileForSummarization[];
+    /**
+     * Summarize files that exceed the context budget.
+     *
+     * For each file marked "summarize" by `planFileSummarization()`, we call
+     * the configured LLM to produce a context-aware summary. If the LLM call
+     * fails, we fall back to naive truncation so the request can still proceed.
+     */
+    summarizeFiles(files: FileForSummarization[], userPrompt: string, budgetParams: FileSummarizationCheckParams): Promise<SummarizedFile[]>;
+}