nothumanallowed 13.5.191 → 13.5.193

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.5.191",
+  "version": "13.5.193",
   "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.191';
+export const VERSION = '13.5.193';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/message-responder.mjs

@@ -207,9 +207,13 @@ async function callAgentWithTools(config, agentName, userMessage, languageOverri
 
     const response = await callLLM(config, systemPrompt, serialized);
     const { textParts, actions } = parseActions(response);
-    finalText = textParts.join('\n').trim();
 
-    if (actions.length === 0) break; // No tools — pure text 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
     const toolResults = [];
@@ -313,6 +317,9 @@ class TelegramResponder {
     this.maxConcurrent = 3;
     this._updateCheckTimer = null;
     this._lastNotifiedVersion = null;
+    // Per-chat sticky agent: remembers last agent used, plus last turn context
+    this._lastAgentByChatId = {};       // chatId → agentName
+    this._lastContextByChatId = {};     // chatId → { agent, userMsg, agentReply, ts }
   }
 
   get enabled() {
@@ -359,11 +366,10 @@ class TelegramResponder {
       if (chatIds.length === 0) return;
 
       const msg =
-        `🆕 *NHA v${latest} disponibile!*\n\n` +
+        `🆕 NHA v${latest} disponibile!\n\n` +
         `Una nuova versione di NotHumanAllowed è stata pubblicata.\n\n` +
-        `Aggiorna con:\n` +
-        `\`npm install -g nothumanallowed@latest\`\n\n` +
-        `Poi riavvia il bot con: \`nha responder restart\``;
+        `Aggiorna con:\nnpm install -g nothumanallowed@latest\n\n` +
+        `Poi riavvia il bot con: nha ops stop && nha ops start`;
 
       this.log(`[Telegram] Broadcasting update notification v${latest} to ${chatIds.length} users`);
 
@@ -372,7 +378,6 @@ class TelegramResponder {
           await this._telegramCall('sendMessage', {
             chat_id: parseInt(chatId, 10),
             text: msg,
-            parse_mode: 'Markdown',
           });
         } catch {
           // User blocked bot or chat no longer exists — ignore
@@ -572,8 +577,31 @@ class TelegramResponder {
 
     this.pendingRequests++;
     try {
-      const agent = routeMessage(cleanText, this.autoRoute);
-      this.log(`[Telegram] ${fromUser} (chat ${chatId}): routed to ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}`);
+      // 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
+
+      let agent;
+      let enrichedMessage = cleanText;
+      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)`);
+      } else {
+        agent = routeMessage(cleanText, this.autoRoute);
+        this.log(`[Telegram] ${fromUser} (chat ${chatId}): routed to ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}`);
+      }
 
       // Broadcast event
       this.wsBroadcast({
@@ -586,18 +614,19 @@ class TelegramResponder {
       await this._telegramCall('sendChatAction', { chat_id: chatId, action: 'typing' });
 
       // Detect language from the message text — overrides system locale
-      const detectedLang = detectLanguage(cleanText);
+      // For sticky context, use lang from previous turn if current message is ambiguous
+      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 response;
       if (TOOL_AGENTS.has(agent)) {
-        response = await callAgentWithTools(this.config, agent, cleanText, detectedLang);
+        response = await callAgentWithTools(this.config, agent, enrichedMessage, detectedLang);
       } else {
         // For non-tool agents: inject language instruction into the message
         const langInstruction = detectedLang ? `[Respond in ${detectedLang}] ` : '';
-        response = await callAgent(this.config, agent, langInstruction + cleanText);
+        response = await callAgent(this.config, agent, langInstruction + enrichedMessage);
       }
 
       // Truncate if too long for Telegram (4096 char limit)
@@ -605,6 +634,15 @@ class TelegramResponder {
         ? response.slice(0, 3950) + '\n\n... [truncated]'
         : response;
 
+      // Save context for sticky agent continuity (next short message reuses this agent)
+      this._lastContextByChatId[chatId] = {
+        agent,
+        userMsg: cleanText,
+        agentReply: response,
+        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,

package/src/services/tool-executor.mjs

@@ -21,6 +21,7 @@ import {
   getEventsForDate,
   createEvent,
   updateEvent,
+  deleteEvent,
   listEvents,
   markAsRead,
   markAsUnread,
@@ -74,6 +75,7 @@ export const DESTRUCTIVE_ACTIONS = new Set([
   'calendar_create',
   'calendar_move',
   'calendar_update',
+  'calendar_delete',
   'contact_delete',
   'task_done',
   'task_delete',
@@ -171,7 +173,11 @@ TOOLS:
     Update ANY field of an existing calendar event: title, location, description, start time, end time.
     You MUST call calendar_find first to get the eventId. Only include fields that need to change. ALWAYS confirm before updating.
 
-19. schedule_meeting(clientName: string, subject: string, location: string, durationMinutes: number, dateFrom: string, dateTo: string, workdayStart?: number, workdayEnd?: number)
+19. calendar_delete(eventId: string)
+    Delete (permanently remove) a calendar event by its eventId.
+    You MUST call calendar_find first to get the eventId. ALWAYS confirm with the user before deleting.
+
+20. schedule_meeting(clientName: string, subject: string, location: string, durationMinutes: number, dateFrom: string, dateTo: string, workdayStart?: number, workdayEnd?: number)
     Find optimal meeting slots considering existing calendar events, locations, and estimated travel time between appointments. Returns ranked slots with travel info. dateFrom and dateTo are YYYY-MM-DD.
 
 20. schedule_draft_email(clientName: string, subject: string, location: string, durationMinutes: number, dateFrom: string, dateTo: string)
@@ -600,7 +606,7 @@ Never output a JSON block as a suggestion — every block executes immediately.
 AVAILABLE TOOLS:
 gmail_list · gmail_read · gmail_send · gmail_draft · gmail_reply · gmail_mark_read · gmail_mark_unread · gmail_archive · gmail_delete · gmail_send_attach
 imap_accounts · imap_list · imap_read · imap_send · imap_sync · imap_labels · imap_mark_read · imap_reply · imap_thread · imap_search · imap_mark_starred · imap_trash · imap_draft · imap_send_template · imap_bulk_send
-calendar_today · calendar_tomorrow · calendar_date · calendar_upcoming · calendar_week · calendar_create · calendar_move · calendar_find · calendar_update · schedule_meeting · schedule_draft_email
+calendar_today · calendar_tomorrow · calendar_date · calendar_upcoming · calendar_week · calendar_create · calendar_move · calendar_find · calendar_update · calendar_delete · schedule_meeting · schedule_draft_email
 task_list · task_add · task_done · task_move · task_delete · task_clear · task_edit
 contact_search · contact_add · contact_update · contact_delete
 gtask_list · gtask_add · gtask_complete
@@ -630,12 +636,19 @@ maps_directions · notify_remind · birthdays_upcoming · birthday_add · execut
 export function parseActions(text) {
   const actions = [];
   const textParts = [];
+
+  // Normalize: some LLMs output "json ... " (double-quote fences) instead of ```json ... ```
+  // Replace "json\n{...}\n" patterns with proper ```json fences before parsing
+  const normalized = text
+    .replace(/"json\s*\n([\s\S]*?)\n\s*"/g, (_, body) => '```json\n' + body.trim() + '\n```')
+    .replace(/'json\s*\n([\s\S]*?)\n\s*'/g, (_, body) => '```json\n' + body.trim() + '\n```');
+
   const fenceRegex = /```json\s*\n?([\s\S]*?)```/g;
   let lastIndex = 0;
   let match;
 
-  while ((match = fenceRegex.exec(text)) !== null) {
-    const before = text.slice(lastIndex, match.index).trim();
+  while ((match = fenceRegex.exec(normalized)) !== null) {
+    const before = normalized.slice(lastIndex, match.index).trim();
     if (before) textParts.push(before);
 
     try {
@@ -650,9 +663,30 @@ export function parseActions(text) {
     lastIndex = match.index + match[0].length;
   }
 
-  const trailing = text.slice(lastIndex).trim();
+  const trailing = normalized.slice(lastIndex).trim();
   if (trailing) textParts.push(trailing);
 
+  // Fallback: if no fenced blocks found, scan for bare {"action": ...} objects in the text
+  if (actions.length === 0) {
+    const bareRegex = /\{[\s\S]*?"action"\s*:\s*"[^"]+[\s\S]*?\}/g;
+    let bareMatch;
+    const consumed = new Set();
+    while ((bareMatch = bareRegex.exec(text)) !== null) {
+      try {
+        const parsed = JSON.parse(bareMatch[0]);
+        if (parsed.action && typeof parsed.action === 'string' && !consumed.has(bareMatch[0])) {
+          actions.push({ action: parsed.action, params: parsed.params || {} });
+          consumed.add(bareMatch[0]);
+        }
+      } catch { /* not valid JSON, skip */ }
+    }
+    // If we found bare actions, rebuild textParts stripping out the JSON blobs
+    if (actions.length > 0) {
+      const cleaned = text.replace(/\{[\s\S]*?"action"\s*:\s*"[^"]+[\s\S]*?\}/g, '').trim();
+      return { textParts: cleaned ? [cleaned] : [], actions };
+    }
+  }
+
   return { textParts, actions };
 }
 
@@ -1318,6 +1352,25 @@ export async function executeTool(action, params, config) {
       return `Event updated successfully (${changes}). ${params.location ? `New location: ${params.location}` : ''}`;
     }
 
+    case 'calendar_delete': {
+      if (!params.eventId) return 'eventId required. Call calendar_find first to get the eventId.';
+      // Smart eventId resolution: if it looks like a name instead of a Google Calendar ID, search for it
+      let delEventId = params.eventId;
+      if (delEventId && (delEventId.includes(' ') || delEventId.length < 10 || /[A-Z]/.test(delEventId))) {
+        const fromD = new Date();
+        const toD = new Date(fromD.getTime() + 60 * 86400000);
+        const evts = await listEvents(config, 'primary', fromD, toD);
+        const m = evts.find(e => (e.summary || '').toLowerCase().includes(delEventId.toLowerCase()));
+        if (m) {
+          delEventId = m.id;
+        } else {
+          return `Could not find event matching "${params.eventId}" in the next 60 days. Use calendar_find to search first.`;
+        }
+      }
+      await deleteEvent(config, 'primary', delEventId);
+      return `Event deleted successfully.`;
+    }
+
     // ── Smart Scheduling ──────────────────────────────────────────────────
     case 'schedule_meeting': {
       const slots = await findAvailableSlots(config, {