n8n-nodes-tembory 1.1.42 → 1.1.44

package/README.md

@@ -2,7 +2,20 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.42`.
+Versao atual: `1.1.44`.
+
+## 1.1.44
+
+- Adiciona `toolReuseGuard` no contexto compacto do agente para reduzir repeticao indevida de tools entre turnos.
+- Registra chamadas bem sucedidas recentes com `input_hash` e classifica tools de leitura versus side effect de forma generica.
+- Instrui o agente a consultar `tool_ledger` antes de nova tool e a nao repetir side effects sem pedido explicito do usuario.
+- Remove duplicacoes do payload compacto para manter o contexto balanceado abaixo do limite de regressao.
+
+## 1.1.43
+
+- Adiciona `toolCapture` no payload visual de `saveContext`, deixando explicito quando nenhuma execucao de tool chegou para a memoria.
+- Suporta tambem `intermediate_steps` em snake case, alem de `intermediateSteps`.
+- Quando `toolCallsCaptured` for `0`, o payload informa que e necessario o AI Agent entregar `intermediateSteps`, `__temboryToolCalls` ou tool messages para a memoria conseguir salvar a tool.
 
 ## 1.1.42
 

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

@@ -1210,9 +1210,14 @@ const extractToolCalls = (outputValues = {}) => {
                 source: 'tool_object',
             });
         }
-        if (Array.isArray(obj.intermediateSteps)) {
-            for (let index = 0; index < obj.intermediateSteps.length; index++) {
-                const step = obj.intermediateSteps[index];
+        const intermediateSteps = Array.isArray(obj.intermediateSteps)
+            ? obj.intermediateSteps
+            : Array.isArray(obj.intermediate_steps)
+                ? obj.intermediate_steps
+                : undefined;
+        if (Array.isArray(intermediateSteps)) {
+            for (let index = 0; index < intermediateSteps.length; index++) {
+                const step = intermediateSteps[index];
                 if (Array.isArray(step) && step.length >= 1) {
                     const action = step[0] || {};
                     push(action.tool || action.name, action.toolInput || action.input || action.args, step[1], true, {
@@ -2167,17 +2172,56 @@ const shouldCarryPreviousGoal = (intent = '', previousGoal = '') => {
         return false;
     return ['general_message', 'profile_update', 'unknown'].includes(intent);
 };
-const toolNameSuggestsSideEffect = (name = '') => /(?:^|[_\-. ])(book|booking|reserv\w*|agend\w*|confirm\w*|cancel\w*|cri\w*|create|update|upsert|set|send|enviar|registr\w*|cadastr\w*|charge|cobran\w*|pagamento|ticket)(?:$|[_\-. ])/i.test(String(name || ''));
-const deriveToolRepeatPolicy = ({ intent = '', query = '', executedTools = [], toolState = {} }) => {
+const toolNameSuggestsSideEffect = (name = '') => {
+    const text = String(name || '');
+    if (/(?:^|[_\-. ])(check|consult\w*|search|lookup|find|list|get|read|info|inform\w*|disponibilidade|availability)(?:$|[_\-. ])/i.test(text))
+        return false;
+    return /(?:^|[_\-. ])(book|booking|reserv\w*|agend\w*|confirm\w*|cancel\w*|cri\w*|create|update|upsert|set|send|enviar|registr\w*|cadastr\w*|charge|cobran\w*|pagamento|ticket)(?:$|[_\-. ])/i.test(text);
+};
+const compactToolPolicyPayload = (value, max = 420) => {
+    const parsed = safeParseToolPayload(value);
+    const cleaned = stripNoisyToolFields(parsed);
+    return truncate(typeof cleaned === 'string' ? cleaned : safeStringify(cleaned), max) || undefined;
+};
+const compactSuccessfulToolCallsForPolicy = (toolHistory = [], toolState = {}, maxItems = 10) => {
+    const fromHistory = (Array.isArray(toolHistory) ? toolHistory : [])
+    .filter((tool) => tool && tool.ok !== false && (tool.name || tool.tool_name || tool.tool))
+    .map((tool) => {
+    const name = String(tool.name || tool.tool_name || tool.tool || 'unknown_tool');
+    return cleanContextValue({
+        name,
+        at: tool.at || tool.timestamp,
+        input_hash: stableHash({ name, input: safeParseToolPayload(tool.input) }),
+        side_effect: toolNameSuggestsSideEffect(name),
+    });
+});
+    const fromToolState = Object.values((toolState || {}).latest_by_name || {}).map((tool) => {
+        const name = String(tool.name || tool.tool || 'unknown_tool');
+        const input = compactToolPolicyPayload(tool.input, 220);
+        return cleanContextValue({
+            name,
+            at: tool.at || tool.timestamp,
+            input_hash: stableHash({ name, input }),
+            side_effect: toolNameSuggestsSideEffect(name),
+        });
+    });
+    return pruneByLimit(fromHistory.length ? fromHistory : fromToolState, maxItems);
+};
+const deriveToolRepeatPolicy = ({ intent = '', query = '', executedTools = [], toolState = {}, toolHistory = [] }) => {
     const tools = Array.from(new Set(executedTools.filter(Boolean)));
     const strictMemoryOnlyTurn = intent === 'conversation_recall' || intent === 'operational_status_question' || hasNoToolRequested(query);
     const sideEffectToolCandidates = tools.filter(toolNameSuggestsSideEffect);
+    const successfulToolCalls = compactSuccessfulToolCallsForPolicy(toolHistory, toolState, 10);
+    const referenceToolCandidates = tools.filter((tool) => !toolNameSuggestsSideEffect(tool));
     return cleanContextValue({
         mode: strictMemoryOnlyTurn ? 'answer_from_memory_when_possible' : 'conditional_reuse',
         avoid_repeating_tools_unless_needed: tools,
         legacy_do_not_repeat_applies: strictMemoryOnlyTurn,
         side_effect_tool_candidates: sideEffectToolCandidates,
-        instruction: 'Prior tools are evidence, not forbidden tools. Reuse outputs when sufficient; call tools for fresh data, new scope, or current side effects.',
+        do_not_repeat_side_effect_tools_without_explicit_new_request: sideEffectToolCandidates,
+        answer_from_memory_candidates: referenceToolCandidates,
+        successful_tool_calls: successfulToolCalls,
+        instruction: 'Check tool_ledger before any tool. If same tool/input already succeeded and user did not request new or fresh data, answer from prior result. Never repeat side-effect tools without an explicit new user request.',
     });
 };
 const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [], toolHistory = [], operationalState = {}, previous = {} }) => {
@@ -2273,7 +2317,7 @@ const deriveDecisionState = ({ query = '', toolHistory = [], operationalState =
         });
     };
     const executedTools = Array.from(new Set(Object.keys(toolState.counts_by_name || {})));
-    const toolRepeatPolicy = deriveToolRepeatPolicy({ intent, query, executedTools, toolState });
+    const toolRepeatPolicy = deriveToolRepeatPolicy({ intent, query, executedTools, toolState, toolHistory });
     const doNotRepeatTools = toolRepeatPolicy.legacy_do_not_repeat_applies ? executedTools : [];
     if (toolState.last_successful_tool)
         pushDecision('last_successful_tool_recorded', `latest successful tool is ${toolState.last_successful_tool.name}`, 'tool_state records successful tool execution', 'tool_orchestration', { confidence: 0.9, tool: toolState.last_successful_tool.name });
@@ -2809,8 +2853,9 @@ const compactToolDecisionStateForAgent = (toolDecisionState = {}) => {
 };
 const compactRepeatToolPolicyForAgent = (policy = {}) => cleanContextValue({
     mode: policy.mode,
-    legacy_do_not_repeat_applies: policy.legacy_do_not_repeat_applies,
-    side_effect_tool_candidates: (policy.side_effect_tool_candidates || []).slice(0, 12),
+    do_not_repeat_side_effect_tools: (policy.do_not_repeat_side_effect_tools_without_explicit_new_request || []).slice(0, 12),
+    answer_from_memory_candidates: (policy.answer_from_memory_candidates || []).slice(0, 12),
+    successful_tool_calls: (policy.successful_tool_calls || []).slice(-8),
     instruction: policy.instruction,
 });
 const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
@@ -2825,9 +2870,6 @@ const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
         at: decision.at || decision.updated_at,
     })),
     do_not_repeat_tools: state.do_not_repeat_tools,
-    repeat_tool_policy: state.repeat_tool_policy ? compactRepeatToolPolicyForAgent(state.repeat_tool_policy) : undefined,
-    avoid_repeating_tools_unless_needed: state.avoid_repeating_tools_unless_needed,
-    tool_decision_state: state.tool_decision_state ? compactToolDecisionStateForAgent(state.tool_decision_state) : undefined,
     latest_tool: state.latest_tool ? cleanContextValue({
         name: state.latest_tool.name,
         status: state.latest_tool.status || (state.latest_tool.ok === false ? 'failed' : 'ok'),
@@ -3187,6 +3229,36 @@ const conversationTimelineFromMessagesForSideChannel = (messages = [], maxItems
         preview: truncate(message.content, 180),
     }));
 };
+const hasToolCaptureSignal = (output = {}) => {
+    let hasIntermediateSteps = false;
+    let hasExplicitToolCalls = false;
+    let hasToolObject = false;
+    readDeep(output || {}, (obj) => {
+        if (Array.isArray(obj.intermediateSteps) || Array.isArray(obj.intermediate_steps))
+            hasIntermediateSteps = true;
+        if (Array.isArray(obj.__temboryToolCalls) || Array.isArray(obj.toolCalls) || Array.isArray(obj.tool_calls))
+            hasExplicitToolCalls = true;
+        const name = obj.tool || obj.toolName || obj.name;
+        const hasInput = obj.toolInput !== undefined || obj.input !== undefined || obj.args !== undefined;
+        const hasResult = obj.observation !== undefined || obj.result !== undefined || obj.output !== undefined || obj.error !== undefined;
+        if (name && hasInput && hasResult)
+            hasToolObject = true;
+    });
+    return { hasIntermediateSteps, hasExplicitToolCalls, hasToolObject };
+};
+const summarizeToolCaptureForSideChannel = (output = {}, toolCalls = []) => {
+    const signals = hasToolCaptureSignal(output);
+    const sources = Array.from(new Set((toolCalls || []).map((tool) => tool.source).filter(Boolean)));
+    return cleanContextValue({
+        status: toolCalls.length ? 'captured' : 'no_tool_payload_received',
+        captured: toolCalls.length,
+        sources,
+        signals,
+        note: toolCalls.length
+            ? undefined
+            : 'No tool execution data was received by memory in this saveContext call. If a tool ran, enable AI Agent Return Intermediate Steps or pass tool messages to memory.',
+    });
+};
 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 || '';
@@ -3204,6 +3276,7 @@ const summarizeSaveContextForSideChannel = (input = {}, output = {}, chatHistory
         assistantOutput: outputMessage ? truncate(String(outputMessage), 700) : undefined,
         toolCallsCaptured: toolCalls.length,
         toolNames: toolEvents.map((tool) => tool.name).filter(Boolean),
+        toolCapture: summarizeToolCaptureForSideChannel(output, toolCalls),
         toolLog: buildToolLogForSideChannel(toolEvents, toolCalls.length, SIDE_CHANNEL_SAVE_TOOL_EVENT_MAX),
         toolEvents,
     }));
@@ -3664,7 +3737,6 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             value: cleanContextValue({
                 current_intent: (decisionState || {}).current_intent || workingMemory.last_user_intent,
                 latest_tool: ((decisionState || {}).latest_tool || (operationalState || {}).last_tool || undefined),
-                repeat_tool_policy: (decisionState || {}).repeat_tool_policy,
                 avoid_repeating_tools_unless_needed: ((decisionState || {}).avoid_repeating_tools_unless_needed || []).slice(0, 12),
                 do_not_repeat_tools_legacy: ((decisionState || {}).do_not_repeat_tools || []).slice(0, 12),
                 instruction: actionDirective || workingMemory.next_expected_action || 'Continue according to the agent prompt.',
@@ -3721,6 +3793,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             state: minimalState,
             workingMemory: sectionValue('working_memory'),
             decisionState: sectionValue('decision_state'),
+            toolReuseGuard: compactRepeatToolPolicyForAgent((decisionState || {}).repeat_tool_policy || {}),
             operationalState: sectionValue('operational_state'),
             actionLedger: sectionValue('action_ledger'),
             memoryCompression: sectionValue('memory_compression'),

package/package.json

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