@juspay/neurolink 7.33.3 → 7.34.0

package/dist/utils/conversationMemory.js

@@ -0,0 +1,121 @@
+/**
+ * Conversation Memory Utilities
+ * Handles configuration merging and conversation memory operations
+ */
+import { getConversationMemoryDefaults } from "../config/conversationMemory.js";
+import { logger } from "./logger.js";
+/**
+ * Apply conversation memory defaults to user configuration
+ * Merges user config with environment variables and default values
+ */
+export function applyConversationMemoryDefaults(userConfig) {
+    const defaults = getConversationMemoryDefaults();
+    return {
+        ...defaults,
+        ...userConfig,
+    };
+}
+/**
+ * Get conversation history as message array, summarizing if needed.
+ */
+export async function getConversationMessages(conversationMemory, options) {
+    if (!conversationMemory || !options.context) {
+        logger.warn("[conversationMemoryUtils] No memory or context, returning empty messages");
+        return [];
+    }
+    const sessionId = options.context?.sessionId;
+    if (typeof sessionId !== "string" || !sessionId) {
+        logger.warn("[conversationMemoryUtils] Invalid or missing sessionId in context", {
+            sessionIdType: typeof sessionId,
+            sessionIdValue: sessionId,
+        });
+        return [];
+    }
+    try {
+        // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
+        const messages = await conversationMemory.buildContextMessages(sessionId);
+        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 [];
+    }
+}
+/**
+ * Store conversation turn for future context
+ * Saves user messages and AI responses for conversation memory
+ */
+export async function storeConversationTurn(conversationMemory, originalOptions, result) {
+    logger.debug("[conversationMemoryUtils] storeConversationTurn called", {
+        hasMemory: !!conversationMemory,
+        memoryType: conversationMemory?.constructor?.name || "NONE",
+        hasContext: !!originalOptions.context,
+        hasResult: !!result,
+        resultContentLength: result?.content?.length || 0,
+    });
+    if (!conversationMemory || !originalOptions.context) {
+        logger.debug("[conversationMemoryUtils] No memory or context, skipping conversation storage");
+        return;
+    }
+    const context = originalOptions.context;
+    const sessionId = context.sessionId;
+    const userId = typeof context.userId === "string" ? context.userId : undefined;
+    logger.debug("[conversationMemoryUtils] Extracted session details from context", {
+        sessionId,
+        userId,
+        contextKeys: Object.keys(context),
+        hasValidSessionId: typeof sessionId === "string" && !!sessionId,
+    });
+    if (typeof sessionId !== "string" || !sessionId) {
+        logger.warn("[conversationMemoryUtils] Invalid or missing sessionId in context", {
+            sessionIdType: typeof sessionId,
+            sessionIdValue: sessionId,
+        });
+        return;
+    }
+    const userMessage = originalOptions.originalPrompt || originalOptions.prompt || "";
+    const aiResponse = result.content;
+    try {
+        await conversationMemory.storeConversationTurn(sessionId, userId, userMessage, aiResponse);
+        logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
+            sessionId,
+            userId,
+            memoryType: conversationMemory.constructor.name,
+            userMessageLength: userMessage.length,
+            aiResponseLength: aiResponse.length,
+        });
+    }
+    catch (error) {
+        logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
+            sessionId,
+            userId,
+            memoryType: conversationMemory.constructor.name,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+    }
+}

package/dist/utils/conversationMemoryUtils.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import type { ConversationMemoryConfig, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig, ChatMessage } from "../types/conversation.js";
 import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
 import type { TextGenerationOptions, TextGenerationResult } from "../types/index.js";
 /**

package/dist/utils/conversationMemoryUtils.js

@@ -2,7 +2,7 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import { getConversationMemoryDefaults } from "../config/conversationMemoryConfig.js";
+import { getConversationMemoryDefaults } from "../config/conversationMemory.js";
 import { logger } from "./logger.js";
 /**
  * Apply conversation memory defaults to user configuration
@@ -28,7 +28,7 @@ export async function getConversationMessages(conversationMemory, options) {
     }
     try {
         // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = conversationMemory.buildContextMessages(sessionId);
+        const messages = await conversationMemory.buildContextMessages(sessionId);
         logger.debug("Conversation messages retrieved", {
             sessionId,
             messageCount: messages.length,

package/dist/utils/messageBuilder.d.ts

@@ -2,7 +2,7 @@
  * Message Builder Utility
  * Centralized logic for building message arrays from TextGenerationOptions
  */
-import type { ChatMessage } from "../types/conversationTypes.js";
+import type { ChatMessage } from "../types/conversation.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 /**

package/dist/utils/messageBuilder.js

@@ -2,7 +2,7 @@
  * Message Builder Utility
  * Centralized logic for building message arrays from TextGenerationOptions
  */
-import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemoryConfig.js";
+import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemory.js";
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt

package/dist/utils/providerHealth.js

@@ -639,9 +639,13 @@ export class ProviderHealthChecker {
             healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
             healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
         }
-        if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
-            healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
-            healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
+        // Check for deployment name using the SAME logic as the Azure provider
+        const deploymentName = process.env.AZURE_OPENAI_MODEL ||
+            process.env.AZURE_OPENAI_DEPLOYMENT ||
+            process.env.AZURE_OPENAI_DEPLOYMENT_ID;
+        if (!deploymentName) {
+            healthStatus.configurationIssues.push("No Azure deployment specified");
+            healthStatus.recommendations.push("Set one of: AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, or AZURE_OPENAI_DEPLOYMENT_ID");
         }
     }
     /**

package/dist/utils/redis.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Redis Utilities for NeuroLink
+ * Helper functions for Redis storage operations
+ */
+import { createClient } from "redis";
+type RedisClient = ReturnType<typeof createClient>;
+import type { ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+/**
+ * Creates a Redis client with the provided configuration
+ */
+export declare function createRedisClient(config: Required<RedisStorageConfig>): Promise<RedisClient>;
+/**
+ * Generates a Redis key for session messages
+ */
+export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string): string;
+/**
+ * Serializes messages for Redis storage
+ */
+export declare function serializeMessages(messages: ChatMessage[]): string;
+/**
+ * Deserializes messages from Redis storage
+ */
+export declare function deserializeMessages(data: string | null): ChatMessage[];
+/**
+ * Checks if Redis client is healthy
+ */
+export declare function isRedisHealthy(client: RedisClient): Promise<boolean>;
+/**
+ * Scan Redis keys matching a pattern without blocking the server
+ * This is a non-blocking alternative to the KEYS command
+ *
+ * @param client Redis client
+ * @param pattern Pattern to match keys (e.g. "prefix:*")
+ * @param batchSize Number of keys to scan in each iteration (default: 100)
+ * @returns Array of keys matching the pattern
+ */
+export declare function scanKeys(client: RedisClient, pattern: string, batchSize?: number): Promise<string[]>;
+/**
+ * Get normalized Redis configuration with defaults
+ */
+export declare function getNormalizedConfig(config: RedisStorageConfig): Required<RedisStorageConfig>;
+export {};

package/dist/utils/redis.js

@@ -0,0 +1,263 @@
+/**
+ * Redis Utilities for NeuroLink
+ * Helper functions for Redis storage operations
+ */
+import { createClient } from "redis";
+import { logger } from "./logger.js";
+// Redis client type
+/**
+ * Creates a Redis client with the provided configuration
+ */
+export async function createRedisClient(config) {
+    const url = `redis://${config.host}:${config.port}/${config.db}`;
+    // Create client options
+    const clientOptions = {
+        url,
+        socket: {
+            connectTimeout: config.connectionOptions?.connectTimeout,
+            reconnectStrategy: (retries) => {
+                if (retries > (config.connectionOptions?.maxRetriesPerRequest || 3)) {
+                    logger.error("Redis connection retries exhausted");
+                    return new Error("Redis connection retries exhausted");
+                }
+                const delay = Math.min((config.connectionOptions?.retryDelayOnFailover || 100) *
+                    Math.pow(2, retries), 10000);
+                return delay;
+            },
+        },
+    };
+    if (config.password) {
+        clientOptions.password = config.password;
+    }
+    // Create client with secured options
+    const client = createClient(clientOptions);
+    client.on("error", (err) => {
+        const sanitizedMessage = err.message.replace(/redis:\/\/.*?@/g, "redis://[redacted]@");
+        logger.error("Redis client error", { error: sanitizedMessage });
+    });
+    client.on("connect", () => {
+        logger.debug("Redis client connected", {
+            host: config.host,
+            port: config.port,
+            db: config.db,
+        });
+    });
+    client.on("reconnecting", () => {
+        logger.debug("Redis client reconnecting");
+    });
+    if (!client.isOpen) {
+        await client.connect();
+    }
+    return client;
+}
+/**
+ * Generates a Redis key for session messages
+ */
+export function getSessionKey(config, sessionId) {
+    const key = `${config.keyPrefix}${sessionId}`;
+    logger.debug("[redisUtils] Generated session key", {
+        sessionId,
+        keyPrefix: config.keyPrefix,
+        fullKey: key,
+    });
+    return key;
+}
+/**
+ * Serializes messages for Redis storage
+ */
+export function serializeMessages(messages) {
+    try {
+        logger.debug("[redisUtils] Serializing messages", {
+            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,
+        });
+        const serialized = JSON.stringify(messages);
+        logger.debug("[redisUtils] Messages serialized successfully", {
+            serializedLength: serialized.length,
+            messageCount: messages.length,
+        });
+        return serialized;
+    }
+    catch (error) {
+        logger.error("[redisUtils] Failed to serialize messages", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+            messageCount: messages.length,
+        });
+        throw error;
+    }
+}
+/**
+ * Deserializes messages from Redis storage
+ */
+export function deserializeMessages(data) {
+    if (!data) {
+        logger.debug("[redisUtils] No data to deserialize, returning empty array");
+        return [];
+    }
+    try {
+        logger.debug("[redisUtils] Deserializing messages", {
+            dataLength: data.length,
+            dataPreview: data.substring(0, 100) + (data.length > 100 ? "..." : ""),
+        });
+        // Parse as unknown first, then validate before casting
+        const parsedData = JSON.parse(data);
+        // Check if the parsed data is an array
+        if (!Array.isArray(parsedData)) {
+            logger.warn("[redisUtils] Deserialized data is not an array", {
+                type: typeof parsedData,
+                preview: JSON.stringify(parsedData).substring(0, 100),
+            });
+            return [];
+        }
+        // Validate each item in the array has the correct ChatMessage structure
+        const isValid = parsedData.every((m) => typeof m === "object" &&
+            m !== null &&
+            "role" in m &&
+            "content" in m &&
+            typeof m.role === "string" &&
+            typeof m.content === "string" &&
+            (m.role === "user" || m.role === "assistant" || m.role === "system"));
+        if (!isValid) {
+            logger.warn("[redisUtils] Deserialized data has unexpected structure", {
+                isArray: true,
+                firstItem: parsedData.length > 0 ? JSON.stringify(parsedData[0]) : null,
+            });
+            return [];
+        }
+        // Now that we've validated, we can safely cast
+        const messages = parsedData;
+        logger.debug("[redisUtils] Messages deserialized successfully", {
+            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,
+        });
+        logger.debug("[deserializeMessages] completed");
+        return messages;
+    }
+    catch (error) {
+        logger.error("[redisUtils] Failed to deserialize messages", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+            dataLength: data.length,
+            dataPreview: "[REDACTED]", // Prevent exposure of potentially sensitive data
+        });
+        return [];
+    }
+}
+/**
+ * Checks if Redis client is healthy
+ */
+export async function isRedisHealthy(client) {
+    try {
+        const pong = await client.ping();
+        return pong === "PONG";
+    }
+    catch (error) {
+        logger.error("Redis health check failed", { error });
+        return false;
+    }
+}
+/**
+ * Scan Redis keys matching a pattern without blocking the server
+ * This is a non-blocking alternative to the KEYS command
+ *
+ * @param client Redis client
+ * @param pattern Pattern to match keys (e.g. "prefix:*")
+ * @param batchSize Number of keys to scan in each iteration (default: 100)
+ * @returns Array of keys matching the pattern
+ */
+export async function scanKeys(client, pattern, batchSize = 100) {
+    logger.debug("[redisUtils] Starting SCAN operation", {
+        pattern,
+        batchSize,
+    });
+    const allKeys = [];
+    let cursor = "0";
+    let iterations = 0;
+    let totalScanned = 0;
+    try {
+        do {
+            iterations++;
+            // Use SCAN instead of KEYS to avoid blocking the server
+            const result = await client.scan(cursor, {
+                MATCH: pattern,
+                COUNT: batchSize,
+            });
+            // Extract cursor and keys from result
+            cursor = result.cursor;
+            const keys = result.keys || [];
+            // Add keys to result array
+            allKeys.push(...keys);
+            totalScanned += keys.length;
+            logger.debug("[redisUtils] SCAN iteration completed", {
+                iteration: iterations,
+                currentCursor: cursor,
+                keysInBatch: keys.length,
+                totalKeysFound: allKeys.length,
+            });
+        } while (cursor !== "0"); // Continue until cursor is 0
+        logger.info("[redisUtils] SCAN operation completed", {
+            pattern,
+            totalIterations: iterations,
+            totalKeysFound: allKeys.length,
+            totalScanned,
+        });
+        return allKeys;
+    }
+    catch (error) {
+        logger.error("[redisUtils] Error during SCAN operation", {
+            pattern,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        throw error;
+    }
+}
+/**
+ * Get normalized Redis configuration with defaults
+ */
+export function getNormalizedConfig(config) {
+    return {
+        host: config.host || "localhost",
+        port: config.port || 6379,
+        password: config.password || "",
+        db: config.db || 0,
+        keyPrefix: config.keyPrefix || "neurolink:conversation:",
+        ttl: config.ttl || 86400,
+        connectionOptions: {
+            connectTimeout: 30000,
+            lazyConnect: true,
+            retryDelayOnFailover: 100,
+            maxRetriesPerRequest: 3,
+            ...config.connectionOptions,
+        },
+    };
+}

package/dist/utils/tokenLimits.d.ts

@@ -6,13 +6,13 @@ import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 /**
  * Get the safe maximum tokens for a provider and model
  */
-export declare function getSafeMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, requestedMaxTokens?: number): number;
+export declare function getSafeMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, requestedMaxTokens?: number): number | undefined;
 /**
  * Validate if maxTokens is safe for a provider/model combination
  */
 export declare function validateMaxTokens(provider: keyof typeof PROVIDER_MAX_TOKENS | string, model?: string, maxTokens?: number): {
     isValid: boolean;
-    recommendedMaxTokens: number;
+    recommendedMaxTokens?: number;
     warning?: string;
 };
 /**

package/dist/utils/tokenLimits.js

@@ -2,7 +2,7 @@
  * Provider-specific token limit utilities
  * Provides safe maxTokens values based on provider and model capabilities
  */
-import { PROVIDER_MAX_TOKENS, DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 import { logger } from "./logger.js";
 /**
  * Get the safe maximum tokens for a provider and model
@@ -11,8 +11,8 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
     // Get provider-specific limits
     const providerLimits = PROVIDER_MAX_TOKENS[provider];
     if (!providerLimits) {
-        logger.warn(`Unknown provider ${provider}, using default maxTokens limit`);
-        return Math.min(requestedMaxTokens || DEFAULT_MAX_TOKENS, PROVIDER_MAX_TOKENS.default);
+        logger.warn(`Unknown provider ${provider}, no token limits enforced`);
+        return requestedMaxTokens || undefined; // No default limit for unknown providers
     }
     // Get model-specific limit or provider default
     let maxLimit;
@@ -54,6 +54,13 @@ export function validateMaxTokens(provider, model, maxTokens) {
             recommendedMaxTokens: safeMaxTokens,
         };
     }
+    // If no limits are defined, validation always passes
+    if (safeMaxTokens === undefined) {
+        return {
+            isValid: true,
+            recommendedMaxTokens: maxTokens,
+        };
+    }
     const isValid = maxTokens <= safeMaxTokens;
     return {
         isValid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.33.3",
+  "version": "7.34.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -175,10 +175,12 @@
     "dotenv": "^16.5.0",
     "inquirer": "^9.2.15",
     "mathjs": "^14.5.3",
+    "nanoid": "^5.1.5",
     "ollama-ai-provider": "^1.2.0",
     "ora": "^7.0.1",
     "p-limit": "^6.2.0",
     "reconnecting-eventsource": "^1.6.4",
+    "redis": "^5.8.2",
     "undici": "^6.6.2",
     "uuid": "^11.1.0",
     "ws": "^8.18.3",