n8n-nodes-tembory 1.0.0

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

@@ -0,0 +1,2564 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mem0Memory = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+const n8n_workflow_1 = require("n8n-workflow");
+let LangChainMessages = {};
+try {
+    LangChainMessages = require("@langchain/core/messages");
+}
+catch { }
+const MAX_TEXT = 12000;
+const nowIso = () => new Date().toISOString();
+const safeStringify = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const snapshotJson = (value) => {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return value;
+    }
+};
+const truncate = (value, max = MAX_TEXT) => {
+    const text = typeof value === 'string' ? value : safeStringify(value);
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n... [truncated ${text.length - max} chars]`;
+};
+const getConnectedEmbedding = async (ctx, itemIndex) => {
+    try {
+        const embedding = await ctx.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiEmbedding, itemIndex);
+        return embedding && typeof embedding.embedQuery === 'function' ? embedding : null;
+    }
+    catch {
+        return null;
+    }
+};
+const createClientVectorMemory = async (embedding, text, metadata, ids = {}) => ({
+    text: truncate(text, 4000),
+    embedding: await embedding.embedQuery(String(text || '')),
+    user_id: ids.user_id,
+    agent_id: ids.agent_id,
+    run_id: ids.run_id,
+    metadata,
+});
+const saveClientVectorMemories = async (ctx, memories, ids = {}) => {
+    const valid = memories.filter((memory) => String(memory === null || memory === void 0 ? void 0 : memory.text || '').trim());
+    if (!valid.length)
+        return null;
+    return GenericFunctions_1.mem0ApiRequest.call(ctx, 'POST', '/elefai/v1/vector-memories', {
+        memories: valid,
+        user_id: ids.user_id,
+        agent_id: ids.agent_id,
+        run_id: ids.run_id,
+    });
+};
+const searchClientVectorMemories = async (ctx, embedding, query, body = {}) => {
+    const text = String(query || '').trim();
+    if (!text)
+        return { results: [] };
+    return GenericFunctions_1.mem0ApiRequest.call(ctx, 'POST', '/elefai/v1/vector-memories/search', {
+        ...body,
+        query: text,
+        embedding: await embedding.embedQuery(text),
+    });
+};
+const stableStringify = (value) => {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+};
+const hashString = (value) => {
+    const text = String(value || '');
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+};
+const stableHash = (value) => hashString(typeof value === 'string' ? value : stableStringify(value));
+const pickText = (values, preferredKeys) => {
+    for (const key of preferredKeys) {
+        const value = values === null || values === void 0 ? void 0 : values[key];
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    for (const value of Object.values(values || {})) {
+        if (typeof value === 'string' && value.trim())
+            return value;
+    }
+    return '';
+};
+const asSearchQuery = (value) => {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return pickText(value, ['query', 'input', 'chatInput', 'text', 'message', 'consolidated_text', 'lastUserMessage']);
+};
+const memoryText = (memory) => {
+    if (!memory)
+        return '';
+    if (typeof memory === 'string')
+        return memory;
+    return memory.memory || memory.text || memory.value || memory.content || memory.data || safeStringify(memory);
+};
+const normalizeResults = (value) => {
+    if (!value)
+        return [];
+    if (Array.isArray(value))
+        return value;
+    if (Array.isArray(value.results))
+        return value.results;
+    if (Array.isArray(value.memories))
+        return value.memories;
+    if (Array.isArray(value.data))
+        return value.data;
+    return [value];
+};
+const metadataOf = (item) => {
+    const meta = (item === null || item === void 0 ? void 0 : item.metadata) || (item === null || item === void 0 ? void 0 : item.raw) || {};
+    if (meta && typeof meta === 'object' && meta.metadata && typeof meta.metadata === 'object')
+        return meta.metadata;
+    return meta && typeof meta === 'object' ? meta : {};
+};
+const scoreOf = (m) => {
+    var _a, _b, _c, _d;
+    return (_d = (_c = (_b = (_a = m === null || m === void 0 ? void 0 : m.score) !== null && _a !== void 0 ? _a : m === null || m === void 0 ? void 0 : m.similarity) !== null && _b !== void 0 ? _b : m === null || m === void 0 ? void 0 : m.relevance) !== null && _c !== void 0 ? _c : m === null || m === void 0 ? void 0 : m.distance) !== null && _d !== void 0 ? _d : undefined;
+};
+const scoreMetaOf = (m) => (m && typeof m === 'object' && (m.elefaiScore || m._elefaiScore)) || {};
+const withElefaiScore = (m, elefaiScore) => {
+    if (!m || typeof m !== 'object')
+        return m;
+    return { ...m, elefaiScore };
+};
+const normalizeFactValue = (value) => String(value || '').replace(/\*\*/g, '').replace(/\s+/g, ' ').replace(/[.,;:]+$/g, '').trim();
+const profileSourceRank = (source = '') => {
+    if (/^user_message$/i.test(source))
+        return 100;
+    if (/recent_user_message/i.test(source))
+        return 90;
+    if (/recent_message/i.test(source))
+        return 70;
+    if (/vector_memory/i.test(source))
+        return 50;
+    if (/assistant_message/i.test(source))
+        return 10;
+    return 40;
+};
+const isNoisyProfileValue = (value) => {
+    const text = String(value || '').trim();
+    if (!text)
+        return true;
+    if (text.length > 180)
+        return true;
+    if (/(\{|\}|\[|\]|"\w+"\s*:|call_[A-Za-z0-9]|Calling\s+\w+|Used tools|tool=|input:|status|confirmation_id|reservation_id|resultado da ferramenta|returned:|CONF-[A-Z0-9-]+|RES-[A-Z0-9-]+)/i.test(text))
+        return true;
+    if (/\?/.test(text))
+        return true;
+    if (/\b(disponibilidade|hor[aá]rios?\s+dispon[ií]ve(?:is|l)|atualizar\s+os\s+hor[aá]rios|qual foi|o que voc[eê] lembra)\b/i.test(text))
+        return true;
+    if (/\b(confirmad[oa]s?|pre[- ]?reservad[oa]s?|pré[- ]?reservad[oa]s?|c[oó]digo de confirma[cç][aã]o)\b/i.test(text))
+        return true;
+    if (/\b(confirmar|reservar|agendar|marcar|cancelar|alterar)\b/i.test(text) && /\b(agenda|hor[aá]rio|pre[- ]?reserva|pré[- ]?reserva|disponibilidade|\d{1,2}[:h]\d{0,2})\b/i.test(text))
+        return true;
+    if (/\b(?:às|as|das|para)\s+\d{1,2}(?::\d{2}|h\d{0,2})\b/i.test(text))
+        return true;
+    if (/\b\d{1,2}:\d{2}\b/.test(text) || /\b\d{1,2}\/\d{1,2}(?:\/\d{2,4})?\b/.test(text))
+        return true;
+    if (/(tamb[eé]m\s+surg(?:em|iram)|refer[eê]ncias?\s+ao\s+contexto|contexto\s+do\s+agendamento|foi mencionado|h[aá]\s+men[cç][aã]o|o usu[aá]rio demonstrou)/i.test(text))
+        return true;
+    if (/^(agora|atual|pre[- ]?reservado|confirmado|3\.|with input|tamb[eé]m surg(?:iram|em)|pr[oó]ximo passo|(?:a|o|as|os|das|às)\s+\d{1,2}[:h]\d{0,2})$/i.test(text))
+        return true;
+    return false;
+};
+const isPlausibleCompanyValue = (value) => {
+    const text = normalizeFactValue(value);
+    if (isNoisyProfileValue(text))
+        return false;
+    if (/\b(contexto|agendamento|refer[eê]ncias?|interesse|reuni[aã]o|cliente|lead|assunto|hor[aá]rio|disponibilidade)\b/i.test(text))
+        return false;
+    if (text.split(/\s+/).length > 5)
+        return false;
+    return true;
+};
+const isWeakBusinessContextValue = (value) => {
+    const text = normalizeFactValue(value);
+    if (isNoisyProfileValue(text))
+        return true;
+    if (/^(consultation|consulta|agendamento|agenda|call|reuni[aã]o)$/i.test(text))
+        return true;
+    if (/^(?:da|do|de|na|no|pela|pelo)\s+[A-ZÀ-Ú][A-Za-zÀ-ÿ0-9&._ -]{1,60}$/i.test(text))
+        return true;
+    if (text.split(/\s+/).length < 3 && !/\b(CRM|ERP|SaaS|IA|AI)\b/i.test(text))
+        return true;
+    if (/\b(Tembory)\b/i.test(text) && !/\b(CRM|imobili[aá]rio|cliente|premium|agent|memory|lead|vendas|atendimento|autom[aá]?[cç][aã]o)\b/i.test(text))
+        return true;
+    return false;
+};
+const setProfileFact = (facts, key, value, source = 'message', at = nowIso()) => {
+    const normalized = normalizeFactValue(value);
+    if (!normalized || isNoisyProfileValue(normalized))
+        return;
+    const current = facts[key];
+    if (current && !Array.isArray(current) && typeof current === 'object' && current.value !== undefined) {
+        const currentRank = profileSourceRank(current.source);
+        const nextRank = profileSourceRank(source);
+        if (currentRank > nextRank)
+            return;
+        if (currentRank === nextRank && String(current.value || '').toLowerCase() !== normalized.toLowerCase() && current.at && at && String(current.at) > String(at))
+            return;
+    }
+    facts[key] = { value: normalized, source, at };
+};
+const addProfileListFact = (facts, key, value, source = 'message', at = nowIso()) => {
+    const normalized = normalizeFactValue(value);
+    if (!normalized || isNoisyProfileValue(normalized))
+        return;
+    if ((key === 'business_context' || key === 'interests') && isWeakBusinessContextValue(normalized))
+        return;
+    const current = Array.isArray(facts[key]) ? facts[key] : [];
+    if (!current.some((item) => String(item.value || '').toLowerCase() === normalized.toLowerCase()))
+        current.push({ value: normalized, source, at });
+    facts[key] = current.slice(-12);
+};
+const extractProfileFactsFromText = (text, source = 'message', at = nowIso()) => {
+    const facts = {};
+    const content = String(text || '');
+    const sourceName = String(source || '').toLowerCase();
+    const canExtractStrongProfileFacts = sourceName !== 'assistant_message';
+    if (!content.trim())
+        return facts;
+    if (/\[Used tools:|Calling\s+agenda_|"tool"\s*:|"args"\s*:|confirmation_id|reservation_id/i.test(content))
+        return facts;
+    const email = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i.exec(content);
+    if (email && canExtractStrongProfileFacts)
+        setProfileFact(facts, 'email', email[0], source, at);
+    const phone = /(?:telefone|tel|celular|whatsapp|whats)\s*(?:e|é|:)?\s*(\+?\d[\d\s().-]{7,}\d)/i.exec(content) || /(?:^|\s)(\+?55\s*)?(?:\(?\d{2}\)?\s*)?\d{4,5}[-.\s]?\d{4}(?:\s|$)/.exec(content);
+    if (phone && canExtractStrongProfileFacts)
+        setProfileFact(facts, 'phone', (phone[1] || phone[0]).trim(), source, at);
+    const name = /(?:meu nome (?:e|é)|me chamo|sou o|sou a)\s+([A-ZÀ-Ú][A-Za-zÀ-ÿ]+(?:\s+[A-ZÀ-Ú][A-Za-zÀ-ÿ]+){0,3})/i.exec(content);
+    if (name && canExtractStrongProfileFacts)
+        setProfileFact(facts, 'name', name[1], source, at);
+    const company = /(?:sou|trabalho|falo|venho)\s+(?:da|do|na|no|pela|pelo)\s+([A-ZÀ-Ú][A-Za-zÀ-ÿ0-9&._ -]{1,60})/i.exec(content) || /(?:empresa|companhia)\s*(?:e|é|:)?\s*([A-ZÀ-Ú][A-Za-zÀ-ÿ0-9&._ -]{1,60})/i.exec(content);
+    const companyValue = company === null || company === void 0 ? void 0 : company[1].replace(/\s+e\s+(?:meu|minha|telefone|tel|email|e-mail)\b.*$/i, '').trim();
+    if (companyValue && canExtractStrongProfileFacts && isPlausibleCompanyValue(companyValue))
+        setProfileFact(facts, 'company', companyValue, source, at);
+    const role = /(?:sou|cargo|funcao|função|atuo como)\s+(?:o|a|um|uma)?\s*([A-Za-zÀ-ÿ ]{3,60})\s+(?:da|do|na|no|em)\s+/i.exec(content);
+    if (role && canExtractStrongProfileFacts)
+        setProfileFact(facts, 'role', role[1], source, at);
+    const timePref = /(?:prefiro|prefer[eê]ncia|gosto de)\s+(?:atendimento|hor[aá]rio|agenda)?\s*(?:no|na|de|por|para|:)?\s*(per[ií]odo da tarde|tarde|manh[aã]|noite|hor[aá]rio comercial|fim de semana)/i.exec(content);
+    if (timePref)
+        addProfileListFact(facts, 'preferences', `atendimento/horario: ${timePref[1]}`, source, at);
+    const stylePref = /(?:prefiro|prefer[eê]ncia|respostas?)\s+(.{0,80}?(?:curtas?|objetivas?|portugu[eê]s|detalhadas?|diretas?))/i.exec(content);
+    if (stylePref)
+        addProfileListFact(facts, 'preferences', `estilo: ${stylePref[1]}`, source, at);
+    const meeting = /(?:reuni[aã]o|agendamento|agenda|call)\s+(?:e|é|para|sobre|de|com)?\s*(.{4,140})/i.exec(content);
+    if (meeting) {
+        const meetingValue = meeting[1].replace(/^(?:sobre|de)\s+/i, '').replace(/^(?:uma\s+)?reuni[aã]o\s+sobre\s+/i, '').trim();
+        addProfileListFact(facts, 'business_context', meetingValue, source, at);
+    }
+    const interest = /(?:interesse|interessado|preciso|quero|busco)\s+(?:em|de|por)?\s*(.{4,120})/i.exec(content);
+    if (interest)
+        addProfileListFact(facts, 'interests', interest[1], source, at);
+    return facts;
+};
+const mergeProfileFacts = (...factSets) => {
+    const merged = {};
+    for (const facts of factSets || []) {
+        if (!facts || typeof facts !== 'object')
+            continue;
+        for (const [key, value] of Object.entries(facts)) {
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    addProfileListFact(merged, key, item.value || item, item.source || 'merged', item.at || nowIso());
+            }
+            else if (value && typeof value === 'object' && value.value !== undefined) {
+                setProfileFact(merged, key, value.value, value.source || 'merged', value.at || nowIso());
+            }
+            else {
+                setProfileFact(merged, key, value, 'merged', nowIso());
+            }
+        }
+    }
+    return merged;
+};
+const profileFactsFromMessages = (messages = [], source = 'recent_message') => messages.reduce((facts, msg) => {
+    const role = String(msg.role || '').toLowerCase();
+    if (role && role !== 'user' && role !== 'human')
+        return facts;
+    const factSource = source === 'recent_message' ? 'recent_user_message' : source;
+    return mergeProfileFacts(facts, extractProfileFactsFromText(msg.content || msg.memory || msg.text || '', factSource, msg.at || msg.created_at || msg.createdAt || nowIso()));
+}, {});
+const isOperationalProfileMemory = (memory) => {
+    const text = memoryText(memory);
+    const meta = metadataOf(memory);
+    const kind = String(meta.kind || meta.type || meta.source || '');
+    return text.startsWith(RECENT_MESSAGE_MARKER) || text.startsWith(TOOL_HISTORY_MARKER) || /tool_history|tool_facts|recent_message/i.test(kind);
+};
+const profileFactsFromMemories = (memories = []) => memories.reduce((facts, memory) => {
+    if (isOperationalProfileMemory(memory))
+        return facts;
+    return mergeProfileFacts(facts, extractProfileFactsFromText(memoryText(memory), 'vector_memory', memory.created_at || memory.createdAt || nowIso()));
+}, {});
+const renderProfileFacts = (facts = {}) => {
+    const out = {};
+    for (const [key, value] of Object.entries(facts || {})) {
+        if (Array.isArray(value))
+            out[key] = value.map((item) => item.value || item).filter(Boolean);
+        else if (value && typeof value === 'object')
+            out[key] = value.value;
+        else
+            out[key] = value;
+    }
+    return out;
+};
+const safeParseToolPayload = (value) => {
+    if (value === undefined || value === null)
+        return value;
+    if (typeof value !== 'string')
+        return value;
+    const text = value.trim();
+    if (!text)
+        return '';
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+const compactToolPayload = (value) => truncate(typeof value === 'string' ? value : safeStringify(value), 900);
+const maybeToolResult = (tool, includeResults = true) => includeResults === false ? undefined : compactToolPayload(safeParseToolPayload(tool === null || tool === void 0 ? void 0 : tool.result));
+const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessages = [], includeResults = true) => {
+    const tools = Array.isArray(toolHistory) ? toolHistory : [];
+    const successfulTools = tools.filter((tool) => tool.ok !== false);
+    const byName = (name) => successfulTools.filter((tool) => tool.name === name);
+    const availability = byName('agenda_consultar_disponibilidade');
+    const reservations = byName('agenda_pre_reservar_horario');
+    const confirmations = byName('agenda_confirmar_agendamento');
+    const lastTool = tools[tools.length - 1] || null;
+    const lastReservation = reservations[reservations.length - 1] || null;
+    const lastConfirmation = confirmations[confirmations.length - 1] || null;
+    const hasPendingReservation = Boolean(lastReservation && (!lastConfirmation || String(lastReservation.at || '') > String(lastConfirmation.at || '')));
+    const blockedWithoutContext = [];
+    if (!availability.length)
+        blockedWithoutContext.push('agenda_pre_reservar_horario');
+    if (!reservations.length)
+        blockedWithoutContext.push('agenda_confirmar_agendamento');
+    const guidance = [];
+    if (!availability.length)
+        guidance.push('No availability result is known for this session; consult availability before reserving or confirming.');
+    else if (hasPendingReservation)
+        guidance.push('A pre-reservation exists after the latest confirmation; confirmation can use the latest pre-reservation context.');
+    else if (lastConfirmation)
+        guidance.push('The latest reservation appears confirmed; do not confirm again unless the user explicitly asks to repeat or change it.');
+    else if (availability.length)
+        guidance.push('Availability is known; if the user chooses one listed slot, reserve without repeating availability.');
+    return {
+        profile_complete: Boolean(profileFacts && profileFacts.name && profileFacts.company && profileFacts.email && profileFacts.phone),
+        last_tool: lastTool ? { name: lastTool.name, ok: lastTool.ok, at: lastTool.at } : null,
+        tool_counts: {
+            total: tools.length,
+            ok: successfulTools.length,
+            failed: tools.length - successfulTools.length,
+            agenda_consultar_disponibilidade: availability.length,
+            agenda_pre_reservar_horario: reservations.length,
+            agenda_confirmar_agendamento: confirmations.length,
+        },
+        agenda_state: {
+            has_availability: availability.length > 0,
+            has_pre_reservation: reservations.length > 0,
+            has_confirmation: confirmations.length > 0,
+            has_pending_pre_reservation: hasPendingReservation,
+            latest_availability_result: availability.length ? maybeToolResult(availability[availability.length - 1], includeResults) : null,
+            latest_pre_reservation_result: lastReservation ? maybeToolResult(lastReservation, includeResults) : null,
+            latest_confirmation_result: lastConfirmation ? maybeToolResult(lastConfirmation, includeResults) : null,
+        },
+        blocked_without_context: Array.from(new Set(blockedWithoutContext)),
+        guidance,
+        recent_message_count: Array.isArray(recentMessages) ? recentMessages.length : 0,
+    };
+};
+const deriveActionLedger = (toolHistory = [], maxItems = 20, includeResults = true) => {
+    const tools = sortToolHistory(Array.isArray(toolHistory) ? toolHistory : []);
+    return pruneByLimit(tools.map((tool, index) => ({
+        sequence: tool.sequence || index + 1,
+        action_id: tool.id || `${tool.name || 'tool'}-${index + 1}`,
+        kind: 'tool_call',
+        name: tool.name || 'unknown_tool',
+        status: tool.ok === false ? 'failed' : 'ok',
+        input: compactToolPayload(safeParseToolPayload(tool.input)),
+        result: maybeToolResult(tool, includeResults),
+        at: tool.at || null,
+        source: tool.source || 'unknown',
+    })), maxItems || 20);
+};
+const deriveEntityTimeline = (profileFacts = {}, graph = [], recentMessages = [], toolHistory = [], maxItems = 24) => {
+    const events = [];
+    const push = (entity, kind, value, meta = {}) => {
+        const normalizedEntity = normalizeFactValue(entity);
+        const normalizedValue = normalizeFactValue(value);
+        if (!normalizedEntity || !normalizedValue || isNoisyProfileValue(normalizedValue))
+            return;
+        if ((normalizedEntity === 'business_context' || normalizedEntity === 'interests') && isWeakBusinessContextValue(normalizedValue))
+            return;
+        events.push({
+            entity: normalizedEntity,
+            kind,
+            value: normalizedValue,
+            at: meta.at || null,
+            source: meta.source || 'derived',
+        });
+    };
+    for (const [key, value] of Object.entries(profileFacts || {})) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                push(key, 'profile_fact', item.value || item, { at: item.at, source: item.source || 'profile_fact' });
+        }
+        else if (value && typeof value === 'object' && value.value !== undefined) {
+            push(key, 'profile_fact', value.value, { at: value.at, source: value.source || 'profile_fact' });
+        }
+        else if (value !== undefined && value !== null) {
+            push(key, 'profile_fact', value, { source: 'profile_fact' });
+        }
+    }
+    for (const relation of graph || []) {
+        if (!relation || typeof relation !== 'object')
+            continue;
+        const from = relation.source || relation.from || relation.subject || relation.entity || relation.node || relation.name;
+        const to = relation.target || relation.to || relation.object || relation.related || relation.value;
+        const label = relation.relation || relation.relationship || relation.type || relation.label || 'related_to';
+        if (from && to)
+            push(from, `graph:${label}`, to, { at: relation.at || relation.created_at || relation.createdAt, source: 'graph' });
+    }
+    for (const msg of recentMessages || []) {
+        const role = String(msg.role || '').toLowerCase();
+        if (role && role !== 'user' && role !== 'human')
+            continue;
+        const facts = extractProfileFactsFromText(msg.content || msg.memory || msg.text || '', 'recent_user_message', msg.at || msg.created_at || msg.createdAt || nowIso());
+        for (const [key, value] of Object.entries(facts)) {
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    push(key, 'recent_fact', item.value || item, { at: item.at || msg.at, source: item.source || 'recent_message' });
+            }
+            else if (value && typeof value === 'object' && value.value !== undefined) {
+                push(key, 'recent_fact', value.value, { at: value.at || msg.at, source: value.source || 'recent_message' });
+            }
+        }
+    }
+    for (const tool of toolHistory || []) {
+        if (tool.name)
+            push(tool.name, 'tool_event', tool.ok === false ? 'failed' : 'called', { at: tool.at, source: tool.source || 'tool_history' });
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const event of events) {
+        const key = `${event.entity.toLowerCase()}|${event.kind.toLowerCase()}|${event.value.toLowerCase()}|${event.at || ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(event);
+    }
+    return pruneByLimit(deduped.sort((a, b) => String(a.at || '').localeCompare(String(b.at || ''))), maxItems || 24);
+};
+const RECENT_MESSAGE_MARKER = '__elefai_recent_message_v1__';
+const TOOL_HISTORY_MARKER = '__elefai_tool_history_v1__';
+const encodeRecentMessage = (recent, threadId) => `${RECENT_MESSAGE_MARKER}${safeStringify({
+    role: recent.role || 'user',
+    content: recent.content || '',
+    at: recent.at || nowIso(),
+    thread_id: threadId,
+})}`;
+const encodeToolCall = (tool, threadId) => `${TOOL_HISTORY_MARKER}${safeStringify({
+    id: tool.id || tool.callId || '',
+    turn_id: tool.turnId || '',
+    sequence: tool.sequence || 0,
+    name: tool.name || '',
+    input: tool.input || '',
+    ok: tool.ok !== false,
+    result: tool.result || '',
+    at: tool.at || nowIso(),
+    source: tool.source || 'n8n',
+    thread_id: threadId,
+})}`;
+const parseRecentMessageMarker = (text) => {
+    if (!text || typeof text !== 'string' || !text.startsWith(RECENT_MESSAGE_MARKER))
+        return null;
+    try {
+        const parsed = JSON.parse(text.slice(RECENT_MESSAGE_MARKER.length));
+        if (!parsed || !parsed.content)
+            return null;
+        return {
+            role: parsed.role || 'user',
+            content: truncate(parsed.content, 2000),
+            at: parsed.at || nowIso(),
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const parseToolHistoryMarker = (text) => {
+    if (!text || typeof text !== 'string' || !text.startsWith(TOOL_HISTORY_MARKER))
+        return null;
+    try {
+        const parsed = JSON.parse(text.slice(TOOL_HISTORY_MARKER.length));
+        if (!parsed || !parsed.name)
+            return null;
+        return {
+            id: parsed.id || parsed.call_id || parsed.callId || '',
+            turnId: parsed.turn_id || parsed.turnId || '',
+            sequence: parsed.sequence || 0,
+            name: String(parsed.name),
+            input: parsed.input === undefined ? '' : String(parsed.input),
+            ok: parsed.ok !== false,
+            result: truncate(parsed.result || '', 1000),
+            at: parsed.at || nowIso(),
+            source: parsed.source || 'mem0_marker',
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const recentMessageFromMemory = (item) => {
+    const meta = metadataOf(item);
+    const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const marked = parseRecentMessageMarker(content);
+    if (marked)
+        return marked;
+    if (meta.kind !== 'recent_message')
+        return null;
+    if (!content)
+        return null;
+    return {
+        role: meta.role || 'user',
+        content: truncate(content, 2000),
+        at: meta.at || item.created_at || item.createdAt || nowIso(),
+    };
+};
+const toolHistoryFromMemory = (item) => {
+    const meta = metadataOf(item);
+    const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const marked = parseToolHistoryMarker(content);
+    if (marked)
+        return marked;
+    if (meta.kind === 'recent_message') {
+        const toolBlock = extractToolCallsFromText(content, meta.at || item.created_at || item.createdAt || nowIso())[0];
+        if (toolBlock)
+            return toolBlock;
+    }
+    if (meta.kind !== 'tool_history' && meta.kind !== 'tool_facts')
+        return null;
+    const factMatch = /(?:^|\b)Tool\s+([A-Za-z0-9_.:-]+)\s+input=([\s\S]*?)(?:\s+result=([\s\S]*))?$/i.exec(String(content || ''));
+    if (factMatch) {
+        return {
+            id: meta.id || meta.call_id || meta.callId || '',
+            turnId: meta.turn_id || meta.turnId || '',
+            name: factMatch[1],
+            input: truncate((factMatch[2] || '').trim(), 1000),
+            ok: true,
+            result: truncate((factMatch[3] || '').trim(), 1000),
+            at: meta.at || item.created_at || item.createdAt || nowIso(),
+            source: 'semantic_fact',
+        };
+    }
+    const namedTool = meta.kind === 'tool_history' ? /(?:tool|ferramenta)\s+([A-Za-z0-9_.:-]*(?:agenda_[A-Za-z0-9_.:-]+)[A-Za-z0-9_.:-]*)/i.exec(String(content || '')) : null;
+    if (namedTool) {
+        return {
+            id: meta.id || meta.call_id || meta.callId || '',
+            turnId: meta.turn_id || meta.turnId || '',
+            name: namedTool[1],
+            input: '',
+            ok: true,
+            result: truncate(content || '', 1000),
+            at: meta.at || item.created_at || item.createdAt || nowIso(),
+            source: 'semantic_named_tool',
+        };
+    }
+    const text = meta.kind === 'tool_history' ? String(content || '').toLowerCase() : '';
+    const inferredAgendaTool = text.includes('confirm') && text.includes('agendamento')
+        ? 'agenda_confirmar_agendamento'
+        : text.includes('pré-reserva') || text.includes('pre-reserva') || text.includes('pre reserva') || text.includes('pré reserva')
+            ? 'agenda_pre_reservar_horario'
+            : (text.includes('horários disponíveis') || text.includes('horarios disponiveis') || text.includes('available') || text.includes('disponibilidade')) && text.includes('agenda')
+                ? 'agenda_consultar_disponibilidade'
+                : '';
+    if (inferredAgendaTool) {
+        return {
+            id: meta.id || meta.call_id || meta.callId || '',
+            turnId: meta.turn_id || meta.turnId || '',
+            name: inferredAgendaTool,
+            input: '',
+            ok: true,
+            result: truncate(content || '', 1000),
+            at: meta.at || item.created_at || item.createdAt || nowIso(),
+            source: 'semantic_inference',
+        };
+    }
+    if (meta.kind !== 'tool_history')
+        return null;
+    const name = meta.name || meta.tool || meta.toolName;
+    if (!name)
+        return null;
+    return {
+        id: meta.id || meta.call_id || meta.callId || '',
+        turnId: meta.turn_id || meta.turnId || '',
+        name: String(name),
+        input: meta.input === undefined ? '' : String(meta.input),
+        ok: meta.ok !== false,
+        result: truncate(meta.result || content || '', 1000),
+        at: meta.at || item.created_at || item.createdAt || nowIso(),
+        source: meta.source || 'metadata',
+    };
+};
+const toolHistoryItemsFromMemory = (item) => {
+    const meta = metadataOf(item);
+    const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const marked = parseToolHistoryMarker(content);
+    if (marked)
+        return [marked];
+    if (meta.kind === 'recent_message') {
+        const textCalls = extractToolCallsFromText(content, meta.at || item.created_at || item.createdAt || nowIso());
+        if (textCalls.length)
+            return textCalls;
+    }
+    const single = toolHistoryFromMemory(item);
+    return single ? [single] : [];
+};
+const toBaseMessage = (message) => {
+    const role = String((message === null || message === void 0 ? void 0 : message.role) || 'system').toLowerCase();
+    const content = typeof message === 'string' ? message : String((message === null || message === void 0 ? void 0 : message.content) || '');
+    const MessageClass = role === 'human' || role === 'user'
+        ? LangChainMessages.HumanMessage
+        : role === 'ai' || role === 'assistant'
+            ? LangChainMessages.AIMessage
+            : LangChainMessages.SystemMessage;
+    if (MessageClass)
+        return new MessageClass(content);
+    return {
+        content,
+        role,
+        _getType: () => role === 'user' ? 'human' : role === 'assistant' ? 'ai' : role,
+        toJSON: () => ({ type: role, data: { content } }),
+    };
+};
+const summarizeToolResult = (value, max = 600) => {
+    if (value === undefined || value === null)
+        return '';
+    const text = typeof value === 'string' ? value : safeStringify(value);
+    const title = /<title[^>]*>([^<]+)<\/title>/i.exec(text);
+    if (/^\s*</.test(text))
+        return truncate(`html(len=${text.length}${title ? `, title="${title[1].trim()}"` : ''})`, max);
+    return truncate(text, max);
+};
+const makeToolEventId = (tool, sequence = 0) => {
+    const base = `${tool.at || ''}|${sequence}|${tool.name || ''}|${tool.input || ''}|${tool.result || ''}`;
+    return `tool_${hashString(base)}`;
+};
+const canonicalToolInput = (value) => {
+    const text = String(value === undefined || value === null ? '' : value).trim();
+    if (text === '""' || text === "''")
+        return '';
+    return text;
+};
+const normalizeToolCall = (tool, sequence = 0, defaults = {}) => {
+    const at = tool.at || defaults.at || nowIso();
+    const input = canonicalToolInput(tool.input);
+    const result = summarizeToolResult(tool.result || tool.output || tool.observation || '');
+    const normalized = {
+        id: tool.id || tool.callId || tool.call_id || '',
+        call_id: tool.id || tool.callId || tool.call_id || '',
+        turnId: tool.turnId || tool.turn_id || defaults.turnId || '',
+        turn_id: tool.turnId || tool.turn_id || defaults.turnId || '',
+        sequence: Number(tool.sequence || defaults.sequence || sequence || 0),
+        name: String(tool.name || tool.tool || tool.toolName || ''),
+        tool_name: String(tool.name || tool.tool || tool.toolName || ''),
+        input,
+        tool_args: input,
+        normalized_args: input,
+        ok: tool.ok !== false,
+        result,
+        result_summary: result,
+        at,
+        timestamp: at,
+        source: tool.source || defaults.source || 'n8n',
+        status: tool.ok === false ? 'failed' : 'ok',
+    };
+    if (!normalized.id)
+        normalized.id = makeToolEventId(normalized, normalized.sequence);
+    if (!normalized.call_id)
+        normalized.call_id = normalized.id;
+    normalized.result_hash = stableHash(normalized.result || '');
+    normalized.args_hash = stableHash(normalized.normalized_args || '');
+    normalized.dedupe_key = toolEventKey(normalized);
+    return normalized;
+};
+const toolEventKey = (tool) => {
+    const generatedId = String(tool.id || '').startsWith('tool_');
+    if (tool.id && !generatedId)
+        return String(tool.id);
+    const atMs = new Date(tool.at || 0).getTime();
+    const timeBucket = Number.isFinite(atMs) && atMs > 0 ? Math.floor(atMs / 2000) : '';
+    return `${timeBucket}:${tool.name || ''}:${hashString(canonicalToolInput(tool.input))}:${hashString(tool.result || '')}`;
+};
+const readDeep = (value, visitor, seen = new Set()) => {
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    visitor(value);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            readDeep(item, visitor, seen);
+        return;
+    }
+    for (const item of Object.values(value))
+        readDeep(item, visitor, seen);
+};
+const extractToolCallsFromText = (text, at = nowIso()) => {
+    const calls = [];
+    const source = String(text || '');
+    const toolBlock = /\[Used tools:\s*([\s\S]*)\]/i.exec(source);
+    if (!toolBlock)
+        return calls;
+    const segments = toolBlock[1].split(/;\s*(?=Tool:)/i);
+    for (const segment of segments) {
+        const match = /Tool:\s*([^,\n]+)\s*,\s*Input:\s*([\s\S]*?)\s*,\s*Result:\s*([\s\S]*)$/i.exec(segment.trim());
+        if (!match)
+            continue;
+        const name = match[1].trim();
+        if (!name)
+            continue;
+        calls.push(normalizeToolCall({
+            name,
+            input: match[2].trim(),
+            ok: true,
+            result: summarizeToolResult(match[3].trim()),
+            at,
+            source: 'used_tools_text',
+        }, calls.length + 1));
+    }
+    return calls;
+};
+const extractToolCalls = (outputValues = {}) => {
+    const calls = [];
+    const at = nowIso();
+    const push = (name, input, result, ok = true, meta = {}) => {
+        if (!name)
+            return;
+        calls.push(normalizeToolCall({
+            id: meta.id || meta.callId || meta.call_id,
+            turnId: meta.turnId || meta.turn_id,
+            sequence: meta.sequence || calls.length + 1,
+            name: String(name),
+            input: input === undefined ? '' : (typeof input === 'string' ? input : stableStringify(input)),
+            ok,
+            result: summarizeToolResult(result),
+            at,
+            source: meta.source || 'intermediate_steps',
+        }, calls.length + 1, { at }));
+    };
+    readDeep(outputValues, (obj) => {
+        const name = obj.tool || obj.toolName || obj.name;
+        const hasInput = obj.toolInput !== undefined || obj.input !== undefined || obj.args !== undefined;
+        const hasResult = obj.observation !== undefined || obj.result !== undefined || obj.output !== undefined || obj.error !== undefined;
+        const hasExplicitId = obj.toolCallId || obj.tool_call_id || obj.callId || obj.call_id || obj.id;
+        if (name && hasInput && (hasResult || hasExplicitId)) {
+            push(name, obj.toolInput !== undefined ? obj.toolInput : obj.input !== undefined ? obj.input : obj.args, obj.observation || obj.result || obj.output, obj.error ? false : true, {
+                id: obj.toolCallId || obj.tool_call_id || obj.callId || obj.call_id || obj.id,
+                turnId: obj.turnId || obj.turn_id,
+                sequence: obj.sequence,
+                source: 'tool_object',
+            });
+        }
+        if (Array.isArray(obj.intermediateSteps)) {
+            for (let index = 0; index < obj.intermediateSteps.length; index++) {
+                const step = obj.intermediateSteps[index];
+                if (Array.isArray(step) && step.length >= 1) {
+                    const action = step[0] || {};
+                    push(action.tool || action.name, action.toolInput || action.input || action.args, step[1], true, {
+                        id: action.toolCallId || action.tool_call_id || action.callId || action.call_id || action.id,
+                        turnId: action.turnId || action.turn_id,
+                        sequence: index + 1,
+                    });
+                }
+                else if (step && typeof step === 'object') {
+                    const action = step.action || step;
+                    push(action.tool || action.name, action.toolInput || action.input || action.args, step.observation || step.result || step.output, step.error ? false : true, {
+                        id: action.toolCallId || action.tool_call_id || action.callId || action.call_id || action.id || step.toolCallId || step.tool_call_id || step.callId || step.call_id || step.id,
+                        turnId: action.turnId || action.turn_id || step.turnId || step.turn_id,
+                        sequence: index + 1,
+                    });
+                }
+            }
+        }
+    });
+    const text = `${pickText(outputValues, ['output', 'response', 'text', 'answer'])}`;
+    for (const tool of extractToolCallsFromText(text))
+        push(tool.name, tool.input, tool.result, tool.ok, { id: tool.id, sequence: tool.sequence, source: tool.source });
+    const byKey = new Map();
+    for (const call of calls) {
+        const key = toolEventKey(call);
+        const prev = byKey.get(key);
+        if (!prev || (call.result || '').length > (prev.result || '').length)
+            byKey.set(key, call);
+    }
+    return Array.from(byKey.values());
+};
+const getMemoryStore = (ctx) => {
+    try {
+        const data = ctx.getWorkflowStaticData('global');
+        data.elefaiBrain = data.elefaiBrain || {};
+        data.elefaiBrain.toolHistory = data.elefaiBrain.toolHistory || {};
+        data.elefaiBrain.recentMessages = data.elefaiBrain.recentMessages || {};
+        data.elefaiBrain.profileFacts = data.elefaiBrain.profileFacts || {};
+        data.elefaiBrain.workingMemory = data.elefaiBrain.workingMemory || {};
+        data.elefaiBrain.decisionState = data.elefaiBrain.decisionState || {};
+        data.elefaiBrain.memoryCompression = data.elefaiBrain.memoryCompression || {};
+        return data.elefaiBrain;
+    }
+    catch {
+        global.__elefaiBrainMemory = global.__elefaiBrainMemory || { toolHistory: {}, recentMessages: {}, profileFacts: {}, workingMemory: {}, decisionState: {}, memoryCompression: {} };
+        global.__elefaiBrainMemory.workingMemory = global.__elefaiBrainMemory.workingMemory || {};
+        global.__elefaiBrainMemory.decisionState = global.__elefaiBrainMemory.decisionState || {};
+        global.__elefaiBrainMemory.memoryCompression = global.__elefaiBrainMemory.memoryCompression || {};
+        return global.__elefaiBrainMemory;
+    }
+};
+const namespacePart = (value) => String(value || '').trim().replace(/\s+/g, '_').replace(/[:|]+/g, '-');
+const userKeyFrom = (threadId, adv, project = '') => {
+    const base = namespacePart((adv === null || adv === void 0 ? void 0 : adv.userId) || threadId || 'default');
+    const namespace = namespacePart(project || (adv === null || adv === void 0 ? void 0 : adv.project) || (adv === null || adv === void 0 ? void 0 : adv.projectId));
+    return namespace ? `${namespace}::${base}` : base;
+};
+const applyOperationalPreset = (advanced = {}) => {
+    const preset = String(advanced.operationPreset || 'custom');
+    const presets = {
+        diagnostic: {
+            includeContextHeader: true,
+            includeSummary: true,
+            includeScores: true,
+            includeDiagnostics: true,
+            includeRelations: true,
+            includeToolHistory: true,
+            includeToolResults: true,
+            persistToolFactsToMem0: true,
+            includeToolHistorySemanticFallback: true,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: true,
+            includeEntityTimeline: true,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: true,
+            includeRecentHighlights: true,
+            topK: 8,
+            lastN: 12,
+            toolHistoryLastN: 15,
+            recentMessagesLastN: 8,
+        },
+        productionBalanced: {
+            includeContextHeader: true,
+            includeSummary: true,
+            includeScores: false,
+            includeDiagnostics: false,
+            includeRelations: true,
+            includeToolHistory: true,
+            includeToolResults: true,
+            persistToolFactsToMem0: false,
+            includeToolHistorySemanticFallback: false,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: true,
+            includeEntityTimeline: true,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: true,
+            includeRecentHighlights: true,
+            topK: 6,
+            lastN: 8,
+            toolHistoryLastN: 10,
+            recentMessagesLastN: 6,
+        },
+        productionCheap: {
+            includeContextHeader: true,
+            includeSummary: false,
+            includeScores: false,
+            includeDiagnostics: false,
+            includeRelations: false,
+            includeToolHistory: true,
+            includeToolResults: false,
+            persistToolFactsToMem0: false,
+            includeToolHistorySemanticFallback: false,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: true,
+            includeEntityTimeline: false,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: true,
+            includeRecentHighlights: false,
+            topK: 4,
+            lastN: 4,
+            toolHistoryLastN: 5,
+            recentMessagesLastN: 4,
+        },
+        audit: {
+            includeContextHeader: true,
+            includeSummary: true,
+            includeScores: true,
+            includeDiagnostics: true,
+            includeRelations: true,
+            includeToolHistory: true,
+            includeToolResults: true,
+            persistToolFactsToMem0: true,
+            includeToolHistorySemanticFallback: true,
+            includeProfileFacts: true,
+            includeOperationalState: true,
+            includeActionLedger: true,
+            includeEntityTimeline: true,
+            includeWorkingMemory: true,
+            includeDecisionState: true,
+            includeMemoryCompression: true,
+            includeRecentMessages: true,
+            includeRecentHighlights: true,
+            topK: 10,
+            lastN: 20,
+            toolHistoryLastN: 20,
+            recentMessagesLastN: 12,
+            payloadFormat: 'auditJson',
+        },
+    };
+    return { ...(presets[preset === 'lab' ? 'diagnostic' : preset] || {}), ...advanced };
+};
+const pruneByLimit = (items, limit) => items.slice(Math.max(0, items.length - Math.max(1, Number(limit) || 1)));
+const dedupeRecentMessages = (items) => {
+    const seen = new Set();
+    const out = [];
+    for (const item of items || []) {
+        const key = `${item.role}:${item.at}:${item.content}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out;
+};
+const dedupeToolHistory = (items) => {
+    const seen = new Set();
+    const out = [];
+    for (const item of [...(items || [])].reverse()) {
+        const key = toolEventKey(item);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(item);
+    }
+    return out.reverse();
+};
+const sortToolHistory = (items) => [...(items || [])].sort((a, b) => {
+    const atA = new Date(a.at || 0).getTime();
+    const atB = new Date(b.at || 0).getTime();
+    if (atA !== atB)
+        return atA - atB;
+    return Number(a.sequence || 0) - Number(b.sequence || 0);
+});
+const applyToolHistoryWindow = (items, ttlSeconds, limit) => {
+    const ttl = Number(ttlSeconds || 0);
+    const filtered = ttl > 0
+        ? (items || []).filter((tool) => !tool.at || ((Date.now() - new Date(tool.at).getTime()) / 1000) <= ttl)
+        : (items || []);
+    return pruneByLimit(sortToolHistory(dedupeToolHistory(filtered)), limit || 15);
+};
+const getRecentHighlights = (recentMessages, tools, maxItems = 6) => {
+    const lines = [];
+    for (const msg of recentMessages || []) {
+        const text = String(msg.content || '');
+        const match = /(meu nome e|me chamo|sou|email|telefone|prefiro|gosto de|quero|preciso|empresa|cliente|cpf|cnpj)\s+(.{2,120})/i.exec(text);
+        if (match)
+            lines.push(`${msg.role}: ${truncate(text, 180)}`);
+    }
+    for (const tool of tools || []) {
+        if (tool.result)
+            lines.push(`tool ${tool.name}: ${truncate(tool.result, 180)}`);
+    }
+    return pruneByLimit(Array.from(new Set(lines)), maxItems);
+};
+const inferToolGuard = ({ query, recentMessages, toolHistory, vectorMemories }) => {
+    const text = String(query || '').toLowerCase();
+    const names = new Set((toolHistory || []).map((tool) => String(tool.name || '')));
+    const hasRecentContext = (recentMessages || []).some((msg) => /reserva|pré-reserva|pre-reserva|agend|confirm|hor[aá]rio|dispon/i.test(String(msg.content || '')));
+    const hasVectorContext = (vectorMemories || []).some((memory) => /reserva|pré-reserva|pre-reserva|agend|confirm|hor[aá]rio|dispon/i.test(memoryText(memory)));
+    const hasAnyContext = names.size > 0 || hasRecentContext || hasVectorContext;
+    const blocked = [];
+    const reasons = [];
+    if (!hasAnyContext) {
+        blocked.push('agenda_pre_reservar_horario', 'agenda_confirmar_agendamento');
+        reasons.push('no prior availability or pre-reservation context was found for this session');
+    }
+    if ((/confirm|confirma|confirmar/.test(text)) && !names.has('agenda_pre_reservar_horario') && !hasRecentContext) {
+        blocked.push('agenda_confirmar_agendamento');
+        reasons.push('confirmation requested but no prior pre-reservation was found in tool_history or recent_messages');
+    }
+    if ((/pre.?reserv|pré.?reserv|reservar/.test(text)) && !names.has('agenda_consultar_disponibilidade') && !hasRecentContext) {
+        blocked.push('agenda_pre_reservar_horario');
+        reasons.push('reservation requested but no prior availability result was found in tool_history or recent_messages');
+    }
+    return { blockedTools: Array.from(new Set(blocked)), reasons };
+};
+const inferUserIntent = (query = '', recentMessages = []) => {
+    const latestUser = [...(recentMessages || [])].reverse().find((msg) => /^(user|human)$/i.test(String(msg.role || '')));
+    const text = `${query || ''}\n${latestUser?.content || ''}`.toLowerCase();
+    if (/\b(confirm|confirma|confirmar|fechar|pode confirmar)\b/.test(text))
+        return 'confirm';
+    if (/\b(pre.?reserv|pré.?reserv|reservar|segurar|marcar)\b/.test(text))
+        return 'pre_reserve';
+    if (/\b(disponibilidade|hor[aá]rios?|agenda|quando pode|tem vaga)\b/.test(text))
+        return 'check_availability';
+    if (/\b(cancel|desmarcar|remarcar|alterar|mudar)\b/.test(text))
+        return 'change_or_cancel';
+    if (/\b(meu nome|email|telefone|empresa|prefiro|prefer[eê]ncia)\b/.test(text))
+        return 'profile_update';
+    if (text.trim())
+        return 'general_message';
+    return 'unknown';
+};
+const deriveNextExpectedAction = (intent, operationalState = {}) => {
+    const agenda = operationalState.agenda_state || {};
+    if (intent === 'confirm') {
+        if (agenda.has_pending_pre_reservation)
+            return 'call agenda_confirmar_agendamento using the latest pre-reservation context';
+        return 'ask for or create a pre-reservation before confirming';
+    }
+    if (intent === 'pre_reserve') {
+        if (agenda.has_availability)
+            return 'call agenda_pre_reservar_horario using one of the known available slots';
+        return 'call agenda_consultar_disponibilidade before pre-reserving';
+    }
+    if (intent === 'check_availability')
+        return agenda.has_availability ? 'reuse known availability unless the user asks to refresh' : 'call agenda_consultar_disponibilidade';
+    if (intent === 'change_or_cancel')
+        return 'inspect current reservation state before changing or cancelling';
+    if (intent === 'profile_update')
+        return 'save stable profile facts and continue the conversation';
+    return 'answer using retrieved context and avoid unnecessary tool calls';
+};
+const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [], toolHistory = [], operationalState = {}, previous = {} }) => {
+    const intent = inferUserIntent(query, recentMessages);
+    const lastUser = [...(recentMessages || [])].reverse().find((msg) => /^(user|human)$/i.test(String(msg.role || '')));
+    const activeEntities = [];
+    for (const key of ['name', 'company', 'email', 'phone']) {
+        if (profileFacts && profileFacts[key])
+            activeEntities.push({ type: key, value: profileFacts[key] });
+    }
+    const lastTool = toolHistory && toolHistory.length ? toolHistory[toolHistory.length - 1] : null;
+    return {
+        current_goal: previous.current_goal || deriveNextExpectedAction(intent, operationalState),
+        current_task: deriveNextExpectedAction(intent, operationalState),
+        last_user_intent: intent,
+        last_user_message: lastUser ? truncate(lastUser.content, 500) : truncate(query, 500),
+        active_entities: activeEntities,
+        open_decisions: previous.open_decisions || [],
+        last_error: lastTool && lastTool.ok === false ? { tool: lastTool.name, at: lastTool.at, result: lastTool.result } : null,
+        next_expected_action: deriveNextExpectedAction(intent, operationalState),
+        updated_at: nowIso(),
+    };
+};
+const deriveDecisionState = ({ query = '', toolHistory = [], operationalState = {}, workingMemory = {} }) => {
+    const agenda = operationalState.agenda_state || {};
+    const decisions = [];
+    const doNotRepeatTools = [];
+    const intent = workingMemory.last_user_intent || inferUserIntent(query, []);
+    const now = nowIso();
+    const pushDecision = (id, decision, reason, appliesTo, extra = {}) => {
+        decisions.push({
+            id,
+            decision,
+            reason,
+            applies_to: appliesTo,
+            status: extra.status || 'active',
+            confidence: extra.confidence ?? 0.85,
+            source: extra.source || 'super_memory_derived',
+            created_at: extra.created_at || now,
+            valid_until: extra.valid_until || null,
+            superseded_by: extra.superseded_by || null,
+        });
+    };
+    if (agenda.has_availability) {
+        doNotRepeatTools.push('agenda_consultar_disponibilidade');
+        pushDecision('agenda_availability_known', 'do not consult availability again unless the user asks to refresh', 'availability result already exists in tool_history', 'agenda_flow', { confidence: 0.9 });
+    }
+    if (agenda.has_pending_pre_reservation) {
+        doNotRepeatTools.push('agenda_pre_reservar_horario');
+        pushDecision('agenda_pre_reservation_pending', 'confirmation should use the latest pre-reservation context', 'a pre-reservation exists after the latest confirmation', 'agenda_flow', { confidence: 0.92 });
+    }
+    if (agenda.has_confirmation && !agenda.has_pending_pre_reservation) {
+        doNotRepeatTools.push('agenda_confirmar_agendamento');
+        pushDecision('agenda_confirmation_done', 'do not confirm again unless the user explicitly asks to repeat or change it', 'latest reservation appears confirmed', 'agenda_flow', { confidence: 0.9 });
+    }
+    const reservationStatus = agenda.has_confirmation && !agenda.has_pending_pre_reservation
+        ? 'confirmed'
+        : agenda.has_pending_pre_reservation
+            ? 'pending_pre_reservation'
+            : agenda.has_pre_reservation
+                ? 'pre_reserved'
+                : agenda.has_availability
+                    ? 'availability_known'
+                    : 'none';
+    return {
+        active_decisions: decisions,
+        do_not_repeat_tools: Array.from(new Set(doNotRepeatTools)),
+        current_intent: intent,
+        agenda_decision_state: {
+            pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
+            active_reservation: Boolean(agenda.has_pre_reservation || agenda.has_confirmation),
+            confirmed_reservation: Boolean(agenda.has_confirmation && !agenda.has_pending_pre_reservation),
+            superseded_reservation: Boolean(agenda.has_confirmation && agenda.has_pending_pre_reservation),
+            reschedule_requested: intent === 'change_or_cancel' && Boolean(agenda.has_confirmation || agenda.has_pre_reservation),
+            cancel_requested: /\b(cancelar|cancele|desmarcar|remover)\b/i.test(String(query || '')),
+            reservation_status: reservationStatus,
+            evaluated_at: now,
+        },
+        conflict_policy: 'prefer active decisions with newer timestamps; ignore superseded or expired memories unless auditing',
+        decision_count: decisions.length,
+        latest_tool: toolHistory && toolHistory.length ? {
+            name: toolHistory[toolHistory.length - 1].name,
+            ok: toolHistory[toolHistory.length - 1].ok,
+            at: toolHistory[toolHistory.length - 1].at,
+        } : null,
+    };
+};
+const memoryStatusOf = (memory) => {
+    const meta = metadataOf(memory);
+    const validUntil = meta.valid_until || meta.validUntil;
+    if (validUntil && new Date(validUntil).getTime() < Date.now())
+        return 'expired';
+    return meta.status || (meta.superseded_by || meta.supersededBy ? 'superseded' : 'active');
+};
+const confidenceOf = (memory) => {
+    const meta = metadataOf(memory);
+    if (meta.confidence !== undefined)
+        return Number(meta.confidence);
+    if (meta.kind === 'tool_history' || meta.kind === 'tool_facts')
+        return 0.9;
+    if (meta.kind === 'recent_message')
+        return 0.75;
+    return 0.65;
+};
+const enrichContextMemory = (memory) => {
+    const meta = metadataOf(memory);
+    return {
+        memory: memoryText(memory),
+        status: memoryStatusOf(memory),
+        confidence: confidenceOf(memory),
+        source: meta.source || scoreMetaOf(memory).source || 'memory',
+        created_at: memory.created_at || memory.createdAt || meta.at || null,
+        valid_until: meta.valid_until || meta.validUntil || null,
+        superseded_by: meta.superseded_by || meta.supersededBy || null,
+    };
+};
+const deriveMemoryCompression = ({ recentMessages = [], toolHistory = [], profileFacts = {}, operationalState = {}, vectorMemories = [], maxItems = 6 }) => {
+    const lastMessages = pruneByLimit(recentMessages || [], maxItems).map((msg) => `${msg.role || 'message'}: ${truncate(msg.content || '', 160)}`);
+    const lastTools = pruneByLimit(toolHistory || [], maxItems).map((tool) => `${tool.name || 'tool'}:${tool.ok === false ? 'failed' : 'ok'}${tool.at ? `@${tool.at}` : ''}`);
+    const profile = renderProfileFacts(profileFacts);
+    const activeMemories = (vectorMemories || []).map(enrichContextMemory).filter((item) => item.status === 'active').slice(0, maxItems);
+    return {
+        turn_summary: lastMessages.length ? lastMessages : [],
+        session_summary: {
+            messages: lastMessages.length,
+            tools: lastTools,
+            agenda_state: operationalState.agenda_state || {},
+        },
+        entity_summary: profile,
+        workflow_summary: {
+            active_memory_count: activeMemories.length,
+            top_active_memories: activeMemories.map((item) => ({
+                memory: truncate(item.memory, 220),
+                confidence: item.confidence,
+                source: item.source,
+            })),
+        },
+    };
+};
+const deriveContextHealth = ({ userId = '', project = '', vectorMemories = [], recentMessages = [], toolHistory = [], workingMemory = {}, decisionState = {}, memoryCompression = {}, operationalState = {}, diagnostics = {} }) => {
+    const checks = {
+        namespace_stable: Boolean(userId && !/^mcp-session-\d+$/i.test(String(userId))),
+        has_recent_messages: Array.isArray(recentMessages) && recentMessages.length > 0,
+        has_tool_history: Array.isArray(toolHistory) && toolHistory.length > 0,
+        has_vector_memories: Array.isArray(vectorMemories) && vectorMemories.length > 0,
+        has_working_memory: Boolean(workingMemory && Object.keys(workingMemory).length),
+        has_decision_state: Boolean(decisionState && Object.keys(decisionState).length),
+        has_memory_compression: Boolean(memoryCompression && Object.keys(memoryCompression).length),
+        has_operational_state: Boolean(operationalState && Object.keys(operationalState).length),
+        connected_language_model: Boolean(diagnostics.connectedAi && diagnostics.connectedAi.languageModel),
+        connected_embedding: Boolean(diagnostics.connectedAi && diagnostics.connectedAi.embedding),
+        no_connected_ai_errors: !((diagnostics.connectedAi && diagnostics.connectedAi.errors) || []).length,
+    };
+    const weights = {
+        namespace_stable: 170,
+        has_recent_messages: 80,
+        has_tool_history: 140,
+        has_vector_memories: 110,
+        has_working_memory: 110,
+        has_decision_state: 110,
+        has_memory_compression: 90,
+        has_operational_state: 80,
+        connected_language_model: 40,
+        connected_embedding: 40,
+        no_connected_ai_errors: 30,
+    };
+    let score = 0;
+    for (const [key, ok] of Object.entries(checks)) {
+        if (ok)
+            score += weights[key] || 0;
+    }
+    const missing = Object.entries(checks).filter(([, ok]) => !ok).map(([key]) => key);
+    const agenda = operationalState.agenda_state || {};
+    return {
+        kind: 'elefai.brain.context_health.v1',
+        namespace: userId || null,
+        project: project || null,
+        quality_score: Math.max(0, Math.min(1000, score)),
+        status: score >= 970 ? 'excellent' : score >= 900 ? 'strong' : score >= 750 ? 'usable' : 'needs_attention',
+        checks,
+        missing,
+        counts: {
+            vector_memories: Array.isArray(vectorMemories) ? vectorMemories.length : 0,
+            recent_messages: Array.isArray(recentMessages) ? recentMessages.length : 0,
+            tool_history: Array.isArray(toolHistory) ? toolHistory.length : 0,
+            active_decisions: Array.isArray(decisionState.active_decisions) ? decisionState.active_decisions.length : 0,
+        },
+        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),
+        },
+        generated_at: nowIso(),
+    };
+};
+const wrapElefaiMemory = (memory, ctx, memoryKey) => new Proxy(memory, {
+    get(target, prop) {
+        if (prop === 'loadMemoryVariables') {
+            return async (values = {}) => {
+                const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, [
+                    [{ json: { action: 'loadMemoryVariables', values } }],
+                ]);
+                try {
+                    const response = await target.loadMemoryVariables(values);
+                    const chatHistory = snapshotJson(response[memoryKey] || response.chatHistory || []);
+                    ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, [
+                        [{
+                                json: {
+                                    action: 'loadMemoryVariables',
+                                    chatHistory,
+                                    context: response.elefaiBrainContext,
+                                    contextText: response.elefaiBrainContextText,
+                                    summary: response.elefaiBrainSummary,
+                                    connectedModelSummary: response.elefaiBrainConnectedModelSummary,
+                                    workingMemory: response.elefaiBrainWorkingMemory,
+                                    decisionState: response.elefaiBrainDecisionState,
+                                    memoryCompression: response.elefaiBrainMemoryCompression,
+                                    profileFacts: response.elefaiBrainProfileFacts,
+                                    operationalState: response.elefaiBrainOperationalState,
+                                    actionLedger: response.elefaiBrainActionLedger,
+                                    entityTimeline: response.elefaiBrainEntityTimeline,
+                                    vectorMemories: response.elefaiBrainVectorMemories,
+                                    graph: response.elefaiBrainGraph,
+                                    recentMessages: response.elefaiBrainRecentMessages,
+                                    recentHighlights: response.elefaiBrainRecentHighlights,
+                                    toolHistory: response.elefaiBrainToolHistory,
+                                    diagnostics: response.elefaiBrainDiagnostics,
+                                },
+                            }],
+                    ]);
+                    return response;
+                }
+                catch (error) {
+                    ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, error);
+                    throw error;
+                }
+            };
+        }
+        if (prop === 'saveContext') {
+            return async (input = {}, output = {}) => {
+                const { index } = ctx.addInputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, [
+                    [{ json: { action: 'saveContext', input, output } }],
+                ]);
+                try {
+                    const response = await target.saveContext(input, output);
+                    const chatHistory = snapshotJson(await target.chatHistory.getMessages());
+                    ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, [
+                        [{ json: { action: 'saveContext', input, output, chatHistory, saved: true } }],
+                    ]);
+                    return response;
+                }
+                catch (error) {
+                    ctx.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiMemory, index, error);
+                    throw error;
+                }
+            };
+        }
+        return target[prop];
+    },
+});
+const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, workingMemory, decisionState, memoryCompression, operationalState, actionLedger, entityTimeline, vectorMemories, recentMessages, toolHistory, highlights, graph, diagnostics, adv }) => {
+    const includeHeader = adv.includeContextHeader !== false;
+    const includeSummary = adv.includeSummary !== false;
+    const includeScores = adv.includeScores !== false;
+    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. If the user asks to continue, choose, reserve, confirm, update, cancel, or perform 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 (includeSummary) {
+        const summary = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map(memoryText).filter(Boolean);
+        sections.push({ section: 'summary', title: 'Summary', value: summary.length ? summary : null, why_null: summary.length ? undefined : 'no 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: 'profile_facts',
+        title: 'Profile facts',
+        value: adv.includeProfileFacts === false ? null : renderProfileFacts(profileFacts),
+        why_null: adv.includeProfileFacts === false ? 'profile facts disabled' : undefined,
+    });
+    const guard = inferToolGuard({ query, recentMessages, toolHistory, vectorMemories });
+    sections.push({
+        section: 'tool_guard',
+        title: 'Tool guard',
+        value: {
+            blocked_tools: guard.blockedTools,
+            reasons: guard.reasons,
+            instruction: guard.blockedTools.length
+                ? `Do not call these tools now: ${guard.blockedTools.join(', ')}. Ask for the missing context or execute the prerequisite step first.`
+                : 'No downstream tool is blocked by missing memory prerequisites.',
+        },
+    });
+    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 : operationalState,
+        why_null: adv.includeOperationalState === false ? 'operational state disabled' : undefined,
+    });
+    sections.push({
+        section: 'action_ledger',
+        title: 'Action ledger',
+        value: adv.includeActionLedger === false ? null : (actionLedger || []),
+        why_null: adv.includeActionLedger === false ? 'action ledger disabled' : undefined,
+    });
+    sections.push({
+        section: 'entity_timeline',
+        title: 'Entity timeline',
+        value: adv.includeEntityTimeline === false ? null : (entityTimeline || []),
+        why_null: adv.includeEntityTimeline === false ? 'entity timeline disabled' : undefined,
+    });
+    sections.push({
+        section: 'vector',
+        title: 'Vector memories',
+        value: vectorMemories.map((m) => {
+            const scoreMeta = scoreMetaOf(m);
+            const rawScore = scoreOf(m);
+            return {
+                memory: memoryText(m),
+                score: includeScores ? (rawScore !== undefined ? rawScore : scoreMeta.hybridScore ?? scoreMeta.recencyScore ?? 'unavailable') : undefined,
+                semantic_score: includeScores ? scoreMeta.semanticScore : undefined,
+                recency_score: includeScores ? scoreMeta.recencyScore : undefined,
+                hybrid_score: includeScores ? scoreMeta.hybridScore : undefined,
+                source: scoreMeta.source,
+                id: m.id || m.uuid || m.memory_id,
+                created_at: m.created_at || m.createdAt,
+            };
+        }),
+    });
+    sections.push({
+        section: 'memory_compression',
+        title: 'Memory compression',
+        value: adv.includeMemoryCompression === false ? null : (memoryCompression || {}),
+        why_null: adv.includeMemoryCompression === false ? 'memory compression disabled' : undefined,
+    });
+    sections.push({
+        section: 'graph',
+        title: 'Graph',
+        value: graph && graph.length ? graph : null,
+        why_null: graph && graph.length ? undefined : 'graph endpoint did not return relations or is not enabled',
+    });
+    sections.push({
+        section: 'recent_messages',
+        title: 'Recent messages',
+        value: recentMessages || [],
+    });
+    sections.push({
+        section: 'recent_highlights',
+        title: 'Recent highlights',
+        value: highlights || [],
+    });
+    sections.push({
+        section: 'tool_history',
+        title: 'Tool history',
+        value: {
+            enabled: adv.includeToolHistory !== false,
+            items: adv.includeToolHistory === false ? [] : toolHistory.map((tool) => ({
+                id: tool.id,
+                turnId: tool.turnId,
+                sequence: tool.sequence,
+                name: tool.name,
+                input: tool.input,
+                ok: tool.ok,
+                at: tool.at,
+                source: tool.source,
+                result: adv.includeToolResults === false ? undefined : tool.result,
+            })),
+        },
+    });
+    if (adv.includeDiagnostics) {
+        sections.push({
+            section: 'diagnostics',
+            title: 'Diagnostics',
+            value: diagnostics,
+        });
+    }
+    const audit = {
+        kind: 'elefai.brain.context.v1',
+        meta: { user_id: userId, payloadFormat, query },
+        sections,
+        diagnostics,
+    };
+    const renderSection = (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), 900)}`).join('\n') : '(empty)'}`;
+        return `## ${section.title}\n${truncate(safeStringify(section.value), 1600)}`;
+    };
+    if (payloadFormat === 'auditJson') {
+        return [{ role: 'system', content: JSON.stringify(audit, null, 2) }];
+    }
+    if (payloadFormat === 'auditBlocks') {
+        return sections.map((section) => ({ role: 'system', content: renderSection(section) }));
+    }
+    const text = sections.map(renderSection).join('\n\n');
+    if (payloadFormat === 'auditText' || payloadFormat === 'singleSystemMessage' || payloadFormat === 'structured') {
+        return [{ role: 'system', content: truncate(text, 16000) }];
+    }
+    return [{ role: 'system', content: truncate(text, 16000) }];
+};
+class Mem0Memory {
+    constructor() {
+        this.description = {
+            displayName: 'Tembory',
+            name: 'temboryMemory',
+            icon: 'file:tembory-brain.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Advanced memory for AI agents with profile, tools, timeline, graph and semantic context',
+            defaults: {
+                name: 'Tembory',
+            },
+            inputs: [
+                {
+                    displayName: 'LLM',
+                    maxConnections: 1,
+                    type: n8n_workflow_1.NodeConnectionTypes.AiLanguageModel,
+                    required: false,
+                },
+                {
+                    displayName: 'Embed',
+                    maxConnections: 1,
+                    type: n8n_workflow_1.NodeConnectionTypes.AiEmbedding,
+                    required: false,
+                },
+            ],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiMemory],
+            outputNames: ['Mem'],
+            builderHint: {
+                inputs: {
+                    ai_languageModel: { required: false },
+                    ai_embedding: { required: false },
+                },
+            },
+            credentials: [
+                {
+                    name: 'mem0Api',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authType: ['cloud'],
+                        },
+                    },
+                },
+                {
+                    name: 'mem0SelfHostedApi',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authType: ['selfHosted'],
+                        },
+                    },
+                },
+            ],
+            codex: {
+                categories: ['AI', 'Memory'],
+                subcategories: {
+                    AI: ['Memory', 'Agents & LLMs'],
+                    Memory: ['AI Memory'],
+                },
+            },
+            properties: [
+                {
+                    displayName: 'Autenticação',
+                    name: 'authType',
+                    type: 'options',
+                    options: [
+                        { name: 'Tembory Cloud', value: 'cloud' },
+                        { name: 'Self-hosted', value: 'selfHosted' },
+                    ],
+                    default: 'cloud',
+                },
+                {
+                    displayName: 'ID da Thread',
+                    name: 'threadId',
+                    type: 'string',
+                    default: '={{ $json.threadId || $json.sessionId || $json.body?.messages?.[0]?.contactId || $json.body?.contactId || $json.contactId || $json.from || $json.sender || $executionId }}',
+                    description: 'Identificador estável desta conversa/thread. Usado como user_id se nenhum User ID explícito for informado.',
+                },
+                {
+                    displayName: 'Projeto',
+                    name: 'project',
+                    type: 'string',
+                    default: '={{ $json.project || $json.projectId || $json.accountId || $json.body?.account?.id || "" }}',
+                    description: 'Namespace estável do cliente/projeto. Quando preenchido, isola memórias mesmo que duas conversas usem o mesmo ID.',
+                },
+                {
+                    displayName: 'Modo de Recuperação de Contexto',
+                    name: 'retrievalMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Básico', value: 'basic', description: 'Retorna memórias brutas (recentes ou todas)' },
+                        { name: 'Resumo', value: 'summary', description: 'Retorna um resumo simples em texto' },
+                        { name: 'Semântico (v1)', value: 'semantic', description: 'Busca semântica usando o endpoint v1 com opção de rerank' },
+                        { name: 'Semântico (v2)', value: 'semanticV2', description: 'Busca semântica avançada com filtros (v2)' },
+                        { name: 'Híbrido', value: 'hybrid', description: 'Combina memórias recentes com busca semântica (v2) usando time-decay e pontuação híbrida' },
+                    ],
+                    default: 'hybrid',
+                },
+                {
+                    displayName: 'Consulta',
+                    name: 'query',
+                    type: 'string',
+                    default: '={{ $json.query || $json.lastUserMessage || $json.chatInput || $json.body?.consolidated_text || $json.body?.message || $json.body?.text || "" }}',
+                    description: 'Consulta em linguagem natural para recuperar memórias relevantes',
+                    displayOptions: {
+                        show: {
+                            retrievalMode: ['semantic', 'semanticV2', 'hybrid'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Chave de Memória',
+                    name: 'memoryKey',
+                    type: 'string',
+                    default: 'chat_history',
+                    description: 'Chave sob a qual a memória será retornada',
+                },
+                {
+                    displayName: 'Formato do Contexto',
+                    name: 'payloadFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'Produção Estruturado', value: 'structured' },
+                        { name: 'Auditoria Texto', value: 'auditText' },
+                        { name: 'Auditoria JSON', value: 'auditJson' },
+                        { name: 'Blocos de Auditoria', value: 'auditBlocks' },
+                        { name: 'Uma System Message', value: 'singleSystemMessage' },
+                    ],
+                    default: 'structured',
+                    description: 'Como o contexto recuperado será entregue ao agente antes da LLM.',
+                },
+                {
+                    displayName: 'Avançado',
+                    name: 'advanced',
+                    type: 'collection',
+                    placeholder: 'Opções',
+                    default: {},
+                    options: [
+                        { displayName: 'User ID', name: 'userId', type: 'string', default: '' },
+                        {
+                            displayName: 'Preset Operacional',
+                            name: 'operationPreset',
+                            type: 'options',
+                            options: [
+                                { name: 'Custom', value: 'custom' },
+                                { name: 'Diagnóstico Completo', value: 'diagnostic' },
+                                { name: 'Produção Balanceada', value: 'productionBalanced' },
+                                { name: 'Produção Econômica', value: 'productionCheap' },
+                                { name: 'Auditoria', value: 'audit' },
+                            ],
+                            default: 'custom',
+                            description: 'Preenche defaults seguros para contexto, diagnostico, historico de tools e mensagens recentes. Valores definidos manualmente continuam tendo prioridade.',
+                        },
+                        { displayName: 'Agent ID', name: 'agentId', type: 'string', default: '' },
+                        { displayName: 'App ID', name: 'appId', type: 'string', default: '' },
+                        { displayName: 'Run ID', name: 'runId', type: 'string', default: '' },
+                        { displayName: 'Top K', name: 'topK', type: 'number', typeOptions: { minValue: 1 }, default: 25, description: 'Quantidade de memórias a recuperar (modos semânticos e limites de recentes)' },
+                        { displayName: 'Rerank', name: 'rerank', type: 'boolean', default: true, description: 'Reordenação por relevância (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
+                        { displayName: 'Fields (lista separada por vírgula)', name: 'fields', type: 'string', default: '', description: 'Campos específicos a retornar da API (modos semânticos)', displayOptions: { show: { '/retrievalMode': ['semantic', 'semanticV2', 'hybrid'] } } },
+                        { displayName: 'Filters (JSON)', name: 'filters', type: 'json', default: '{}', description: 'Objeto de filtros avançados para busca v2', displayOptions: { show: { '/retrievalMode': ['semanticV2', 'hybrid'] } } },
+                        { displayName: 'Last N (recentes)', name: 'lastN', type: 'number', default: 20, description: 'Se > 0, retorna apenas as últimas N memórias em Básico/Resumo e compõe a parte de recentes no Híbrido', displayOptions: { show: { '/retrievalMode': ['basic', 'summary', 'hybrid'] } } },
+                        { displayName: 'Alpha (peso semântico)', name: 'alpha', type: 'number', typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 }, default: 0.65, description: 'Peso da relevância semântica na pontuação híbrida', displayOptions: { show: { '/retrievalMode': ['hybrid'] } } },
+                        { displayName: 'Half-life (horas)', name: 'halfLifeHours', type: 'number', typeOptions: { minValue: 1 }, default: 48, description: 'Meia-vida (em horas) usada no decaimento temporal', displayOptions: { show: { '/retrievalMode': ['hybrid'] } } },
+                        { displayName: 'Máximo a retornar', name: 'maxReturn', type: 'number', typeOptions: { minValue: 1 }, default: 30, description: 'Quantidade final de memórias retornadas ao agente', displayOptions: { show: { '/retrievalMode': ['hybrid'] } } },
+                        { 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: '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 },
+                        { displayName: 'Incluir Diagnóstico', name: 'includeDiagnostics', type: 'boolean', default: false },
+                        { displayName: 'Incluir Grafo', name: 'includeRelations', type: 'boolean', default: true },
+                        { displayName: 'Máximo de Relações', name: 'maxRelations', type: 'number', default: 10 },
+                        { displayName: 'Incluir Tool History', name: 'includeToolHistory', type: 'boolean', default: true },
+                        { displayName: 'Incluir Resultado Das Tools', name: 'includeToolResults', type: 'boolean', default: true },
+                        { displayName: 'Últimas N Tools', name: 'toolHistoryLastN', type: 'number', default: 15 },
+                        { displayName: 'TTL Das Tools (Segundos)', name: 'toolHistoryTTLSeconds', type: 'number', default: 3600 },
+                        { displayName: 'Persistir Tool Facts no Backend', name: 'persistToolFactsToMem0', type: 'boolean', default: false },
+                        { displayName: 'Fallback Semântico Para Tools', name: 'includeToolHistorySemanticFallback', type: 'boolean', default: false, description: 'Usa memórias vetoriais para tentar inferir histórico de tools quando não houver eventos estruturados. Útil em laboratório, não recomendado como fonte primária em produção.' },
+                        { displayName: 'Incluir Profile Facts', name: 'includeProfileFacts', type: 'boolean', default: true, description: 'Extrai e injeta fatos estáveis do lead/cliente como nome, empresa, email, telefone, preferências, interesses e contexto comercial.' },
+                        { displayName: 'Incluir Working Memory', name: 'includeWorkingMemory', type: 'boolean', default: true, description: 'Injeta objetivo atual, intenção recente, entidades ativas, último erro e próxima ação esperada.' },
+                        { displayName: 'Incluir Decision State', name: 'includeDecisionState', type: 'boolean', default: true, description: 'Injeta decisões ativas, ferramentas que não devem ser repetidas e política de resolução de conflitos.' },
+                        { displayName: 'Incluir Estado Operacional', name: 'includeOperationalState', type: 'boolean', default: true, description: 'Injeta um resumo determinístico do estado das tools, pré-requisitos, reservas pendentes e próximo passo seguro.' },
+                        { displayName: 'Incluir Action Ledger', name: 'includeActionLedger', type: 'boolean', default: true, description: 'Injeta um ledger cronológico e compacto das ações/tools executadas, com input, resultado e status.' },
+                        { displayName: 'Incluir Entity Timeline', name: 'includeEntityTimeline', type: 'boolean', default: true, description: 'Injeta uma timeline compacta de entidades, fatos de perfil, relações do grafo e eventos importantes da sessão.' },
+                        { displayName: 'Incluir Compressão de Memória', name: 'includeMemoryCompression', type: 'boolean', default: true, description: 'Injeta resumos compactos de turno, sessão, entidades e workflow para reduzir ruído.' },
+                        { displayName: 'Incluir Mensagens Recentes', name: 'includeRecentMessages', type: 'boolean', default: true },
+                        { displayName: 'Últimas N Mensagens', name: 'recentMessagesLastN', type: 'number', default: 8 },
+                        { displayName: 'Incluir Highlights Recentes', name: 'includeRecentHighlights', type: 'boolean', default: true },
+                        { displayName: 'Máximo de Highlights', name: 'recentHighlightsMaxItems', type: 'number', default: 6 },
+                    ],
+                },
+            ],
+        };
+    }
+    // For AI connections, n8n reads from supplyData. The AI Agent expects a
+    // memory-like object, not raw JSON, so expose the LangChain memory contract.
+    async supplyData(itemIndex) {
+        const memoryKey = this.getNodeParameter('memoryKey', itemIndex);
+        let currentMessages = [];
+        const memory = {
+            memoryKeys: [memoryKey],
+            inputKey: 'input',
+            outputKey: 'output',
+            returnMessages: true,
+            chatHistory: {
+                getMessages: async () => currentMessages,
+                addMessage: async (message) => {
+                    currentMessages.push(message);
+                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [message]);
+                },
+                addUserMessage: async (message) => {
+                    const baseMessage = toBaseMessage({ role: 'user', content: message });
+                    currentMessages.push(baseMessage);
+                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                },
+                addAIChatMessage: async (message) => {
+                    const baseMessage = toBaseMessage({ role: 'assistant', content: message });
+                    currentMessages.push(baseMessage);
+                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, [baseMessage]);
+                },
+                addMessages: async (messages) => {
+                    currentMessages.push(...messages);
+                    await Mem0Memory.prototype.saveMessagesForItem.call(this, itemIndex, messages);
+                },
+                clear: async () => {
+                    currentMessages = [];
+                },
+            },
+            loadMemoryVariables: async (inputValues = {}) => {
+                const result = await Mem0Memory.prototype.loadMemoryVariablesForItem.call(this, itemIndex, inputValues);
+                const chatHistory = (result.response[memoryKey] || []).map(toBaseMessage);
+                const extra = { ...(result.response || {}) };
+                delete extra[memoryKey];
+                currentMessages = chatHistory;
+                return {
+                    ...extra,
+                    [memoryKey]: chatHistory,
+                    chatHistory,
+                };
+            },
+            saveContext: async (inputValues = {}, outputValues = {}) => {
+                const input = pickText(inputValues, ['input', 'chatInput', 'text', 'query', 'question']);
+                const output = pickText(outputValues, ['output', 'response', 'text', 'answer']);
+                if (input)
+                    currentMessages.push(toBaseMessage({ role: 'user', content: input }));
+                if (output)
+                    currentMessages.push(toBaseMessage({ role: 'assistant', content: output }));
+                await Mem0Memory.prototype.saveContextForItem.call(this, itemIndex, inputValues, outputValues);
+            },
+        };
+        return { response: wrapElefaiMemory(memory, this, memoryKey) };
+    }
+    async saveMessagesForItem(itemIndex, messages = []) {
+        const inputValues = {};
+        const outputValues = {};
+        const toolCalls = [];
+        const inputParts = [];
+        const outputParts = [];
+        for (const message of messages || []) {
+            const type = typeof (message === null || message === void 0 ? void 0 : message._getType) === 'function' ? message._getType() : String((message === null || message === void 0 ? void 0 : message.role) || '');
+            const content = typeof (message === null || message === void 0 ? void 0 : message.content) === 'string' ? message.content : safeStringify(message === null || message === void 0 ? void 0 : message.content);
+            if (type === 'human' || type === 'user')
+                inputParts.push(content);
+            else if (type === 'ai' || type === 'assistant')
+                outputParts.push(content);
+            else if (type === 'tool') {
+                toolCalls.push({
+                    name: message.name || message.toolName || message.tool || (message.additional_kwargs && (message.additional_kwargs.name || message.additional_kwargs.tool_name)) || 'tool',
+                    input: '',
+                    ok: true,
+                    result: summarizeToolResult(content),
+                    at: nowIso(),
+                });
+            }
+        }
+        if (inputParts.length)
+            inputValues.input = inputParts.join('\n');
+        const toolContext = toolCalls.length
+            ? `[Used tools: ${toolCalls.map((tool) => `Tool: ${tool.name}, Input: ${tool.input}, Result: ${tool.result}`).join('; ')}] `
+            : '';
+        if (outputParts.length || toolContext)
+            outputValues.output = `${toolContext}${outputParts.join('\n')}`.trim();
+        if (inputValues.input || outputValues.output)
+            await Mem0Memory.prototype.saveContextForItem.call(this, itemIndex, inputValues, outputValues);
+    }
+    async saveContextForItem(itemIndex, inputValues = {}, outputValues = {}) {
+        const threadId = this.getNodeParameter('threadId', itemIndex);
+        const project = this.getNodeParameter('project', itemIndex, '');
+        const adv = applyOperationalPreset(this.getNodeParameter('advanced', itemIndex, {}) || {});
+        const store = getMemoryStore(this);
+        const key = userKeyFrom(threadId, adv, project);
+        const input = pickText(inputValues, ['input', 'chatInput', 'text', 'query', 'question']);
+        const output = pickText(outputValues, ['output', 'response', 'text', 'answer']);
+        const toolCalls = extractToolCalls(outputValues);
+        const recentForMem0 = [];
+        const profileFromTurn = extractProfileFactsFromText(input, 'user_message', nowIso());
+        if (Object.keys(profileFromTurn).length) {
+            store.profileFacts[key] = mergeProfileFacts(store.profileFacts[key], profileFromTurn);
+            try {
+                const globalData = this.getWorkflowStaticData('global');
+                globalData.__dataChanged = true;
+            }
+            catch { }
+        }
+        if (toolCalls.length) {
+            const existing = store.toolHistory[key] || [];
+            store.toolHistory[key] = applyToolHistoryWindow(existing.concat(toolCalls), adv.toolHistoryTTLSeconds, adv.toolHistoryLastN || 15);
+            try {
+                const globalData = this.getWorkflowStaticData('global');
+                globalData.__dataChanged = true;
+            }
+            catch { }
+        }
+        if (adv.includeRecentMessages !== false) {
+            const recent = store.recentMessages[key] || [];
+            if (input) {
+                const item = { role: 'user', content: truncate(input, 2000), at: nowIso() };
+                recent.push(item);
+                recentForMem0.push(item);
+            }
+            if (output) {
+                const item = { role: 'assistant', content: truncate(output, 2000), at: nowIso() };
+                recent.push(item);
+                recentForMem0.push(item);
+            }
+            store.recentMessages[key] = pruneByLimit(recent, adv.recentMessagesLastN || 8);
+            try {
+                const globalData = this.getWorkflowStaticData('global');
+                globalData.__dataChanged = true;
+            }
+            catch { }
+        }
+        const renderedProfileForTurn = renderProfileFacts(store.profileFacts[key] || {});
+        const recentForTurn = store.recentMessages[key] || [];
+        const toolHistoryForTurn = store.toolHistory[key] || [];
+        const operationalStateForTurn = deriveOperationalState(toolHistoryForTurn, renderedProfileForTurn, recentForTurn, adv.includeToolResults !== false);
+        const workingMemoryForTurn = deriveWorkingMemory({
+            query: input,
+            profileFacts: renderedProfileForTurn,
+            recentMessages: recentForTurn,
+            toolHistory: toolHistoryForTurn,
+            operationalState: operationalStateForTurn,
+            previous: store.workingMemory[key] || {},
+        });
+        const decisionStateForTurn = deriveDecisionState({
+            query: input,
+            toolHistory: toolHistoryForTurn,
+            operationalState: operationalStateForTurn,
+            workingMemory: workingMemoryForTurn,
+        });
+        const compressionForTurn = deriveMemoryCompression({
+            recentMessages: recentForTurn,
+            toolHistory: toolHistoryForTurn,
+            profileFacts: store.profileFacts[key] || {},
+            operationalState: operationalStateForTurn,
+            vectorMemories: [],
+            maxItems: adv.compressionMaxItems || 6,
+        });
+        store.workingMemory[key] = workingMemoryForTurn;
+        store.decisionState[key] = decisionStateForTurn;
+        store.memoryCompression[key] = compressionForTurn;
+        try {
+            const globalData = this.getWorkflowStaticData('global');
+            globalData.__dataChanged = true;
+        }
+        catch { }
+        const messages = [];
+        if (input)
+            messages.push({ role: 'user', content: input });
+        if (output)
+            messages.push({ role: 'assistant', content: output });
+        if (!messages.length)
+            return;
+        const body = { messages };
+        body.user_id = key;
+        if (adv.agentId)
+            body.agent_id = String(adv.agentId);
+        if (adv.appId)
+            body.app_id = String(adv.appId);
+        if (adv.runId)
+            body.run_id = String(adv.runId);
+        const connectedEmbedding = await getConnectedEmbedding(this, itemIndex);
+        if (connectedEmbedding) {
+            const ids = { user_id: body.user_id, agent_id: body.agent_id, run_id: body.run_id };
+            const clientMemories = [];
+            for (const message of messages) {
+                clientMemories.push(await createClientVectorMemory(connectedEmbedding, message.content, {
+                    kind: 'conversation_message',
+                    role: message.role,
+                    thread_id: threadId,
+                    project: project || undefined,
+                    at: nowIso(),
+                    source: 'n8n_connected_embedding',
+                }, ids));
+            }
+            if (adv.includeRecentMessages !== false && recentForMem0.length) {
+                for (const recent of recentForMem0) {
+                    clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeRecentMessage(recent, threadId), {
+                        kind: 'recent_message',
+                        role: recent.role,
+                        content: recent.content,
+                        at: recent.at,
+                        thread_id: threadId,
+                        project: project || undefined,
+                        source: 'n8n_connected_embedding',
+                    }, ids));
+                }
+            }
+            if (adv.persistToolFactsToMem0 && toolCalls.length) {
+                const facts = toolCalls.map((tool) => `Tool ${tool.name} input=${tool.input}${tool.result ? ` result=${tool.result}` : ''}`).join('\n');
+                clientMemories.push(await createClientVectorMemory(connectedEmbedding, `Tool facts (read-only):\n${truncate(facts, 2000)}`, {
+                    kind: 'tool_facts',
+                    source: 'n8n_connected_embedding',
+                }, ids));
+                for (const tool of toolCalls) {
+                    clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeToolCall(tool, threadId), {
+                        kind: 'tool_history',
+                        id: tool.id,
+                        sequence: tool.sequence,
+                        turn_id: tool.turnId,
+                        name: tool.name,
+                        input: tool.input,
+                        ok: tool.ok,
+                        result: tool.result,
+                        at: tool.at,
+                        source: tool.source || 'n8n_connected_embedding',
+                        thread_id: threadId,
+                    }, ids));
+                }
+            }
+            await saveClientVectorMemories(this, clientMemories, ids);
+            return;
+        }
+        await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', '/v1/memories/', body);
+        if (adv.includeRecentMessages !== false && recentForMem0.length) {
+            for (const recent of recentForMem0) {
+                await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', '/v1/memories/', {
+                    messages: [{ role: 'system', content: encodeRecentMessage(recent, threadId) }],
+                    infer: false,
+                    user_id: body.user_id,
+                    agent_id: body.agent_id,
+                    run_id: body.run_id,
+                    metadata: {
+                        kind: 'recent_message',
+                        role: recent.role,
+                        content: recent.content,
+                        at: recent.at,
+                        thread_id: threadId,
+                        project: project || undefined,
+                    },
+                });
+            }
+        }
+        if (adv.persistToolFactsToMem0 && toolCalls.length) {
+            const facts = toolCalls.map((tool) => `Tool ${tool.name} input=${tool.input}${tool.result ? ` result=${tool.result}` : ''}`).join('\n');
+            await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', '/v1/memories/', {
+                messages: [{ role: 'system', content: `Tool facts (read-only):\n${truncate(facts, 2000)}` }],
+                infer: false,
+                user_id: body.user_id,
+                metadata: { kind: 'tool_facts' },
+            });
+            for (const tool of toolCalls) {
+                await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', '/v1/memories/', {
+                    messages: [{ role: 'system', content: encodeToolCall(tool, threadId) }],
+                    infer: false,
+                    user_id: body.user_id,
+                    agent_id: body.agent_id,
+                    run_id: body.run_id,
+                    metadata: {
+                        kind: 'tool_history',
+                        id: tool.id,
+                        sequence: tool.sequence,
+                        turn_id: tool.turnId,
+                        name: tool.name,
+                        input: tool.input,
+                        ok: tool.ok,
+                        result: tool.result,
+                        at: tool.at,
+                        source: tool.source,
+                        thread_id: threadId,
+                    },
+                });
+            }
+        }
+    }
+    async loadMemoryVariablesForItem(itemIndex, inputValues = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const memoryKey = this.getNodeParameter('memoryKey', itemIndex);
+        const retrievalMode = this.getNodeParameter('retrievalMode', itemIndex);
+        let payloadFormat = this.getNodeParameter('payloadFormat', itemIndex, 'structured');
+        const threadId = this.getNodeParameter('threadId', itemIndex);
+        const project = this.getNodeParameter('project', itemIndex, '');
+        const adv = applyOperationalPreset(this.getNodeParameter('advanced', itemIndex, {}) || {});
+        payloadFormat = adv.payloadFormat || payloadFormat;
+        const store = getMemoryStore(this);
+        const key = userKeyFrom(threadId, adv, project);
+        const queryParam = this.getNodeParameter('query', itemIndex, '');
+        const query = asSearchQuery(queryParam) || asSearchQuery(inputValues.query) || asSearchQuery(inputValues.input) || asSearchQuery(inputValues.chatInput);
+        let connectedLanguageModel;
+        let connectedEmbedding;
+        const connectedAi = {
+            languageModel: false,
+            embedding: false,
+            embeddingQuery: false,
+            languageModelSummary: false,
+            errors: [],
+        };
+        try {
+            connectedLanguageModel = await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiLanguageModel, itemIndex);
+            connectedAi.languageModel = true;
+        }
+        catch (error) {
+            connectedAi.errors.push(`languageModel: ${error.message || String(error)}`);
+        }
+        try {
+            connectedEmbedding = await this.getInputConnectionData(n8n_workflow_1.NodeConnectionTypes.AiEmbedding, itemIndex);
+            connectedAi.embedding = true;
+        }
+        catch (error) {
+            connectedAi.errors.push(`embedding: ${error.message || String(error)}`);
+        }
+        if (connectedEmbedding && typeof connectedEmbedding.embedQuery === 'function' && String(query || '').trim()) {
+            try {
+                await connectedEmbedding.embedQuery(String(query));
+                connectedAi.embeddingQuery = true;
+            }
+            catch (error) {
+                connectedAi.errors.push(`embedding.embedQuery: ${error.message || String(error)}`);
+            }
+        }
+        try {
+            this.logger?.debug('Tembory loading memory variables before model invocation', {
+                itemIndex,
+                retrievalMode,
+                hasQuery: String(query || '').trim().length > 0,
+                connectedAi,
+            });
+        }
+        catch { }
+        let payload;
+        let vectorMemories = [];
+        if (retrievalMode === 'semantic' || retrievalMode === 'semanticV2' || retrievalMode === 'hybrid') {
+            const body = { query: String(query || '') };
+            // IDs
+            body.user_id = key;
+            if (adv.agentId)
+                body.agent_id = String(adv.agentId);
+            if (adv.appId)
+                body.app_id = String(adv.appId);
+            if (adv.runId)
+                body.run_id = String(adv.runId);
+            // Options
+            if (adv.topK)
+                body.top_k = Number(adv.topK);
+            if (adv.rerank !== undefined)
+                body.rerank = Boolean(adv.rerank);
+            if (typeof adv.fields === 'string' && adv.fields)
+                body.fields = String(adv.fields).split(',').map((f) => f.trim());
+            if (retrievalMode === 'semanticV2' || retrievalMode === 'hybrid') {
+                try {
+                    const filters = typeof adv.filters === 'string' ? JSON.parse(adv.filters) : (adv.filters || {});
+                    body.filters = filters;
+                }
+                catch (error) {
+                    connectedAi.errors.push(`filters.parse: ${error.message || String(error)}`);
+                }
+            }
+            const hasQuery = String(query || '').trim().length > 0;
+            const url = retrievalMode === 'semanticV2' || retrievalMode === 'hybrid' ? '/v2/memories/search/' : '/v1/memories/search/';
+            const semRes = hasQuery && connectedEmbedding
+                ? await searchClientVectorMemories(this, connectedEmbedding, query, body)
+                : hasQuery
+                    ? await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', url, body)
+                    : { results: [] };
+            let semMemories = normalizeResults(semRes);
+            if (retrievalMode === 'hybrid' || !hasQuery) {
+                // coletar recentes
+                const qs = {};
+                qs.user_id = key;
+                if (adv.agentId)
+                    qs.agent_id = String(adv.agentId);
+                if (adv.appId)
+                    qs.app_id = String(adv.appId);
+                if (adv.runId)
+                    qs.run_id = String(adv.runId);
+                const recRes = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/v1/memories/', {}, qs);
+                let recents = normalizeResults(recRes);
+                const lastN = Number((_a = adv.lastN) !== null && _a !== void 0 ? _a : 20);
+                if (lastN > 0)
+                    recents = recents.slice(-lastN);
+                // scoring híbrido
+                const alpha = Number((_b = adv.alpha) !== null && _b !== void 0 ? _b : 0.65);
+                const halfLife = Number((_c = adv.halfLifeHours) !== null && _c !== void 0 ? _c : 48);
+                const maxReturn = Number((_d = adv.maxReturn) !== null && _d !== void 0 ? _d : 30);
+                const mmr = adv.mmr !== undefined ? Boolean(adv.mmr) : true;
+                const mmrLambda = Number((_e = adv.mmrLambda) !== null && _e !== void 0 ? _e : 0.5);
+                const LN2 = Math.log(2);
+                const now = Date.now();
+                const idOf = (m) => m.id || m.uuid || m._id || m.memory_id || m.pk || JSON.stringify(m).slice(0, 1000);
+                const createdOf = (m) => m.created_at || m.createdAt || m.timestamp || m.time || m.date;
+                const rankingScoreOf = (m) => { var _a; return (_a = scoreOf(m)) !== null && _a !== void 0 ? _a : m.rank !== undefined ? Number(m.rank) : 1; };
+                const merged = new Map();
+                // add semantic part
+                for (const m of semMemories) {
+                    const id = idOf(m);
+                    const created = createdOf(m);
+                    let recency = 0.5;
+                    if (created) {
+                        const t = new Date(created).getTime();
+                        if (!isNaN(t)) {
+                            const ageH = Math.max(0, (now - t) / 3600000);
+                            recency = Math.exp(-LN2 * (ageH / Math.max(1, halfLife)));
+                        }
+                    }
+                    const sem = Number(rankingScoreOf(m));
+                    const hybrid = alpha * sem + (1 - alpha) * recency;
+                    merged.set(id, { m, semanticScore: sem, recencyScore: recency, hybrid, source: 'semantic' });
+                }
+                // add recents part
+                for (const m of recents) {
+                    const id = idOf(m);
+                    const created = createdOf(m);
+                    let recency = 0.7;
+                    if (created) {
+                        const t = new Date(created).getTime();
+                        if (!isNaN(t)) {
+                            const ageH = Math.max(0, (now - t) / 3600000);
+                            recency = Math.exp(-LN2 * (ageH / Math.max(1, halfLife)));
+                        }
+                    }
+                    const prev = merged.get(id);
+                    const sem = (_f = prev === null || prev === void 0 ? void 0 : prev.semanticScore) !== null && _f !== void 0 ? _f : 0;
+                    const hybrid = alpha * sem + (1 - alpha) * recency;
+                    merged.set(id, { m: (_g = prev === null || prev === void 0 ? void 0 : prev.m) !== null && _g !== void 0 ? _g : m, semanticScore: sem, recencyScore: recency, hybrid, source: prev ? 'hybrid' : 'recent' });
+                }
+                let ranked = Array.from(merged.values());
+                ranked.sort((a, b) => b.hybrid - a.hybrid);
+                if (mmr && ranked.length > 2) {
+                    // MMR greedy (sem embeddings; usa score como proxy)
+                    const selected = [];
+                    const rest = [...ranked];
+                    // pick top-1
+                    selected.push(rest.shift());
+                    while (selected.length < Math.min(maxReturn, ranked.length) && rest.length) {
+                        let bestIdx = 0;
+                        let bestScore = -Infinity;
+                        for (let i = 0; i < rest.length; i++) {
+                            const cand = rest[i];
+                            const rel = cand.hybrid;
+                            // diversidade simples: penaliza se muito parecido com já escolhidos (aproximação via diferença de score)
+                            const sim = Math.max(...selected.map((s) => 1 - Math.abs(s.hybrid - cand.hybrid)));
+                            const mmrScore = mmrLambda * rel - (1 - mmrLambda) * sim;
+                            if (mmrScore > bestScore) {
+                                bestScore = mmrScore;
+                                bestIdx = i;
+                            }
+                        }
+                        selected.push(rest.splice(bestIdx, 1)[0]);
+                    }
+                    ranked = selected;
+                }
+                const finalMemories = ranked.slice(0, maxReturn).map((r) => withElefaiScore(r.m, {
+                    semanticScore: r.semanticScore,
+                    recencyScore: r.recencyScore,
+                    hybridScore: r.hybrid,
+                    source: r.source,
+                }));
+                vectorMemories = finalMemories;
+                payload = finalMemories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
+            }
+            else {
+                vectorMemories = semMemories.map((m) => withElefaiScore(m, {
+                    semanticScore: scoreOf(m),
+                    source: 'semantic',
+                }));
+                payload = semMemories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
+            }
+        }
+        else {
+            const qs = {};
+            qs.user_id = key;
+            if (adv.agentId)
+                qs.agent_id = String(adv.agentId);
+            if (adv.appId)
+                qs.app_id = String(adv.appId);
+            if (adv.runId)
+                qs.run_id = String(adv.runId);
+            const res = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/v1/memories/', {}, qs);
+            let memories = normalizeResults(res);
+            // lastN limit
+            if (adv.lastN && Number(adv.lastN) > 0)
+                memories = memories.slice(-Number(adv.lastN));
+            vectorMemories = memories;
+            if (retrievalMode === 'summary') {
+                const text = memories
+                    .map((m) => m.memory || m.text || m.value)
+                    .filter(Boolean)
+                    .join('\n');
+                payload = [{ role: 'system', content: `Summary of memories:\n${text}` }];
+            }
+            else {
+                payload = memories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
+            }
+        }
+        let graph = [];
+        if (adv.includeRelations !== false) {
+            try {
+                const entityRes = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/entities/relations', {}, { user_id: key, agent_id: adv.agentId || undefined, run_id: adv.runId || undefined, limit: Number(adv.maxRelations || 10) });
+                graph = normalizeResults(entityRes).slice(0, Number(adv.maxRelations || 10));
+            }
+            catch (error) {
+                connectedAi.errors.push(`graph.relations: ${error.message || String(error)}`);
+            }
+        }
+        let persistedRecentMessages = [];
+        let persistedToolHistory = [];
+        if (adv.includeRecentMessages !== false) {
+            try {
+                const qs = { user_id: key };
+                if (adv.agentId)
+                    qs.agent_id = String(adv.agentId);
+                if (adv.runId)
+                    qs.run_id = String(adv.runId);
+                const recentRes = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/v1/memories/', {}, qs);
+                persistedRecentMessages = normalizeResults(recentRes)
+                    .map(recentMessageFromMemory)
+                    .filter(Boolean)
+                    .sort((a, b) => new Date(a.at || 0).getTime() - new Date(b.at || 0).getTime());
+            }
+            catch (error) {
+                connectedAi.errors.push(`recentMessages.load: ${error.message || String(error)}`);
+            }
+        }
+        if (adv.includeToolHistory !== false) {
+            try {
+                const qs = { user_id: key };
+                if (adv.agentId)
+                    qs.agent_id = String(adv.agentId);
+                if (adv.runId)
+                    qs.run_id = String(adv.runId);
+                const toolRes = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/v1/memories/', {}, qs);
+                persistedToolHistory = normalizeResults(toolRes)
+                    .flatMap(toolHistoryItemsFromMemory)
+                    .sort((a, b) => new Date(a.at || 0).getTime() - new Date(b.at || 0).getTime());
+            }
+            catch (error) {
+                connectedAi.errors.push(`toolHistory.load: ${error.message || String(error)}`);
+            }
+        }
+        const allRecentMessages = dedupeRecentMessages((store.recentMessages[key] || []).concat(persistedRecentMessages));
+        const recentMessages = adv.includeRecentMessages === false ? [] : pruneByLimit(allRecentMessages, adv.recentMessagesLastN || 8);
+        const toolHistoryFromRecentMessages = [];
+        if (adv.includeToolHistory !== false) {
+            for (const msg of recentMessages)
+                toolHistoryFromRecentMessages.push(...extractToolCallsFromText(msg.content, msg.at));
+        }
+        const toolHistoryFromVectorMemories = adv.includeToolHistory === false || adv.includeToolHistorySemanticFallback !== true ? [] : vectorMemories.flatMap(toolHistoryItemsFromMemory);
+        const toolHistory = adv.includeToolHistory === false ? [] : applyToolHistoryWindow((store.toolHistory[key] || []).concat(persistedToolHistory, toolHistoryFromRecentMessages, toolHistoryFromVectorMemories), adv.toolHistoryTTLSeconds, adv.toolHistoryLastN || 15);
+        const highlights = adv.includeRecentHighlights === false ? [] : getRecentHighlights(recentMessages, toolHistory, adv.recentHighlightsMaxItems || 6);
+        const profileFacts = adv.includeProfileFacts === false ? {} : mergeProfileFacts(store.profileFacts[key], profileFactsFromMessages(allRecentMessages), profileFactsFromMemories(vectorMemories));
+        if (adv.includeProfileFacts !== false && Object.keys(profileFacts).length) {
+            store.profileFacts[key] = mergeProfileFacts(store.profileFacts[key], profileFacts);
+            try {
+                const globalData = this.getWorkflowStaticData('global');
+                globalData.__dataChanged = true;
+            }
+            catch { }
+        }
+        let connectedModelSummary = '';
+        if (connectedLanguageModel && typeof connectedLanguageModel.invoke === 'function' && (vectorMemories.length || String(query || '').trim()) && adv.includeSummary !== false) {
+            try {
+                const facts = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map(memoryText).filter(Boolean).join('\n') || '(no vector memories found)';
+                if (facts || String(query || '').trim()) {
+                    const response = await connectedLanguageModel.invoke([
+                        toBaseMessage({
+                            role: 'user',
+                            content: `Summarize available Tembory context as concise factual bullets. If there are no memories, return exactly "(empty)".\n\nQuery: ${String(query || '')}\n\nMemories:\n${truncate(facts, 3000)}`,
+                        }),
+                    ]);
+                    connectedModelSummary = truncate(response?.content || response?.text || String(response || ''), 1200);
+                    connectedAi.languageModelSummary = true;
+                }
+            }
+            catch (error) {
+                connectedAi.errors.push(`languageModel.invoke: ${error.message || String(error)}`);
+            }
+        }
+        const diagnostics = {
+            vectorMemories: vectorMemories.length,
+            recentMessages: recentMessages.length,
+            toolHistory: toolHistory.length,
+            graph: graph.length,
+            project: project || null,
+            memoryNamespace: key,
+            connectedAi,
+        };
+        const includeToolResults = adv.includeToolResults !== false;
+        const operationalState = deriveOperationalState(toolHistory, renderProfileFacts(profileFacts), recentMessages, includeToolResults);
+        const actionLedger = deriveActionLedger(toolHistory, adv.actionLedgerMaxItems || adv.toolHistoryLastN || 20, includeToolResults);
+        const entityTimeline = deriveEntityTimeline(profileFacts, graph, recentMessages, toolHistory, adv.entityTimelineMaxItems || 24);
+        const workingMemory = deriveWorkingMemory({
+            query,
+            profileFacts: renderProfileFacts(profileFacts),
+            recentMessages,
+            toolHistory,
+            operationalState,
+            previous: store.workingMemory[key] || {},
+        });
+        const decisionState = deriveDecisionState({
+            query,
+            toolHistory,
+            operationalState,
+            workingMemory,
+        });
+        const memoryCompression = deriveMemoryCompression({
+            recentMessages,
+            toolHistory,
+            profileFacts,
+            operationalState,
+            vectorMemories,
+            maxItems: adv.compressionMaxItems || 6,
+        });
+        const contextHealth = deriveContextHealth({
+            userId: key,
+            project,
+            vectorMemories,
+            recentMessages,
+            toolHistory,
+            workingMemory,
+            decisionState,
+            memoryCompression,
+            operationalState,
+            diagnostics,
+        });
+        store.workingMemory[key] = workingMemory;
+        store.decisionState[key] = decisionState;
+        store.memoryCompression[key] = memoryCompression;
+        try {
+            const globalData = this.getWorkflowStaticData('global');
+            globalData.__dataChanged = true;
+        }
+        catch { }
+        payload = buildContextMessages({
+            payloadFormat,
+            query,
+            userId: key,
+            profileFacts,
+            workingMemory,
+            decisionState,
+            memoryCompression,
+            operationalState,
+            actionLedger,
+            entityTimeline,
+            vectorMemories,
+            recentMessages,
+            toolHistory,
+            highlights,
+            graph,
+            diagnostics,
+            adv,
+        });
+        const normalizedVectorMemories = vectorMemories.map((m) => {
+            const scoreMeta = scoreMetaOf(m);
+            const rawScore = scoreOf(m);
+            const enriched = enrichContextMemory(m);
+            return {
+                memory: memoryText(m),
+                score: adv.includeScores === false ? undefined : (rawScore !== undefined ? rawScore : scoreMeta.hybridScore ?? scoreMeta.recencyScore ?? 'unavailable'),
+                semantic_score: adv.includeScores === false ? undefined : scoreMeta.semanticScore,
+                recency_score: adv.includeScores === false ? undefined : scoreMeta.recencyScore,
+                hybrid_score: adv.includeScores === false ? undefined : scoreMeta.hybridScore,
+                source: scoreMeta.source,
+                status: enriched.status,
+                confidence: enriched.confidence,
+                valid_until: enriched.valid_until,
+                superseded_by: enriched.superseded_by,
+                id: m.id || m.uuid || m.memory_id,
+                created_at: m.created_at || m.createdAt,
+                raw: m,
+            };
+        });
+        const summary = vectorMemories.slice(0, Number(adv.summaryMaxFacts || 4)).map(memoryText).filter(Boolean);
+        const contextText = payload.map((message) => String(message.content || '')).join('\n\n');
+        const audit = {
+            kind: 'elefai.brain.context.v1',
+            userId: key,
+            project: project || undefined,
+            query,
+            retrievalMode,
+            payloadFormat,
+            options: {
+                includeContextHeader: adv.includeContextHeader !== false,
+                includeSummary: adv.includeSummary !== false,
+                includeScores: adv.includeScores !== false,
+                includeDiagnostics: Boolean(adv.includeDiagnostics),
+                includeRelations: adv.includeRelations !== false,
+                includeToolHistory: adv.includeToolHistory !== false,
+                includeToolResults: adv.includeToolResults !== false,
+                includeRecentMessages: adv.includeRecentMessages !== false,
+                includeRecentHighlights: adv.includeRecentHighlights !== false,
+                includeOperationalState: adv.includeOperationalState !== false,
+                includeActionLedger: adv.includeActionLedger !== false,
+                includeEntityTimeline: adv.includeEntityTimeline !== false,
+            includeWorkingMemory: adv.includeWorkingMemory !== false,
+            includeDecisionState: adv.includeDecisionState !== false,
+            includeMemoryCompression: adv.includeMemoryCompression !== false,
+            includeContextHealth: true,
+            },
+            context: contextText,
+            summary,
+            connectedModelSummary,
+            contextHealth,
+            contextQualityScore: contextHealth.quality_score,
+            workingMemory,
+            decisionState,
+            memoryCompression,
+            profileFacts: renderProfileFacts(profileFacts),
+            operationalState,
+            actionLedger,
+            entityTimeline,
+            vectorMemories: normalizedVectorMemories,
+            graph,
+            recentMessages,
+            recentHighlights: highlights,
+            toolHistory: {
+                enabled: adv.includeToolHistory !== false,
+                items: adv.includeToolHistory === false ? [] : toolHistory.map((tool) => ({
+                    id: tool.id,
+                    call_id: tool.call_id || tool.id,
+                    turnId: tool.turnId,
+                    turn_id: tool.turn_id || tool.turnId,
+                    sequence: tool.sequence,
+                    name: tool.name,
+                    tool_name: tool.tool_name || tool.name,
+                    input: tool.input,
+                    tool_args: tool.tool_args || tool.input,
+                    normalized_args: tool.normalized_args || tool.input,
+                    ok: tool.ok,
+                    status: tool.status || (tool.ok === false ? 'failed' : 'ok'),
+                    at: tool.at,
+                    timestamp: tool.timestamp || tool.at,
+                    source: tool.source,
+                    result_hash: tool.result_hash || stableHash(tool.result || ''),
+                    args_hash: tool.args_hash || stableHash(tool.input || ''),
+                    dedupe_key: tool.dedupe_key || toolEventKey(tool),
+                    result: adv.includeToolResults === false ? undefined : tool.result,
+                    result_summary: adv.includeToolResults === false ? undefined : (tool.result_summary || tool.result),
+                })),
+            },
+            diagnostics,
+        };
+        return {
+            response: {
+                [memoryKey]: payload,
+                elefaiBrainContext: audit,
+                elefaiBrainContextText: contextText,
+                elefaiBrainSummary: summary,
+                elefaiBrainConnectedModelSummary: connectedModelSummary,
+                elefaiBrainContextHealth: contextHealth,
+                elefaiBrainContextQualityScore: contextHealth.quality_score,
+                elefaiBrainWorkingMemory: workingMemory,
+                elefaiBrainDecisionState: decisionState,
+                elefaiBrainMemoryCompression: memoryCompression,
+                elefaiBrainProfileFacts: renderProfileFacts(profileFacts),
+                elefaiBrainOperationalState: operationalState,
+                elefaiBrainActionLedger: actionLedger,
+                elefaiBrainEntityTimeline: entityTimeline,
+                elefaiBrainVectorMemories: normalizedVectorMemories,
+                elefaiBrainGraph: graph,
+                elefaiBrainRecentMessages: recentMessages,
+                elefaiBrainRecentHighlights: highlights,
+                elefaiBrainToolHistory: audit.toolHistory,
+                elefaiBrainDiagnostics: diagnostics,
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const count = Math.max(items.length, 1);
+        for (let i = 0; i < count; i++) {
+            const memoryKey = this.getNodeParameter('memoryKey', i);
+            const retrievalMode = this.getNodeParameter('retrievalMode', i);
+            const threadId = this.getNodeParameter('threadId', i);
+            const project = this.getNodeParameter('project', i, '');
+            const adv = applyOperationalPreset(this.getNodeParameter('advanced', i, {}) || {});
+            const key = userKeyFrom(threadId, adv, project);
+            const query = asSearchQuery(this.getNodeParameter('query', i, ''));
+            const connectedEmbedding = await getConnectedEmbedding(this, i);
+            let payload;
+            if (retrievalMode === 'semantic' || retrievalMode === 'semanticV2') {
+                const body = { query: String(query || '') };
+                body.user_id = key;
+                if (adv.agentId)
+                    body.agent_id = String(adv.agentId);
+                if (adv.appId)
+                    body.app_id = String(adv.appId);
+                if (adv.runId)
+                    body.run_id = String(adv.runId);
+                if (adv.topK)
+                    body.top_k = Number(adv.topK);
+                if (adv.rerank !== undefined)
+                    body.rerank = Boolean(adv.rerank);
+                if (typeof adv.fields === 'string' && adv.fields)
+                    body.fields = String(adv.fields).split(',').map((f) => f.trim());
+                if (retrievalMode === 'semanticV2') {
+                    try {
+                        const filters = typeof adv.filters === 'string' ? JSON.parse(adv.filters) : (adv.filters || {});
+                        body.filters = filters;
+                    }
+                    catch { }
+                }
+                const url = retrievalMode === 'semanticV2' ? '/v2/memories/search/' : '/v1/memories/search/';
+                const res = connectedEmbedding
+                    ? await searchClientVectorMemories(this, connectedEmbedding, query, body)
+                    : await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', url, body);
+                const memories = Array.isArray(res) ? res : [res];
+                payload = memories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
+            }
+            else {
+                const qs = {};
+                qs.user_id = key;
+                if (adv.agentId)
+                    qs.agent_id = String(adv.agentId);
+                if (adv.appId)
+                    qs.app_id = String(adv.appId);
+                if (adv.runId)
+                    qs.run_id = String(adv.runId);
+                const res = await GenericFunctions_1.mem0ApiRequest.call(this, 'GET', '/v1/memories/', {}, qs);
+                let memories = Array.isArray(res) ? res : [res];
+                if (adv.lastN && Number(adv.lastN) > 0)
+                    memories = memories.slice(-Number(adv.lastN));
+                if (retrievalMode === 'summary') {
+                    const text = memories
+                        .map((m) => m.memory || m.text || m.value)
+                        .filter(Boolean)
+                        .join('\n');
+                    payload = [{ role: 'system', content: `Summary of memories:\n${text}` }];
+                }
+                else {
+                    payload = memories.map((m) => { var _a, _b; return ({ role: 'system', content: (_b = (_a = m.memory) !== null && _a !== void 0 ? _a : m.text) !== null && _b !== void 0 ? _b : JSON.stringify(m) }); });
+                }
+            }
+            const json = {};
+            json[memoryKey] = payload;
+            returnData.push({ json });
+        }
+        return [returnData];
+    }
+}
+exports.Mem0Memory = Mem0Memory;
+exports.__private = {
+    extractToolCallsFromText,
+    extractToolCalls,
+    toolHistoryItemsFromMemory,
+    toolHistoryFromMemory,
+    recentMessageFromMemory,
+    dedupeToolHistory,
+    applyToolHistoryWindow,
+    dedupeRecentMessages,
+    parseToolHistoryMarker,
+    parseRecentMessageMarker,
+    encodeToolCall,
+    encodeRecentMessage,
+    userKeyFrom,
+    applyOperationalPreset,
+    asSearchQuery,
+    canonicalToolInput,
+    buildContextMessages,
+    inferToolGuard,
+    inferUserIntent,
+    deriveWorkingMemory,
+    deriveDecisionState,
+    deriveMemoryCompression,
+    deriveContextHealth,
+    enrichContextMemory,
+    deriveOperationalState,
+    deriveActionLedger,
+    deriveEntityTimeline,
+    scoreOf,
+    scoreMetaOf,
+    extractProfileFactsFromText,
+    mergeProfileFacts,
+    renderProfileFacts,
+    isNoisyProfileValue,
+};