nothumanallowed 13.2.96 → 13.2.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.2.96",
+  "version": "13.2.97",
   "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/commands/ui.mjs

@@ -3280,122 +3280,146 @@ ${context ? `## OUTPUT FROM PREVIOUS AGENTS (use only what is RELEVANT to the wo
           }
 
           // ── Stream LLM response ───────────────────────────────────────
+          // Specialist (non-canvas, non-live-data) agents use Structured Generation:
+          //   Phase 1 — Outline: one call that returns ONLY section headings as a numbered list
+          //   Phase 2 — Section fill: one call per section, with full context of sections already written
+          // Live-data + Canvas agents use the classic single-stream approach.
           let fullOutput = '';
-          let inThinkBlock = false;
-          let thinkBuf = '';
-          sendToken(isCanvasAgent ? 'Generating visual report...' : '');
-          const llmTimeout = isCanvasAgent ? 180000 : 120000;
-          // Canvas: no thinking (needs full tokens for HTML). Specialists: cap thinking to 2048 to leave room for answer.
-          const stepLlmOpts = isCanvasAgent
-            ? { max_tokens: 12288, thinking: 'off' }
-            : { max_tokens: 8192, thinking_budget: 2048 };
-          try {
+          let fullOutputClean = '';
+
+          // ── Helper: strip <think> tags from a string ─────────────────
+          const stripThink = (s) => s.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+
+          // ── Helper: stream a single LLM call, strip think tags, return full text ─
+          const streamCall = async (sysPr, usrMsg, opts, timeout, onToken) => {
+            let raw = '';
+            let inThink = false;
+            let tBuf = '';
             await withTimeout(
-              callLLMStream(config, sysPrompt, userMsg,
-                (token) => {
-                  fullOutput += token;
-                  if (!isCanvasAgent) {
-                    // Buffer and strip <think>...</think> blocks before sending to client
-                    thinkBuf += token;
-                    // Process thinkBuf: emit only content outside think tags
-                    let out = '';
-                    let buf = thinkBuf;
-                    while (buf.length > 0) {
-                      if (inThinkBlock) {
-                        const closeIdx = buf.indexOf('</think>');
-                        if (closeIdx >= 0) {
-                          buf = buf.slice(closeIdx + 8);
-                          inThinkBlock = false;
-                        } else {
-                          buf = '';
-                        }
-                      } else {
-                        const openIdx = buf.indexOf('<think>');
-                        if (openIdx >= 0) {
-                          out += buf.slice(0, openIdx);
-                          buf = buf.slice(openIdx + 7);
-                          inThinkBlock = true;
-                        } else {
-                          out += buf;
-                          buf = '';
-                        }
-                      }
+              callLLMStream(config, sysPr, usrMsg, (tok) => {
+                raw += tok;
+                if (onToken) {
+                  tBuf += tok;
+                  let out = '';
+                  let buf = tBuf;
+                  while (buf.length > 0) {
+                    if (inThink) {
+                      const ci = buf.indexOf('</think>');
+                      if (ci >= 0) { buf = buf.slice(ci + 8); inThink = false; }
+                      else { buf = ''; }
+                    } else {
+                      const oi = buf.indexOf('<think>');
+                      if (oi >= 0) { out += buf.slice(0, oi); buf = buf.slice(oi + 7); inThink = true; }
+                      else { out += buf; buf = ''; }
                     }
-                    thinkBuf = '';
-                    // Strip JSON tool calls from specialist agent output
-                    const stripped = out.replace(/\{[\s\S]*?"action"[\s\S]*?\}/g, '').trim();
-                    if (stripped) sendToken(stripped);
                   }
-                },
-                stepLlmOpts,
-              ),
-              llmTimeout
+                  tBuf = '';
+                  const stripped = out.replace(/\{[\s\S]*?"action"[\s\S]*?\}/g, '').trim();
+                  if (stripped) onToken(stripped);
+                }
+              }, opts),
+              timeout
             );
-          } catch (e) {
-            if (!isCanvasAgent) sendToken(`[Error: ${e.message}]`);
-          }
+            return stripThink(raw);
+          };
 
-          // Strip think tags from fullOutput before emptiness check
-          let fullOutputClean = fullOutput.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+          const useStructuredGen = !isCanvasAgent && !isLiveDataAgent;
 
-          // ── Fill empty sections — iterative loop until no empty sections remain ─────
-          // Detect headings with no body: heading immediately followed by another heading or end.
-          // We loop because filling section A may expose B, C, D that were skipped by detection.
-          const getEmptySections = (text) => {
-            const rx = /^(#{1,4}\s+[^\n]+)\n+(?=#{1,4}\s|$)/gm;
-            const found = [];
-            let m;
-            while ((m = rx.exec(text)) !== null) found.push(m[1].trim());
-            return found;
-          };
+          if (isCanvasAgent) {
+            // ── Canvas: single stream, HTML output ────────────────────
+            sendToken('Generating visual report...');
+            try {
+              fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 12288, thinking: 'off' }, 180000, null);
+            } catch (e) { /* canvas errors surfaced below */ }
+            fullOutputClean = fullOutput;
+
+          } else if (useStructuredGen) {
+            // ── Structured Generation ─────────────────────────────────
+            // Phase 1: ask for ONLY the section outline (headings list), fast and cheap
+            const structConfig = Object.assign({}, config, { thinking: 'off' });
+            const outlineSys = `You are ${agent}, a specialist AI agent. Today is ${today}. Respond in ${language}.
+Your task: plan the sections of a complete structured report for this goal: ${task}
+Instruction: ${stepPrompt}
+
+Output ONLY a numbered list of section headings — one per line, no body text, no explanation.
+Use ## prefix for each heading. Maximum 8 sections. Example:
+## 1. Executive Summary
+## 2. Key Findings
+## 3. Analysis`;
+            let outlineRaw = '';
+            try {
+              outlineRaw = await withTimeout(
+                new Promise((res) => {
+                  let acc = '';
+                  callLLMStream(structConfig, outlineSys, 'List the section headings only.', (tok) => { acc += tok; }, { max_tokens: 300, thinking: 'off' }).then(() => res(acc)).catch(() => res(acc));
+                }),
+                20000
+              );
+            } catch {}
+
+            // Parse headings: lines starting with ## (or plain numbered lines as fallback)
+            const headingLines = stripThink(outlineRaw)
+              .split('\n')
+              .map(l => l.trim())
+              .filter(l => l.match(/^#{1,4}\s+\S/) || l.match(/^\d+[\.\)]\s+\S/))
+              .map(l => l.match(/^#{1,4}\s+/) ? l : '## ' + l.replace(/^\d+[\.\)]\s+/, ''))
+              .slice(0, 8);
+
+            if (headingLines.length === 0) {
+              // Outline failed — fall back to single stream
+              sendToken('');
+              try {
+                fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 8192, thinking_budget: 2048 }, 120000, sendToken);
+              } catch (e) { sendToken(`[Error: ${e.message}]`); }
+              fullOutputClean = stripThink(fullOutput);
+            } else {
+              // Phase 2: one call per section, each sees the sections already written
+              const dataBlock = [
+                attachmentText ? `## ATTACHED FILE:\n${attachmentText}` : '',
+                toolData ? `## LIVE DATA:\n${toolData}` : '',
+                context ? `## PREVIOUS AGENTS OUTPUT:\n${context}` : '',
+              ].filter(Boolean).join('\n\n');
+              const sectionParts = [];
+              for (let si = 0; si < headingLines.length; si++) {
+                const heading = headingLines[si];
+                const writtenSoFar = sectionParts.join('\n\n');
+                const secSys = `You are ${agent}, a specialist AI agent inside NHA Studio. Today is ${today}. Respond entirely in ${language}.
+
+## OVERALL WORKFLOW GOAL:
+${task}
 
-          if (!isCanvasAgent) {
-            const dataForFill = (toolData || context || '').slice(0, 4000);
-            const fillConfig = Object.assign({}, config, { thinking: 'off' });
-            let fillRound = 0;
-            const MAX_FILL_ROUNDS = 3; // safety cap — never more than 3 passes
-            let emptySections = getEmptySections(fullOutputClean);
-
-            while (emptySections.length > 0 && fillRound < MAX_FILL_ROUNDS) {
-              fillRound++;
-              if (fillRound === 1) sendToken('\n\n[Completando sezioni mancanti...] ');
-              for (const emptyHeading of emptySections) {
-                sendToken('\n' + emptyHeading + '\n');
-                let filledContent = '';
-                const reportSoFar = fullOutputClean.slice(-3000);
+CRITICAL RULES:
+- Write ONLY the body content for the section heading given — do NOT repeat the heading
+- Do NOT open new headings or sub-sections — write flowing prose + bullet points
+- Do NOT invent data — use ONLY what is in the DATA block below
+- Be thorough, specific, and complete — this is one section of an executive report
+
+${dataBlock}
+${writtenSoFar ? `## REPORT WRITTEN SO FAR (for consistency):\n${writtenSoFar.slice(-3000)}` : ''}`;
+                const secUser = `Write the complete body content for this section (do NOT repeat the heading):\n${heading}`;
+                sendToken('\n\n' + heading + '\n');
+                let secContent = '';
                 try {
-                  await withTimeout(
-                    callLLMStream(
-                      fillConfig,
-                      `You are ${agent}. You wrote a report and accidentally left one section empty. Fill in ONLY the missing section — do NOT repeat the heading, do NOT add other sections. Be specific, consistent with the rest of the report, and thorough. Write in ${language}.\n\nSource data:\n${dataForFill}\n\nOverall task: ${task}\n\nReport written so far (for context and style consistency):\n${reportSoFar}`,
-                      `Write ONLY the body content for this section (heading already printed, do not repeat it):\n${emptyHeading}`,
-                      (tok) => { filledContent += tok; sendToken(tok); },
-                      { max_tokens: 1500, thinking: 'off' }
-                    ),
-                    45000
-                  );
+                  secContent = await streamCall(secSys, secUser, { max_tokens: 2000, thinking: 'off' }, 60000, sendToken);
                 } catch {}
-                if (filledContent.trim()) {
-                  const escapedH = emptyHeading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                  // Inject after heading when followed by another heading
-                  fullOutputClean = fullOutputClean.replace(
-                    new RegExp('(' + escapedH + ')\\n+(#{1,4}\\s)', 'g'),
-                    '$1\n\n' + filledContent.trim() + '\n\n$2'
-                  );
-                  // Inject at end of document (trailing heading)
-                  fullOutputClean = fullOutputClean.replace(
-                    new RegExp('(' + escapedH + ')\\s*$', 'g'),
-                    '$1\n\n' + filledContent.trim()
-                  );
+                if (secContent.trim()) {
+                  sectionParts.push(heading + '\n\n' + secContent.trim());
+                  fullOutput += '\n\n' + heading + '\n\n' + secContent.trim();
                 }
               }
-              // Re-detect after this round — newly injected content may close all gaps
-              emptySections = getEmptySections(fullOutputClean);
+              fullOutputClean = fullOutput.trim();
             }
-            // Strip any unfillable trailing headings
-            fullOutputClean = fullOutputClean.replace(/^(#{1,4}\s+[^\n]+)\n+(?=#{1,4}\s|$)/gm, '');
+
+          } else {
+            // ── Live-data agents: single stream ───────────────────────
+            sendToken('');
+            try {
+              fullOutput = await streamCall(sysPrompt, userMsg, { max_tokens: 8192, thinking_budget: 2048 }, 120000, sendToken);
+            } catch (e) { sendToken(`[Error: ${e.message}]`); }
+            fullOutputClean = stripThink(fullOutput);
           }
-          // Strip trailing lone headings at end of output (truly unfillable)
+
+          // Strip trailing lone headings at end of output (truly unfillable edge cases)
           fullOutputClean = fullOutputClean.replace(/(#{1,4}\s+[^\n]+)\s*$/g, '').trim();
 
           // Fallback: if LLM returned empty and we have tool data, send it directly

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.2.96';
+export const VERSION = '13.2.97';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';