nothumanallowed 15.1.37 → 15.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.1.37",
+  "version": "15.1.39",
   "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.37';
+export const VERSION = '15.1.39';
 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,37 @@ class TelegramResponder {
     saveTelegramContext(this._lastContextByChatId);
   }
 
+  /**
+   * Language-agnostic intent classifier (15.1.38).
+   *
+   * Previous versions hard-coded confirmation/reaction keywords for Italian
+   * and English. That couldn't scale — every new language ("schedule it"
+   * in Spanish, German, Japanese, Polish, Turkish, ...) would need a new
+   * keyword list. Now we delegate to a tiny LLM call: 16 tokens output,
+   * works in any human language the model knows.
+   *
+   * Fast path: if the keyword matcher already returned a confident verdict,
+   * skip the LLM. Only ambiguous cases (short messages, no obvious keyword)
+   * pay the ~50ms LLM cost.
+   *
+   * @returns 'continuation' | 'new_request' | 'unknown'
+   */
+  async _classifyIntent(text, lastCtx) {
+    if (!lastCtx) return 'new_request';
+    const hasKey = !!(this.config.llm?.apiKey || this.config.llm?.openaiKey || this.config.llm?.geminiKey || (this.config.llm?.provider === 'nha'));
+    if (!hasKey) return 'unknown';
+    try {
+      const prev = (lastCtx.agentReply || '').slice(0, 600);
+      const sys = 'You are a binary intent classifier for a chat assistant. Reply with EXACTLY one word: "continuation" or "new_request". Use "continuation" when the user is confirming, denying, reacting to, or refining the assistant\'s previous message (in any language). Use "new_request" when the user is starting an unrelated topic. Do not output anything else.';
+      const usr = `Assistant just said:\n"${prev}"\n\nUser now writes:\n"${text}"\n\nClassify the user\'s message: continuation or new_request?`;
+      const ans = await callLLM(this.config, sys, usr, { max_tokens: 8 });
+      const v = String(ans || '').trim().toLowerCase().replace(/[^a-z_]/g, '');
+      if (v === 'continuation' || v.startsWith('cont')) return 'continuation';
+      if (v === 'new_request' || v.startsWith('new')) return 'new_request';
+      return 'unknown';
+    } catch { return 'unknown'; }
+  }
+
   /**
    * Route a fresh message to the best agent.
    *
@@ -823,8 +854,27 @@ class TelegramResponder {
       const withinStickyWindow = stickyAge < 5 * 60 * 1000; // 5 min
 
       // Determine if this message is a continuation of the previous turn
-      // (confirmation, reaction, short reply) vs a new independent request
-      const isContinuation = withinStickyWindow && isContinuationMessage(cleanText, lastCtx);
+      // (confirmation, reaction, short reply) vs a new independent request.
+      //
+      // Two-stage detection:
+      //   1. Fast keyword path (IT + EN) — handles the obvious cases (~80%) with zero cost.
+      //   2. LLM classifier fallback — for ambiguous cases in any language
+      //      ("agéndalo", "termin verschieben", "schedule it",
+      //       "ya", "tamam", "harika", ...). Costs ~50 ms and 8 output tokens
+      //      but is language-agnostic by design.
+      let isContinuation = withinStickyWindow && isContinuationMessage(cleanText, lastCtx);
+      if (withinStickyWindow && !isContinuation && lastCtx) {
+        // Only invoke the LLM if keyword fast-path didn't flag continuation
+        // AND the message is short enough to plausibly be a reaction (≤ 12 words).
+        const wordCount = cleanText.trim().split(/\s+/).length;
+        if (wordCount <= 12) {
+          const verdict = await this._classifyIntent(cleanText, lastCtx);
+          if (verdict === 'continuation') {
+            isContinuation = true;
+            this.log(`[Telegram] ${fromUser}: LLM classifier overrode keyword → continuation`);
+          }
+        }
+      }
 
       // If last response was a completed action, don't carry history forward —
       // the next message is a fresh request even if it looks like a reaction

package/src/services/tool-executor.mjs

@@ -294,8 +294,34 @@ TOOLS:
 40. slack_messages(channel: string, maxResults?: number)
     List recent messages in a Slack channel (name or ID). Default max 15.
 
-41. slack_send(channel: string, text: string)
+41. slack_send(channel: string, text: string, threadTs?: string)
     Send a message to a Slack channel. ALWAYS confirm before sending.
+    If `threadTs` is provided, post as a thread reply instead of a top-level message.
+
+41b. slack_search(query: string, count?: number)
+     Full-text search messages across the whole Slack workspace. Returns the most
+     recent matches with channel, user, text and a Slack permalink each. Use this
+     for "find the message where X talked about Y", "trova il messaggio di Marco
+     su X", "did anyone post about the release", etc.
+
+41c. slack_dm(user: string, text?: string)
+     Open or send a direct message to a user. `user` accepts Slack user ID (Uxxx),
+     username, real name, or email — the tool resolves them automatically.
+     If `text` is provided, the message is sent immediately; otherwise the DM
+     channel is just opened.
+
+41d. slack_thread(channel: string, ts: string)
+     List all replies in a thread. `ts` is the parent message timestamp (returned
+     by slack_messages or slack_search). Use this before posting a contextual
+     reply with slack_send + threadTs.
+
+41e. slack_react(channel: string, ts: string, emoji: string)
+     Add an emoji reaction to a message. `emoji` is the name without colons
+     (e.g. "thumbsup", "rocket", "white_check_mark"). Confirm before reacting on
+     someone else's message.
+
+41f. slack_mark_read(channel: string, ts?: string)
+     Mark a Slack channel as read up to a given timestamp (default: now).
 
 --- FILE ATTACHMENT ---