@juspay/neurolink 7.37.1 → 7.38.0

package/dist/utils/messageBuilder.js

@@ -8,6 +8,21 @@ import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerIma
 import { logger } from "./logger.js";
 import { request } from "undici";
 import { readFileSync, existsSync } from "fs";
+/**
+ * Convert ChatMessage to CoreMessage for AI SDK compatibility
+ */
+function toCoreMessage(message) {
+    // Only include messages with roles supported by AI SDK
+    if (message.role === "user" ||
+        message.role === "assistant" ||
+        message.role === "system") {
+        return {
+            role: message.role,
+            content: message.content,
+        };
+    }
+    return null; // Filter out tool_call and tool_result messages
+}
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
@@ -31,8 +46,14 @@ export function buildMessagesArray(options) {
         });
     }
     // Add conversation history if available
+    // Convert ChatMessages to CoreMessages and filter out tool messages
     if (hasConversationHistory && options.conversationMessages) {
-        messages.push(...options.conversationMessages);
+        for (const chatMessage of options.conversationMessages) {
+            const coreMessage = toCoreMessage(chatMessage);
+            if (coreMessage) {
+                messages.push(coreMessage);
+            }
+        }
     }
     // Add current user prompt (required)
     // Handle both TextGenerationOptions (prompt field) and StreamOptions (input.text field)

package/dist/utils/redis.d.ts

@@ -4,7 +4,7 @@
  */
 import { createClient } from "redis";
 type RedisClient = ReturnType<typeof createClient>;
-import type { ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+import type { RedisStorageConfig, RedisConversationObject } from "../types/conversation.js";
 /**
  * Creates a Redis client with the provided configuration
  */
@@ -12,15 +12,19 @@ export declare function createRedisClient(config: Required<RedisStorageConfig>):
 /**
  * Generates a Redis key for session messages
  */
-export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string): string;
+export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string, userId?: string): string;
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export declare function serializeMessages(messages: ChatMessage[]): string;
+export declare function getUserSessionsKey(config: Required<RedisStorageConfig>, userId: string): string;
 /**
- * Deserializes messages from Redis storage
+ * Serializes conversation object for Redis storage
  */
-export declare function deserializeMessages(data: string | null): ChatMessage[];
+export declare function serializeConversation(conversation: RedisConversationObject): string;
+/**
+ * Deserializes conversation object from Redis storage
+ */
+export declare function deserializeConversation(data: string | null): RedisConversationObject | null;
 /**
  * Checks if Redis client is healthy
  */

package/dist/utils/redis.js

@@ -53,123 +53,120 @@ export async function createRedisClient(config) {
 /**
  * Generates a Redis key for session messages
  */
-export function getSessionKey(config, sessionId) {
-    const key = `${config.keyPrefix}${sessionId}`;
+export function getSessionKey(config, sessionId, userId) {
+    const key = `${config.keyPrefix}${userId || "randomUser"}:${sessionId}`;
     logger.debug("[redisUtils] Generated session key", {
         sessionId,
+        userId,
         keyPrefix: config.keyPrefix,
         fullKey: key,
     });
     return key;
 }
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export function serializeMessages(messages) {
+export function getUserSessionsKey(config, userId) {
+    return `${config.userSessionsKeyPrefix}${userId}`;
+}
+/**
+ * Serializes conversation object for Redis storage
+ */
+export function serializeConversation(conversation) {
     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,
-        });
+        const serialized = JSON.stringify(conversation);
         return serialized;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to serialize messages", {
+        logger.error("[redisUtils] Failed to serialize conversation", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
-            messageCount: messages.length,
+            sessionId: conversation?.sessionId,
+            userId: conversation?.userId,
         });
         throw error;
     }
 }
 /**
- * Deserializes messages from Redis storage
+ * Deserializes conversation object from Redis storage
  */
-export function deserializeMessages(data) {
+export function deserializeConversation(data) {
     if (!data) {
-        logger.debug("[redisUtils] No data to deserialize, returning empty array");
-        return [];
+        logger.debug("[redisUtils] No conversation data to deserialize, returning null");
+        return null;
     }
     try {
-        logger.debug("[redisUtils] Deserializing messages", {
+        logger.debug("[redisUtils] Deserializing conversation", {
             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", {
+        // Check if the parsed data is an object with required properties
+        if (typeof parsedData !== "object" ||
+            parsedData === null ||
+            !("title" in parsedData) ||
+            !("sessionId" in parsedData) ||
+            !("userId" in parsedData) ||
+            !("createdAt" in parsedData) ||
+            !("updatedAt" in parsedData) ||
+            !("messages" in parsedData)) {
+            logger.warn("[redisUtils] Deserialized data is not a valid conversation object", {
                 type: typeof parsedData,
+                hasRequiredFields: parsedData && typeof parsedData === "object"
+                    ? Object.keys(parsedData).join(", ")
+                    : "none",
                 preview: JSON.stringify(parsedData).substring(0, 100),
             });
-            return [];
+            return null;
+        }
+        const conversation = parsedData;
+        // Validate messages is an array
+        if (!Array.isArray(conversation.messages)) {
+            logger.warn("[redisUtils] messages is not an array", {
+                type: typeof conversation.messages,
+            });
+            return null;
         }
-        // Validate each item in the array has the correct ChatMessage structure
-        const isValid = parsedData.every((m) => typeof m === "object" &&
+        // Validate each message in the messages array
+        const isValidHistory = conversation.messages.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,
+            (m.role === "user" ||
+                m.role === "assistant" ||
+                m.role === "system" ||
+                m.role === "tool_call" ||
+                m.role === "tool_result"));
+        if (!isValidHistory) {
+            logger.warn("[redisUtils] Invalid messages structure", {
+                messageCount: conversation.messages.length,
+                firstMessage: conversation.messages.length > 0
+                    ? JSON.stringify(conversation.messages[0])
+                    : null,
             });
-            return [];
+            return null;
         }
-        // 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("[redisUtils] Conversation deserialized successfully", {
+            sessionId: conversation.sessionId,
+            userId: conversation.userId,
+            title: conversation.title,
+            messageCount: conversation.messages.length,
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
         });
-        logger.debug("[deserializeMessages] completed");
-        return messages;
+        return conversation;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to deserialize messages", {
+        logger.error("[redisUtils] Failed to deserialize conversation", {
             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 [];
+        return null;
     }
 }
 /**
@@ -245,12 +242,16 @@ export async function scanKeys(client, pattern, batchSize = 100) {
  * Get normalized Redis configuration with defaults
  */
 export function getNormalizedConfig(config) {
+    const keyPrefix = config.keyPrefix || "neurolink:conversation:";
+    // Intelligent default: derive user sessions prefix from conversation prefix
+    const defaultUserSessionsPrefix = keyPrefix.replace(/conversation:?$/, "user:sessions:");
     return {
         host: config.host || "localhost",
         port: config.port || 6379,
         password: config.password || "",
         db: config.db || 0,
-        keyPrefix: config.keyPrefix || "neurolink:conversation:",
+        keyPrefix,
+        userSessionsKeyPrefix: config.userSessionsKeyPrefix || defaultUserSessionsPrefix,
         ttl: config.ttl || 86400,
         connectionOptions: {
             connectTimeout: 30000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.37.1",
+  "version": "7.38.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",