@juspay/neurolink 7.11.1 → 7.13.0

package/dist/lib/neurolink.js

@@ -27,10 +27,15 @@ import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryCon
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { applyConversationMemoryDefaults, getConversationMessages, storeConversationTurn, } from "./utils/conversationMemoryUtils.js";
+import { ContextManager } from "./context/ContextManager.js";
+import { defaultContextConfig } from "./context/config.js";
 // Core types imported from core/types.js
 export class NeuroLink {
     mcpInitialized = false;
     emitter = new EventEmitter();
+    contextManager = null;
     // Tool registration support
     customTools = new Map();
     inMemoryServers = new Map();
@@ -52,11 +57,22 @@ export class NeuroLink {
             timestamp: Date.now(),
         });
     }
-    constructor() {
+    // Conversation memory support
+    conversationMemory;
+    constructor(config) {
         // SDK always disables manual MCP config for security
         ProviderRegistry.setOptions({
             enableManualMCP: false,
         });
+        // Initialize conversation memory if enabled
+        if (config?.conversationMemory?.enabled) {
+            const memoryConfig = applyConversationMemoryDefaults(config.conversationMemory);
+            this.conversationMemory = new ConversationMemoryManager(memoryConfig);
+            logger.info("NeuroLink initialized with conversation memory", {
+                maxSessions: memoryConfig.maxSessions,
+                maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
+            });
+        }
     }
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
@@ -107,7 +123,33 @@ export class NeuroLink {
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
      */
+    /**
+     * Extracts the original prompt text from the provided input.
+     * If a string is provided, it returns the string directly.
+     * If a GenerateOptions object is provided, it returns the input text from the object.
+     * @param optionsOrPrompt The prompt input, either as a string or a GenerateOptions object.
+     * @returns The original prompt text as a string.
+     */
+    _extractOriginalPrompt(optionsOrPrompt) {
+        return typeof optionsOrPrompt === 'string' ? optionsOrPrompt : optionsOrPrompt.input.text;
+    }
+    /**
+     * Enables automatic context summarization for the NeuroLink instance.
+     * Once enabled, the instance will maintain conversation history and
+     * automatically summarize it when it exceeds token limits.
+     * @param config Optional configuration to override default summarization settings.
+     */
+    enableContextSummarization(config) {
+        const contextConfig = {
+            ...defaultContextConfig,
+            ...config,
+        };
+        // Pass the internal generator function directly, bound to the correct `this` context.
+        this.contextManager = new ContextManager(this.generateTextInternal.bind(this), contextConfig);
+        logger.info("[NeuroLink] Automatic context summarization enabled.");
+    }
     async generate(optionsOrPrompt) {
+        const originalPrompt = this._extractOriginalPrompt(optionsOrPrompt);
         // Convert string prompt to full options
         const options = typeof optionsOrPrompt === "string"
             ? { input: { text: optionsOrPrompt } }
@@ -116,6 +158,11 @@ export class NeuroLink {
         if (!options.input?.text || typeof options.input.text !== "string") {
             throw new Error("Input text is required and must be a non-empty string");
         }
+        // Handle Context Management if enabled
+        if (this.contextManager) {
+            // Get the full context for the prompt without permanently adding the user's turn yet
+            options.input.text = this.contextManager.getContextForPrompt("user", options.input.text);
+        }
         const startTime = Date.now();
         // Emit generation start event
         this.emitter.emit("generation:start", {
@@ -227,6 +274,11 @@ export class NeuroLink {
                 }
                 : undefined,
         };
+        // Add both the user's turn and the AI's response to the permanent history
+        if (this.contextManager) {
+            await this.contextManager.addTurn("user", originalPrompt);
+            await this.contextManager.addTurn("assistant", generateResult.content);
+        }
         return generateResult;
     }
     /**
@@ -247,9 +299,11 @@ export class NeuroLink {
      * REDESIGNED INTERNAL GENERATION - NO CIRCULAR DEPENDENCIES
      *
      * This method implements a clean fallback chain:
-     * 1. Try MCP-enhanced generation if available
-     * 2. Fall back to direct provider generation
-     * 3. No recursive calls - each method has a specific purpose
+     * 1. Initialize conversation memory if enabled
+     * 2. Inject conversation history into prompt
+     * 3. Try MCP-enhanced generation if available
+     * 4. Fall back to direct provider generation
+     * 5. Store conversation turn for future context
      */
     async generateTextInternal(options) {
         const startTime = Date.now();
@@ -257,14 +311,21 @@ export class NeuroLink {
         logger.debug(`[${functionTag}] Starting generation`, {
             provider: options.provider || "auto",
             promptLength: options.prompt?.length || 0,
+            hasConversationMemory: !!this.conversationMemory,
         });
         try {
+            // Initialize conversation memory if enabled
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
             // Try MCP-enhanced generation first (if not explicitly disabled)
             if (!options.disableTools) {
                 try {
                     const mcpResult = await this.tryMCPGeneration(options);
                     if (mcpResult && mcpResult.content) {
                         logger.debug(`[${functionTag}] MCP generation successful`);
+                        // Store conversation turn
+                        await storeConversationTurn(this.conversationMemory, options, mcpResult);
                         return mcpResult;
                     }
                 }
@@ -277,6 +338,8 @@ export class NeuroLink {
             // Fall back to direct provider generation
             const directResult = await this.directProviderGeneration(options);
             logger.debug(`[${functionTag}] Direct generation successful`);
+            // Store conversation turn
+            await storeConversationTurn(this.conversationMemory, options, directResult);
             return directResult;
         }
         catch (error) {
@@ -334,6 +397,8 @@ export class NeuroLink {
             }
             // Create tool-aware system prompt
             const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
+            // Get conversation messages for context
+            const conversationMessages = await getConversationMessages(this.conversationMemory, options);
             // Create provider and generate
             const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
             this);
@@ -345,6 +410,7 @@ export class NeuroLink {
             const result = await provider.generate({
                 ...options,
                 systemPrompt: enhancedSystemPrompt,
+                conversationMessages, // Inject conversation history
             });
             const responseTime = Date.now() - startTime;
             // Check if result is meaningful
@@ -413,6 +479,8 @@ export class NeuroLink {
         for (const providerName of tryProviders) {
             try {
                 logger.debug(`[${functionTag}] Attempting provider: ${providerName}`);
+                // Get conversation messages for context
+                const conversationMessages = await getConversationMessages(this.conversationMemory, options);
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
                 this);
                 // Enable tool execution for direct provider generation using BaseProvider method
@@ -420,7 +488,10 @@ export class NeuroLink {
                     customTools: this.customTools,
                     executeTool: this.executeTool.bind(this),
                 }, functionTag);
-                const result = await provider.generate(options);
+                const result = await provider.generate({
+                    ...options,
+                    conversationMessages, // Inject conversation history
+                });
                 const responseTime = Date.now() - startTime;
                 if (!result) {
                     throw new Error(`Provider ${providerName} returned null result`);
@@ -1577,6 +1648,36 @@ export class NeuroLink {
             tools,
         };
     }
+    // ============================================================================
+    // CONVERSATION MEMORY PUBLIC API
+    // ============================================================================
+    /**
+     * Get conversation memory statistics (public API)
+     */
+    async getConversationStats() {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        return await this.conversationMemory.getStats();
+    }
+    /**
+     * Clear conversation history for a specific session (public API)
+     */
+    async clearConversationSession(sessionId) {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        return await this.conversationMemory.clearSession(sessionId);
+    }
+    /**
+     * Clear all conversation history (public API)
+     */
+    async clearAllConversations() {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        await this.conversationMemory.clearAllSessions();
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/lib/providers/amazonBedrock.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createAWSAccessKeyConfig, createAWSSecretConfig, getAWSRegion, getAWSSessionToken, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers
 const getBedrockModelId = () => {
     return (process.env.BEDROCK_MODEL ||
@@ -79,10 +80,11 @@ export class AmazonBedrockProvider extends BaseProvider {
     async executeStream(options, analysisSchema) {
         try {
             this.validateStreamOptions(options);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 temperature: options.temperature,
             });

package/dist/lib/providers/anthropic.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
     return validateApiKey(createAnthropicConfig());
@@ -94,10 +95,11 @@ export class AnthropicProvider extends BaseProvider {
             // ✅ Get tools for streaming (same as generate method)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt || undefined,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/lib/providers/azureOpenai.js

@@ -3,6 +3,7 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } from "../utils/providerConfig.js";
 import { logger } from "../utils/logger.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 export class AzureOpenAIProvider extends BaseProvider {
     apiKey;
     resourceName;
@@ -69,12 +70,13 @@ export class AzureOpenAIProvider extends BaseProvider {
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {
         try {
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const stream = await streamText({
                 model: this.azureProvider(this.deployment),
-                prompt: options.input?.text || "",
+                messages: messages,
                 maxTokens: options.maxTokens || 1000,
                 temperature: options.temperature || 0.7,
-                system: options.systemPrompt,
             });
             return {
                 stream: (async function* () {

package/dist/lib/providers/googleAiStudio.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
     process.env.GOOGLE_AI_API_KEY) {
@@ -76,10 +77,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/lib/providers/googleVertex.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Cache for anthropic module to avoid repeated imports
 let _createVertexAnthropic = null;
 let _anthropicImportAttempted = false;
@@ -189,6 +190,8 @@ export class GoogleVertexProvider extends BaseProvider {
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             this.validateStreamOptions(options);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             logger.debug(`${functionTag}: Starting stream request`, {
                 modelName: this.modelName,
                 promptLength: options.input.text.length,
@@ -209,8 +212,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // Build complete stream options with proper typing
             let streamOptions = {
                 model: model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 ...(maxTokens && { maxTokens }),
                 tools,

package/dist/lib/providers/huggingFace.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getHuggingFaceApiKey = () => {
     return validateApiKey(createHuggingFaceConfig());
@@ -111,10 +112,11 @@ export class HuggingFaceProvider extends BaseProvider {
         try {
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: streamOptions.prompt,
-                system: streamOptions.system,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions

package/dist/lib/providers/litellm.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
     return {
@@ -118,10 +119,11 @@ export class LiteLLMProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools: options.tools,

package/dist/lib/providers/mistral.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
@@ -46,10 +47,10 @@ export class MistralProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/lib/providers/openAI.js

@@ -7,6 +7,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -77,10 +78,11 @@ export class OpenAIProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

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

@@ -0,0 +1,95 @@
+/**
+ * Conversation Memory Types for NeuroLink
+ * Provides type-safe conversation storage and context management
+ */
+/**
+ * Configuration for conversation memory feature
+ */
+export interface ConversationMemoryConfig {
+    /** Enable conversation memory feature */
+    enabled: boolean;
+    /** Maximum number of sessions to keep in memory (default: 50) */
+    maxSessions?: number;
+    /** Maximum number of conversation turns to keep per session (default: 20) */
+    maxTurnsPerSession?: number;
+}
+/**
+ * Complete memory for a conversation session
+ * ULTRA-OPTIMIZED: Direct ChatMessage[] storage - zero conversion overhead
+ */
+export interface SessionMemory {
+    /** Unique session identifier */
+    sessionId: string;
+    /** User identifier (optional) */
+    userId?: string;
+    /** Direct message storage - ready for immediate AI consumption */
+    messages: ChatMessage[];
+    /** When this session was created */
+    createdAt: number;
+    /** When this session was last active */
+    lastActivity: number;
+    /** Optional session metadata */
+    metadata?: {
+        /** User role or permissions */
+        userRole?: string;
+        /** Tags for categorizing this session */
+        tags?: string[];
+        /** Custom data specific to the organization */
+        customData?: Record<string, unknown>;
+    };
+}
+/**
+ * Statistics about conversation memory usage (simplified for pure in-memory storage)
+ */
+export interface ConversationMemoryStats {
+    /** Total number of active sessions */
+    totalSessions: number;
+    /** Total number of conversation turns across all sessions */
+    totalTurns: number;
+}
+/**
+ * Chat message format for conversation history
+ */
+export interface ChatMessage {
+    /** Role of the message sender */
+    role: "user" | "assistant" | "system";
+    /** Content of the message */
+    content: string;
+}
+/**
+ * Events emitted by conversation memory system
+ */
+export interface ConversationMemoryEvents {
+    /** Emitted when a new session is created */
+    "session:created": {
+        sessionId: string;
+        userId?: string;
+        timestamp: number;
+    };
+    /** Emitted when a conversation turn is stored */
+    "turn:stored": {
+        sessionId: string;
+        turnIndex: number;
+        timestamp: number;
+    };
+    /** Emitted when a session is cleaned up */
+    "session:cleanup": {
+        sessionId: string;
+        reason: "expired" | "limit_exceeded";
+        timestamp: number;
+    };
+    /** Emitted when context is injected */
+    "context:injected": {
+        sessionId: string;
+        turnsIncluded: number;
+        timestamp: number;
+    };
+}
+/**
+ * Error types specific to conversation memory
+ */
+export declare class ConversationMemoryError extends Error {
+    code: "STORAGE_ERROR" | "CONFIG_ERROR" | "SESSION_NOT_FOUND" | "CLEANUP_ERROR";
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: "STORAGE_ERROR" | "CONFIG_ERROR" | "SESSION_NOT_FOUND" | "CLEANUP_ERROR", details?: Record<string, unknown> | undefined);
+}

package/dist/lib/types/conversationTypes.js

@@ -0,0 +1,17 @@
+/**
+ * Conversation Memory Types for NeuroLink
+ * Provides type-safe conversation storage and context management
+ */
+/**
+ * Error types specific to conversation memory
+ */
+export class ConversationMemoryError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ConversationMemoryError";
+    }
+}

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

@@ -2,6 +2,7 @@ import type { ZodType, ZodTypeDef } from "zod";
 import type { Tool, Schema } from "ai";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
+import type { ChatMessage } from "./conversationTypes.js";
 /**
  * Interface for tool execution calls (AI SDK compatible)
  */
@@ -107,6 +108,7 @@ export interface StreamOptions {
         enableProgress?: boolean;
         fallbackToGenerate?: boolean;
     };
+    conversationMessages?: ChatMessage[];
 }
 /**
  * Stream function result interface - Primary output format for streaming

package/dist/lib/utils/conversationMemoryUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Conversation Memory Utilities
+ * Handles configuration merging and conversation memory operations
+ */
+import type { ConversationMemoryConfig, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
+import type { TextGenerationOptions, TextGenerationResult } from "../core/types.js";
+/**
+ * Apply conversation memory defaults to user configuration
+ * Merges user config with environment variables and default values
+ */
+export declare function applyConversationMemoryDefaults(userConfig?: Partial<ConversationMemoryConfig>): ConversationMemoryConfig;
+/**
+ * Get conversation history as message array (PREFERRED METHOD)
+ * Returns proper message array format for AI providers
+ */
+export declare function getConversationMessages(conversationMemory: ConversationMemoryManager | undefined, options: TextGenerationOptions): Promise<ChatMessage[]>;
+/**
+ * Store conversation turn for future context
+ * Saves user messages and AI responses for conversation memory
+ */
+export declare function storeConversationTurn(conversationMemory: ConversationMemoryManager | undefined, originalOptions: TextGenerationOptions, result: TextGenerationResult): Promise<void>;

package/dist/lib/utils/conversationMemoryUtils.js

@@ -0,0 +1,77 @@
+/**
+ * Conversation Memory Utilities
+ * Handles configuration merging and conversation memory operations
+ */
+import { getConversationMemoryDefaults } from "../config/conversationMemoryConfig.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 {
+        enabled: userConfig?.enabled ?? defaults.enabled,
+        maxSessions: userConfig?.maxSessions ?? defaults.maxSessions,
+        maxTurnsPerSession: userConfig?.maxTurnsPerSession ?? defaults.maxTurnsPerSession,
+    };
+}
+/**
+ * Get conversation history as message array (PREFERRED METHOD)
+ * Returns proper message array format for AI providers
+ */
+export async function getConversationMessages(conversationMemory, options) {
+    if (!conversationMemory || !options.context) {
+        return [];
+    }
+    const sessionId = options.context?.sessionId;
+    if (typeof sessionId !== "string" || !sessionId) {
+        return [];
+    }
+    try {
+        const messages = conversationMemory.buildContextMessages(sessionId);
+        logger.debug("Conversation messages retrieved", {
+            sessionId,
+            messageCount: messages.length,
+        });
+        return messages;
+    }
+    catch (error) {
+        logger.warn("Failed to get conversation messages", {
+            sessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return [];
+    }
+}
+/**
+ * Store conversation turn for future context
+ * Saves user messages and AI responses for conversation memory
+ */
+export async function storeConversationTurn(conversationMemory, originalOptions, result) {
+    if (!conversationMemory || !originalOptions.context) {
+        return;
+    }
+    const context = originalOptions.context;
+    const sessionId = context.sessionId;
+    const userId = typeof context.userId === "string" ? context.userId : undefined;
+    if (typeof sessionId !== "string" || !sessionId) {
+        return;
+    }
+    try {
+        await conversationMemory.storeConversationTurn(sessionId, userId, originalOptions.prompt || "", result.content);
+        logger.debug("Conversation turn stored", {
+            sessionId,
+            userId,
+            promptLength: originalOptions.prompt?.length || 0,
+            responseLength: result.content.length,
+        });
+    }
+    catch (error) {
+        logger.warn("Failed to store conversation turn", {
+            sessionId,
+            userId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}