n8n-nodes-tembory 1.0.37 → 1.0.39

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;
     }
 };
@@ -1041,8 +1113,50 @@ const userKeyFrom = (threadId, adv, project = '') => {
     return namespace ? `${namespace}::${base}` : base;
 };
 const applyOperationalPreset = (advanced = {}) => {
-    const preset = String(advanced.operationPreset || 'productionBalanced');
+    const preset = String(advanced.operationPreset || 'productionFast');
     const presets = {
+        productionFast: {
+            summarySource: 'activeContext',
+            includeConnectedModelSummary: true,
+            includeActiveSummary: true,
+            persistActiveSummary: true,
+            activeSummaryMaxChars: 1800,
+            activeSummaryRetentionDays: 30,
+            enableTransientSummaryCache: true,
+            transientSummaryCacheTTLSeconds: 300,
+            compactStateSections: true,
+            useVectorMemory: false,
+            persistBackendMemories: false,
+            includeRecentMessageProbe: false,
+            includeToolLedgerProbe: false,
+            includeContextHeader: true,
+            includeSummary: true,
+            includeScores: false,
+            includeDiagnostics: false,
+            includeRelations: false,
+            includeToolHistory: true,
+            includeToolResults: true,
+            persistToolFactsToMem0: false,
+            includeToolHistorySemanticFallback: false,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: true,
+            includeEntityTimeline: false,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: true,
+            includeRecentHighlights: false,
+            topK: 0,
+            lastN: 0,
+            maxReturn: 0,
+            toolHistoryLastN: 15,
+            recentMessagesLastN: 50,
+            vectorMemoryMaxChars: 220,
+            contextMaxChars: 9000,
+            connectedModelSummaryMaxChars: 1200,
+            connectedModelSummaryInputMaxChars: 4200,
+        },
         diagnostic: {
             summarySource: 'auto',
             includeConnectedModelSummary: true,
@@ -1617,13 +1731,13 @@ const deriveContextHealth = ({ userId = '', project = '', vectorMemories = [], r
         namespace_stable: Boolean(userId && !/^mcp-session-\d+$/i.test(String(userId))),
         has_recent_messages: Array.isArray(recentMessages) && recentMessages.length > 0,
         has_tool_history: Array.isArray(toolHistory) && toolHistory.length > 0,
-        has_vector_memories: Array.isArray(vectorMemories) && vectorMemories.length > 0,
+        has_vector_memories: diagnostics.vectorMemoryEnabled === false ? true : Array.isArray(vectorMemories) && vectorMemories.length > 0,
         has_working_memory: Boolean(workingMemory && Object.keys(workingMemory).length),
         has_decision_state: Boolean(decisionState && Object.keys(decisionState).length),
         has_memory_compression: Boolean(memoryCompression && Object.keys(memoryCompression).length),
         has_operational_state: Boolean(operationalState && Object.keys(operationalState).length),
         connected_language_model: Boolean(diagnostics.connectedAi && diagnostics.connectedAi.languageModel),
-        connected_embedding: Boolean(diagnostics.connectedAi && diagnostics.connectedAi.embedding),
+        connected_embedding: diagnostics.vectorMemoryEnabled === false ? true : Boolean(diagnostics.connectedAi && diagnostics.connectedAi.embedding),
         no_connected_ai_errors: !((diagnostics.connectedAi && diagnostics.connectedAi.errors) || []).length,
     };
     const weights = {
@@ -1824,9 +1938,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 +2327,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 {
@@ -2440,12 +2565,13 @@ class Mem0Memory {
                                     options: [
                                         { name: 'Custom', value: 'custom' },
                                         { name: 'Diagnóstico Completo', value: 'diagnostic' },
+                                        { name: 'Produção Rápida (Thread + SLM)', value: 'productionFast' },
                                         { name: 'Produção Balanceada', value: 'productionBalanced' },
                                         { name: 'Produção Econômica', value: 'productionCheap' },
                                         { name: 'Produção Nano/SLM', value: 'productionNano' },
                                         { name: 'Auditoria', value: 'audit' },
                                     ],
-                                    default: 'productionBalanced',
+                                    default: 'productionFast',
                                     description: 'Preenche defaults seguros para contexto, historico de tools e memoria ativa.',
                                 },
                                 { displayName: 'Incluir Cabeçalho de Contexto', name: 'includeContextHeader', type: 'boolean', default: true },
@@ -2472,6 +2598,10 @@ class Mem0Memory {
                                 { displayName: 'Máximo de Relações', name: 'maxRelations', type: 'number', default: 10 },
                                 { displayName: 'Incluir Action Ledger', name: 'includeActionLedger', type: 'boolean', default: true },
                                 { displayName: 'Incluir Entity Timeline', name: 'includeEntityTimeline', type: 'boolean', default: true },
+                                { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: false },
+                                { displayName: 'Persistir Memórias no Backend', name: 'persistBackendMemories', type: 'boolean', default: false },
+                                { displayName: 'Probe Vetorial de Mensagens Recentes', name: 'includeRecentMessageProbe', type: 'boolean', default: false },
+                                { displayName: 'Probe Vetorial de Tool Ledger', name: 'includeToolLedgerProbe', type: 'boolean', default: false },
                             ],
                         },
                         {
@@ -2552,18 +2682,21 @@ class Mem0Memory {
                             options: [
                                 { name: 'Custom', value: 'custom' },
                                 { name: 'Diagnóstico Completo', value: 'diagnostic' },
+                                { name: 'Produção Rápida (Thread + SLM)', value: 'productionFast' },
                                 { name: 'Produção Balanceada', value: 'productionBalanced' },
                                 { name: 'Produção Econômica', value: 'productionCheap' },
                                 { name: 'Produção Nano/SLM', value: 'productionNano' },
                                 { name: 'Auditoria', value: 'audit' },
                             ],
-                            default: 'productionBalanced',
+                            default: 'productionFast',
                             description: 'Preenche defaults seguros para contexto, diagnostico, historico de tools e mensagens recentes. Valores definidos manualmente continuam tendo prioridade.',
                         },
                         { displayName: 'Agent ID', name: 'agentId', type: 'string', default: '' },
                         { displayName: 'App ID', name: 'appId', type: 'string', default: '' },
                         { displayName: 'Run ID', name: 'runId', type: 'string', default: '' },
                         { displayName: 'Top K', name: 'topK', type: 'number', typeOptions: { minValue: 1 }, default: 25, description: 'Quantidade de memórias a recuperar (modos semânticos e limites de recentes)' },
+                        { displayName: 'Usar Memória Vetorial no Caminho Quente', name: 'useVectorMemory', type: 'boolean', default: false, description: 'Quando desligado, o padrão usa thread estruturada, tools e SLM sem buscar/vetorizar a cada turno.' },
+                        { displayName: 'Persistir Memórias no Backend', name: 'persistBackendMemories', type: 'boolean', default: false, description: 'Quando desligado, mantém o estado no workflow/static data para reduzir latência.' },
                         { displayName: 'Rerank', name: 'rerank', type: 'boolean', default: true, description: 'Reordenação por relevância (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
                         { displayName: 'Fields (lista separada por vírgula)', name: 'fields', type: 'string', default: '', description: 'Campos específicos a retornar da API (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
                         { displayName: 'Filters (JSON)', name: 'filters', type: 'json', default: '{}', description: 'Objeto de filtros avançados para busca v2', displayOptions: { show: { '/retrievalMode': ['semanticV2', 'hybrid'] } } },
@@ -2634,6 +2767,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 +2788,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 +2871,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 +2891,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 +2907,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) {
@@ -2851,7 +3002,9 @@ class Mem0Memory {
             body.app_id = String(adv.appId);
         if (adv.runId)
             body.run_id = String(adv.runId);
-        const connectedEmbedding = await getConnectedEmbedding(this, itemIndex);
+        if (adv.persistBackendMemories === false)
+            return;
+        const connectedEmbedding = adv.useVectorMemory === false ? null : await getConnectedEmbedding(this, itemIndex);
         if (connectedEmbedding) {
             const ids = { user_id: body.user_id, agent_id: body.agent_id, run_id: body.run_id };
             const clientMemories = [];
@@ -3119,6 +3272,8 @@ class Mem0Memory {
         const project = this.getNodeParameter('project', itemIndex, '');
         const adv = applyOperationalPreset(readAdvancedOptions(this, itemIndex));
         payloadFormat = adv.payloadFormat || payloadFormat;
+        const vectorMemoryEnabled = adv.useVectorMemory !== false;
+        const backendPersistenceEnabled = adv.persistBackendMemories !== false;
         const store = getMemoryStore(this);
         const key = userKeyFrom(threadId, adv, project);
         const queryParam = this.getNodeParameter('query', itemIndex, '');
@@ -3139,12 +3294,14 @@ class Mem0Memory {
         catch (error) {
             connectedAi.errors.push(`languageModel: ${error.message || String(error)}`);
         }
-        try {
-            connectedEmbedding = await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiEmbedding, itemIndex);
-            connectedAi.embedding = true;
-        }
-        catch (error) {
-            connectedAi.errors.push(`embedding: ${error.message || String(error)}`);
+        if (vectorMemoryEnabled) {
+            try {
+                connectedEmbedding = await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiEmbedding, itemIndex);
+                connectedAi.embedding = true;
+            }
+            catch (error) {
+                connectedAi.errors.push(`embedding: ${error.message || String(error)}`);
+            }
         }
         if (connectedEmbedding && typeof connectedEmbedding.embedQuery === 'function' && String(query || '').trim()) {
             try {
@@ -3166,7 +3323,7 @@ class Mem0Memory {
         catch { }
         let payload;
         let vectorMemories = [];
-        if (retrievalMode === 'semantic' || retrievalMode === 'semanticV2' || retrievalMode === 'hybrid') {
+        if (vectorMemoryEnabled && (retrievalMode === 'semantic' || retrievalMode === 'semanticV2' || retrievalMode === 'hybrid')) {
             const body = { query: String(query || '') };
             // IDs
             body.user_id = key;
@@ -3303,7 +3460,7 @@ class Mem0Memory {
                 payload = semMemories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
             }
         }
-        else {
+        else if (backendPersistenceEnabled) {
             const qs = {};
             qs.user_id = key;
             if (adv.agentId)
@@ -3339,7 +3496,7 @@ class Mem0Memory {
                 connectedAi.errors.push(`graph.relations: ${error.message || String(error)}`);
             }
         }
-        if (connectedEmbedding && adv.includeRecentMessages !== false) {
+        if (vectorMemoryEnabled && connectedEmbedding && adv.includeRecentMessages !== false && adv.includeRecentMessageProbe !== false) {
             try {
                 const transcriptProbe = [
                     'recent conversation transcript',
@@ -3374,7 +3531,7 @@ class Mem0Memory {
                 connectedAi.errors.push(`recentMessageProbe: ${error.message || String(error)}`);
             }
         }
-        if (connectedEmbedding && adv.includeToolHistory !== false) {
+        if (vectorMemoryEnabled && connectedEmbedding && adv.includeToolHistory !== false && adv.includeToolLedgerProbe !== false) {
             try {
                 const toolProbe = [
                     'Tool history ledger',
@@ -3412,7 +3569,7 @@ class Mem0Memory {
         let persistedRecentMessages = [];
         let persistedToolHistory = [];
         let persistedMemoryItems = [];
-        if (adv.includeRecentMessages !== false || adv.includeToolHistory !== false) {
+        if (backendPersistenceEnabled && (adv.includeRecentMessages !== false || adv.includeToolHistory !== false)) {
             try {
                 const qs = { user_id: key, limit: Math.max(Number(adv.recentMessagesLastN || 50) * 8, Number(adv.toolHistoryLastN || 10) * 12, 200) };
                 if (adv.agentId)
@@ -3559,6 +3716,16 @@ class Mem0Memory {
             graph: graph.length,
             project: project || null,
             memoryNamespace: key,
+            vectorMemoryEnabled,
+            backendPersistenceEnabled,
+            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,
         };
@@ -3803,6 +3970,7 @@ exports.Mem0Memory = Mem0Memory;
 exports.__private = {
     extractToolCallsFromText,
     extractToolCalls,
+    extractToolCallsFromMessages,
     toolHistoryItemsFromMemory,
     explicitToolHistoryItemsFromMemory,
     toolHistoryFromMemory,
@@ -3855,6 +4023,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.37",
+  "version": "1.0.39",
   "description": "Tembory node for n8n AI Agents with profile, tools, timeline, graph and semantic memory",
   "license": "MIT",
   "homepage": "https://tembory.com",