@juspay/neurolink 9.87.4 → 9.88.0

package/dist/neurolink.js

@@ -10504,6 +10504,139 @@ Current user's request: ${currentInput}`;
         this.lastCompactionMessageCount.clear();
         await this.conversationMemory.clearAllSessions();
     }
+    /**
+     * List all conversation sessions with metadata (public API)
+     * @param userId - Optional user ID to filter sessions (required for Redis storage)
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        // First ensure memory is initialized
+        const initId = `list-sessions-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        // Check if listSessions is available on the memory manager
+        if (!this.conversationMemory.listSessions) {
+            logger.warn("listSessions not available on current memory manager");
+            return [];
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const sessions = await withTimeout(this.conversationMemory.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            logger.debug("Listed conversation sessions", {
+                userId,
+                sessionCount: sessions.length,
+            });
+            return sessions;
+        }
+        catch (error) {
+            logger.error("Failed to list conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Export a single session with full history and metadata (public API)
+     * @param sessionId - The session ID to export
+     * @param options - Export options
+     * @returns Session export object with full history
+     */
+    async exportSession(sessionId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-session-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        if (!sessionId || typeof sessionId !== "string") {
+            throw new Error("Session ID must be a non-empty string");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        try {
+            const messages = await withTimeout(this.conversationMemory.buildContextMessages(sessionId), MEMORY_OPERATION_TIMEOUT, new Error("buildContextMessages operation timed out after 30s"));
+            if (messages.length === 0) {
+                logger.debug("No messages found for session export", { sessionId });
+                return null;
+            }
+            const sessionResult = this.conversationMemory.getSession(sessionId);
+            const session = await withTimeout(sessionResult instanceof Promise
+                ? sessionResult
+                : Promise.resolve(sessionResult), MEMORY_OPERATION_TIMEOUT, new Error("getSession operation timed out after 30s"));
+            const now = new Date().toISOString();
+            const exportData = {
+                sessionId,
+                title: sessionId, // Use sessionId as title if not available
+                userId: session?.userId,
+                createdAt: session?.createdAt
+                    ? new Date(session.createdAt).toISOString()
+                    : now,
+                updatedAt: session?.lastActivity
+                    ? new Date(session.lastActivity).toISOString()
+                    : now,
+                messages,
+            };
+            if (options.includeMetadata) {
+                exportData.exportMetadata = {
+                    exportedAt: now,
+                    exportFormat: options.format || "json",
+                };
+            }
+            logger.debug("Exported conversation session", {
+                sessionId,
+                messageCount: messages.length,
+            });
+            return exportData;
+        }
+        catch (error) {
+            logger.error("Failed to export conversation session", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Export all sessions for a user (public API)
+     * @param userId - Optional user ID (required for Redis storage)
+     * @param options - Export options
+     * @returns Array of session exports
+     */
+    async exportAllSessions(userId, options = {}) {
+        // First ensure memory is initialized
+        const initId = `export-all-init-${Date.now()}`;
+        await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        const MEMORY_OPERATION_TIMEOUT = 30000; // 30 seconds
+        const EXPORT_SESSION_TIMEOUT = 60000; // 60 seconds for full export
+        try {
+            // Get all session IDs
+            const sessions = await withTimeout(this.listSessions(userId), MEMORY_OPERATION_TIMEOUT, new Error("listSessions operation timed out after 30s"));
+            const exports = [];
+            for (const session of sessions) {
+                const exportData = await withTimeout(this.exportSession(session.id, options), EXPORT_SESSION_TIMEOUT, new Error(`exportSession operation timed out after 60s for session ${session.id}`));
+                if (exportData) {
+                    exports.push(exportData);
+                }
+            }
+            logger.debug("Exported all conversation sessions", {
+                userId,
+                sessionCount: exports.length,
+            });
+            return exports;
+        }
+        catch (error) {
+            logger.error("Failed to export all conversation sessions", {
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/types/conversation.d.ts

@@ -451,6 +451,42 @@ export type AgenticLoopReportMetadata = {
         endDate: string;
     };
 };
+/**
+ * Session list item for CLI/API listing
+ * Extends SessionMetadata with additional display information
+ */
+export type SessionListItem = SessionMetadata & {
+    /** User identifier associated with this session */
+    userId?: string;
+    /** Total number of messages in this session */
+    messageCount: number;
+    /** Human-readable time since last activity (e.g., "2 hours ago") */
+    lastActive?: string;
+};
+/**
+ * Complete session export format for backup/analytics
+ * Contains full session data including all messages
+ */
+export type SessionExport = {
+    /** Session identifier */
+    sessionId: string;
+    /** Session title/description */
+    title?: string;
+    /** User identifier */
+    userId?: string;
+    /** When session was created (ISO 8601) */
+    createdAt: string;
+    /** When session was last updated (ISO 8601) */
+    updatedAt: string;
+    /** Complete message history */
+    messages: ChatMessage[];
+    /** Export metadata */
+    exportMetadata?: {
+        exportedAt: string;
+        exportFormat: "json" | "csv";
+        neuroLinkVersion?: string;
+    };
+};
 /**
  * Base conversation metadata (shared fields across all conversation types)
  * Contains essential conversation information without heavy data arrays

package/dist/types/conversationMemoryInterface.d.ts

@@ -3,7 +3,7 @@
  * Both ConversationMemoryManager and RedisConversationMemoryManager
  * should implement this type.
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions } from "./conversation.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions } from "./conversation.js";
 /**
  * Common type for all conversation memory manager implementations.
  * Provides a consistent API for storing, retrieving, and managing conversation history.
@@ -24,6 +24,10 @@ export type IConversationMemoryManager = {
     clearAllSessions(): Promise<void> | void;
     /** Get memory statistics */
     getStats(): Promise<ConversationMemoryStats> | ConversationMemoryStats;
+    /** List all sessions with metadata (optional - for session management) */
+    listSessions?(userId?: string): Promise<SessionListItem[]>;
+    /** List all sessions with metadata (optional - for session management) */
+    listSessions?(userId?: string): Promise<SessionListItem[]>;
     /** Get raw messages array for a session (no context filtering or summarization) */
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */

package/dist/utils/fileDetector.js

@@ -1823,23 +1823,47 @@ class ExtensionStrategy {
         };
     }
     getExtension(input) {
-        if (this.isURL(input)) {
-            const url = new URL(input);
-            const match = url.pathname.match(/\.([^.]+)$/);
-            return match ? match[1] : null;
+        const normalizedInput = input.trim();
+        let extensionSource = normalizedInput;
+        if (this.isURL(normalizedInput)) {
+            try {
+                const url = new URL(normalizedInput);
+                extensionSource = url.pathname;
+                try {
+                    extensionSource = decodeURIComponent(extensionSource);
+                }
+                catch {
+                    // Keep the original pathname if the URL contains malformed escapes.
+                }
+            }
+            catch {
+                extensionSource = normalizedInput;
+            }
         }
-        const match = input.match(/\.([^.]+)$/);
-        return match ? match[1] : null;
+        const match = extensionSource.trim().match(/\.([^.]+)$/);
+        if (!match) {
+            return null;
+        }
+        const ext = match[1].split(/[?#]/)[0].toLowerCase();
+        return /^[a-z0-9]+$/.test(ext) ? ext : null;
     }
     isURL(str) {
-        return str.startsWith("http://") || str.startsWith("https://");
+        const normalized = str.trim();
+        return (normalized.startsWith("http://") || normalized.startsWith("https://"));
     }
     detectSource(input) {
-        if (input.startsWith("data:")) {
+        const normalized = input.trim();
+        if (normalized.startsWith("data:")) {
             return "datauri";
         }
-        if (this.isURL(input)) {
-            return "url";
+        if (this.isURL(normalized)) {
+            try {
+                new URL(normalized);
+                return "url";
+            }
+            catch {
+                return "path";
+            }
         }
         return "path";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.87.4",
+  "version": "9.88.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (58+ servers), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -114,6 +114,7 @@
     "test:dynamic": "npx tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "npx tsx test/continuous-test-suite-proxy.ts",
     "test:bugfixes": "npx tsx test/continuous-test-suite-bugfixes.ts",
+    "test:file-detector-extension": "npx tsx test/continuous-test-suite-file-detector-extension.ts",
     "test:json": "npx tsx test/continuous-test-suite-json.ts",
     "test:json-e2e": "npx tsx test/continuous-test-suite-json-e2e.ts",
     "test:workflow": "npx tsx test/continuous-test-suite-workflow.ts",
@@ -140,7 +141,7 @@
     "test:system-messages:vitest": "pnpm exec vitest run test/systemMessages.test.ts",
     "test:tool-routing-semantic:vitest": "pnpm exec vitest run test/toolRoutingSemantic.test.ts",
     "test:tool-routing-semantic": "pnpm run test:tool-routing-semantic:vitest && npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:system-messages:vitest && pnpm run test:tool-routing-semantic:vitest && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest && pnpm run test:tool-routing-cli:vitest && pnpm run test:tool-dedup:vitest && pnpm run test:model-pool:vitest && pnpm run test:system-messages:vitest && pnpm run test:tool-routing-semantic:vitest && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",