@juspay/neurolink 9.54.5 → 9.54.7

package/dist/lib/mcp/toolDiscoveryService.js

@@ -11,6 +11,7 @@ import { validateToolName, validateToolDescription, } from "../utils/parameterVa
 import { withTimeout } from "../utils/errorHandling.js";
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { tracers } from "../telemetry/tracers.js";
+import { withSpan } from "../telemetry/withSpan.js";
 const mcpTracer = tracers.mcp;
 /**
  * Default timeout for MCP tool execution operations in milliseconds.
@@ -44,71 +45,83 @@ export class ToolDiscoveryService extends EventEmitter {
      * Discover tools from an external MCP server
      */
     async discoverTools(serverId, client, timeout = DEFAULT_TOOL_TIMEOUT) {
-        const startTime = Date.now();
-        try {
-            // Prevent concurrent discovery for same server
-            if (this.discoveryInProgress.has(serverId)) {
+        return withSpan({
+            name: "neurolink.mcp.discoverTools",
+            tracer: tracers.mcp,
+            attributes: { "mcp.server_id": serverId },
+        }, async (span) => {
+            const startTime = Date.now();
+            try {
+                // Prevent concurrent discovery for same server
+                if (this.discoveryInProgress.has(serverId)) {
+                    return {
+                        success: false,
+                        error: `Discovery already in progress for server: ${serverId}`,
+                        toolCount: 0,
+                        tools: [],
+                        duration: Date.now() - startTime,
+                        serverId,
+                    };
+                }
+                this.discoveryInProgress.add(serverId);
+                mcpLogger.info(`[ToolDiscoveryService] Starting tool discovery for server: ${serverId}`);
+                // Create circuit breaker for tool discovery
+                const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-discovery-${serverId}`, {
+                    failureThreshold: 2,
+                    resetTimeout: 60000,
+                    operationTimeout: timeout,
+                });
+                // Discover tools with circuit breaker protection
+                const tools = await circuitBreaker.execute(async () => {
+                    return await this.performToolDiscovery(serverId, client, timeout);
+                });
+                // Register discovered tools
+                const registeredTools = await this.registerDiscoveredTools(serverId, tools);
+                span.setAttribute("mcp.tools_discovered", registeredTools.length);
+                const result = {
+                    success: true,
+                    toolCount: registeredTools.length,
+                    tools: registeredTools,
+                    duration: Date.now() - startTime,
+                    serverId,
+                };
+                // Emit discovery completed event
+                this.emit("discoveryCompleted", {
+                    serverId,
+                    toolCount: registeredTools.length,
+                    duration: result.duration,
+                    timestamp: new Date(),
+                });
+                mcpLogger.info(`[ToolDiscoveryService] Discovery completed for ${serverId}: ${registeredTools.length} tools`);
+                return result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: errorMessage,
+                });
+                span.recordException(error instanceof Error ? error : new Error(errorMessage));
+                mcpLogger.error(`[ToolDiscoveryService] Discovery failed for ${serverId}:`, error);
+                // Emit discovery failed event
+                this.emit("discoveryFailed", {
+                    serverId,
+                    error: errorMessage,
+                    timestamp: new Date(),
+                });
                 return {
                     success: false,
-                    error: `Discovery already in progress for server: ${serverId}`,
+                    error: errorMessage,
                     toolCount: 0,
                     tools: [],
                     duration: Date.now() - startTime,
                     serverId,
                 };
             }
-            this.discoveryInProgress.add(serverId);
-            mcpLogger.info(`[ToolDiscoveryService] Starting tool discovery for server: ${serverId}`);
-            // Create circuit breaker for tool discovery
-            const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-discovery-${serverId}`, {
-                failureThreshold: 2,
-                resetTimeout: 60000,
-                operationTimeout: timeout,
-            });
-            // Discover tools with circuit breaker protection
-            const tools = await circuitBreaker.execute(async () => {
-                return await this.performToolDiscovery(serverId, client, timeout);
-            });
-            // Register discovered tools
-            const registeredTools = await this.registerDiscoveredTools(serverId, tools);
-            const result = {
-                success: true,
-                toolCount: registeredTools.length,
-                tools: registeredTools,
-                duration: Date.now() - startTime,
-                serverId,
-            };
-            // Emit discovery completed event
-            this.emit("discoveryCompleted", {
-                serverId,
-                toolCount: registeredTools.length,
-                duration: result.duration,
-                timestamp: new Date(),
-            });
-            mcpLogger.info(`[ToolDiscoveryService] Discovery completed for ${serverId}: ${registeredTools.length} tools`);
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            mcpLogger.error(`[ToolDiscoveryService] Discovery failed for ${serverId}:`, error);
-            // Emit discovery failed event
-            this.emit("discoveryFailed", {
-                serverId,
-                error: errorMessage,
-                timestamp: new Date(),
-            });
-            return {
-                success: false,
-                error: errorMessage,
-                toolCount: 0,
-                tools: [],
-                duration: Date.now() - startTime,
-                serverId,
-            };
-        }
-        finally {
-            this.discoveryInProgress.delete(serverId);
-        }
+            finally {
+                this.discoveryInProgress.delete(serverId);
+            }
+        });
     }
     /**
      * Perform the actual tool discovery

package/dist/lib/mcp/toolRegistry.js

@@ -12,6 +12,7 @@ import { FlexibleToolValidator } from "./flexibleToolValidator.js";
 import { ErrorFactory } from "../utils/errorHandling.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
 import { withSpan, tracers, ATTR } from "../telemetry/index.js";
+import { SpanStatusCode } from "@opentelemetry/api";
 import { getAuthContext } from "../auth/authContext.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
@@ -251,7 +252,7 @@ export class MCPToolRegistry extends MCPRegistry {
             }
         }
         return withSpan({
-            name: "neurolink.tool.execute",
+            name: "neurolink.tool.registry.execute",
             tracer: tracers.mcp,
             attributes: {
                 [ATTR.GEN_AI_TOOL_NAME]: toolName,
@@ -412,6 +413,15 @@ export class MCPToolRegistry extends MCPRegistry {
                     errMsg.includes("not executable")) {
                     throw error;
                 }
+                // Explicitly set ERROR status — we're returning (not throwing) so withSpan
+                // won't automatically detect this as an error (gap T3 fix)
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: errMsg,
+                });
+                if (error instanceof Error) {
+                    span.recordException(error);
+                }
                 // Return runtime execution errors in ToolResult format
                 const errorResult = {
                     success: false,

package/dist/lib/memory/hippocampusInitializer.d.ts

@@ -1,3 +1,2 @@
-import { Hippocampus, type HippocampusConfig, type StorageConfig } from "@juspay/hippocampus";
-export type { HippocampusConfig, StorageConfig };
+import { Hippocampus, type HippocampusConfig } from "@juspay/hippocampus";
 export declare function initializeHippocampus(config: HippocampusConfig): Hippocampus | null;

package/dist/lib/memory/hippocampusInitializer.js

@@ -1,4 +1,4 @@
-import { Hippocampus, } from "@juspay/hippocampus";
+import { Hippocampus } from "@juspay/hippocampus";
 import { logger } from "../utils/logger.js";
 export function initializeHippocampus(config) {
     try {

package/dist/lib/memory/memoryRetrievalTools.js

@@ -7,10 +7,13 @@
  * @module
  */
 import { tool } from "ai";
+import { SpanStatusCode } from "@opentelemetry/api";
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { withTimeout } from "../utils/errorHandling.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
+import { withSpan } from "../telemetry/withSpan.js";
+import { tracers } from "../telemetry/tracers.js";
 /** Maximum characters returned per retrieval request */
 const DEFAULT_RETRIEVAL_LIMIT = 50_000;
 /** Hard maximum for user/LLM-supplied limit to prevent massive tool outputs */
@@ -81,154 +84,192 @@ export function createMemoryRetrievalTools(memoryManager, artifactStore) {
                     .describe("Regex pattern to search within message content. " +
                     "Returns matching lines with line numbers."),
             }),
-            execute: async (args) => {
-                // ── Artifact resolution path ────────────────────────────────────────
-                // When the caller supplies an artifactId we short-circuit to the
-                // artifact store (bypassing Redis) and return the full payload with
-                // optional offset/limit pagination.
-                if (args.artifactId) {
-                    if (!artifactStore) {
-                        logger.warn("[MemoryRetrievalTools] retrieve_context called with artifactId " +
-                            "but no ArtifactStore is configured");
-                        return {
-                            error: "Artifact store not configured — " +
-                                "mcp.outputLimits.strategy must be set to 'externalize' to use artifactId retrieval",
-                            artifactId: args.artifactId,
-                        };
-                    }
-                    const content = await withTimeout(artifactStore.retrieve(args.artifactId), 10_000, new Error(`ArtifactStore.retrieve() timed out for artifact "${args.artifactId}"`));
-                    if (content === null) {
+            execute: async (args) => withSpan({
+                name: "neurolink.memory.retrieve_context",
+                tracer: tracers.memory,
+                attributes: {
+                    "memory.operation": args.artifactId
+                        ? "artifact.fetch"
+                        : "session.retrieve",
+                    "memory.has_artifact_id": Boolean(args.artifactId),
+                    "memory.has_session_id": Boolean(args.sessionId),
+                    "memory.role": args.role ?? "any",
+                    "memory.search": Boolean(args.search),
+                },
+            }, async (otelSpan) => executeRetrieveContext(args, memoryManager, artifactStore, otelSpan)),
+        }),
+    };
+}
+async function executeRetrieveContext(args, memoryManager, artifactStore, otelSpan) {
+    // ── Artifact resolution path ────────────────────────────────────────
+    // When the caller supplies an artifactId we short-circuit to the
+    // artifact store (bypassing Redis) and return the full payload with
+    // optional offset/limit pagination.
+    if (args.artifactId) {
+        if (!artifactStore) {
+            logger.warn("[MemoryRetrievalTools] retrieve_context called with artifactId " +
+                "but no ArtifactStore is configured");
+            otelSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: "Artifact store not configured",
+            });
+            return {
+                error: "Artifact store not configured — " +
+                    "mcp.outputLimits.strategy must be set to 'externalize' to use artifactId retrieval",
+                artifactId: args.artifactId,
+            };
+        }
+        const content = await withTimeout(artifactStore.retrieve(args.artifactId), 10_000, new Error(`ArtifactStore.retrieve() timed out for artifact "${args.artifactId}"`));
+        if (content === null) {
+            otelSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: "Artifact not found or has expired",
+            });
+            return {
+                error: "Artifact not found or has expired",
+                artifactId: args.artifactId,
+            };
+        }
+        const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
+        const start = args.offset ?? 0;
+        const slice = content.slice(start, start + charLimit);
+        otelSpan.setAttribute("memory.artifact_size", content.length);
+        otelSpan.setAttribute("memory.returned_bytes", slice.length);
+        return {
+            artifactId: args.artifactId,
+            content: slice,
+            totalSize: content.length,
+            hasMore: start + charLimit < content.length,
+            offset: start,
+            limit: charLimit,
+        };
+    }
+    // ── End artifact resolution ─────────────────────────────────────────
+    if (!args.sessionId) {
+        otelSpan.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: "sessionId is required when artifactId is not provided",
+        });
+        return {
+            error: "sessionId is required when artifactId is not provided",
+        };
+    }
+    if (!memoryManager) {
+        otelSpan.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: "Memory manager not configured",
+        });
+        return {
+            error: "Session history retrieval requires Redis conversation memory — " +
+                "enable mcp.conversationMemory with a Redis backend, or use " +
+                "artifactId to retrieve an externalized MCP tool output.",
+        };
+    }
+    const span = SpanSerializer.createSpan(SpanType.MEMORY, "memory.retrieve", {
+        "memory.operation": "retrieve",
+        "memory.store": "redis",
+        "memory.query": args.search || args.messageId || `lastN:${args.lastN ?? "all"}`,
+    });
+    const startTime = Date.now();
+    // args.sessionId is guaranteed non-null here — we returned early above
+    // when it was missing. Cast via string coercion to satisfy eslint.
+    const sessionId = String(args.sessionId);
+    try {
+        const conversation = await withTimeout(memoryManager.getSessionRaw(sessionId), 10_000, new Error(`getSessionRaw() timed out for session "${sessionId}"`));
+        if (!conversation) {
+            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Session not found: ${sessionId}`);
+            getMetricsAggregator().recordSpan(endedSpan);
+            return { error: "Session not found", sessionId };
+        }
+        let messages = conversation.messages;
+        // Filter by specific messageId
+        if (args.messageId) {
+            const msg = messages.find((m) => m.id === args.messageId);
+            if (!msg) {
+                const endedSpan = SpanSerializer.endSpan(span, SpanStatus.ERROR, `Message not found: ${args.messageId}`);
+                getMetricsAggregator().recordSpan(endedSpan);
+                return { error: "Message not found", messageId: args.messageId };
+            }
+            messages = [msg];
+        }
+        // Filter by role
+        if (args.role) {
+            messages = messages.filter((m) => m.role === args.role);
+        }
+        // Take last N
+        if (args.lastN) {
+            messages = messages.slice(-args.lastN);
+        }
+        const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
+        const results = messages.map((msg) => {
+            const content = msg.content ?? "";
+            // Search mode: return matching lines with line numbers
+            if (args.search) {
+                try {
+                    const pattern = args.search;
+                    // Validate regex length to mitigate ReDoS from LLM-provided input
+                    if (pattern.length > 200) {
                         return {
-                            error: "Artifact not found or has expired",
-                            artifactId: args.artifactId,
+                            id: msg.id,
+                            error: "Search pattern too long (max 200 chars)",
                         };
                     }
-                    const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
-                    const start = args.offset ?? 0;
-                    const slice = content.slice(start, start + charLimit);
+                    // Treat user input as literal search to prevent ReDoS.
+                    // Regex metacharacters are escaped so patterns like "foo|bar" match literally.
+                    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                    const regex = new RegExp(escaped, "i");
+                    const lines = content.split("\n");
+                    const matches = lines
+                        .map((line, i) => ({ line: i + 1, text: line }))
+                        .filter((l) => regex.test(l.text))
+                        .slice(0, MAX_SEARCH_MATCHES);
                     return {
-                        artifactId: args.artifactId,
-                        content: slice,
+                        id: msg.id,
+                        role: msg.role,
+                        tool: msg.tool,
+                        matchCount: matches.length,
+                        matches,
                         totalSize: content.length,
-                        hasMore: start + charLimit < content.length,
-                        offset: start,
-                        limit: charLimit,
-                    };
-                }
-                // ── End artifact resolution ─────────────────────────────────────────
-                if (!args.sessionId) {
-                    return {
-                        error: "sessionId is required when artifactId is not provided",
                     };
                 }
-                if (!memoryManager) {
-                    return {
-                        error: "Session history retrieval requires Redis conversation memory — " +
-                            "enable mcp.conversationMemory with a Redis backend, or use " +
-                            "artifactId to retrieve an externalized MCP tool output.",
-                    };
+                catch {
+                    return { id: msg.id, error: "Invalid regex pattern" };
                 }
-                const span = SpanSerializer.createSpan(SpanType.MEMORY, "memory.retrieve", {
-                    "memory.operation": "retrieve",
-                    "memory.store": "redis",
-                    "memory.query": args.search || args.messageId || `lastN:${args.lastN ?? "all"}`,
-                });
-                const startTime = Date.now();
-                // args.sessionId is guaranteed non-null here — we returned early above
-                // when it was missing. Cast via string coercion to satisfy eslint.
-                const sessionId = String(args.sessionId);
-                try {
-                    const conversation = await withTimeout(memoryManager.getSessionRaw(sessionId), 10_000, new Error(`getSessionRaw() timed out for session "${sessionId}"`));
-                    if (!conversation) {
-                        span.durationMs = Date.now() - startTime;
-                        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-                        getMetricsAggregator().recordSpan(endedSpan);
-                        return { error: "Session not found", sessionId };
-                    }
-                    let messages = conversation.messages;
-                    // Filter by specific messageId
-                    if (args.messageId) {
-                        const msg = messages.find((m) => m.id === args.messageId);
-                        if (!msg) {
-                            span.durationMs = Date.now() - startTime;
-                            const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-                            getMetricsAggregator().recordSpan(endedSpan);
-                            return { error: "Message not found", messageId: args.messageId };
-                        }
-                        messages = [msg];
-                    }
-                    // Filter by role
-                    if (args.role) {
-                        messages = messages.filter((m) => m.role === args.role);
-                    }
-                    // Take last N
-                    if (args.lastN) {
-                        messages = messages.slice(-args.lastN);
-                    }
-                    const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
-                    const results = messages.map((msg) => {
-                        const content = msg.content ?? "";
-                        // Search mode: return matching lines with line numbers
-                        if (args.search) {
-                            try {
-                                const pattern = args.search;
-                                // Validate regex length to mitigate ReDoS from LLM-provided input
-                                if (pattern.length > 200) {
-                                    return {
-                                        id: msg.id,
-                                        error: "Search pattern too long (max 200 chars)",
-                                    };
-                                }
-                                const regex = new RegExp(pattern, "i"); // no 'g' flag — avoids stateful .test() bug
-                                const lines = content.split("\n");
-                                const matches = lines
-                                    .map((line, i) => ({ line: i + 1, text: line }))
-                                    .filter((l) => regex.test(l.text))
-                                    .slice(0, MAX_SEARCH_MATCHES);
-                                return {
-                                    id: msg.id,
-                                    role: msg.role,
-                                    tool: msg.tool,
-                                    matchCount: matches.length,
-                                    matches,
-                                    totalSize: content.length,
-                                };
-                            }
-                            catch {
-                                return { id: msg.id, error: "Invalid regex pattern" };
-                            }
-                        }
-                        // Paginated read mode
-                        const start = args.offset ?? 0;
-                        const end = start + charLimit;
-                        const slice = content.slice(start, end);
-                        return {
-                            id: msg.id,
-                            role: msg.role,
-                            tool: msg.tool,
-                            content: slice,
-                            totalSize: content.length,
-                            hasMore: end < content.length,
-                        };
-                    });
-                    span.durationMs = Date.now() - startTime;
-                    const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
-                    getMetricsAggregator().recordSpan(endedSpan);
-                    return { messages: results, totalMessages: results.length };
-                }
-                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);
-                    logger.error("[MemoryRetrievalTools] Error retrieving context", {
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    return { error: "Failed to retrieve context" };
-                }
-            },
-        }),
-    };
+            }
+            // Paginated read mode
+            const start = args.offset ?? 0;
+            const end = start + charLimit;
+            const slice = content.slice(start, end);
+            return {
+                id: msg.id,
+                role: msg.role,
+                tool: msg.tool,
+                content: slice,
+                totalSize: content.length,
+                hasMore: end < content.length,
+            };
+        });
+        span.durationMs = Date.now() - startTime;
+        const endedSpan = SpanSerializer.endSpan(span, SpanStatus.OK);
+        getMetricsAggregator().recordSpan(endedSpan);
+        otelSpan.setAttribute("memory.message_count", results.length);
+        return { messages: results, totalMessages: results.length };
+    }
+    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);
+        logger.error("[MemoryRetrievalTools] Error retrieving context", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        otelSpan.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        otelSpan.recordException(error instanceof Error ? error : new Error(String(error)));
+        return { error: "Failed to retrieve context" };
+    }
 }
 //# sourceMappingURL=memoryRetrievalTools.js.map

package/dist/lib/models/anthropicModels.d.ts

@@ -6,7 +6,6 @@
  */
 import type { ClaudeSubscriptionTier, AnthropicModelMetadata } from "../types/index.js";
 import { ModelAccessError } from "../types/index.js";
-export type { ClaudeSubscriptionTier, AnthropicModelMetadata };
 export { ModelAccessError };
 /**
  * Anthropic Claude model identifiers

package/dist/lib/models/anthropicModels.js

@@ -5,6 +5,7 @@
  * model capabilities, and provides helper functions for tier-based access control.
  */
 import { ModelAccessError } from "../types/index.js";
+// Re-export runtime value for convenience
 export { ModelAccessError };
 // ============================================================================
 // ANTHROPIC MODEL ENUM