nothumanallowed 13.5.194 → 13.5.196

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.194",
+  "version": "13.5.196",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '13.5.194';
+export const VERSION = '13.5.196';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -9,7 +9,7 @@
  */
 
 import { callAgent, callLLM } from './llm.mjs';
-import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS } from './tool-executor.mjs';
+import { buildSystemPrompt, parseActions, executeTool, TOOL_DEFINITIONS, LIARA_TOOL_DEFINITIONS } from './tool-executor.mjs';
 import https from 'https';
 import http from 'http';
 import { URL } from 'url';
@@ -179,27 +179,77 @@ function detectLanguage(text) {
  * Like chat.mjs but headless — no confirmation prompts, all tools auto-executed.
  * Returns a human-readable summary of what was done.
  */
+// Detect if a message is a reaction/continuation (not a new independent request)
+// Used to decide whether to use sticky agent context
+function isContinuationMessage(text, lastCtx) {
+  if (!lastCtx) return false;
+  const lower = text.toLowerCase().trim();
+
+  // Explicit confirmations / reactions
+  const CONFIRMATIONS = ['sì','si','yes','ok','okay','procedi','fallo','vai','confermo','cancellalo',
+    'eliminalo','mandalo','esegui','perfetto','giusto','corretto','fatto','bene','certo','esatto',
+    'assolutamente','ovviamente','naturalmente','ciao','avanti','go','do it','proceed','confirm',
+    'sure','yep','yup','please','per favore','grazie','thanks'];
+  if (CONFIRMATIONS.some(c => lower === c || lower.startsWith(c + ' ') || lower.endsWith(' ' + c))) return true;
+
+  // Negative reactions that refer to previous turn (not new requests)
+  const REACTIONS = ['no','nope','annulla','stop','lascia perdere','non farlo','aspetta',
+    'sbagliato','non è quello','con cazzo','impossibile','stai scherzando','non ci credo',
+    'ma va','davvero','sicuro','sei sicuro','ma sei sicuro','ancora','di nuovo','riprova'];
+  if (REACTIONS.some(r => lower === r || lower.startsWith(r + ' ') || lower.endsWith(' ' + r))) return true;
+
+  // Short messages (≤ 6 words) without clear new-request keywords are likely continuations
+  const words = lower.split(/\s+/);
+  if (words.length <= 6) {
+    const NEW_REQUEST_KEYWORDS = ['calendario','appuntamento','email','posta','meteo','tempo',
+      'crea','aggiungi','cerca','trova','mostra','mandami','dimmi','quanto','quando','dove',
+      'create','add','find','search','show','send','delete','cancel','weather','mail','event'];
+    const hasNewKeyword = NEW_REQUEST_KEYWORDS.some(k => lower.includes(k));
+    if (!hasNewKeyword) return true;
+  }
+
+  return false;
+}
+
+// Detect if the last agent response indicates a completed action (context should reset after)
+function isCompletedAction(text) {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  const DONE_SIGNALS = ['cancellato con successo','eliminato con successo','evento eliminato',
+    'evento cancellato','deleted successfully','removed successfully','email inviata','email sent',
+    'draft created','bozza creata','aggiornato con successo','updated successfully',
+    'task completato','task done','creato con successo','created successfully',
+    'spostato con successo','moved successfully'];
+  return DONE_SIGNALS.some(s => lower.includes(s));
+}
+
 async function callAgentWithTools(config, agentName, userMessage, languageOverride, preHistory) {
   const today = new Date().toISOString().split('T')[0];
   const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
   const locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en';
   const LANG_MAP = { en: 'English', it: 'Italian', es: 'Spanish', fr: 'French', de: 'German', pt: 'Portuguese', nl: 'Dutch', pl: 'Polish', ru: 'Russian', ja: 'Japanese', ko: 'Korean', zh: 'Chinese', ar: 'Arabic', hi: 'Hindi', tr: 'Turkish' };
-  // Priority: explicit override (from message text detection) → config setting → system locale
   const language = languageOverride || config?.profile?.language || config?.language || LANG_MAP[locale.split('-')[0]] || 'English';
 
-  const systemPrompt = TOOL_DEFINITIONS
+  // Use compact Liara prompt when provider is 'nha' (same logic as buildSystemPrompt)
+  const isLiara = config?.llm?.provider === 'nha';
+  const baseDefinitions = isLiara ? LIARA_TOOL_DEFINITIONS : TOOL_DEFINITIONS;
+  const systemPrompt = baseDefinitions
     .replace('{{TODAY}}', today)
     .replace('{{TIMEZONE}}', tz)
-    .replace(/\{\{LANGUAGE\}\}/g, language);
-
-  // Multi-turn: serialize history as [User]/[Assistant] string (same pattern as chat.mjs)
-  // preHistory: optional [{role, content}] from previous conversation turn (for sticky confirmations)
+    .replace(/\{\{LANGUAGE\}\}/g, language) +
+    // Telegram context: execute destructive actions immediately, user already confirmed via chat
+    '\n\nTELEGRAM BOT RULES:\n' +
+    '- Execute ALL actions (including delete, cancel, send) IMMEDIATELY when the user confirms. Never say "I need an ID" if you can search for the event yourself using calendar_find.\n' +
+    '- When you find an event with calendar_find, include its eventId in your reply so the user sees it.\n' +
+    '- After completing an action, confirm it simply and clearly. Do not loop back asking for more info.\n' +
+    '- If the user says "procedi", "sì", "fallo", "cancellalo" etc. — they are confirming. Execute the action.\n' +
+    '- Never ask the user to provide an eventId manually — always search with calendar_find first.';
+
+  // preHistory: full conversation history from previous turn (for sticky confirmations)
   const history = preHistory ? [...preHistory] : [];
   let finalText = '';
-  let lastToolResults = null; // saved for context return
 
-  for (let round = 0; round < 4; round++) {
-    // Build serialized message
+  for (let round = 0; round < 5; round++) {
     const parts = history.map(h => (h.role === 'user' ? '[User]' : '[Assistant]') + ' ' + h.content);
     parts.push('[User] ' + userMessage);
     const serialized = parts.join('\n\n');
@@ -208,13 +258,11 @@ async function callAgentWithTools(config, agentName, userMessage, languageOverri
     const { textParts, actions } = parseActions(response);
 
     if (actions.length === 0) {
-      // Final round — no tools, just text for the user
       finalText = textParts.join('\n').trim();
       break;
     }
-    // Intermediate round with tools — don't expose tool-call JSON to the user
 
-    // Execute all tools and collect results
+    // Execute all tools
     const toolResults = [];
     for (const { action, params } of actions) {
       try {
@@ -225,14 +273,12 @@ async function callAgentWithTools(config, agentName, userMessage, languageOverri
         toolResults.push(`[${action}] Error: ${err.message}`);
       }
     }
-    lastToolResults = toolResults;
 
-    // Feed results back: append assistant response + tool results as next user turn
     history.push({ role: 'assistant', content: response });
-    userMessage = 'Tool results:\n' + toolResults.join('\n') + '\n\nNow give the user a concise confirmation in ' + language + '. Do NOT use HERALD format — respond conversationally.';
+    userMessage = 'Tool results:\n' + toolResults.join('\n') + '\n\nNow give the user a short, clear confirmation in ' + language + '. Be direct — no preamble, no HERALD format. If an action was completed, say so clearly.';
   }
 
-  return { text: finalText || 'Done.', history, lastToolResults };
+  return { text: finalText || 'Fatto.', history };
 }
 
 // ── Telegram Bot (Long Polling via native fetch) ─────────────────────────────
@@ -577,37 +623,33 @@ class TelegramResponder {
 
     this.pendingRequests++;
     try {
-      // Sticky agent: for short/ambiguous messages (< 6 words), reuse last agent for this chat
-      // This handles confirmation messages like "Sì", "Ok", "Fallo", "Confermo", etc.
-      const wordCount = cleanText.trim().split(/\s+/).length;
-      const isAmbiguous = wordCount <= 5;
       const lastCtx = this._lastContextByChatId[chatId];
       const stickyAge = lastCtx ? (Date.now() - lastCtx.ts) : Infinity;
-      const useStickyAgent = isAmbiguous && lastCtx && stickyAge < 5 * 60 * 1000; // sticky for 5 min
+      const withinStickyWindow = stickyAge < 5 * 60 * 1000; // 5 min
+
+      // Determine if this message is a continuation of the previous turn
+      // (confirmation, reaction, short reply) vs a new independent request
+      const isContinuation = withinStickyWindow && isContinuationMessage(cleanText, lastCtx);
+
+      // If last response was a completed action, don't carry history forward —
+      // the next message is a fresh request even if it looks like a reaction
+      const lastWasCompleted = lastCtx && isCompletedAction(lastCtx.agentReply);
 
       let agent;
       let enrichedMessage = cleanText;
       let preHistory = null;
-      if (useStickyAgent) {
+
+      if (isContinuation && !lastWasCompleted) {
+        // Continue with same agent and inject full history for context
         agent = lastCtx.agent;
-        // Re-inject the full conversation history from last turn so the agent
-        // has the eventId/context already and can proceed directly (e.g. calendar_delete)
         if (lastCtx.history && lastCtx.history.length > 0) {
           preHistory = lastCtx.history;
-        } else {
-          // Fallback: text-only context injection
-          const nl = '\n';
-          enrichedMessage =
-            '[Conversazione precedente]' + nl +
-            'Utente: ' + lastCtx.userMsg + nl +
-            'Tu (' + agent.toUpperCase() + '): ' + lastCtx.agentReply.slice(0, 600) + nl + nl +
-            '[Nuovo messaggio utente — è una conferma/risposta al turno precedente]' + nl +
-            cleanText;
         }
-        this.log(`[Telegram] ${fromUser}: sticky agent ${agent.toUpperCase()} (ambiguous, last ctx ${Math.round(stickyAge/1000)}s ago, preHistory=${preHistory ? preHistory.length : 0} turns)`);
+        this.log(`[Telegram] ${fromUser}: continuation → ${agent.toUpperCase()} (ctx ${Math.round(stickyAge/1000)}s ago, history=${preHistory ? preHistory.length : 0})`);
       } else {
+        // Fresh request — route normally
         agent = routeMessage(cleanText, this.autoRoute);
-        this.log(`[Telegram] ${fromUser} (chat ${chatId}): routed to ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}`);
+        this.log(`[Telegram] ${fromUser}: new request → ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}${lastWasCompleted ? ' [prev completed]' : ''}`);
       }
 
       // Broadcast event
@@ -620,48 +662,43 @@ class TelegramResponder {
       // Send typing indicator
       await this._telegramCall('sendChatAction', { chat_id: chatId, action: 'typing' });
 
-      // Detect language from the message text — overrides system locale
-      // For sticky context, use lang from previous turn if current message is ambiguous
+      // Language: detect from message, fallback to previous turn's language
       const detectedLang = detectLanguage(cleanText) || (lastCtx ? detectLanguage(lastCtx.userMsg) : null);
 
-      // Tool-capable agents use the full tool execution loop
-      // Pure reasoning/analysis agents use the simple callAgent (no tools)
       const TOOL_AGENTS = new Set(['herald', 'hermes', 'edi', 'jarvis', 'flux', 'echo', 'mercury', 'pipe', 'navi', 'link', 'prometheus', 'tempest']);
       let responseText;
       let responseHistory = null;
+
       if (TOOL_AGENTS.has(agent)) {
         const result = await callAgentWithTools(this.config, agent, enrichedMessage, detectedLang, preHistory);
         responseText = result.text;
         responseHistory = result.history;
       } else {
-        // For non-tool agents: inject language instruction into the message
         const langInstruction = detectedLang ? `[Respond in ${detectedLang}] ` : '';
         responseText = await callAgent(this.config, agent, langInstruction + enrichedMessage);
       }
 
-      // Truncate if too long for Telegram (4096 char limit)
+      // Truncate to Telegram limit (4096 chars)
       const truncated = responseText.length > 4000
         ? responseText.slice(0, 3950) + '\n\n... [truncated]'
         : responseText;
 
-      // Save context for sticky agent continuity (next short message reuses this agent)
-      // Save full history so next confirmation turn has the eventId already resolved
+      // Save context — if action was completed, mark it so next turn starts fresh
       this._lastContextByChatId[chatId] = {
         agent,
         userMsg: cleanText,
         agentReply: responseText,
-        history: responseHistory,
+        history: isCompletedAction(responseText) ? null : responseHistory, // clear history after success
         ts: Date.now(),
       };
       this._lastAgentByChatId[chatId] = agent;
 
-      // Send response as plain text — no parse_mode to avoid Markdown entity parse errors
       await this._telegramCall('sendMessage', {
         chat_id: chatId,
         text: `[${agent.toUpperCase()}]\n\n${truncated}`,
       });
 
-      this.log(`[Telegram] Responded to ${fromUser} via ${agent.toUpperCase()} (${responseText.length} chars)`);
+      this.log(`[Telegram] Responded to ${fromUser} via ${agent.toUpperCase()} (${responseText.length} chars)${isCompletedAction(responseText) ? ' [action completed — context reset]' : ''}`);
     } catch (err) {
       this.log(`[Telegram] Agent call failed: ${err.message}`);
       // Send error message to user