n8n-nodes-tembory 1.1.38 → 1.1.40

package/README.md

@@ -2,7 +2,19 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.38`.
+Versao atual: `1.1.40`.
+
+## 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
+
+- Ajusta a semantica de repeticao de tools: `do_not_repeat_tools` fica restrito a turnos de recall, status operacional ou pedido explicito para nao chamar tools.
+- Em turnos normais, o Agent recebe `repeat_tool_policy` e `avoid_repeating_tools_unless_needed`, deixando claro que tools anteriores sao evidencia reutilizavel, nao ferramentas proibidas.
+- Compacta `decisionState.tool_decision_state` para evitar duplicar outputs longos de tools no contexto balanceado.
 
 ## 1.1.38
 

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',
@@ -2046,6 +2051,8 @@ const buildTurnBriefForAgent = ({ query = '', recentMessages = [], toolHistory =
             status: lastTool.status || (lastTool.ok === false ? 'failed' : 'ok'),
             at: lastTool.at || lastTool.timestamp,
         } : 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: ((decisionState || {}).do_not_repeat_tools || []).slice(0, 12),
         guidance: turnBriefGuidanceForIntent(currentIntent),
     });
@@ -2092,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 }) => {
@@ -2151,6 +2167,19 @@ 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 tools = Array.from(new Set(executedTools.filter(Boolean)));
+    const strictMemoryOnlyTurn = intent === 'conversation_recall' || intent === 'operational_status_question' || hasNoToolRequested(query);
+    const sideEffectToolCandidates = tools.filter(toolNameSuggestsSideEffect);
+    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.',
+    });
+};
 const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [], toolHistory = [], operationalState = {}, previous = {} }) => {
     const intent = inferUserIntent(query, recentMessages);
     const chronological = sortConversationChronological(recentMessages || []);
@@ -2225,7 +2254,6 @@ const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [
 };
 const deriveDecisionState = ({ query = '', toolHistory = [], operationalState = {}, workingMemory = {} }) => {
     const decisions = [];
-    const doNotRepeatTools = [];
     const intent = workingMemory.last_user_intent || inferUserIntent(query, []);
     const now = nowIso();
     const toolState = operationalState.tool_state || {};
@@ -2244,9 +2272,9 @@ const deriveDecisionState = ({ query = '', toolHistory = [], operationalState =
             tool: extra.tool,
         });
     };
-    for (const name of Object.keys(toolState.counts_by_name || {})) {
-        doNotRepeatTools.push(name);
-    }
+    const executedTools = Array.from(new Set(Object.keys(toolState.counts_by_name || {})));
+    const toolRepeatPolicy = deriveToolRepeatPolicy({ intent, query, executedTools, toolState });
+    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 });
     for (const [name, count] of Object.entries(toolState.failed_by_name || {}))
@@ -2254,15 +2282,18 @@ const deriveDecisionState = ({ query = '', toolHistory = [], operationalState =
     return {
         active_decisions: decisions,
         do_not_repeat_tools: Array.from(new Set(doNotRepeatTools)),
+        repeat_tool_policy: toolRepeatPolicy,
+        avoid_repeating_tools_unless_needed: toolRepeatPolicy.avoid_repeating_tools_unless_needed,
         current_intent: intent,
         tool_decision_state: {
-            executed_tools: Object.keys(toolState.counts_by_name || {}),
+            executed_tools: executedTools,
             failed_tools: Object.keys(toolState.failed_by_name || {}),
             last_successful_tool: toolState.last_successful_tool || null,
             do_not_repeat_tools: Array.from(new Set(doNotRepeatTools)),
+            repeat_tool_policy: toolRepeatPolicy,
             evaluated_at: now,
         },
-        conflict_policy: 'prefer active decisions with newer timestamps; ignore superseded or expired memories unless auditing',
+        conflict_policy: 'prefer newer active decisions; ignore superseded or expired memories unless auditing',
         decision_count: decisions.length,
         latest_tool: toolHistory && toolHistory.length ? {
             name: toolHistory[toolHistory.length - 1].name,
@@ -2503,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;
@@ -2542,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) => {
@@ -2580,6 +2758,26 @@ const compactWorkingMemoryForAgent = (memory = {}) => cleanContextValue({
     next_expected_action: memory.next_expected_action,
     updated_at: memory.updated_at,
 });
+const compactToolDecisionStateForAgent = (toolDecisionState = {}) => {
+    const lastTool = toolDecisionState.last_successful_tool || null;
+    return cleanContextValue({
+        executed_tools: (toolDecisionState.executed_tools || []).slice(0, 12),
+        failed_tools: (toolDecisionState.failed_tools || []).slice(0, 12),
+        last_successful_tool: lastTool ? cleanContextValue({
+            name: lastTool.name || lastTool.tool_name || lastTool.tool,
+            status: lastTool.status || (lastTool.ok === false ? 'failed' : 'ok'),
+            at: lastTool.at || lastTool.timestamp,
+        }) : undefined,
+        do_not_repeat_tools: (toolDecisionState.do_not_repeat_tools || []).slice(0, 12),
+        evaluated_at: toolDecisionState.evaluated_at,
+    });
+};
+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),
+    instruction: policy.instruction,
+});
 const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
     current_intent: state.current_intent,
     active_decisions: (state.active_decisions || []).slice(-4).map((decision) => cleanContextValue({
@@ -2592,18 +2790,19 @@ const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
         at: decision.at || decision.updated_at,
     })),
     do_not_repeat_tools: state.do_not_repeat_tools,
-    tool_decision_state: state.tool_decision_state,
+    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'),
         at: state.latest_tool.at,
     }) : undefined,
-    conflict_policy: state.conflict_policy,
 });
 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,
@@ -2617,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),
@@ -3138,6 +3336,12 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
             decisionCount: parsed.decisionState?.decision_count,
             latestTool: parsed.decisionState?.latest_tool,
             doNotRepeatTools: parsed.decisionState?.do_not_repeat_tools,
+            avoidRepeatingToolsUnlessNeeded: parsed.decisionState?.avoid_repeating_tools_unless_needed,
+            repeatToolPolicy: parsed.decisionState?.repeat_tool_policy ? {
+                mode: parsed.decisionState.repeat_tool_policy.mode,
+                legacyDoNotRepeatApplies: parsed.decisionState.repeat_tool_policy.legacy_do_not_repeat_applies,
+                sideEffectToolCandidates: parsed.decisionState.repeat_tool_policy.side_effect_tool_candidates,
+            } : undefined,
         });
         summary.quality = parsed.contextHealth?.quality_score || parsed.contextQualityScore || undefined;
         summary.debug = includeDebug ? cleanContextValue({
@@ -3338,7 +3542,9 @@ 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),
-                do_not_repeat_tools: ((decisionState || {}).do_not_repeat_tools || []).slice(0, 12),
+                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.',
             }),
         });
@@ -3382,7 +3588,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')),

package/package.json

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