@juspay/neurolink 9.15.0 → 9.16.0

package/dist/core/conversationMemoryManager.js

@@ -8,7 +8,9 @@ import { TokenUtils } from "../constants/tokens.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
 import { ConversationMemoryError } from "../types/conversation.js";
 import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
+import { runWithCurrentLangfuseContext } from "../services/server/ai/observability/instrumentation.js";
 import { logger } from "../utils/logger.js";
+import { tracers, withSpan } from "../telemetry/index.js";
 export class ConversationMemoryManager {
     sessions = new Map();
     config;
@@ -62,61 +64,76 @@ export class ConversationMemoryManager {
      * TOKEN-BASED: Validates message size and triggers summarization based on tokens
      */
     async storeConversationTurn(options) {
-        await this.ensureInitialized();
-        try {
-            // Get or create session
-            let session = this.sessions.get(options.sessionId);
-            if (!session) {
-                session = this.createNewSession(options.sessionId, options.userId);
-                this.sessions.set(options.sessionId, session);
-            }
-            const tokenThreshold = options.providerDetails
-                ? getEffectiveTokenThreshold(options.providerDetails.provider, options.providerDetails.model, this.config.tokenThreshold, session.tokenThreshold)
-                : this.config.tokenThreshold || 50000;
-            const userMsg = await this.validateAndPrepareMessage(options.userMessage, "user", tokenThreshold);
-            const assistantMsg = await this.validateAndPrepareMessage(options.aiResponse, "assistant", tokenThreshold);
-            if (options.events && options.events.length > 0) {
-                assistantMsg.events = options.events;
-            }
-            session.messages.push(userMsg, assistantMsg);
-            session.lastActivity = Date.now();
-            // Store API-reported token counts if available
-            if (options.tokenUsage) {
-                session.lastApiTokenCount = options.tokenUsage;
-            }
-            const shouldSummarize = options.enableSummarization !== undefined
-                ? options.enableSummarization
-                : this.config.enableSummarization;
-            if (shouldSummarize) {
-                // Only trigger summarization if not already in progress for this session
-                if (!this.summarizationInProgress.has(options.sessionId)) {
-                    setImmediate(async () => {
-                        try {
-                            await this.checkAndSummarize(session, tokenThreshold, options.requestId);
-                        }
-                        catch (error) {
-                            logger.error("Background summarization failed", {
-                                sessionId: session.sessionId,
-                                requestId: options.requestId,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        }
-                    });
+        return withSpan({
+            name: "neurolink.memory.storeTurn",
+            tracer: tracers.memory,
+            attributes: {
+                "memory.type": "in-memory",
+                "session.id": options.sessionId,
+                "memory.operation": "store_turn",
+            },
+        }, async (span) => {
+            await this.ensureInitialized();
+            try {
+                // Get or create session
+                let session = this.sessions.get(options.sessionId);
+                if (!session) {
+                    session = this.createNewSession(options.sessionId, options.userId);
+                    this.sessions.set(options.sessionId, session);
                 }
-                else {
-                    logger.debug("[ConversationMemoryManager] Summarization already in progress, skipping", {
-                        sessionId: options.sessionId,
-                    });
+                const tokenThreshold = options.providerDetails
+                    ? getEffectiveTokenThreshold(options.providerDetails.provider, options.providerDetails.model, this.config.tokenThreshold, session.tokenThreshold)
+                    : this.config.tokenThreshold || 50000;
+                const userMsg = await this.validateAndPrepareMessage(options.userMessage, "user", tokenThreshold);
+                const assistantMsg = await this.validateAndPrepareMessage(options.aiResponse, "assistant", tokenThreshold);
+                if (options.events && options.events.length > 0) {
+                    assistantMsg.events = options.events;
                 }
+                session.messages.push(userMsg, assistantMsg);
+                session.lastActivity = Date.now();
+                // Store API-reported token counts if available
+                if (options.tokenUsage) {
+                    session.lastApiTokenCount = options.tokenUsage;
+                }
+                span.setAttribute("memory.message_count", session.messages.length);
+                const shouldSummarize = options.enableSummarization !== undefined
+                    ? options.enableSummarization
+                    : this.config.enableSummarization;
+                if (shouldSummarize) {
+                    // Only trigger summarization if not already in progress for this session
+                    if (!this.summarizationInProgress.has(options.sessionId)) {
+                        // Capture the current Langfuse ALS context before setImmediate,
+                        // which breaks automatic AsyncLocalStorage propagation and would
+                        // otherwise cause orphaned traces in Langfuse.
+                        const summarizeWithContext = runWithCurrentLangfuseContext(async () => {
+                            try {
+                                await this.checkAndSummarize(session, tokenThreshold, options.requestId);
+                            }
+                            catch (error) {
+                                logger.error("Background summarization failed", {
+                                    sessionId: session.sessionId,
+                                    requestId: options.requestId,
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            }
+                        });
+                        setImmediate(summarizeWithContext);
+                    }
+                    else {
+                        logger.debug("[ConversationMemoryManager] Summarization already in progress, skipping", {
+                            sessionId: options.sessionId,
+                        });
+                    }
+                }
+                this.enforceSessionLimit();
             }
-            this.enforceSessionLimit();
-        }
-        catch (error) {
-            throw new ConversationMemoryError(`Failed to store conversation turn for session ${options.sessionId}`, "STORAGE_ERROR", {
-                sessionId: options.sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
+            catch (error) {
+                throw new ConversationMemoryError(`Failed to store conversation turn for session ${options.sessionId}`, "STORAGE_ERROR", {
+                    sessionId: options.sessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
     }
     /**
      * Validate and prepare a message before adding to session
@@ -197,8 +214,22 @@ export class ConversationMemoryManager {
      * Now consistently async to match Redis implementation
      */
     async buildContextMessages(sessionId, _userId, _enableSummarization, requestId) {
-        const session = this.sessions.get(sessionId);
-        return session ? buildContextFromPointer(session, requestId) : [];
+        return withSpan({
+            name: "neurolink.memory.buildContext",
+            tracer: tracers.memory,
+            attributes: {
+                "memory.type": "in-memory",
+                "session.id": sessionId,
+                "memory.operation": "build_context",
+            },
+        }, async (span) => {
+            const session = this.sessions.get(sessionId);
+            const messages = session
+                ? buildContextFromPointer(session, requestId)
+                : [];
+            span.setAttribute("memory.message_count", messages.length);
+            return messages;
+        });
     }
     getSession(sessionId, _userId) {
         return this.sessions.get(sessionId);
@@ -251,13 +282,25 @@ export class ConversationMemoryManager {
         };
     }
     async clearSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return false;
-        }
-        this.sessions.delete(sessionId);
-        logger.info("Session cleared", { sessionId });
-        return true;
+        return withSpan({
+            name: "neurolink.memory.clear",
+            tracer: tracers.memory,
+            attributes: {
+                "memory.type": "in-memory",
+                "session.id": sessionId,
+                "memory.operation": "clear_session",
+            },
+        }, async (span) => {
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                span.setAttribute("memory.session_found", false);
+                return false;
+            }
+            this.sessions.delete(sessionId);
+            span.setAttribute("memory.session_found", true);
+            logger.info("Session cleared", { sessionId });
+            return true;
+        });
     }
     async clearAllSessions() {
         const sessionIds = Array.from(this.sessions.keys());

package/dist/core/evaluationProviders.js

@@ -56,7 +56,7 @@ export function getAvailableProviders() {
  * Sort providers by preference (cost, speed, quality)
  */
 export function sortProvidersByPreference(providers, preferCheap = true) {
-    return providers.sort((a, b) => {
+    return [...providers].sort((a, b) => {
         const aPerf = a.performance || { cost: 0, speed: 0, quality: 0 };
         const bPerf = b.performance || { cost: 0, speed: 0, quality: 0 };
         if (preferCheap) {
@@ -160,16 +160,17 @@ export function getPerformanceOptimizedProvider(priority = "speed") {
     if (availableProviders.length === 0) {
         return null;
     }
-    // Score providers based on real performance data
-    const scoredProviders = availableProviders.map((provider) => {
+    // Score providers based on real performance data.
+    // Only consider providers that have runtime metrics (sampleCount >= 3).
+    // Providers without metrics are excluded to avoid misleading recommendations
+    // (e.g. ollama appearing as "recommended" when it has no requiredEnvVars and
+    // thus always passes the "available" check, even when not actually in use).
+    const scoredProviders = [];
+    for (const provider of availableProviders) {
         const metrics = providerMetrics.get(provider.provider);
         if (!metrics || metrics.sampleCount < 3) {
-            // Fall back to static performance ratings for providers without data
-            return {
-                provider,
-                score: getStaticPerformanceScore(provider, priority),
-                metrics: null,
-            };
+            // Skip providers without sufficient runtime data
+            continue;
         }
         let score = 0;
         switch (priority) {
@@ -190,34 +191,16 @@ export function getPerformanceOptimizedProvider(priority = "speed") {
                 break;
             }
         }
-        return { provider, score, metrics };
-    });
+        scoredProviders.push({ provider, score });
+    }
+    if (scoredProviders.length === 0) {
+        // No providers have sufficient runtime data to make a recommendation
+        return null;
+    }
     // Sort by score and return best
     scoredProviders.sort((a, b) => b.score - a.score);
     return scoredProviders[0].provider;
 }
-/**
- * Helper function for providers without performance data
- */
-function getStaticPerformanceScore(provider, priority) {
-    switch (priority) {
-        case "speed": {
-            const speedScore = provider.performance?.speed || 1;
-            return speedScore;
-        }
-        case "cost": {
-            const costScore = provider.performance?.cost || 1;
-            return costScore;
-        }
-        case "reliability": {
-            const qualityScore = provider.performance?.quality || 1;
-            return qualityScore;
-        }
-        default: {
-            throw new Error(`Invalid priority: "${priority}". Must be one of: speed, cost, reliability`);
-        }
-    }
-}
 export function getProviderPerformanceAnalytics() {
     const analytics = {};
     for (const [providerName, metrics] of providerMetrics.entries()) {