n8n-nodes-tembory 1.0.7 → 1.0.9

package/dist/nodes/Mem0/Mem0Memory.node.js

@@ -43,7 +43,7 @@ const getConnectedEmbedding = async (ctx, itemIndex) => {
 };
 const createClientVectorMemory = async (embedding, text, metadata, ids = {}) => ({
     text: truncate(text, 4000),
-    embedding: await embedding.embedQuery(String(text || '')),
+    embedding: await embedQueryCached(embedding, String(text || '')),
     user_id: ids.user_id,
     agent_id: ids.agent_id,
     run_id: ids.run_id,
@@ -67,7 +67,7 @@ const searchClientVectorMemories = async (ctx, embedding, query, body = {}) => {
     return GenericFunctions_1.mem0ApiRequest.call(ctx, 'POST', '/elefai/v1/vector-memories/search', {
         ...body,
         query: text,
-        embedding: await embedding.embedQuery(text),
+        embedding: await embedQueryCached(embedding, text),
     });
 };
 const stableStringify = (value) => {
@@ -87,6 +87,31 @@ const hashString = (value) => {
     return (hash >>> 0).toString(36);
 };
 const stableHash = (value) => hashString(typeof value === 'string' ? value : stableStringify(value));
+const embeddingCacheByModel = new WeakMap();
+const MAX_EMBEDDING_CACHE_ITEMS = 500;
+const embedQueryCached = async (embedding, text) => {
+    const query = String(text || '');
+    if (!embedding || typeof embedding.embedQuery !== 'function')
+        return undefined;
+    let cache = embeddingCacheByModel.get(embedding);
+    if (!cache) {
+        cache = new Map();
+        embeddingCacheByModel.set(embedding, cache);
+    }
+    const key = stableHash(query);
+    if (cache.has(key))
+        return cache.get(key);
+    const promise = Promise.resolve(embedding.embedQuery(query)).catch((error) => {
+        cache.delete(key);
+        throw error;
+    });
+    cache.set(key, promise);
+    if (cache.size > MAX_EMBEDDING_CACHE_ITEMS) {
+        const firstKey = cache.keys().next().value;
+        cache.delete(firstKey);
+    }
+    return promise;
+};
 const pickText = (values, preferredKeys) => {
     for (const key of preferredKeys) {
         const value = values === null || values === void 0 ? void 0 : values[key];
@@ -928,6 +953,34 @@ const applyOperationalPreset = (advanced = {}) => {
             toolHistoryLastN: 5,
             recentMessagesLastN: 4,
         },
+        productionNano: {
+            compactForAgent: true,
+            includeContextHeader: true,
+            includeSummary: true,
+            includeScores: false,
+            includeDiagnostics: false,
+            includeRelations: false,
+            includeToolHistory: true,
+            includeToolResults: true,
+            persistToolFactsToMem0: false,
+            includeToolHistorySemanticFallback: false,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: false,
+            includeEntityTimeline: false,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: false,
+            includeRecentHighlights: false,
+            topK: 4,
+            lastN: 4,
+            maxReturn: 6,
+            toolHistoryLastN: 6,
+            recentMessagesLastN: 2,
+            vectorMemoryMaxChars: 220,
+            contextMaxChars: 6000,
+        },
         audit: {
             includeContextHeader: true,
             includeSummary: true,
@@ -1308,6 +1361,105 @@ const contextMemoryText = (memory, max = 700) => {
     }
     return truncate(text, max);
 };
+const approxTokenCount = (text) => Math.ceil(String(text || '').length / 4);
+const importantJsonFields = ['reservation_id', 'confirmation_id', 'selected_from_message', 'status', 'next_step', 'available_slots', 'timezone', 'error'];
+const pickImportantFields = (value) => {
+    if (value === null || value === undefined)
+        return {};
+    const out = {};
+    const visit = (item) => {
+        if (!item || typeof item !== 'object')
+            return;
+        if (Array.isArray(item)) {
+            item.slice(0, 3).forEach(visit);
+            return;
+        }
+        for (const key of importantJsonFields) {
+            if (item[key] !== undefined && out[key] === undefined)
+                out[key] = item[key];
+        }
+        if (item.args)
+            visit(item.args);
+        if (item.result)
+            visit(item.result);
+    };
+    visit(value);
+    return out;
+};
+const compactToolResult = (result, max = 360) => {
+    const text = String(result || '');
+    if (!text.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        const picked = pickImportantFields(parsed);
+        if (Object.keys(picked).length)
+            return truncate(safeStringify(picked), max);
+    }
+    catch { }
+    const picked = {};
+    for (const key of importantJsonFields) {
+        const re = new RegExp(`["']?${key}["']?\\s*[:=]\\s*["']?([^"',}\\]]+)`, 'i');
+        const match = re.exec(text);
+        if (match)
+            picked[key] = match[1];
+    }
+    if (Object.keys(picked).length)
+        return truncate(safeStringify(picked), max);
+    return truncate(text, max);
+};
+const compactToolHistoryForAgent = (toolHistory = [], maxItems = 6, includeResults = true) => pruneByLimit(toolHistory || [], maxItems).map((tool) => ({
+    name: tool.name,
+    status: tool.ok === false ? 'failed' : 'ok',
+    at: tool.at,
+    input: truncate(String(tool.input || ''), 180) || undefined,
+    result: includeResults ? compactToolResult(tool.result, 360) : undefined,
+}));
+const compactOperationalStateForAgent = (state = {}) => {
+    const agenda = state.agenda_state || {};
+    return {
+        last_tool: state.last_tool || null,
+        tool_counts: state.tool_counts || {},
+        agenda_state: {
+            has_availability: Boolean(agenda.has_availability),
+            has_pre_reservation: Boolean(agenda.has_pre_reservation),
+            has_confirmation: Boolean(agenda.has_confirmation),
+            has_pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
+            latest_availability: compactToolResult(agenda.latest_availability_result),
+            latest_pre_reservation: compactToolResult(agenda.latest_pre_reservation_result),
+            latest_confirmation: compactToolResult(agenda.latest_confirmation_result),
+        },
+        blocked_without_context: state.blocked_without_context || [],
+        guidance: (state.guidance || []).slice(0, 3),
+    };
+};
+const compactMemoryCompressionForAgent = (compression = {}) => ({
+    turn_summary: (compression.turn_summary || []).slice(-3),
+    session_tools: (((compression.session_summary || {}).tools) || []).slice(-6),
+    agenda_state: ((compression.session_summary || {}).agenda_state) ? {
+        has_availability: Boolean(compression.session_summary.agenda_state.has_availability),
+        has_pre_reservation: Boolean(compression.session_summary.agenda_state.has_pre_reservation),
+        has_confirmation: Boolean(compression.session_summary.agenda_state.has_confirmation),
+        has_pending_pre_reservation: Boolean(compression.session_summary.agenda_state.has_pending_pre_reservation),
+    } : undefined,
+    active_memory_count: ((compression.workflow_summary || {}).active_memory_count) || 0,
+});
+const compactVectorMemoriesForAgent = (vectorMemories = [], toolHistory = [], maxItems = 3) => {
+    const hasStructuredTools = Array.isArray(toolHistory) && toolHistory.length > 0;
+    return (vectorMemories || [])
+        .map((memory) => contextMemoryText(memory, 220))
+        .filter(Boolean)
+        .filter((text) => !hasStructuredTools || !/^\[tool_events_extracted\]/i.test(text))
+        .slice(0, maxItems);
+};
+const contextSizeOfMessages = (messages = []) => {
+    const perMessage = (messages || []).map((message, index) => {
+        const content = String(message.content || '');
+        return { index, role: message.role || 'system', chars: content.length, approx_tokens: approxTokenCount(content) };
+    });
+    const chars = perMessage.reduce((sum, item) => sum + item.chars, 0);
+    return { chars, approx_tokens: approxTokenCount((messages || []).map((m) => m.content || '').join('\n')), messages: perMessage };
+};
 const wrapElefaiMemory = (memory, ctx, memoryKey) => new Proxy(memory, {
     get(target, prop) {
         if (prop === 'loadMemoryVariables') {
@@ -1317,11 +1469,15 @@ const wrapElefaiMemory = (memory, ctx, memoryKey) => new Proxy(memory, {
                 ]);
                 try {
                     const response = await target.loadMemoryVariables(values);
-                    const chatHistory = snapshotJson(response[memoryKey] || response.chatHistory || []);
+                    const cacheHit = Boolean(response.elefaiBrainDiagnostics && response.elefaiBrainDiagnostics.cacheHit);
+                    const chatHistory = cacheHit
+                        ? [{ cached: true, messages: Array.isArray(response[memoryKey] || response.chatHistory) ? (response[memoryKey] || response.chatHistory).length : 0 }]
+                        : snapshotJson(response[memoryKey] || response.chatHistory || []);
                     ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, [
                         [{
                                 json: {
                                     action: 'loadMemoryVariables',
+                                    cached: cacheHit || undefined,
                                     chatHistory,
                                     context: response.elefaiBrainContext,
                                     contextText: response.elefaiBrainContextText,
@@ -1377,14 +1533,81 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
     const includeHeader = adv.includeContextHeader !== false;
     const includeSummary = adv.includeSummary !== false;
     const includeScores = adv.includeScores !== false;
+    const compactForAgent = Boolean(adv.compactForAgent);
     const sections = [];
     if (includeHeader) {
         sections.push({
             section: 'context_header',
             title: 'Tembory context',
-            value: 'Use this context as read-only memory. Prefer it over guessing. Do not mention internal section names to the user. Treat next_expected_action as an instruction, not as a suggestion. If it says to call a tool now, call that tool instead of asking the user the same question again. If the user asks to continue, chooses a slot, says ok/sim, reserve, confirm, update, cancel, or performs any downstream action that depends on a prior tool result, first verify the required prior result in tool_history, recent_messages, or vector memories. If the required prior result is absent, do not call the downstream tool; ask for the missing context or call the appropriate prerequisite tool.',
+            value: compactForAgent
+                ? 'Read-only memory. Follow next_expected_action when present. Before calling downstream tools, verify required prior tool context in tool_history or operational_state. Do not repeat tools listed in do_not_repeat_tools.'
+                : 'Use this context as read-only memory. Prefer it over guessing. Do not mention internal section names to the user. Treat next_expected_action as an instruction, not as a suggestion. If it says to call a tool now, call that tool instead of asking the user the same question again. If the user asks to continue, chooses a slot, says ok/sim, reserve, confirm, update, cancel, or performs any downstream action that depends on a prior tool result, first verify the required prior result in tool_history, recent_messages, or vector memories. If the required prior result is absent, do not call the downstream tool; ask for the missing context or call the appropriate prerequisite tool.',
         });
     }
+    if (compactForAgent) {
+        if (includeSummary) {
+            const summary = compactVectorMemoriesForAgent(vectorMemories, toolHistory, Number(adv.summaryMaxFacts || 3));
+            sections.push({ section: 'summary', title: 'Summary', value: summary.length ? summary : null, why_null: summary.length ? undefined : 'no non-tool vector memories to summarize' });
+        }
+        sections.push({
+            section: 'working_memory',
+            title: 'Working memory',
+            value: adv.includeWorkingMemory === false ? null : (workingMemory || {}),
+            why_null: adv.includeWorkingMemory === false ? 'working memory disabled' : undefined,
+        });
+        sections.push({
+            section: 'decision_state',
+            title: 'Decision state',
+            value: adv.includeDecisionState === false ? null : (decisionState || {}),
+            why_null: adv.includeDecisionState === false ? 'decision state disabled' : undefined,
+        });
+        sections.push({
+            section: 'operational_state',
+            title: 'Operational state',
+            value: adv.includeOperationalState === false ? null : compactOperationalStateForAgent(operationalState || {}),
+            why_null: adv.includeOperationalState === false ? 'operational state disabled' : undefined,
+        });
+        sections.push({
+            section: 'tool_history',
+            title: 'Tool history',
+            value: {
+                enabled: adv.includeToolHistory !== false,
+                items: adv.includeToolHistory === false ? [] : compactToolHistoryForAgent(toolHistory, adv.toolHistoryLastN || 6, adv.includeToolResults !== false),
+            },
+        });
+        sections.push({
+            section: 'profile_facts',
+            title: 'Profile facts',
+            value: adv.includeProfileFacts === false ? null : renderProfileFacts(profileFacts),
+            why_null: adv.includeProfileFacts === false ? 'profile facts disabled' : undefined,
+        });
+        sections.push({
+            section: 'memory_compression',
+            title: 'Memory compression',
+            value: adv.includeMemoryCompression === false ? null : compactMemoryCompressionForAgent(memoryCompression || {}),
+            why_null: adv.includeMemoryCompression === false ? 'memory compression disabled' : undefined,
+        });
+        const audit = {
+            kind: 'elefai.brain.context.v1',
+            meta: { user_id: userId, payloadFormat, query, compact_for_agent: true },
+            sections,
+            diagnostics,
+        };
+        const renderCompactSection = (section) => {
+            if (section.value === null || section.value === undefined)
+                return `## ${section.title}\n${section.why_null || 'empty'}`;
+            if (typeof section.value === 'string')
+                return `## ${section.title}\n${section.value}`;
+            if (Array.isArray(section.value))
+                return `## ${section.title}\n${section.value.length ? section.value.map((item) => typeof item === 'string' ? `- ${item}` : `- ${truncate(safeStringify(item), 420)}`).join('\n') : '(empty)'}`;
+            return `## ${section.title}\n${truncate(safeStringify(section.value), 900)}`;
+        };
+        if (payloadFormat === 'auditJson')
+            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: truncate(sections.map(renderCompactSection).join('\n\n'), Number(adv.contextMaxChars || 6000)) }];
+    }
     if (includeSummary) {
         const summary = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map((memory) => contextMemoryText(memory, 360)).filter(Boolean);
         sections.push({ section: 'summary', title: 'Summary', value: summary.length ? summary : null, why_null: summary.length ? undefined : 'no vector memories to summarize' });
@@ -1654,6 +1877,7 @@ class Mem0Memory {
                                 { name: 'Diagnóstico Completo', value: 'diagnostic' },
                                 { name: 'Produção Balanceada', value: 'productionBalanced' },
                                 { name: 'Produção Econômica', value: 'productionCheap' },
+                                { name: 'Produção Nano/SLM', value: 'productionNano' },
                                 { name: 'Auditoria', value: 'audit' },
                             ],
                             default: 'custom',
@@ -1673,6 +1897,8 @@ class Mem0Memory {
                         { displayName: 'MMR (diversidade)', name: 'mmr', type: 'boolean', default: true, description: 'Aplicar diversidade de resultados (Maximal Marginal Relevance)', displayOptions: { show: { '/retrievalMode': ['hybrid'] } } },
                         { displayName: 'MMR Lambda', name: 'mmrLambda', type: 'number', typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 }, default: 0.5, description: 'Equilíbrio entre relevância e diversidade no MMR', displayOptions: { show: { '/retrievalMode': ['hybrid'] } } },
                         { displayName: 'Incluir Cabeçalho de Contexto', name: 'includeContextHeader', type: 'boolean', default: true },
+                        { displayName: 'Compactar Contexto Para Agente', name: 'compactForAgent', type: 'boolean', default: false, description: 'Entrega ao agente apenas o estado acionável: working memory, decisões, estado operacional e histórico de tools compacto. Mantém detalhes completos no audit/debug.' },
+                        { displayName: 'Máximo de Caracteres do Contexto', name: 'contextMaxChars', type: 'number', default: 6000, description: 'Limite final aplicado quando Compactar Contexto Para Agente estiver ativo.' },
                         { displayName: 'Incluir Resumo', name: 'includeSummary', type: 'boolean', default: true },
                         { displayName: 'Máximo de Fatos no Resumo', name: 'summaryMaxFacts', type: 'number', default: 4 },
                         { displayName: 'Incluir Scores', name: 'includeScores', type: 'boolean', default: true },
@@ -1706,6 +1932,7 @@ class Mem0Memory {
     async supplyData(itemIndex) {
         const memoryKey = this.getNodeParameter('memoryKey', itemIndex);
         let currentMessages = [];
+        const loadCache = new Map();
         const memory = {
             memoryKeys: [memoryKey],
             inputKey: 'input',
@@ -1736,7 +1963,38 @@ class Mem0Memory {
                 },
             },
             loadMemoryVariables: async (inputValues = {}) => {
-                const result = await Mem0Memory.prototype.loadMemoryVariablesForItem.call(this, itemIndex, inputValues);
+                const cacheKey = stableHash({ itemIndex, inputValues, memoryKey });
+                let result;
+                if (loadCache.has(cacheKey)) {
+                    result = snapshotJson(loadCache.get(cacheKey));
+                    result.response = result.response || {};
+                    result.response.elefaiBrainDiagnostics = {
+                        ...(result.response.elefaiBrainDiagnostics || {}),
+                        cacheHit: true,
+                        cacheScope: 'supplyData.loadMemoryVariables',
+                    };
+                    if (result.response.elefaiBrainContext) {
+                        result.response.elefaiBrainContext = {
+                            kind: result.response.elefaiBrainContext.kind,
+                            userId: result.response.elefaiBrainContext.userId,
+                            project: result.response.elefaiBrainContext.project,
+                            query: result.response.elefaiBrainContext.query,
+                            retrievalMode: result.response.elefaiBrainContext.retrievalMode,
+                            payloadFormat: result.response.elefaiBrainContext.payloadFormat,
+                            contextQualityScore: result.response.elefaiBrainContext.contextQualityScore,
+                            cacheHit: true,
+                        };
+                    }
+                    delete result.response.elefaiBrainContextText;
+                }
+                else {
+                    result = await Mem0Memory.prototype.loadMemoryVariablesForItem.call(this, itemIndex, inputValues);
+                    loadCache.set(cacheKey, snapshotJson(result));
+                    if (loadCache.size > 20) {
+                        const firstKey = loadCache.keys().next().value;
+                        loadCache.delete(firstKey);
+                    }
+                }
                 const chatHistory = (result.response[memoryKey] || []).map(toBaseMessage);
                 const extra = { ...(result.response || {}) };
                 delete extra[memoryKey];
@@ -1748,6 +2006,7 @@ class Mem0Memory {
                 };
             },
             saveContext: async (inputValues = {}, outputValues = {}) => {
+                loadCache.clear();
                 const input = pickText(inputValues, ['input', 'chatInput', 'text', 'query', 'question']);
                 const output = pickText(outputValues, ['output', 'response', 'text', 'answer']);
                 if (input)
@@ -2030,7 +2289,7 @@ class Mem0Memory {
         }
         if (connectedEmbedding && typeof connectedEmbedding.embedQuery === 'function' && String(query || '').trim()) {
             try {
-                await connectedEmbedding.embedQuery(String(query));
+                await embedQueryCached(connectedEmbedding, String(query));
                 connectedAi.embeddingQuery = true;
             }
             catch (error) {
@@ -2270,10 +2529,10 @@ class Mem0Memory {
             catch { }
         }
         let connectedModelSummary = '';
-        if (connectedLanguageModel && typeof connectedLanguageModel.invoke === 'function' && (vectorMemories.length || String(query || '').trim()) && adv.includeSummary !== false) {
+        if (connectedLanguageModel && typeof connectedLanguageModel.invoke === 'function' && vectorMemories.length && adv.includeSummary !== false) {
             try {
                 const facts = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map((memory) => contextMemoryText(memory, 500)).filter(Boolean).join('\n') || '(no vector memories found)';
-                if (facts || String(query || '').trim()) {
+                if (facts) {
                     const response = await connectedLanguageModel.invoke([
                         toBaseMessage({
                             role: 'user',
@@ -2362,6 +2621,7 @@ class Mem0Memory {
             diagnostics,
             adv,
         });
+        diagnostics.contextSize = contextSizeOfMessages(payload);
         const normalizedVectorMemories = vectorMemories.map((m) => {
             const scoreMeta = scoreMetaOf(m);
             const rawScore = scoreOf(m);
@@ -2404,6 +2664,7 @@ class Mem0Memory {
                 includeOperationalState: adv.includeOperationalState !== false,
                 includeActionLedger: adv.includeActionLedger !== false,
                 includeEntityTimeline: adv.includeEntityTimeline !== false,
+            compactForAgent: Boolean(adv.compactForAgent),
             includeWorkingMemory: adv.includeWorkingMemory !== false,
             includeDecisionState: adv.includeDecisionState !== false,
             includeMemoryCompression: adv.includeMemoryCompression !== false,
@@ -2587,4 +2848,10 @@ exports.__private = {
     mergeProfileFacts,
     renderProfileFacts,
     isNoisyProfileValue,
+    approxTokenCount,
+    contextSizeOfMessages,
+    embedQueryCached,
+    compactToolResult,
+    compactToolHistoryForAgent,
+    compactOperationalStateForAgent,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Tembory node for n8n AI Agents with profile, tools, timeline, graph and semantic memory",
   "license": "MIT",
   "homepage": "https://tembory.com",
@@ -24,7 +24,8 @@
     "lintfix": "tslint --fix -p tsconfig.json -c tslint.json",
     "test": "node --test test/*.test.js",
     "smoke:n8n:multiturn": "node scripts/smoke-n8n-multiturn-tools.js",
-    "prepublishOnly": "npm run build"
+    "simulate:agent-context": "node scripts/simulate-agent-context.js",
+    "prepublishOnly": "npm test"
   },
   "files": [
     "dist",

package/scripts/simulate-agent-context.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+const Module = require('node:module');
+
+const originalLoad = Module._load;
+Module._load = function patchedLoad(request, parent, isMain) {
+  if (request === 'n8n-workflow') {
+    return {
+      NodeConnectionTypes: {
+        AiMemory: 'ai_memory',
+        AiLanguageModel: 'ai_languageModel',
+        AiEmbedding: 'ai_embedding',
+      },
+      NodeApiError: class NodeApiError extends Error {},
+    };
+  }
+  if (request === '@langchain/core/messages') {
+    return {
+      HumanMessage: class HumanMessage { constructor(content) { this.content = content; } _getType() { return 'human'; } },
+      AIMessage: class AIMessage { constructor(content) { this.content = content; } _getType() { return 'ai'; } },
+      SystemMessage: class SystemMessage { constructor(content) { this.content = content; } _getType() { return 'system'; } },
+    };
+  }
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+const core = require('../dist/nodes/Mem0/Mem0Memory.node.js').__private;
+
+const toolHistory = [
+  {
+    id: 'tool_ry3twg',
+    name: 'agenda_consultar_disponibilidade',
+    input: '',
+    ok: true,
+    at: '2026-05-14T05:34:12.460Z',
+    source: 'used_tools_text',
+    result: '[{"args":{"tool":"agenda_consultar_disponibilidade","available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30","timezone":"America/Sao_Paulo","next_step":"escolher_um_horario"}}]',
+  },
+  {
+    id: 'tool_mu9qd2',
+    name: 'agenda_pre_reservar_horario',
+    input: '',
+    ok: true,
+    at: '2026-05-14T05:34:34.017Z',
+    source: 'used_tools_text',
+    result: '[{"args":{"tool":"agenda_pre_reservar_horario","reservation_id":"RES-ELEFAI-LAB-001","selected_from_message":"dia 13","status":"pre_reserved","next_step":"confirmar_agendamento"}}]',
+  },
+];
+
+const vectorMemories = [
+  {
+    memory: '[Used tools: Tool: agenda_pre_reservar_horario, Input: , Result: [{"args":{"tool":"agenda_pre_reservar_horario","reservation_id":"RES-ELEFAI-LAB-001","selected_from_message":"dia 13","status":"pre_reserved","next_step":"confirmar_agendamento"}}]] Calling agenda_pre_reservar_horario with input: {"id":"call_bfHlltcjI1vCagRkav0fj8Ha"}\nPré-reserva feita para o dia 13.\nSe quiser, posso confirmar agora.',
+    created_at: '2026-05-14T05:34:35.373020Z',
+    elefaiScore: { semanticScore: 0.71, recencyScore: 0.99, hybridScore: 0.81, source: 'semantic' },
+  },
+  {
+    memory: '[Used tools: Tool: agenda_consultar_disponibilidade, Input: , Result: [{"args":{"tool":"agenda_consultar_disponibilidade","available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30","timezone":"America/Sao_Paulo","next_step":"escolher_um_horario"}}]] Temos estes horários vagos:\n- 12/05 às 09:00\n- 12/05 às 14:00\n- 13/05 às 10:30',
+    created_at: '2026-05-14T05:34:14.717988Z',
+    elefaiScore: { semanticScore: 0.7, recencyScore: 0.99, hybridScore: 0.8, source: 'semantic' },
+  },
+  { memory: 'Oi! Como posso ajudar?', created_at: '2026-05-14T05:33:47.194630Z' },
+  { memory: 'oi', created_at: '2026-05-14T05:33:47.194355Z' },
+];
+
+const operationalState = core.deriveOperationalState(toolHistory, {}, [], true);
+const workingMemory = {
+  current_goal: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
+  current_task: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
+  last_user_intent: 'affirm',
+  last_user_message: 'ok',
+  next_expected_action: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
+};
+const decisionState = core.deriveDecisionState({ query: 'ok', toolHistory, operationalState, workingMemory });
+const memoryCompression = core.deriveMemoryCompression({ toolHistory, operationalState, vectorMemories });
+const common = {
+  payloadFormat: 'structured',
+  query: 'ok',
+  userId: 'd48292bd4c9f4eccb9120092e3acd073',
+  profileFacts: {},
+  workingMemory,
+  decisionState,
+  memoryCompression,
+  operationalState,
+  actionLedger: core.deriveActionLedger(toolHistory, 20, true),
+  entityTimeline: core.deriveEntityTimeline({}, [], [], toolHistory),
+  vectorMemories,
+  recentMessages: [],
+  toolHistory,
+  highlights: [
+    'tool agenda_consultar_disponibilidade: [{"args":{"available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30"}}]',
+    'tool agenda_pre_reservar_horario: [{"args":{"reservation_id":"RES-ELEFAI-LAB-001","status":"pre_reserved"}}]',
+  ],
+  graph: [],
+  diagnostics: {},
+};
+
+const modes = [
+  ['productionBalanced', core.applyOperationalPreset({ operationPreset: 'productionBalanced' })],
+  ['productionNano', core.applyOperationalPreset({ operationPreset: 'productionNano' })],
+];
+
+for (const [name, adv] of modes) {
+  const messages = core.buildContextMessages({ ...common, adv });
+  const text = messages.map((message) => message.content).join('\n\n');
+  console.log(JSON.stringify({
+    mode: name,
+    size: core.contextSizeOfMessages(messages),
+    has_next_expected_action: /next_expected_action/.test(text),
+    has_do_not_repeat_tools: /do_not_repeat_tools/.test(text),
+    has_reservation_id: /RES-ELEFAI-LAB-001/.test(text),
+    has_available_slots: /available_slots/.test(text),
+    has_duplicate_calling_text: /Calling agenda_pre_reservar_horario/.test(text),
+  }, null, 2));
+}