@juspay/neurolink 9.23.0 → 9.25.0

package/dist/lib/context/contextCompactor.js

@@ -8,9 +8,11 @@
  * Stage 3: LLM Summarization (expensive -- requires LLM call)
  * Stage 4: Sliding Window Truncation (fallback -- no LLM call)
  */
-import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { estimateMessagesTokens } from "../utils/tokenEstimation.js";
 import { logger } from "../utils/logger.js";
+import { withTimeout } from "../utils/async/withTimeout.js";
+import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
+import { getMetricsAggregator } from "../observability/index.js";
 import { pruneToolOutputs } from "./stages/toolOutputPruner.js";
 import { deduplicateFileReads } from "./stages/fileReadDeduplicator.js";
 import { summarizeMessages } from "./stages/structuredSummarizer.js";
@@ -38,155 +40,161 @@ export class ContextCompactor {
      * Run the multi-stage compaction pipeline until messages fit within budget.
      */
     async compact(messages, targetTokens, memoryConfig, requestId) {
-        const compactionStartTime = Date.now();
-        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,
+        const span = SpanSerializer.createSpan(SpanType.CONTEXT_COMPACTION, "context.compact", {
+            "context.operation": "compact",
+            "context.targetTokens": 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)", {
+        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 summarizeMessages(currentMessages, {
-                    provider: this.config.summarizationProvider,
-                    model: this.config.summarizationModel,
-                    keepRecentRatio: this.config.keepRecentRatio,
-                    memoryConfig,
+            // 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 (summarizeResult.summarized) {
-                    currentMessages = summarizeResult.messages;
-                    stagesUsed.push("summarize");
+                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) {
-                // Capture the actual error for debugging
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const errorName = error instanceof Error ? error.name : "UnknownError";
-                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: errorMessage,
-                    errorName,
+                    ran: dedupResult.deduplicated,
                     tokensBefore: stageTokensBefore,
-                    tokensAfter: stageTokensBefore,
-                    saved: 0,
+                    tokensAfter: stageTokensAfter,
+                    saved: stageTokensBefore - stageTokensAfter,
                 });
-                // Record on OTel span for trace visibility
-                const activeSpan = trace.getActiveSpan();
-                if (activeSpan) {
-                    activeSpan.addEvent("compaction.stage3.failed", {
-                        "error.message": errorMessage,
-                        "error.name": errorName,
-                        "stage.tokens_before": stageTokensBefore,
-                    });
-                    if (error instanceof Error) {
-                        activeSpan.recordException(error);
+            }
+            // 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,
+                    }), 120_000, "LLM summarization timed out after 120s");
+                    if (summarizeResult.summarized) {
+                        currentMessages = summarizeResult.messages;
+                        stagesUsed.push("summarize");
                     }
-                    // NLK-GAP-005 fix: set error status alongside recordException
-                    activeSpan.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: `Compaction stage 3 (summarize) failed: ${errorMessage}`,
+                    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
+                    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
                 }
-                // 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: 3,
-            });
-            if (truncResult.truncated) {
-                currentMessages = truncResult.messages;
-                stagesUsed.push("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,
+                });
+                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 stageTokensAfter = estimateMessagesTokens(currentMessages, provider);
-            logger.info("[Compaction] Stage 4 (truncate)", {
+            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 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;
         }
-        const tokensAfter = estimateMessagesTokens(currentMessages, provider);
-        logger.info("[Compaction] Complete", {
-            requestId,
-            tokensBefore,
-            tokensAfter,
-            totalSaved: tokensBefore - tokensAfter,
-            stagesUsed,
-            durationMs: Date.now() - compactionStartTime,
-        });
-        return {
-            compacted: stagesUsed.length > 0,
-            stagesUsed,
-            tokensBefore,
-            tokensAfter,
-            tokensSaved: tokensBefore - tokensAfter,
-            messages: currentMessages,
-        };
     }
 }
 //# sourceMappingURL=contextCompactor.js.map

package/dist/lib/core/baseProvider.d.ts

@@ -24,6 +24,11 @@ export declare abstract class BaseProvider implements AIProvider {
     protected sessionId?: string;
     protected userId?: string;
     protected neurolink?: NeuroLink;
+    /** Trace context propagated from NeuroLink SDK for span hierarchy */
+    _traceContext: {
+        traceId: string;
+        parentSpanId: string;
+    } | null;
     private readonly messageBuilder;
     private readonly streamHandler;
     private readonly generationHandler;