n8n-nodes-tembory 1.0.36 → 1.0.38

package/dist/nodes/Mem0/Mem0Memory.node.js

@@ -852,10 +852,13 @@ const makeToolEventId = (tool, sequence = 0) => {
     return `tool_${hashString(base)}`;
 };
 const canonicalToolInput = (value) => {
-    const text = String(value === undefined || value === null ? '' : value).trim();
-    if (text === '""' || text === "''")
+    const text = value === undefined || value === null
+        ? ''
+        : (typeof value === 'string' ? value : stableStringify(value));
+    const trimmed = String(text).trim();
+    if (trimmed === '""' || trimmed === "''")
         return '';
-    return text;
+    return trimmed;
 };
 const normalizeToolCall = (tool, sequence = 0, defaults = {}) => {
     const at = tool.at || defaults.at || nowIso();
@@ -910,6 +913,73 @@ const readDeep = (value, visitor, seen = new Set()) => {
     for (const item of Object.values(value))
         readDeep(item, visitor, seen);
 };
+const messageTypeOf = (message) => {
+    if (typeof (message === null || message === void 0 ? void 0 : message._getType) === 'function')
+        return String(message._getType() || '');
+    return String((message === null || message === void 0 ? void 0 : message.role) || (message === null || message === void 0 ? void 0 : message.type) || (message === null || message === void 0 ? void 0 : message.lc_kwargs && message.lc_kwargs.type) || '').toLowerCase();
+};
+const messageContentOf = (message) => typeof (message === null || message === void 0 ? void 0 : message.content) === 'string' ? message.content : safeStringify(message === null || message === void 0 ? void 0 : message.content);
+const extractToolCallsFromMessages = (messages = []) => {
+    const calls = [];
+    const toolCallById = new Map();
+    const push = (tool, index = calls.length) => {
+        if (!tool || !(tool.name || tool.tool || tool.toolName))
+            return;
+        const normalized = normalizeToolCall({
+            id: tool.id || tool.callId || tool.call_id || tool.toolCallId || tool.tool_call_id,
+            turnId: tool.turnId || tool.turn_id,
+            sequence: tool.sequence || index + 1,
+            name: tool.name || tool.tool || tool.toolName,
+            input: tool.input !== undefined ? tool.input : tool.args !== undefined ? tool.args : tool.toolInput !== undefined ? tool.toolInput : '',
+            ok: tool.ok !== false,
+            result: tool.result !== undefined ? tool.result : tool.output !== undefined ? tool.output : tool.observation !== undefined ? tool.observation : '',
+            at: tool.at || nowIso(),
+            source: tool.source || 'langchain_message',
+        }, calls.length + 1);
+        calls.push(normalized);
+        if (normalized.id)
+            toolCallById.set(String(normalized.id), normalized);
+    };
+    for (const [index, message] of (messages || []).entries()) {
+        const type = messageTypeOf(message);
+        const additional = (message && (message.additional_kwargs || message.additionalKwargs)) || {};
+        const kwargs = (message && message.lc_kwargs) || {};
+        const toolCalls = message && (message.tool_calls || message.toolCalls || additional.tool_calls || additional.toolCalls || kwargs.tool_calls || kwargs.toolCalls);
+        if (Array.isArray(toolCalls)) {
+            for (const tool of toolCalls)
+                push({ ...tool, source: 'ai_message_tool_calls' }, index);
+        }
+        const invalidToolCalls = message && (message.invalid_tool_calls || message.invalidToolCalls || additional.invalid_tool_calls || additional.invalidToolCalls);
+        if (Array.isArray(invalidToolCalls)) {
+            for (const tool of invalidToolCalls)
+                push({ ...tool, ok: false, source: 'ai_message_invalid_tool_calls' }, index);
+        }
+        if (type === 'tool') {
+            const id = message.tool_call_id || message.toolCallId || additional.tool_call_id || additional.toolCallId || message.id;
+            const name = message.name || message.toolName || message.tool || additional.name || additional.tool_name || additional.toolName || kwargs.name || 'tool';
+            const existing = id ? toolCallById.get(String(id)) : null;
+            if (existing) {
+                existing.result = summarizeToolResult(messageContentOf(message));
+                existing.result_summary = existing.result;
+                existing.ok = true;
+                existing.status = 'ok';
+                existing.result_hash = stableHash(existing.result || '');
+                existing.dedupe_key = toolEventKey(existing);
+            }
+            else {
+                push({
+                    id,
+                    name,
+                    input: '',
+                    result: messageContentOf(message),
+                    ok: true,
+                    source: 'tool_message',
+                }, index);
+            }
+        }
+    }
+    return dedupeToolHistory(calls);
+};
 const extractToolCallsFromText = (text, at = nowIso()) => {
     const calls = [];
     const source = String(text || '');
@@ -1022,15 +1092,17 @@ const getMemoryStore = (ctx) => {
         data.tembory.memoryCompression = data.tembory.memoryCompression || {};
         data.tembory.activeSummary = data.tembory.activeSummary || {};
         data.tembory.connectedModelSummaryCache = data.tembory.connectedModelSummaryCache || {};
+        data.tembory.captureState = data.tembory.captureState || {};
         return data.tembory;
     }
     catch {
-        global.__temboryMemory = global.__temboryMemory || { toolHistory: {}, recentMessages: {}, profileFacts: {}, workingMemory: {}, decisionState: {}, memoryCompression: {}, activeSummary: {}, connectedModelSummaryCache: {} };
+        global.__temboryMemory = global.__temboryMemory || { toolHistory: {}, recentMessages: {}, profileFacts: {}, workingMemory: {}, decisionState: {}, memoryCompression: {}, activeSummary: {}, connectedModelSummaryCache: {}, captureState: {} };
         global.__temboryMemory.workingMemory = global.__temboryMemory.workingMemory || {};
         global.__temboryMemory.decisionState = global.__temboryMemory.decisionState || {};
         global.__temboryMemory.memoryCompression = global.__temboryMemory.memoryCompression || {};
         global.__temboryMemory.activeSummary = global.__temboryMemory.activeSummary || {};
         global.__temboryMemory.connectedModelSummaryCache = global.__temboryMemory.connectedModelSummaryCache || {};
+        global.__temboryMemory.captureState = global.__temboryMemory.captureState || {};
         return global.__temboryMemory;
     }
 };
@@ -1824,9 +1896,20 @@ const compactEntityTimelineForAgent = (timeline = [], maxItems = 8) => pruneByLi
     at: item.at,
     source: item.source_type || item.source,
 }));
+const isConversationEchoMemory = (memory) => {
+    const meta = metadataOf(memory);
+    const kind = String(meta.kind || meta.type || '').toLowerCase();
+    if (/^(recent_message|conversation_ledger|conversation_message)$/i.test(kind))
+        return true;
+    const raw = memoryText(memory);
+    if (parseRecentMessageMarker(raw) || parseConversationLedgerMarker(raw).length)
+        return true;
+    return /__tembory_conversation_ledger_v1__/.test(String(raw || ''));
+};
 const compactVectorMemoriesForAgent = (vectorMemories = [], toolHistory = [], maxItems = 3) => {
     const hasStructuredTools = Array.isArray(toolHistory) && toolHistory.length > 0;
     return (vectorMemories || [])
+        .filter((memory) => !isConversationEchoMemory(memory))
         .map((memory) => contextMemoryText(memory, 220))
         .filter(Boolean)
         .filter((text) => !/^\[recent_message\]/i.test(text))
@@ -2202,7 +2285,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
     sections.push({
         section: 'vector',
         title: 'Vector memories',
-        value: compactStateSections ? compactVectorMemoriesForAgent(vectorMemories, toolHistory, Number(adv.maxReturn || adv.topK || 4)) : vectorMemories.map((m) => {
+        value: compactStateSections ? compactVectorMemoriesForAgent(vectorMemories, toolHistory, Number(adv.maxReturn || adv.topK || 4)) : vectorMemories.filter((m) => !isConversationEchoMemory(m)).map((m) => {
             const scoreMeta = scoreMetaOf(m);
             const rawScore = scoreOf(m);
             return {
@@ -2634,6 +2717,18 @@ class Mem0Memory {
         const memoryKey = this.getNodeParameter('memoryKey', itemIndex);
         let currentMessages = [];
         const loadCache = new Map();
+        const recordMemoryEvent = (action, payload = {}, error) => {
+            const { index } = this.addInputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, [
+                [{ json: { action, ...(payload.input !== undefined ? { input: payload.input } : {}), ...(payload.values !== undefined ? { values: payload.values } : {}) } }],
+            ]);
+            if (error) {
+                this.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, error);
+                return;
+            }
+            this.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, [
+                [{ json: { action, ...payload } }],
+            ]);
+        };
         const memory = {
             memoryKeys: [memoryKey],
             inputKey: 'input',
@@ -2643,21 +2738,25 @@ class Mem0Memory {
                 getMessages: async () => currentMessages,
                 addMessage: async (message) => {
                     currentMessages.push(message);
-                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [message]);
+                    const saved = await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [message]);
+                    recordMemoryEvent('chatHistory.addMessage', { saved: Boolean(saved && saved.saved), toolCalls: (saved && saved.toolCalls) || [], messages: 1 });
                 },
                 addUserMessage: async (message) => {
                     const baseMessage = toBaseMessage({ role: 'user', content: message });
                     currentMessages.push(baseMessage);
-                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                    const saved = await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                    recordMemoryEvent('chatHistory.addUserMessage', { saved: Boolean(saved && saved.saved), toolCalls: (saved && saved.toolCalls) || [], messages: 1 });
                 },
                 addAIChatMessage: async (message) => {
                     const baseMessage = toBaseMessage({ role: 'assistant', content: message });
                     currentMessages.push(baseMessage);
-                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                    const saved = await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                    recordMemoryEvent('chatHistory.addAIChatMessage', { saved: Boolean(saved && saved.saved), toolCalls: (saved && saved.toolCalls) || [], messages: 1 });
                 },
                 addMessages: async (messages) => {
                     currentMessages.push(...messages);
-                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, messages);
+                    const saved = await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, messages);
+                    recordMemoryEvent('chatHistory.addMessages', { saved: Boolean(saved && saved.saved), toolCalls: (saved && saved.toolCalls) || [], messages: Array.isArray(messages) ? messages.length : 0 });
                 },
                 clear: async () => {
                     currentMessages = [];
@@ -2722,25 +2821,16 @@ class Mem0Memory {
     async saveMessagesForItem(itemIndex, messages = []) {
         const inputValues = {};
         const outputValues = {};
-        const toolCalls = [];
+        const toolCalls = extractToolCallsFromMessages(messages);
         const inputParts = [];
         const outputParts = [];
         for (const message of messages || []) {
-            const type = typeof (message === null || message === void 0 ? void 0 : message._getType) === 'function' ? message._getType() : String((message === null || message === void 0 ? void 0 : message.role) || '');
-            const content = typeof (message === null || message === void 0 ? void 0 : message.content) === 'string' ? message.content : safeStringify(message === null || message === void 0 ? void 0 : message.content);
+            const type = messageTypeOf(message);
+            const content = messageContentOf(message);
             if (type === 'human' || type === 'user')
                 inputParts.push(content);
             else if (type === 'ai' || type === 'assistant')
                 outputParts.push(content);
-            else if (type === 'tool') {
-                toolCalls.push({
-                    name: message.name || message.toolName || message.tool || (message.additional_kwargs && (message.additional_kwargs.name || message.additional_kwargs.tool_name)) || 'tool',
-                    input: '',
-                    ok: true,
-                    result: summarizeToolResult(content),
-                    at: nowIso(),
-                });
-            }
         }
         if (inputParts.length)
             inputValues.input = inputParts.join('\n');
@@ -2751,8 +2841,11 @@ class Mem0Memory {
             outputValues.output = outputParts.join('\n').trim();
         if (toolContext.length)
             outputValues.__temboryToolCalls = toolContext;
-        if (inputValues.input || outputValues.output)
+        if (inputValues.input || outputValues.output || toolContext.length) {
             await Mem0Memory.prototype.saveContextForItem.call(this, itemIndex, inputValues, outputValues);
+            return { saved: true, input: inputValues, output: outputValues, toolCalls: toolContext };
+        }
+        return { saved: false, input: inputValues, output: outputValues, toolCalls: toolContext };
     }
     async saveContextForItem(itemIndex, inputValues = {}, outputValues = {}) {
         const threadId = this.getNodeParameter('threadId', itemIndex);
@@ -2764,6 +2857,14 @@ class Mem0Memory {
         const rawOutput = pickText(outputValues, ['output', 'response', 'text', 'answer']);
         const output = cleanAssistantTranscriptText(rawOutput);
         const toolCalls = extractToolCalls(outputValues);
+        store.captureState[key] = {
+            last_save_at: nowIso(),
+            last_save_had_input: Boolean(input),
+            last_save_had_output: Boolean(output),
+            last_save_tool_calls_captured: toolCalls.length,
+            last_save_tool_names: toolCalls.map((tool) => tool.name).filter(Boolean).slice(0, 20),
+            last_save_capture_sources: Array.from(new Set(toolCalls.map((tool) => tool.source).filter(Boolean))),
+        };
         const recentForMem0 = [];
         const profileFromTurn = extractProfileFactsFromText(input, 'user_message', nowIso());
         if (Object.keys(profileFromTurn).length) {
@@ -3374,12 +3475,47 @@ class Mem0Memory {
                 connectedAi.errors.push(`recentMessageProbe: ${error.message || String(error)}`);
             }
         }
+        if (connectedEmbedding && adv.includeToolHistory !== false) {
+            try {
+                const toolProbe = [
+                    'Tool history ledger',
+                    'tools called in this thread tool inputs tool outputs tool status tool order action ledger',
+                    query,
+                ].filter(Boolean).join('\n');
+                const seen = new Set(vectorMemories.map((memory) => stableHash(memoryText(memory) || safeStringify(memory))));
+                for (const kind of ['tool_ledger', 'tool_history']) {
+                    const toolBody = {
+                        user_id: key,
+                        agent_id: adv.agentId ? String(adv.agentId) : undefined,
+                        run_id: adv.runId ? String(adv.runId) : undefined,
+                        top_k: Math.max(Number(adv.toolHistoryLastN || 10) * 4, 40),
+                        filters: { kind },
+                    };
+                    const toolRes = await searchClientVectorMemories(this, connectedEmbedding, toolProbe, toolBody);
+                    const toolMemories = normalizeResults(toolRes).map((memory) => withTemboryScore(memory, {
+                        semanticScore: scoreOf(memory),
+                        source: `${kind}_probe`,
+                    }));
+                    for (const memory of toolMemories) {
+                        const hash = stableHash(memoryText(memory) || safeStringify(memory));
+                        if (!seen.has(hash)) {
+                            seen.add(hash);
+                            vectorMemories.push(memory);
+                        }
+                    }
+                }
+                connectedAi.toolLedgerProbe = true;
+            }
+            catch (error) {
+                connectedAi.errors.push(`toolLedgerProbe: ${error.message || String(error)}`);
+            }
+        }
         let persistedRecentMessages = [];
         let persistedToolHistory = [];
         let persistedMemoryItems = [];
         if (adv.includeRecentMessages !== false || adv.includeToolHistory !== false) {
             try {
-                const qs = { user_id: key };
+                const qs = { user_id: key, limit: Math.max(Number(adv.recentMessagesLastN || 50) * 8, Number(adv.toolHistoryLastN || 10) * 12, 200) };
                 if (adv.agentId)
                     qs.agent_id = String(adv.agentId);
                 if (adv.runId)
@@ -3524,6 +3660,14 @@ class Mem0Memory {
             graph: graph.length,
             project: project || null,
             memoryNamespace: key,
+            captureState: store.captureState[key] || {
+                last_save_at: null,
+                last_save_had_input: false,
+                last_save_had_output: false,
+                last_save_tool_calls_captured: 0,
+                last_save_tool_names: [],
+                last_save_capture_sources: [],
+            },
             connectedAi,
             activeSummary: summaryDiagnostics,
         };
@@ -3768,6 +3912,7 @@ exports.Mem0Memory = Mem0Memory;
 exports.__private = {
     extractToolCallsFromText,
     extractToolCalls,
+    extractToolCallsFromMessages,
     toolHistoryItemsFromMemory,
     explicitToolHistoryItemsFromMemory,
     toolHistoryFromMemory,
@@ -3820,6 +3965,8 @@ exports.__private = {
     embedQueryCached,
     compactToolResult,
     compactToolHistoryForAgent,
+    compactVectorMemoriesForAgent,
+    isConversationEchoMemory,
     compactOperationalStateForAgent,
     activeSummaryIsFresh,
     readActiveSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "Tembory node for n8n AI Agents with profile, tools, timeline, graph and semantic memory",
   "license": "MIT",
   "homepage": "https://tembory.com",