@juspay/neurolink 9.23.0 → 9.25.0

package/dist/lib/rag/pipeline/RAGPipeline.js

@@ -33,12 +33,16 @@ import { InMemoryBM25Index, createHybridSearch, } from "../retrieval/hybridSearc
 import { GraphRAG } from "../graphRag/graphRAG.js";
 import { rerank } from "../reranker/reranker.js";
 import { ProviderFactory } from "../../factories/providerFactory.js";
+import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
 import { logger } from "../../utils/logger.js";
+import { withTimeout } from "../../utils/async/withTimeout.js";
 /**
  * RAG Pipeline Orchestrator
  *
  * Complete end-to-end pipeline for Retrieval-Augmented Generation.
  */
+/** Default timeout for external provider calls (30 seconds) */
+const DEFAULT_TIMEOUT_MS = 30_000;
 export class RAGPipeline {
     id;
     config;
@@ -195,96 +199,127 @@ export class RAGPipeline {
      * @returns RAG response with retrieved context and optional generated answer
      */
     async query(query, options) {
-        await this.ensureInitialized();
-        const startTime = Date.now();
-        const topK = options?.topK || this.config.defaultTopK || 5;
-        const useHybrid = options?.hybrid ?? this.config.enableHybridSearch;
-        const useGraph = options?.graph ?? this.config.enableGraphRAG;
-        const useRerank = options?.rerank ?? this.config.enableReranking;
-        let results;
-        let retrievalMethod = "vector";
-        // Generate query embedding
-        const queryEmbedding = await this.generateEmbedding(query);
-        if (useGraph && this.config.enableGraphRAG) {
-            // Graph RAG search
-            retrievalMethod = "graph";
-            const graphResults = this.graphRAG.query({
-                query: queryEmbedding,
-                topK: topK * 2, // Get more for potential reranking
-            });
-            results = graphResults.map((r) => ({
-                id: r.id,
-                text: r.content,
-                score: r.score,
-                metadata: r.metadata,
-            }));
-        }
-        else if (useHybrid && this.hybridSearch) {
-            // Hybrid search
-            retrievalMethod = "hybrid";
-            const hybridResults = await this.hybridSearch(query, { topK: topK * 2 });
-            results = hybridResults.map((r) => ({
+        const span = SpanSerializer.createSpan(SpanType.RAG, "rag.pipeline", {
+            "rag.operation": "pipeline",
+            "rag.query": query.slice(0, 200),
+            "rag.topK": options?.topK ?? this.config.defaultTopK ?? 5,
+            "rag.hybrid": options?.hybrid ?? this.config.enableHybridSearch ?? false,
+            "rag.graph": options?.graph ?? this.config.enableGraphRAG ?? false,
+            "rag.rerank": options?.rerank ?? this.config.enableReranking ?? false,
+        });
+        const spanStartTime = Date.now();
+        try {
+            await this.ensureInitialized();
+            const startTime = Date.now();
+            const topK = options?.topK || this.config.defaultTopK || 5;
+            const useHybrid = options?.hybrid ?? this.config.enableHybridSearch;
+            const useGraph = options?.graph ?? this.config.enableGraphRAG;
+            const useRerank = options?.rerank ?? this.config.enableReranking;
+            let results;
+            let retrievalMethod = "vector";
+            // Generate query embedding
+            const queryEmbedding = await this.generateEmbedding(query);
+            if (useGraph && this.config.enableGraphRAG) {
+                // Graph RAG search
+                retrievalMethod = "graph";
+                const graphResults = this.graphRAG.query({
+                    query: queryEmbedding,
+                    topK: topK * 2, // Get more for potential reranking
+                });
+                results = graphResults.map((r) => ({
+                    id: r.id,
+                    text: r.content,
+                    score: r.score,
+                    metadata: r.metadata,
+                }));
+            }
+            else if (useHybrid && this.hybridSearch) {
+                // Hybrid search
+                retrievalMethod = "hybrid";
+                const hybridResults = await this.hybridSearch(query, {
+                    topK: topK * 2,
+                });
+                results = hybridResults.map((r) => ({
+                    id: r.id,
+                    text: r.text,
+                    score: r.score,
+                    metadata: r.metadata,
+                }));
+            }
+            else {
+                // Vector search
+                results = await this.vectorStore.query({
+                    indexName: this.config.indexName ?? "default",
+                    queryVector: queryEmbedding,
+                    topK: topK * 2,
+                    filter: options?.filter,
+                });
+            }
+            // Apply reranking if enabled
+            let reranked = false;
+            if (useRerank && this.config.rerankingModel && results.length > 0) {
+                const rerankModel = await ProviderFactory.createProvider(this.config.rerankingModel.provider, this.config.rerankingModel.modelName);
+                const rerankedResults = await rerank(results, query, rerankModel, {
+                    topK,
+                    queryEmbedding,
+                });
+                results = rerankedResults.map((r) => r.result);
+                reranked = true;
+            }
+            // Take top K results
+            results = results.slice(0, topK);
+            // Assemble context
+            const context = this.assembleContext(results);
+            // Format sources
+            const sources = results.map((r) => ({
                 id: r.id,
-                text: r.text,
-                score: r.score,
+                text: r.text || r.metadata?.text || "",
+                score: r.score || 0,
                 metadata: r.metadata,
             }));
-        }
-        else {
-            // Vector search
-            results = await this.vectorStore.query({
-                indexName: this.config.indexName ?? "default",
-                queryVector: queryEmbedding,
-                topK: topK * 2,
-                filter: options?.filter,
-            });
-        }
-        // Apply reranking if enabled
-        let reranked = false;
-        if (useRerank && this.config.rerankingModel && results.length > 0) {
-            const rerankModel = await ProviderFactory.createProvider(this.config.rerankingModel.provider, this.config.rerankingModel.modelName);
-            const rerankedResults = await rerank(results, query, rerankModel, {
-                topK,
-                queryEmbedding,
+            // Generate answer if requested
+            let answer;
+            if (options?.generate !== false && this.generationProvider) {
+                answer = await this.generateAnswer(query, context, options?.systemPrompt, options?.temperature);
+            }
+            const queryTime = Date.now() - startTime;
+            logger.info("[RAGPipeline] Query completed", {
+                query: query.slice(0, 50),
+                retrievalMethod,
+                resultsCount: results.length,
+                reranked,
+                queryTime,
             });
-            results = rerankedResults.map((r) => r.result);
-            reranked = true;
+            const response = {
+                answer,
+                context,
+                sources,
+                metadata: {
+                    queryTime,
+                    retrievalMethod,
+                    chunksRetrieved: results.length,
+                    reranked,
+                },
+            };
+            span.durationMs = Date.now() - spanStartTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            endedSpan.attributes = {
+                ...endedSpan.attributes,
+                "rag.retrieval_method": retrievalMethod,
+                "rag.results_count": results.length,
+                "rag.reranked": reranked,
+            };
+            getMetricsAggregator().recordSpan(endedSpan);
+            return response;
         }
-        // Take top K results
-        results = results.slice(0, topK);
-        // Assemble context
-        const context = this.assembleContext(results);
-        // Format sources
-        const sources = results.map((r) => ({
-            id: r.id,
-            text: r.text || r.metadata?.text || "",
-            score: r.score || 0,
-            metadata: r.metadata,
-        }));
-        // Generate answer if requested
-        let answer;
-        if (options?.generate !== false && this.generationProvider) {
-            answer = await this.generateAnswer(query, context, options?.systemPrompt, options?.temperature);
+        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 queryTime = Date.now() - startTime;
-        logger.info("[RAGPipeline] Query completed", {
-            query: query.slice(0, 50),
-            retrievalMethod,
-            resultsCount: results.length,
-            reranked,
-            queryTime,
-        });
-        return {
-            answer,
-            context,
-            sources,
-            metadata: {
-                queryTime,
-                retrievalMethod,
-                chunksRetrieved: results.length,
-                reranked,
-            },
-        };
     }
     /**
      * Get pipeline statistics
@@ -340,7 +375,7 @@ export class RAGPipeline {
             .embed !== "function") {
             throw new Error(`Provider ${this.config.embeddingModel.provider} does not support embeddings`);
         }
-        return await this.embeddingProvider.embed(text);
+        return await withTimeout(this.embeddingProvider.embed(text), DEFAULT_TIMEOUT_MS, "Embedding generation timed out");
     }
     /**
      * Assemble context from results
@@ -367,12 +402,12 @@ Use only the information from the context to answer the question.
 If the context doesn't contain relevant information, say so.
 Cite sources when possible using [Source N] format.`;
         const prompt = `Context:\n${context}\n\nQuestion: ${query}\n\nAnswer:`;
-        const result = await this.generationProvider.generate({
+        const result = await withTimeout(this.generationProvider.generate({
             prompt,
             systemPrompt,
             temperature: temperature ?? this.config.generationModel?.temperature ?? 0.7,
             maxTokens: this.config.generationModel?.maxTokens ?? 1000,
-        });
+        }), DEFAULT_TIMEOUT_MS * 2, "Answer generation timed out");
         return result?.content || "";
     }
 }

package/dist/lib/rag/ragIntegration.js

@@ -9,6 +9,7 @@
 import { existsSync, readFileSync } from "fs";
 import { extname, resolve } from "path";
 import { z } from "zod";
+import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 import { logger } from "../utils/logger.js";
 import { createChunker } from "./ChunkerFactory.js";
 import { createVectorQueryTool, InMemoryVectorStore, } from "./retrieval/vectorQueryTool.js";
@@ -149,6 +150,35 @@ function diversifyResults(results, topK) {
  * @returns Prepared RAG tool to inject into the tools record
  */
 export async function prepareRAGTool(ragConfig, fallbackProvider) {
+    const span = SpanSerializer.createSpan(SpanType.RAG, "rag.prepare", {
+        "rag.operation": "prepare",
+        "rag.files_count": ragConfig.files?.length ?? 0,
+        "rag.strategy": ragConfig.strategy ?? "auto",
+        "rag.chunk_size": ragConfig.chunkSize ?? 1000,
+    });
+    const startTime = Date.now();
+    try {
+        const result = await _prepareRAGToolInner(ragConfig, fallbackProvider);
+        span.durationMs = Date.now() - startTime;
+        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+        endedSpan.attributes = {
+            ...endedSpan.attributes,
+            "rag.chunks_indexed": result.chunksIndexed,
+            "rag.files_loaded": result.filesLoaded,
+        };
+        getMetricsAggregator().recordSpan(endedSpan);
+        return result;
+    }
+    catch (error) {
+        span.durationMs = Date.now() - startTime;
+        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+        endedSpan.statusMessage =
+            error instanceof Error ? error.message : String(error);
+        getMetricsAggregator().recordSpan(endedSpan);
+        throw error;
+    }
+}
+async function _prepareRAGToolInner(ragConfig, fallbackProvider) {
     const { files, strategy: userStrategy, chunkSize = 1000, chunkOverlap = 200, topK: userTopK = 5, toolName = "search_knowledge_base", toolDescription = "REQUIRED: Search through pre-loaded local documents to find relevant information. Use this tool FIRST before any web search or other tools. This searches an indexed knowledge base of documents the user has provided.", embeddingProvider, embeddingModel, } = ragConfig;
     if (!files || files.length === 0) {
         throw new Error("RAG config requires at least one file path in 'files'");

package/dist/lib/rag/retrieval/hybridSearch.js

@@ -5,6 +5,7 @@
  * Supports multiple fusion methods: Reciprocal Rank Fusion (RRF) and Linear Combination.
  */
 import { ProviderFactory } from "../../factories/providerFactory.js";
+import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../../observability/index.js";
 import { logger } from "../../utils/logger.js";
 import { rerank } from "../reranker/reranker.js";
 /**
@@ -166,6 +167,13 @@ export function createHybridSearch(options) {
     return async function hybridSearch(query, config) {
         const startTime = Date.now();
         const { vectorWeight = defaultConfig.vectorWeight ?? 0.5, bm25Weight = defaultConfig.bm25Weight ?? 0.5, fusionMethod = defaultConfig.fusionMethod ?? "rrf", rrfK = defaultConfig.rrfK ?? 60, topK = defaultConfig.topK ?? 10, enableReranking = defaultConfig.enableReranking ?? false, reranker: rerankerConfig = defaultConfig.reranker, } = config || {};
+        const span = SpanSerializer.createSpan(SpanType.RAG, "rag.search", {
+            "rag.operation": "search",
+            "rag.topK": topK,
+            "rag.fusionMethod": fusionMethod,
+            "rag.query": query.slice(0, 200),
+        });
+        const spanStartTime = Date.now();
         try {
             // Generate query embedding
             const embeddingProvider = await ProviderFactory.createProvider(embeddingModel?.provider, embeddingModel?.modelName);
@@ -300,9 +308,23 @@ export function createHybridSearch(options) {
                 fusionMethod,
                 queryTime,
             });
+            span.durationMs = Date.now() - spanStartTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            endedSpan.attributes = {
+                ...endedSpan.attributes,
+                "rag.results_count": fusedResults.length,
+                "rag.vector_results": vectorResults.length,
+                "rag.bm25_results": bm25Results.length,
+            };
+            getMetricsAggregator().recordSpan(endedSpan);
             return fusedResults;
         }
         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);
             logger.error("[HybridSearch] Search failed", {
                 query: query.slice(0, 50),
                 error: error instanceof Error ? error.message : String(error),

package/dist/lib/server/abstract/baseServerAdapter.js

@@ -4,6 +4,8 @@
  * Follows NeuroLink's composition and factory patterns
  */
 import { EventEmitter } from "events";
+import { getMetricsAggregator } from "../../observability/index.js";
+import { SpanSerializer, SpanStatus, SpanType, } from "../../observability/index.js";
 import { withTimeout } from "../../utils/errorHandling.js";
 import { logger } from "../../utils/logger.js";
 import { DrainTimeoutError, InvalidLifecycleStateError, ShutdownTimeoutError, } from "../errors.js";
@@ -112,6 +114,12 @@ export class BaseServerAdapter extends EventEmitter {
             host: this.config.host,
             basePath: this.config.basePath,
         });
+        const span = SpanSerializer.createSpan(SpanType.SERVER_REQUEST, "server.initialize", {
+            "server.operation": "initialize",
+            "server.port": this.config.port,
+            "server.host": this.config.host,
+        });
+        const startTime = Date.now();
         try {
             // Initialize framework-specific setup
             this.initializeFramework();
@@ -129,9 +137,17 @@ export class BaseServerAdapter extends EventEmitter {
                 routes: this.routes.size,
                 middlewares: this.middlewares.length,
             });
+            span.durationMs = Date.now() - startTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedSpan);
         }
         catch (error) {
             this.lifecycleState = "error";
+            span.durationMs = Date.now() - startTime;
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+            endedSpan.statusMessage =
+                error instanceof Error ? error.message : String(error);
+            getMetricsAggregator().recordSpan(endedSpan);
             throw error;
         }
     }
@@ -397,29 +413,34 @@ export class BaseServerAdapter extends EventEmitter {
             gracefulShutdownTimeoutMs,
             drainTimeoutMs,
         });
-        // Set draining state
-        this.lifecycleState = "draining";
-        // Stop accepting new connections
-        await this.stopAcceptingConnections();
-        logger.info("[ServerAdapter] Stopped accepting new connections");
-        // Create drain promise that resolves when all connections are closed
-        const drainPromise = this.drainConnections();
+        const shutdownSpan = SpanSerializer.createSpan(SpanType.SERVER_REQUEST, "server.shutdown", {
+            "server.operation": "gracefulShutdown",
+            "server.activeConnections": this.activeConnections.size,
+        });
+        const shutdownStartTime = Date.now();
         // Timer references for cleanup
         let shutdownTimer;
         let drainTimer;
-        // Create timeout promise for overall shutdown
-        const shutdownTimeoutPromise = new Promise((_, reject) => {
-            shutdownTimer = setTimeout(() => {
-                reject(new ShutdownTimeoutError(gracefulShutdownTimeoutMs, this.activeConnections.size));
-            }, gracefulShutdownTimeoutMs);
-        });
-        // Create timeout promise for drain phase
-        const drainTimeoutPromise = new Promise((resolve) => {
-            drainTimer = setTimeout(() => {
-                resolve("drain_timeout");
-            }, drainTimeoutMs);
-        });
         try {
+            // Set draining state
+            this.lifecycleState = "draining";
+            // Stop accepting new connections (covered by shutdown span)
+            await this.stopAcceptingConnections();
+            logger.info("[ServerAdapter] Stopped accepting new connections");
+            // Create drain promise that resolves when all connections are closed
+            const drainPromise = this.drainConnections();
+            // Create timeout promise for overall shutdown
+            const shutdownTimeoutPromise = new Promise((_, reject) => {
+                shutdownTimer = setTimeout(() => {
+                    reject(new ShutdownTimeoutError(gracefulShutdownTimeoutMs, this.activeConnections.size));
+                }, gracefulShutdownTimeoutMs);
+            });
+            // Create timeout promise for drain phase
+            const drainTimeoutPromise = new Promise((resolve) => {
+                drainTimer = setTimeout(() => {
+                    resolve("drain_timeout");
+                }, drainTimeoutMs);
+            });
             // Race drain against drain timeout
             const drainResult = await Promise.race([
                 drainPromise,
@@ -442,6 +463,9 @@ export class BaseServerAdapter extends EventEmitter {
             // Close the server with shutdown timeout
             await Promise.race([this.closeServer(), shutdownTimeoutPromise]);
             logger.info("[ServerAdapter] Server closed successfully");
+            shutdownSpan.durationMs = Date.now() - shutdownStartTime;
+            const endedShutdownSpan = SpanSerializer.endSpan(shutdownSpan, SpanStatus.OK);
+            getMetricsAggregator().recordSpan(endedShutdownSpan);
         }
         catch (error) {
             // If force close is enabled and we hit a timeout, try to force close
@@ -453,9 +477,17 @@ export class BaseServerAdapter extends EventEmitter {
                 });
                 await this.forceCloseConnections();
                 await this.closeServer();
+                shutdownSpan.durationMs = Date.now() - shutdownStartTime;
+                const endedShutdownSpan = SpanSerializer.endSpan(shutdownSpan, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedShutdownSpan);
             }
             else {
                 this.lifecycleState = "error";
+                shutdownSpan.durationMs = Date.now() - shutdownStartTime;
+                const endedShutdownSpan = SpanSerializer.endSpan(shutdownSpan, SpanStatus.ERROR);
+                endedShutdownSpan.statusMessage =
+                    error instanceof Error ? error.message : String(error);
+                getMetricsAggregator().recordSpan(endedShutdownSpan);
                 throw error;
             }
         }

package/dist/lib/server/middleware/common.js

@@ -2,6 +2,8 @@
  * Common Middleware Components
  * Utility middleware for common server operations
  */
+import { getMetricsAggregator } from "../../observability/index.js";
+import { SpanSerializer, SpanStatus, SpanType, } from "../../observability/index.js";
 import { logger } from "../../utils/logger.js";
 /**
  * Create request timing middleware
@@ -21,17 +23,34 @@ export function createTimingMiddleware() {
             const startHrTime = process.hrtime.bigint();
             // Store start time in metadata
             ctx.metadata.requestStartTime = startTime;
-            const result = await next();
-            // Calculate duration
-            const endHrTime = process.hrtime.bigint();
-            const durationNs = Number(endHrTime - startHrTime);
-            const durationMs = durationNs / 1_000_000;
-            // Add timing headers to responseHeaders (adapters read from here)
-            ctx.responseHeaders = ctx.responseHeaders || {};
-            ctx.responseHeaders["X-Response-Time"] = `${durationMs.toFixed(2)}ms`;
-            ctx.responseHeaders["Server-Timing"] =
-                `total;dur=${durationMs.toFixed(2)}`;
-            return result;
+            const span = SpanSerializer.createSpan(SpanType.SERVER_REQUEST, "server.middleware.timing", {
+                "server.operation": "middleware",
+                "server.middleware": "timing",
+            });
+            try {
+                const result = await next();
+                // Calculate duration
+                const endHrTime = process.hrtime.bigint();
+                const durationNs = Number(endHrTime - startHrTime);
+                const durationMs = durationNs / 1_000_000;
+                // Add timing headers to responseHeaders (adapters read from here)
+                ctx.responseHeaders = ctx.responseHeaders || {};
+                ctx.responseHeaders["X-Response-Time"] = `${durationMs.toFixed(2)}ms`;
+                ctx.responseHeaders["Server-Timing"] =
+                    `total;dur=${durationMs.toFixed(2)}`;
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return result;
+            }
+            catch (error) {
+                span.durationMs = Date.now() - startTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+                endedSpan.statusMessage =
+                    error instanceof Error ? error.message : String(error);
+                getMetricsAggregator().recordSpan(endedSpan);
+                throw error;
+            }
         },
     };
 }
@@ -77,8 +96,17 @@ export function createErrorHandlingMiddleware(options) {
         name: "error-handling",
         order: 1, // Run very early to catch all errors
         handler: async (ctx, next) => {
+            const span = SpanSerializer.createSpan(SpanType.SERVER_REQUEST, "server.middleware.errorHandling", {
+                "server.operation": "middleware",
+                "server.middleware": "error-handling",
+            });
+            const middlewareStartTime = Date.now();
             try {
-                return await next();
+                const result = await next();
+                span.durationMs = Date.now() - middlewareStartTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return result;
             }
             catch (error) {
                 const err = error;
@@ -89,6 +117,10 @@ export function createErrorHandlingMiddleware(options) {
                         stack: err.stack,
                     });
                 }
+                span.durationMs = Date.now() - middlewareStartTime;
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR);
+                endedSpan.statusMessage = err.message;
+                getMetricsAggregator().recordSpan(endedSpan);
                 // Use custom handler if provided
                 if (onError) {
                     return onError(err, ctx);

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

@@ -6,10 +6,10 @@
  *
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { trace } from "@opentelemetry/api";
+import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import type { LangfuseConfig } from "../../../../types/observability.js";
 /**
  * Extended context for Langfuse spans

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

@@ -6,12 +6,12 @@
  *
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { trace } from "@opentelemetry/api";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "async_hooks";
-import { trace } from "@opentelemetry/api";
 import { logger } from "../../../../utils/logger.js";
 const LOG_PREFIX = "[OpenTelemetry]";
 const contextStorage = new AsyncLocalStorage();
@@ -343,11 +343,16 @@ class ContextEnricher {
  * @param config - Langfuse configuration passed from parent application
  */
 export function initializeOpenTelemetry(config) {
-    // Guard against multiple initializations
+    // Guard against multiple initializations — but always update config
+    // so that later NeuroLink instances can change traceNameFormat,
+    // autoDetectOperationName, and other configuration preferences
+    // without re-initializing the OTEL infrastructure.
     if (isInitialized) {
-        logger.debug(`${LOG_PREFIX} Already initialized`, {
+        currentConfig = config;
+        logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
             usingExternalProvider,
             hasLangfuseProcessor: !!langfuseProcessor,
+            hasTraceNameFormat: typeof config.traceNameFormat === "function",
         });
         return;
     }

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

@@ -68,8 +68,8 @@ export type GenerateCommandArgs = BaseCommandArgs & {
     thinkingLevel?: "minimal" | "low" | "medium" | "high";
     /** Vertex AI region */
     region?: string;
-    /** Output mode - 'text' for standard generation, 'video' for video generation */
-    outputMode?: "text" | "video";
+    /** Output mode - 'text' for standard generation, 'video' for video generation, 'ppt' for presentation */
+    outputMode?: "text" | "video" | "ppt";
     /** Path to save generated video file */
     videoOutput?: string;
     /** Video output resolution (720p or 1080p) */
@@ -80,6 +80,20 @@ export type GenerateCommandArgs = BaseCommandArgs & {
     videoAspectRatio?: "9:16" | "16:9";
     /** Enable/disable audio generation in video */
     videoAudio?: boolean;
+    /** Number of slides to generate (5-50) */
+    pptPages?: number;
+    /** Presentation theme/style */
+    pptTheme?: "modern" | "corporate" | "creative" | "minimal" | "dark";
+    /** Target audience */
+    pptAudience?: "business" | "students" | "technical" | "general";
+    /** Presentation tone/style */
+    pptTone?: "professional" | "casual" | "educational" | "persuasive";
+    /** Path to save generated PPTX file */
+    pptOutput?: string;
+    /** PPT aspect ratio */
+    pptAspectRatio?: "16:9" | "4:3";
+    /** Disable AI image generation for PPT slides */
+    pptNoImages?: boolean;
     /** Custom path for generated image output */
     imageOutput?: string;
 };
@@ -371,6 +385,8 @@ export type GenerateResult = CommandResult & {
     audio?: import("./index.js").TTSResult;
     /** Video generation result when video mode is enabled */
     video?: import("./multimodal.js").VideoGenerationResult;
+    /** PPT generation result when ppt mode is enabled */
+    ppt?: import("./pptTypes.js").PPTGenerationResult;
     imageOutput?: {
         base64: string;
         savedPath?: string;

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

@@ -28,4 +28,6 @@ export type IConversationMemoryManager = {
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /** Close/shutdown the memory manager and release resources (e.g., Redis connections) */
+    close?(): Promise<void>;
 };