n8n-nodes-tembory 1.0.11 → 1.0.12

package/README.md

@@ -2,12 +2,14 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.0.11`.
+Versao atual: `1.0.12`.
 
 O Tembory entrega contexto rico para o AI Agent sem depender apenas do historico textual da conversa. Ele combina memoria semantica, working memory, decision state, fatos estaveis do lead, historico de tools, estado operacional, action ledger, timeline de entidades, compressao de memoria, grafo, mensagens recentes e diagnosticos.
 
 Nos presets de producao, o contexto e organizado como um pacote acionavel: secoes vazias sao removidas, evidencias de tools ficam canonicas em `tool_history`/`operational_state`, e blocos como `decision_state`, `working_memory` e `memory_compression` sao compactados sem perder IDs, proximas acoes, slots, reservas, confirmacoes e bloqueios de repeticao.
 
+Quando um modelo barato esta conectado ao Tembory, os presets de producao usam esse SLM para gerar um resumo ativo do contexto. Em modo `auto`, ele organiza tanto o estado atual (`working_memory`, `tool_history`, `operational_state`, `decision_state`) quanto memorias vetoriais recuperadas. Assim o primeiro turno ja pode receber highlights uteis mesmo antes de haver resultados do banco vetorial.
+
 ## Smoke tecnico
 
 Antes de publicar uma versao, rode:

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

@@ -882,6 +882,8 @@ const applyOperationalPreset = (advanced = {}) => {
     const preset = String(advanced.operationPreset || 'custom');
     const presets = {
         diagnostic: {
+            summarySource: 'auto',
+            includeConnectedModelSummary: true,
             includeContextHeader: true,
             includeSummary: true,
             includeScores: true,
@@ -906,6 +908,8 @@ const applyOperationalPreset = (advanced = {}) => {
             recentMessagesLastN: 8,
         },
         productionBalanced: {
+            summarySource: 'auto',
+            includeConnectedModelSummary: true,
             compactStateSections: true,
             includeContextHeader: true,
             includeSummary: true,
@@ -931,8 +935,12 @@ const applyOperationalPreset = (advanced = {}) => {
             recentMessagesLastN: 6,
             vectorMemoryMaxChars: 360,
             contextMaxChars: 10000,
+            connectedModelSummaryMaxChars: 900,
+            connectedModelSummaryInputMaxChars: 3200,
         },
         productionCheap: {
+            summarySource: 'activeContext',
+            includeConnectedModelSummary: true,
             compactStateSections: true,
             includeContextHeader: true,
             includeSummary: false,
@@ -958,8 +966,12 @@ const applyOperationalPreset = (advanced = {}) => {
             recentMessagesLastN: 4,
             vectorMemoryMaxChars: 260,
             contextMaxChars: 7000,
+            connectedModelSummaryMaxChars: 700,
+            connectedModelSummaryInputMaxChars: 2400,
         },
         productionNano: {
+            summarySource: 'auto',
+            includeConnectedModelSummary: true,
             compactForAgent: true,
             includeContextHeader: true,
             includeSummary: true,
@@ -986,8 +998,12 @@ const applyOperationalPreset = (advanced = {}) => {
             recentMessagesLastN: 2,
             vectorMemoryMaxChars: 220,
             contextMaxChars: 6000,
+            connectedModelSummaryMaxChars: 700,
+            connectedModelSummaryInputMaxChars: 2200,
         },
         audit: {
+            summarySource: 'auto',
+            includeConnectedModelSummary: true,
             includeContextHeader: true,
             includeSummary: true,
             includeScores: true,
@@ -1524,6 +1540,87 @@ const compactVectorMemoriesForAgent = (vectorMemories = [], toolHistory = [], ma
         .filter((text) => !hasStructuredTools || !/^\[tool_events_extracted\]/i.test(text))
         .slice(0, maxItems);
 };
+const modelResponseText = (response) => {
+    const content = response === null || response === void 0 ? void 0 : response.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((item) => {
+            if (typeof item === 'string')
+                return item;
+            if (item && typeof item === 'object' && typeof item.text === 'string')
+                return item.text;
+            if (item && typeof item === 'object' && typeof item.content === 'string')
+                return item.content;
+            return '';
+        }).filter(Boolean).join('\n');
+    }
+    if (typeof (response === null || response === void 0 ? void 0 : response.text) === 'string')
+        return response.text;
+    return response === undefined || response === null ? '' : String(response);
+};
+const cleanModelSummaryText = (value, max = 900) => {
+    let text = modelResponseText(value).trim();
+    if (!text)
+        return '';
+    try {
+        const parsed = JSON.parse(text);
+        text = modelResponseText(parsed) || (Array.isArray(parsed) ? parsed.map(modelResponseText).filter(Boolean).join('\n') : '');
+        if (!text && parsed && typeof parsed === 'object') {
+            const bullets = parsed.highlights || parsed.current_summary || parsed.summary || parsed.facts;
+            if (Array.isArray(bullets))
+                text = bullets.map((item) => `- ${typeof item === 'string' ? item : safeStringify(item)}`).join('\n');
+        }
+    }
+    catch { }
+    text = text
+        .replace(/^\s*\[\s*\{\s*"type"\s*:\s*"text"\s*,\s*"text"\s*:\s*"/, '')
+        .replace(/"\s*,\s*"annotations"\s*:\s*\[\s*\]\s*\}\s*\]\s*$/, '')
+        .replace(/\\n/g, '\n')
+        .trim();
+    return truncate(text, max);
+};
+const buildConnectedModelSummaryInput = ({ query, profileFacts, workingMemory, decisionState, memoryCompression, operationalState, toolHistory, recentMessages, vectorMemories, highlights, adv }) => {
+    const source = String(adv.summarySource || 'auto');
+    if (source === 'off' || source === 'disabled' || adv.includeConnectedModelSummary === false)
+        return '';
+    const includeVectors = source === 'auto' || source === 'vectorOnly' || source === 'vectors';
+    const includeActive = source === 'auto' || source === 'activeContext' || source === 'active';
+    const payload = cleanContextValue({
+        query: String(query || ''),
+        active_context: includeActive ? {
+            profile_facts: renderProfileFacts(profileFacts),
+            working_memory: compactWorkingMemoryForAgent(workingMemory || {}),
+            decision_state: compactDecisionStateForAgent(decisionState || {}),
+            operational_state: compactOperationalStateForAgent(operationalState || {}),
+            memory_compression: compactMemoryCompressionForAgent(memoryCompression || {}),
+            tool_history: compactToolHistoryForAgent(toolHistory || [], adv.summaryToolHistoryLastN || adv.toolHistoryLastN || 6, adv.includeToolResults !== false),
+            recent_messages: pruneByLimit(recentMessages || [], adv.summaryRecentMessagesLastN || 4).map((message) => cleanContextValue({
+                role: message.role,
+                content: truncate(message.content, 240),
+                at: message.at,
+            })),
+            highlights: (highlights || []).slice(0, adv.summaryHighlightsMaxItems || 4),
+        } : undefined,
+        vector_memories: includeVectors ? compactVectorMemoriesForAgent(vectorMemories || [], toolHistory || [], adv.summaryMaxFacts || 4) : undefined,
+    });
+    const hasActiveSignal = includeActive && Boolean((payload.active_context && Object.keys(payload.active_context).length) || payload.query);
+    const hasVectorSignal = includeVectors && Array.isArray(payload.vector_memories) && payload.vector_memories.length > 0;
+    if (!hasActiveSignal && !hasVectorSignal)
+        return '';
+    return truncate(safeStringify(payload), Number(adv.connectedModelSummaryInputMaxChars || 3000));
+};
+const invokeConnectedModelSummary = async (connectedLanguageModel, summaryInput, adv = {}) => {
+    if (!connectedLanguageModel || typeof connectedLanguageModel.invoke !== 'function' || !summaryInput)
+        return '';
+    const response = await connectedLanguageModel.invoke([
+        toBaseMessage({
+            role: 'user',
+            content: `Organize the Tembory memory context for the next agent turn. Return concise Portuguese bullets only. Preserve IDs, dates, tool names, next action, do-not-repeat instructions, and contradictions. Do not invent facts.\n\nContext:\n${summaryInput}`,
+        }),
+    ]);
+    return cleanModelSummaryText(response, Number(adv.connectedModelSummaryMaxChars || 900));
+};
 const contextSizeOfMessages = (messages = []) => {
     const perMessage = (messages || []).map((message, index) => {
         const content = String(message.content || '');
@@ -1601,7 +1698,7 @@ const wrapTemboryMemory = (memory, ctx, memoryKey) => new Proxy(memory, {
         return target[prop];
     },
 });
-const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, workingMemory, decisionState, memoryCompression, operationalState, actionLedger, entityTimeline, vectorMemories, recentMessages, toolHistory, highlights, graph, diagnostics, adv }) => {
+const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, workingMemory, decisionState, memoryCompression, operationalState, actionLedger, entityTimeline, vectorMemories, recentMessages, toolHistory, highlights, graph, diagnostics, connectedModelSummary, adv }) => {
     const includeHeader = adv.includeContextHeader !== false;
     const includeSummary = adv.includeSummary !== false;
     const includeScores = adv.includeScores !== false;
@@ -1622,6 +1719,9 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             const summary = compactVectorMemoriesForAgent(vectorMemories, toolHistory, Number(adv.summaryMaxFacts || 3));
             sections.push({ section: 'summary', title: 'Summary', value: summary.length ? summary : null, why_null: summary.length ? undefined : 'no non-tool vector memories to summarize' });
         }
+        if (connectedModelSummary && adv.includeConnectedModelSummary !== false) {
+            sections.push({ section: 'connected_model_summary', title: 'SLM summary', value: connectedModelSummary });
+        }
         sections.push({
             section: 'working_memory',
             title: 'Working memory',
@@ -1687,6 +1787,9 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             : vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map((memory) => contextMemoryText(memory, 360)).filter(Boolean);
         sections.push({ section: 'summary', title: 'Summary', value: summary.length ? summary : null, why_null: summary.length ? undefined : 'no vector memories to summarize' });
     }
+    if (connectedModelSummary && adv.includeConnectedModelSummary !== false) {
+        sections.push({ section: 'connected_model_summary', title: 'SLM summary', value: connectedModelSummary });
+    }
     sections.push({
         section: 'working_memory',
         title: 'Working memory',
@@ -1995,6 +2098,22 @@ class Mem0Memory {
                         { displayName: 'Organizar Seções de Produção', name: 'compactStateSections', type: 'boolean', default: false, description: 'Renderiza blocos de produção com campos canônicos, remove seções vazias e evita duplicar evidências já presentes em tool_history/operational_state.' },
                         { displayName: 'Máximo de Caracteres do Contexto', name: 'contextMaxChars', type: 'number', default: 6000, description: 'Limite final aplicado ao contexto entregue ao agente em modos estruturados de produção.' },
                         { displayName: 'Incluir Resumo', name: 'includeSummary', type: 'boolean', default: true },
+                        { displayName: 'Incluir Resumo do SLM', name: 'includeConnectedModelSummary', type: 'boolean', default: true, description: 'Usa o modelo barato conectado ao Tembory para organizar contexto ativo e/ou memórias vetoriais em bullets curtos.' },
+                        {
+                            displayName: 'Fonte do Resumo do SLM',
+                            name: 'summarySource',
+                            type: 'options',
+                            options: [
+                                { name: 'Automático', value: 'auto' },
+                                { name: 'Contexto Ativo', value: 'activeContext' },
+                                { name: 'Somente Vetores', value: 'vectorOnly' },
+                                { name: 'Desligado', value: 'off' },
+                            ],
+                            default: 'auto',
+                            description: 'Define se o SLM resume working memory/tool state, memórias vetoriais, ambos ou nada.',
+                        },
+                        { displayName: 'Máximo de Caracteres de Entrada do SLM', name: 'connectedModelSummaryInputMaxChars', type: 'number', default: 3000 },
+                        { displayName: 'Máximo de Caracteres do Resumo do SLM', name: 'connectedModelSummaryMaxChars', type: 'number', default: 900 },
                         { displayName: 'Máximo de Fatos no Resumo', name: 'summaryMaxFacts', type: 'number', default: 4 },
                         { displayName: 'Incluir Scores', name: 'includeScores', type: 'boolean', default: true },
                         { displayName: 'Incluir Diagnóstico', name: 'includeDiagnostics', type: 'boolean', default: false },
@@ -2623,34 +2742,6 @@ class Mem0Memory {
             }
             catch { }
         }
-        let connectedModelSummary = '';
-        if (connectedLanguageModel && typeof connectedLanguageModel.invoke === 'function' && vectorMemories.length && adv.includeSummary !== false) {
-            try {
-                const facts = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map((memory) => contextMemoryText(memory, 500)).filter(Boolean).join('\n') || '(no vector memories found)';
-                if (facts) {
-                    const response = await connectedLanguageModel.invoke([
-                        toBaseMessage({
-                            role: 'user',
-                            content: `Summarize available Tembory context as concise factual bullets. If there are no memories, return exactly "(empty)".\n\nQuery: ${String(query || '')}\n\nMemories:\n${truncate(facts, 3000)}`,
-                        }),
-                    ]);
-                    connectedModelSummary = truncate(response?.content || response?.text || String(response || ''), 1200);
-                    connectedAi.languageModelSummary = true;
-                }
-            }
-            catch (error) {
-                connectedAi.errors.push(`languageModel.invoke: ${error.message || String(error)}`);
-            }
-        }
-        const diagnostics = {
-            vectorMemories: vectorMemories.length,
-            recentMessages: recentMessages.length,
-            toolHistory: toolHistory.length,
-            graph: graph.length,
-            project: project || null,
-            memoryNamespace: key,
-            connectedAi,
-        };
         const includeToolResults = adv.includeToolResults !== false;
         const operationalState = deriveOperationalState(toolHistory, renderProfileFacts(profileFacts), recentMessages, includeToolResults);
         const actionLedger = deriveActionLedger(toolHistory, adv.actionLedgerMaxItems || adv.toolHistoryLastN || 20, includeToolResults);
@@ -2677,6 +2768,38 @@ class Mem0Memory {
             vectorMemories,
             maxItems: adv.compressionMaxItems || 6,
         });
+        let connectedModelSummary = '';
+        if (connectedLanguageModel && typeof connectedLanguageModel.invoke === 'function' && adv.includeSummary !== false && adv.includeConnectedModelSummary !== false) {
+            try {
+                const summaryInput = buildConnectedModelSummaryInput({
+                    query,
+                    profileFacts,
+                    workingMemory,
+                    decisionState,
+                    memoryCompression,
+                    operationalState,
+                    toolHistory,
+                    recentMessages,
+                    vectorMemories,
+                    highlights,
+                    adv,
+                });
+                connectedModelSummary = await invokeConnectedModelSummary(connectedLanguageModel, summaryInput, adv);
+                connectedAi.languageModelSummary = Boolean(connectedModelSummary);
+            }
+            catch (error) {
+                connectedAi.errors.push(`languageModel.invoke: ${error.message || String(error)}`);
+            }
+        }
+        const diagnostics = {
+            vectorMemories: vectorMemories.length,
+            recentMessages: recentMessages.length,
+            toolHistory: toolHistory.length,
+            graph: graph.length,
+            project: project || null,
+            memoryNamespace: key,
+            connectedAi,
+        };
         const contextHealth = deriveContextHealth({
             userId: key,
             project,
@@ -2714,6 +2837,7 @@ class Mem0Memory {
             highlights,
             graph,
             diagnostics,
+            connectedModelSummary,
             adv,
         });
         diagnostics.contextSize = contextSizeOfMessages(payload);
@@ -2949,4 +3073,7 @@ exports.__private = {
     compactToolResult,
     compactToolHistoryForAgent,
     compactOperationalStateForAgent,
+    buildConnectedModelSummaryInput,
+    cleanModelSummaryText,
+    invokeConnectedModelSummary,
 };

package/package.json

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