@juspay/neurolink 9.5.3 → 9.7.0

package/dist/utils/conversationMemory.js

@@ -2,10 +2,11 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import { getConversationMemoryDefaults, MEMORY_THRESHOLD_PERCENTAGE, DEFAULT_FALLBACK_THRESHOLD, } from "../config/conversationMemory.js";
-import { TokenUtils } from "../constants/tokens.js";
-import { logger } from "./logger.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";
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values
@@ -103,7 +104,22 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
     }
     const userMessage = originalOptions.originalPrompt || originalOptions.prompt || "";
     const aiResponse = result.content ?? "";
-    let providerDetails = undefined;
+    // Guard: skip storing conversation turn if AI response is empty AND no tools were used.
+    // Empty assistant messages cause "text content blocks must be non-empty" errors
+    // when loaded as conversation history on the next interaction.
+    // However, tool-only turns (empty text but tools were invoked) must still be stored
+    // to preserve tool-calling conversation history.
+    const hasToolActivity = (result.toolsUsed && result.toolsUsed.length > 0) ||
+        (result.toolExecutions && result.toolExecutions.length > 0);
+    if (!aiResponse.trim() && !hasToolActivity) {
+        logger.warn("[conversationMemoryUtils] Skipping conversation turn storage — AI response is empty and no tool activity", {
+            sessionId,
+            userId,
+            userMessageLength: userMessage.length,
+        });
+        return;
+    }
+    let providerDetails;
     if (result.provider && result.model) {
         providerDetails = {
             provider: result.provider,
@@ -119,6 +135,15 @@ export async function storeConversationTurn(conversationMemory, originalOptions,
             startTimeStamp,
             providerDetails,
             enableSummarization: originalOptions.enableSummarization,
+            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", {
             sessionId,
@@ -189,49 +214,34 @@ export function createSummarizationPrompt(history, previousSummary) {
     const formattedHistory = history
         .map((msg) => `${msg.role}: ${msg.content}`)
         .join("\n\n");
-    const previousSummarySection = previousSummary
-        ? `Previous Summary:
----
-${previousSummary}
----
-
-`
-        : "";
-    return `
-You are a context summarization AI. Your task is to condense the following conversation history for another AI assistant.
-${previousSummary ? "Build upon the previous summary and incorporate the new conversation turns below." : ""}
-The summary must be a concise, third-person narrative that retains all critical information, including key entities, technical details, decisions made, and any specific dates or times mentioned.
-Ensure the summary flows logically and is ready to be used as context for the next turn in the conversation.
+    const structuredPrompt = buildSummarizationPrompt({
+        isIncremental: !!previousSummary,
+        previousSummary,
+    });
+    return `${structuredPrompt}
 
-${previousSummarySection}Conversation History to Summarize:
+Conversation History to Summarize:
 ---
 ${formattedHistory}
----
-`.trim();
+---`;
 }
 /**
- * Calculate token threshold based on model's output token limit
- * Uses existing provider token limits as proxy for context window
+ * Calculate token threshold based on model's context window and available input tokens
+ * Uses context window registry for accurate per-provider, per-model limits
  * @param provider - AI provider name
  * @param model - Model name
- * @returns Token threshold (80% of model's token limit)
+ * @param maxTokens - Optional explicit maxTokens for output reserve calculation
+ * @returns Token threshold (80% of available input tokens)
  */
-export function calculateTokenThreshold(provider, model) {
-    try {
-        // Get model's token limit from existing TokenUtils
-        const modelTokenLimit = TokenUtils.getProviderTokenLimit(provider, model);
-        // Return 80% of token limit for conversation memory
-        // This is conservative since output limits are typically smaller than input limits
-        return Math.floor(modelTokenLimit * MEMORY_THRESHOLD_PERCENTAGE);
+export function calculateTokenThreshold(provider, model, maxTokens) {
+    if (!provider) {
+        return DEFAULT_FALLBACK_THRESHOLD;
     }
-    catch (error) {
-        logger.warn("Failed to calculate model threshold, using fallback", {
-            provider,
-            model,
-            error: error instanceof Error ? error.message : String(error),
-        });
+    const availableInput = getAvailableInputTokens(provider, model, maxTokens);
+    if (availableInput <= 0) {
         return DEFAULT_FALLBACK_THRESHOLD;
     }
+    return Math.floor(availableInput * MEMORY_THRESHOLD_PERCENTAGE);
 }
 /**
  * Get effective token threshold for a session
@@ -297,3 +307,48 @@ export async function generateSummary(messages, config, logPrefix = "[Conversati
         return null;
     }
 }
+/**
+ * Check if Redis is available for conversation memory.
+ * Migrated from the deprecated conversationMemoryUtils.ts.
+ */
+export async function checkRedisAvailability() {
+    const { createRedisClient, getNormalizedConfig } = await import("./redis.js");
+    let testClient = null;
+    try {
+        const testConfig = getNormalizedConfig({
+            host: process.env.REDIS_HOST,
+            port: process.env.REDIS_PORT ? Number(process.env.REDIS_PORT) : undefined,
+            password: process.env.REDIS_PASSWORD,
+            db: process.env.REDIS_DB ? Number(process.env.REDIS_DB) : undefined,
+            keyPrefix: process.env.REDIS_KEY_PREFIX,
+            ttl: process.env.REDIS_TTL ? Number(process.env.REDIS_TTL) : undefined,
+            connectionOptions: {
+                connectTimeout: 5000,
+                maxRetriesPerRequest: 1,
+                retryDelayOnFailover: 100,
+            },
+        });
+        testClient = await createRedisClient(testConfig);
+        await testClient.ping();
+        logger.debug("Redis connection test successful");
+        return true;
+    }
+    catch (error) {
+        logger.debug("Redis connection test failed", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+    finally {
+        if (testClient) {
+            try {
+                await testClient.quit();
+            }
+            catch (quitError) {
+                logger.debug("Error during Redis test client disconnect", {
+                    error: quitError instanceof Error ? quitError.message : String(quitError),
+                });
+            }
+        }
+    }
+}

package/dist/utils/errorHandling.d.ts

@@ -244,6 +244,11 @@ export declare class CircuitBreaker {
     getState(): "closed" | "open" | "half-open";
     getFailureCount(): number;
 }
+/**
+ * Detect AbortError from any source (DOMException, plain Error, or message-based).
+ * Used to short-circuit retry/fallback loops when an abort signal fires.
+ */
+export declare function isAbortError(error: unknown): boolean;
 /**
  * Error handler that decides whether to retry based on error type
  */

package/dist/utils/errorHandling.js

@@ -820,6 +820,25 @@ export class CircuitBreaker {
         return this.failures;
     }
 }
+/**
+ * Detect AbortError from any source (DOMException, plain Error, or message-based).
+ * Used to short-circuit retry/fallback loops when an abort signal fires.
+ */
+export function isAbortError(error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+        return true;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return true;
+    }
+    if (error instanceof Error &&
+        (error.message === "This operation was aborted" ||
+            error.message === "The operation was aborted" ||
+            error.message?.includes("The user aborted a request"))) {
+        return true;
+    }
+    return false;
+}
 /**
  * Error handler that decides whether to retry based on error type
  */

package/dist/utils/fileDetector.d.ts

@@ -65,10 +65,72 @@ export declare class FileDetector {
      * Load file content from various sources
      */
     private static loadContent;
+    /**
+     * SDK-8: Format an informative placeholder when a file processor fails.
+     * Instead of bare "[Video file: name]" strings, include size, format, and
+     * the reason for failure so the LLM can acknowledge the attachment.
+     */
+    private static formatInformativePlaceholder;
+    /**
+     * Extract metadata and printable strings from an unrecognized binary file.
+     * This is the "extract what you can" path for unknown file types.
+     *
+     * Extracts:
+     * - File size (human-readable)
+     * - MIME type / detected format
+     * - First N bytes as hex dump (for identification)
+     * - Printable ASCII/UTF-8 strings found in the binary (like `strings` command)
+     * - Known file signatures that we don't have full processors for
+     *
+     * @param content  Raw file buffer
+     * @param detection  Detection result (may be "unknown")
+     * @param filename  Original filename (if known)
+     * @returns Formatted text summary suitable for LLM consumption
+     */
+    private static extractBinaryMetadata;
+    /**
+     * Identify known binary file signatures beyond what we can process.
+     * Returns a human-readable description, or null if unrecognized.
+     */
+    private static identifyBinarySignature;
+    /**
+     * Extract printable ASCII strings from a binary buffer.
+     * Similar to the Unix `strings` utility.
+     *
+     * @param buf        Buffer to scan
+     * @param minLength  Minimum string length to include (default 4)
+     * @param maxStrings Maximum number of strings to return (default 50)
+     * @returns Array of printable strings found in the binary
+     */
+    private static extractPrintableStrings;
     /**
      * Route to appropriate processor
      */
     private static processFile;
+    /**
+     * Process video file: extract metadata, keyframes, and subtitles via VideoProcessor
+     */
+    private static processVideoFile;
+    /**
+     * Process audio file: extract metadata, tags, and cover art via AudioProcessor
+     */
+    private static processAudioFile;
+    /**
+     * Process archive file: list contents and extract metadata via ArchiveProcessor
+     */
+    private static processArchiveFile;
+    /**
+     * Process Excel/OpenDocument spreadsheet file via ExcelProcessor or OpenDocumentProcessor
+     */
+    private static processXlsxFile;
+    /**
+     * Process Word/OpenDocument/RTF document via WordProcessor, OpenDocumentProcessor, or RtfProcessor
+     */
+    private static processDocxFile;
+    /**
+     * Process PowerPoint/OpenDocument presentation via PptxProcessor
+     */
+    private static processPptxFile;
     /**
      * Process SVG file as text content
      * Uses SvgProcessor for security sanitization (removes XSS vectors)