@juspay/neurolink 9.10.1 → 9.12.0

package/dist/lib/memory/memoryRetrievalTools.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Memory retrieval tools for LLM access to conversation history.
+ * Enables the AI to retrieve full tool outputs, review previous messages,
+ * and search conversation memory.
+ *
+ * Follows the createFileTools() factory pattern from files/fileTools.ts.
+ * @module
+ */
+import { z } from "zod";
+import type { RedisConversationMemoryManager } from "../core/redisConversationMemoryManager.js";
+/**
+ * Factory function that creates memory retrieval tools bound to a memory manager.
+ * @param memoryManager - The Redis conversation memory manager instance
+ * @returns Record of tool name to Vercel AI SDK tool definition
+ */
+export declare function createMemoryRetrievalTools(memoryManager: RedisConversationMemoryManager): {
+    retrieve_context: import("ai").Tool<z.ZodObject<{
+        sessionId: z.ZodString;
+        messageId: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<["user", "assistant", "system", "tool_call", "tool_result"]>>;
+        lastN: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sessionId: string;
+        search?: string | undefined;
+        role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+        messageId?: string | undefined;
+        lastN?: number | undefined;
+    }, {
+        sessionId: string;
+        search?: string | undefined;
+        role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+        messageId?: string | undefined;
+        lastN?: number | undefined;
+    }>, {
+        error: string;
+        sessionId: string;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        error: string;
+        messageId: string;
+        sessionId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    } | {
+        messages: ({
+            id: string;
+            error: string;
+            role?: undefined;
+            tool?: undefined;
+            matchCount?: undefined;
+            matches?: undefined;
+            totalSize?: undefined;
+            content?: undefined;
+            hasMore?: undefined;
+        } | {
+            id: string;
+            role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+            tool: string | undefined;
+            matchCount: number;
+            matches: {
+                line: number;
+                text: string;
+            }[];
+            totalSize: number;
+            error?: undefined;
+            content?: undefined;
+            hasMore?: undefined;
+        } | {
+            id: string;
+            role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+            tool: string | undefined;
+            content: string;
+            totalSize: number;
+            hasMore: boolean;
+            error?: undefined;
+            matchCount?: undefined;
+            matches?: undefined;
+        })[];
+        totalMessages: number;
+        error?: undefined;
+        sessionId?: undefined;
+        messageId?: undefined;
+    } | {
+        error: string;
+        sessionId?: undefined;
+        messageId?: undefined;
+        messages?: undefined;
+        totalMessages?: undefined;
+    }> & {
+        execute: (args: {
+            sessionId: string;
+            search?: string | undefined;
+            role?: "system" | "user" | "assistant" | "tool_call" | "tool_result" | undefined;
+            offset?: number | undefined;
+            limit?: number | undefined;
+            messageId?: string | undefined;
+            lastN?: number | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            error: string;
+            sessionId: string;
+            messageId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        } | {
+            error: string;
+            messageId: string;
+            sessionId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        } | {
+            messages: ({
+                id: string;
+                error: string;
+                role?: undefined;
+                tool?: undefined;
+                matchCount?: undefined;
+                matches?: undefined;
+                totalSize?: undefined;
+                content?: undefined;
+                hasMore?: undefined;
+            } | {
+                id: string;
+                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+                tool: string | undefined;
+                matchCount: number;
+                matches: {
+                    line: number;
+                    text: string;
+                }[];
+                totalSize: number;
+                error?: undefined;
+                content?: undefined;
+                hasMore?: undefined;
+            } | {
+                id: string;
+                role: "system" | "user" | "assistant" | "tool_call" | "tool_result";
+                tool: string | undefined;
+                content: string;
+                totalSize: number;
+                hasMore: boolean;
+                error?: undefined;
+                matchCount?: undefined;
+                matches?: undefined;
+            })[];
+            totalMessages: number;
+            error?: undefined;
+            sessionId?: undefined;
+            messageId?: undefined;
+        } | {
+            error: string;
+            sessionId?: undefined;
+            messageId?: undefined;
+            messages?: undefined;
+            totalMessages?: undefined;
+        }>;
+    };
+};

package/dist/lib/memory/memoryRetrievalTools.js

@@ -0,0 +1,145 @@
+/**
+ * Memory retrieval tools for LLM access to conversation history.
+ * Enables the AI to retrieve full tool outputs, review previous messages,
+ * and search conversation memory.
+ *
+ * Follows the createFileTools() factory pattern from files/fileTools.ts.
+ * @module
+ */
+import { tool } from "ai";
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+/** Maximum characters returned per retrieval request */
+const DEFAULT_RETRIEVAL_LIMIT = 50_000;
+/** Hard maximum for user/LLM-supplied limit to prevent massive tool outputs */
+const MAX_RETRIEVAL_LIMIT = 200_000;
+/** Maximum number of search matches returned */
+const MAX_SEARCH_MATCHES = 50;
+/**
+ * Factory function that creates memory retrieval tools bound to a memory manager.
+ * @param memoryManager - The Redis conversation memory manager instance
+ * @returns Record of tool name to Vercel AI SDK tool definition
+ */
+export function createMemoryRetrievalTools(memoryManager) {
+    return {
+        retrieve_context: tool({
+            description: "Retrieve messages from conversation memory. Use this to access full tool " +
+                "outputs when a result was truncated, review previous assistant responses, " +
+                "or search through conversation history. Supports filtering by role, " +
+                "pagination for large content, and regex search within messages.",
+            parameters: z.object({
+                sessionId: z.string().describe("Session ID for the conversation"),
+                messageId: z
+                    .string()
+                    .optional()
+                    .describe("Specific message ID to retrieve"),
+                role: z
+                    .enum(["user", "assistant", "system", "tool_call", "tool_result"])
+                    .optional()
+                    .describe("Filter messages by role"),
+                lastN: z
+                    .number()
+                    .int()
+                    .positive()
+                    .optional()
+                    .describe("Retrieve the last N messages matching the filter"),
+                offset: z
+                    .number()
+                    .int()
+                    .nonnegative()
+                    .optional()
+                    .describe("Character offset for paginated reading of large content (default: 0)"),
+                limit: z
+                    .number()
+                    .int()
+                    .positive()
+                    .optional()
+                    .describe("Max characters to return per message (default: 50000)"),
+                search: z
+                    .string()
+                    .optional()
+                    .describe("Regex pattern to search within message content. " +
+                    "Returns matching lines with line numbers."),
+            }),
+            execute: async (args) => {
+                try {
+                    const conversation = await memoryManager.getSessionRaw(args.sessionId);
+                    if (!conversation) {
+                        return { error: "Session not found", sessionId: args.sessionId };
+                    }
+                    let messages = conversation.messages;
+                    // Filter by specific messageId
+                    if (args.messageId) {
+                        const msg = messages.find((m) => m.id === args.messageId);
+                        if (!msg) {
+                            return { error: "Message not found", messageId: args.messageId };
+                        }
+                        messages = [msg];
+                    }
+                    // Filter by role
+                    if (args.role) {
+                        messages = messages.filter((m) => m.role === args.role);
+                    }
+                    // Take last N
+                    if (args.lastN) {
+                        messages = messages.slice(-args.lastN);
+                    }
+                    const charLimit = Math.min(args.limit ?? DEFAULT_RETRIEVAL_LIMIT, MAX_RETRIEVAL_LIMIT);
+                    const results = messages.map((msg) => {
+                        const content = msg.content ?? "";
+                        // Search mode: return matching lines with line numbers
+                        if (args.search) {
+                            try {
+                                const pattern = args.search;
+                                // Validate regex length to mitigate ReDoS from LLM-provided input
+                                if (pattern.length > 200) {
+                                    return {
+                                        id: msg.id,
+                                        error: "Search pattern too long (max 200 chars)",
+                                    };
+                                }
+                                const regex = new RegExp(pattern, "i"); // no 'g' flag — avoids stateful .test() bug
+                                const lines = content.split("\n");
+                                const matches = lines
+                                    .map((line, i) => ({ line: i + 1, text: line }))
+                                    .filter((l) => regex.test(l.text))
+                                    .slice(0, MAX_SEARCH_MATCHES);
+                                return {
+                                    id: msg.id,
+                                    role: msg.role,
+                                    tool: msg.tool,
+                                    matchCount: matches.length,
+                                    matches,
+                                    totalSize: content.length,
+                                };
+                            }
+                            catch {
+                                return { id: msg.id, error: "Invalid regex pattern" };
+                            }
+                        }
+                        // Paginated read mode
+                        const start = args.offset ?? 0;
+                        const end = start + charLimit;
+                        const slice = content.slice(start, end);
+                        return {
+                            id: msg.id,
+                            role: msg.role,
+                            tool: msg.tool,
+                            content: slice,
+                            totalSize: content.length,
+                            hasMore: end < content.length,
+                        };
+                    });
+                    return { messages: results, totalMessages: results.length };
+                }
+                catch (error) {
+                    logger.error("[MemoryRetrievalTools] Error retrieving context", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    return { error: "Failed to retrieve context" };
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=memoryRetrievalTools.js.map

package/dist/lib/neurolink.d.ts

@@ -6,7 +6,7 @@
  * Uses real MCP infrastructure for tool discovery and execution.
  */
 import { type CompactionConfig, type CompactionResult } from "./context/contextCompactor.js";
-import type { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
@@ -123,6 +123,7 @@ export declare class NeuroLink {
     private hitlManager?;
     private mem0Instance?;
     private mem0Config?;
+    private _sessionCostUsd;
     private fileRegistry;
     private cachedFileTools;
     /**
@@ -215,6 +216,12 @@ export declare class NeuroLink {
      * and registers them as direct tools so they're available to LLMs.
      */
     private registerFileTools;
+    /**
+     * Register memory retrieval tools that allow the AI to access
+     * conversation history, including full tool outputs.
+     * Only registered when Redis conversation memory is active.
+     */
+    private registerMemoryRetrievalTools;
     /** Format memory context for prompt inclusion */
     private formatMemoryContext;
     /** Extract memory context from search results */
@@ -469,6 +476,10 @@ export declare class NeuroLink {
      * Schedule non-blocking Mem0 memory storage after generate completes.
      */
     private scheduleGenerateMem0Storage;
+    /**
+     * Handle PPT generation mode
+     */
+    private generateWithPPT;
     /**
      * Generate with workflow engine integration
      * Returns both original and processed responses for AB testing
@@ -1186,6 +1197,29 @@ export declare class NeuroLink {
      * @returns boolean indicating if Redis storage is configured and available
      */
     isToolExecutionStorageAvailable(): boolean;
+    /**
+     * Get the raw messages array for a session.
+     * Returns the full messages list without context filtering or summarization.
+     * @param sessionId - The session ID to retrieve messages for
+     * @returns Array of ChatMessage objects, or empty array if session doesn't exist
+     */
+    getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
+    /**
+     * Replace the entire messages array for a session.
+     * @param sessionId - The session ID to update
+     * @param messages - The new messages array
+     * @param userId - Optional user ID for scoped Redis key lookup
+     */
+    setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
+    /**
+     * Modify the last assistant message in a session using a transformer function.
+     * Convenience wrapper around getSessionMessages/setSessionMessages.
+     * @param sessionId - The session ID to modify
+     * @param transformer - Function that receives the last assistant message content and returns the modified content
+     * @param userId - Optional user ID for scoped Redis key lookup
+     * @returns true if a message was modified, false if no assistant message was found
+     */
+    modifyLastAssistantMessage(sessionId: string, transformer: (content: string) => string, userId?: string): Promise<boolean>;
     /**
      * Add an external MCP server
      * Automatically discovers and registers tools from the server