nothumanallowed 13.5.193 → 13.5.195

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.193",
+  "version": "13.5.195",
   "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.193';
+export const VERSION = '13.5.195';
 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,7 +179,7 @@ function detectLanguage(text) {
  * Like chat.mjs but headless — no confirmation prompts, all tools auto-executed.
  * Returns a human-readable summary of what was done.
  */
-async function callAgentWithTools(config, agentName, userMessage, languageOverride) {
+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';
@@ -187,22 +187,26 @@ async function callAgentWithTools(config, agentName, userMessage, languageOverri
   // 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);
+    .replace(/\{\{LANGUAGE\}\}/g, language) +
+    // For Telegram: user confirmation already happened in the chat — execute destructive actions directly
+    '\n\nIMPORTANT: This is a Telegram bot context. The user has already confirmed destructive actions (delete, send, etc.) via chat messages. Execute them immediately without asking again — do NOT describe what you are about to do, just do it and confirm when done.';
 
   // Multi-turn: serialize history as [User]/[Assistant] string (same pattern as chat.mjs)
-  const history = []; // [{role, content}]
+  // preHistory: optional [{role, content}] from previous conversation turn (for sticky confirmations)
+  const history = preHistory ? [...preHistory] : [];
   let finalText = '';
+  let lastToolResults = null; // saved for context return
 
-  for (let round = 0; round < 3; round++) {
+  for (let round = 0; round < 4; round++) {
     // Build serialized message
     const parts = history.map(h => (h.role === 'user' ? '[User]' : '[Assistant]') + ' ' + h.content);
     parts.push('[User] ' + userMessage);
-    if (round > 0) {
-      // Replace last user with tool results continuation
-    }
     const serialized = parts.join('\n\n');
 
     const response = await callLLM(config, systemPrompt, serialized);
@@ -226,13 +230,14 @@ 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.';
   }
 
-  return finalText || 'Done.';
+  return { text: finalText || 'Done.', history, lastToolResults };
 }
 
 // ── Telegram Bot (Long Polling via native fetch) ─────────────────────────────
@@ -587,17 +592,24 @@ class TelegramResponder {
 
       let agent;
       let enrichedMessage = cleanText;
+      let preHistory = null;
       if (useStickyAgent) {
         agent = lastCtx.agent;
-        // Inject previous turn context so agent understands what "Sì" refers to
-        const nl = '\n';
-        enrichedMessage =
-          '[Conversazione precedente]' + nl +
-          'Utente: ' + lastCtx.userMsg + nl +
-          'Tu (' + agent.toUpperCase() + '): ' + lastCtx.agentReply.slice(0, 400) + nl + nl +
-          '[Nuovo messaggio utente]' + nl +
-          cleanText;
-        this.log(`[Telegram] ${fromUser}: sticky agent ${agent.toUpperCase()} (ambiguous message, last ctx ${Math.round(stickyAge/1000)}s ago)`);
+        // 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)`);
       } else {
         agent = routeMessage(cleanText, this.autoRoute);
         this.log(`[Telegram] ${fromUser} (chat ${chatId}): routed to ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}`);
@@ -620,25 +632,30 @@ class TelegramResponder {
       // 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 response;
+      let responseText;
+      let responseHistory = null;
       if (TOOL_AGENTS.has(agent)) {
-        response = await callAgentWithTools(this.config, agent, enrichedMessage, detectedLang);
+        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}] ` : '';
-        response = await callAgent(this.config, agent, langInstruction + enrichedMessage);
+        responseText = await callAgent(this.config, agent, langInstruction + enrichedMessage);
       }
 
       // Truncate if too long for Telegram (4096 char limit)
-      const truncated = response.length > 4000
-        ? response.slice(0, 3950) + '\n\n... [truncated]'
-        : response;
+      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
       this._lastContextByChatId[chatId] = {
         agent,
         userMsg: cleanText,
-        agentReply: response,
+        agentReply: responseText,
+        history: responseHistory,
         ts: Date.now(),
       };
       this._lastAgentByChatId[chatId] = agent;
@@ -649,7 +666,7 @@ class TelegramResponder {
         text: `[${agent.toUpperCase()}]\n\n${truncated}`,
       });
 
-      this.log(`[Telegram] Responded to ${fromUser} via ${agent.toUpperCase()} (${response.length} chars)`);
+      this.log(`[Telegram] Responded to ${fromUser} via ${agent.toUpperCase()} (${responseText.length} chars)`);
     } catch (err) {
       this.log(`[Telegram] Agent call failed: ${err.message}`);
       // Send error message to user