nothumanallowed 13.2.72 → 13.2.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "13.2.72",
+  "version": "13.2.74",
   "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

@@ -2852,35 +2852,73 @@ export async function cmdUI(args) {
 
           // ── Fetch REAL data for each agent type ──────────────────────
           if (agent === 'DocumentReaderAgent') {
-            // Extract text from attached PDF and return it as the step output.
-            // This becomes context for all subsequent steps (WebSearchAgent etc.)
+            // Extract text from attached PDF, then ask the LLM to structure it cleanly.
+            // The structured output becomes context for all subsequent steps.
             sendToken('[Reading attached document...] ');
+            let rawText = '';
             if (stepPdfBase64) {
               try {
                 const b64 = stepPdfBase64.includes(',') ? stepPdfBase64.split(',')[1] : stepPdfBase64;
                 const pdfBuffer = Buffer.from(b64, 'base64');
-                const extracted = extractTextFromPdf(pdfBuffer);
-                if (extracted && extracted.length > 20) {
-                  toolData = `## Document: ${stepPdfName || 'attached'}\n\n${extracted.slice(0, 20000)}`;
-                } else {
-                  // Fallback: ask vision model to describe/OCR the document
-                  sendToken('[No text found — using vision OCR...] ');
+                rawText = extractTextFromPdf(pdfBuffer) || '';
+                if (!rawText || rawText.length < 20) {
+                  // Scanned PDF — use vision OCR
+                  sendToken('[No text layer — using vision OCR...] ');
                   try {
-                    const visionText = await callLLMVision(config, stepPdfBase64, 'application/pdf',
-                      `Extract ALL text, technical specifications, model numbers, part codes, product names, manufacturer details, dimensions, ratings, and any other data from this document. List every detail exactly as printed.`);
-                    toolData = `## Document (OCR): ${stepPdfName || 'attached'}\n\n${visionText}`;
-                  } catch (ve) {
-                    toolData = `Could not extract text from document: ${ve.message}`;
-                  }
+                    rawText = await callLLMVision(config, stepPdfBase64, 'application/pdf',
+                      'Extract ALL text from this document exactly as printed, preserving all numbers, codes, and values.');
+                  } catch (ve) { rawText = ''; }
                 }
-              } catch (e) { toolData = `Document read failed: ${e.message}`; }
-            } else {
-              toolData = 'No document attached.';
+              } catch (e) { rawText = ''; }
+            }
+            if (!rawText) {
+              sendToken('Could not extract text from the attached document.');
+              clearInterval(keepalive);
+              sendEvent({ done: true, usage: { input: 0, output: 0 } });
+              res.end();
+              logRequest(method, pathname, 200, Date.now() - start);
+              return;
+            }
+            // Ask LLM to structure the raw extracted text into readable markdown
+            sendToken('[Structuring document content...] ');
+            const LANG_MAP_DOC = {en:'English',it:'Italian',es:'Spanish',fr:'French',de:'German',pt:'Portuguese',zh:'Chinese',ja:'Japanese',ar:'Arabic',hi:'Hindi',ru:'Russian',nl:'Dutch',pl:'Polish',tr:'Turkish',ko:'Korean',sv:'Swedish',da:'Danish',fi:'Finnish',no:'Norwegian',cs:'Czech'};
+            const docLang = LANG_MAP_DOC[(config?.language||'it').toLowerCase().slice(0,2)] || 'Italian';
+            const docSys = `You are a technical document analyst. Extract and structure the content of this document into clear, readable markdown. Respond in ${docLang}.
+Rules:
+- List ALL technical specifications with their exact values (codes, voltages, pressures, temperatures, dimensions, flow rates, etc.)
+- Use markdown headers (##), bullet points (-), and tables where appropriate
+- Do NOT invent, interpret, or add anything not present in the raw text
+- Include all product/part codes exactly as written
+- Keep all numeric values with their units`;
+            const docUser = `Here is the raw text extracted from "${stepPdfName || 'document.pdf'}". Structure it into clean, readable markdown:\n\n${rawText.slice(0, 18000)}`;
+            let structuredOutput = '';
+            let inThink = false;
+            try {
+              await withTimeout(
+                callLLMStream(config, docSys, docUser,
+                  (token) => {
+                    // Strip <think> blocks
+                    let buf = token;
+                    if (inThink) {
+                      const ci = buf.indexOf('</think>');
+                      if (ci >= 0) { buf = buf.slice(ci + 8); inThink = false; }
+                      else return;
+                    }
+                    const oi = buf.indexOf('<think>');
+                    if (oi >= 0) { buf = buf.slice(0, oi); inThink = true; }
+                    if (buf) { structuredOutput += buf; sendToken(buf); }
+                  },
+                  { max_tokens: 3000 }
+                ),
+                90000
+              );
+            } catch (e) {
+              // LLM failed — fall back to raw text
+              structuredOutput = `## ${stepPdfName || 'Document'}\n\n${rawText.slice(0, 8000)}`;
+              sendToken(structuredOutput);
             }
-            // Stream the extracted content as the step output directly — no LLM rewrite needed
-            sendToken(toolData);
             clearInterval(keepalive);
-            sendEvent({ done: true, usage: { input: 0, output: Math.ceil(toolData.length / 4) } });
+            sendEvent({ done: true, usage: { input: Math.ceil(rawText.length / 4), output: Math.ceil(structuredOutput.length / 4) } });
             res.end();
             logRequest(method, pathname, 200, Date.now() - start);
             return;
@@ -2909,22 +2947,55 @@ export async function cmdUI(args) {
               // Extract a concise search query from the step prompt
               let searchQuery = stepPrompt;
 
-              // If context contains extracted PDF data, extract the best search query from it:
-              // product codes, model numbers, part numbers etc. are better search terms than the task text.
+              // If context contains extracted PDF/document data, build a smart search query.
+              // Detect whether the task asks for "similar" products vs. exact product lookup.
               if (context && context.length > 50) {
-                // Look for product codes: alphanumeric codes, e.g. 321k63, VFD-001, 4WE6D6X
-                const codeMatch = context.match(/\b([A-Z0-9]{2,}[-\/]?[A-Z0-9]{2,}(?:[-\/][A-Z0-9]+)*)\b/g);
-                const productCodes = codeMatch ? [...new Set(codeMatch)].slice(0, 3) : [];
-                // Also grab manufacturer name if present
-                const mfrMatch = context.match(/(?:Marca|Marchio|Manufacturer|Brand|Produttore|Costruttore)[:\s]+([A-Za-z0-9 &]{2,40})/i);
-                const mfr = mfrMatch ? mfrMatch[1].trim() : '';
-                if (productCodes.length > 0) {
-                  searchQuery = (mfr ? mfr + ' ' : '') + productCodes.join(' ') + ' buy acquista distributore';
-                  sendToken(`[Search query from document: "${searchQuery}"] `);
+                const taskLow2 = task.toLowerCase();
+                const wantsSimilar = /simil|equivalen|alternativ|sostitut|find similar|alternative|replacement/i.test(taskLow2 + ' ' + stepPrompt);
+
+                // Extract manufacturer name from structured context
+                const mfrMatch = context.match(/(?:Marca|Marchio|Manufacturer|Brand|Produttore|Costruttore|Parker|Bosch|Rexroth|SMC|Festo|Burkert|Norgren|Sirai|Asco)[:\s]*([A-Za-z0-9 &]{2,40})/i);
+                const mfr = mfrMatch ? mfrMatch[1].trim().split(/\s+/).slice(0,2).join(' ') : '';
+
+                // Extract model/part code: 3-8 char alphanumeric, NOT common words/units
+                const IGNORE = new Set(['NBR','FKM','RUBY','BSP','PDF','URL','HTTP','THE','AND','FOR','MIN','MAX','BAR','VAC','KV','AC','DC','CE','UK','EU','ISO','DIN']);
+                const codeRx = /\b([A-Z][A-Z0-9]{2,7}(?:[-\/][A-Z0-9]{1,6})*)\b/g;
+                const allCodes = [];
+                let cm;
+                while ((cm = codeRx.exec(context)) !== null) {
+                  const c = cm[1];
+                  if (!IGNORE.has(c) && c.length >= 4 && /\d/.test(c)) allCodes.push(c);
+                }
+                const productCode = [...new Set(allCodes)][0] || '';
+
+                // Extract key technical specs for similarity search
+                const pressMatch = context.match(/(?:pressione|pressure|MOPD)[^\d]*(\d+)\s*bar/i);
+                const pressure = pressMatch ? pressMatch[1] + ' bar' : '';
+                const portMatch = context.match(/(?:porta|port|attacco|fitting)[^\d]*(\d+\/\d+[''"]?)/i);
+                const port = portMatch ? portMatch[1] : '';
+                const typeMatch = context.match(/(?:valvola|valve|solenoid)[^,\n]{0,30}?(2\/2|3\/2|pilot.operated|normally.closed|normally.open)/i);
+                const valveType = typeMatch ? typeMatch[1] : '';
+
+                if (wantsSimilar) {
+                  // Task wants equivalent/similar product — search by specs, not by exact code
+                  const specParts = [
+                    valveType || 'solenoid valve',
+                    pressure,
+                    port,
+                    'hydraulic oil',
+                    'acquista distributore Italy'
+                  ].filter(Boolean);
+                  searchQuery = specParts.join(' ');
+                  if (mfr && mfr.toLowerCase() !== productCode.toLowerCase()) searchQuery = mfr + ' ' + searchQuery;
+                  sendToken(`[Search query (similar product): "${searchQuery}"] `);
+                } else if (productCode) {
+                  // Task wants the exact product — search by code + manufacturer
+                  searchQuery = (mfr ? mfr + ' ' : '') + productCode + ' acquista distributore';
+                  sendToken(`[Search query (exact product): "${searchQuery}"] `);
                 }
               }
 
-              if (searchQuery.length > 120 && !context) {
+              if (!context && searchQuery.length > 120) {
                 const keywordMatch = searchQuery.match(/(?:cerca|search|find|ricerca|notizie su|news about|latest on|aggiornamenti su)\s+(.{5,80}?)(?:\s+(?:e|and|per|for|poi|then)|$)/i);
                 if (keywordMatch) {
                   searchQuery = keywordMatch[1].trim();
@@ -2946,10 +3017,29 @@ export async function cmdUI(args) {
                   }
                 } catch {}
               }
-              // Deep web search for broader context
+              // Primary search
               const searchResult = await withTimeout(executeTool('web_search', { query: searchQuery, deep: true }, config), 25000);
               const searchStr = typeof searchResult === 'string' ? searchResult : JSON.stringify(searchResult);
               toolData += (toolData ? '\n\n' : '') + `## Web search results for "${searchQuery}":\n${searchStr}`;
+
+              // Secondary search: if task mentions "similar" or "where to buy", run a second query for vendors
+              const taskLow3 = task.toLowerCase();
+              if (/simil|equivalen|alternativ|sostitut|rivendit|distributore|vend|acquist|compra|dove\s+trovare|where\s+to\s+buy/i.test(taskLow3) && context && context.length > 50) {
+                // Build vendor search query from manufacturer + product type
+                const mfrVendor = context.match(/(?:Parker|Bosch|Rexroth|SMC|Festo|Burkert|Norgren|Sirai|Asco)\s+[A-Za-z]*/i);
+                const mfrName = mfrVendor ? mfrVendor[0].trim() : '';
+                const typeVendor = context.match(/(?:valvola|valve|solenoid|elettrovalvola)[^,\n]{0,30}?(2\/2|pilot.operated|normally.closed)/i);
+                const typeStr = typeVendor ? typeVendor[1] : 'solenoid valve';
+                const pressVendor = context.match(/(\d+)\s*bar/i);
+                const pressStr = pressVendor ? pressVendor[1] + ' bar' : '';
+                const vendorQuery = [mfrName, typeStr, pressStr, 'rivenditore distributore acquisto'].filter(Boolean).join(' ');
+                sendToken(`[Search query (vendor/similar): "${vendorQuery}"] `);
+                try {
+                  const vendorResult = await withTimeout(executeTool('web_search', { query: vendorQuery, deep: true }, config), 20000);
+                  const vendorStr = typeof vendorResult === 'string' ? vendorResult : JSON.stringify(vendorResult);
+                  toolData += `\n\n## Vendor search results for "${vendorQuery}":\n${vendorStr}`;
+                } catch {}
+              }
             } catch (e) { toolData = toolData || `Web search failed: ${e.message}`; }
 
           } else if (agent === 'BrowserAgent') {

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

package/src/services/web-ui.mjs

@@ -3367,7 +3367,11 @@ function renderStudioLog() {
   el.scrollTop = el.scrollHeight;
 }
 
+var _downloadPdfLast = 0;
 function downloadStudioPDF() {
+  var now = Date.now();
+  if (now - _downloadPdfLast < 3000) return; // debounce: max 1 download every 3s
+  _downloadPdfLast = now;
   var task = studioState.task || 'NHA Studio Report';
   var today = new Date().toLocaleDateString('it-IT', {day:'2-digit',month:'2-digit',year:'numeric'});
   var nodes = studioState.nodes || [];