n8n-nodes-tembory 1.1.39 → 1.1.40

package/README.md

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

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),
@@ -3428,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.39",
+  "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",