@juspay/neurolink 9.5.3 → 9.7.0

package/dist/lib/context/summarizationEngine.js

@@ -0,0 +1,111 @@
+/**
+ * Shared Summarization Engine
+ *
+ * Extracted from ConversationMemoryManager and RedisConversationMemoryManager
+ * to eliminate code duplication. Both managers delegate to this engine.
+ */
+import { TokenUtils } from "../constants/tokens.js";
+import { buildContextFromPointer, generateSummary, } from "../utils/conversationMemory.js";
+import { RECENT_MESSAGES_RATIO } from "../config/conversationMemory.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Centralized summarization engine for conversation memory.
+ * Handles token counting, threshold checking, and summary generation.
+ */
+export class SummarizationEngine {
+    /**
+     * Check if a session needs summarization and perform it if so.
+     * @param session - Session memory to check and potentially summarize
+     * @param threshold - Token threshold that triggers summarization
+     * @param config - Conversation memory configuration (partial allowed)
+     * @param logPrefix - Prefix for log messages
+     * @returns True if summarization was performed
+     */
+    async checkAndSummarize(session, threshold, config, logPrefix = "[SummarizationEngine]") {
+        const contextMessages = buildContextFromPointer(session);
+        const tokenCount = this.estimateTokens(contextMessages);
+        session.lastTokenCount = tokenCount;
+        session.lastCountedAt = Date.now();
+        logger.debug(`${logPrefix} Token count check`, {
+            sessionId: session.sessionId,
+            tokenCount,
+            threshold,
+            needsSummarization: tokenCount >= threshold,
+        });
+        if (tokenCount >= threshold) {
+            await this.summarizeSession(session, threshold, config, logPrefix);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Perform token-based summarization on a session.
+     * Uses pointer-based, non-destructive approach.
+     * @param session - Session memory to summarize
+     * @param threshold - Token threshold for calculating split point
+     * @param config - Conversation memory configuration (partial allowed)
+     * @param logPrefix - Prefix for log messages
+     */
+    async summarizeSession(session, threshold, config, logPrefix = "[SummarizationEngine]") {
+        const startIndex = session.summarizedUpToMessageId
+            ? session.messages.findIndex((m) => m.id === session.summarizedUpToMessageId) + 1
+            : 0;
+        const recentMessages = session.messages.slice(startIndex);
+        if (recentMessages.length === 0) {
+            return;
+        }
+        const targetRecentTokens = threshold * RECENT_MESSAGES_RATIO;
+        const splitIndex = this.findSplitIndexByTokens(recentMessages, targetRecentTokens);
+        const messagesToSummarize = recentMessages.slice(0, splitIndex);
+        if (messagesToSummarize.length === 0) {
+            return;
+        }
+        const summary = await generateSummary(messagesToSummarize, config, logPrefix, session.summarizedMessage);
+        if (!summary) {
+            logger.warn(`${logPrefix} Summary generation failed`, {
+                sessionId: session.sessionId,
+            });
+            return;
+        }
+        const lastSummarized = messagesToSummarize[messagesToSummarize.length - 1];
+        session.summarizedUpToMessageId = lastSummarized.id;
+        session.summarizedMessage = summary;
+        logger.info(`${logPrefix} Summarization complete`, {
+            sessionId: session.sessionId,
+            summarizedCount: messagesToSummarize.length,
+            totalMessages: session.messages.length,
+        });
+    }
+    /**
+     * Estimate total tokens for a message array.
+     * @param messages - Array of chat messages
+     * @returns Estimated token count
+     */
+    estimateTokens(messages) {
+        return messages.reduce((total, msg) => {
+            return total + TokenUtils.estimateTokenCount(msg.content);
+        }, 0);
+    }
+    /**
+     * Find split index to keep recent messages within target token count.
+     * Works backwards from the most recent message to find the split point.
+     * @param messages - Array of messages to analyze
+     * @param targetRecentTokens - Target token count for recent messages
+     * @returns Index at which to split (messages before this index will be summarized)
+     */
+    findSplitIndexByTokens(messages, targetRecentTokens) {
+        let recentTokens = 0;
+        let splitIndex = messages.length;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msgTokens = TokenUtils.estimateTokenCount(messages[i].content);
+            if (recentTokens + msgTokens > targetRecentTokens) {
+                splitIndex = i + 1;
+                break;
+            }
+            recentTokens += msgTokens;
+        }
+        // Ensure at least one message is summarized
+        return Math.max(1, splitIndex);
+    }
+}
+//# sourceMappingURL=summarizationEngine.js.map

package/dist/lib/context/toolOutputLimits.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tool Output Size Limits
+ *
+ * Truncates tool outputs exceeding size limits.
+ * Can save full output to disk with a pointer.
+ * Modeled on OpenCode's approach.
+ */
+/** Maximum tool output size in bytes (50KB) */
+export declare const MAX_TOOL_OUTPUT_BYTES: number;
+/** Maximum tool output lines */
+export declare const MAX_TOOL_OUTPUT_LINES = 2000;
+import type { TruncateOptions, TruncateResult } from "../types/contextTypes.js";
+export type { TruncateOptions, TruncateResult } from "../types/contextTypes.js";
+/**
+ * Truncate tool output if it exceeds size limits.
+ */
+export declare function truncateToolOutput(output: string, options?: TruncateOptions): TruncateResult;

package/dist/lib/context/toolOutputLimits.js

@@ -0,0 +1,85 @@
+/**
+ * Tool Output Size Limits
+ *
+ * Truncates tool outputs exceeding size limits.
+ * Can save full output to disk with a pointer.
+ * Modeled on OpenCode's approach.
+ */
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { tmpdir } from "os";
+/** Maximum tool output size in bytes (50KB) */
+export const MAX_TOOL_OUTPUT_BYTES = 50 * 1024;
+/** Maximum tool output lines */
+export const MAX_TOOL_OUTPUT_LINES = 2_000;
+/**
+ * Truncate tool output if it exceeds size limits.
+ */
+export function truncateToolOutput(output, options) {
+    const maxBytes = options?.maxBytes ?? MAX_TOOL_OUTPUT_BYTES;
+    const maxLines = options?.maxLines ?? MAX_TOOL_OUTPUT_LINES;
+    const direction = options?.direction ?? "tail";
+    const saveToDisk = options?.saveToDisk ?? false;
+    const originalSize = Buffer.byteLength(output, "utf-8");
+    // Check byte limit
+    const exceedsBytes = originalSize > maxBytes;
+    // Check line limit
+    const lines = output.split("\n");
+    const exceedsLines = lines.length > maxLines;
+    if (!exceedsBytes && !exceedsLines) {
+        return { content: output, truncated: false, originalSize };
+    }
+    // Save to disk if requested
+    let savedPath;
+    if (saveToDisk) {
+        try {
+            const saveDir = options?.saveDir ?? join(tmpdir(), "neurolink-tool-output");
+            mkdirSync(saveDir, { recursive: true });
+            savedPath = join(saveDir, `tool-output-${randomUUID()}.txt`);
+            writeFileSync(savedPath, output, "utf-8");
+        }
+        catch {
+            // Silently fail disk save
+        }
+    }
+    // Apply truncation
+    let truncated;
+    if (exceedsLines) {
+        if (direction === "head") {
+            truncated = lines.slice(0, maxLines).join("\n");
+        }
+        else {
+            truncated = lines.slice(-maxLines).join("\n");
+        }
+    }
+    else {
+        truncated = output;
+    }
+    // Apply byte limit
+    if (Buffer.byteLength(truncated, "utf-8") > maxBytes) {
+        if (direction === "head") {
+            truncated = truncated.slice(0, maxBytes);
+        }
+        else {
+            truncated = truncated.slice(-maxBytes);
+        }
+    }
+    // Add truncation notice
+    const notice = savedPath
+        ? `\n\n[Output truncated from ${originalSize} bytes to ${Buffer.byteLength(truncated, "utf-8")} bytes. Full output saved to: ${savedPath}]`
+        : `\n\n[Output truncated from ${originalSize} bytes to ${Buffer.byteLength(truncated, "utf-8")} bytes]`;
+    if (direction === "head") {
+        truncated = truncated + notice;
+    }
+    else {
+        truncated = notice + "\n" + truncated;
+    }
+    return {
+        content: truncated,
+        truncated: true,
+        savedPath,
+        originalSize,
+    };
+}
+//# sourceMappingURL=toolOutputLimits.js.map

package/dist/lib/context/toolPairRepair.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool Use/Result Pair Repair
+ *
+ * After compaction, validates that every tool_use (tool_call) has a
+ * corresponding tool_result and vice versa. Inserts synthetic
+ * placeholders for orphaned entries.
+ */
+import type { ChatMessage } from "../types/conversation.js";
+import type { RepairResult } from "../types/contextTypes.js";
+export type { RepairResult } from "../types/contextTypes.js";
+/**
+ * Repair orphaned tool_use/tool_result pairs in a message array.
+ *
+ * Ensures every tool_call has a following tool_result and vice versa.
+ */
+export declare function repairToolPairs(messages: ChatMessage[]): RepairResult;

package/dist/lib/context/toolPairRepair.js

@@ -0,0 +1,67 @@
+/**
+ * Tool Use/Result Pair Repair
+ *
+ * After compaction, validates that every tool_use (tool_call) has a
+ * corresponding tool_result and vice versa. Inserts synthetic
+ * placeholders for orphaned entries.
+ */
+import { randomUUID } from "crypto";
+/**
+ * Repair orphaned tool_use/tool_result pairs in a message array.
+ *
+ * Ensures every tool_call has a following tool_result and vice versa.
+ */
+export function repairToolPairs(messages) {
+    const result = [];
+    let orphanedCallsFixed = 0;
+    let orphanedResultsFixed = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const nextMsg = i + 1 < messages.length ? messages[i + 1] : undefined;
+        if (msg.role === "tool_call") {
+            result.push(msg);
+            // Check if next message is the corresponding tool_result
+            if (!nextMsg || nextMsg.role !== "tool_result") {
+                // Insert synthetic tool_result
+                result.push({
+                    id: `repair-result-${randomUUID()}`,
+                    role: "tool_result",
+                    content: "[Tool result unavailable - conversation was compacted]",
+                    tool: msg.tool,
+                    timestamp: msg.timestamp,
+                    metadata: { truncated: true },
+                });
+                orphanedCallsFixed++;
+            }
+        }
+        else if (msg.role === "tool_result") {
+            // Check if previous message was the corresponding tool_call
+            const prevMsg = result.length > 0 ? result[result.length - 1] : undefined;
+            if (!prevMsg ||
+                (prevMsg.role !== "tool_call" && prevMsg.role !== "tool_result")) {
+                // Insert synthetic tool_call before this result
+                result.push({
+                    id: `repair-call-${randomUUID()}`,
+                    role: "tool_call",
+                    content: `[Tool call for ${msg.tool || "unknown"} - conversation was compacted]`,
+                    tool: msg.tool,
+                    timestamp: msg.timestamp,
+                    metadata: { truncated: true },
+                });
+                orphanedResultsFixed++;
+            }
+            result.push(msg);
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    const repaired = orphanedCallsFixed > 0 || orphanedResultsFixed > 0;
+    return {
+        repaired,
+        messages: repaired ? result : messages,
+        orphanedCallsFixed,
+        orphanedResultsFixed,
+    };
+}
+//# sourceMappingURL=toolPairRepair.js.map

package/dist/lib/core/analytics.js

@@ -7,6 +7,7 @@
 import { logger } from "../utils/logger.js";
 import { modelConfig } from "./modelConfiguration.js";
 import { extractTokenUsage as extractTokenUsageUtil } from "../utils/tokenUtils.js";
+import { calculateCost, hasPricing } from "../utils/pricing.js";
 /**
  * Create analytics data structure from AI response
  */
@@ -60,19 +61,25 @@ function extractTokenUsage(result) {
     return extractTokenUsageUtil(result.usage);
 }
 /**
- * Estimate cost based on provider, model, and token usage
+ * Estimate cost based on provider, model, and token usage.
+ * Uses the per-model pricing table first (which includes cache token rates),
+ * then falls back to the provider-level configuration system.
  */
 function estimateCost(provider, model, tokens) {
     try {
-        // Use the new configuration system instead of hardcoded costs
+        // Try the per-model pricing table first (includes cache token rates)
+        if (hasPricing(provider, model)) {
+            return calculateCost(provider, model, tokens);
+        }
+        // Fall back to the configuration system for providers/models not in the pricing table
         const costInfo = modelConfig.getCostInfo(provider.toLowerCase(), model);
         if (!costInfo) {
             return undefined;
         }
-        // Calculate cost using the configuration system
+        // Calculate cost using the configuration system (per-1K-token rates)
         const inputCost = (tokens.input / 1000) * costInfo.input;
         const outputCost = (tokens.output / 1000) * costInfo.output;
-        return Math.round((inputCost + outputCost) * 100000) / 100000; // Round to 5 decimal places
+        return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000; // Round to 6 decimal places
     }
     catch (error) {
         logger.debug("Cost estimation failed", { provider, model, error });

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

@@ -46,6 +46,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * Execute fake streaming - extracted method for reusability
      */
     private executeFakeStreaming;
+    /**
+     * 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.
+     */
+    private applyToolFiltering;
     /**
      * Prepare generation context including tools and model
      */

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

@@ -2,11 +2,13 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ConversationMemoryConfig, SessionMemory, ConversationMemoryStats, ChatMessage, StoreConversationTurnOptions } from "../types/conversation.js";
-export declare class ConversationMemoryManager {
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions } from "../types/conversation.js";
+import type { IConversationMemoryManager } from "../types/conversationMemoryInterface.js";
+export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
     private isInitialized;
+    private summarizationEngine;
     /**
      * Track sessions currently being summarized to prevent race conditions
      */
@@ -16,6 +18,15 @@ export declare class ConversationMemoryManager {
      * 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
@@ -40,16 +51,8 @@ export declare class ConversationMemoryManager {
      * Now consistently async to match Redis implementation
      */
     buildContextMessages(sessionId: string): Promise<ChatMessage[]>;
-    getSession(sessionId: string): SessionMemory | undefined;
+    getSession(sessionId: string, _userId?: string): SessionMemory | undefined;
     createSummarySystemMessage(content: string, summarizesFrom?: string, summarizesTo?: string): ChatMessage;
-    /**
-     * Token-based summarization (pointer-based, non-destructive)
-     */
-    private summarizeSessionTokenBased;
-    /**
-     * Find split index to keep recent messages within target token count
-     */
-    private findSplitIndexByTokens;
     private ensureInitialized;
     private createNewSession;
     private enforceSessionLimit;