@juspay/neurolink 9.6.0 → 9.7.0

package/dist/lib/core/baseProvider.js

@@ -1,8 +1,9 @@
 import { directAgentTools } from "../agent/directTools.js";
 import { IMAGE_GENERATION_MODELS } from "../core/constants.js";
 import { MiddlewareFactory } from "../middleware/factory.js";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { getKeyCount, getKeysAsString } from "../utils/transformationUtils.js";
 import { TTSProcessor } from "../utils/ttsProcessor.js";
@@ -101,16 +102,11 @@ export class BaseProvider {
         // executeStream() can simply use options.tools (or getAllTools() + options.tools)
         // and get the complete tool set without needing per-provider merge logic.
         if (!options.disableTools && this.supportsTools()) {
-            const baseTools = await this.getAllTools();
-            const externalTools = (options.tools || {});
-            const mergedTools = { ...baseTools, ...externalTools };
+            const mergedTools = await this.getToolsForStream(options);
             options = { ...options, tools: mergedTools };
-            logger.debug(`Central tool merge for stream`, {
-                provider: this.providerName,
-                baseToolCount: Object.keys(baseTools).length,
-                externalToolCount: Object.keys(externalTools).length,
-                totalToolCount: Object.keys(mergedTools).length,
-            });
+        }
+        else {
+            options = { ...options, tools: {} };
         }
         // CRITICAL FIX: Always prefer real streaming over fake streaming
         // Try real streaming first, use fake streaming only as fallback
@@ -175,6 +171,13 @@ export class BaseProvider {
                 toolUsageContext: options.toolUsageContext,
                 context: options.context,
                 csvOptions: options.csvOptions,
+                // Forward abort, tool filtering, and timeout options to prevent
+                // silent bypass when falling back from real streaming to fake streaming
+                abortSignal: options.abortSignal,
+                toolFilter: options.toolFilter,
+                excludeTools: options.excludeTools,
+                skipToolPromptInjection: options.skipToolPromptInjection,
+                timeout: options.timeout,
             };
             logger.debug(`Calling generate for fake streaming`, {
                 provider: this.providerName,
@@ -254,18 +257,62 @@ export class BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Apply per-call tool filtering (whitelist/blacklist) to a tools record.
+     * If toolFilter is set, only tools whose names are in the list are kept.
+     * If excludeTools is set, matching tools are removed. excludeTools is applied after toolFilter.
+     */
+    applyToolFiltering(tools, options) {
+        if ((!options.toolFilter || options.toolFilter.length === 0) &&
+            (!options.excludeTools || options.excludeTools.length === 0)) {
+            return tools;
+        }
+        const beforeCount = Object.keys(tools).length;
+        let filtered = { ...tools };
+        if (options.toolFilter && options.toolFilter.length > 0) {
+            const allowSet = new Set(options.toolFilter);
+            const result = {};
+            for (const [name, tool] of Object.entries(filtered)) {
+                if (allowSet.has(name)) {
+                    result[name] = tool;
+                }
+            }
+            filtered = result;
+        }
+        if (options.excludeTools && options.excludeTools.length > 0) {
+            const denySet = new Set(options.excludeTools);
+            for (const name of Object.keys(filtered)) {
+                if (denySet.has(name)) {
+                    delete filtered[name];
+                }
+            }
+        }
+        const afterCount = Object.keys(filtered).length;
+        if (beforeCount !== afterCount) {
+            logger.debug(`Tool filtering applied`, {
+                provider: this.providerName,
+                beforeCount,
+                afterCount,
+                toolFilter: options.toolFilter,
+                excludeTools: options.excludeTools,
+            });
+        }
+        return filtered;
+    }
     /**
      * Prepare generation context including tools and model
      */
     async prepareGenerationContext(options) {
         const shouldUseTools = !options.disableTools && this.supportsTools();
         const baseTools = shouldUseTools ? await this.getAllTools() : {};
-        const tools = shouldUseTools
+        let tools = shouldUseTools
             ? {
                 ...baseTools,
                 ...(options.tools || {}),
             }
             : {};
+        // Apply per-call tool filtering (whitelist/blacklist)
+        tools = this.applyToolFiltering(tools, options);
         logger.debug(`Final tools prepared for AI`, {
             provider: this.providerName,
             directTools: getKeyCount(baseTools),
@@ -294,7 +341,9 @@ export class BaseProvider {
         }
         const baseTools = await this.getAllTools();
         const externalTools = (options.tools || {});
-        const merged = { ...baseTools, ...externalTools };
+        let merged = { ...baseTools, ...externalTools };
+        // Apply per-call tool filtering (whitelist/blacklist)
+        merged = this.applyToolFiltering(merged, options);
         logger.debug(`Tools prepared for streaming`, {
             provider: this.providerName,
             baseToolCount: Object.keys(baseTools).length,
@@ -424,7 +473,19 @@ export class BaseProvider {
             // ===== Normal AI Generation Flow =====
             const { tools, model } = await this.prepareGenerationContext(options);
             const messages = await this.buildMessages(options);
-            const generateResult = await this.executeGeneration(model, messages, tools, options);
+            // Compose timeout signal with user-provided abort signal (mirrors stream path)
+            const timeoutController = createTimeoutController(options.timeout, this.providerName, "generate");
+            const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+            const composedOptions = composedSignal
+                ? { ...options, abortSignal: composedSignal }
+                : options;
+            let generateResult;
+            try {
+                generateResult = await this.executeGeneration(model, messages, tools, composedOptions);
+            }
+            finally {
+                timeoutController?.cleanup();
+            }
             this.analyzeAIResponse(generateResult);
             this.logGenerationComplete(generateResult);
             const responseTime = Date.now() - startTime;
@@ -471,7 +532,15 @@ export class BaseProvider {
             return await this.enhanceResult(enhancedResult, options, startTime);
         }
         catch (error) {
-            logger.error(`Generate failed for ${this.providerName}:`, error);
+            // Abort errors are expected when a generation is cancelled — log at info, not error
+            if (isAbortError(error)) {
+                logger.info(`Generate aborted for ${this.providerName}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            else {
+                logger.error(`Generate failed for ${this.providerName}:`, error);
+            }
             throw this.handleProviderError(error);
         }
     }

package/dist/lib/core/conversationMemoryManager.d.ts

@@ -18,6 +18,15 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
      * Initialize the memory manager
      */
     initialize(): Promise<void>;
+    /** Whether this memory manager can persist data (always true for in-memory within process) */
+    get canPersist(): boolean;
+    /** Whether Redis client is configured (always false for in-memory) */
+    get isRedisConfigured(): boolean;
+    /** Get health status for monitoring */
+    getHealthStatus(): {
+        initialized: boolean;
+        connected: boolean;
+    };
     /**
      * Store a conversation turn for a session
      * TOKEN-BASED: Validates message size and triggers summarization based on tokens
@@ -32,6 +41,10 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
      * Check if summarization is needed based on token count
      */
     private checkAndSummarize;
+    /**
+     * Estimate total tokens for a list of messages
+     */
+    private estimateTokens;
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)

package/dist/lib/core/conversationMemoryManager.js

@@ -42,6 +42,21 @@ export class ConversationMemoryManager {
             });
         }
     }
+    /** Whether this memory manager can persist data (always true for in-memory within process) */
+    get canPersist() {
+        return true;
+    }
+    /** Whether Redis client is configured (always false for in-memory) */
+    get isRedisConfigured() {
+        return false;
+    }
+    /** Get health status for monitoring */
+    getHealthStatus() {
+        return {
+            initialized: this.isInitialized,
+            connected: false,
+        };
+    }
     /**
      * Store a conversation turn for a session
      * TOKEN-BASED: Validates message size and triggers summarization based on tokens
@@ -162,6 +177,19 @@ export class ConversationMemoryManager {
             this.summarizationInProgress.delete(session.sessionId);
         }
     }
+    /**
+     * Estimate total tokens for a list of messages
+     */
+    estimateTokens(messages) {
+        return messages.reduce((total, msg) => {
+            let msgTokens = TokenUtils.estimateTokenCount(msg.content);
+            if (msg.events && Array.isArray(msg.events) && msg.events.length > 0) {
+                const eventsJson = JSON.stringify(msg.events);
+                msgTokens += TokenUtils.estimateTokenCount(eventsJson);
+            }
+            return total + msgTokens;
+        }, 0);
+    }
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)

package/dist/lib/core/dynamicModels.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 /**
  * Model configuration schema for validation
@@ -122,7 +123,7 @@ export class DynamicModelProvider {
             }
             catch (error) {
                 clearTimeout(timeoutId);
-                if (error instanceof Error && error.name === "AbortError") {
+                if (isAbortError(error)) {
                     throw new Error(`Request timeout after ${timeoutMs}ms`);
                 }
                 throw error;
@@ -177,7 +178,7 @@ export class DynamicModelProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error(`Localhost health check timeout - server may not be running`);
             }
             // For connection refused, throw a more specific error

package/dist/lib/core/modules/GenerationHandler.js

@@ -53,6 +53,7 @@ export class GenerationHandler {
             ...(shouldUseTools && { toolChoice: "auto" }),
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            abortSignal: options.abortSignal,
             ...(useStructuredOutput &&
                 options.schema && {
                 experimental_output: Output.object({ schema: options.schema }),
@@ -272,6 +273,7 @@ export class GenerationHandler {
         return {
             content,
             usage,
+            finishReason: generateResult.finishReason,
             provider: this.providerName,
             model: this.modelName,
             toolCalls: generateResult.toolCalls

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -34,6 +34,17 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * Initialize the memory manager with Redis connection
      */
     initialize(): Promise<void>;
+    /** Whether this memory manager can persist data (Redis connected and initialized) */
+    get canPersist(): boolean;
+    /** Whether Redis client is configured and connected */
+    get isRedisConfigured(): boolean;
+    /** Get health status for monitoring */
+    getHealthStatus(): {
+        initialized: boolean;
+        connected: boolean;
+        host: string;
+        keyPrefix: string;
+    };
     /**
      * Get session by ID, reconstructing a SessionMemory from Redis storage.
      */

package/dist/lib/core/redisConversationMemoryManager.js

@@ -9,7 +9,7 @@ import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
 import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
 import { logger } from "../utils/logger.js";
-import { createRedisClient, deserializeConversation, getNormalizedConfig, getSessionKey, getUserSessionsKey, scanKeys, serializeConversation, } from "../utils/redis.js";
+import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -54,7 +54,7 @@ export class RedisConversationMemoryManager {
                 keyPrefix: this.redisConfig.keyPrefix,
                 ttl: this.redisConfig.ttl,
             });
-            this.redisClient = await createRedisClient(this.redisConfig);
+            this.redisClient = await getPooledRedisClient(this.redisConfig);
             this.isInitialized = true;
             logger.info("RedisConversationMemoryManager initialized", {
                 storage: "redis",
@@ -82,6 +82,23 @@ export class RedisConversationMemoryManager {
             });
         }
     }
+    /** Whether this memory manager can persist data (Redis connected and initialized) */
+    get canPersist() {
+        return (this.isInitialized && this.redisClient !== null && this.redisClient.isOpen);
+    }
+    /** Whether Redis client is configured and connected */
+    get isRedisConfigured() {
+        return this.redisClient !== null && this.redisClient.isOpen;
+    }
+    /** Get health status for monitoring */
+    getHealthStatus() {
+        return {
+            initialized: this.isInitialized,
+            connected: this.redisClient?.isOpen ?? false,
+            host: this.redisConfig.host,
+            keyPrefix: this.redisConfig.keyPrefix,
+        };
+    }
     /**
      * Get session by ID, reconstructing a SessionMemory from Redis storage.
      */
@@ -671,7 +688,7 @@ export class RedisConversationMemoryManager {
      * Uses AI to create a concise, descriptive title (5-8 words)
      */
     async generateConversationTitle(userMessage) {
-        logger.debug("[RedisConversationMemoryManager] Generating conversation title", {
+        logger.info("[RedisConversationMemoryManager] Generating conversation title", {
             userMessageLength: userMessage.length,
             userMessagePreview: userMessage.substring(0, 100),
         });
@@ -680,12 +697,12 @@ export class RedisConversationMemoryManager {
             const titleGenerator = new NeuroLink({
                 conversationMemory: { enabled: false },
             });
-            const titlePrompt = `Generate a clear, concise, and descriptive title (5–8 words maximum) for a conversation based on the following user message. 
-The title must meaningfully reflect the topic or intent of the message. 
-Do not output anything unrelated, vague, or generic. 
+            const titlePrompt = `Generate a clear, concise, and descriptive title (5–8 words maximum) for a conversation based on the following user message.
+The title must meaningfully reflect the topic or intent of the message.
+Do not output anything unrelated, vague, or generic.
 Do not say you cannot create a title. Always return a valid title.
 
-User message: "${userMessage}`;
+User message: "${userMessage}"`;
             const result = await titleGenerator.generate({
                 input: { text: titlePrompt },
                 provider: this.config.summarizationProvider || "vertex",
@@ -704,7 +721,7 @@ User message: "${userMessage}`;
             if (title.length < 3) {
                 title = "New Conversation";
             }
-            logger.debug("[RedisConversationMemoryManager] Generated conversation title", {
+            logger.info("[RedisConversationMemoryManager] Generated conversation title", {
                 originalLength: result.content?.length || 0,
                 cleanedTitle: title,
                 titleLength: title.length,
@@ -744,7 +761,7 @@ User message: "${userMessage}`;
      */
     async close() {
         if (this.redisClient) {
-            await this.redisClient.quit();
+            await releasePooledRedisClient(this.redisConfig);
             this.redisClient = null;
             this.isInitialized = false;
             logger.info("Redis connection closed");

package/dist/lib/index.d.ts

@@ -40,12 +40,15 @@ export { validateTool } from "./sdk/toolRegistration.js";
 export * from "./types/index.js";
 export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
 export { getAvailableProviders, getBestProvider, isValidProvider, } from "./utils/providerUtils.js";
+export { calculateCost, hasPricing } from "./utils/pricing.js";
+export { isAbortError } from "./utils/errorHandling.js";
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 export type { MCPServerInfo } from "./types/mcpTypes.js";
 export type { LangfuseConfig, LangfuseSpanAttributes, ObservabilityConfig, OpenTelemetryConfig, TraceNameFormat, } from "./types/observability.js";
 export { buildObservabilityConfigFromEnv } from "./utils/observabilityHelpers.js";
 import { createContextEnricher, flushOpenTelemetry, getLangfuseContext, getLangfuseHealthStatus, getLangfuseSpanProcessor, getSpanProcessors, getTracer, getTracerProvider, initializeOpenTelemetry, isOpenTelemetryInitialized, isUsingExternalTracerProvider, setLangfuseContext, shutdownOpenTelemetry } from "./services/server/ai/observability/instrumentation.js";
+export type { LangfuseContext } from "./services/server/ai/observability/instrumentation.js";
 export { initializeOpenTelemetry, shutdownOpenTelemetry, flushOpenTelemetry, getLangfuseHealthStatus, setLangfuseContext, getLangfuseSpanProcessor, getTracerProvider, isOpenTelemetryInitialized, getSpanProcessors, createContextEnricher, isUsingExternalTracerProvider, getLangfuseContext, getTracer, };
 export { clearAnalyticsMetrics, createAnalyticsMiddleware, getAnalyticsMetrics, } from "./middleware/builtin/analytics.js";
 export { MiddlewareFactory } from "./middleware/factory.js";
@@ -191,6 +194,7 @@ export type { AuthorizationUrlResult, DiscoveredMcp, HTTPRetryConfig, MCPOAuthCo
 export type { ExecutionContext, ToolExecutionResult, ToolInfo, } from "./types/tools.js";
 export type { LogLevel } from "./types/utilities.js";
 export { logger } from "./utils/logger.js";
+export { getPoolStats } from "./utils/redis.js";
 export declare function initializeTelemetry(): Promise<boolean>;
 export declare function getTelemetryStatus(): Promise<{
     enabled: boolean;

package/dist/lib/index.js

@@ -45,6 +45,10 @@ export { validateTool } from "./sdk/toolRegistration.js";
 export * from "./types/index.js";
 // Utility exports
 export { getAvailableProviders, getBestProvider, isValidProvider, } from "./utils/providerUtils.js";
+// Pricing utilities
+export { calculateCost, hasPricing } from "./utils/pricing.js";
+// Error utilities
+export { isAbortError } from "./utils/errorHandling.js";
 // Main NeuroLink wrapper class and diagnostic types
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
@@ -222,6 +226,7 @@ initializeMCPEcosystem, isRetryableHTTPError, isRetryableStatusCode, isTokenExpi
 // Circuit Breaker
 MCPCircuitBreaker, mcpLogger, NeuroLinkOAuthProvider, RateLimiterManager, validateServerTools, validateTool as validateMCPTool, withHTTPRetry, } from "./mcp/index.js";
 export { logger } from "./utils/logger.js";
+export { getPoolStats } from "./utils/redis.js";
 // ============================================================================
 // REAL-TIME SERVICES & TELEMETRY - Enterprise Platform Features
 // ============================================================================

package/dist/lib/mcp/httpRetryHandler.js

@@ -4,6 +4,7 @@
  * Provides retry logic with exponential backoff and jitter
  * specifically designed for HTTP-based MCP transport connections.
  */
+import { isAbortError } from "../utils/errorHandling.js";
 import { calculateBackoffDelay } from "../utils/retryHandler.js";
 import { logger } from "../utils/logger.js";
 /**
@@ -50,11 +51,14 @@ export function isRetryableHTTPError(error, config = DEFAULT_HTTP_RETRY_CONFIG)
         return false;
     }
     const errorObj = error;
+    // User-initiated aborts are NOT retryable — the caller explicitly cancelled
+    if (isAbortError(error)) {
+        return false;
+    }
     // Check for timeout errors
     if (errorObj.name === "TimeoutError" ||
         errorObj.code === "TIMEOUT" ||
-        errorObj.code === "ETIMEDOUT" ||
-        errorObj.name === "AbortError") {
+        errorObj.code === "ETIMEDOUT") {
         return true;
     }
     // Check for network-related errors

package/dist/lib/neurolink.d.ts

@@ -527,6 +527,11 @@ export declare class NeuroLink {
     /**
      * Create tool-aware system prompt that informs AI about available tools
      */
+    /**
+     * Apply per-call tool filtering (whitelist/blacklist) to a ToolInfo array.
+     * Used to filter the tool list before building the system prompt.
+     */
+    private applyToolInfoFiltering;
     private createToolAwareSystemPrompt;
     /**
      * Execute tools if available through centralized registry