@juspay/neurolink 10.10.5 → 10.10.6

package/dist/core/conversationMemoryManager.d.ts

@@ -80,6 +80,31 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
      * Resets summary pointers since old pointers may reference messages that no longer exist.
      */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages, mirroring the Redis manager.
+     *
+     * Parity fix: this used to exist only on the Redis backend, so an in-memory
+     * session never turned tool activity into messages and every downstream path
+     * that reasons about tool batches (compaction, pruning, pair repair) saw a
+     * different history shape depending on `STORAGE_TYPE`.
+     *
+     * Calls are written before results — the same order the Redis flush uses —
+     * and `toolCallId` is carried on BOTH sides so `repairToolPairs` can match by
+     * id rather than adjacency (a parallel batch has no positional pairing).
+     */
+    storeToolExecution(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown — no-op for in-memory manager (no external connections to release) */
     close(): Promise<void>;
 }

package/dist/core/conversationMemoryManager.js

@@ -392,6 +392,77 @@ export class ConversationMemoryManager {
         session.lastCountedAt = undefined;
         session.lastActivity = Date.now();
     }
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages, mirroring the Redis manager.
+     *
+     * Parity fix: this used to exist only on the Redis backend, so an in-memory
+     * session never turned tool activity into messages and every downstream path
+     * that reasons about tool batches (compaction, pruning, pair repair) saw a
+     * different history shape depending on `STORAGE_TYPE`.
+     *
+     * Calls are written before results — the same order the Redis flush uses —
+     * and `toolCallId` is carried on BOTH sides so `repairToolPairs` can match by
+     * id rather than adjacency (a parallel batch has no positional pairing).
+     */
+    async storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime) {
+        await this.ensureInitialized();
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = this.createNewSession(sessionId, userId);
+            this.sessions.set(sessionId, session);
+            this.enforceSessionLimit();
+        }
+        const timestamp = (currentTime ?? new Date()).toISOString();
+        const toolNameById = new Map();
+        for (const toolCall of toolCalls ?? []) {
+            const toolCallId = toolCall.toolCallId ?? "";
+            const toolName = toolCall.toolName ?? "unknown";
+            if (toolCallId) {
+                toolNameById.set(toolCallId, toolName);
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_call",
+                content: "", // Tool calls carry their payload in `args`, not content.
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                args: (toolCall.args ?? {}),
+                timestamp,
+            });
+        }
+        for (const toolResult of toolResults ?? []) {
+            const toolCallId = toolResult.toolCallId ?? "";
+            const toolName = (toolCallId ? toolNameById.get(toolCallId) : undefined) ??
+                String(toolResult.toolName ?? "unknown");
+            const rawOutput = "output" in toolResult ? toolResult.output : toolResult.result;
+            let content;
+            if (typeof rawOutput === "string") {
+                content = rawOutput;
+            }
+            else {
+                try {
+                    content = JSON.stringify(rawOutput ?? null) ?? "null";
+                }
+                catch (error) {
+                    content = `[Serialization failed: ${error instanceof Error ? error.message : String(error)}]`;
+                }
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_result",
+                content,
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                result: {
+                    success: !toolResult.error,
+                    ...(toolResult.error ? { error: String(toolResult.error) } : {}),
+                },
+                timestamp,
+            });
+        }
+        session.lastActivity = Date.now();
+    }
     /** Close/shutdown — no-op for in-memory manager (no external connections to release) */
     async close() {
         // In-memory manager has nothing to close

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

@@ -80,6 +80,31 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
      * Resets summary pointers since old pointers may reference messages that no longer exist.
      */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages, mirroring the Redis manager.
+     *
+     * Parity fix: this used to exist only on the Redis backend, so an in-memory
+     * session never turned tool activity into messages and every downstream path
+     * that reasons about tool batches (compaction, pruning, pair repair) saw a
+     * different history shape depending on `STORAGE_TYPE`.
+     *
+     * Calls are written before results — the same order the Redis flush uses —
+     * and `toolCallId` is carried on BOTH sides so `repairToolPairs` can match by
+     * id rather than adjacency (a parallel batch has no positional pairing).
+     */
+    storeToolExecution(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown — no-op for in-memory manager (no external connections to release) */
     close(): Promise<void>;
 }

package/dist/lib/core/conversationMemoryManager.js

@@ -392,6 +392,77 @@ export class ConversationMemoryManager {
         session.lastCountedAt = undefined;
         session.lastActivity = Date.now();
     }
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages, mirroring the Redis manager.
+     *
+     * Parity fix: this used to exist only on the Redis backend, so an in-memory
+     * session never turned tool activity into messages and every downstream path
+     * that reasons about tool batches (compaction, pruning, pair repair) saw a
+     * different history shape depending on `STORAGE_TYPE`.
+     *
+     * Calls are written before results — the same order the Redis flush uses —
+     * and `toolCallId` is carried on BOTH sides so `repairToolPairs` can match by
+     * id rather than adjacency (a parallel batch has no positional pairing).
+     */
+    async storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime) {
+        await this.ensureInitialized();
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = this.createNewSession(sessionId, userId);
+            this.sessions.set(sessionId, session);
+            this.enforceSessionLimit();
+        }
+        const timestamp = (currentTime ?? new Date()).toISOString();
+        const toolNameById = new Map();
+        for (const toolCall of toolCalls ?? []) {
+            const toolCallId = toolCall.toolCallId ?? "";
+            const toolName = toolCall.toolName ?? "unknown";
+            if (toolCallId) {
+                toolNameById.set(toolCallId, toolName);
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_call",
+                content: "", // Tool calls carry their payload in `args`, not content.
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                args: (toolCall.args ?? {}),
+                timestamp,
+            });
+        }
+        for (const toolResult of toolResults ?? []) {
+            const toolCallId = toolResult.toolCallId ?? "";
+            const toolName = (toolCallId ? toolNameById.get(toolCallId) : undefined) ??
+                String(toolResult.toolName ?? "unknown");
+            const rawOutput = "output" in toolResult ? toolResult.output : toolResult.result;
+            let content;
+            if (typeof rawOutput === "string") {
+                content = rawOutput;
+            }
+            else {
+                try {
+                    content = JSON.stringify(rawOutput ?? null) ?? "null";
+                }
+                catch (error) {
+                    content = `[Serialization failed: ${error instanceof Error ? error.message : String(error)}]`;
+                }
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_result",
+                content,
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                result: {
+                    success: !toolResult.error,
+                    ...(toolResult.error ? { error: String(toolResult.error) } : {}),
+                },
+                timestamp,
+            });
+        }
+        session.lastActivity = Date.now();
+    }
     /** Close/shutdown — no-op for in-memory manager (no external connections to release) */
     async close() {
         // In-memory manager has nothing to close

package/dist/lib/neurolink.d.ts

@@ -1787,8 +1787,14 @@ export declare class NeuroLink {
         [key: string]: unknown;
     }>, currentTime?: Date): Promise<void>;
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable(): boolean;
     /**

package/dist/lib/neurolink.js

@@ -11129,11 +11129,16 @@ Current user's request: ${currentInput}`;
             });
             return;
         }
-        // Type guard to ensure it's Redis conversation memory manager
-        const redisMemory = this
-            .conversationMemory;
+        // Any backend that implements storeToolExecution — no longer a Redis cast.
+        // The in-memory manager implements it too, so tool activity becomes
+        // tool_call/tool_result messages regardless of STORAGE_TYPE.
+        const memory = this.conversationMemory;
+        if (!memory?.storeToolExecution) {
+            logger.debug("Tool execution storage not supported by this memory backend");
+            return;
+        }
         try {
-            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
+            await memory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
         }
         catch (error) {
             logger.warn("Failed to store tool executions", {
@@ -11145,15 +11150,17 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable() {
-        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
-        const hasRedisConversationMemory = this.conversationMemory &&
-            this.conversationMemory.constructor.name ===
-                "RedisConversationMemoryManager";
-        return !!(isRedisStorage && hasRedisConversationMemory);
+        return typeof this.conversationMemory?.storeToolExecution === "function";
     }
     /**
      * Get the raw messages array for a session.

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

@@ -32,6 +32,28 @@ export type IConversationMemoryManager = {
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages on the session.
+     *
+     * Declared on the interface so every backend can implement it. Previously
+     * only the Redis manager had it, and the caller reached it by casting — so
+     * on in-memory storage tool activity never became messages at all, and the
+     * compaction, pruning and pair-repair paths saw a different history shape
+     * depending on `STORAGE_TYPE`.
+     */
+    storeToolExecution?(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown the memory manager and release resources (e.g., Redis connections) */
     close?(): Promise<void>;
 };

package/dist/neurolink.d.ts

@@ -1787,8 +1787,14 @@ export declare class NeuroLink {
         [key: string]: unknown;
     }>, currentTime?: Date): Promise<void>;
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable(): boolean;
     /**

package/dist/neurolink.js

@@ -11129,11 +11129,16 @@ Current user's request: ${currentInput}`;
             });
             return;
         }
-        // Type guard to ensure it's Redis conversation memory manager
-        const redisMemory = this
-            .conversationMemory;
+        // Any backend that implements storeToolExecution — no longer a Redis cast.
+        // The in-memory manager implements it too, so tool activity becomes
+        // tool_call/tool_result messages regardless of STORAGE_TYPE.
+        const memory = this.conversationMemory;
+        if (!memory?.storeToolExecution) {
+            logger.debug("Tool execution storage not supported by this memory backend");
+            return;
+        }
         try {
-            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
+            await memory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
         }
         catch (error) {
             logger.warn("Failed to store tool executions", {
@@ -11145,15 +11150,17 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable() {
-        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
-        const hasRedisConversationMemory = this.conversationMemory &&
-            this.conversationMemory.constructor.name ===
-                "RedisConversationMemoryManager";
-        return !!(isRedisStorage && hasRedisConversationMemory);
+        return typeof this.conversationMemory?.storeToolExecution === "function";
     }
     /**
      * Get the raw messages array for a session.

package/dist/types/conversationMemoryInterface.d.ts

@@ -32,6 +32,28 @@ export type IConversationMemoryManager = {
     getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
     /** Replace the entire messages array for a session */
     setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages on the session.
+     *
+     * Declared on the interface so every backend can implement it. Previously
+     * only the Redis manager had it, and the caller reached it by casting — so
+     * on in-memory storage tool activity never became messages at all, and the
+     * compaction, pruning and pair-repair paths saw a different history shape
+     * depending on `STORAGE_TYPE`.
+     */
+    storeToolExecution?(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        output?: unknown;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>, currentTime?: Date): Promise<void>;
     /** Close/shutdown the memory manager and release resources (e.g., Redis connections) */
     close?(): Promise<void>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.10.5",
+  "version": "10.10.6",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -88,6 +88,7 @@
     "test:loop-guard-core": "npx tsx test/continuous-test-suite-loop-guard-core.ts",
     "test:openai-compat-guard": "npx tsx test/continuous-test-suite-openai-compat-guard.ts",
     "test:anthropic-guard": "npx tsx test/continuous-test-suite-anthropic-guard.ts",
+    "test:tool-storage-parity": "npx tsx test/continuous-test-suite-tool-storage-parity.ts",
     "test:middleware": "npx tsx test/continuous-test-suite-middleware.ts",
     "test:observability": "npx tsx test/continuous-test-suite-observability.ts",
     "test:ppt": "npx tsx test/continuous-test-suite-ppt.ts",