@juspay/neurolink 7.21.0 → 7.23.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.23.0](https://github.com/juspay/neurolink/compare/v7.22.0...v7.23.0) (2025-08-19)
+
+### Features
+
+- **(docs):** modernize api examples ([c77706b](https://github.com/juspay/neurolink/commit/c77706b427c2ea781269c6d0c2dc7ca2511128cb))
+
+## [7.22.0](https://github.com/juspay/neurolink/compare/v7.21.0...v7.22.0) (2025-08-19)
+
+### Features
+
+- **(memory):** Add conversation memory test suite for NeuroLink stream functionality ([b896bef](https://github.com/juspay/neurolink/commit/b896bef43fb0d743f5d9a7196ecf5ca4e39aa8a0))
+
 ## [7.21.0](https://github.com/juspay/neurolink/compare/v7.20.0...v7.21.0) (2025-08-19)
 
 ### Features

package/README.md

@@ -146,32 +146,7 @@ const { NeuroLink } = require('@juspay/neurolink');
 ### Basic Usage
 
 ```typescript
-import { NeuroLink, AIProviderFactory } from "@juspay/neurolink";
-
-// LiteLLM - Access 100+ models through unified interface
-const litellmProvider = await AIProviderFactory.createProvider(
-  "litellm",
-  "openai/gpt-4o",
-);
-const result = await litellmProvider.generate({
-  input: { text: "Write a haiku about programming" },
-});
-
-// Compare multiple models simultaneously
-const models = [
-  "openai/gpt-4o",
-  "anthropic/claude-3-5-sonnet",
-  "google/gemini-2.0-flash",
-];
-const comparisons = await Promise.all(
-  models.map(async (model) => {
-    const provider = await AIProviderFactory.createProvider("litellm", model);
-    const result = await provider.generate({
-      input: { text: "Explain quantum computing" },
-    });
-    return { model, response: result.content, provider: result.provider };
-  }),
-);
+import { NeuroLink } from "@juspay/neurolink";
 
 // Auto-select best available provider
 const neurolink = new NeuroLink();
@@ -181,8 +156,8 @@ const autoResult = await neurolink.generate({
   timeout: "30s",
 });
 
-console.log(result.content);
-console.log(`Used: ${result.provider}`);
+console.log(autoResult.content);
+console.log(`Used: ${autoResult.provider}`);
 ```
 
 ### Conversation Memory
@@ -241,27 +216,10 @@ npx @juspay/neurolink generate "Write a proposal" --enable-analytics --enable-ev
 npx @juspay/neurolink stream "What time is it and write a file with the current date"
 ```
 
-#### SDK with LiteLLM and Enhancement Features
+#### SDK and Enhancement Features
 
 ```typescript
-import { NeuroLink, AIProviderFactory } from "@juspay/neurolink";
-
-// LiteLLM multi-model comparison
-const models = [
-  "openai/gpt-4o",
-  "anthropic/claude-3-5-sonnet",
-  "google/gemini-2.0-flash",
-];
-const comparisons = await Promise.all(
-  models.map(async (model) => {
-    const provider = await AIProviderFactory.createProvider("litellm", model);
-    return await provider.generate({
-      input: { text: "Explain the benefits of renewable energy" },
-      enableAnalytics: true,
-      enableEvaluation: true,
-    });
-  }),
-);
+import { NeuroLink } from "@juspay/neurolink";
 
 // Enhanced generation with analytics
 const neurolink = new NeuroLink();

package/dist/lib/neurolink.js

@@ -749,6 +749,15 @@ export class NeuroLink {
                 provider: providerName,
                 prompt: (options.input.text?.substring(0, 100) || "No text") + "...",
             });
+            // Initialize conversation memory if enabled (same as generate function)
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
+            // Get conversation messages for context injection (same as generate function)
+            const conversationMessages = await getConversationMessages(this.conversationMemory, {
+                prompt: options.input.text,
+                context: enhancedOptions.context,
+            });
             // Create provider using the same factory pattern as generate
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
             // Enable tool execution for streaming using BaseProvider method
@@ -756,12 +765,69 @@ export class NeuroLink {
                 customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
-            // Create clean options for provider (remove factoryConfig)
+            // Create clean options for provider (remove factoryConfig) and inject conversation history
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
-            // Call the provider's stream method with clean options
-            const streamResult = await provider.stream(cleanOptions);
+            const optionsWithHistory = {
+                ...cleanOptions,
+                conversationMessages, // Inject conversation history like in generate function
+            };
+            // Call the provider's stream method with conversation history
+            const streamResult = await provider.stream(optionsWithHistory);
             // Extract the stream from the result
-            const stream = streamResult.stream;
+            const originalStream = streamResult.stream;
+            // Create a proper tee pattern that accumulates content and stores memory after consumption
+            let accumulatedContent = "";
+            const processedStream = (async function* (self) {
+                try {
+                    for await (const chunk of originalStream) {
+                        // Enhanced chunk validation and content handling
+                        let processedChunk = chunk;
+                        if (chunk && typeof chunk === "object") {
+                            // Ensure chunk has content property and it's a string
+                            if (typeof chunk.content === "string") {
+                                accumulatedContent += chunk.content;
+                            }
+                            else if (chunk.content === undefined ||
+                                chunk.content === null) {
+                                // Handle undefined/null content gracefully - create a new chunk object
+                                processedChunk = { ...chunk, content: "" };
+                            }
+                            else if (typeof chunk.content !== "string") {
+                                // Convert non-string content to string - create a new chunk object
+                                const stringContent = String(chunk.content || "");
+                                processedChunk = { ...chunk, content: stringContent };
+                                accumulatedContent += stringContent;
+                            }
+                        }
+                        else if (chunk === null || chunk === undefined) {
+                            // Create a safe empty chunk if chunk is null/undefined
+                            processedChunk = { content: "" };
+                        }
+                        yield processedChunk; // Preserve original streaming behavior with safe content
+                    }
+                }
+                finally {
+                    // Store memory after stream consumption
+                    if (self.conversationMemory) {
+                        try {
+                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
+                                ?.sessionId, enhancedOptions.context
+                                ?.userId, options.input.text, accumulatedContent);
+                            logger.debug("Stream conversation turn stored", {
+                                sessionId: enhancedOptions.context
+                                    ?.sessionId,
+                                userInputLength: options.input.text.length,
+                                responseLength: accumulatedContent.length,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("Failed to store stream conversation turn", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+            })(this);
             const responseTime = Date.now() - startTime;
             mcpLogger.debug(`[${functionTag}] MCP-enabled streaming completed`, {
                 responseTime,
@@ -774,7 +840,7 @@ export class NeuroLink {
             });
             // Convert to StreamResult format - Include analytics and evaluation from provider
             return {
-                stream,
+                stream: processedStream,
                 provider: providerName,
                 model: options.model,
                 usage: streamResult.usage,
@@ -804,6 +870,15 @@ export class NeuroLink {
             mcpLogger.warn(`[${functionTag}] MCP streaming failed, falling back to regular`, {
                 error: error instanceof Error ? error.message : String(error),
             });
+            // Initialize conversation memory for fallback path (same as success path)
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
+            // Get conversation messages for fallback context injection
+            const fallbackConversationMessages = await getConversationMessages(this.conversationMemory, {
+                prompt: options.input.text,
+                context: enhancedOptions.context,
+            });
             // Use factory to create provider without MCP
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, false, // Disable MCP for fallback
             this);
@@ -812,9 +887,46 @@ export class NeuroLink {
                 customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
-            // Create clean options for fallback provider (remove factoryConfig)
+            // Create clean options for fallback provider and inject conversation history
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
-            const streamResult = await provider.stream(cleanOptions);
+            const fallbackOptionsWithHistory = {
+                ...cleanOptions,
+                conversationMessages: fallbackConversationMessages, // Inject conversation history in fallback
+            };
+            const streamResult = await provider.stream(fallbackOptionsWithHistory);
+            // Create a proper tee pattern for fallback that accumulates content and stores memory after consumption
+            let fallbackAccumulatedContent = "";
+            const fallbackProcessedStream = (async function* (self) {
+                try {
+                    for await (const chunk of streamResult.stream) {
+                        if (chunk && typeof chunk.content === "string") {
+                            fallbackAccumulatedContent += chunk.content;
+                        }
+                        yield chunk; // Preserve original streaming behavior
+                    }
+                }
+                finally {
+                    // Store memory after fallback stream consumption
+                    if (self.conversationMemory) {
+                        try {
+                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
+                                ?.sessionId, enhancedOptions.context
+                                ?.userId, options.input.text, fallbackAccumulatedContent);
+                            logger.debug("Fallback stream conversation turn stored", {
+                                sessionId: enhancedOptions.context
+                                    ?.sessionId,
+                                userInputLength: options.input.text.length,
+                                responseLength: fallbackAccumulatedContent.length,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("Failed to store fallback stream conversation turn", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+            })(this);
             const responseTime = Date.now() - startTime;
             // Emit stream completion event for fallback
             this.emitter.emit("stream:end", {
@@ -823,7 +935,7 @@ export class NeuroLink {
                 fallback: true,
             });
             return {
-                stream: streamResult.stream,
+                stream: fallbackProcessedStream,
                 provider: providerName,
                 model: options.model,
                 usage: streamResult.usage,

package/dist/neurolink.js

@@ -749,6 +749,15 @@ export class NeuroLink {
                 provider: providerName,
                 prompt: (options.input.text?.substring(0, 100) || "No text") + "...",
             });
+            // Initialize conversation memory if enabled (same as generate function)
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
+            // Get conversation messages for context injection (same as generate function)
+            const conversationMessages = await getConversationMessages(this.conversationMemory, {
+                prompt: options.input.text,
+                context: enhancedOptions.context,
+            });
             // Create provider using the same factory pattern as generate
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
             // Enable tool execution for streaming using BaseProvider method
@@ -756,12 +765,69 @@ export class NeuroLink {
                 customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
-            // Create clean options for provider (remove factoryConfig)
+            // Create clean options for provider (remove factoryConfig) and inject conversation history
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
-            // Call the provider's stream method with clean options
-            const streamResult = await provider.stream(cleanOptions);
+            const optionsWithHistory = {
+                ...cleanOptions,
+                conversationMessages, // Inject conversation history like in generate function
+            };
+            // Call the provider's stream method with conversation history
+            const streamResult = await provider.stream(optionsWithHistory);
             // Extract the stream from the result
-            const stream = streamResult.stream;
+            const originalStream = streamResult.stream;
+            // Create a proper tee pattern that accumulates content and stores memory after consumption
+            let accumulatedContent = "";
+            const processedStream = (async function* (self) {
+                try {
+                    for await (const chunk of originalStream) {
+                        // Enhanced chunk validation and content handling
+                        let processedChunk = chunk;
+                        if (chunk && typeof chunk === "object") {
+                            // Ensure chunk has content property and it's a string
+                            if (typeof chunk.content === "string") {
+                                accumulatedContent += chunk.content;
+                            }
+                            else if (chunk.content === undefined ||
+                                chunk.content === null) {
+                                // Handle undefined/null content gracefully - create a new chunk object
+                                processedChunk = { ...chunk, content: "" };
+                            }
+                            else if (typeof chunk.content !== "string") {
+                                // Convert non-string content to string - create a new chunk object
+                                const stringContent = String(chunk.content || "");
+                                processedChunk = { ...chunk, content: stringContent };
+                                accumulatedContent += stringContent;
+                            }
+                        }
+                        else if (chunk === null || chunk === undefined) {
+                            // Create a safe empty chunk if chunk is null/undefined
+                            processedChunk = { content: "" };
+                        }
+                        yield processedChunk; // Preserve original streaming behavior with safe content
+                    }
+                }
+                finally {
+                    // Store memory after stream consumption
+                    if (self.conversationMemory) {
+                        try {
+                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
+                                ?.sessionId, enhancedOptions.context
+                                ?.userId, options.input.text, accumulatedContent);
+                            logger.debug("Stream conversation turn stored", {
+                                sessionId: enhancedOptions.context
+                                    ?.sessionId,
+                                userInputLength: options.input.text.length,
+                                responseLength: accumulatedContent.length,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("Failed to store stream conversation turn", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+            })(this);
             const responseTime = Date.now() - startTime;
             mcpLogger.debug(`[${functionTag}] MCP-enabled streaming completed`, {
                 responseTime,
@@ -774,7 +840,7 @@ export class NeuroLink {
             });
             // Convert to StreamResult format - Include analytics and evaluation from provider
             return {
-                stream,
+                stream: processedStream,
                 provider: providerName,
                 model: options.model,
                 usage: streamResult.usage,
@@ -804,6 +870,15 @@ export class NeuroLink {
             mcpLogger.warn(`[${functionTag}] MCP streaming failed, falling back to regular`, {
                 error: error instanceof Error ? error.message : String(error),
             });
+            // Initialize conversation memory for fallback path (same as success path)
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
+            // Get conversation messages for fallback context injection
+            const fallbackConversationMessages = await getConversationMessages(this.conversationMemory, {
+                prompt: options.input.text,
+                context: enhancedOptions.context,
+            });
             // Use factory to create provider without MCP
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, false, // Disable MCP for fallback
             this);
@@ -812,9 +887,46 @@ export class NeuroLink {
                 customTools: this.getCustomTools(),
                 executeTool: this.executeTool.bind(this),
             }, functionTag);
-            // Create clean options for fallback provider (remove factoryConfig)
+            // Create clean options for fallback provider and inject conversation history
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
-            const streamResult = await provider.stream(cleanOptions);
+            const fallbackOptionsWithHistory = {
+                ...cleanOptions,
+                conversationMessages: fallbackConversationMessages, // Inject conversation history in fallback
+            };
+            const streamResult = await provider.stream(fallbackOptionsWithHistory);
+            // Create a proper tee pattern for fallback that accumulates content and stores memory after consumption
+            let fallbackAccumulatedContent = "";
+            const fallbackProcessedStream = (async function* (self) {
+                try {
+                    for await (const chunk of streamResult.stream) {
+                        if (chunk && typeof chunk.content === "string") {
+                            fallbackAccumulatedContent += chunk.content;
+                        }
+                        yield chunk; // Preserve original streaming behavior
+                    }
+                }
+                finally {
+                    // Store memory after fallback stream consumption
+                    if (self.conversationMemory) {
+                        try {
+                            await self.conversationMemory.storeConversationTurn(enhancedOptions.context
+                                ?.sessionId, enhancedOptions.context
+                                ?.userId, options.input.text, fallbackAccumulatedContent);
+                            logger.debug("Fallback stream conversation turn stored", {
+                                sessionId: enhancedOptions.context
+                                    ?.sessionId,
+                                userInputLength: options.input.text.length,
+                                responseLength: fallbackAccumulatedContent.length,
+                            });
+                        }
+                        catch (error) {
+                            logger.warn("Failed to store fallback stream conversation turn", {
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        }
+                    }
+                }
+            })(this);
             const responseTime = Date.now() - startTime;
             // Emit stream completion event for fallback
             this.emitter.emit("stream:end", {
@@ -823,7 +935,7 @@ export class NeuroLink {
                 fallback: true,
             });
             return {
-                stream: streamResult.stream,
+                stream: fallbackProcessedStream,
                 provider: providerName,
                 model: options.model,
                 usage: streamResult.usage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.21.0",
+  "version": "7.23.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",