nothumanallowed 13.5.192 → 13.5.194

package/package.json

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

package/src/services/message-responder.mjs

@@ -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';
@@ -193,23 +193,26 @@ async function callAgentWithTools(config, agentName, userMessage, languageOverri
     .replace(/\{\{LANGUAGE\}\}/g, language);
 
   // 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);
     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 = [];
@@ -222,13 +225,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) ─────────────────────────────
@@ -583,17 +587,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]' : ''}`);
@@ -616,25 +627,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;
@@ -645,7 +661,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

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, {