nothumanallowed 14.1.25 → 14.1.26

package/package.json

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

package/src/server/routes/studio.mjs

@@ -11,23 +11,7 @@ import { NHA_DIR, AGENTS_DIR } from '../../constants.mjs';
 import { callLLM, callLLMStream, parseAgentFile } from '../../services/llm.mjs';
 import { webSearch, fetchUrl } from '../../services/web-tools.mjs';
 
-// ── Studio web tool definitions injected into agent system prompts ────────────
-const STUDIO_WEB_TOOLS = `
-You have access to two web tools. Use them to gather real data before writing your analysis.
-
-TOOL USAGE — output a JSON block wrapped in <tool_call> tags:
-<tool_call>{"tool": "web_search", "query": "your search query"}</tool_call>
-<tool_call>{"tool": "fetch_url", "url": "https://example.com/article"}</tool_call>
-
-Rules:
-- Use web_search to find relevant URLs, news, prices, data
-- Use fetch_url on specific URLs from search results to read full article content
-- You may call multiple tools (each on its own line)
-- After receiving <tool_response> results, write your complete analysis
-- NEVER fabricate data — only use what the tools return
-`;
-
-// Agents that should have web tool access in Studio
+// Agents that get web data pre-fetched before their LLM call
 const WEB_TOOL_AGENTS = new Set([
   'WebSearchAgent', 'TravelAgent', 'mercury', 'MERCURY',
   'athena', 'ATHENA', 'oracle', 'ORACLE', 'cassandra', 'CASSANDRA',
@@ -35,49 +19,58 @@ const WEB_TOOL_AGENTS = new Set([
 ]);
 
 /**
- * Execute a single studio tool call. Returns a result string.
+ * Run a web search and return formatted results string.
  */
-async function executeStudioTool(toolCall) {
+async function runWebSearch(query) {
   try {
-    const { tool, query, url } = toolCall;
-    if (tool === 'web_search') {
-      if (!query) return 'ERROR: web_search requires a query parameter';
-      const result = await webSearch(query);
-      if (result.error) return `Search failed: ${result.message}`;
-      const snippets = result.results
-        .slice(0, 6)
-        .map((r, i) => `[${i + 1}] ${r.title}\nURL: ${r.url}\n${r.snippet || ''}`)
-        .join('\n\n');
-      return `Search results for "${query}" (${result.resultCount} found):\n\n${snippets}`;
-    }
-    if (tool === 'fetch_url') {
-      if (!url) return 'ERROR: fetch_url requires a url parameter';
-      const result = await fetchUrl(url);
-      if (result.error) return `Fetch failed: ${result.message}`;
-      const titlePart = result.title ? `Title: ${result.title}\n\n` : '';
-      const text = (result.body || '').slice(0, 5000);
-      return `Content from ${url}:\n\n${titlePart}${text}`;
-    }
-    return `Unknown tool: ${tool}`;
+    const result = await webSearch(query);
+    if (result.error) return `Search failed: ${result.message}`;
+    const snippets = result.results
+      .slice(0, 6)
+      .map((r, i) => `[${i + 1}] ${r.title}\nURL: ${r.url}\n${r.snippet || ''}`)
+      .join('\n\n');
+    return `Search results for "${query}" (${result.resultCount} found):\n\n${snippets}`;
   } catch (e) {
-    return `Tool execution error: ${e.message}`;
+    return `Search error: ${e.message}`;
   }
 }
 
 /**
- * Parse <tool_call> blocks from LLM output.
+ * Fetch a URL and return formatted content string.
  */
-function parseToolCalls(text) {
-  const calls = [];
-  const re = /<tool_call>([\s\S]*?)<\/tool_call>/g;
-  let m;
-  while ((m = re.exec(text)) !== null) {
-    try {
-      const parsed = JSON.parse(m[1].trim());
-      if (parsed.tool) calls.push(parsed);
-    } catch {}
+async function runFetchUrl(url) {
+  try {
+    const result = await fetchUrl(url);
+    if (result.error) return `Fetch failed: ${result.message}`;
+    const titlePart = result.title ? `Title: ${result.title}\n\n` : '';
+    const text = (result.body || '').slice(0, 5000);
+    return `Content from ${url}:\n\n${titlePart}${text}`;
+  } catch (e) {
+    return `Fetch error: ${e.message}`;
   }
-  return calls;
+}
+
+/**
+ * Extract search queries from a task string.
+ * Returns up to 3 queries covering different angles.
+ */
+function extractSearchQueries(task, stepPrompt) {
+  const text = (stepPrompt || task).slice(0, 500);
+  // Primary query: the full task condensed
+  const primary = text.replace(/[^\w\s.,&/-]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 120);
+  const queries = [primary];
+
+  // Finance: add price + news queries
+  if (/gold|silver|oil|stock|bitcoin|crypto|eur|usd|etf|nasdaq|sp500|dow|tesla|apple|nvidia/i.test(text)) {
+    const ticker = text.match(/\b([A-Z]{2,5}|gold|silver|oil|bitcoin|ethereum)\b/i)?.[1] || '';
+    if (ticker) {
+      queries.push(`${ticker} price today 2025`);
+      queries.push(`${ticker} analyst forecast outlook 2025`);
+    }
+  }
+
+  // Dedup and cap at 3
+  return [...new Set(queries)].slice(0, 3);
 }
 
 export function register(router) {
@@ -233,62 +226,59 @@ export function register(router) {
       const userMessage = stepDef?.prompt || task;
 
       const useWebTools = WEB_TOOL_AGENTS.has(agent);
-      const finalSystemPrompt = useWebTools
-        ? systemPrompt + '\n\n' + STUDIO_WEB_TOOLS
+      let webDataBlock = '';
+
+      // Pre-fetch web data BEFORE the LLM call so the model writes with real facts
+      if (useWebTools) {
+        sse({ token: '[Raccolta dati web...]\n' });
+
+        const queries = extractSearchQueries(task, stepDef?.prompt);
+        const searchResults = await Promise.all(
+          queries.map(async (q) => {
+            sse({ token: `[Searching: "${q}"]\n` });
+            return { query: q, result: await runWebSearch(q) };
+          })
+        );
+
+        // From first search, extract up to 3 URLs and fetch their content
+        const firstResult = searchResults[0]?.result || '';
+        const urlMatches = [...firstResult.matchAll(/URL: (https?:\/\/[^\s\n]+)/g)]
+          .map((m) => m[1])
+          .slice(0, 3);
+
+        const fetchResults = await Promise.all(
+          urlMatches.map(async (url) => {
+            sse({ token: `[Fetching: ${url}]\n` });
+            return { url, content: await runFetchUrl(url) };
+          })
+        );
+
+        const searchBlock = searchResults
+          .map((s) => `### Search: "${s.query}"\n${s.result}`)
+          .join('\n\n---\n\n');
+
+        const fetchBlock = fetchResults.length > 0
+          ? fetchResults.map((f) => `### Full content: ${f.url}\n${f.content}`).join('\n\n---\n\n')
+          : '';
+
+        webDataBlock = `\n\n## REAL-TIME WEB DATA (use ONLY this data — do NOT invent prices or figures):\n\n${searchBlock}${fetchBlock ? '\n\n---\n\n' + fetchBlock : ''}`;
+
+        sse({ token: '\n' });
+      }
+
+      const finalSystemPrompt = webDataBlock
+        ? systemPrompt + webDataBlock
         : systemPrompt;
 
       let output = '';
       let tokensOut = 0;
 
-      // Round 1: initial LLM call (may contain tool_call blocks)
       await callLLMStream(config, finalSystemPrompt, userMessage, (tok) => {
         output += tok;
         tokensOut += Math.ceil(tok.length / 4);
         sse({ token: tok });
       }, { max_tokens: 8192 });
 
-      // Tool execution loop (max 2 rounds to prevent runaway)
-      if (useWebTools) {
-        for (let round = 0; round < 2; round++) {
-          const toolCalls = parseToolCalls(output);
-          if (toolCalls.length === 0) break;
-
-          sse({ token: '\n\n' });
-
-          // Execute all tool calls in parallel
-          const toolResults = await Promise.all(
-            toolCalls.map(async (tc) => {
-              const label = tc.tool === 'web_search' ? `Searching: "${tc.query}"` : `Fetching: ${tc.url}`;
-              sse({ token: `\n[${label}...] ` });
-              const result = await executeStudioTool(tc);
-              return { call: tc, result };
-            })
-          );
-
-          // Build tool responses block
-          const toolResponseBlock = toolResults
-            .map(({ call, result }) => {
-              const callJson = JSON.stringify(call);
-              return `<tool_call>${callJson}</tool_call>\n<tool_response>${result}</tool_response>`;
-            })
-            .join('\n\n');
-
-          // Round 2: synthesis with tool results
-          const synthesisPrompt = `## TOOL RESULTS:\n${toolResponseBlock}\n\n## YOUR TASK:\n${userMessage}\n\nNow write your complete analysis using the real data from the tool results above. Do not emit more tool calls — write the final answer directly.`;
-
-          sse({ token: '\n\n' });
-          let synthOutput = '';
-          await callLLMStream(config, finalSystemPrompt, synthesisPrompt, (tok) => {
-            synthOutput += tok;
-            tokensOut += Math.ceil(tok.length / 4);
-            sse({ token: tok });
-          }, { max_tokens: 8192 });
-
-          output = synthOutput;
-          break; // one tool round is sufficient
-        }
-      }
-
       clearInterval(keepalive);
       sse({ done: true, output, tokensOut });
       res.write('data: [DONE]\n\n');