nothumanallowed 14.1.24 → 14.1.25

package/package.json

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

package/src/server/routes/studio.mjs

@@ -9,6 +9,76 @@ import { sendJSON, sendError, parseBody } from '../index.mjs';
 import { loadConfig } from '../../config.mjs';
 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
+const WEB_TOOL_AGENTS = new Set([
+  'WebSearchAgent', 'TravelAgent', 'mercury', 'MERCURY',
+  'athena', 'ATHENA', 'oracle', 'ORACLE', 'cassandra', 'CASSANDRA',
+  'HERALD', 'DataAnalystAgent',
+]);
+
+/**
+ * Execute a single studio tool call. Returns a result string.
+ */
+async function executeStudioTool(toolCall) {
+  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}`;
+  } catch (e) {
+    return `Tool execution error: ${e.message}`;
+  }
+}
+
+/**
+ * Parse <tool_call> blocks from LLM output.
+ */
+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 {}
+  }
+  return calls;
+}
 
 export function register(router) {
   router.post('/api/studio/plan', async (req, res) => {
@@ -162,14 +232,63 @@ export function register(router) {
       const systemPrompt = sysParts.join('');
       const userMessage = stepDef?.prompt || task;
 
+      const useWebTools = WEB_TOOL_AGENTS.has(agent);
+      const finalSystemPrompt = useWebTools
+        ? systemPrompt + '\n\n' + STUDIO_WEB_TOOLS
+        : systemPrompt;
+
       let output = '';
       let tokensOut = 0;
-      await callLLMStream(config, systemPrompt, userMessage, (tok) => {
+
+      // 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');