@juspay/neurolink 7.33.4 → 7.34.0

package/dist/providers/huggingFace.d.ts

@@ -68,12 +68,12 @@ export declare class HuggingFaceProvider extends BaseProvider {
     /**
      * Enhanced error handling with HuggingFace-specific guidance
      */
-    protected handleProviderError(error: unknown): Error;
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    handleProviderError(error: unknown): Error;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for HuggingFace
      */
-    protected getAISDKModel(): LanguageModelV1;
+    getAISDKModel(): LanguageModelV1;
 }
 export default HuggingFaceProvider;

package/dist/providers/litellm.d.ts

@@ -19,7 +19,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for LiteLLM
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    handleProviderError(error: unknown): Error;
     /**
      * LiteLLM supports tools for compatible models
      */

package/dist/providers/mistral.d.ts

@@ -11,13 +11,13 @@ export declare class MistralProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
     protected executeStream(options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Mistral
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    getAISDKModel(): LanguageModelV1;
+    handleProviderError(error: unknown): Error;
     /**
      * Validate provider configuration
      */

package/dist/providers/mistral.js

@@ -111,8 +111,8 @@ export class MistralProvider extends BaseProvider {
             message.includes("Invalid API key")) {
             return new Error("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.");
         }
-        if (message.includes("rate limit")) {
-            return new Error("Mistral rate limit exceeded. Please try again later.");
+        if (message.includes("Rate limit exceeded")) {
+            return new Error("Mistral rate limit exceeded");
         }
         return new Error(`Mistral error: ${message}`);
     }

package/dist/providers/openAI.d.ts

@@ -11,13 +11,13 @@ import type { NeuroLink } from "../neurolink.js";
 export declare class OpenAIProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, neurolink?: NeuroLink);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for OpenAI
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    getAISDKModel(): LanguageModelV1;
+    handleProviderError(error: unknown): Error;
     /**
      * executeGenerate method removed - generation is now handled by BaseProvider.
      * For details on the changes and migration steps, refer to the BaseProvider documentation

package/dist/session/globalSessionState.d.ts

@@ -0,0 +1,27 @@
+import { NeuroLink } from "../neurolink.js";
+import type { ConversationMemoryConfig } from "../types/conversation.js";
+type SessionVariableValue = string | number | boolean;
+interface LoopSessionState {
+    neurolinkInstance: NeuroLink;
+    sessionId: string;
+    isActive: boolean;
+    conversationMemoryConfig?: ConversationMemoryConfig;
+    sessionVariables: Record<string, SessionVariableValue>;
+}
+export declare class GlobalSessionManager {
+    private static instance;
+    private loopSession;
+    static getInstance(): GlobalSessionManager;
+    setLoopSession(config?: ConversationMemoryConfig): string;
+    getLoopSession(): LoopSessionState | null;
+    clearLoopSession(): void;
+    getOrCreateNeuroLink(): NeuroLink;
+    getCurrentSessionId(): string | undefined;
+    setSessionVariable(key: string, value: SessionVariableValue): void;
+    getSessionVariable(key: string): SessionVariableValue | undefined;
+    getSessionVariables(): Record<string, SessionVariableValue>;
+    unsetSessionVariable(key: string): boolean;
+    clearSessionVariables(): void;
+}
+export declare const globalSession: GlobalSessionManager;
+export {};

package/dist/session/globalSessionState.js

@@ -0,0 +1,77 @@
+import { nanoid } from "nanoid";
+import { NeuroLink } from "../neurolink.js";
+export class GlobalSessionManager {
+    static instance;
+    loopSession = null;
+    static getInstance() {
+        if (!GlobalSessionManager.instance) {
+            GlobalSessionManager.instance = new GlobalSessionManager();
+        }
+        return GlobalSessionManager.instance;
+    }
+    setLoopSession(config) {
+        const sessionId = `NL_${nanoid()}`;
+        const neurolinkOptions = {};
+        if (config?.enabled) {
+            neurolinkOptions.conversationMemory = {
+                enabled: true,
+                maxSessions: config.maxSessions,
+                maxTurnsPerSession: config.maxTurnsPerSession,
+            };
+        }
+        this.loopSession = {
+            neurolinkInstance: new NeuroLink(neurolinkOptions),
+            sessionId,
+            isActive: true,
+            conversationMemoryConfig: config,
+            sessionVariables: {},
+        };
+        return sessionId;
+    }
+    getLoopSession() {
+        return this.loopSession?.isActive ? this.loopSession : null;
+    }
+    clearLoopSession() {
+        if (this.loopSession) {
+            this.loopSession.isActive = false;
+            this.loopSession = null;
+        }
+    }
+    getOrCreateNeuroLink() {
+        const session = this.getLoopSession();
+        return session ? session.neurolinkInstance : new NeuroLink();
+    }
+    getCurrentSessionId() {
+        return this.getLoopSession()?.sessionId;
+    }
+    // Session variable management
+    setSessionVariable(key, value) {
+        const session = this.getLoopSession();
+        if (session) {
+            session.sessionVariables[key] = value;
+        }
+    }
+    getSessionVariable(key) {
+        const session = this.getLoopSession();
+        return session?.sessionVariables[key];
+    }
+    getSessionVariables() {
+        const session = this.getLoopSession();
+        return session?.sessionVariables || {};
+    }
+    unsetSessionVariable(key) {
+        const session = this.getLoopSession();
+        if (session && key in session.sessionVariables) {
+            delete session.sessionVariables[key];
+            return true;
+        }
+        return false;
+    }
+    clearSessionVariables() {
+        const session = this.getLoopSession();
+        if (session) {
+            session.sessionVariables = {};
+        }
+    }
+}
+export const globalSession = GlobalSessionManager.getInstance();

package/dist/types/{conversationTypes.d.ts → conversation.d.ts}

@@ -103,3 +103,35 @@ export declare class ConversationMemoryError extends Error {
     details?: Record<string, unknown> | undefined;
     constructor(message: string, code: "STORAGE_ERROR" | "CONFIG_ERROR" | "SESSION_NOT_FOUND" | "CLEANUP_ERROR", details?: Record<string, unknown> | undefined);
 }
+/**
+ * Session identifier for Redis storage operations
+ */
+export type SessionIdentifier = {
+    sessionId: string;
+    userId?: string;
+};
+/**
+ * Redis storage configuration
+ */
+export type RedisStorageConfig = {
+    /** Redis host (default: 'localhost') */
+    host?: string;
+    /** Redis port (default: 6379) */
+    port?: number;
+    /** Redis password (optional) */
+    password?: string;
+    /** Redis database number (default: 0) */
+    db?: number;
+    /** Key prefix for Redis keys (default: 'neurolink:conversation:') */
+    keyPrefix?: string;
+    /** Time-to-live in seconds (default: 86400, 24 hours) */
+    ttl?: number;
+    /** Additional Redis connection options */
+    connectionOptions?: {
+        connectTimeout?: number;
+        lazyConnect?: boolean;
+        retryDelayOnFailover?: number;
+        maxRetriesPerRequest?: number;
+        [key: string]: string | number | boolean | undefined;
+    };
+};

package/dist/types/generateTypes.d.ts

@@ -3,7 +3,7 @@ import type { ValidationSchema, StandardRecord, ZodUnknownSchema } from "./typeA
 import type { AIProviderName } from "./providers.js";
 import type { AnalyticsData, TokenUsage } from "./analytics.js";
 import type { EvaluationData } from "./evaluation.js";
-import type { ChatMessage, ConversationMemoryConfig } from "./conversationTypes.js";
+import type { ChatMessage, ConversationMemoryConfig } from "./conversation.js";
 import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 import type { JsonValue } from "./common.js";
 /**

package/dist/types/streamTypes.d.ts

@@ -4,7 +4,7 @@ import type { AIProviderName, ProviderConfig } from "./providers.js";
 import type { AnalyticsData, TokenUsage } from "./analytics.js";
 import type { EvaluationData } from "./evaluation.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
-import type { ChatMessage } from "./conversationTypes.js";
+import type { ChatMessage } from "./conversation.js";
 import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 /**
  * Progress tracking and metadata for streaming operations

package/dist/utils/conversationMemory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Conversation Memory Utilities
+ * Handles configuration merging and conversation memory operations
+ */
+import type { ConversationMemoryConfig, ChatMessage } from "../types/conversation.js";
+import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
+import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.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, summarizing if needed.
+ */
+export declare function getConversationMessages(conversationMemory: ConversationMemoryManager | RedisConversationMemoryManager | null | 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 | RedisConversationMemoryManager | null | undefined, originalOptions: TextGenerationOptions, result: TextGenerationResult): Promise<void>;

package/dist/utils/conversationMemory.js

@@ -0,0 +1,121 @@
+/**
+ * Conversation Memory Utilities
+ * Handles configuration merging and conversation memory operations
+ */
+import { getConversationMemoryDefaults } from "../config/conversationMemory.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 {
+        ...defaults,
+        ...userConfig,
+    };
+}
+/**
+ * Get conversation history as message array, summarizing if needed.
+ */
+export async function getConversationMessages(conversationMemory, options) {
+    if (!conversationMemory || !options.context) {
+        logger.warn("[conversationMemoryUtils] No memory or context, returning empty messages");
+        return [];
+    }
+    const sessionId = options.context?.sessionId;
+    if (typeof sessionId !== "string" || !sessionId) {
+        logger.warn("[conversationMemoryUtils] Invalid or missing sessionId in context", {
+            sessionIdType: typeof sessionId,
+            sessionIdValue: sessionId,
+        });
+        return [];
+    }
+    try {
+        // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
+        const messages = await conversationMemory.buildContextMessages(sessionId);
+        logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
+            sessionId,
+            messageCount: messages.length,
+            messageTypes: messages.map((m) => m.role),
+            firstMessage: messages.length > 0
+                ? {
+                    role: messages[0].role,
+                    contentLength: messages[0].content.length,
+                    contentPreview: messages[0].content.substring(0, 50),
+                }
+                : null,
+            lastMessage: messages.length > 0
+                ? {
+                    role: messages[messages.length - 1].role,
+                    contentLength: messages[messages.length - 1].content.length,
+                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
+                }
+                : null,
+        });
+        return messages;
+    }
+    catch (error) {
+        logger.warn("[conversationMemoryUtils] Failed to get conversation messages", {
+            sessionId,
+            memoryType: conversationMemory.constructor.name,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        return [];
+    }
+}
+/**
+ * Store conversation turn for future context
+ * Saves user messages and AI responses for conversation memory
+ */
+export async function storeConversationTurn(conversationMemory, originalOptions, result) {
+    logger.debug("[conversationMemoryUtils] storeConversationTurn called", {
+        hasMemory: !!conversationMemory,
+        memoryType: conversationMemory?.constructor?.name || "NONE",
+        hasContext: !!originalOptions.context,
+        hasResult: !!result,
+        resultContentLength: result?.content?.length || 0,
+    });
+    if (!conversationMemory || !originalOptions.context) {
+        logger.debug("[conversationMemoryUtils] No memory or context, skipping conversation storage");
+        return;
+    }
+    const context = originalOptions.context;
+    const sessionId = context.sessionId;
+    const userId = typeof context.userId === "string" ? context.userId : undefined;
+    logger.debug("[conversationMemoryUtils] Extracted session details from context", {
+        sessionId,
+        userId,
+        contextKeys: Object.keys(context),
+        hasValidSessionId: typeof sessionId === "string" && !!sessionId,
+    });
+    if (typeof sessionId !== "string" || !sessionId) {
+        logger.warn("[conversationMemoryUtils] Invalid or missing sessionId in context", {
+            sessionIdType: typeof sessionId,
+            sessionIdValue: sessionId,
+        });
+        return;
+    }
+    const userMessage = originalOptions.originalPrompt || originalOptions.prompt || "";
+    const aiResponse = result.content;
+    try {
+        await conversationMemory.storeConversationTurn(sessionId, userId, userMessage, aiResponse);
+        logger.debug("[conversationMemoryUtils] Conversation turn stored successfully", {
+            sessionId,
+            userId,
+            memoryType: conversationMemory.constructor.name,
+            userMessageLength: userMessage.length,
+            aiResponseLength: aiResponse.length,
+        });
+    }
+    catch (error) {
+        logger.warn("[conversationMemoryUtils] Failed to store conversation turn", {
+            sessionId,
+            userId,
+            memoryType: conversationMemory.constructor.name,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+    }
+}

package/dist/utils/conversationMemoryUtils.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import type { ConversationMemoryConfig, ChatMessage } from "../types/conversationTypes.js";
+import type { ConversationMemoryConfig, ChatMessage } from "../types/conversation.js";
 import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
 import type { TextGenerationOptions, TextGenerationResult } from "../types/index.js";
 /**

package/dist/utils/conversationMemoryUtils.js

@@ -2,7 +2,7 @@
  * Conversation Memory Utilities
  * Handles configuration merging and conversation memory operations
  */
-import { getConversationMemoryDefaults } from "../config/conversationMemoryConfig.js";
+import { getConversationMemoryDefaults } from "../config/conversationMemory.js";
 import { logger } from "./logger.js";
 /**
  * Apply conversation memory defaults to user configuration
@@ -28,7 +28,7 @@ export async function getConversationMessages(conversationMemory, options) {
     }
     try {
         // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = conversationMemory.buildContextMessages(sessionId);
+        const messages = await conversationMemory.buildContextMessages(sessionId);
         logger.debug("Conversation messages retrieved", {
             sessionId,
             messageCount: messages.length,

package/dist/utils/messageBuilder.d.ts

@@ -2,7 +2,7 @@
  * Message Builder Utility
  * Centralized logic for building message arrays from TextGenerationOptions
  */
-import type { ChatMessage } from "../types/conversationTypes.js";
+import type { ChatMessage } from "../types/conversation.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 /**

package/dist/utils/messageBuilder.js

@@ -2,7 +2,7 @@
  * Message Builder Utility
  * Centralized logic for building message arrays from TextGenerationOptions
  */
-import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemoryConfig.js";
+import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemory.js";
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt

package/dist/utils/redis.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Redis Utilities for NeuroLink
+ * Helper functions for Redis storage operations
+ */
+import { createClient } from "redis";
+type RedisClient = ReturnType<typeof createClient>;
+import type { ChatMessage, RedisStorageConfig } from "../types/conversation.js";
+/**
+ * Creates a Redis client with the provided configuration
+ */
+export declare function createRedisClient(config: Required<RedisStorageConfig>): Promise<RedisClient>;
+/**
+ * Generates a Redis key for session messages
+ */
+export declare function getSessionKey(config: Required<RedisStorageConfig>, sessionId: string): string;
+/**
+ * Serializes messages for Redis storage
+ */
+export declare function serializeMessages(messages: ChatMessage[]): string;
+/**
+ * Deserializes messages from Redis storage
+ */
+export declare function deserializeMessages(data: string | null): ChatMessage[];
+/**
+ * Checks if Redis client is healthy
+ */
+export declare function isRedisHealthy(client: RedisClient): Promise<boolean>;
+/**
+ * Scan Redis keys matching a pattern without blocking the server
+ * This is a non-blocking alternative to the KEYS command
+ *
+ * @param client Redis client
+ * @param pattern Pattern to match keys (e.g. "prefix:*")
+ * @param batchSize Number of keys to scan in each iteration (default: 100)
+ * @returns Array of keys matching the pattern
+ */
+export declare function scanKeys(client: RedisClient, pattern: string, batchSize?: number): Promise<string[]>;
+/**
+ * Get normalized Redis configuration with defaults
+ */
+export declare function getNormalizedConfig(config: RedisStorageConfig): Required<RedisStorageConfig>;
+export {};