nothumanallowed 15.1.35 → 15.1.36

package/package.json

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

package/src/services/message-responder.mjs

@@ -530,6 +530,38 @@ class TelegramResponder {
     saveTelegramContext(this._lastContextByChatId);
   }
 
+  /**
+   * Route a fresh message to the best agent.
+   *
+   * Tier 1 — keyword table (fast, no LLM cost). Falls through to CONDUCTOR
+   * when nothing matches.
+   *
+   * Tier 2 — if Tier 1 returned the fallback CONDUCTOR AND the user has an
+   * LLM key configured, ask the LLM to pick the right agent given the
+   * conversation history. This rescues paraphrased queries like
+   * "mostrami quanto vale ora il metallo prezioso giallo" (no keyword match)
+   * which v13 used to route correctly because of a similar LLM router.
+   */
+  async _routeFreshMessage(text, lastCtx) {
+    const keywordAgent = routeMessage(text, this.autoRoute);
+    if (keywordAgent !== 'conductor') return keywordAgent;
+    // Tier 2 fallback
+    const hasKey = !!(this.config.llm?.apiKey || this.config.llm?.openaiKey || this.config.llm?.geminiKey || this.config.llm?.deepseekKey || (this.config.llm?.provider === 'nha'));
+    if (!hasKey) return keywordAgent;
+    try {
+      const AGENTS = ['herald', 'mercury', 'athena', 'oracle', 'forge', 'scheherazade', 'saber', 'sauron', 'conductor'];
+      const tail = (lastCtx?.conversationLog || []).slice(-6)
+        .map(t => `${t.role === 'user' ? 'User' : 'Bot'}: ${String(t.content).slice(0, 200)}`)
+        .join('\n');
+      const sys = 'You are a routing classifier. Reply with EXACTLY one lowercase agent name from this list and nothing else: ' + AGENTS.join(', ') + '. herald=calendar/email/weather/news, mercury=finance/markets/crypto, athena=audit/compliance, oracle=data/analytics, forge=code/architecture, scheherazade=writing/content, saber=security, sauron=monitoring, conductor=anything else.';
+      const usr = `Recent conversation (most recent last):\n${tail || '(none)'}\n\nUser message: "${text}"\n\nWhich agent? Reply with ONLY the lowercase agent name.`;
+      const ans = await callLLM(this.config, sys, usr, { max_tokens: 16 });
+      const picked = String(ans || '').trim().toLowerCase().split(/\s+/)[0];
+      if (AGENTS.includes(picked)) return picked;
+    } catch { /* LLM unavailable, keep keyword fallback */ }
+    return keywordAgent;
+  }
+
   get enabled() {
     return !!this.token;
   }
@@ -802,10 +834,25 @@ class TelegramResponder {
       let enrichedMessage = cleanText;
       let preHistory = null;
 
+      // ── Always inject multi-turn rolling history (15.1.36) ─────────────
+      // Even when the new message isn't a "continuation" of the very last
+      // turn, the user may still be referring to something earlier in the
+      // conversation ("come ti avevo detto ieri", "ricorda che..."). Pass
+      // the full conversation log to the agent as preHistory.
+      const rollingLog = (lastCtx && Array.isArray(lastCtx.conversationLog) && lastCtx.conversationLog.length > 0)
+        ? lastCtx.conversationLog
+            .filter(t => t && (t.role === 'user' || t.role === 'assistant') && typeof t.content === 'string')
+            .map(t => ({ role: t.role, content: t.content }))
+        : null;
+
       if (isContinuation && !lastWasCompleted) {
         // Continue with same agent and inject full history for context
         agent = lastCtx.agent;
-        if (lastCtx.history && lastCtx.history.length > 0) {
+        // Prefer the rolling multi-turn log if available; fall back to the
+        // legacy single-turn `history` for older saved contexts.
+        if (rollingLog && rollingLog.length > 0) {
+          preHistory = rollingLog;
+        } else if (lastCtx.history && lastCtx.history.length > 0) {
           preHistory = lastCtx.history;
         }
 
@@ -870,9 +917,13 @@ class TelegramResponder {
 
         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}: new request → ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}${lastWasCompleted ? ' [prev completed]' : ''}`);
+        // Fresh request — route normally, but STILL pass the rolling log so
+        // the model has the conversation context even when the new message
+        // is on a fresh topic (e.g. user starts a new task but the previous
+        // session is still relevant for memory: names, preferences, etc.).
+        agent = await this._routeFreshMessage(cleanText, lastCtx);
+        if (rollingLog && rollingLog.length > 0) preHistory = rollingLog;
+        this.log(`[Telegram] ${fromUser}: new request → ${agent.toUpperCase()}${isVoice ? ' [voice]' : ''}${lastWasCompleted ? ' [prev completed]' : ''} (rolling history=${preHistory ? preHistory.length : 0})`);
       }
 
       // Broadcast event
@@ -906,12 +957,25 @@ class TelegramResponder {
         ? responseText.slice(0, 3950) + '\n\n... [truncated]'
         : responseText;
 
-      // Save context — if action was completed, mark it so next turn starts fresh
+      // ── Multi-turn rolling memory (15.1.36) ────────────────────────────
+      // v13 worked well partially because every chat retained a real
+      // conversation history. The v14 refactor reduced this to 1 turn —
+      // hence "Telegram doesn't understand me anymore". We now keep the
+      // last MAX_CONVERSATION_TURNS turns per chat, persisted to disk.
+      const MAX_CONVERSATION_TURNS = 20; // user+assistant pairs
+      const prevLog = (lastCtx && Array.isArray(lastCtx.conversationLog)) ? lastCtx.conversationLog : [];
+      const conversationLog = [
+        ...prevLog,
+        { role: 'user',      content: cleanText,    ts: Date.now() },
+        { role: 'assistant', content: responseText, ts: Date.now() },
+      ].slice(-MAX_CONVERSATION_TURNS * 2);
+
       this._lastContextByChatId[chatId] = {
         agent,
         userMsg: cleanText,
         agentReply: responseText,
-        history: isCompletedAction(responseText) ? null : responseHistory, // clear history after success
+        history: isCompletedAction(responseText) ? null : responseHistory, // single-turn (legacy)
+        conversationLog,                                                   // multi-turn (new)
         ts: Date.now(),
       };
       this._lastAgentByChatId[chatId] = agent;