@juspay/neurolink 9.15.0 → 9.16.0

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

@@ -700,6 +700,45 @@ export async function setLangfuseContext(context, callback) {
 export function getLangfuseContext() {
     return contextStorage.getStore();
 }
+/**
+ * Capture the current Langfuse AsyncLocalStorage context and return a wrapper
+ * that re-enters that context when executing the provided callback.
+ *
+ * This is essential for preserving trace context across async boundaries that
+ * break the automatic ALS propagation chain, such as `setImmediate()`,
+ * `setTimeout()`, or event-emitter callbacks. Without this, spans created
+ * inside those callbacks become orphaned traces in Langfuse.
+ *
+ * **How it works:**
+ * 1. Captures the current ALS store at call time (synchronously).
+ * 2. Returns an async function that, when invoked, re-enters the captured
+ *    context via `contextStorage.run()` before executing the callback.
+ * 3. If no context exists at capture time, the callback runs without
+ *    ALS wrapping (no-op passthrough).
+ *
+ * @param fn - The async function to execute within the captured context
+ * @returns A new async function that preserves the Langfuse ALS context
+ *
+ * @example
+ * // Before (broken — setImmediate loses ALS context):
+ * setImmediate(async () => {
+ *   await this.checkAndSummarize(session, threshold);
+ * });
+ *
+ * // After (fixed — context is captured and re-entered):
+ * const wrappedFn = runWithCurrentLangfuseContext(async () => {
+ *   await this.checkAndSummarize(session, threshold);
+ * });
+ * setImmediate(wrappedFn);
+ */
+export function runWithCurrentLangfuseContext(fn) {
+    const capturedContext = contextStorage.getStore();
+    if (capturedContext) {
+        return () => contextStorage.run(capturedContext, fn);
+    }
+    // No context to preserve — return the function as-is
+    return fn;
+}
 /**
  * Get an OpenTelemetry Tracer for creating custom spans
  *

package/dist/lib/telemetry/attributes.d.ts

@@ -0,0 +1,52 @@
+export declare const ATTR: {
+    readonly GEN_AI_SYSTEM: "gen_ai.system";
+    readonly GEN_AI_MODEL: "gen_ai.request.model";
+    readonly GEN_AI_OPERATION: "gen_ai.operation.name";
+    readonly GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens";
+    readonly GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
+    readonly GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason";
+    readonly GEN_AI_COST_USD: "gen_ai.cost_usd";
+    readonly GEN_AI_TOOL_NAME: "gen_ai.tool.name";
+    readonly GEN_AI_TEMPERATURE: "gen_ai.request.temperature";
+    readonly GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens";
+    readonly NL_PROVIDER: "neurolink.provider";
+    readonly NL_MODEL: "neurolink.model";
+    readonly NL_STREAM_MODE: "neurolink.stream_mode";
+    readonly NL_TOOL_COUNT: "neurolink.tool_count";
+    readonly NL_MESSAGE_COUNT: "neurolink.message_count";
+    readonly NL_HAS_TOOLS: "neurolink.has_tools";
+    readonly NL_INPUT_LENGTH: "neurolink.input_length";
+    readonly NL_OUTPUT_LENGTH: "neurolink.output_length";
+    readonly NL_REQUEST_ID: "neurolink.request_id";
+    readonly NL_PATH: "neurolink.path";
+    readonly NL_HAS_MEMORY: "neurolink.has_conversation_memory";
+    readonly NL_COST: "neurolink.cost";
+    readonly NL_STRUCTURED_OUTPUT: "neurolink.structured_output";
+    readonly NL_HAS_FALLBACK: "neurolink.has_fallback";
+    readonly MCP_SERVER_ID: "mcp.server_id";
+    readonly MCP_TOOL_NAME: "mcp.tool_name";
+    readonly MCP_TIMEOUT_MS: "mcp.timeout_ms";
+    readonly MCP_TRANSPORT: "mcp.transport";
+    readonly MCP_CIRCUIT_STATE: "mcp.circuit_state";
+    readonly SESSION_ID: "session.id";
+    readonly USER_ID: "user.id";
+    readonly MEMORY_TYPE: "memory.type";
+    readonly MESSAGE_COUNT: "message.count";
+    readonly CONTENT_LENGTH: "content.length";
+    readonly RAG_FILE_COUNT: "rag.file_count";
+    readonly RAG_STRATEGY: "rag.strategy";
+    readonly RAG_CHUNK_SIZE: "rag.chunk_size";
+    readonly RAG_TOP_K: "rag.top_k";
+    readonly RAG_RESULT_COUNT: "rag.result_count";
+    readonly MSG_COUNT: "message.build.count";
+    readonly MSG_HAS_IMAGES: "message.has_images";
+    readonly MSG_HAS_FILES: "message.has_files";
+    readonly MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt";
+    readonly MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length";
+    readonly MSG_IS_MULTIMODAL: "message.is_multimodal";
+    readonly CONTEXT_STAGE: "context.compaction_stage";
+    readonly CONTEXT_TOKENS_BEFORE: "context.tokens_before";
+    readonly CONTEXT_TOKENS_AFTER: "context.tokens_after";
+    readonly MW_COUNT: "middleware.count";
+    readonly MW_NAMES: "middleware.names";
+};

package/dist/lib/telemetry/attributes.js

@@ -0,0 +1,61 @@
+export const ATTR = {
+    // GenAI standard (OpenTelemetry semantic conventions)
+    GEN_AI_SYSTEM: "gen_ai.system",
+    GEN_AI_MODEL: "gen_ai.request.model",
+    GEN_AI_OPERATION: "gen_ai.operation.name",
+    GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+    GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+    GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason",
+    GEN_AI_COST_USD: "gen_ai.cost_usd",
+    GEN_AI_TOOL_NAME: "gen_ai.tool.name",
+    GEN_AI_TEMPERATURE: "gen_ai.request.temperature",
+    GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens",
+    // NeuroLink custom
+    NL_PROVIDER: "neurolink.provider",
+    NL_MODEL: "neurolink.model",
+    NL_STREAM_MODE: "neurolink.stream_mode",
+    NL_TOOL_COUNT: "neurolink.tool_count",
+    NL_MESSAGE_COUNT: "neurolink.message_count",
+    NL_HAS_TOOLS: "neurolink.has_tools",
+    NL_INPUT_LENGTH: "neurolink.input_length",
+    NL_OUTPUT_LENGTH: "neurolink.output_length",
+    NL_REQUEST_ID: "neurolink.request_id",
+    NL_PATH: "neurolink.path",
+    NL_HAS_MEMORY: "neurolink.has_conversation_memory",
+    NL_COST: "neurolink.cost",
+    NL_STRUCTURED_OUTPUT: "neurolink.structured_output",
+    NL_HAS_FALLBACK: "neurolink.has_fallback",
+    // MCP
+    MCP_SERVER_ID: "mcp.server_id",
+    MCP_TOOL_NAME: "mcp.tool_name",
+    MCP_TIMEOUT_MS: "mcp.timeout_ms",
+    MCP_TRANSPORT: "mcp.transport",
+    MCP_CIRCUIT_STATE: "mcp.circuit_state",
+    // Session/Memory
+    SESSION_ID: "session.id",
+    USER_ID: "user.id",
+    MEMORY_TYPE: "memory.type",
+    MESSAGE_COUNT: "message.count",
+    CONTENT_LENGTH: "content.length",
+    // RAG
+    RAG_FILE_COUNT: "rag.file_count",
+    RAG_STRATEGY: "rag.strategy",
+    RAG_CHUNK_SIZE: "rag.chunk_size",
+    RAG_TOP_K: "rag.top_k",
+    RAG_RESULT_COUNT: "rag.result_count",
+    // Message building
+    MSG_COUNT: "message.build.count",
+    MSG_HAS_IMAGES: "message.has_images",
+    MSG_HAS_FILES: "message.has_files",
+    MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt",
+    MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length",
+    MSG_IS_MULTIMODAL: "message.is_multimodal",
+    // Context
+    CONTEXT_STAGE: "context.compaction_stage",
+    CONTEXT_TOKENS_BEFORE: "context.tokens_before",
+    CONTEXT_TOKENS_AFTER: "context.tokens_after",
+    // Middleware
+    MW_COUNT: "middleware.count",
+    MW_NAMES: "middleware.names",
+};
+//# sourceMappingURL=attributes.js.map

package/dist/lib/telemetry/index.d.ts

@@ -1,4 +1,7 @@
 export { TelemetryService, type HealthMetrics } from "./telemetryService.js";
+export { tracers } from "./tracers.js";
+export { withSpan, withClientSpan, type SpanOptions } from "./withSpan.js";
+export { ATTR } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
  * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true

package/dist/lib/telemetry/index.js

@@ -1,5 +1,8 @@
 // Optional Telemetry Infrastructure (Phase 2)
 export { TelemetryService } from "./telemetryService.js";
+export { tracers } from "./tracers.js";
+export { withSpan, withClientSpan } from "./withSpan.js";
+export { ATTR } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink

package/dist/lib/telemetry/telemetryService.d.ts

@@ -32,6 +32,12 @@ export declare class TelemetryService {
     private initializeTelemetry;
     private initializeMetrics;
     initialize(): Promise<void>;
+    /**
+     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
+     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
+     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
+     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
+     */
     traceAIRequest<T>(provider: string, operation: () => Promise<T>, operationType?: string): Promise<T>;
     recordAIRequest(provider: string, model: string, tokens: number, duration: number, cost?: number): void;
     recordAIError(provider: string, error: Error): void;

package/dist/lib/telemetry/telemetryService.js

@@ -112,6 +112,12 @@ export class TelemetryService {
         }
     }
     // AI Operation Tracing (NO-OP when disabled)
+    /**
+     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
+     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
+     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
+     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
+     */
     async traceAIRequest(provider, operation, operationType = "generate_text") {
         if (!this.enabled || !this.tracer) {
             return await operation();

package/dist/lib/telemetry/tracers.d.ts

@@ -0,0 +1,15 @@
+export declare const tracers: {
+    readonly sdk: import("@opentelemetry/api").Tracer;
+    readonly provider: import("@opentelemetry/api").Tracer;
+    readonly generation: import("@opentelemetry/api").Tracer;
+    readonly stream: import("@opentelemetry/api").Tracer;
+    readonly http: import("@opentelemetry/api").Tracer;
+    readonly mcp: import("@opentelemetry/api").Tracer;
+    readonly memory: import("@opentelemetry/api").Tracer;
+    readonly redis: import("@opentelemetry/api").Tracer;
+    readonly factory: import("@opentelemetry/api").Tracer;
+    readonly rag: import("@opentelemetry/api").Tracer;
+    readonly context: import("@opentelemetry/api").Tracer;
+    readonly middleware: import("@opentelemetry/api").Tracer;
+    readonly processor: import("@opentelemetry/api").Tracer;
+};

package/dist/lib/telemetry/tracers.js

@@ -0,0 +1,17 @@
+import { trace } from "@opentelemetry/api";
+export const tracers = {
+    sdk: trace.getTracer("neurolink"),
+    provider: trace.getTracer("neurolink.provider"),
+    generation: trace.getTracer("neurolink.generation"),
+    stream: trace.getTracer("neurolink.stream"),
+    http: trace.getTracer("neurolink.http"),
+    mcp: trace.getTracer("neurolink.mcp"),
+    memory: trace.getTracer("neurolink.memory"),
+    redis: trace.getTracer("neurolink.redis"),
+    factory: trace.getTracer("neurolink.factory"),
+    rag: trace.getTracer("neurolink.rag"),
+    context: trace.getTracer("neurolink.context"),
+    middleware: trace.getTracer("neurolink.middleware"),
+    processor: trace.getTracer("neurolink.processor"),
+};
+//# sourceMappingURL=tracers.js.map

package/dist/lib/telemetry/withSpan.d.ts

@@ -0,0 +1,9 @@
+import { type Span, type Tracer, SpanKind } from "@opentelemetry/api";
+export type SpanOptions = {
+    name: string;
+    tracer: Tracer;
+    kind?: SpanKind;
+    attributes?: Record<string, string | number | boolean | undefined>;
+};
+export declare function withSpan<T>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
+export declare function withClientSpan<T>(options: Omit<SpanOptions, "kind">, fn: (span: Span) => Promise<T>): Promise<T>;

package/dist/lib/telemetry/withSpan.js

@@ -0,0 +1,35 @@
+import { SpanKind, SpanStatusCode, } from "@opentelemetry/api";
+export async function withSpan(options, fn) {
+    const { name, tracer, kind = SpanKind.INTERNAL, attributes } = options;
+    return tracer.startActiveSpan(name, { kind }, async (span) => {
+        if (attributes) {
+            for (const [key, value] of Object.entries(attributes)) {
+                if (value !== undefined) {
+                    span.setAttribute(key, value);
+                }
+            }
+        }
+        try {
+            const result = await fn(span);
+            span.setStatus({ code: SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            if (error instanceof Error) {
+                span.recordException(error);
+            }
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+export async function withClientSpan(options, fn) {
+    return withSpan({ ...options, kind: SpanKind.CLIENT }, fn);
+}
+//# sourceMappingURL=withSpan.js.map

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

@@ -424,6 +424,16 @@ export type PruneResult = {
 /** Configuration for sliding window truncation (Stage 4). */
 export type TruncationConfig = {
     fraction?: number;
+    /** Current estimated tokens (enables adaptive mode) */
+    currentTokens?: number;
+    /** Target token budget (enables adaptive mode) */
+    targetTokens?: number;
+    /** Provider for token estimation (enables adaptive mode) */
+    provider?: string;
+    /** Buffer above required reduction (default: 0.15 = 15%) */
+    adaptiveBuffer?: number;
+    /** Maximum iterations for adaptive truncation (default: 3) */
+    maxIterations?: number;
 };
 /** Result of sliding window truncation (Stage 4). */
 export type TruncationResult = {

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

@@ -364,6 +364,20 @@ export type StreamOptions = {
     workflow?: string;
     workflowConfig?: import("../workflow/types.js").WorkflowConfig;
     enableSummarization?: boolean;
+    /**
+     * Maximum cumulative cost (USD) for this session.
+     * Once the session spend reaches this limit, subsequent stream() calls
+     * will throw a SESSION_BUDGET_EXCEEDED error instead of making API calls.
+     *
+     * @example
+     * ```typescript
+     * const result = await neurolink.stream({
+     *   input: { text: "Summarize this" },
+     *   maxBudgetUsd: 1.00
+     * });
+     * ```
+     */
+    maxBudgetUsd?: number;
     /**
      * RAG (Retrieval-Augmented Generation) configuration.
      *

package/dist/lib/utils/conversationMemory.js

@@ -2,11 +2,16 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
+import { withTimeout } from "./errorHandling.js";
 import { DEFAULT_FALLBACK_THRESHOLD, getConversationMemoryDefaults, MEMORY_THRESHOLD_PERCENTAGE, } from "../config/conversationMemory.js";
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { buildSummarizationPrompt } from "../context/prompts/summarizationPrompt.js";
-import { NeuroLink } from "../neurolink.js";
 import { logger } from "./logger.js";
+const memoryTracer = tracers.memory;
+// Cached NeuroLink instance for summarization to avoid creating a new instance per call
+let cachedSummarizer = null;
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values
@@ -34,41 +39,49 @@ export async function getConversationMessages(conversationMemory, options) {
         });
         return [];
     }
-    try {
-        // Extract userId from context
-        const userId = options.context?.userId;
-        const enableSummarization = options.enableSummarization ?? undefined;
-        const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
-        logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
-            sessionId,
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
-        });
-        return messages;
-    }
-    catch (error) {
-        logger.warn("[conversationMemoryUtils] Failed to get conversation messages", {
-            sessionId,
-            memoryType: conversationMemory.constructor.name,
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        return [];
-    }
+    return memoryTracer.startActiveSpan("neurolink.conversation.getMessages", {
+        kind: SpanKind.INTERNAL,
+        attributes: {
+            "session.id": sessionId,
+            "memory.type": conversationMemory.constructor.name,
+        },
+    }, async (span) => {
+        try {
+            // Extract userId from context
+            const userId = options.context?.userId;
+            if (userId) {
+                span.setAttribute("user.id", userId);
+            }
+            const enableSummarization = options.enableSummarization ?? undefined;
+            const messages = await conversationMemory.buildContextMessages(sessionId, userId, enableSummarization);
+            span.setAttribute("message.count", messages.length);
+            if (logger.shouldLog("debug")) {
+                logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
+                    sessionId,
+                    messageCount: messages.length,
+                    messageTypes: messages.map((m) => m.role),
+                });
+            }
+            return messages;
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            logger.warn("[conversationMemoryUtils] Failed to get conversation messages", {
+                sessionId,
+                memoryType: conversationMemory.constructor.name,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return [];
+        }
+        finally {
+            span.end();
+        }
+    });
 }
 /**
  * Store conversation turn for future context
@@ -128,47 +141,66 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
             model: result.model,
         };
     }
-    try {
-        await conversationMemory.storeConversationTurn({
-            sessionId,
-            userId,
-            userMessage,
-            aiResponse,
-            startTimeStamp,
-            providerDetails,
-            enableSummarization: originalOptions.enableSummarization,
-            requestId,
-            tokenUsage: result.usage
-                ? {
-                    inputTokens: result.usage.input,
-                    outputTokens: result.usage.output,
-                    totalTokens: result.usage.total,
-                    cacheReadTokens: result.usage.cacheReadTokens,
-                    cacheWriteTokens: result.usage.cacheCreationTokens,
-                }
-                : undefined,
-        });
-        logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
-            requestId,
-            sessionId,
-            userId,
-            memoryType: conversationMemory.constructor.name,
-            userMessageLength: userMessage.length,
-            aiResponseLength: aiResponse.length,
-        });
-    }
-    catch (error) {
-        const details = error?.details;
-        logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
-            sessionId,
-            userId,
-            memoryType: conversationMemory.constructor.name,
-            error: error instanceof Error ? error.message : String(error),
-            innerError: details?.error || "none",
-            errorCode: error?.code || "unknown",
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-    }
+    await memoryTracer.startActiveSpan("neurolink.conversation.storeTurn", {
+        kind: SpanKind.INTERNAL,
+        attributes: {
+            "session.id": sessionId,
+            "content.length": userMessage.length + aiResponse.length,
+        },
+    }, async (span) => {
+        if (userId) {
+            span.setAttribute("user.id", userId);
+        }
+        try {
+            await conversationMemory.storeConversationTurn({
+                sessionId,
+                userId,
+                userMessage,
+                aiResponse,
+                startTimeStamp,
+                providerDetails,
+                enableSummarization: originalOptions.enableSummarization,
+                requestId,
+                tokenUsage: result.usage
+                    ? {
+                        inputTokens: result.usage.input,
+                        outputTokens: result.usage.output,
+                        totalTokens: result.usage.total,
+                        cacheReadTokens: result.usage.cacheReadTokens,
+                        cacheWriteTokens: result.usage.cacheCreationTokens,
+                    }
+                    : undefined,
+            });
+            logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
+                requestId,
+                sessionId,
+                userId,
+                memoryType: conversationMemory.constructor.name,
+                userMessageLength: userMessage.length,
+                aiResponseLength: aiResponse.length,
+            });
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            const details = error?.details;
+            logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
+                sessionId,
+                userId,
+                memoryType: conversationMemory.constructor.name,
+                error: error instanceof Error ? error.message : String(error),
+                innerError: details?.error || "none",
+                errorCode: error?.code || "unknown",
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        finally {
+            span.end();
+        }
+    });
 }
 /**
  * Build context messages from pointer onwards (token-based memory)
@@ -322,22 +354,29 @@ export function getEffectiveTokenThreshold(provider, model, envOverride, session
  */
 export async function generateSummary(messages, config, logPrefix = "[ConversationMemory]", previousSummary, requestId) {
     const summarizationPrompt = createSummarizationPrompt(messages, previousSummary);
-    const summarizer = new NeuroLink({
-        conversationMemory: { enabled: false },
-    });
+    const SUMMARIZER_INIT_TIMEOUT = 15_000;
+    const SUMMARIZER_GENERATE_TIMEOUT = 60_000;
     try {
+        if (!cachedSummarizer) {
+            cachedSummarizer = await withTimeout((async () => {
+                const { NeuroLink: NeuroLinkClass } = await import("../neurolink.js");
+                return new NeuroLinkClass({
+                    conversationMemory: { enabled: false },
+                });
+            })(), SUMMARIZER_INIT_TIMEOUT, new Error("Summarizer initialization timed out"));
+        }
         if (!config.summarizationProvider || !config.summarizationModel) {
             logger.error(`${logPrefix} Missing summarization provider`, {
                 requestId,
             });
             return null;
         }
-        const summaryResult = await summarizer.generate({
+        const summaryResult = await withTimeout(cachedSummarizer.generate({
             input: { text: summarizationPrompt },
             provider: config.summarizationProvider,
             model: config.summarizationModel,
             disableTools: true,
-        });
+        }), SUMMARIZER_GENERATE_TIMEOUT, new Error("Summary generation timed out"));
         return summaryResult.content || null;
     }
     catch (error) {

package/dist/lib/utils/logger.d.ts

@@ -63,6 +63,11 @@ declare class NeuroLinkLogger {
      * @returns Formatted prefix string like "[2025-08-18T13:45:30.123Z] [NEUROLINK:ERROR]"
      */
     private getLogPrefix;
+    /**
+     * Extracts current OTel trace context (trace_id, span_id) if available.
+     * Returns empty object if OTel is not initialized or no active span exists.
+     */
+    private getTraceContext;
     /**
      * Safely serialize data to fully expanded JSON string.
      * Handles circular references and non-serializable values.