@juspay/neurolink 9.87.4 → 9.88.1

package/dist/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/agent/directTools.d.ts

@@ -56,6 +56,12 @@ export declare const directAgentTools: {
         path: string;
         includeHidden: boolean;
     }, {
+        success: boolean;
+        error: string;
+        path?: undefined;
+        items?: undefined;
+        count?: undefined;
+    } | {
         success: boolean;
         path: string;
         items: {

package/dist/lib/agent/directTools.js

@@ -14,6 +14,28 @@ function truncateOutput(output) {
     }
     return output;
 }
+/**
+ * Contain a built-in file tool to the process working directory.
+ *
+ * Returns the resolved absolute path when it lies inside `process.cwd()`, or an
+ * `error` string otherwise. This is the sandbox for the default-enabled
+ * `readFile` / `writeFile` / `listDirectory` / `analyzeCSV` tools: without it an
+ * agent can pass an absolute path (`/etc/passwd`) or `../` traversal and reach
+ * arbitrary files. The previous guard (`!resolvedPath.startsWith(cwd) &&
+ * !path.isAbsolute(filePath)`) was always false for absolute paths, so it never
+ * fired. The `cwd + path.sep` suffix prevents a sibling-prefix bypass
+ * (`/home/app` vs `/home/app-evil`).
+ */
+function resolveWithinCwd(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const cwd = path.resolve(process.cwd());
+    if (resolvedPath !== cwd && !resolvedPath.startsWith(cwd + path.sep)) {
+        return {
+            error: `Access denied: "${filePath}" resolves outside the working directory`,
+        };
+    }
+    return { path: resolvedPath };
+}
 // Runtime Google Search tool creation - bypasses TypeScript strict typing
 function createGoogleSearchTools() {
     const searchTool = {};
@@ -71,15 +93,13 @@ export const directAgentTools = {
         }),
         execute: async ({ path: filePath }) => {
             try {
-                // Security check - prevent reading outside current directory for relative paths
-                const resolvedPath = path.resolve(filePath);
-                const cwd = process.cwd();
-                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
-                    return {
-                        success: false,
-                        error: `Access denied: Cannot read files outside current directory`,
-                    };
+                // Sandbox: contain reads to the working directory (blocks absolute-path
+                // escape and ../ traversal).
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
                 }
+                const resolvedPath = guard.path;
                 const content = fs.readFileSync(resolvedPath, "utf-8");
                 const stats = fs.statSync(resolvedPath);
                 return {
@@ -113,7 +133,12 @@ export const directAgentTools = {
         }),
         execute: async ({ path: dirPath, includeHidden }) => {
             try {
-                const resolvedPath = path.resolve(dirPath);
+                // Sandbox: contain directory listing to the working directory.
+                const guard = resolveWithinCwd(dirPath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
+                }
+                const resolvedPath = guard.path;
                 const items = fs.readdirSync(resolvedPath);
                 const filteredItems = includeHidden
                     ? items
@@ -229,15 +254,13 @@ export const directAgentTools = {
         }),
         execute: async ({ path: filePath, content, mode }) => {
             try {
-                const resolvedPath = path.resolve(filePath);
-                const cwd = process.cwd();
-                // Security check
-                if (!resolvedPath.startsWith(cwd) && !path.isAbsolute(filePath)) {
-                    return {
-                        success: false,
-                        error: `Access denied: Cannot write files outside current directory`,
-                    };
+                // Sandbox: contain writes to the working directory (blocks absolute-path
+                // escape and ../ traversal).
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
                 }
+                const resolvedPath = guard.path;
                 // Check if file exists for create mode
                 if (mode === "create" && fs.existsSync(resolvedPath)) {
                     return {
@@ -326,11 +349,12 @@ export const directAgentTools = {
             try {
                 // Resolve file path
                 logger.debug(`[analyzeCSV] Resolving file: ${filePath}`);
-                const path = await import("path");
-                // Resolve path (support both relative and absolute)
-                const resolvedPath = path.isAbsolute(filePath)
-                    ? filePath
-                    : path.resolve(process.cwd(), filePath);
+                // Sandbox: contain CSV reads to the working directory.
+                const guard = resolveWithinCwd(filePath);
+                if ("error" in guard) {
+                    return { success: false, error: guard.error };
+                }
+                const resolvedPath = guard.path;
                 logger.debug(`[analyzeCSV] Resolved path: ${resolvedPath}`);
                 // Parse CSV using streaming from disk (memory efficient)
                 logger.info(`[analyzeCSV] Starting CSV parsing (max ${maxRows} rows)...`);

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

@@ -2,7 +2,7 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
 export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
@@ -56,6 +56,16 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
     private createNewSession;
     private enforceSessionLimit;
     getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     clearSession(sessionId: string): Promise<boolean>;
     clearAllSessions(): Promise<void>;
     /**

package/dist/lib/core/conversationMemoryManager.js

@@ -292,6 +292,50 @@ export class ConversationMemoryManager {
             totalTurns,
         };
     }
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const now = Date.now();
+        return sessions
+            .filter((session) => !userId || session.userId === userId)
+            .map((session) => {
+            const lastActive = this.formatTimeAgo(now - session.lastActivity);
+            return {
+                id: session.sessionId,
+                title: session.sessionId, // In-memory doesn't store title, use sessionId
+                createdAt: new Date(session.createdAt).toISOString(),
+                updatedAt: new Date(session.lastActivity).toISOString(),
+                userId: session.userId,
+                messageCount: session.messages.length,
+                lastActive,
+            };
+        })
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     async clearSession(sessionId) {
         return withSpan({
             name: "neurolink.memory.clear",

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

@@ -2,7 +2,7 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionListItem, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -175,6 +175,17 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * @returns Array of session metadata objects
      */
     getUserAllSessionsHistory(userId: string): Promise<SessionMetadata[]>;
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/core/redisConversationMemoryManager.js

@@ -1271,6 +1271,86 @@ User message: "${userMessage}"`;
             return results;
         }
     }
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        const now = Date.now();
+        const list = [];
+        if (userId) {
+            // List sessions for a specific user
+            const sessionIds = await this.getUserSessions(userId);
+            for (const sessionId of sessionIds) {
+                const session = await this.getUserSessionObject(userId, sessionId);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        else {
+            // List all sessions across all users by scanning Redis keys
+            const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
+            for (const key of keys) {
+                // Skip user session index keys (they end with :sessions)
+                if (key.endsWith(":sessions")) {
+                    continue;
+                }
+                const raw = await this.redisClient.get(key);
+                if (!raw) {
+                    continue;
+                }
+                const session = deserializeConversation(raw);
+                if (!session) {
+                    continue;
+                }
+                list.push({
+                    id: session.sessionId,
+                    title: session.title || session.sessionId,
+                    createdAt: session.createdAt,
+                    updatedAt: session.updatedAt,
+                    userId: session.userId,
+                    messageCount: session.messages.length,
+                    lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
+                });
+            }
+        }
+        return list.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks

package/dist/lib/neurolink.d.ts

@@ -14,6 +14,7 @@ import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { DynamicOptions } from "./types/index.js";
 import { SkillsManager } from "./skills/skillsManager.js";
 import { TaskManager } from "./tasks/taskManager.js";
+import type { SessionExport, SessionListItem } from "./types/index.js";
 /**
  * Curator P2-4 dedup (concurrency-safe): native providers emit
  * `generation:end` on the shared SDK emitter. We attach a fresh
@@ -1631,6 +1632,32 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * 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
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * 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
+     */
+    exportSession(sessionId: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport | 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
+     */
+    exportAllSessions(userId?: string, options?: {
+        includeMetadata?: boolean;
+        format?: "json" | "csv";
+    }): Promise<SessionExport[]>;
     /**
      * Store tool executions in conversation memory if enabled and Redis is configured
      * @param sessionId - Session identifier

package/dist/lib/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/lib/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/lib/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 */