n8n-nodes-tembory 1.1.40 → 1.1.42

package/README.md

@@ -2,7 +2,19 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.40`.
+Versao atual: `1.1.42`.
+
+## 1.1.42
+
+- Explicita `conversation` e `conversationTimeline` tambem no payload visual de `saveContext`.
+- Aumenta a timeline visual de conversa do `loadMemoryVariables` para ate 16 mensagens recentes.
+- Parseia resultados de tools de busca vetorial em `outputParsed.documents`, preservando `pageContent`, `metadata`, `id`, `source` e `score` quando existirem.
+
+## 1.1.41
+
+- Padroniza a saida visual do node com `visualSchema`, `memorySummary` e `toolLog` tanto no `loadMemoryVariables` quanto no `saveContext`.
+- Mantem `toolEvents` para compatibilidade, mas agora tambem mostra `inputParsed`, `outputParsed`, timestamps e `facts` com IDs operacionais quando existirem.
+- Aumenta a visibilidade do historico recente de tools no resumo visual para evitar esconder eventos importantes no debug humano.
 
 ## 1.1.40
 

package/dist/nodes/Tembory/TemboryMemory.node.js

@@ -2680,9 +2680,44 @@ const extractToolOperationalFacts = (tool = {}) => {
     const facts = mergeOperationalFactObjects(outputFacts, inputFacts);
     return Object.keys(facts || {}).length ? facts : undefined;
 };
+const compactVectorDocumentForSideChannel = (value) => {
+    const original = value;
+    let parsed = value;
+    if (typeof parsed === 'string')
+        parsed = tryParseJsonValue(parsed) || parsed;
+    if (parsed && typeof parsed === 'object' && typeof parsed.text === 'string') {
+        const textParsed = tryParseJsonValue(parsed.text);
+        if (textParsed && typeof textParsed === 'object')
+            parsed = { ...parsed, ...textParsed };
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    const pageContent = parsed.pageContent || parsed.content || parsed.document || (original && original.type === 'text' ? parsed.text : undefined);
+    const rawMetadata = parsed.metadata && typeof parsed.metadata === 'object' ? parsed.metadata : undefined;
+    const metadata = rawMetadata ? stripNoisyToolFields(rawMetadata) : undefined;
+    if (!pageContent && !metadata)
+        return undefined;
+    return cleanContextValue({
+        pageContent: pageContent ? truncate(String(pageContent), 1200) : undefined,
+        metadata,
+        id: parsed.id || metadata?.id,
+        source: parsed.source || rawMetadata?.source,
+        score: parsed.score || metadata?.score,
+    });
+};
+const compactVectorDocumentsForSideChannel = (value) => {
+    const items = Array.isArray(value) ? value : [value];
+    return items
+        .map((item) => compactVectorDocumentForSideChannel(item))
+        .filter((item) => item && Object.keys(item).length)
+        .slice(0, 8);
+};
 const compactParsedToolOutputForSideChannel = (parsed) => {
     if (parsed === undefined || parsed === null)
         return undefined;
+    const vectorDocuments = compactVectorDocumentsForSideChannel(parsed);
+    if (vectorDocuments.length)
+        return cleanContextValue({ documents: vectorDocuments, count: vectorDocuments.length });
     if (Array.isArray(parsed))
         return cleanContextValue(parsed.map((item) => compactParsedToolOutputForSideChannel(item)));
     if (typeof parsed !== 'object')
@@ -3006,6 +3041,16 @@ const invokeConnectedModelSummary = async (connectedLanguageModel, summaryInput,
     ]);
     return cleanModelSummaryText(response, Number(adv.connectedModelSummaryMaxChars || 1200));
 };
+const VISUAL_SCHEMA_VERSION = 'tembory.visual.v1';
+const TOOL_LOG_VISUAL_SCHEMA_VERSION = 'tembory.visual.v1.toolLog';
+const SIDE_CHANNEL_TOOL_EVENT_MAX = 12;
+const SIDE_CHANNEL_SAVE_TOOL_EVENT_MAX = 20;
+const compactParsedToolInputForSideChannel = (input) => {
+    const parsed = safeParseToolPayload(input);
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    return cleanContextValue(stripNoisyToolFields(parsed));
+};
 const compactToolAuditForSideChannel = (tool = {}) => {
     const capturedAt = tool.at || tool.timestamp;
     const rawResult = tool.result !== undefined ? tool.result : tool.output !== undefined ? tool.output : tool.observation;
@@ -3019,10 +3064,36 @@ const compactToolAuditForSideChannel = (tool = {}) => {
         toolTimestamp: toolResultTimestampFromParsed(parsedResult),
         toolStatus: parsedResult && typeof parsedResult === 'object' && !Array.isArray(parsedResult) ? parsedResult.status : undefined,
         input: truncate(String(tool.input || tool.tool_args || tool.normalized_args || ''), 300) || undefined,
+        inputParsed: compactParsedToolInputForSideChannel(tool.input || tool.tool_args || tool.normalized_args),
         output: compactToolResult(rawResult, 800),
         outputParsed: compactParsedToolOutputForSideChannel(parsedResult),
+        facts: extractToolOperationalFacts(tool),
     });
 };
+const compactToolEventsForSideChannel = (toolItems = [], maxItems = SIDE_CHANNEL_TOOL_EVENT_MAX) => pruneByLimit(toolItems || [], maxItems)
+    .map((tool) => compactToolAuditForSideChannel(tool || {}))
+    .filter((tool) => tool && Object.keys(tool).length);
+const buildToolLogForSideChannel = (toolEvents = [], totalCount, maxItems = SIDE_CHANNEL_TOOL_EVENT_MAX) => {
+    const events = Array.isArray(toolEvents) ? toolEvents : [];
+    const count = typeof totalCount === 'number' ? totalCount : events.length;
+    return {
+        schema: TOOL_LOG_VISUAL_SCHEMA_VERSION,
+        count,
+        names: events.map((tool) => tool.name).filter(Boolean).slice(0, maxItems),
+        events,
+        truncated: count > events.length,
+        maxEvents: maxItems,
+    };
+};
+const keepVisibleToolLogArrays = (payload = {}) => {
+    if (payload.toolLog) {
+        if (!Array.isArray(payload.toolLog.names))
+            payload.toolLog.names = [];
+        if (!Array.isArray(payload.toolLog.events))
+            payload.toolLog.events = [];
+    }
+    return payload;
+};
 const compactMessageForSideChannel = (message = {}) => {
     const type = messageTypeOf(message) || String(message.role || 'message').toLowerCase();
     const role = type === 'human' ? 'user' : type === 'ai' ? 'assistant' : type || 'message';
@@ -3045,17 +3116,19 @@ const normalizeConversationRoleForSideChannel = (role = '') => {
         return 'tool';
     return normalized || 'message';
 };
-const compactConversationTimelineForSideChannel = (conversation = {}, maxItems = 4, includeFull = false) => {
+const compactConversationTimelineForSideChannel = (conversation = {}, maxItems = 16, includeFull = false) => {
     const chronological = Array.isArray(conversation.conversation_history_chronological)
         ? conversation.conversation_history_chronological
         : [];
-    return pruneByLimit(chronological, maxItems).map((message, index) => {
+    const visible = pruneByLimit(chronological, maxItems);
+    const offset = Math.max(0, chronological.length - visible.length);
+    return visible.map((message, index) => {
         const role = normalizeConversationRoleForSideChannel(message.role || message.type);
         const content = String(message.content || message.text || message.message || '');
         const at = message.at || message.timestamp || message.created_at || message.createdAt;
         const preview = role === 'system' ? '[system context hidden]' : truncate(content, 180);
         return cleanContextValue({
-            index,
+            index: offset + index,
             role,
             speaker: role,
             at,
@@ -3070,24 +3143,70 @@ const compactConversationTimelineForSideChannel = (conversation = {}, maxItems =
         });
     });
 };
+const conversationEntriesFromMessagesForSideChannel = (messages = []) => (Array.isArray(messages) ? messages : [])
+    .map((message) => {
+    const type = messageTypeOf(message) || String(message.role || 'message').toLowerCase();
+    const role = type === 'human' || type === 'user' ? 'user' : type === 'ai' || type === 'assistant' ? 'agent' : type === 'tool' ? 'tool' : type === 'system' ? 'system' : 'message';
+    const content = messageContentOf(message);
+    return {
+        role,
+        speaker: role,
+        at: message.at || message.timestamp || message.created_at || message.createdAt,
+        content,
+    };
+})
+    .filter((message) => message.role !== 'system' && message.content);
+const conversationDigestFromMessagesForSideChannel = (messages = []) => {
+    const entries = conversationEntriesFromMessagesForSideChannel(messages);
+    const lastUser = [...entries].reverse().find((message) => message.role === 'user');
+    const lastAgent = [...entries].reverse().find((message) => message.role === 'agent');
+    return cleanContextValue({
+        messages: entries.length,
+        userMessages: entries.filter((message) => message.role === 'user').length,
+        assistantMessages: entries.filter((message) => message.role === 'agent').length,
+        lastUser: lastUser ? {
+            at: lastUser.at,
+            preview: truncate(lastUser.content, 240),
+        } : undefined,
+        lastAgent: lastAgent ? {
+            at: lastAgent.at,
+            preview: truncate(lastAgent.content, 240),
+        } : undefined,
+    });
+};
+const conversationTimelineFromMessagesForSideChannel = (messages = [], maxItems = 16) => {
+    const entries = conversationEntriesFromMessagesForSideChannel(messages);
+    const visible = pruneByLimit(entries, maxItems);
+    const offset = Math.max(0, entries.length - visible.length);
+    return visible.map((message, index) => cleanContextValue({
+        index: offset + index,
+        role: message.role,
+        speaker: message.speaker,
+        at: message.at,
+        chars: message.content.length,
+        preview: truncate(message.content, 180),
+    }));
+};
 const summarizeSaveContextForSideChannel = (input = {}, output = {}, chatHistory = []) => {
     const inputMessage = input?.input || input?.chatInput || input?.query || input?.question || input?.text || input?.message || '';
     const outputMessage = output?.output || output?.response || output?.text || output?.message || output?.answer || '';
-    const toolEvents = extractToolCalls(output || {})
-        .map((tool) => compactToolAuditForSideChannel(tool || {}))
-        .filter((tool) => tool && Object.keys(tool).length)
-        .slice(0, 20);
-    return cleanContextValue({
+    const toolCalls = extractToolCalls(output || {});
+    const toolEvents = compactToolEventsForSideChannel(toolCalls, SIDE_CHANNEL_SAVE_TOOL_EVENT_MAX);
+    return keepVisibleToolLogArrays(cleanContextValue({
+        visualSchema: VISUAL_SCHEMA_VERSION,
         messagesAfterSave: Array.isArray(chatHistory) ? chatHistory.length : 0,
+        conversation: conversationDigestFromMessagesForSideChannel(chatHistory),
+        conversationTimeline: conversationTimelineFromMessagesForSideChannel(chatHistory, 16),
         savedMessages: Array.isArray(chatHistory)
             ? chatHistory.slice(-6).map((message) => compactMessageForSideChannel(message))
             : undefined,
         userInput: inputMessage ? truncate(String(inputMessage), 500) : undefined,
         assistantOutput: outputMessage ? truncate(String(outputMessage), 700) : undefined,
-        toolCallsCaptured: toolEvents.length || undefined,
+        toolCallsCaptured: toolCalls.length,
         toolNames: toolEvents.map((tool) => tool.name).filter(Boolean),
+        toolLog: buildToolLogForSideChannel(toolEvents, toolCalls.length, SIDE_CHANNEL_SAVE_TOOL_EVENT_MAX),
         toolEvents,
-    });
+    }));
 };
 const compactMemoryEventPayload = (payload = {}) => {
     const compact = { ...(payload || {}) };
@@ -3097,18 +3216,20 @@ const compactMemoryEventPayload = (payload = {}) => {
             .map((tool) => (tool && (tool.name || tool.tool_name || tool.tool)) || '')
             .filter(Boolean)
             .slice(0, 12);
-        compact.toolEvents = compact.toolCalls
-            .map((tool) => compactToolAuditForSideChannel(tool || {}))
-            .filter((tool) => tool && Object.keys(tool).length)
-            .slice(0, 8);
+        compact.toolEvents = compactToolEventsForSideChannel(compact.toolCalls, SIDE_CHANNEL_TOOL_EVENT_MAX);
+        compact.toolLog = buildToolLogForSideChannel(compact.toolEvents, compact.toolCalls.length, SIDE_CHANNEL_TOOL_EVENT_MAX);
         delete compact.toolCalls;
     }
+    if (!compact.visualSchema)
+        compact.visualSchema = VISUAL_SCHEMA_VERSION;
+    if (Array.isArray(compact.toolEvents) && !compact.toolLog)
+        compact.toolLog = buildToolLogForSideChannel(compact.toolEvents, compact.toolCallsCaptured, SIDE_CHANNEL_TOOL_EVENT_MAX);
     for (const key of ['input', 'output', 'values', 'chatHistory', 'context', 'contextText', 'diagnostics']) {
         if (compact[key] !== undefined)
             compact[`${key}Chars`] = typeof compact[key] === 'string' ? compact[key].length : safeStringify(compact[key]).length;
         delete compact[key];
     }
-    return compact;
+    return keepVisibleToolLogArrays(compact);
 };
 const compactLastSaveForSideChannel = (lastSave = {}) => cleanContextValue({
     saved: lastSave.saved,
@@ -3259,6 +3380,7 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         const fullDedupeSummary = parsed.dedupeSummary || parsed.diagnostics?.dedupeSummary || undefined;
         const loadedSections = loadedSectionsForSideChannel(parsed, memoryAudit);
         const agentContextBudget = agentContextBudgetForSideChannel(list, parsed);
+        summary.visualSchema = VISUAL_SCHEMA_VERSION;
         summary.userId = parsed.userId;
         summary.project = parsed.project || undefined;
         summary.retrievalMode = parsed.retrievalMode;
@@ -3281,13 +3403,12 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
                 preview: truncate(String(lastAgent.content || lastAgent.text || lastAgent.message || ''), 240),
             } : undefined,
         });
-        summary.conversationTimeline = compactConversationTimelineForSideChannel(conversation, 4);
+        summary.conversationTimeline = compactConversationTimelineForSideChannel(conversation, 16);
+        const visibleToolEvents = compactToolEventsForSideChannel(toolItems, SIDE_CHANNEL_TOOL_EVENT_MAX);
         summary.toolCount = toolItems.length || tools.count || parsed.operationalState?.tool_counts?.total || undefined;
         summary.toolNames = toolItems.map((tool) => tool.name || tool.tool_name).filter(Boolean).slice(0, 12);
-        summary.toolEvents = toolItems
-            .slice(-3)
-            .map((tool) => compactToolAuditForSideChannel(tool || {}))
-            .filter((tool) => tool && Object.keys(tool).length);
+        summary.toolLog = buildToolLogForSideChannel(visibleToolEvents, toolItems.length || summary.toolCount || visibleToolEvents.length, SIDE_CHANNEL_TOOL_EVENT_MAX);
+        summary.toolEvents = visibleToolEvents;
         summary.lastTool = tools.last_successful_tool
             ? {
                 name: tools.last_successful_tool.name,
@@ -3377,7 +3498,7 @@ const wrapTemboryMemory = (memory, ctx, memoryKey, itemIndex = 0) => new Proxy(m
         if (prop === 'loadMemoryVariables') {
             return async (values = {}) => {
                 const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, [
-                    [{ json: { action: 'loadMemoryVariables', valuesChars: JSON.stringify(values || {}).length } }],
+                    [{ json: { action: 'loadMemoryVariables', visualSchema: VISUAL_SCHEMA_VERSION, valuesChars: JSON.stringify(values || {}).length } }],
                 ]);
                 try {
                     const response = await target.loadMemoryVariables(values);
@@ -3387,6 +3508,7 @@ const wrapTemboryMemory = (memory, ctx, memoryKey, itemIndex = 0) => new Proxy(m
                         [{
                                 json: {
                                     action: 'loadMemoryVariables',
+                                    visualSchema: VISUAL_SCHEMA_VERSION,
                                     messages,
                                     memorySummary: summarizeMemoryMessagesForSideChannel(memoryMessages),
                                 },
@@ -4039,14 +4161,15 @@ class TemboryMemory {
         const loadCache = new Map();
         const recordMemoryEvent = (action, payload = {}, error) => {
             const { index } = this.addInputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, [
-                [{ json: { action } }],
+                [{ json: { action, visualSchema: VISUAL_SCHEMA_VERSION } }],
             ]);
             if (error) {
                 this.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, error);
                 return;
             }
+            const compactPayload = compactMemoryEventPayload(payload);
             this.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, [
-                [{ json: { action, ...compactMemoryEventPayload(payload) } }],
+                [{ json: { action, visualSchema: VISUAL_SCHEMA_VERSION, memorySummary: compactPayload, ...compactPayload } }],
             ]);
         };
         const memory = {
@@ -5382,6 +5505,7 @@ class TemboryMemory {
             }
             const json = {
                 action: 'loadMemoryVariables',
+                visualSchema: VISUAL_SCHEMA_VERSION,
                 messages: Array.isArray(payload) ? payload.length : 0,
                 memorySummary: summarizeMemoryMessagesForSideChannel(payload),
             };
@@ -5458,6 +5582,9 @@ exports.__private = {
     contextSizeOfMessages,
     embedQueryCached,
     compactToolResult,
+    compactToolAuditForSideChannel,
+    buildToolLogForSideChannel,
+    compactParsedToolOutputForSideChannel,
     compactToolHistoryForAgent,
     compactVectorMemoriesForAgent,
     isConversationEchoMemory,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.1.40",
+  "version": "1.1.42",
   "description": "Tembory node for n8n AI Agents with operational memory, tool history and decision state",
   "license": "MIT",
   "homepage": "https://tembory.com",