morpheus-cli 0.8.7 → 0.8.9

package/dist/devkit/tools/browser.js

@@ -1,16 +1,48 @@
 import { tool } from '@langchain/core/tools';
 import { z } from 'zod';
+import os from 'os';
+import path from 'path';
 import { truncateOutput } from '../utils.js';
 import { registerToolFactory } from '../registry.js';
-import { PATHS } from '../../config/paths.js';
+import { Readability } from '@mozilla/readability';
+import { JSDOM } from 'jsdom';
+// ─── Local path resolution (standalone Smith, no Morpheus PATHS) ────────────
+const SMITH_HOME = process.env.SMITH_HOME ?? path.join(os.homedir(), '.smith');
+const BROWSER_CACHE = path.join(SMITH_HOME, 'cache', 'browser');
 // ─── Module-level browser singleton ────────────────────────────────────────
 let browserInstance = null;
 let pageInstance = null;
 let idleTimer = null;
 let installPromise = null;
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+// ─── Common User Agents (rotated to avoid detection) ───────────────────────
+const USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+];
+function getRandomUserAgent() {
+    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+// ─── Retry helper with exponential backoff ──────────────────────────────────
+async function withRetry(fn, maxRetries = 3, baseDelayMs = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxRetries - 1) {
+                const delay = baseDelayMs * Math.pow(2, attempt);
+                await new Promise(r => setTimeout(r, delay));
+            }
+        }
+    }
+    throw lastError;
+}
 /**
- * Ensures Chromium is downloaded to ~/.morpheus/cache/browser/.
+ * Ensures Chromium is downloaded to ~/.smith/cache/browser/.
  * Downloads only once; subsequent calls return the cached executablePath.
  */
 async function ensureChromium() {
@@ -21,24 +53,24 @@ async function ensureChromium() {
     const execPath = computeExecutablePath({
         browser: PBrowser.CHROME,
         buildId,
-        cacheDir: PATHS.browser,
+        cacheDir: BROWSER_CACHE,
     });
     const { default: fs } = await import('fs-extra');
     if (await fs.pathExists(execPath)) {
         return execPath;
     }
     // Download with progress indicator
-    process.stdout.write('[Morpheus] Installing Chromium for browser tools (first run, ~150MB)...\n');
+    process.stdout.write('[Smith] Installing Chromium for browser tools (first run, ~150MB)...\n');
     const installed = await install({
         browser: PBrowser.CHROME,
         buildId,
-        cacheDir: PATHS.browser,
+        cacheDir: BROWSER_CACHE,
         downloadProgressCallback: (downloaded, total) => {
             const pct = total > 0 ? Math.round((downloaded / total) * 100) : 0;
-            process.stdout.write(`\r[Morpheus] Downloading Chromium: ${pct}%   `);
+            process.stdout.write(`\r[Smith] Downloading Chromium: ${pct}%   `);
         },
     });
-    process.stdout.write('\n[Morpheus] Chromium installed successfully.\n');
+    process.stdout.write('\n[Smith] Chromium installed successfully.\n');
     return installed.executablePath;
 }
 /**
@@ -94,24 +126,66 @@ process.on('exit', () => {
     catch { /* ignore */ }
 });
 // ─── Tool Definitions ───────────────────────────────────────────────────────
-const browserNavigateTool = tool(async ({ url, wait_until, timeout_ms, return_html }) => {
+const browserNavigateTool = tool(async ({ url, wait_until, timeout_ms, return_html, wait_for_selector, extract_readable }) => {
     try {
         const { page } = await acquireBrowser();
-        await page.goto(url, {
-            waitUntil: (wait_until ?? 'domcontentloaded'),
-            timeout: timeout_ms ?? 30_000,
+        // Set a realistic user agent
+        await page.setUserAgent(getRandomUserAgent());
+        // Set extra headers to appear more like a real browser
+        await page.setExtraHTTPHeaders({
+            'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
         });
+        await withRetry(async () => {
+            await page.goto(url, {
+                waitUntil: (wait_until ?? 'domcontentloaded'),
+                timeout: timeout_ms ?? 30_000,
+            });
+        }, 2);
+        // Wait for specific selector if requested
+        if (wait_for_selector) {
+            await page.waitForSelector(wait_for_selector, { timeout: timeout_ms ?? 30_000 });
+        }
         const title = await page.title();
-        const text = await page.evaluate(() => document.body.innerText);
+        const htmlContent = await page.content();
+        let text;
+        let articleTitle = null;
+        let articleByline = null;
+        let articleExcerpt = null;
+        // Use Readability for cleaner content extraction
+        if (extract_readable !== false) {
+            try {
+                const dom = new JSDOM(htmlContent, { url });
+                const reader = new Readability(dom.window.document);
+                const article = reader.parse();
+                if (article) {
+                    articleTitle = article.title || null;
+                    articleByline = article.byline || null;
+                    articleExcerpt = article.excerpt || null;
+                    text = article.textContent || '';
+                }
+                else {
+                    text = await page.evaluate(() => document.body.innerText);
+                }
+            }
+            catch {
+                text = await page.evaluate(() => document.body.innerText);
+            }
+        }
+        else {
+            text = await page.evaluate(() => document.body.innerText);
+        }
         const result = {
             success: true,
             url,
             current_url: page.url(),
-            title,
+            title: articleTitle || title,
+            byline: articleByline,
+            excerpt: articleExcerpt,
             text: truncateOutput(text),
         };
         if (return_html) {
-            result.html = truncateOutput(await page.content());
+            result.html = truncateOutput(htmlContent);
         }
         return JSON.stringify(result);
     }
@@ -120,7 +194,8 @@ const browserNavigateTool = tool(async ({ url, wait_until, timeout_ms, return_ht
     }
 }, {
     name: 'browser_navigate',
-    description: 'Navigate to a URL in a real browser (executes JavaScript). Use instead of http_request for SPAs, JS-heavy pages, or sites requiring interaction. Returns page title and text content.',
+    description: 'Navigate to a URL in a real browser (executes JavaScript). Use for SPAs, JS-heavy pages, or sites requiring interaction. ' +
+        'Automatically extracts clean readable content using Mozilla Readability. Returns page title, byline, excerpt, and text content.',
     schema: z.object({
         url: z.string().describe('Full URL to navigate to (must include https://)'),
         wait_until: z
@@ -132,6 +207,14 @@ const browserNavigateTool = tool(async ({ url, wait_until, timeout_ms, return_ht
             .boolean()
             .optional()
             .describe('Also return raw HTML in response. Default: false'),
+        wait_for_selector: z
+            .string()
+            .optional()
+            .describe('CSS selector to wait for before extracting content (useful for dynamic content)'),
+        extract_readable: z
+            .boolean()
+            .optional()
+            .describe('Use Readability to extract clean article content. Default: true'),
     }),
 });
 const browserGetDomTool = tool(async ({ selector, include_attributes }) => {
@@ -213,7 +296,6 @@ const browserClickTool = tool(async ({ selector, text, timeout_ms, wait_after_ms
         }
         const clickTimeout = timeout_ms ?? 10_000;
         if (text) {
-            // Use Puppeteer pseudo-selector to find element by visible text
             await page.locator(`::-p-text(${text})`).setTimeout(clickTimeout).click();
         }
         else {
@@ -286,89 +368,128 @@ const browserFillTool = tool(async ({ selector, value, press_enter, timeout_ms }
 });
 /**
  * Search via DuckDuckGo Lite (plain HTML, no JS, no bot detection).
- * Uses a simple POST fetch — no browser required, much faster and more reliable
- * than headless browser scraping of Google.
- *
- * DDG Lite returns results as: href="URL" class='result-link'>TITLE</a>
- * and <td class='result-snippet'>SNIPPET</td>, paired by index.
- * Sponsored links have URLs starting with "https://duckduckgo.com/y.js" and are filtered out.
+ * Enhanced with better parsing, intent detection, and fallbacks.
  */
-const browserSearchTool = tool(async ({ query, num_results, language }) => {
+const browserSearchTool = tool(async ({ query, num_results, language, search_type }) => {
     try {
         const max = Math.min(num_results ?? 10, 20);
         const year = new Date().getFullYear().toString();
         const lang = language ?? "pt";
-        // ─────────────────────────────────────────────
-        // 1️⃣ Intent Classification (heurístico leve)
-        // ─────────────────────────────────────────────
         const qLower = query.toLowerCase();
         let intent = "general";
-        if (/(hoje|último|resultado|placar|próximos|futebol|202\d)/.test(qLower))
+        // News patterns (PT/EN)
+        if (/(hoje|ontem|último|resultado|placar|próximos|futebol|eleição|202\d|today|yesterday|latest|breaking|election)/i.test(qLower)) {
             intent = "news";
-        if (/(site oficial|gov|receita federal|ministério)/.test(qLower))
+        }
+        // Official/Government patterns
+        else if (/(site oficial|gov\.|receita federal|ministério|official site|government)/i.test(qLower)) {
             intent = "official";
-        if (/(api|sdk|npm|docs|documentação)/.test(qLower))
+        }
+        // Documentation patterns
+        else if (/(api|sdk|npm|pypi|docs|documentação|documentation|reference|tutorial|example)/i.test(qLower)) {
             intent = "documentation";
-        if (/(preço|valor|quanto custa)/.test(qLower))
+        }
+        // Price patterns
+        else if (/(preço|valor|quanto custa|price|cost|pricing|buy)/i.test(qLower)) {
             intent = "price";
-        // ─────────────────────────────────────────────
-        // 2️⃣ Query Refinement
-        // ─────────────────────────────────────────────
-        let refinedQuery = query;
-        if (intent === "news") {
-            refinedQuery = `${query} ${year}`;
         }
-        if (intent === "official") {
-            refinedQuery = `${query} site:gov.br OR site:org`;
+        // Academic patterns
+        else if (/(research|paper|study|journal|artigo|pesquisa|científico|scientific)/i.test(qLower)) {
+            intent = "academic";
         }
-        if (intent === "documentation") {
-            refinedQuery = `${query} documentation OR docs OR github`;
+        // How-to patterns
+        else if (/(como|how to|tutorial|guia|guide|passo a passo|step by step)/i.test(qLower)) {
+            intent = "how-to";
         }
-        if (intent === "price") {
-            refinedQuery = `${query} preço ${year} Brasil`;
+        // ─── Smart Query Refinement ──────────────────────────────────────────
+        let refinedQuery = query;
+        const refinements = [];
+        switch (intent) {
+            case "news":
+                refinements.push(year);
+                break;
+            case "official":
+                // Don't modify - let user's query stand
+                break;
+            case "documentation":
+                // Only add if not already present
+                if (!/docs|documentation|github/i.test(qLower)) {
+                    refinements.push("documentation");
+                }
+                break;
+            case "price":
+                refinements.push(year);
+                if (lang === "pt" || lang === "br")
+                    refinements.push("Brasil");
+                break;
+            case "academic":
+                refinements.push("site:scholar.google.com OR site:arxiv.org OR site:researchgate.net");
+                break;
+            case "how-to":
+                // Don't add noise, how-to queries are usually specific enough
+                break;
         }
-        // ─────────────────────────────────────────────
-        // 3️⃣ DuckDuckGo Lite Fetch
-        // ─────────────────────────────────────────────
+        if (refinements.length > 0) {
+            refinedQuery = `${query} ${refinements.join(" ")}`;
+        }
+        // ─── Region Mapping ──────────────────────────────────────────────────
         const regionMap = {
             pt: "br-pt",
             br: "br-pt",
             en: "us-en",
             us: "us-en",
+            uk: "uk-en",
+            es: "es-es",
+            fr: "fr-fr",
+            de: "de-de",
         };
         const kl = regionMap[lang] ?? lang;
-        const body = new URLSearchParams({ q: refinedQuery, kl }).toString();
-        const res = await fetch("https://lite.duckduckgo.com/lite/", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-            },
-            body,
-            signal: AbortSignal.timeout(20000),
-        });
-        if (!res.ok) {
-            return JSON.stringify({ success: false, error: `HTTP ${res.status}` });
-        }
-        const html = await res.text();
-        const linkPattern = /href="(https?:\/\/[^"]+)"[^>]*class='result-link'>([^<]+)<\/a>/g;
-        const snippetPattern = /class='result-snippet'>([\s\S]*?)<\/td>/g;
+        // ─── Execute Search with Retry ───────────────────────────────────────
+        const searchResult = await withRetry(async () => {
+            const body = new URLSearchParams({ q: refinedQuery, kl }).toString();
+            const res = await fetch("https://lite.duckduckgo.com/lite/", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "User-Agent": getRandomUserAgent(),
+                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                    "Accept-Language": lang === "pt" ? "pt-BR,pt;q=0.9,en;q=0.8" : "en-US,en;q=0.9",
+                },
+                body,
+                signal: AbortSignal.timeout(20000),
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}`);
+            }
+            return res.text();
+        }, 3);
+        const html = searchResult;
+        // ─── Improved Parsing (handles both quote styles) ────────────────────
+        // Match links with either single or double quotes
+        const linkPattern = /href=["'](https?:\/\/[^"']+)["'][^>]*class=["']result-link["'][^>]*>([^<]+)<\/a>/gi;
+        const snippetPattern = /class=["']result-snippet["'][^>]*>([\s\S]*?)<\/td>/gi;
         const links = [...html.matchAll(linkPattern)];
         const snippets = [...html.matchAll(snippetPattern)];
         if (!links.length) {
-            return JSON.stringify({
-                success: false,
-                query: refinedQuery,
-                error: "No results found",
-            });
+            // Try alternative pattern (DuckDuckGo sometimes changes format)
+            const altLinkPattern = /<a[^>]+class=["']result-link["'][^>]+href=["'](https?:\/\/[^"']+)["'][^>]*>([^<]+)<\/a>/gi;
+            const altLinks = [...html.matchAll(altLinkPattern)];
+            if (!altLinks.length) {
+                return JSON.stringify({
+                    success: false,
+                    query: refinedQuery,
+                    error: "No results found. Try a different search term.",
+                    hint: intent !== "general" ? `Detected intent: ${intent}. Try a more specific query.` : undefined,
+                });
+            }
+            links.push(...altLinks);
         }
-        // ─────────────────────────────────────────────
-        // 4️⃣ Helpers
-        // ─────────────────────────────────────────────
+        // ─── Helper Functions ────────────────────────────────────────────────
         function normalizeUrl(url) {
             try {
                 const u = new URL(url);
-                u.search = ""; // remove tracking params
+                // Remove tracking parameters
+                ['utm_source', 'utm_medium', 'utm_campaign', 'ref', 'fbclid', 'gclid'].forEach(p => u.searchParams.delete(p));
                 return u.toString();
             }
             catch {
@@ -377,59 +498,114 @@ const browserSearchTool = tool(async ({ query, num_results, language }) => {
         }
         function getDomain(url) {
             try {
-                return new URL(url).hostname.replace("www.", "");
+                return new URL(url).hostname.replace(/^www\./, "");
             }
             catch {
                 return "";
             }
         }
-        const trustedDomains = [
-            "gov.br",
-            "bbc.com",
-            "reuters.com",
-            "globo.com",
-            "uol.com",
-            "cnn.com",
-            "github.com",
-            "npmjs.com",
-            "com.br"
+        // ─── Enhanced Domain Scoring ─────────────────────────────────────────
+        const domainScores = {
+            // High authority
+            "github.com": 8,
+            "stackoverflow.com": 8,
+            "wikipedia.org": 7,
+            "docs.python.org": 8,
+            "developer.mozilla.org": 8,
+            "npmjs.com": 7,
+            "pypi.org": 7,
+            // News
+            "bbc.com": 6,
+            "reuters.com": 6,
+            "cnn.com": 5,
+            "globo.com": 5,
+            "uol.com.br": 4,
+            "g1.globo.com": 6,
+            // Brazilian official
+            "gov.br": 7,
+            // Tech blogs
+            "medium.com": 3,
+            "dev.to": 4,
+            "hashnode.dev": 3,
+            // Academic
+            "arxiv.org": 7,
+            "scholar.google.com": 7,
+            "researchgate.net": 6,
+        };
+        const penalizedPatterns = [
+            /login|signin|signup/i,
+            /assine|subscribe|paywall/i,
+            /compre|buy now|add to cart/i,
+            /pinterest\.com/i,
+            /facebook\.com/i,
+            /instagram\.com/i,
         ];
         function scoreResult(result) {
             let score = 0;
             const domain = getDomain(result.url);
-            if (trustedDomains.some((d) => domain.includes(d)))
+            // Domain-based scoring
+            for (const [d, s] of Object.entries(domainScores)) {
+                if (domain.includes(d) || domain.endsWith(d)) {
+                    score += s;
+                    break;
+                }
+            }
+            // Intent-based bonuses
+            if (intent === "documentation") {
+                if (/github|docs|reference|api/i.test(domain))
+                    score += 4;
+                if (/example|tutorial|guide/i.test(result.title))
+                    score += 2;
+            }
+            if (intent === "news") {
+                if (/(globo|uol|cnn|bbc|reuters|g1)/i.test(domain))
+                    score += 4;
+                if (new RegExp(year).test(result.snippet))
+                    score += 2;
+            }
+            if (intent === "official" && /gov\.|\.gov|official/i.test(domain)) {
                 score += 5;
-            if (intent === "official" && domain.includes("gov"))
+            }
+            if (intent === "academic" && /arxiv|scholar|research/i.test(domain)) {
                 score += 5;
-            if (intent === "documentation" && domain.includes("github"))
-                score += 4;
-            if (intent === "news" && /(globo|uol|cnn|bbc)/.test(domain))
+            }
+            if (intent === "how-to" && /tutorial|guide|how/i.test(result.title)) {
                 score += 3;
-            if (result.title.toLowerCase().includes(query.toLowerCase()))
-                score += 2;
-            if (result.snippet.length > 120)
+            }
+            // Title relevance
+            const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+            const titleLower = result.title.toLowerCase();
+            const matchedWords = queryWords.filter(w => titleLower.includes(w));
+            score += Math.min(matchedWords.length * 1.5, 5);
+            // Snippet quality
+            if (result.snippet.length > 100)
                 score += 1;
-            if (/login|assine|subscribe|paywall/i.test(result.snippet))
-                score -= 3;
-            return score;
+            if (result.snippet.length > 200)
+                score += 1;
+            // Penalties
+            for (const pattern of penalizedPatterns) {
+                if (pattern.test(result.url) || pattern.test(result.snippet)) {
+                    score -= 4;
+                }
+            }
+            return Math.max(0, score);
         }
-        // ─────────────────────────────────────────────
-        // 5️⃣ Build Results + Deduplicate Domain
-        // ─────────────────────────────────────────────
+        // ─── Process Results ─────────────────────────────────────────────────
         const domainSeen = new Set();
         const results = [];
         for (let i = 0; i < links.length; i++) {
             const rawUrl = links[i][1];
-            if (rawUrl.startsWith("https://duckduckgo.com/"))
+            if (rawUrl.includes("duckduckgo.com"))
                 continue;
             const url = normalizeUrl(rawUrl);
             const domain = getDomain(url);
+            // Skip if we already have this domain (dedupe)
             if (domainSeen.has(domain))
                 continue;
             domainSeen.add(domain);
-            const title = links[i][2].trim();
+            const title = links[i][2].trim().replace(/\s+/g, " ");
             const snippet = snippets[i]
-                ? snippets[i][1].replace(/<[^>]+>/g, "").trim()
+                ? snippets[i][1].replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim()
                 : "";
             const result = { title, url, snippet };
             const score = scoreResult(result);
@@ -442,33 +618,24 @@ const browserSearchTool = tool(async ({ query, num_results, language }) => {
                 error: "No valid results after filtering",
             });
         }
-        // ─────────────────────────────────────────────
-        // 6️⃣ Ranking
-        // ─────────────────────────────────────────────
+        // Sort by score and take top results
         results.sort((a, b) => b.score - a.score);
         const topResults = results.slice(0, max);
-        const avgScore = topResults.reduce((acc, r) => acc + r.score, 0) /
-            topResults.length;
-        // ─────────────────────────────────────────────
-        // 7️⃣ Low-Confidence Auto Retry
-        // ─────────────────────────────────────────────
-        if (avgScore < 2 && intent !== "general") {
-            return JSON.stringify({
-                success: false,
-                query: refinedQuery,
-                warning: "Low confidence results. Consider refining query further.",
-                results: topResults,
-            });
-        }
+        // Calculate confidence
+        const avgScore = topResults.reduce((acc, r) => acc + r.score, 0) / topResults.length;
+        const confidence = avgScore >= 6 ? "high" : avgScore >= 3 ? "medium" : "low";
         return JSON.stringify({
             success: true,
             original_query: query,
-            refined_query: refinedQuery,
+            refined_query: refinedQuery !== query ? refinedQuery : undefined,
             intent,
+            confidence,
+            result_count: topResults.length,
             results: topResults.map((r) => ({
                 title: r.title,
                 url: r.url,
                 snippet: r.snippet,
+                domain: r.domain,
                 score: r.score,
             })),
         });
@@ -477,20 +644,172 @@ const browserSearchTool = tool(async ({ query, num_results, language }) => {
         return JSON.stringify({
             success: false,
             error: err.message,
+            hint: "Search failed. Try simplifying your query or check your internet connection."
         });
     }
 }, {
     name: "browser_search",
-    description: "Enhanced internet search with query refinement, ranking, deduplication, and confidence scoring. Uses DuckDuckGo Lite.",
+    description: "Intelligent web search with automatic intent detection (news, documentation, how-to, academic, etc.), " +
+        "smart query refinement, domain authority scoring, and confidence levels. Uses DuckDuckGo Lite for privacy. " +
+        "Returns ranked results with relevance scores.",
+    schema: z.object({
+        query: z.string().describe("Search query. Be specific for better results."),
+        num_results: z.number().int().min(1).max(20).optional().describe("Max results to return. Default: 10"),
+        language: z.enum(["pt", "br", "en", "us", "uk", "es", "fr", "de"]).optional().describe("Search region/language. Default: pt"),
+        search_type: z.enum(["web", "news"]).optional().describe("Type of search. Default: web (news not yet implemented)"),
+    }),
+});
+/**
+ * Lightweight content fetcher - uses fetch + Readability instead of Puppeteer.
+ * Much faster for static pages, articles, documentation, etc.
+ */
+const browserFetchContentTool = tool(async ({ url, timeout_ms, include_links }) => {
+    try {
+        const result = await withRetry(async () => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout_ms ?? 30_000);
+            try {
+                const response = await fetch(url, {
+                    signal: controller.signal,
+                    headers: {
+                        'User-Agent': getRandomUserAgent(),
+                        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                        'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7',
+                        'Accept-Encoding': 'gzip, deflate, br',
+                        'Cache-Control': 'no-cache',
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const contentType = response.headers.get('content-type') || '';
+                // Handle JSON responses directly
+                if (contentType.includes('application/json')) {
+                    const json = await response.json();
+                    return {
+                        success: true,
+                        url,
+                        content_type: 'json',
+                        data: json,
+                    };
+                }
+                const html = await response.text();
+                return { html, response };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }, 3);
+        // If it was JSON, return early
+        if ('content_type' in result && result.content_type === 'json') {
+            return JSON.stringify(result);
+        }
+        const { html } = result;
+        // Parse with JSDOM and extract with Readability
+        const dom = new JSDOM(html, { url });
+        const document = dom.window.document;
+        // Extract metadata
+        const title = document.querySelector('title')?.textContent?.trim() || '';
+        const description = document.querySelector('meta[name="description"]')?.getAttribute('content') ||
+            document.querySelector('meta[property="og:description"]')?.getAttribute('content') || '';
+        const author = document.querySelector('meta[name="author"]')?.getAttribute('content') || '';
+        // Use Readability for main content
+        const reader = new Readability(document.cloneNode(true));
+        const article = reader.parse();
+        // Extract links if requested
+        let links = [];
+        if (include_links) {
+            const anchors = document.querySelectorAll('a[href]');
+            const seen = new Set();
+            anchors.forEach((a) => {
+                const href = a.getAttribute('href');
+                const text = a.textContent?.trim();
+                if (href && text && !seen.has(href) && href.startsWith('http')) {
+                    seen.add(href);
+                    links.push({ text: text.slice(0, 100), href });
+                }
+            });
+            links = links.slice(0, 50); // Limit to 50 links
+        }
+        const output = {
+            success: true,
+            url,
+            title: article?.title || title,
+            description,
+            author: article?.byline || author,
+            excerpt: article?.excerpt || description,
+            content: truncateOutput(article?.textContent || document.body?.textContent || ''),
+            word_count: article?.textContent?.split(/\s+/).length || 0,
+        };
+        if (include_links && links.length > 0) {
+            output.links = links;
+        }
+        return JSON.stringify(output);
+    }
+    catch (err) {
+        return JSON.stringify({
+            success: false,
+            url,
+            error: err.message,
+            hint: 'If this is a JavaScript-heavy site, try browser_navigate instead.'
+        });
+    }
+}, {
+    name: 'browser_fetch_content',
+    description: 'Fast, lightweight content fetcher for static pages, articles, documentation, and APIs. ' +
+        'Uses HTTP fetch + Readability (no browser needed). Much faster than browser_navigate. ' +
+        'Use this for: documentation pages, blog posts, news articles, API endpoints. ' +
+        'For JavaScript-heavy SPAs, use browser_navigate instead.',
+    schema: z.object({
+        url: z.string().describe('Full URL to fetch (must include https://)'),
+        timeout_ms: z.number().optional().describe('Timeout in ms. Default: 30000'),
+        include_links: z.boolean().optional().describe('Extract and return all links from the page. Default: false'),
+    }),
+});
+/**
+ * Screenshot tool - useful for visual verification and debugging
+ */
+const browserScreenshotTool = tool(async ({ selector, full_page }) => {
+    try {
+        const { page } = await acquireBrowser();
+        let screenshot;
+        if (selector) {
+            const element = await page.$(selector);
+            if (!element) {
+                return JSON.stringify({ success: false, error: `Element not found: ${selector}` });
+            }
+            screenshot = await element.screenshot({ encoding: 'binary' });
+        }
+        else {
+            screenshot = await page.screenshot({
+                fullPage: full_page ?? false,
+                encoding: 'binary'
+            });
+        }
+        const base64 = screenshot.toString('base64');
+        return JSON.stringify({
+            success: true,
+            current_url: page.url(),
+            title: await page.title(),
+            screenshot_base64: base64,
+            size_bytes: screenshot.length,
+        });
+    }
+    catch (err) {
+        return JSON.stringify({ success: false, error: err.message });
+    }
+}, {
+    name: 'browser_screenshot',
+    description: 'Take a screenshot of the current page or a specific element. ' +
+        'Useful for visual verification and debugging. Returns base64-encoded PNG.',
     schema: z.object({
-        query: z.string(),
-        num_results: z.number().int().min(1).max(20).optional(),
-        language: z.string().optional(),
+        selector: z.string().optional().describe('CSS selector of element to screenshot. Omit for full viewport.'),
+        full_page: z.boolean().optional().describe('Capture full scrollable page. Default: false (viewport only)'),
     }),
 });
 // ─── Factory ────────────────────────────────────────────────────────────────
 export function createBrowserTools(_ctx) {
-    if (process.env.MORPHEUS_BROWSER_ENABLED === 'false') {
+    if (process.env.SMITH_BROWSER_ENABLED === 'false') {
         return [];
     }
     return [
@@ -499,6 +818,8 @@ export function createBrowserTools(_ctx) {
         browserClickTool,
         browserFillTool,
         browserSearchTool,
+        browserFetchContentTool,
+        browserScreenshotTool,
     ];
 }
 registerToolFactory(createBrowserTools, 'browser');

package/dist/runtime/apoc.js

@@ -259,7 +259,7 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
         try {
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await this.agent.invoke({ messages });
+            const response = await this.agent.invoke({ messages }, { recursionLimit: 100 });
             const durationMs = Date.now() - startMs;
             const apocConfig = this.config.apoc || this.config.llm;
             const lastMessage = response.messages[response.messages.length - 1];

package/dist/runtime/keymaker.js

@@ -116,7 +116,7 @@ CRITICAL — NEVER FABRICATE DATA:
                 origin_user_id: taskContext?.origin_user_id,
             };
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 100 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"

package/dist/runtime/memory/sati/service.js

@@ -97,7 +97,7 @@ export class SatiService {
                 console.warn('[SatiService] Failed to persist input log:', e);
             }
             const satiStartMs = Date.now();
-            const response = await agent.invoke({ messages });
+            const response = await agent.invoke({ messages }, { recursionLimit: 100 });
             const satiDurationMs = Date.now() - satiStartMs;
             const lastMessage = response.messages[response.messages.length - 1];
             let content = lastMessage.content.toString();

package/dist/runtime/neo.js

@@ -137,7 +137,7 @@ ${context ? `Context:\n${context}` : ""}
             };
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 100 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"

package/dist/runtime/oracle.js

@@ -395,7 +395,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let syncDelegationCount = 0;
             const oracleStartMs = Date.now();
             const response = await TaskRequestContext.run(invokeContext, async () => {
-                const agentResponse = await this.provider.invoke({ messages });
+                const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 100 });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
                 syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;

package/dist/runtime/smiths/delegator.js

@@ -7,6 +7,8 @@ import { ConfigManager } from '../../config/manager.js';
 import { ProviderFactory } from '../providers/factory.js';
 import { buildDevKit } from '../../devkit/index.js';
 import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+import { AuditRepository } from '../audit/repository.js';
+import { TaskRequestContext } from '../tasks/context.js';
 /**
  * SmithDelegator — delegates natural-language tasks to a specific Smith.
  *
@@ -70,6 +72,25 @@ export class SmithDelegator {
             connection.onMessage(progressHandler);
             try {
                 const result = await connection.sendTask(taskId, localTool.name, args);
+                // Audit the remote tool execution — data already available from Smith's response
+                const sessionId = TaskRequestContext.get()?.session_id ?? 'smith';
+                const resultStr = result.data !== undefined
+                    ? (typeof result.data === 'string' ? result.data : JSON.stringify(result.data))
+                    : result.error;
+                const meta = { smith: smithName };
+                if (args && Object.keys(args).length > 0)
+                    meta.args = args;
+                if (resultStr)
+                    meta.result = resultStr.length > 500 ? resultStr.slice(0, 500) + '…' : resultStr;
+                AuditRepository.getInstance().insert({
+                    session_id: sessionId,
+                    event_type: 'tool_call',
+                    agent: 'smith',
+                    tool_name: `${smithName}/${localTool.name}`,
+                    duration_ms: result.duration_ms,
+                    status: result.success ? 'success' : 'error',
+                    metadata: meta,
+                });
                 if (result.success) {
                     return typeof result.data === 'string'
                         ? result.data
@@ -135,7 +156,7 @@ Respond in the same language as the task.`);
                 : task;
             const messages = [systemMessage, new HumanMessage(userContent)];
             const startMs = Date.now();
-            const response = await agent.invoke({ messages });
+            const response = await agent.invoke({ messages }, { recursionLimit: 100 });
             const durationMs = Date.now() - startMs;
             // Extract final response
             const lastMessage = response.messages[response.messages.length - 1];

package/dist/runtime/trinity.js

@@ -238,7 +238,7 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ''}
         const messages = [systemMessage, userMessage];
         try {
             const startMs = Date.now();
-            const response = await this.agent.invoke({ messages });
+            const response = await this.agent.invoke({ messages }, { recursionLimit: 100 });
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morpheus-cli",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "Morpheus is a local AI agent for developers, running as a CLI daemon that connects to LLMs, local tools, and MCPs, enabling interaction via Terminal, Telegram, and Discord. Inspired by the character Morpheus from *The Matrix*, the project acts as an intelligent orchestrator, bridging the gap between the developer and complex systems.",
   "bin": {
     "morpheus": "./bin/morpheus.js"
@@ -34,8 +34,10 @@
     "@langchain/mcp-adapters": "^1.1.2",
     "@langchain/ollama": "^1.2.1",
     "@langchain/openai": "^1.2.3",
+    "@mozilla/readability": "^0.6.0",
     "@openrouter/sdk": "^0.8.0",
     "@types/better-sqlite3": "^7.6.13",
+    "@types/jsdom": "^28.0.0",
     "@types/pg": "^8.16.0",
     "@xenova/transformers": "^2.17.2",
     "better-sqlite3": "^12.6.2",
@@ -54,6 +56,7 @@
     "figlet": "^1.10.0",
     "fs-extra": "^11.3.3",
     "js-yaml": "^4.1.1",
+    "jsdom": "^28.1.0",
     "langchain": "^1.2.16",
     "mcp-remote": "^0.1.38",
     "mongodb": "^6.21.0",