@juspay/neurolink 7.54.0 → 8.0.1

package/dist/lib/services/server/ai/observability/instrumentation.d.ts

@@ -55,3 +55,20 @@ export declare function getLangfuseHealthStatus(): {
         release: string;
     } | undefined;
 };
+/**
+ * Set user and session context for Langfuse spans in the current async context
+ *
+ * Merges the provided context with existing AsyncLocalStorage context. If a callback is provided,
+ * the context is scoped to that callback execution. Without a callback, the context applies to
+ * the current execution context and its children.
+ *
+ * Uses AsyncLocalStorage to properly scope context per request, avoiding race conditions
+ * in concurrent scenarios.
+ *
+ * @param context - Object containing optional userId and/or sessionId to merge with existing context
+ * @param callback - Optional callback to run within the context scope. If omitted, context applies to current execution
+ */
+export declare function setLangfuseContext(context: {
+    userId?: string | null;
+    sessionId?: string | null;
+}, callback?: () => void | Promise<void>): Promise<void>;

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -10,13 +10,38 @@ import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { AsyncLocalStorage } from "async_hooks";
 import { logger } from "../../../../utils/logger.js";
 const LOG_PREFIX = "[OpenTelemetry]";
+const contextStorage = new AsyncLocalStorage();
 let tracerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
 let isCredentialsValid = false;
 let currentConfig = null;
+/**
+ * Span processor that enriches spans with user and session context from AsyncLocalStorage
+ */
+class ContextEnricher {
+    onStart(span) {
+        const context = contextStorage.getStore();
+        const userId = context?.userId ?? currentConfig?.userId;
+        const sessionId = context?.sessionId ?? currentConfig?.sessionId;
+        if (userId) {
+            span.setAttribute("user.id", userId);
+        }
+        if (sessionId) {
+            span.setAttribute("session.id", sessionId);
+        }
+    }
+    onEnd() { }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
 /**
  * Initialize OpenTelemetry with Langfuse span processor
  *
@@ -46,7 +71,6 @@ export function initializeOpenTelemetry(config) {
     try {
         currentConfig = config;
         isCredentialsValid = true;
-        // Create Langfuse span processor with configuration
         langfuseProcessor = new LangfuseSpanProcessor({
             publicKey: config.publicKey,
             secretKey: config.secretKey,
@@ -54,18 +78,15 @@ export function initializeOpenTelemetry(config) {
             environment: config.environment || "dev",
             release: config.release || "v1.0.0",
         });
-        // Create resource with service metadata (v2.x API)
         const resource = resourceFromAttributes({
             [ATTR_SERVICE_NAME]: "neurolink",
             [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
             "deployment.environment": config.environment || "dev",
         });
-        // Initialize tracer provider with span processor and resource
         tracerProvider = new NodeTracerProvider({
             resource,
-            spanProcessors: [langfuseProcessor],
+            spanProcessors: [new ContextEnricher(), langfuseProcessor],
         });
-        // Register provider globally so Vercel AI SDK can use it
         tracerProvider.register();
         isInitialized = true;
         logger.info(`${LOG_PREFIX} Initialized with Langfuse span processor`, {
@@ -168,4 +189,32 @@ export function getLangfuseHealthStatus() {
             : undefined,
     };
 }
+/**
+ * Set user and session context for Langfuse spans in the current async context
+ *
+ * Merges the provided context with existing AsyncLocalStorage context. If a callback is provided,
+ * the context is scoped to that callback execution. Without a callback, the context applies to
+ * the current execution context and its children.
+ *
+ * Uses AsyncLocalStorage to properly scope context per request, avoiding race conditions
+ * in concurrent scenarios.
+ *
+ * @param context - Object containing optional userId and/or sessionId to merge with existing context
+ * @param callback - Optional callback to run within the context scope. If omitted, context applies to current execution
+ */
+export async function setLangfuseContext(context, callback) {
+    const currentContext = contextStorage.getStore() || {};
+    const newContext = {
+        userId: context.userId !== undefined ? context.userId : currentContext.userId,
+        sessionId: context.sessionId !== undefined
+            ? context.sessionId
+            : currentContext.sessionId,
+    };
+    if (callback) {
+        return await contextStorage.run(newContext, callback);
+    }
+    else {
+        contextStorage.enterWith(newContext);
+    }
+}
 //# sourceMappingURL=instrumentation.js.map

package/dist/lib/types/conversation.d.ts

@@ -2,10 +2,7 @@
  * Conversation Memory Types for NeuroLink
  * Provides type-safe conversation storage and context management
  */
-import type { MemoryConfig } from "mem0ai/oss";
-/**
- * Mem0 configuration type matching mem0ai/oss MemoryConfig structure
- */
+import type { Mem0Config } from "../memory/mem0Initializer.js";
 /**
  * Configuration for conversation memory feature
  */
@@ -28,8 +25,8 @@ export type ConversationMemoryConfig = {
     summarizationModel?: string;
     /** Enable mem0 integration for conversation memory */
     mem0Enabled?: boolean;
-    /** Configuration for mem0 integration */
-    mem0Config?: MemoryConfig;
+    /** Configuration for mem0 cloud API integration */
+    mem0Config?: Mem0Config;
     /** Redis configuration (optional) - overrides environment variables */
     redisConfig?: RedisStorageConfig;
 };

package/dist/lib/types/observability.d.ts

@@ -24,6 +24,10 @@ export type LangfuseConfig = {
     environment?: string;
     /** Release/version identifier */
     release?: string;
+    /** Optional default user id to attach to spans */
+    userId?: string;
+    /** Optional default session id to attach to spans */
+    sessionId?: string;
 };
 /**
  * OpenTelemetry configuration

package/dist/lib/types/utilities.d.ts

@@ -171,38 +171,3 @@ export type EnvVarValidationResult = {
     invalidVars: string[];
     warnings: string[];
 };
-/**
- * Interface for mem0 Memory instance methods based on actual mem0ai/oss API
- */
-export type Mem0Memory = {
-    search(query: string, config: {
-        userId?: string;
-        limit?: number;
-    }): Promise<{
-        results: Array<{
-            memory: string;
-            id: string;
-        }>;
-    }>;
-    add(messages: string, config: {
-        userId?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<{
-        results: Array<{
-            id: string;
-            memory: string;
-        }>;
-    }>;
-    get(memoryId: string): Promise<{
-        id: string;
-        memory: string;
-    } | null>;
-    update(memoryId: string, data: string): Promise<{
-        message: string;
-    }>;
-    delete(memoryId: string): Promise<{
-        message: string;
-    }>;
-    history(memoryId: string): Promise<unknown[]>;
-    reset(): Promise<void>;
-};

package/dist/lib/utils/fileDetector.js

@@ -3,7 +3,7 @@
  * Centralized file detection for all multimodal file types
  * Uses multi-strategy approach for reliable type identification
  */
-import { request } from "undici";
+import { request, getGlobalDispatcher, interceptors } from "undici";
 import { readFile, stat } from "fs/promises";
 import { logger } from "./logger.js";
 import { CSVProcessor } from "./csvProcessor.js";
@@ -146,10 +146,10 @@ export class FileDetector {
         const maxSize = options?.maxSize || 10 * 1024 * 1024;
         const timeout = options?.timeout || 30000;
         const response = await request(url, {
+            dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
             method: "GET",
             headersTimeout: timeout,
             bodyTimeout: timeout,
-            maxRedirections: 5,
         });
         if (response.statusCode !== 200) {
             throw new Error(`HTTP ${response.statusCode}`);
@@ -271,10 +271,10 @@ class MimeTypeStrategy {
         }
         try {
             const response = await request(input, {
+                dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
                 method: "HEAD",
                 headersTimeout: 5000,
                 bodyTimeout: 5000,
-                maxRedirections: 5,
             });
             const contentType = response.headers["content-type"] || "";
             const type = this.mimeToFileType(contentType);

package/dist/lib/utils/messageBuilder.js

@@ -8,7 +8,7 @@ import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerIma
 import { logger } from "./logger.js";
 import { FileDetector } from "./fileDetector.js";
 import { PDFProcessor } from "./pdfProcessor.js";
-import { request } from "undici";
+import { request, getGlobalDispatcher, interceptors } from "undici";
 import { readFileSync, existsSync } from "fs";
 /**
  * Type guard for validating message roles
@@ -562,10 +562,10 @@ function isInternetUrl(input) {
 async function downloadImageFromUrl(url) {
     try {
         const response = await request(url, {
+            dispatcher: getGlobalDispatcher().compose(interceptors.redirect({ maxRedirections: 5 })),
             method: "GET",
             headersTimeout: 10000, // 10 second timeout for headers
-            bodyTimeout: 30000, // 30 second timeout for body
-            maxRedirections: 5,
+            bodyTimeout: 30000, // 30 second timeout for body,
         });
         if (response.statusCode !== 200) {
             throw new Error(`HTTP ${response.statusCode}: Failed to download image from ${url}`);

package/dist/mcp/mcpClientFactory.js

@@ -20,9 +20,6 @@ export class MCPClientFactory {
         version: "1.0.0",
     };
     static DEFAULT_CAPABILITIES = {
-        tools: {},
-        resources: {},
-        prompts: {},
         sampling: {},
         roots: {
             listChanged: false,

package/dist/memory/mem0Initializer.d.ts

@@ -1,10 +1,15 @@
 /**
  * Mem0 Memory Initializer
- * Simple initialization logic for mem0ai/oss integration
+ * Simple initialization logic for mem0ai cloud API integration
  */
-import type { MemoryConfig } from "mem0ai/oss";
-import type { Mem0Memory } from "../types/utilities.js";
+import { MemoryClient } from "mem0ai";
 /**
- * Initialize mem0 memory instance with configuration
+ * Mem0 cloud API configuration
  */
-export declare function initializeMem0(mem0Config: MemoryConfig): Promise<Mem0Memory | null>;
+export interface Mem0Config {
+    apiKey: string;
+}
+/**
+ * Initialize mem0 memory instance with cloud API
+ */
+export declare function initializeMem0(mem0Config: Mem0Config): Promise<MemoryClient | null>;

package/dist/memory/mem0Initializer.js

@@ -1,42 +1,31 @@
 /**
  * Mem0 Memory Initializer
- * Simple initialization logic for mem0ai/oss integration
+ * Simple initialization logic for mem0ai cloud API integration
  */
-import { Memory } from "mem0ai/oss";
+import { MemoryClient } from "mem0ai";
 import { logger } from "../utils/logger.js";
 /**
- * Initialize mem0 memory instance with configuration
+ * Initialize mem0 memory instance with cloud API
  */
 export async function initializeMem0(mem0Config) {
-    logger.debug("[mem0Initializer] Starting mem0 initialization");
+    // Guard: skip initialization if API key is missing
+    if (!mem0Config?.apiKey || mem0Config.apiKey.trim() === "") {
+        logger.warn("[mem0Initializer] Missing MEM0_API_KEY; skipping mem0 initialization");
+        return null;
+    }
+    logger.debug("[mem0Initializer] Starting mem0 cloud API initialization");
     try {
-        // Create Memory instance
-        const memory = new Memory(mem0Config);
-        logger.info("[mem0Initializer] Mem0 initialized successfully");
-        return memory;
+        // Create MemoryClient instance with cloud API
+        const client = new MemoryClient({
+            apiKey: mem0Config.apiKey,
+        });
+        logger.info("[mem0Initializer] Mem0 cloud API initialized successfully");
+        return client;
     }
     catch (error) {
-        logger.warn("[mem0Initializer] Failed to initialize mem0, using fallback", {
+        logger.warn("[mem0Initializer] Failed to initialize mem0 cloud API; disabling mem0", {
             error: error instanceof Error ? error.message : String(error),
         });
-        return createFallbackMemory();
+        return null;
     }
 }
-/**
- * Create fallback memory implementation
- */
-function createFallbackMemory() {
-    return {
-        search: async () => ({ results: [] }),
-        add: async () => ({ results: [] }),
-        get: async () => null,
-        update: async () => ({
-            message: "Fallback memory does not support updates",
-        }),
-        delete: async () => ({
-            message: "Fallback memory does not support deletion",
-        }),
-        history: async () => [],
-        reset: async () => { },
-    };
-}

package/dist/neurolink.d.ts

@@ -50,6 +50,10 @@ export declare class NeuroLink {
     private hitlManager?;
     private mem0Instance?;
     private mem0Config?;
+    /**
+     * Extract and set Langfuse context from options with proper async scoping
+     */
+    private setLangfuseContextFromOptions;
     /**
      * Simple sync config setup for mem0
      */
@@ -130,6 +134,10 @@ export declare class NeuroLink {
     private initializeHITL;
     /** Format memory context for prompt inclusion */
     private formatMemoryContext;
+    /** Extract memory context from search results */
+    private extractMemoryContext;
+    /** Store conversation turn in mem0 */
+    private storeConversationTurn;
     /**
      * Set up HITL event forwarding to main emitter
      */