n8n-nodes-tembory 1.1.25 → 1.1.26

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

@@ -1859,21 +1859,73 @@ const deriveNextExpectedAction = (intent, operationalState = {}) => {
     return 'continue according to the agent prompt using retrieved context; call tools when the agent prompt or tool policy requires them';
 };
 const isGenericMemoryNextAction = (value = '') => /answer using retrieved context and avoid unnecessary tool calls|continue according to the agent prompt using retrieved context/i.test(String(value || ''));
+const shouldCarryPreviousGoal = (intent = '', previousGoal = '') => {
+    if (!previousGoal || isGenericMemoryNextAction(previousGoal))
+        return false;
+    return ['general_message', 'profile_update', 'unknown'].includes(intent);
+};
 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 chronological = sortConversationChronological(recentMessages || []);
+    const userMessages = chronological.filter((msg) => /^(user|human)$/i.test(String(msg.role || '')));
+    const assistantMessages = chronological.filter((msg) => /^(assistant|ai|agent)$/i.test(String(msg.role || '')));
+    const normalizedQuery = normalizeIntentText(query).trim();
+    const lastUser = [...userMessages].reverse().find((msg) => /^(user|human)$/i.test(String(msg.role || '')));
+    const priorUser = [...userMessages].reverse().find((msg) => normalizeIntentText(msg.content).trim() !== normalizedQuery);
+    const lastAssistant = assistantMessages[assistantMessages.length - 1] || null;
     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;
+    const toolState = (operationalState || {}).tool_state || {};
     const nextExpectedAction = deriveNextExpectedAction(intent, operationalState);
+    const carryPreviousGoal = shouldCarryPreviousGoal(intent, previous.current_goal);
+    const currentGoal = carryPreviousGoal ? previous.current_goal : nextExpectedAction;
+    const toolNames = Array.from(new Set((toolHistory || []).map((tool) => tool.name || tool.tool_name || tool.tool).filter(Boolean)));
+    const currentTurnMayNeedTool = ['affirm', 'commit_or_continue', 'tool_action_candidate', 'selection_or_slot'].includes(intent);
     return {
-        current_goal: previous.current_goal && !isGenericMemoryNextAction(previous.current_goal) ? previous.current_goal : nextExpectedAction,
+        current_goal: currentGoal,
+        current_goal_reason: carryPreviousGoal ? 'carried_from_previous_non_generic_goal' : 'derived_from_current_turn_intent',
         current_task: nextExpectedAction,
         last_user_intent: intent,
         last_user_message: lastUser ? truncate(lastUser.content, 500) : truncate(query, 500),
+        conversation_digest: cleanContextValue({
+            messages: chronological.length,
+            user_messages: userMessages.length,
+            assistant_messages: assistantMessages.length,
+            current_user: truncate(query, 220),
+            prior_user: priorUser ? { content: truncate(priorUser.content, 180), at: priorUser.at } : undefined,
+            last_assistant: lastAssistant ? { content: truncate(lastAssistant.content, 180), at: lastAssistant.at } : undefined,
+        }),
+        tool_digest: cleanContextValue({
+            total: Array.isArray(toolHistory) ? toolHistory.length : 0,
+            ok: (operationalState || {}).tool_counts?.ok,
+            failed: (operationalState || {}).tool_counts?.failed,
+            names: toolNames.slice(0, 12),
+            last_successful: toolState.last_successful_tool ? {
+                name: toolState.last_successful_tool.name,
+                at: toolState.last_successful_tool.at,
+                status: toolState.last_successful_tool.status || 'ok',
+            } : undefined,
+            failed_by_name: toolState.failed_by_name,
+        }),
+        turn_flags: cleanContextValue({
+            recall_only: intent === 'conversation_recall',
+            status_question: intent === 'operational_status_question',
+            current_turn_may_need_tool: currentTurnMayNeedTool,
+            has_prior_tools: Array.isArray(toolHistory) && toolHistory.length > 0,
+            has_profile_facts: activeEntities.length > 0,
+            carry_previous_goal: carryPreviousGoal,
+        }),
+        context_sources: cleanContextValue({
+            conversation: chronological.length > 0,
+            tool_history: Array.isArray(toolHistory) && toolHistory.length > 0,
+            operational_state: Boolean((operationalState || {}).tool_state || (operationalState || {}).tool_counts),
+            profile_facts: activeEntities.length > 0,
+        }),
+        agent_guidance: nextExpectedAction,
         active_entities: activeEntities,
         open_decisions: previous.open_decisions || [],
         last_error: lastTool && lastTool.ok === false ? { tool: lastTool.name, at: lastTool.at, result: lastTool.result } : null,
@@ -2148,9 +2200,15 @@ const cleanContextValue = (value) => {
 };
 const compactWorkingMemoryForAgent = (memory = {}) => cleanContextValue({
     current_goal: memory.current_goal,
+    current_goal_reason: memory.current_goal_reason,
     current_task: memory.current_task,
     last_user_intent: memory.last_user_intent,
     last_user_message: truncate(memory.last_user_message, 220),
+    conversation_digest: memory.conversation_digest,
+    tool_digest: memory.tool_digest,
+    turn_flags: memory.turn_flags,
+    context_sources: memory.context_sources,
+    agent_guidance: memory.agent_guidance,
     active_entities: memory.active_entities,
     open_decisions: memory.open_decisions,
     last_error: memory.last_error,
@@ -2543,10 +2601,16 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         });
         summary.workingMemory = cleanContextValue({
             currentGoal: parsed.workingMemory?.current_goal,
+            currentGoalReason: parsed.workingMemory?.current_goal_reason,
             currentTask: parsed.workingMemory?.current_task,
             nextExpectedAction: parsed.workingMemory?.next_expected_action,
             lastUserIntent: parsed.workingMemory?.last_user_intent,
             lastUserMessage: parsed.workingMemory?.last_user_message ? truncate(parsed.workingMemory.last_user_message, 220) : undefined,
+            conversation: parsed.workingMemory?.conversation_digest,
+            tools: parsed.workingMemory?.tool_digest,
+            turnFlags: parsed.workingMemory?.turn_flags,
+            contextSources: parsed.workingMemory?.context_sources,
+            agentGuidance: parsed.workingMemory?.agent_guidance,
         });
         summary.decisionState = cleanContextValue({
             currentIntent: parsed.decisionState?.current_intent,

package/package.json

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