nothumanallowed 15.1.47 → 15.1.48

package/package.json

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

package/src/server/routes/chat.mjs

@@ -16,7 +16,7 @@ import {
 } from '../../services/conversations.mjs';
 import { callLLMStream, callLLM, callLLMVision, parseAgentFile } from '../../services/llm.mjs';
 import { buildMemoryContext } from '../../services/memory.mjs';
-import { parseActions, executeTool, buildSystemPrompt } from '../../services/tool-executor.mjs';
+import { parseActions, executeTool, buildSystemPrompt, stripOrphanFences } from '../../services/tool-executor.mjs';
 
 // Migrate on import (once)
 migrateOldHistory();
@@ -275,17 +275,59 @@ export function register(router) {
           a.params = { url: 'https://' + a.params.query.trim() };
         }
       }
-      // Auto-detect email reading intent — force imap_list if LLM didn't emit the tool
+      // Auto-detect email reading intent — force the right IMAP tool if the
+      // LLM didn't emit one. Semantic keywords (offerta/RFQ/preventivo/...)
+      // trigger `imap_search` across all synced messages with each variant,
+      // because users almost never want "just the 5 latest" — they want
+      // "everything matching X". Generic "leggi le email" still falls back
+      // to imap_list. Multi-language: it/en/de/fr/es.
+      const lower = msg.toLowerCase();
       const wantsReadEmail = /\b(leggi|read|mostra|lista|ultime?|recenti?|email|mail|inbox|posta)\b.*\b(email|mail|messag|inbox|posta)\b|\b(email|mail)\b.*\b(leggi|read|mostra|lista|ultime?|recenti?)\b/i.test(msg);
-      if (wantsReadEmail && !actions.some(a => a.action?.startsWith('imap_') || a.action === 'list_emails')) {
+      // Semantic intent → quote / offer / proposal / order requests
+      const QUOTE_KEYWORDS = {
+        offerta:    ['offerta', 'richiesta offerta', 'richiesta di offerta', 'preventivo', 'quotazione', 'rdo', 'rda'],
+        quote:      ['quote', 'quotation', 'rfq', 'rfp', 'request for quote', 'request for proposal', 'price request', 'pricing'],
+        order:      ['ordine', 'order', 'po ', 'purchase order', 'commessa', 'bestellung', 'commande'],
+        invoice:    ['fattura', 'invoice', 'rechnung', 'facture'],
+        proposal:   ['proposta', 'proposal', 'angebot', 'devis'],
+      };
+      let semanticBag = null;
+      if (/\b(offert|preventiv|quotaz|rdo\b|rda\b|quotation|rfq|rfp|request\s+for\s+(quote|proposal|pricing)|price\s+request|pricing|angebot|devis|proposta|proposal)/i.test(lower)) {
+        semanticBag = 'offerta';
+      } else if (/\b(ordin|order|purchase\s+order|po\s+\d|commessa|bestellung|commande)/i.test(lower)) {
+        semanticBag = 'order';
+      } else if (/\b(fattur|invoice|rechnung|facture)/i.test(lower)) {
+        semanticBag = 'invoice';
+      } else if (/\b(propost|proposal|angebot|devis)/i.test(lower)) {
+        semanticBag = 'proposal';
+      }
+
+      if ((wantsReadEmail || semanticBag) && !actions.some(a => a.action?.startsWith('imap_') || a.action === 'list_emails')) {
         try {
           const { listAccounts: _la } = await import('../../services/email-db.mjs');
           const imapAccs = _la();
           if (imapAccs.length > 0) {
             const firstAcc = imapAccs[0];
-            const limitMatch = msg.match(/\b(\d+)\b/);
-            const limit = limitMatch ? Math.min(parseInt(limitMatch[1]), 20) : 5;
-            actions.push({ action: 'imap_list', params: { accountId: firstAcc.id, limit } });
+            if (semanticBag) {
+              // Push one imap_search per keyword variant in the bag. The
+              // synthesis step will dedupe overlapping hits. We default to a
+              // 60-day window (limit=80 per query) — much wider than the
+              // 5-email peek the old branch did.
+              const bag = QUOTE_KEYWORDS[semanticBag] || [];
+              const variants = [
+                ...(QUOTE_KEYWORDS.offerta || []).slice(0, 3),
+                ...(QUOTE_KEYWORDS.quote   || []).slice(0, 3),
+                ...bag,
+              ];
+              const unique = [...new Set(variants)].slice(0, 6);
+              for (const q of unique) {
+                actions.push({ action: 'imap_search', params: { accountId: firstAcc.id, query: q, limit: 50 } });
+              }
+            } else {
+              const limitMatch = msg.match(/\b(\d+)\b/);
+              const limit = limitMatch ? Math.min(parseInt(limitMatch[1]), 50) : 20;
+              actions.push({ action: 'imap_list', params: { accountId: firstAcc.id, limit } });
+            }
           }
         } catch { /* fallback to LLM response */ }
       }
@@ -389,18 +431,23 @@ export function register(router) {
         });
       }
 
+      // Strip orphan tool-fence blocks that the LLM may have emitted as
+      // a "no-more-tools" marker (e.g. empty ```json ``` or '''json ''').
+      // They leaked into the chat panel as visible noise.
+      const cleanFullResponse = stripOrphanFences(fullResponse);
+
       // Persist to conversation
       if (body.conversationId) {
         try {
           const conv = loadConversation(body.conversationId);
           if (conv) {
-            addMessages(conv, msg, fullResponse);
+            addMessages(conv, msg, cleanFullResponse);
           }
         } catch {}
       }
 
       if (heartbeatInterval) { clearInterval(heartbeatInterval); heartbeatInterval = null; }
-      sse('done', { content: fullResponse });
+      sse('done', { content: cleanFullResponse });
       res.write('data: [DONE]\n\n');
       res.end();
     } catch (e) {

package/src/services/tool-executor.mjs

@@ -820,9 +820,12 @@ 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
+  // Normalize: some LLMs output "json ... ", 'json ... ' or '''json ... '''
+  // (Python-style triple-quote) instead of ```json ... ```. We rewrite all
+  // these to proper triple-backtick fences before the main regex runs.
   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```')
     .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```');
 
@@ -914,6 +917,30 @@ export function parseActions(text) {
   return { textParts, actions };
 }
 
+/**
+ * Strip orphan tool-fence blocks from a finished LLM response. These appear
+ * when the model emits an empty `'''json '''` (or backtick-fenced) block
+ * as a no-op marker — the parser doesn't pick them up as actions but they
+ * leak into the UI as visible noise. Run this on the final assistant text
+ * before showing it to the user.
+ */
+export function stripOrphanFences(text) {
+  if (!text || typeof text !== 'string') return text;
+  return text
+    // Triple-backtick, triple-single, triple-double quote fences with `json`
+    // marker — empty or with a body. We strip the whole block.
+    .replace(/```json\s*\n?[\s\S]*?```/g, '')
+    .replace(/'''json\s*\n?[\s\S]*?'''/g, '')
+    .replace(/"""json\s*\n?[\s\S]*?"""/g, '')
+    // Bare action JSON that the parser already consumed but the synthesis
+    // step regurgitated (rare but happens with Liara). Only strip if the
+    // JSON shape matches "action":"...".
+    .replace(/\{\s*"action"\s*:\s*"[^"]+"\s*,?\s*("params"\s*:\s*\{[\s\S]*?\}\s*)?\}/g, '')
+    // Collapse blank-line clusters produced by the stripping.
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
 // ── Formatting Helpers ───────────────────────────────────────────────────────
 
 /**