@juspay/neurolink 7.33.3 → 7.34.0

package/dist/providers/azureOpenai.js

@@ -6,6 +6,7 @@ import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } f
 import { logger } from "../utils/logger.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 export class AzureOpenAIProvider extends BaseProvider {
     apiKey;
     resourceName;
@@ -19,9 +20,11 @@ export class AzureOpenAIProvider extends BaseProvider {
         this.resourceName = endpoint
             .replace("https://", "")
             .replace(/\/+$/, "") // Remove trailing slashes
-            .replace(".openai.azure.com", "");
+            .replace(".openai.azure.com", "")
+            .replace(".cognitiveservices.azure.com", "");
         this.deployment =
             modelName ||
+                process.env.AZURE_OPENAI_MODEL ||
                 process.env.AZURE_OPENAI_DEPLOYMENT ||
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o";
@@ -34,6 +37,7 @@ export class AzureOpenAIProvider extends BaseProvider {
             validateApiKey(createAzureEndpointConfig());
         }
         // Create the Azure provider instance with proxy support
+        // Let the Azure SDK handle all URL construction automatically
         this.azureProvider = createAzure({
             resourceName: this.resourceName,
             apiKey: this.apiKey,
@@ -73,20 +77,57 @@ export class AzureOpenAIProvider extends BaseProvider {
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {
         try {
+            // Get ALL available tools (direct + MCP + external from options) - EXACTLY like BaseProvider
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const baseTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? {
+                    ...baseTools,
+                    ...(options.tools || {}), // Include external tools passed from NeuroLink
+                }
+                : undefined;
+            // DEBUG: Log detailed tool information
+            logger.debug("Azure Stream - Tool Loading Debug", {
+                shouldUseTools,
+                baseToolsProvided: !!baseTools,
+                baseToolCount: baseTools ? Object.keys(baseTools).length : 0,
+                finalToolCount: tools ? Object.keys(tools).length : 0,
+                toolNames: tools ? Object.keys(tools).slice(0, 10) : [],
+                disableTools: options.disableTools,
+                supportsTools: this.supportsTools(),
+                externalToolsCount: options.tools
+                    ? Object.keys(options.tools).length
+                    : 0,
+            });
+            if (tools && Object.keys(tools).length > 0) {
+                logger.debug("Azure Stream - First 5 Tools Detail", {
+                    tools: Object.keys(tools)
+                        .slice(0, 5)
+                        .map((name) => ({
+                        name,
+                        description: tools[name]?.description?.substring(0, 100),
+                    })),
+                });
+            }
             // Build message array from options
             const messages = buildMessagesArray(options);
             const stream = await streamText({
                 model: this.azureProvider(this.deployment),
                 messages: messages,
-                maxTokens: options.maxTokens || 1000,
-                temperature: options.temperature || 0.7,
+                ...(options.maxTokens !== null && options.maxTokens !== undefined
+                    ? { maxTokens: options.maxTokens }
+                    : {}),
+                ...(options.temperature !== null && options.temperature !== undefined
+                    ? { temperature: options.temperature }
+                    : {}),
+                tools,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             });
+            // Transform string stream to content object stream using BaseProvider method
+            const transformedStream = this.createTextStream(stream);
             return {
-                stream: (async function* () {
-                    for await (const chunk of stream.textStream) {
-                        yield { content: chunk };
-                    }
-                })(),
+                stream: transformedStream,
                 provider: "azure",
                 model: this.deployment,
                 metadata: {

package/dist/providers/googleAiStudio.d.ts

@@ -9,13 +9,13 @@ import { BaseProvider } from "../core/baseProvider.js";
  */
 export declare class GoogleAIStudioProvider extends BaseProvider {
     constructor(modelName?: string, sdk?: unknown);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    getProviderName(): AIProviderName;
+    getDefaultModel(): string;
     /**
      * 🔧 PHASE 2: Return AI SDK model instance for tool calling
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
+    getAISDKModel(): LanguageModelV1;
+    handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     private executeAudioStreamViaGeminiLive;
     private getApiKey;

package/dist/providers/googleAiStudio.js

@@ -5,7 +5,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Create Google GenAI client
@@ -96,7 +96,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",

package/dist/providers/googleVertex.js

@@ -4,7 +4,7 @@ import { streamText, Output, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 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 { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
 import fs from "fs";
@@ -945,7 +945,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // This avoids hardcoded model-specific logic and repeated config lookups
             const shouldSetMaxTokens = this.shouldSetMaxTokensCached(modelName);
             const maxTokens = shouldSetMaxTokens
-                ? options.maxTokens || DEFAULT_MAX_TOKENS
+                ? options.maxTokens // No default limit
                 : undefined;
             // Build complete stream options with proper typing
             let streamOptions = {

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/huggingFace.js

@@ -3,7 +3,6 @@ import { streamText, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 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";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
@@ -120,7 +119,7 @@ export class HuggingFaceProvider extends BaseProvider {
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
                 toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
                 abortSignal: timeoutController?.controller.signal,

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/litellm.js

@@ -3,7 +3,6 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 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";
@@ -127,7 +126,7 @@ export class LiteLLMProvider extends BaseProvider {
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,

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

@@ -3,7 +3,7 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 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 { 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";
@@ -54,7 +54,7 @@ export class MistralProvider extends BaseProvider {
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
@@ -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/ollama.js

@@ -1,6 +1,5 @@
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { modelConfig } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { TimeoutError } from "../utils/timeout.js";
@@ -88,10 +87,10 @@ class OllamaLanguageModel {
         return {
             text: data.response,
             usage: {
-                promptTokens: data.prompt_eval_count || this.estimateTokens(prompt),
-                completionTokens: data.eval_count || this.estimateTokens(data.response),
-                totalTokens: (data.prompt_eval_count || this.estimateTokens(prompt)) +
-                    (data.eval_count || this.estimateTokens(data.response)),
+                promptTokens: data.prompt_eval_count ?? this.estimateTokens(prompt),
+                completionTokens: data.eval_count ?? this.estimateTokens(String(data.response ?? "")),
+                totalTokens: (data.prompt_eval_count ?? this.estimateTokens(prompt)) +
+                    (data.eval_count ?? this.estimateTokens(String(data.response ?? ""))),
             },
             finishReason: "stop",
             rawCall: {
@@ -271,7 +270,7 @@ export class OllamaProvider extends BaseProvider {
      * @returns true for supported models, false for unsupported models
      */
     supportsTools() {
-        const modelName = this.modelName.toLowerCase();
+        const modelName = (this.modelName ?? getDefaultOllamaModel()).toLowerCase();
         // Get tool-capable models from configuration
         const ollamaConfig = modelConfig.getProviderConfiguration("ollama");
         const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
@@ -340,7 +339,7 @@ export class OllamaProvider extends BaseProvider {
                 tool_choice: "auto",
                 stream: true,
                 temperature: options.temperature,
-                max_tokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                max_tokens: options.maxTokens,
             }),
             signal: createAbortSignalWithTimeout(this.timeout),
         });
@@ -381,7 +380,7 @@ export class OllamaProvider extends BaseProvider {
                 stream: true,
                 options: {
                     temperature: options.temperature,
-                    num_predict: options.maxTokens || DEFAULT_MAX_TOKENS,
+                    num_predict: options.maxTokens,
                 },
             }),
             signal: createAbortSignalWithTimeout(this.timeout),

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/providers/openAI.js

@@ -5,7 +5,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
+import { 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";
@@ -97,7 +97,7 @@ export class OpenAIProvider extends BaseProvider {
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",

package/dist/providers/openaiCompatible.js

@@ -3,7 +3,6 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Constants
@@ -163,7 +162,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 prompt: options.input.text,
                 system: options.systemPrompt,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
@@ -207,12 +206,16 @@ export class OpenAICompatibleProvider extends BaseProvider {
             const modelsUrl = new URL("/v1/models", this.config.baseURL).toString();
             logger.debug(`Fetching available models from: ${modelsUrl}`);
             const proxyFetch = createProxyFetch();
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), 5000);
             const response = await proxyFetch(modelsUrl, {
                 headers: {
                     Authorization: `Bearer ${this.config.apiKey}`,
                     "Content-Type": "application/json",
                 },
+                signal: controller.signal,
             });
+            clearTimeout(t);
             if (!response.ok) {
                 logger.warn(`Models endpoint returned ${response.status}: ${response.statusText}`);
                 return this.getFallbackModels();

package/dist/providers/sagemaker/language-model.d.ts

@@ -9,6 +9,11 @@ import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
 import type { ConnectivityResult } from "../../types/typeAliases.js";
 /**
  * SageMaker Language Model implementing LanguageModelV1 interface
+ *
+ * Token Limit Behavior:
+ * - When maxTokens is undefined, SageMaker uses the model's default token limits
+ * - When maxTokens is specified, it sets max_new_tokens parameter explicitly
+ * - This aligns with the unlimited-by-default token policy across all providers
  */
 export declare class SageMakerLanguageModel implements LanguageModelV1 {
     readonly specificationVersion = "v1";

package/dist/providers/sagemaker/language-model.js

@@ -75,6 +75,11 @@ const DEFAULT_MAX_CONCURRENCY = 10;
 const DEFAULT_MIN_CONCURRENCY = 1;
 /**
  * SageMaker Language Model implementing LanguageModelV1 interface
+ *
+ * Token Limit Behavior:
+ * - When maxTokens is undefined, SageMaker uses the model's default token limits
+ * - When maxTokens is specified, it sets max_new_tokens parameter explicitly
+ * - This aligns with the unlimited-by-default token policy across all providers
  */
 export class SageMakerLanguageModel {
     specificationVersion = "v1";
@@ -345,7 +350,10 @@ export class SageMakerLanguageModel {
         const request = {
             inputs: promptText,
             parameters: {
-                max_new_tokens: options.maxTokens || 512,
+                // Only include max_new_tokens if explicitly specified; let SageMaker use model defaults otherwise
+                ...(options.maxTokens !== undefined
+                    ? { max_new_tokens: options.maxTokens }
+                    : {}),
                 temperature: options.temperature || 0.7,
                 top_p: options.topP || 0.9,
                 stop: options.stopSequences || [],

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>;