@juspay/neurolink 7.11.0 → 7.12.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.12.0](https://github.com/juspay/neurolink/compare/v7.11.1...v7.12.0) (2025-08-14)
+
+### Features
+
+- **(memory):** Added support for Conversation History ([5cf3650](https://github.com/juspay/neurolink/commit/5cf36507ec12fca525df652c1c15acc8c1c71297))
+
+## [7.11.1](https://github.com/juspay/neurolink/compare/v7.11.0...v7.11.1) (2025-08-14)
+
+### Bug Fixes
+
+- **(ci):** add external contributor detection to GitHub Copilot PR Review workflow ([c7d9f2c](https://github.com/juspay/neurolink/commit/c7d9f2cf8d1d0079b34e443a935a84d4a53adf9a))
+
 ## [7.11.0](https://github.com/juspay/neurolink/compare/v7.10.3...v7.11.0) (2025-08-14)
 
 ### Features

package/README.md

@@ -162,6 +162,21 @@ console.log(result.content);
 console.log(`Used: ${result.provider}`);
 ```
 
+### Conversation Memory
+
+NeuroLink supports automatic conversation history management that maintains context across multiple turns within sessions. This enables AI to remember previous interactions and provide contextually aware responses. Session-based memory isolation ensures privacy between different conversations.
+
+```typescript
+// Enable conversation memory with configurable limits
+const neurolink = new NeuroLink({
+  conversationMemory: {
+    enabled: true,
+    maxSessions: 50, // Keep last 50 sessions
+    maxTurnsPerSession: 20, // Keep last 20 turns per session
+  },
+});
+```
+
 #### 🔗 CLI-SDK Consistency (NEW! ✨)
 
 Method aliases that match CLI command names:

package/dist/config/conversationMemoryConfig.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Conversation Memory Configuration
+ * Provides default values for conversation memory feature with environment variable support
+ */
+import type { ConversationMemoryConfig } from "../types/conversationTypes.js";
+/**
+ * Default maximum number of turns per session
+ */
+export declare const DEFAULT_MAX_TURNS_PER_SESSION = 50;
+/**
+ * Default maximum number of sessions
+ */
+export declare const DEFAULT_MAX_SESSIONS = 50;
+/**
+ * Number of messages per conversation turn (user + assistant)
+ */
+export declare const MESSAGES_PER_TURN = 2;
+/**
+ * Conversation instructions for ongoing conversations
+ * Used to enhance system prompts when conversation history exists
+ */
+export declare const CONVERSATION_INSTRUCTIONS = "\n\nIMPORTANT: You are continuing an ongoing conversation. The previous messages in this conversation contain important context including:\n- Names, personal information, and preferences shared by the user\n- Projects, tasks, and topics discussed previously  \n- Any decisions, agreements, or conclusions reached\n\nAlways reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.";
+/**
+ * Get default configuration values for conversation memory
+ * Reads environment variables when called (not at module load time)
+ */
+export declare function getConversationMemoryDefaults(): ConversationMemoryConfig;

package/dist/config/conversationMemoryConfig.js

@@ -0,0 +1,39 @@
+/**
+ * Conversation Memory Configuration
+ * Provides default values for conversation memory feature with environment variable support
+ */
+/**
+ * Default maximum number of turns per session
+ */
+export const DEFAULT_MAX_TURNS_PER_SESSION = 50;
+/**
+ * Default maximum number of sessions
+ */
+export const DEFAULT_MAX_SESSIONS = 50;
+/**
+ * Number of messages per conversation turn (user + assistant)
+ */
+export const MESSAGES_PER_TURN = 2;
+/**
+ * Conversation instructions for ongoing conversations
+ * Used to enhance system prompts when conversation history exists
+ */
+export const CONVERSATION_INSTRUCTIONS = `
+
+IMPORTANT: You are continuing an ongoing conversation. The previous messages in this conversation contain important context including:
+- Names, personal information, and preferences shared by the user
+- Projects, tasks, and topics discussed previously  
+- Any decisions, agreements, or conclusions reached
+
+Always reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.`;
+/**
+ * Get default configuration values for conversation memory
+ * Reads environment variables when called (not at module load time)
+ */
+export function getConversationMemoryDefaults() {
+    return {
+        enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
+        maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
+        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) || DEFAULT_MAX_TURNS_PER_SESSION,
+    };
+}

package/dist/core/baseProvider.js

@@ -4,6 +4,7 @@ import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 /**
  * Validates if a result contains a valid toolsObject structure
  * @param result - The result object to validate
@@ -162,10 +163,11 @@ export class BaseProvider {
             logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
             // EVERY provider uses Vercel AI SDK - no exceptions
             const model = await this.getAISDKModel(); // This method is now REQUIRED
+            // Build proper message array with conversation history
+            const messages = buildMessagesArray(options);
             const result = await generateText({
                 model,
-                prompt: options.prompt || options.input?.text || "",
-                system: options.systemPrompt,
+                messages: messages,
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",

package/dist/core/conversationMemoryManager.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Conversation Memory Manager for NeuroLink
+ * Handles in-memory conversation storage, session management, and context injection
+ */
+import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
+export declare class ConversationMemoryManager {
+    private sessions;
+    private config;
+    private isInitialized;
+    constructor(config: ConversationMemoryConfig);
+    /**
+     * Initialize the memory manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store a conversation turn for a session
+     * ULTRA-OPTIMIZED: Direct ChatMessage[] storage with zero conversion overhead
+     */
+    storeConversationTurn(sessionId: string, userId: string | undefined, userMessage: string, aiResponse: string): Promise<void>;
+    /**
+     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
+     * Returns pre-stored message array with zero conversion overhead
+     */
+    buildContextMessages(sessionId: string): ChatMessage[];
+    /**
+     * Get memory statistics (simplified for pure in-memory storage)
+     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
+     */
+    getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * Clear all conversations for a specific session
+     */
+    clearSession(sessionId: string): Promise<boolean>;
+    /**
+     * Clear all conversations (reset memory)
+     */
+    clearAllSessions(): Promise<void>;
+    private ensureInitialized;
+    private createNewSession;
+    private enforceSessionLimit;
+}

package/dist/core/conversationMemoryManager.js

@@ -0,0 +1,152 @@
+/**
+ * Conversation Memory Manager for NeuroLink
+ * Handles in-memory conversation storage, session management, and context injection
+ */
+import { ConversationMemoryError } from "../types/conversationTypes.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
+import { logger } from "../utils/logger.js";
+export class ConversationMemoryManager {
+    sessions = new Map();
+    config;
+    isInitialized = false;
+    constructor(config) {
+        // Trust that config is already complete from applyConversationMemoryDefaults()
+        this.config = config;
+    }
+    /**
+     * Initialize the memory manager
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        try {
+            this.isInitialized = true;
+            logger.info("ConversationMemoryManager initialized", {
+                storage: "in-memory",
+                maxSessions: this.config.maxSessions,
+                maxTurnsPerSession: this.config.maxTurnsPerSession,
+            });
+        }
+        catch (error) {
+            throw new ConversationMemoryError("Failed to initialize conversation memory", "CONFIG_ERROR", { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Store a conversation turn for a session
+     * ULTRA-OPTIMIZED: Direct ChatMessage[] storage with zero conversion overhead
+     */
+    async storeConversationTurn(sessionId, userId, userMessage, aiResponse) {
+        await this.ensureInitialized();
+        try {
+            // Get or create session
+            let session = this.sessions.get(sessionId);
+            if (!session) {
+                session = this.createNewSession(sessionId, userId);
+                this.sessions.set(sessionId, session);
+            }
+            // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
+            session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
+            session.lastActivity = Date.now();
+            // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
+            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+            if (session.messages.length > maxMessages) {
+                session.messages = session.messages.slice(-maxMessages);
+            }
+            // Enforce global session limit
+            this.enforceSessionLimit();
+            logger.debug("Conversation turn stored", {
+                sessionId,
+                messageCount: session.messages.length,
+                turnCount: session.messages.length / MESSAGES_PER_TURN, // Each turn = MESSAGES_PER_TURN messages
+                userMessageLength: userMessage.length,
+                aiResponseLength: aiResponse.length,
+            });
+        }
+        catch (error) {
+            throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
+     * Returns pre-stored message array with zero conversion overhead
+     */
+    buildContextMessages(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.messages.length === 0) {
+            return [];
+        }
+        // ULTRA-OPTIMIZED: Direct return - no processing needed!
+        return session.messages;
+    }
+    /**
+     * Get memory statistics (simplified for pure in-memory storage)
+     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
+     */
+    async getStats() {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+        return {
+            totalSessions: sessions.length,
+            totalTurns,
+        };
+    }
+    /**
+     * Clear all conversations for a specific session
+     */
+    async clearSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        // Remove from memory
+        this.sessions.delete(sessionId);
+        logger.info("Session cleared", { sessionId });
+        return true;
+    }
+    /**
+     * Clear all conversations (reset memory)
+     */
+    async clearAllSessions() {
+        const sessionIds = Array.from(this.sessions.keys());
+        // Clear memory
+        this.sessions.clear();
+        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
+    }
+    // Private methods
+    async ensureInitialized() {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+    }
+    createNewSession(sessionId, userId) {
+        return {
+            sessionId,
+            userId,
+            messages: [],
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+        };
+    }
+    enforceSessionLimit() {
+        const maxSessions = this.config.maxSessions || DEFAULT_MAX_SESSIONS;
+        if (this.sessions.size <= maxSessions) {
+            return;
+        }
+        // Sort sessions by last activity (oldest first)
+        const sessions = Array.from(this.sessions.entries()).sort(([, a], [, b]) => a.lastActivity - b.lastActivity);
+        // Remove oldest sessions
+        const sessionsToRemove = sessions.slice(0, sessions.length - maxSessions);
+        for (const [sessionId] of sessionsToRemove) {
+            this.sessions.delete(sessionId);
+        }
+        logger.debug("Session limit enforced", {
+            removedSessions: sessionsToRemove.length,
+            remainingSessions: this.sessions.size,
+        });
+    }
+}

package/dist/core/types.d.ts

@@ -3,6 +3,7 @@ import type { Schema, Tool } from "ai";
 import type { GenerateResult } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue } from "../types/common.js";
+import type { ChatMessage } from "../types/conversationTypes.js";
 export interface TextGenerationResult {
     content: string;
     provider?: string;
@@ -150,6 +151,7 @@ export interface TextGenerationOptions {
         role: string;
         content: string;
     }>;
+    conversationMessages?: ChatMessage[];
 }
 /**
  * Analytics data for usage tracking

package/dist/lib/config/conversationMemoryConfig.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Conversation Memory Configuration
+ * Provides default values for conversation memory feature with environment variable support
+ */
+import type { ConversationMemoryConfig } from "../types/conversationTypes.js";
+/**
+ * Default maximum number of turns per session
+ */
+export declare const DEFAULT_MAX_TURNS_PER_SESSION = 50;
+/**
+ * Default maximum number of sessions
+ */
+export declare const DEFAULT_MAX_SESSIONS = 50;
+/**
+ * Number of messages per conversation turn (user + assistant)
+ */
+export declare const MESSAGES_PER_TURN = 2;
+/**
+ * Conversation instructions for ongoing conversations
+ * Used to enhance system prompts when conversation history exists
+ */
+export declare const CONVERSATION_INSTRUCTIONS = "\n\nIMPORTANT: You are continuing an ongoing conversation. The previous messages in this conversation contain important context including:\n- Names, personal information, and preferences shared by the user\n- Projects, tasks, and topics discussed previously  \n- Any decisions, agreements, or conclusions reached\n\nAlways reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.";
+/**
+ * Get default configuration values for conversation memory
+ * Reads environment variables when called (not at module load time)
+ */
+export declare function getConversationMemoryDefaults(): ConversationMemoryConfig;

package/dist/lib/config/conversationMemoryConfig.js

@@ -0,0 +1,39 @@
+/**
+ * Conversation Memory Configuration
+ * Provides default values for conversation memory feature with environment variable support
+ */
+/**
+ * Default maximum number of turns per session
+ */
+export const DEFAULT_MAX_TURNS_PER_SESSION = 50;
+/**
+ * Default maximum number of sessions
+ */
+export const DEFAULT_MAX_SESSIONS = 50;
+/**
+ * Number of messages per conversation turn (user + assistant)
+ */
+export const MESSAGES_PER_TURN = 2;
+/**
+ * Conversation instructions for ongoing conversations
+ * Used to enhance system prompts when conversation history exists
+ */
+export const CONVERSATION_INSTRUCTIONS = `
+
+IMPORTANT: You are continuing an ongoing conversation. The previous messages in this conversation contain important context including:
+- Names, personal information, and preferences shared by the user
+- Projects, tasks, and topics discussed previously  
+- Any decisions, agreements, or conclusions reached
+
+Always reference and build upon this conversation history when relevant. If the user asks about information mentioned earlier in the conversation, refer to those previous messages to provide accurate, contextual responses.`;
+/**
+ * Get default configuration values for conversation memory
+ * Reads environment variables when called (not at module load time)
+ */
+export function getConversationMemoryDefaults() {
+    return {
+        enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
+        maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
+        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) || DEFAULT_MAX_TURNS_PER_SESSION,
+    };
+}

package/dist/lib/core/baseProvider.js

@@ -4,6 +4,7 @@ import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 /**
  * Validates if a result contains a valid toolsObject structure
  * @param result - The result object to validate
@@ -162,10 +163,11 @@ export class BaseProvider {
             logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
             // EVERY provider uses Vercel AI SDK - no exceptions
             const model = await this.getAISDKModel(); // This method is now REQUIRED
+            // Build proper message array with conversation history
+            const messages = buildMessagesArray(options);
             const result = await generateText({
                 model,
-                prompt: options.prompt || options.input?.text || "",
-                system: options.systemPrompt,
+                messages: messages,
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",

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

@@ -0,0 +1,41 @@
+/**
+ * Conversation Memory Manager for NeuroLink
+ * Handles in-memory conversation storage, session management, and context injection
+ */
+import type { ConversationMemoryConfig, ConversationMemoryStats, ChatMessage } from "../types/conversationTypes.js";
+export declare class ConversationMemoryManager {
+    private sessions;
+    private config;
+    private isInitialized;
+    constructor(config: ConversationMemoryConfig);
+    /**
+     * Initialize the memory manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store a conversation turn for a session
+     * ULTRA-OPTIMIZED: Direct ChatMessage[] storage with zero conversion overhead
+     */
+    storeConversationTurn(sessionId: string, userId: string | undefined, userMessage: string, aiResponse: string): Promise<void>;
+    /**
+     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
+     * Returns pre-stored message array with zero conversion overhead
+     */
+    buildContextMessages(sessionId: string): ChatMessage[];
+    /**
+     * Get memory statistics (simplified for pure in-memory storage)
+     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
+     */
+    getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * Clear all conversations for a specific session
+     */
+    clearSession(sessionId: string): Promise<boolean>;
+    /**
+     * Clear all conversations (reset memory)
+     */
+    clearAllSessions(): Promise<void>;
+    private ensureInitialized;
+    private createNewSession;
+    private enforceSessionLimit;
+}

package/dist/lib/core/conversationMemoryManager.js

@@ -0,0 +1,152 @@
+/**
+ * Conversation Memory Manager for NeuroLink
+ * Handles in-memory conversation storage, session management, and context injection
+ */
+import { ConversationMemoryError } from "../types/conversationTypes.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
+import { logger } from "../utils/logger.js";
+export class ConversationMemoryManager {
+    sessions = new Map();
+    config;
+    isInitialized = false;
+    constructor(config) {
+        // Trust that config is already complete from applyConversationMemoryDefaults()
+        this.config = config;
+    }
+    /**
+     * Initialize the memory manager
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        try {
+            this.isInitialized = true;
+            logger.info("ConversationMemoryManager initialized", {
+                storage: "in-memory",
+                maxSessions: this.config.maxSessions,
+                maxTurnsPerSession: this.config.maxTurnsPerSession,
+            });
+        }
+        catch (error) {
+            throw new ConversationMemoryError("Failed to initialize conversation memory", "CONFIG_ERROR", { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Store a conversation turn for a session
+     * ULTRA-OPTIMIZED: Direct ChatMessage[] storage with zero conversion overhead
+     */
+    async storeConversationTurn(sessionId, userId, userMessage, aiResponse) {
+        await this.ensureInitialized();
+        try {
+            // Get or create session
+            let session = this.sessions.get(sessionId);
+            if (!session) {
+                session = this.createNewSession(sessionId, userId);
+                this.sessions.set(sessionId, session);
+            }
+            // ULTRA-OPTIMIZED: Direct message storage - no intermediate objects
+            session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
+            session.lastActivity = Date.now();
+            // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
+            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+            if (session.messages.length > maxMessages) {
+                session.messages = session.messages.slice(-maxMessages);
+            }
+            // Enforce global session limit
+            this.enforceSessionLimit();
+            logger.debug("Conversation turn stored", {
+                sessionId,
+                messageCount: session.messages.length,
+                turnCount: session.messages.length / MESSAGES_PER_TURN, // Each turn = MESSAGES_PER_TURN messages
+                userMessageLength: userMessage.length,
+                aiResponseLength: aiResponse.length,
+            });
+        }
+        catch (error) {
+            throw new ConversationMemoryError(`Failed to store conversation turn for session ${sessionId}`, "STORAGE_ERROR", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Build context messages for AI prompt injection (ULTRA-OPTIMIZED)
+     * Returns pre-stored message array with zero conversion overhead
+     */
+    buildContextMessages(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.messages.length === 0) {
+            return [];
+        }
+        // ULTRA-OPTIMIZED: Direct return - no processing needed!
+        return session.messages;
+    }
+    /**
+     * Get memory statistics (simplified for pure in-memory storage)
+     * ULTRA-OPTIMIZED: Calculate turns from message count (each turn = MESSAGES_PER_TURN messages)
+     */
+    async getStats() {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const totalTurns = sessions.reduce((sum, session) => sum + session.messages.length / MESSAGES_PER_TURN, 0);
+        return {
+            totalSessions: sessions.length,
+            totalTurns,
+        };
+    }
+    /**
+     * Clear all conversations for a specific session
+     */
+    async clearSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        // Remove from memory
+        this.sessions.delete(sessionId);
+        logger.info("Session cleared", { sessionId });
+        return true;
+    }
+    /**
+     * Clear all conversations (reset memory)
+     */
+    async clearAllSessions() {
+        const sessionIds = Array.from(this.sessions.keys());
+        // Clear memory
+        this.sessions.clear();
+        logger.info("All sessions cleared", { clearedCount: sessionIds.length });
+    }
+    // Private methods
+    async ensureInitialized() {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+    }
+    createNewSession(sessionId, userId) {
+        return {
+            sessionId,
+            userId,
+            messages: [],
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+        };
+    }
+    enforceSessionLimit() {
+        const maxSessions = this.config.maxSessions || DEFAULT_MAX_SESSIONS;
+        if (this.sessions.size <= maxSessions) {
+            return;
+        }
+        // Sort sessions by last activity (oldest first)
+        const sessions = Array.from(this.sessions.entries()).sort(([, a], [, b]) => a.lastActivity - b.lastActivity);
+        // Remove oldest sessions
+        const sessionsToRemove = sessions.slice(0, sessions.length - maxSessions);
+        for (const [sessionId] of sessionsToRemove) {
+            this.sessions.delete(sessionId);
+        }
+        logger.debug("Session limit enforced", {
+            removedSessions: sessionsToRemove.length,
+            remainingSessions: this.sessions.size,
+        });
+    }
+}

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

@@ -3,6 +3,7 @@ import type { Schema, Tool } from "ai";
 import type { GenerateResult } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import type { JsonValue } from "../types/common.js";
+import type { ChatMessage } from "../types/conversationTypes.js";
 export interface TextGenerationResult {
     content: string;
     provider?: string;
@@ -150,6 +151,7 @@ export interface TextGenerationOptions {
         role: string;
         content: string;
     }>;
+    conversationMessages?: ChatMessage[];
 }
 /**
  * Analytics data for usage tracking