@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/context/contextCompactor.js

@@ -12,6 +12,9 @@ import { estimateMessagesTokens } from "../utils/tokenEstimation.js";
 import { logger } from "../utils/logger.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { getActiveTraceContext } from "../telemetry/traceContext.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 import { pruneToolOutputs } from "./stages/toolOutputPruner.js";
 import { deduplicateFileReads } from "./stages/fileReadDeduplicator.js";
 import { truncateWithSlidingWindow } from "./stages/slidingWindowTruncator.js";
@@ -39,167 +42,184 @@ export class ContextCompactor {
      * Run the multi-stage compaction pipeline until messages fit within budget.
      */
     async compact(messages, targetTokens, memoryConfig, requestId) {
-        let span = SpanSerializer.createSpan(SpanType.CONTEXT_COMPACTION, "context.compact", {
-            "context.operation": "compact",
-            "context.targetTokens": targetTokens,
-        });
-        const spanStartTime = Date.now();
-        try {
-            const provider = this.config.provider || undefined;
-            const tokensBefore = estimateMessagesTokens(messages, provider);
-            const stagesUsed = [];
-            let currentMessages = [...messages];
-            logger.info("[Compaction] Starting", {
-                requestId,
-                estimatedTokens: tokensBefore,
-                budgetTokens: targetTokens,
-            });
-            // Stage 1: Tool Output Pruning
-            if (this.config.enablePrune &&
-                estimateMessagesTokens(currentMessages, provider) > targetTokens) {
-                const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
-                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");
-                }
-                const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
-                logger.info("[Compaction] Stage 1 (prune)", {
+        return withSpan({
+            name: "neurolink.context.compact",
+            tracer: tracers.context,
+            attributes: {
+                "context.target_tokens": targetTokens,
+                "context.message_count": messages.length,
+            },
+        }, async () => {
+            const { traceId, parentSpanId } = getActiveTraceContext();
+            let span = SpanSerializer.createSpan(SpanType.CONTEXT_COMPACTION, "context.compact", {
+                "context.operation": "compact",
+                "context.targetTokens": targetTokens,
+            }, parentSpanId, traceId);
+            const spanStartTime = Date.now();
+            try {
+                const provider = this.config.provider || undefined;
+                const tokensBefore = estimateMessagesTokens(messages, provider);
+                const stagesUsed = [];
+                let currentMessages = [...messages];
+                logger.info("[Compaction] Starting", {
                     requestId,
-                    ran: pruneResult.pruned,
-                    tokensBefore: stageTokensBefore,
-                    tokensAfter: stageTokensAfter,
-                    saved: stageTokensBefore - stageTokensAfter,
+                    estimatedTokens: tokensBefore,
+                    budgetTokens: targetTokens,
                 });
-            }
-            // Stage 2: File Read Deduplication
-            if (this.config.enableDeduplicate &&
-                estimateMessagesTokens(currentMessages, provider) > targetTokens) {
-                const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
-                const dedupResult = deduplicateFileReads(currentMessages);
-                if (dedupResult.deduplicated) {
-                    currentMessages = dedupResult.messages;
-                    stagesUsed.push("deduplicate");
-                }
-                const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
-                logger.info("[Compaction] Stage 2 (deduplicate)", {
-                    requestId,
-                    ran: dedupResult.deduplicated,
-                    tokensBefore: stageTokensBefore,
-                    tokensAfter: stageTokensAfter,
-                    saved: stageTokensBefore - stageTokensAfter,
-                });
-            }
-            // Stage 3: LLM Summarization
-            if (this.config.enableSummarize &&
-                estimateMessagesTokens(currentMessages, provider) > targetTokens) {
-                const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
-                try {
-                    const summarizeResult = await withTimeout(summarizeMessages(currentMessages, {
-                        provider: this.config.summarizationProvider,
-                        model: this.config.summarizationModel,
-                        keepRecentRatio: this.config.keepRecentRatio,
-                        memoryConfig,
-                        targetTokens,
-                    }), 120_000, "LLM summarization timed out after 120s");
-                    if (summarizeResult.summarized) {
-                        currentMessages = summarizeResult.messages;
-                        stagesUsed.push("summarize");
+                // Stage 1: Tool Output Pruning
+                if (this.config.enablePrune &&
+                    estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+                    const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
+                    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");
                     }
                     const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
-                    logger.info("[Compaction] Stage 3 (summarize)", {
+                    logger.info("[Compaction] Stage 1 (prune)", {
                         requestId,
-                        ran: summarizeResult.summarized,
+                        ran: pruneResult.pruned,
                         tokensBefore: stageTokensBefore,
                         tokensAfter: stageTokensAfter,
                         saved: stageTokensBefore - stageTokensAfter,
                     });
                 }
-                catch (error) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    logger.warn("[Compaction] Stage 3 (summarize) FAILED", {
+                // Stage 2: File Read Deduplication
+                if (this.config.enableDeduplicate &&
+                    estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+                    const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
+                    const dedupResult = deduplicateFileReads(currentMessages);
+                    if (dedupResult.deduplicated) {
+                        currentMessages = dedupResult.messages;
+                        stagesUsed.push("deduplicate");
+                    }
+                    const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
+                    logger.info("[Compaction] Stage 2 (deduplicate)", {
                         requestId,
-                        error: err.message,
-                        errorName: err.name,
+                        ran: dedupResult.deduplicated,
                         tokensBefore: stageTokensBefore,
-                        tokensAfter: stageTokensBefore,
-                        saved: 0,
-                    });
-                    // Record failure on the compaction span for trace visibility
-                    span = SpanSerializer.updateAttributes(span, {
-                        "compaction.stage3.error": err.message,
-                        "compaction.stage3.errorName": err.name,
-                        "compaction.stage3.tokensBefore": stageTokensBefore,
-                        "compaction.stage3_failed": true,
+                        tokensAfter: stageTokensAfter,
+                        saved: stageTokensBefore - stageTokensAfter,
                     });
-                    // Fall through to Stage 4 truncation as before
                 }
-            }
-            // Stage 4: Sliding Window Truncation (fallback)
-            if (this.config.enableTruncate &&
-                estimateMessagesTokens(currentMessages, provider) > targetTokens) {
-                const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
-                const truncResult = truncateWithSlidingWindow(currentMessages, {
-                    fraction: this.config.truncationFraction,
-                    currentTokens: stageTokensBefore,
-                    targetTokens: targetTokens,
-                    provider: provider,
-                    adaptiveBuffer: 0.15,
-                    maxIterations: 6,
-                });
-                if (truncResult.truncated) {
-                    currentMessages = truncResult.messages;
-                    stagesUsed.push("truncate");
+                // Stage 3: LLM Summarization
+                if (this.config.enableSummarize &&
+                    estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+                    const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
+                    try {
+                        const summarizeResult = await withTimeout(summarizeMessages(currentMessages, {
+                            provider: this.config.summarizationProvider,
+                            model: this.config.summarizationModel,
+                            keepRecentRatio: this.config.keepRecentRatio,
+                            memoryConfig,
+                            targetTokens,
+                        }), 120_000, "LLM summarization timed out after 120s");
+                        if (summarizeResult.summarized) {
+                            currentMessages = summarizeResult.messages;
+                            stagesUsed.push("summarize");
+                        }
+                        const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
+                        logger.info("[Compaction] Stage 3 (summarize)", {
+                            requestId,
+                            ran: summarizeResult.summarized,
+                            tokensBefore: stageTokensBefore,
+                            tokensAfter: stageTokensAfter,
+                            saved: stageTokensBefore - stageTokensAfter,
+                        });
+                    }
+                    catch (error) {
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        logger.warn("[Compaction] Stage 3 (summarize) FAILED", {
+                            requestId,
+                            error: err.message,
+                            errorName: err.name,
+                            tokensBefore: stageTokensBefore,
+                            tokensAfter: stageTokensBefore,
+                            saved: 0,
+                        });
+                        // Record failure on the compaction span for trace visibility
+                        span = SpanSerializer.updateAttributes(span, {
+                            "compaction.stage3.error": err.message,
+                            "compaction.stage3.errorName": err.name,
+                            "compaction.stage3.tokensBefore": stageTokensBefore,
+                            "compaction.stage3_failed": true,
+                        });
+                        // Fall through to Stage 4 truncation as before
+                    }
                 }
-                const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
-                logger.info("[Compaction] Stage 4 (truncate)", {
+                // Stage 4: Sliding Window Truncation (fallback)
+                if (this.config.enableTruncate &&
+                    estimateMessagesTokens(currentMessages, provider) > targetTokens) {
+                    const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
+                    const truncResult = truncateWithSlidingWindow(currentMessages, {
+                        fraction: this.config.truncationFraction,
+                        currentTokens: stageTokensBefore,
+                        targetTokens: targetTokens,
+                        provider: provider,
+                        adaptiveBuffer: 0.15,
+                        maxIterations: 6,
+                    });
+                    if (truncResult.truncated) {
+                        currentMessages = truncResult.messages;
+                        stagesUsed.push("truncate");
+                    }
+                    const stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
+                    logger.info("[Compaction] Stage 4 (truncate)", {
+                        requestId,
+                        ran: truncResult.truncated,
+                        tokensBefore: stageTokensBefore,
+                        tokensAfter: stageTokensAfter,
+                        saved: stageTokensBefore - stageTokensAfter,
+                    });
+                }
+                const tokensAfter = estimateMessagesTokens(currentMessages, provider);
+                logger.info("[Compaction] Complete", {
                     requestId,
-                    ran: truncResult.truncated,
-                    tokensBefore: stageTokensBefore,
-                    tokensAfter: stageTokensAfter,
-                    saved: stageTokensBefore - stageTokensAfter,
+                    tokensBefore,
+                    tokensAfter,
+                    totalSaved: tokensBefore - tokensAfter,
+                    stagesUsed,
+                    durationMs: Date.now() - spanStartTime,
                 });
+                const result = {
+                    compacted: stagesUsed.length > 0,
+                    stagesUsed,
+                    tokensBefore,
+                    tokensAfter,
+                    tokensSaved: tokensBefore - tokensAfter,
+                    messages: currentMessages,
+                };
+                span.durationMs = Date.now() - spanStartTime;
+                const compactionSucceeded = tokensAfter <= targetTokens;
+                const finalStatus = compactionSucceeded
+                    ? SpanStatus.OK
+                    : SpanStatus.WARNING;
+                const finalMessage = compactionSucceeded
+                    ? undefined
+                    : `Compaction insufficient: ${tokensAfter} tokens remain (target: ${targetTokens})`;
+                const endedSpan = SpanSerializer.endSpan(SpanSerializer.updateAttributes(span, {
+                    "context.stage": stagesUsed.join(",") || "none",
+                    "context.tokensBefore": tokensBefore,
+                    "context.tokensAfter": tokensAfter,
+                    "context.tokensSaved": tokensBefore - tokensAfter,
+                }), finalStatus, finalMessage);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return result;
+            }
+            catch (error) {
+                span.durationMs = Date.now() - spanStartTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+                endedSpan.statusMessage =
+                    error instanceof Error ? error.message : String(error);
+                getMetricsAggregator().recordSpan(endedSpan);
+                throw error;
             }
-            const tokensAfter = estimateMessagesTokens(currentMessages, provider);
-            logger.info("[Compaction] Complete", {
-                requestId,
-                tokensBefore,
-                tokensAfter,
-                totalSaved: tokensBefore - tokensAfter,
-                stagesUsed,
-                durationMs: Date.now() - spanStartTime,
-            });
-            const result = {
-                compacted: stagesUsed.length > 0,
-                stagesUsed,
-                tokensBefore,
-                tokensAfter,
-                tokensSaved: tokensBefore - tokensAfter,
-                messages: currentMessages,
-            };
-            span.durationMs = Date.now() - spanStartTime;
-            const endedSpan = SpanSerializer.endSpan(SpanSerializer.updateAttributes(span, {
-                "context.stage": stagesUsed.join(",") || "none",
-                "context.tokensBefore": tokensBefore,
-                "context.tokensAfter": tokensAfter,
-                "context.tokensSaved": tokensBefore - tokensAfter,
-            }), SpanStatus.OK);
-            getMetricsAggregator().recordSpan(endedSpan);
-            return result;
-        }
-        catch (error) {
-            span.durationMs = Date.now() - spanStartTime;
-            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
-            endedSpan.statusMessage =
-                error instanceof Error ? error.message : String(error);
-            getMetricsAggregator().recordSpan(endedSpan);
-            throw error;
-        }
+        }); // end withSpan
     }
 }
 //# sourceMappingURL=contextCompactor.js.map

package/dist/lib/context/fileSummarizationService.d.ts

@@ -11,14 +11,7 @@
  * The LLM is instantiated via a *dynamic import* of NeuroLink to avoid
  * circular dependency issues (NeuroLink → fileSummarizationService → NeuroLink).
  */
-import type { FileSummarizationCheckParams, FileForSummarization, RawFileInput, SummarizedFile } from "../types/index.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;
-};
+import type { FileForSummarization, FileSummarizationCheckParams, FileSummarizationServiceOptions, RawFileInput, SummarizedFile } from "../types/index.js";
 export declare class FileSummarizationService {
     private readonly provider;
     private readonly model;
@@ -50,4 +43,3 @@ export declare class FileSummarizationService {
      */
     summarizeFiles(files: FileForSummarization[], userPrompt: string, budgetParams: FileSummarizationCheckParams): Promise<SummarizedFile[]>;
 }
-export {};

package/dist/lib/context/summarizationEngine.js

@@ -7,6 +7,8 @@
 import { TokenUtils } from "../constants/tokens.js";
 import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
 import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 import { logger } from "../utils/logger.js";
 /**
  * Centralized summarization engine for conversation memory.
@@ -22,22 +24,33 @@ export class SummarizationEngine {
      * @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;
+        return withSpan({
+            name: "neurolink.memory.summarize",
+            tracer: tracers.memory,
+            attributes: {
+                "memory.session_id": session.sessionId ?? "unknown",
+                "memory.threshold": threshold,
+            },
+        }, async (span) => {
+            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);
+                span.setAttribute("memory.summarized", true);
+                return true;
+            }
+            span.setAttribute("memory.summarized", false);
+            return false;
+        }); // end withSpan
     }
     /**
      * Perform token-based summarization on a session.