n8n-nodes-tembory 1.1.43 → 1.2.0

package/README.md

@@ -2,7 +2,22 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.1.43`.
+Versao atual: `1.2.0`.
+
+## 1.2.0
+
+- Remodela o contexto compacto do Agent para `tembory.agent_context.v2`, com contrato unico para conversa, fatos canonicos, evidencias de tools, politica de reuso, frescor, captura e budget.
+- Remove duplicacao estrutural de mensagens no prompt do Agent: a conversa passa por `conversationFrame` e nao e repetida em blocos equivalentes.
+- Preserva inputs, outputs, timestamps, fatos extraidos e resultados parseados de tools em `toolEvidence`, incluindo tools de busca vetorial quando o n8n entrega o payload.
+- Mantem `toolReuseGuard` generico para evitar repeticao indevida de side effects e reutilizar outputs anteriores como evidencia sem transformar memoria em ToolMessage.
+- Enriquece o resumo visual do n8n lendo o novo schema v2 sem vazar o `chatHistory` bruto no output do Agent.
+
+## 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
 

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

@@ -2172,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 = {} }) => {
@@ -2278,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 });
@@ -2814,10 +2853,32 @@ 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 repeatToolPolicyForAgentContext = (decisionState = {}, toolHistory = []) => {
+    if (decisionState.repeat_tool_policy)
+        return decisionState.repeat_tool_policy;
+    const legacy = Array.isArray(decisionState.do_not_repeat_tools) ? decisionState.do_not_repeat_tools : [];
+    if (!legacy.length)
+        return {};
+    return cleanContextValue({
+        mode: 'conditional_reuse',
+        do_not_repeat_side_effect_tools_without_explicit_new_request: legacy.filter((name) => toolNameSuggestsSideEffect(name)),
+        answer_from_memory_candidates: legacy,
+        successful_tool_calls: (toolHistory || [])
+            .filter((tool) => legacy.includes(tool.name || tool.tool_name || tool.tool) && tool.ok !== false)
+            .map((tool) => ({
+            name: tool.name || tool.tool_name || tool.tool,
+            at: tool.at || tool.timestamp,
+            input_hash: stableHash({ name: tool.name || tool.tool_name || tool.tool, input: safeParseToolPayload(tool.input) }),
+            side_effect: toolNameSuggestsSideEffect(tool.name || tool.tool_name || tool.tool),
+        })),
+        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 compactDecisionStateForAgent = (state = {}) => cleanContextValue({
     current_intent: state.current_intent,
     active_decisions: (state.active_decisions || []).slice(-4).map((decision) => cleanContextValue({
@@ -2830,9 +2891,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'),
@@ -2937,6 +2995,234 @@ const compactVectorMemoriesForAgent = (vectorMemories = [], toolHistory = [], ma
         .filter((text) => !hasStructuredTools || !/^\[Used tools:/i.test(text))
         .slice(0, maxItems);
 };
+const AGENT_CONTEXT_KIND_V2 = 'tembory.agent_context.v2';
+const compactStructuredPayloadForAgentV2 = (value, max = 900) => {
+    const parsed = safeParseToolPayload(value);
+    const cleaned = parsed && typeof parsed === 'object' ? stripNoisyToolFields(parsed) : parsed;
+    const text = typeof cleaned === 'string' ? cleaned : safeStringify(cleaned);
+    if (!text || text === 'undefined')
+        return undefined;
+    if (text.length <= max)
+        return cleaned;
+    return truncate(text, max);
+};
+const compactToolOutputForAgentV2 = (tool = {}, includeResults = true) => {
+    if (includeResults === false)
+        return undefined;
+    const raw = tool.result !== undefined ? tool.result : tool.output !== undefined ? tool.output : tool.observation;
+    const parsed = compactParsedToolOutputForSideChannel(safeParseToolPayload(raw));
+    if (parsed !== undefined)
+        return parsed;
+    return compactToolResult(raw, 1000);
+};
+const compactToolEvidenceForAgentV2 = (toolHistory = [], maxItems = 8, includeResults = true) => {
+    const tools = pruneByLimit(toolHistory || [], maxItems);
+    const events = tools.map((tool, index) => {
+        const name = String(tool.name || tool.tool_name || tool.tool || 'unknown_tool');
+        return cleanContextValue({
+            index,
+            name,
+            status: tool.ok === false ? 'failed' : 'ok',
+            at: tool.at || tool.timestamp,
+            input: compactStructuredPayloadForAgentV2(tool.input, 700),
+            inputHash: stableHash({ name, input: safeParseToolPayload(tool.input) }),
+            facts: extractToolOperationalFacts(tool),
+            output: compactToolOutputForAgentV2(tool, includeResults),
+            sideEffect: toolNameSuggestsSideEffect(name),
+            source: tool.source,
+        });
+    });
+    const names = Array.from(new Set((toolHistory || []).map((tool) => tool.name || tool.tool_name || tool.tool).filter(Boolean)));
+    return cleanContextValue({
+        count: Array.isArray(toolHistory) ? toolHistory.length : 0,
+        shown: events.length,
+        names: names.slice(0, 16),
+        latest: events.length ? {
+            name: events[events.length - 1].name,
+            status: events[events.length - 1].status,
+            at: events[events.length - 1].at,
+        } : undefined,
+        events,
+    });
+};
+const compactConversationFrameForAgentV2 = ({ query = '', recentMessages = [], workingMemory = {}, maxItems = 10 }) => {
+    const chronological = sortConversationChronological(recentMessages || []).map((message) => ({
+        role: normalizeConversationRoleForSideChannel(message.role || message.type),
+        at: message.at || message.timestamp || message.created_at || message.createdAt,
+        content: truncate(message.content || message.text || message.message || '', 500),
+    }));
+    const currentNormalized = normalizeIntentText(query).trim();
+    const users = chronological.filter((message) => message.role === 'user');
+    const assistants = chronological.filter((message) => message.role === 'agent' || message.role === 'assistant' || message.role === 'ai');
+    const currentUser = [...users].reverse().find((message) => normalizeIntentText(message.content).trim() === currentNormalized) || (query ? { role: 'user', content: truncate(query, 500), at: nowIso() } : users[users.length - 1]);
+    const previousUser = [...users].reverse().find((message) => normalizeIntentText(message.content).trim() !== currentNormalized);
+    const lastAssistant = assistants[assistants.length - 1] || null;
+    return cleanContextValue({
+        currentUserMessage: currentUser ? currentUser.content : truncate(query, 500),
+        previousUserMessage: previousUser ? { content: previousUser.content, at: previousUser.at } : undefined,
+        lastAssistantMessage: lastAssistant ? { content: lastAssistant.content, at: lastAssistant.at } : undefined,
+        timeline: pruneByLimit(chronological, maxItems),
+        counts: {
+            messages: chronological.length,
+            userMessages: users.length,
+            assistantMessages: assistants.length,
+        },
+        instruction: 'This is the authoritative user/assistant transcript. Use it for recall questions before summaries, facts, or tool evidence.',
+        digest: (workingMemory || {}).conversation_digest,
+    });
+};
+const mergeLatestOperationalFacts = (toolHistory = []) => {
+    let merged = {};
+    for (const tool of toolHistory || []) {
+        if (tool && tool.ok === false)
+            continue;
+        const facts = extractToolOperationalFacts(tool);
+        if (facts)
+            merged = mergeOperationalFactObjects(facts, merged);
+    }
+    return cleanContextValue(merged);
+};
+const buildCanonicalFactsForAgentV2 = ({ profileFacts = {}, toolHistory = [], operationalState = {} }) => {
+    const toolState = (operationalState || {}).tool_state || {};
+    const latestByTool = {};
+    for (const [name, item] of Object.entries(toolState.latest_by_name || {})) {
+        latestByTool[name] = cleanContextValue({
+            at: item.at,
+            status: item.ok === false ? 'failed' : 'ok',
+            facts: item.facts,
+        });
+    }
+    const sideEffects = (toolHistory || []).filter((tool) => tool && tool.ok !== false && toolNameSuggestsSideEffect(tool.name || tool.tool_name || tool.tool)).map((tool) => cleanContextValue({
+        tool: tool.name || tool.tool_name || tool.tool,
+        at: tool.at || tool.timestamp,
+        facts: extractToolOperationalFacts(tool),
+        output: compactToolOutputForAgentV2(tool, true),
+    }));
+    return cleanContextValue({
+        profile: renderProfileFacts(profileFacts),
+        operational: mergeLatestOperationalFacts(toolHistory),
+        latestByTool,
+        completedSideEffects: sideEffects.slice(-8),
+        sourcePolicy: 'Structured tool outputs and tool facts beat vector text and summaries when they conflict.',
+    });
+};
+const classifyToolFreshnessPolicy = (tool = {}, ttlSeconds = 0) => {
+    const name = String(tool.name || tool.tool_name || tool.tool || '');
+    if (tool.ok === false)
+        return { ttlPolicy: 'failed_tool_short_memory', canReuseAsEvidence: true, shouldRefreshForNewAction: true };
+    if (toolNameSuggestsSideEffect(name))
+        return { ttlPolicy: 'completed_side_effect_until_changed', canReuseAsEvidence: true, shouldRefreshForNewAction: false };
+    if (/(availability|disponibilidade|slot|horario|horário|agenda)/i.test(name))
+        return { ttlPolicy: 'volatile_lookup', canReuseAsEvidence: true, shouldRefreshForNewAction: true };
+    return { ttlPolicy: ttlSeconds > 0 ? 'bounded_reference' : 'stable_reference', canReuseAsEvidence: true, shouldRefreshForNewAction: false };
+};
+const buildFreshnessForAgentV2 = (toolHistory = [], adv = {}) => {
+    const ttlSeconds = Number(adv.toolHistoryTTLSeconds || 0);
+    const nowMs = Date.now();
+    return cleanContextValue({
+        generatedAt: nowIso(),
+        toolHistoryTTLSeconds: ttlSeconds || undefined,
+        tools: pruneByLimit(toolHistory || [], adv.toolHistoryLastN || 8).map((tool) => {
+            const at = tool.at || tool.timestamp;
+            const ageSeconds = at ? Math.max(0, Math.round((nowMs - new Date(at).getTime()) / 1000)) : undefined;
+            return cleanContextValue({
+                name: tool.name || tool.tool_name || tool.tool,
+                at,
+                ageSeconds,
+                ...classifyToolFreshnessPolicy(tool, ttlSeconds),
+            });
+        }),
+    });
+};
+const buildCaptureHealthForAgentV2 = ({ diagnostics = {}, toolHistory = [], recentMessages = [] }) => {
+    const capture = (diagnostics || {}).captureState || {};
+    const lastCaptured = Number(capture.last_save_tool_calls_captured || 0);
+    const hasToolHistory = Array.isArray(toolHistory) && toolHistory.length > 0;
+    return cleanContextValue({
+        conversationCaptured: Array.isArray(recentMessages) && recentMessages.length > 0,
+        toolPayloadReceived: lastCaptured > 0 || hasToolHistory,
+        toolCallsCapturedLastSave: capture.last_save_tool_calls_captured,
+        toolHistoryAvailable: hasToolHistory,
+        lastSaveAt: capture.last_save_at,
+        captureSources: capture.last_save_capture_sources,
+        status: lastCaptured > 0 ? 'captured_in_last_save' : hasToolHistory ? 'historical_tool_context_available' : 'no_tool_payload_received',
+        actionRequired: !hasToolHistory && lastCaptured === 0 ? 'Enable AI Agent Return Intermediate Steps or pass tool messages/__temboryToolCalls to memory so tools can be saved.' : undefined,
+    });
+};
+const buildAgentContextV2 = ({ query = '', userId = '', payloadFormat = 'structured', profileFacts = {}, workingMemory = {}, decisionState = {}, memoryCompression = {}, operationalState = {}, actionLedger = [], vectorMemories = [], recentMessages = [], toolHistory = [], diagnostics = {}, activeSummary = '', connectedModelSummary = '', adv = {} }) => {
+    const intent = (decisionState || {}).current_intent || (workingMemory || {}).last_user_intent || inferUserIntent(query, recentMessages);
+    const toolEvidence = compactToolEvidenceForAgentV2(toolHistory, adv.toolHistoryLastN || 8, adv.includeToolResults !== false);
+    const referenceFacts = compactVectorMemoriesForAgent(vectorMemories || [], toolHistory || [], Number(adv.summaryMaxFacts || 4));
+    const captureHealth = buildCaptureHealthForAgentV2({ diagnostics, toolHistory, recentMessages });
+    const statusQuestion = intent === 'operational_status_question';
+    const recallOnly = intent === 'conversation_recall' || (statusQuestion && hasNoToolRequested(query));
+    const actionDirective = buildActionDirective({ workingMemory, operationalState });
+    return cleanContextValue({
+        kind: AGENT_CONTEXT_KIND_V2,
+        schemaVersion: '2.0',
+        meta: {
+            userId,
+            payloadFormat,
+            generatedAt: nowIso(),
+        },
+        instruction: {
+            role: 'read_only_operational_memory',
+            precedence: [
+                'The current user message and the agent prompt are authoritative for what to do now.',
+                'conversationFrame is authoritative for what the user and assistant said.',
+                'toolEvidence is authoritative for prior tool calls, inputs, outputs, status and timestamps.',
+                'canonicalFacts are derived from structured tool outputs and profile facts; use source tool facts over vector text when they conflict.',
+                'Do not represent a new side effect as completed from memory alone. New side effects require a current successful tool call when the agent prompt requires one.',
+            ],
+            langchainN8nContract: 'This is a SystemMessage context payload. Historical tools are evidence, not LangChain ToolMessages, and must not be replayed as tool results.',
+        },
+        currentTurn: {
+            userMessage: truncate(query, 700),
+            intentHint: intent,
+            noToolRequested: hasNoToolRequested(query),
+            recallOnly,
+            statusQuestion,
+        },
+        conversationFrame: compactConversationFrameForAgentV2({
+            query,
+            recentMessages,
+            workingMemory,
+            maxItems: Number(adv.agentRecentMessagesLastN || adv.lastN || 10),
+        }),
+        canonicalFacts: buildCanonicalFactsForAgentV2({ profileFacts, toolHistory, operationalState }),
+        toolEvidence,
+        toolReuseGuard: compactRepeatToolPolicyForAgent(repeatToolPolicyForAgentContext(decisionState || {}, toolHistory || [])),
+        actionDirective: actionDirective ? cleanContextValue({
+            requiredTool: actionDirective.required_tool,
+            evidenceFromRecentTools: actionDirective.evidence_from_recent_tools,
+            instruction: actionDirective.instruction,
+        }) : undefined,
+        pendingState: {
+            nextExpectedAction: (workingMemory || {}).next_expected_action,
+            activeDecisions: compactDecisionStateForAgent(decisionState || {}).active_decisions,
+            missingRequiredFields: [],
+        },
+        freshness: buildFreshnessForAgentV2(toolHistory, adv),
+        memory: cleanContextValue({
+            slmSummary: connectedModelSummary ? truncate(connectedModelSummary, Number(adv.connectedModelSummaryMaxChars || 900)) : undefined,
+            activeSummary: !connectedModelSummary && activeSummary ? truncate(activeSummary, Number(adv.activeSummaryMaxChars || 900)) : undefined,
+            referenceFacts,
+            compression: adv.includeMemoryCompression === false ? undefined : compactMemoryCompressionForAgent(memoryCompression || {}),
+        }),
+        statusAnswerMaterial: statusQuestion ? buildStatusAnswerMaterialForAgent({ query, workingMemory, toolHistory, actionLedger }) : undefined,
+        captureHealth,
+        contextBudget: {
+            approxTokens: approxTokenCount(safeStringify({
+                query,
+                recentMessages: pruneByLimit(recentMessages || [], Number(adv.agentRecentMessagesLastN || adv.lastN || 10)),
+                toolEvidence,
+                referenceFacts,
+            })),
+            conversationMessagesIncluded: Math.min((recentMessages || []).length, Number(adv.agentRecentMessagesLastN || adv.lastN || 10)),
+            toolEventsIncluded: (toolEvidence.events || []).length,
+        },
+    });
+};
 const modelResponseText = (response) => {
     const content = response === null || response === void 0 ? void 0 : response.content;
     if (typeof content === 'string')
@@ -3270,15 +3556,15 @@ const compactMemoryEventPayload = (payload = {}) => {
 const compactLastSaveForSideChannel = (lastSave = {}) => cleanContextValue({
     saved: lastSave.saved,
     status: lastSave.status,
-    at: lastSave.at,
-    inputChars: lastSave.input_chars,
-    outputChars: lastSave.output_chars,
-    toolCallsCaptured: lastSave.tool_calls_captured,
-    toolNames: lastSave.tool_names,
-    conversationMessagesAfterSave: lastSave.conversation_messages_after_save,
-    toolHistoryAfterSave: lastSave.tool_history_after_save,
-    threadStateSaved: lastSave.thread_state_saved,
-    backendPersistence: lastSave.backend_memory_persistence,
+    at: lastSave.at || lastSave.lastSaveAt,
+    inputChars: lastSave.input_chars || lastSave.inputChars,
+    outputChars: lastSave.output_chars || lastSave.outputChars,
+    toolCallsCaptured: lastSave.tool_calls_captured || lastSave.toolCallsCaptured,
+    toolNames: lastSave.tool_names || lastSave.toolNames,
+    conversationMessagesAfterSave: lastSave.conversation_messages_after_save || lastSave.conversationMessagesAfterSave,
+    toolHistoryAfterSave: lastSave.tool_history_after_save || lastSave.toolHistoryAfterSave,
+    threadStateSaved: lastSave.thread_state_saved || lastSave.threadStateSaved,
+    backendPersistence: lastSave.backend_memory_persistence || lastSave.backendPersistence,
 });
 const compactDedupeForSideChannel = (dedupe = {}) => {
     const load = dedupe.load || {};
@@ -3293,18 +3579,23 @@ const compactDedupeForSideChannel = (dedupe = {}) => {
     });
 };
 const loadedSectionsForSideChannel = (parsed = {}, memoryAudit = {}) => cleanContextValue({
-    conversation: Boolean(parsed.conversation),
-    summary: Boolean(parsed.summary),
+    conversation: Boolean(parsed.conversation || parsed.conversationFrame),
+    summary: Boolean(parsed.summary || parsed.memory),
     activeSummary: Boolean(parsed.activeSummary),
     connectedModelSummary: Boolean(parsed.connectedModelSummary),
-    workingMemory: Boolean(parsed.workingMemory),
+    workingMemory: Boolean(parsed.workingMemory || parsed.pendingState),
     decisionState: Boolean(parsed.decisionState),
-    memoryCompression: Boolean(parsed.memoryCompression),
+    memoryCompression: Boolean(parsed.memoryCompression || parsed.memory?.compression),
     operationalState: Boolean(parsed.operationalState),
     actionLedger: Array.isArray(parsed.actionLedger),
     statusAnswerMaterial: Boolean(parsed.statusAnswerMaterial || parsed.status_answer_material),
     turnBrief: Boolean(parsed.turnBrief || parsed.turn_brief),
     memoryAudit: Boolean(memoryAudit && Object.keys(memoryAudit).length),
+    canonicalFacts: Boolean(parsed.canonicalFacts),
+    toolEvidence: Boolean(parsed.toolEvidence),
+    toolReuseGuard: Boolean(parsed.toolReuseGuard),
+    freshness: Boolean(parsed.freshness),
+    captureHealth: Boolean(parsed.captureHealth),
     entityTimeline: Array.isArray(parsed.entityTimeline),
     vectorMemories: Array.isArray(parsed.vectorMemories),
     graph: Array.isArray(parsed.graph),
@@ -3338,12 +3629,17 @@ const agentContextBudgetForSideChannel = (messages = [], parsed = {}) => {
     const totalChars = messageBudgets.reduce((sum, item) => sum + item.chars, 0);
     const sectionCandidates = [
         ['instruction', parsed.instruction],
-        ['conversation', parsed.conversation],
+        ['conversation', parsed.conversation || parsed.conversationFrame],
         ['current_turn_focus', parsed.current_turn_focus || parsed.currentTurn || parsed.current_turn],
+        ['canonical_facts', parsed.canonicalFacts],
+        ['tool_evidence', parsed.toolEvidence],
+        ['tool_reuse_guard', parsed.toolReuseGuard],
+        ['freshness', parsed.freshness],
+        ['capture_health', parsed.captureHealth],
         ['action_directive', parsed.action_directive],
         ['status_answer_material', parsed.statusAnswerMaterial || parsed.status_answer_material],
         ['turn_brief', parsed.turnBrief || parsed.turn_brief],
-        ['summary', parsed.summary],
+        ['summary', parsed.summary || parsed.memory],
         ['working_memory', parsed.workingMemory || parsed.working_memory],
         ['decision_state', parsed.decisionState || parsed.decision_state],
         ['operational_state', parsed.operationalState || parsed.operational_state],
@@ -3382,7 +3678,7 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         const type = messageTypeOf(message);
         return type === 'system' || /system/i.test(String(message?.role || ''));
     });
-    const contextMessage = firstSystem || list.find((message) => messageContentOf(message).includes('tembory.agent_context.v1')) || list[0];
+    const contextMessage = firstSystem || list.find((message) => /tembory\.agent_context\.v[12]/.test(messageContentOf(message))) || list[0];
     if (!contextMessage)
         return summary;
     try {
@@ -3398,11 +3694,35 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
                 throw new Error('Tembory visual summary could not find JSON context');
             parsed = JSON.parse(rawContent.slice(start, end + 1));
         }
-        const conversation = parsed.conversation || {};
-        const tools = parsed.tools || {};
-        const toolItems = Array.isArray(tools.items) ? tools.items : [];
-        const memoryAudit = parsed.memoryAudit || parsed.memory_audit || {};
-        const summaryText = parsed.summary?.slm || parsed.summary || parsed.connectedModelSummary || parsed.activeSummary || '';
+        const isAgentContextV2 = parsed.kind === AGENT_CONTEXT_KIND_V2;
+        const rawConversation = parsed.conversation || parsed.conversationFrame || {};
+        const conversation = isAgentContextV2 ? cleanContextValue({
+            current_user_message: rawConversation.currentUserMessage,
+            conversation_history_chronological: (rawConversation.timeline || []).map((message) => ({
+                role: message.role,
+                content: message.content,
+                at: message.at,
+            })),
+            all_user_messages_chronological: (rawConversation.timeline || []).filter((message) => normalizeConversationRoleForSideChannel(message.role) === 'user').map((message) => ({
+                role: 'user',
+                content: message.content,
+                at: message.at,
+            })),
+        }) : rawConversation;
+        const tools = parsed.tools || parsed.toolEvidence || {};
+        const rawToolItems = Array.isArray(tools.items) ? tools.items : (Array.isArray(tools.events) ? tools.events : []);
+        const toolItems = rawToolItems.map((tool) => cleanContextValue({
+            name: tool.name || tool.tool_name || tool.tool,
+            status: tool.status,
+            ok: tool.ok !== false && tool.status !== 'failed',
+            at: tool.at || tool.timestamp,
+            input: tool.input,
+            result: tool.result !== undefined ? tool.result : tool.output,
+            facts: tool.facts,
+            source: tool.source,
+        }));
+        const memoryAudit = parsed.memoryAudit || parsed.memory_audit || parsed.captureHealth || {};
+        const summaryText = parsed.summary?.slm || parsed.summary || parsed.connectedModelSummary || parsed.activeSummary || parsed.memory?.slmSummary || parsed.memory?.activeSummary || '';
         const chronological = Array.isArray(conversation.conversation_history_chronological)
             ? conversation.conversation_history_chronological
             : [];
@@ -3412,7 +3732,11 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         const lastUser = [...chronological].reverse().find((message) => normalizeConversationRoleForSideChannel(message.role || message.type) === 'user');
         const lastAgent = [...chronological].reverse().find((message) => normalizeConversationRoleForSideChannel(message.role || message.type) === 'agent');
         const includeDebug = Boolean(parsed.options?.includeDiagnostics || parsed.diagnostics?.includeDiagnostics || parsed.diagnostics?.include_diagnostics);
-        const lastSave = compactLastSaveForSideChannel(memoryAudit.last_save || parsed.state?.last_save || {});
+        const lastSave = compactLastSaveForSideChannel(memoryAudit.last_save || parsed.state?.last_save || (isAgentContextV2 ? {
+            at: parsed.captureHealth?.lastSaveAt,
+            toolCallsCaptured: parsed.captureHealth?.toolCallsCapturedLastSave,
+            captureSources: parsed.captureHealth?.captureSources,
+        } : {}));
         const fullDedupeSummary = parsed.dedupeSummary || parsed.diagnostics?.dedupeSummary || undefined;
         const loadedSections = loadedSectionsForSideChannel(parsed, memoryAudit);
         const agentContextBudget = agentContextBudgetForSideChannel(list, parsed);
@@ -3421,7 +3745,7 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         summary.project = parsed.project || undefined;
         summary.retrievalMode = parsed.retrievalMode;
         summary.payloadFormat = parsed.payloadFormat;
-        summary.intent = parsed.observations?.inferred_intent?.label || parsed.workingMemory?.last_user_intent || parsed.decisionState?.current_intent || undefined;
+        summary.intent = parsed.currentTurn?.intentHint || parsed.observations?.inferred_intent?.label || parsed.workingMemory?.last_user_intent || parsed.decisionState?.current_intent || undefined;
         const parsedTurnBrief = parsed.turnBrief || parsed.turn_brief || undefined;
         summary.currentTurn = parsed.currentTurn || parsed.current_turn || parsed.diagnostics?.currentTurn || undefined;
         summary.currentUserMessage = conversation.current_user_message ? truncate(conversation.current_user_message, 180) : undefined;
@@ -3476,29 +3800,37 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         summary.lastSave = Object.keys(lastSave).length ? lastSave : undefined;
         summary.dedupe = fullDedupeSummary ? compactDedupeForSideChannel(fullDedupeSummary) : undefined;
         summary.workingMemory = cleanContextValue({
-            currentGoal: parsed.workingMemory?.current_goal,
+            currentGoal: parsed.workingMemory?.current_goal || parsed.pendingState?.nextExpectedAction,
             currentGoalReason: parsed.workingMemory?.current_goal_reason,
-            currentTask: parsed.workingMemory?.current_task,
-            nextExpectedAction: parsed.workingMemory?.next_expected_action,
-            lastUserIntent: parsed.workingMemory?.last_user_intent,
-            lastUserMessage: parsed.workingMemory?.last_user_message ? truncate(parsed.workingMemory.last_user_message, 220) : undefined,
-            conversation: parsed.workingMemory?.conversation_digest,
-            tools: parsed.workingMemory?.tool_digest,
-            turnFlags: parsed.workingMemory?.turn_flags,
+            currentTask: parsed.workingMemory?.current_task || parsed.pendingState?.nextExpectedAction,
+            nextExpectedAction: parsed.workingMemory?.next_expected_action || parsed.pendingState?.nextExpectedAction,
+            lastUserIntent: parsed.workingMemory?.last_user_intent || parsed.currentTurn?.intentHint,
+            lastUserMessage: parsed.workingMemory?.last_user_message ? truncate(parsed.workingMemory.last_user_message, 220) : parsed.currentTurn?.userMessage,
+            conversation: parsed.workingMemory?.conversation_digest || parsed.conversationFrame?.counts,
+            tools: parsed.workingMemory?.tool_digest || { total: parsed.toolEvidence?.count, names: parsed.toolEvidence?.names },
+            turnFlags: parsed.workingMemory?.turn_flags || cleanContextValue({
+                recall_only: parsed.currentTurn?.recallOnly,
+                status_question: parsed.currentTurn?.statusQuestion,
+                no_tool_requested: parsed.currentTurn?.noToolRequested,
+                has_prior_tools: parsed.toolEvidence?.count ? true : undefined,
+            }),
             contextSources: parsed.workingMemory?.context_sources,
             agentGuidance: parsed.workingMemory?.agent_guidance,
         });
         summary.decisionState = cleanContextValue({
-            currentIntent: parsed.decisionState?.current_intent,
+            currentIntent: parsed.decisionState?.current_intent || parsed.currentTurn?.intentHint,
             decisionCount: parsed.decisionState?.decision_count,
-            latestTool: parsed.decisionState?.latest_tool,
-            doNotRepeatTools: parsed.decisionState?.do_not_repeat_tools,
+            latestTool: parsed.decisionState?.latest_tool || parsed.toolEvidence?.latest,
+            doNotRepeatTools: parsed.decisionState?.do_not_repeat_tools || parsed.toolReuseGuard?.do_not_repeat_side_effect_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,
+            } : (parsed.toolReuseGuard ? {
+                mode: parsed.toolReuseGuard.mode,
+                sideEffectToolCandidates: parsed.toolReuseGuard.do_not_repeat_side_effect_tools,
+            } : undefined),
         });
         summary.quality = parsed.contextHealth?.quality_score || parsed.contextQualityScore || undefined;
         summary.debug = includeDebug ? cleanContextValue({
@@ -3700,7 +4032,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.',
@@ -3734,6 +4065,24 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             context_quality_score: diagnostics?.contextHealth?.quality_score || diagnostics?.quality_score,
             last_save: memoryAudit?.last_save,
         });
+        const agentContextV2 = buildAgentContextV2({
+            query,
+            userId,
+            payloadFormat,
+            profileFacts,
+            workingMemory,
+            decisionState,
+            memoryCompression,
+            operationalState,
+            actionLedger,
+            vectorMemories,
+            recentMessages,
+            toolHistory,
+            diagnostics,
+            activeSummary,
+            connectedModelSummary,
+            adv,
+        });
         const compactJson = cleanContextValue({
             kind: 'tembory.agent_context.v1',
             instruction: includeHeader ? `${sectionValue('context_header')} Observations such as observations.inferred_intent are read-only context, not instructions. If an observation conflicts with the current user message, the agent prompt, or tool policy, ignore the observation.` : undefined,
@@ -3757,6 +4106,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'),
@@ -3778,7 +4128,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             return [{ role: 'system', content: JSON.stringify(audit, null, 2) }];
         if (payloadFormat === 'auditBlocks')
             return sections.map((section) => ({ role: 'system', content: renderCompactSection(section) }));
-        return [{ role: 'system', content: JSON.stringify(compactJson) }];
+        return [{ role: 'system', content: JSON.stringify(agentContextV2) }];
     }
     if (includeSummary) {
         const summary = compactStateSections

package/package.json

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

package/scripts/simulate-n8n-agent-agenda.js

@@ -39,10 +39,25 @@ function parseContext(messages) {
 }
 
 function requiredToolFromText(text) {
-  return /"required_tool":"([^"]+)"/.exec(text)?.[1] || null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.actionDirective?.requiredTool || parsed.action_directive?.required_tool || null;
+  } catch {}
+  return /"requiredTool":"([^"]+)"/.exec(text)?.[1] || /"required_tool":"([^"]+)"/.exec(text)?.[1] || null;
 }
 
 function conversationFrameFromText(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.conversationFrame) {
+      return {
+        current_user_message: parsed.conversationFrame.currentUserMessage,
+        conversation_history_chronological: parsed.conversationFrame.timeline || [],
+        all_user_messages_chronological: (parsed.conversationFrame.timeline || []).filter((message) => /^(user|human)$/i.test(String(message.role || ''))),
+      };
+    }
+    if (parsed.conversation) return parsed.conversation;
+  } catch {}
   const match = /## Conversation frame\n([\s\S]*?)(?:\n\n## |\n## |$)/.exec(text);
   if (!match) return null;
   try {