n8n-nodes-tembory 1.1.40 → 1.1.41

package/README.md

@@ -2,7 +2,13 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.40`.
+Versao atual: `1.1.41`.
+
+## 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

@@ -3006,6 +3006,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 +3029,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';
@@ -3073,21 +3109,21 @@ const compactConversationTimelineForSideChannel = (conversation = {}, maxItems =
 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,
         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 +3133,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 +3297,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;
@@ -3282,12 +3321,11 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
             } : undefined,
         });
         summary.conversationTimeline = compactConversationTimelineForSideChannel(conversation, 4);
+        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 +3415,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 +3425,7 @@ const wrapTemboryMemory = (memory, ctx, memoryKey, itemIndex = 0) => new Proxy(m
                         [{
                                 json: {
                                     action: 'loadMemoryVariables',
+                                    visualSchema: VISUAL_SCHEMA_VERSION,
                                     messages,
                                     memorySummary: summarizeMemoryMessagesForSideChannel(memoryMessages),
                                 },
@@ -4039,14 +4078,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 +5422,7 @@ class TemboryMemory {
             }
             const json = {
                 action: 'loadMemoryVariables',
+                visualSchema: VISUAL_SCHEMA_VERSION,
                 messages: Array.isArray(payload) ? payload.length : 0,
                 memorySummary: summarizeMemoryMessagesForSideChannel(payload),
             };
@@ -5458,6 +5499,8 @@ exports.__private = {
     contextSizeOfMessages,
     embedQueryCached,
     compactToolResult,
+    compactToolAuditForSideChannel,
+    buildToolLogForSideChannel,
     compactToolHistoryForAgent,
     compactVectorMemoriesForAgent,
     isConversationEchoMemory,

package/package.json

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