n8n-nodes-token-aware-memory 0.1.28 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-token-aware-memory",
-    "version": "0.1.28",
+    "version": "0.1.29",
     "description": "Token aware memory node for n8n AI workflows",
     "license": "MIT",
     "homepage": "",
@@ -23,13 +23,7 @@
         "release": "n8n-node release",
         "prepublishOnly": "n8n-node prerelease"
     },
-    "files": [
-        "dist/nodes/TokenAwareMemory/token-aware-memory.svg",
-        "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.js",
-        "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.json",
-        "dist/package.json",
-        "README.md"
-    ],
+    "files": "dist",
     "n8n": {
         "n8nNodesApiVersion": 1,
         "strict": false,
@@ -40,7 +34,7 @@
             }
         ],
         "nodes": [
-            "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.js"
+            "nodes/TokenAwareMemory/TokenAwareMemory.node.js"
         ]
     },
     "dependencies": {

package/dist/nodes/TokenAwareMemory/TokenAwareMemory.node.js

@@ -1,270 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenAwareMemory = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const redis_1 = require("redis");
-class TokenEstimator {
-    static estimateTokens(text) {
-        return Math.ceil(text.length / 4);
-    }
-    static estimateMessageTokens(message) {
-        return message.tokens || this.estimateTokens(message.content);
-    }
-}
-class HierarchicalTokenMemory {
-    constructor(redisClient, workflowId, nodeId, sessionId, maxTokens = 8000) {
-        this.redisClient = redisClient;
-        this.compressionThreshold = Math.floor(maxTokens * 0.8);
-        this.shortTermKey = `memory:${workflowId}:${nodeId}:${sessionId}:short`;
-        this.midTermKey = `memory:${workflowId}:${nodeId}:${sessionId}:mid`;
-        this.longTermKey = `memory:${workflowId}:${nodeId}:${sessionId}:long`;
-        this.metadataKey = `memory:${workflowId}:${nodeId}:${sessionId}:meta`;
-    }
-    async initialize() {
-        try {
-            await this.redisClient.connect();
-        }
-        catch {
-        }
-    }
-    async loadMemory() {
-        const [shortTerm, midTerm, longTerm] = await Promise.all([
-            this.redisClient.lRange(this.shortTermKey, 0, -1),
-            this.redisClient.lRange(this.midTermKey, 0, -1),
-            this.redisClient.lRange(this.longTermKey, 0, -1),
-        ]);
-        const parseMessages = (rawMessages) => {
-            return rawMessages.map(msg => JSON.parse(msg)).filter(Boolean);
-        };
-        const shortTermMessages = parseMessages(shortTerm);
-        const midTermMessages = parseMessages(midTerm);
-        const longTermMessages = parseMessages(longTerm);
-        const calculateTotalTokens = (messages) => {
-            return messages.reduce((total, msg) => total + TokenEstimator.estimateMessageTokens(msg), 0);
-        };
-        return [
-            { messages: longTermMessages, totalTokens: calculateTotalTokens(longTermMessages) },
-            { messages: midTermMessages, totalTokens: calculateTotalTokens(midTermMessages) },
-            { messages: shortTermMessages, totalTokens: calculateTotalTokens(shortTermMessages) },
-        ];
-    }
-    async getTotalTokens() {
-        const levels = await this.loadMemory();
-        return levels.reduce((total, level) => total + level.totalTokens, 0);
-    }
-    async saveMessage(role, content) {
-        const message = {
-            role,
-            content,
-            timestamp: new Date().toISOString(),
-            tokens: TokenEstimator.estimateTokens(content),
-        };
-        await this.redisClient.rPush(this.shortTermKey, JSON.stringify(message));
-    }
-    async compressMemory(llmConnection, summarizationPrompt) {
-        const levels = await this.loadMemory();
-        const shortTerm = levels[2];
-        if (shortTerm.messages.length > 1) {
-            const messagesToCompress = shortTerm.messages.slice(0, -1);
-            await this.redisClient.del(this.shortTermKey);
-            if (shortTerm.messages.length > 0) {
-                const recentMessage = shortTerm.messages[shortTerm.messages.length - 1];
-                await this.redisClient.rPush(this.shortTermKey, JSON.stringify(recentMessage));
-            }
-            const conversationText = messagesToCompress
-                .map(msg => `${msg.role}: ${msg.content}`)
-                .join('\n\n');
-            const prompt = summarizationPrompt.replace('{{conversation}}', conversationText);
-            const compressedContent = await this.summarizeWithLLM(llmConnection, prompt);
-            const compressedMessage = {
-                role: 'assistant',
-                content: compressedContent,
-                timestamp: new Date().toISOString(),
-                tokens: TokenEstimator.estimateTokens(compressedContent),
-            };
-            await this.redisClient.rPush(this.midTermKey, JSON.stringify(compressedMessage));
-        }
-    }
-    async summarizeWithLLM(llmConnection, prompt) {
-        return `[AI-SUMMARY] Conversation compressed for token efficiency. Original length: ${prompt.length} characters.`;
-    }
-    async getFullHistory() {
-        const levels = await this.loadMemory();
-        const [longTerm, midTerm, shortTerm] = levels;
-        return [...longTerm.messages, ...midTerm.messages, ...shortTerm.messages];
-    }
-    async clear() {
-        await Promise.all([
-            this.redisClient.del(this.shortTermKey),
-            this.redisClient.del(this.midTermKey),
-            this.redisClient.del(this.longTermKey),
-            this.redisClient.del(this.metadataKey),
-        ]);
-    }
-    async disconnect() {
-        try {
-            await this.redisClient.disconnect();
-        }
-        catch {
-        }
-    }
-}
-class TokenAwareMemory {
-    constructor() {
-        this.description = {
-            displayName: 'Token Aware Memory',
-            name: 'tokenAwareMemory',
-            icon: 'file:token-aware-memory.svg',
-            group: ['transform'],
-            version: 1,
-            description: 'Token-aware memory node with hierarchical storage, Redis persistence, and automatic compression using LLM summarization.',
-            defaults: {
-                name: 'Token Aware Memory',
-            },
-            codex: {
-                categories: ['AI'],
-                subcategories: {
-                    AI: ['Memory'],
-                    Memory: ['Other memories'],
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/',
-                        },
-                    ],
-                },
-            },
-            inputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
-            outputs: [n8n_workflow_1.NodeConnectionTypes.AiMemory],
-            outputNames: ['Memory'],
-            usableAsTool: true,
-            credentials: [
-                {
-                    name: 'redisApi',
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Max Tokens',
-                    name: 'maxTokens',
-                    type: 'number',
-                    default: 8000,
-                    description: 'Maximum total tokens allowed before triggering automatic compression',
-                    typeOptions: {
-                        minValue: 1000,
-                    },
-                },
-                {
-                    displayName: 'Summarization Prompt',
-                    name: 'summarizationPrompt',
-                    type: 'string',
-                    default: 'Please summarize the following conversation history concisely while preserving key information and context:\n\n{{conversation}}',
-                    description: 'Prompt template used when compressing messages. Use {{conversation}} as placeholder for the content to summarize.',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                },
-                {
-                    displayName: 'Redis Credentials',
-                    name: 'redisCredentials',
-                    type: 'credentials',
-                    default: '',
-                    required: true,
-                    description: 'Redis connection credentials for memory persistence',
-                },
-                {
-                    displayName: 'Session ID',
-                    name: 'sessionId',
-                    type: 'string',
-                    default: '',
-                    description: 'Unique session identifier to separate memory between different conversations/executions (leave empty for auto-generated)',
-                },
-            ],
-        };
-    }
-    async supplyData(itemIndex) {
-        const maxTokens = this.getNodeParameter('maxTokens', itemIndex, 8000);
-        const summarizationPrompt = this.getNodeParameter('summarizationPrompt', itemIndex, '');
-        let sessionId = this.getNodeParameter('sessionId', itemIndex, '');
-        if (!sessionId) {
-            sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        }
-        const credentials = await this.getCredentials('redis', itemIndex);
-        try {
-            const redisOptions = {
-                socket: {
-                    host: credentials.host,
-                    port: credentials.port || 6379,
-                    tls: credentials.ssl === true,
-                },
-                database: credentials.database || 0,
-            };
-            if (credentials.user) {
-                redisOptions.username = credentials.user;
-            }
-            if (credentials.password) {
-                redisOptions.password = credentials.password;
-            }
-            const redisClient = (0, redis_1.createClient)(redisOptions);
-            redisClient.on('error', async (error) => {
-                await redisClient.disconnect();
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Redis Error: ' + error.message);
-            });
-            const workflowId = this.getWorkflow().id || 'default-workflow';
-            const nodeId = this.getNode().id || 'default-node';
-            const memory = new HierarchicalTokenMemory(redisClient, workflowId, nodeId, sessionId, maxTokens);
-            await memory.initialize();
-            let llmConnection = null;
-            try {
-                llmConnection = null;
-            }
-            catch {
-            }
-            const memoryInterface = {
-                loadMemoryVariables: async () => {
-                    const history = await memory.getFullHistory();
-                    return {
-                        history,
-                    };
-                },
-                saveContext: async (input, output) => {
-                    if (input) {
-                        await memory.saveMessage('user', String(input));
-                    }
-                    if (output) {
-                        await memory.saveMessage('assistant', String(output));
-                    }
-                    const totalTokens = await memory.getTotalTokens();
-                    if (totalTokens >= memory['compressionThreshold']) {
-                        if (!llmConnection || !summarizationPrompt) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LLM connection and summarization prompt are required for memory compression');
-                        }
-                        await memory.compressMemory(llmConnection, summarizationPrompt);
-                    }
-                },
-                clear: async () => {
-                    await memory.clear();
-                },
-                getTotalTokens: async () => {
-                    return memory.getTotalTokens();
-                },
-                getFullHistory: async () => {
-                    return memory.getFullHistory();
-                },
-                disconnect: async () => {
-                    await memory.disconnect();
-                },
-            };
-            return {
-                response: memoryInterface,
-            };
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to create token-aware memory: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-}
-exports.TokenAwareMemory = TokenAwareMemory;
-//# sourceMappingURL=TokenAwareMemory.node.js.map

package/dist/nodes/TokenAwareMemory/TokenAwareMemory.node.json

@@ -1,16 +0,0 @@
-{
-    "node": "n8n-nodes-token-aware-memory",
-    "nodeVersion": "1.0",
-    "codexVersion": "1.0",
-    "categories": ["AI"],
-    "subcategories": {
-        "AI": ["Memory"]
-    },
-    "resources": {
-        "primaryDocumentation": [
-            {
-                "url": "https://github.com/org/repo?tab=readme-ov-file"
-            }
-        ]
-    }
-}

package/dist/nodes/TokenAwareMemory/token-aware-memory.svg

@@ -1,6 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-  <circle cx="12" cy="12" r="3"></circle>
-  <path d="M12 1v6m0 6v6"></path>
-  <path d="M1 12h6m6 0h6"></path>
-  <circle cx="12" cy="12" r="10" fill="none"></circle>
-</svg>

package/dist/package.json

@@ -1,60 +0,0 @@
-{
-    "name": "n8n-nodes-token-aware-memory",
-    "version": "0.1.27",
-    "description": "Token aware memory node for n8n AI workflows",
-    "license": "MIT",
-    "homepage": "",
-    "keywords": [
-        "n8n-community-node-package"
-    ],
-    "author": {
-        "name": "antspider"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/example/n8n-nodes-token-aware-memory.git"
-    },
-    "scripts": {
-        "build": "n8n-node build",
-        "build:watch": "tsc --watch",
-        "dev": "n8n-node dev",
-        "lint": "n8n-node lint",
-        "lint:fix": "n8n-node lint --fix",
-        "release": "n8n-node release",
-        "prepublishOnly": "n8n-node prerelease"
-    },
-    "files": [
-        "dist/nodes/TokenAwareMemory/token-aware-memory.svg",
-        "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.js",
-        "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.json",
-        "dist/package.json",
-        "README.md"
-    ],
-    "n8n": {
-        "n8nNodesApiVersion": 1,
-        "strict": false,
-        "credentials": [
-            {
-                "name": "redisApi",
-                "displayName": "Redis"
-            }
-        ],
-        "nodes": [
-            "dist/nodes/TokenAwareMemory/TokenAwareMemory.node.js"
-        ]
-    },
-    "dependencies": {
-        "redis": "^4.6.13"
-    },
-    "devDependencies": {
-        "@n8n/node-cli": "*",
-        "eslint": "9.32.0",
-        "prettier": "3.6.2",
-        "release-it": "^19.0.4",
-        "typescript": "5.9.2",
-        "@types/node": "^20.0.0"
-    },
-    "peerDependencies": {
-        "n8n-workflow": "*"
-    }
-}