n8n-nodes-tembory 1.1.39 → 1.1.41

package/README.md

@@ -2,7 +2,19 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.39`.
+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
+
+- Extrai fatos operacionais path aware de inputs e outputs de tools, preservando IDs como `serviceId`, `providerId`, `locationId`, `customerId`, `reservationId` e `bookingId`.
+- Injeta esses fatos em `operationalState`, `actionLedger`, `toolLedger` e `action_directive`.
+- Corrige o risco de o Agent usar `serviceId` antigo de memoria vetorial quando o `check_availabilities` mais recente ja retornou o ID correto para o `Booking`.
 
 ## 1.1.39
 

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

@@ -489,6 +489,7 @@ const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessa
         const name = String(tool.name || 'unknown_tool');
         const compactInput = compactToolPayload(safeParseToolPayload(tool.input));
         const compactResult = maybeToolResult(tool, includeResults);
+        const facts = extractToolOperationalFacts(tool);
         const reason = truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 260);
         toolCountsByName[name] = (toolCountsByName[name] || 0) + 1;
         latestByName[name] = {
@@ -496,6 +497,7 @@ const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessa
             ok: tool.ok !== false,
             at: tool.at || null,
             input: compactInput,
+            facts,
             result: compactResult,
             reason,
             source: tool.source || 'unknown',
@@ -507,6 +509,7 @@ const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessa
             at: tool.at || null,
             reason,
             input: compactInput,
+            facts,
             output: compactResult,
         }));
         if (tool.ok === false)
@@ -538,6 +541,7 @@ const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessa
             last_successful_tool: successfulTools.length ? {
                 name: successfulTools[successfulTools.length - 1].name,
                 at: successfulTools[successfulTools.length - 1].at || null,
+                facts: extractToolOperationalFacts(successfulTools[successfulTools.length - 1]),
                 result: maybeToolResult(successfulTools[successfulTools.length - 1], includeResults),
             } : null,
         },
@@ -556,6 +560,7 @@ const deriveActionLedger = (toolHistory = [], maxItems = 20, includeResults = tr
         status: tool.ok === false ? 'failed' : 'ok',
         reason: truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 260),
         input: compactToolPayload(safeParseToolPayload(tool.input)),
+        facts: extractToolOperationalFacts(tool),
         result: maybeToolResult(tool, includeResults),
         at: tool.at || null,
         source: tool.source || 'unknown',
@@ -2094,16 +2099,25 @@ const buildActionDirective = ({ workingMemory = {}, operationalState = {} }) =>
         return null;
     const toolState = (operationalState || {}).tool_state || {};
     const latestForTool = ((toolState.latest_by_name || {})[tool]) || null;
+    const recentToolEvidence = pruneByLimit((toolState.recent_sequence || [])
+        .filter((item) => item && item.status !== 'failed')
+        .map((item) => cleanContextValue({
+        tool: item.tool,
+        at: item.at,
+        facts: item.facts,
+    }))
+        .filter((item) => item && item.facts), 6);
     return cleanContextValue({
         required_tool: tool,
         next_expected_action: next,
+        evidence_from_recent_tools: recentToolEvidence,
         tool_state: {
             last_tool: (operationalState || {}).last_tool || null,
             required_tool_last_result: latestForTool,
             counts_by_name: toolState.counts_by_name || {},
             failed_by_name: toolState.failed_by_name || {},
         },
-        instruction: `If the agent prompt requires this action, call ${tool} now using tool_state/action_ledger as evidence. Do not infer domain policy from memory; memory only provides prior conversation, decisions, inputs and outputs.`,
+        instruction: `call ${tool} now if the agent prompt requires it. Use tool evidence for exact IDs. Do not complete side effects from memory.`,
     });
 };
 const inferToolGuard = ({ query, recentMessages, toolHistory, vectorMemories }) => {
@@ -2520,6 +2534,152 @@ const normalizeToolResultEnvelope = (value) => {
     }
     return parsed;
 };
+const normalizeFactKey = (key = '') => String(key || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+const scalarFactValue = (value) => {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (['string', 'number', 'boolean'].includes(typeof value))
+        return value;
+    return undefined;
+};
+const pushCandidate = (facts, bucket, value, path) => {
+    const scalar = scalarFactValue(value);
+    if (scalar === undefined)
+        return;
+    facts[bucket] = facts[bucket] || [];
+    if (!facts[bucket].some((item) => String(item.value) === String(scalar) && item.path === path)) {
+        facts[bucket].push({ value: scalar, path });
+    }
+};
+const firstCandidateValue = (items = []) => items.length ? items[0].value : undefined;
+const extractOperationalFactsFromValue = (value, maxCandidates = 8) => {
+    const parsed = normalizeToolResultEnvelope(value);
+    const facts = {
+        serviceIdCandidates: [],
+        providerIdCandidates: [],
+        locationIdCandidates: [],
+        customerIdCandidates: [],
+        reservationIdCandidates: [],
+        bookingIdCandidates: [],
+        confirmationIdCandidates: [],
+        serviceNameCandidates: [],
+        providerNameCandidates: [],
+        statusCandidates: [],
+        timeCandidates: [],
+        dateCandidates: [],
+    };
+    const seen = new Set();
+    let visited = 0;
+    const visit = (item, path = []) => {
+        if (visited > 220 || item === undefined || item === null)
+            return;
+        if (typeof item !== 'object')
+            return;
+        if (seen.has(item))
+            return;
+        seen.add(item);
+        visited += 1;
+        if (Array.isArray(item)) {
+            item.slice(0, 12).forEach((entry, index) => visit(entry, path.concat(String(index))));
+            return;
+        }
+        for (const [rawKey, rawValue] of Object.entries(item)) {
+            const key = normalizeFactKey(rawKey);
+            const nextPath = path.concat(rawKey);
+            const pathText = nextPath.join('.');
+            const parentText = path.join('.').toLowerCase();
+            const parentSuggestsService = /(^|\.)(service|services|servico|servicos|especialidade|especialidades)(\.|$)/i.test(parentText);
+            const parentSuggestsProvider = /(^|\.)(provider|providers|veterinario|veterinarios|vet|vets|professional|profissional|profissionais)(\.|$)/i.test(parentText);
+            const parentSuggestsLocation = /(^|\.)(location|locations|local|locais|unidade|unidades)(\.|$)/i.test(parentText);
+            if (key === 'serviceid' || key === 'servicoid' || (key === 'id' && parentSuggestsService))
+                pushCandidate(facts, 'serviceIdCandidates', rawValue, pathText);
+            if (key === 'providerid' || key === 'veterinarioid' || key === 'vetid' || (key === 'id' && parentSuggestsProvider))
+                pushCandidate(facts, 'providerIdCandidates', rawValue, pathText);
+            if (key === 'locationid' || key === 'localid' || key === 'unidadeid' || (key === 'id' && parentSuggestsLocation))
+                pushCandidate(facts, 'locationIdCandidates', rawValue, pathText);
+            if (key === 'customerid' || key === 'clienteid')
+                pushCandidate(facts, 'customerIdCandidates', rawValue, pathText);
+            if (key === 'reservationid' || key === 'reservaid')
+                pushCandidate(facts, 'reservationIdCandidates', rawValue, pathText);
+            if (key === 'bookingid' || key === 'appointmentid' || key === 'agendamentoid')
+                pushCandidate(facts, 'bookingIdCandidates', rawValue, pathText);
+            if (key === 'confirmationid')
+                pushCandidate(facts, 'confirmationIdCandidates', rawValue, pathText);
+            if (key === 'servicename' || key === 'servico' || key === 'especialidade' || (key === 'name' && parentSuggestsService))
+                pushCandidate(facts, 'serviceNameCandidates', rawValue, pathText);
+            if (key === 'providername' || key === 'veterinarioname' || key === 'nomeveterinario' || (key === 'name' && parentSuggestsProvider))
+                pushCandidate(facts, 'providerNameCandidates', rawValue, pathText);
+            if (key === 'status' || key === 'state')
+                pushCandidate(facts, 'statusCandidates', rawValue, pathText);
+            if (key === 'horario' || key === 'horarios' || key === 'time' || key === 'start' || key === 'end')
+                pushCandidate(facts, 'timeCandidates', rawValue, pathText);
+            if (key === 'date' || key === 'data' || key === 'datadisponivel')
+                pushCandidate(facts, 'dateCandidates', rawValue, pathText);
+            if (rawValue && typeof rawValue === 'object')
+                visit(rawValue, nextPath);
+        }
+    };
+    visit(parsed);
+    const compactCandidates = (items = []) => items.slice(0, maxCandidates);
+    return cleanContextValue({
+        ids: {
+            serviceId: firstCandidateValue(facts.serviceIdCandidates),
+            providerId: firstCandidateValue(facts.providerIdCandidates),
+            locationId: firstCandidateValue(facts.locationIdCandidates),
+            customerId: firstCandidateValue(facts.customerIdCandidates),
+            reservationId: firstCandidateValue(facts.reservationIdCandidates),
+            bookingId: firstCandidateValue(facts.bookingIdCandidates),
+            confirmationId: firstCandidateValue(facts.confirmationIdCandidates),
+        },
+        labels: {
+            serviceName: firstCandidateValue(facts.serviceNameCandidates),
+            providerName: firstCandidateValue(facts.providerNameCandidates),
+            status: firstCandidateValue(facts.statusCandidates),
+            date: firstCandidateValue(facts.dateCandidates),
+            time: firstCandidateValue(facts.timeCandidates),
+        },
+        candidates: {
+            serviceIds: compactCandidates(facts.serviceIdCandidates),
+            providerIds: compactCandidates(facts.providerIdCandidates),
+            locationIds: compactCandidates(facts.locationIdCandidates),
+        },
+    });
+};
+const mergeOperationalFactObjects = (primary = {}, secondary = {}) => {
+    const pick = (path) => {
+        const read = (source) => path.reduce((acc, key) => acc && acc[key] !== undefined ? acc[key] : undefined, source);
+        return read(primary) !== undefined ? read(primary) : read(secondary);
+    };
+    return cleanContextValue({
+        ids: {
+            serviceId: pick(['ids', 'serviceId']),
+            providerId: pick(['ids', 'providerId']),
+            locationId: pick(['ids', 'locationId']),
+            customerId: pick(['ids', 'customerId']),
+            reservationId: pick(['ids', 'reservationId']),
+            bookingId: pick(['ids', 'bookingId']),
+            confirmationId: pick(['ids', 'confirmationId']),
+        },
+        labels: {
+            serviceName: pick(['labels', 'serviceName']),
+            providerName: pick(['labels', 'providerName']),
+            status: pick(['labels', 'status']),
+            date: pick(['labels', 'date']),
+            time: pick(['labels', 'time']),
+        },
+        candidates: {
+            serviceIds: ((primary.candidates || {}).serviceIds || (secondary.candidates || {}).serviceIds || []).slice(0, 8),
+            providerIds: ((primary.candidates || {}).providerIds || (secondary.candidates || {}).providerIds || []).slice(0, 8),
+            locationIds: ((primary.candidates || {}).locationIds || (secondary.candidates || {}).locationIds || []).slice(0, 8),
+        },
+    });
+};
+const extractToolOperationalFacts = (tool = {}) => {
+    const inputFacts = extractOperationalFactsFromValue(safeParseToolPayload(tool.input));
+    const outputFacts = extractOperationalFactsFromValue(tool.result);
+    const facts = mergeOperationalFactObjects(outputFacts, inputFacts);
+    return Object.keys(facts || {}).length ? facts : undefined;
+};
 const compactParsedToolOutputForSideChannel = (parsed) => {
     if (parsed === undefined || parsed === null)
         return undefined;
@@ -2559,6 +2719,7 @@ const compactToolHistoryForAgent = (toolHistory = [], maxItems = 6, includeResul
     at: tool.at,
     reason: truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 140),
     input: truncate(String(tool.input || ''), 500) || undefined,
+    facts: extractToolOperationalFacts(tool),
     result: includeResults ? compactToolResult(tool.result, 1200) : undefined,
 }));
 const cleanContextValue = (value) => {
@@ -2641,7 +2802,7 @@ const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
 const compactOperationalStateForAgent = (state = {}) => {
     const counts = state.tool_counts || {};
     const toolState = state.tool_state || {};
-    return {
+    return cleanContextValue({
         last_tool: state.last_tool || null,
         tool_counts: {
             total: counts.total || 0,
@@ -2655,8 +2816,7 @@ const compactOperationalStateForAgent = (state = {}) => {
             last_successful_tool: toolState.last_successful_tool || undefined,
         } : undefined,
         blocked_without_context: state.blocked_without_context || [],
-        guidance: (state.guidance || []).slice(0, 3),
-    };
+    });
 };
 const compactMemoryCompressionForAgent = (compression = {}) => ({
     turn_summary: (compression.turn_summary || []).slice(-3),
@@ -2846,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;
@@ -2859,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';
@@ -2913,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 || {}) };
@@ -2937,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,
@@ -3099,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;
@@ -3122,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,
@@ -3217,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);
@@ -3227,6 +3425,7 @@ const wrapTemboryMemory = (memory, ctx, memoryKey, itemIndex = 0) => new Proxy(m
                         [{
                                 json: {
                                     action: 'loadMemoryVariables',
+                                    visualSchema: VISUAL_SCHEMA_VERSION,
                                     messages,
                                     memorySummary: summarizeMemoryMessagesForSideChannel(memoryMessages),
                                 },
@@ -3428,7 +3627,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             statusAnswerMaterial: sectionValue('status_answer_material'),
             action_directive: directive ? cleanContextValue({
                 required_tool: directive.required_tool,
-                next_expected_action: directive.next_expected_action,
+                evidence_from_recent_tools: directive.evidence_from_recent_tools,
                 instruction: directive.instruction,
             }) : undefined,
             turnBrief: compactTurnBriefForAgent(sectionValue('turn_brief')),
@@ -3879,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 = {
@@ -5222,6 +5422,7 @@ class TemboryMemory {
             }
             const json = {
                 action: 'loadMemoryVariables',
+                visualSchema: VISUAL_SCHEMA_VERSION,
                 messages: Array.isArray(payload) ? payload.length : 0,
                 memorySummary: summarizeMemoryMessagesForSideChannel(payload),
             };
@@ -5298,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.39",
+  "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",