@causyne/agent 0.0.0-stage → 1.10.0

package/src/tools/toolForge.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { causyneHome } from '../utils/paths.js';
+
+const CUSTOM_TOOLS_DIR = path.join(causyneHome(), 'custom_tools');
+
+export const toolForgeTool = {
+  schema: {
+    name: 'tool.forge',
+    description: 'Self-Evolution Engine: Write a new custom Javascript tool that will be permanently added to your capabilities. Use this when you lack a specific tool to accomplish a goal. The tool will be hot-reloaded instantly.',
+    parameters: {
+      type: 'object',
+      properties: {
+        toolName: {
+          type: 'string',
+          description: 'CamelCase name of the tool (e.g. "imageResizer", "pdfExtractor"). Must be alphanumeric without spaces.',
+        },
+        toolDescription: {
+          type: 'string',
+          description: 'Detailed description of what the tool does, so you know how to use it later.',
+        },
+        parametersSchema: {
+          type: 'string',
+          description: 'Stringified JSON schema of the arguments the tool accepts. E.g. {"type":"object","properties":{"filePath":{"type":"string"}},"required":["filePath"]}',
+        },
+        javascriptCode: {
+          type: 'string',
+          description: 'The actual Node.js code block for the execute function. MUST be an async function accepting (args, context). Must return an object like { success: true, data: ... }. DO NOT use `export` or `const toolName =`, just provide the raw function body or `async (args, context) => { ... }`.',
+        },
+      },
+      required: ['toolName', 'toolDescription', 'parametersSchema', 'javascriptCode'],
+    }
+  },
+  execute: async (args, context) => {
+    try {
+      const { toolName, toolDescription, parametersSchema, javascriptCode } = args;
+
+      // Validate name
+      if (!/^[a-zA-Z0-9_]+$/.test(toolName)) {
+        return { success: false, error: 'Invalid toolName. Use alphanumeric characters only.' };
+      }
+
+      // Ethical Safety Gate Layer 4: Block malicious tool names and descriptions
+      const BANNED_TOOL_NAMES = [
+        /keylog/i, /phish/i, /exploit/i, /malware/i, /trojan/i,
+        /ransomware/i, /rootkit/i, /backdoor/i, /ddos/i,
+        /credential.?harvest/i, /password.?steal/i, /brute.?force/i,
+        /crypto.?mine/i, /wallet.?drain/i, /spyware/i, /surveil/i
+      ];
+
+      for (const pattern of BANNED_TOOL_NAMES) {
+        if (pattern.test(toolName) || pattern.test(toolDescription)) {
+          return {
+            success: false,
+            error: 'Safety violation: Tool name or description indicates malicious intent. Causyne exists to make the world better.'
+          };
+        }
+      }
+
+      
+      const SUBPROCESS_MODULE = "child_process";
+      const BANNED_TOOL_PATTERNS = [
+        /process\.kill\(/,
+        new RegExp(SUBPROCESS_MODULE),
+        new RegExp('require\\s*\\(\\s*[\'"]' + SUBPROCESS_MODULE + '[\'"]\\s*\\)'),
+        /fs\.(rm|rmdir)Sync.*recursive/i,
+        /fs\.writeFileSync\s*\(\s*['"]\/etc/,
+        /fs\.writeFileSync\s*\(\s*['"]C:\\\\Windows/i,
+        /stratum\+tcp/i,
+        /cryptonight|ethash|randomx/i,
+        /iohook|keypress|keylog/i,
+        /getUserMedia|MediaRecorder.*audio|MediaRecorder.*video/i,
+        /sqlmap|nikto|metasploit/i
+      ];
+
+      for (const pattern of BANNED_TOOL_PATTERNS) {
+        if (pattern.test(javascriptCode)) {
+          return {
+            success: false,
+            error: 'Safety violation: Tool code contains a banned pattern. Causyne cannot forge tools designed for harm.'
+          };
+        }
+      }
+
+      // Ensure directory exists
+      if (!fs.existsSync(CUSTOM_TOOLS_DIR)) {
+        fs.mkdirSync(CUSTOM_TOOLS_DIR, { recursive: true, mode: 0o700 });
+      }
+
+      const filePath = path.join(CUSTOM_TOOLS_DIR, `${toolName}.js`);
+
+      // Construct the ES Module file
+      const fileContent = `
+// AUTOGENERATED CUSTOM TOOL: ${toolName}
+// Generated at: ${new Date().toISOString()}
+
+export const ${toolName}Tool = {
+  name: '${toolName}',
+  description: ${JSON.stringify(toolDescription)},
+  parameters: ${parametersSchema},
+  execute: async (args, context) => {
+    // LLM Generated Code Start
+    const llmFunction = ${javascriptCode.trim().startsWith('async') ? javascriptCode : `async (args, context) => { ${javascriptCode} }`};
+    return await llmFunction(args, context);
+    // LLM Generated Code End
+  }
+};
+`;
+
+      fs.writeFileSync(filePath, fileContent.trim());
+
+      return {
+        success: true,
+        message: `Successfully forged new tool '${toolName}'. It is saved to ${filePath}. It will be available on the next loop iteration.`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to forge tool: ${error.message}`
+      };
+    }
+  },
+};

package/src/tools/updatePlan.js

@@ -0,0 +1,88 @@
+import fs from 'fs';
+import path from 'path';
+
+export const updatePlan = {
+  schema: {
+    name: 'update_plan',
+    description: 'Self-Correcting Trajectory Engine: Update specific tasks in your plan using delta operations without rewriting everything.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['read', 'ADD_TASK', 'REMOVE_TASK', 'MARK_COMPLETED', 'MARK_FAILED']
+        },
+        taskId: { type: 'string', description: 'ID of the task to modify' },
+        taskContent: { type: 'string', description: 'Content of the new task (if ADD_TASK)' },
+        failureReason: { type: 'string', description: 'REQUIRED if action is MARK_FAILED' }
+      },
+      required: ['action']
+    }
+  },
+  
+  execute: async (args) => {
+    try {
+      const todoPath = path.resolve(process.cwd(), '.causyne_todos.json');
+      const mdPath = path.resolve(process.cwd(), 'AGI_PLAN.md');
+      
+      let todos = [];
+      if (fs.existsSync(todoPath)) {
+        todos = JSON.parse(fs.readFileSync(todoPath, 'utf8'));
+      }
+      
+      if (args.action === 'read') {
+        if (!fs.existsSync(mdPath)) return "No plan exists.";
+        return fs.readFileSync(mdPath, 'utf8');
+      }
+      
+      if (args.action === 'MARK_FAILED' && !args.failureReason) {
+        return "Error: You MUST provide a failureReason when marking a task as failed.";
+      }
+
+      if (args.action === 'ADD_TASK') {
+        if (!args.taskId || !args.taskContent) return "Missing taskId or taskContent";
+        todos.push({ id: args.taskId, content: args.taskContent, status: 'pending' });
+      } 
+      else if (args.action === 'REMOVE_TASK') {
+        todos = todos.filter(t => t.id !== args.taskId);
+      }
+      else if (args.action === 'MARK_COMPLETED') {
+        const t = todos.find(t => t.id === args.taskId);
+        if (t) t.status = 'completed';
+      }
+      else if (args.action === 'MARK_FAILED') {
+        const t = todos.find(t => t.id === args.taskId);
+        if (t) {
+          t.status = 'pending'; // Reset it
+          // Phase 2 AGI Upgrade: Auto-Pivot
+          todos.push({ 
+            id: `investigate_${args.taskId}`, 
+            content: `Investigate failure of ${args.taskId}: ${args.failureReason}`, 
+            status: 'in_progress' 
+          });
+        }
+      }
+
+      // Sync JSON
+      fs.writeFileSync(todoPath, JSON.stringify(todos, null, 2), 'utf8');
+      
+      // Sync MD
+      let mdContent = '# AGI Execution Plan\n\n';
+      for (const t of todos) {
+        let box = '[ ]';
+        if (t.status === 'in_progress') box = '[/]';
+        if (t.status === 'completed') box = '[x]';
+        mdContent += `- ${box} ${t.id}: ${t.content}\n`;
+      }
+      fs.writeFileSync(mdPath, mdContent, 'utf8');
+      
+      if (args.action === 'MARK_FAILED') {
+        return `Task failed. Auto-pivot engaged. Added investigation task.`;
+      }
+
+      return "Plan delta updated successfully.";
+    } catch (error) {
+      return `Error updating plan: ${error.message}`;
+    }
+  }
+};

package/src/tools/viewImage.js

@@ -0,0 +1,82 @@
+import fs from 'fs/promises';
+import { resolveUserPath } from '../utils/paths.js';
+import { existsSync, statSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+
+export const viewImage = {
+  schema: {
+    name: 'view_image',
+    description: 'Multi-Modal Pre-Processing Engine. View an image file from disk. Automatically compresses huge images to save tokens. For text-only LLMs, it autonomously extracts text via OCR.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Absolute or relative path to the image file' },
+        extractTextOnly: { type: 'boolean', description: 'If true, skips Vision APIs and uses local OCR to read text from the image.' }
+      },
+      required: ['path']
+    }
+  },
+  
+  execute: async (args, sandbox) => {
+    try {
+      const targetPath = resolveUserPath(args.path);
+      if (!existsSync(targetPath)) {
+        return { success: false, error: `Image not found at ${targetPath}` };
+      }
+      
+      const stat = statSync(targetPath);
+      if (stat.size > 20 * 1024 * 1024) { 
+        return { success: false, error: 'Image too large. Maximum raw size is 20MB.' };
+      }
+
+      // Phase 6 AGI Upgrade: OCR Fallback for Text-Only LLMs
+      const forceOcr = args.extractTextOnly || (sandbox && sandbox.llmSupportsVision === false);
+      
+      if (forceOcr) {
+        const ocr = await ensureCapability('ocr');
+        if (!ocr.ok) return { success: false, error: ocr.reason, requiresConsent: ocr.requiresConsent };
+        const Tesseract = await loadCapabilityPackage('tesseract.js');
+        
+        const worker = await Tesseract.createWorker('eng');
+        const { data: { text } } = await worker.recognize(targetPath);
+        await worker.terminate();
+        
+        return { success: true, output: `[OCR FALLBACK] Extracted Text from Image:\n\n${text}` };
+      }
+      
+      // Phase 6 AGI Upgrade: Dynamic Resizing & Format Normalization
+      let processedBuffer;
+      let mimeType = 'image/jpeg';
+      
+      try {
+        // sharp already lives in the Cortex tree as a pinned override, so it is
+        // loaded from there rather than installed a second time.
+        const sharp = await loadCapabilityPackage('sharp');
+        processedBuffer = await sharp(targetPath)
+          .resize({ width: 1024, height: 1024, fit: 'inside', withoutEnlargement: true })
+          .jpeg({ quality: 85 })
+          .toBuffer();
+      } catch (e) {
+        // Fallback if sharp is missing (return raw buffer but warn)
+        processedBuffer = await fs.readFile(targetPath);
+        const ext = path.extname(targetPath).toLowerCase();
+        if (ext === '.png') mimeType = 'image/png';
+        else if (ext === '.webp') mimeType = 'image/webp';
+        else if (ext === '.gif') mimeType = 'image/gif';
+      }
+      
+      const base64 = processedBuffer.toString('base64');
+      
+      return {
+        _is_image_marker: true,
+        mimeType,
+        base64,
+        filename: path.basename(targetPath)
+      };
+    } catch (error) {
+      return { success: false, error: `Error viewing image: ${error.message}` };
+    }
+  }
+};

package/src/tools/visionInspector.js

@@ -0,0 +1,154 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+
+const execFileAsync = promisify(execFile);
+
+// Helper: Sovereign Workspace Buffer to prevent /tmp/ boundary errors
+function getWorkspaceTempDir() {
+  const dir = path.join(process.cwd(), '.tmp_causyne_3d');
+  if (!fsSync.existsSync(dir)) {
+    fsSync.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+export const visionInspector = {
+  schema: {
+    name: 'vision.inspect_ui',
+    description: 'Captures live desktop (macOS/Windows) or mobile (Android via ADB) screenshots directly into the local workspace buffer (.tmp_causyne_3d/) and extracts spatial bounding box coordinates for visual layout verification, LCP debugging, and UI automation.',
+    parameters: {
+      type: 'object',
+      properties: {
+        target: { 
+          type: 'string', 
+          enum: ['desktop', 'android_adb'], 
+          description: 'Target device screen to capture: desktop (OS GUI) or android_adb (connected mobile screen).' 
+        },
+        prompt: { type: 'string', description: 'The verification prompt describing what UI element, visual bug, alignment, or LCP state is being audited.' },
+        deviceSerial: { type: 'string', description: 'Optional Android ADB device serial when target is android_adb.' }
+      },
+      required: ['target', 'prompt']
+    }
+  },
+
+  async execute(args, context = {}) {
+    try {
+      const target = args.target || 'desktop';
+      const prompt = args.prompt || 'Inspect UI spatial layout';
+      const tempDir = getWorkspaceTempDir();
+      const timestamp = Date.now();
+      const destPath = path.join(tempDir, `ui_inspect_${target}_${timestamp}.png`);
+
+      if (target === 'android_adb') {
+        const adbArgs = [];
+        if (args.deviceSerial) adbArgs.push('-s', args.deviceSerial);
+        adbArgs.push('shell', 'screencap', '-p');
+
+        try {
+          const { stdout } = await execFileAsync('adb', adbArgs, { encoding: 'buffer', maxBuffer: 20 * 1024 * 1024 });
+          // Handle CRLF on Windows ADB pipes
+          let cleanBuffer = stdout;
+          if (process.platform === 'win32') {
+            cleanBuffer = Buffer.from(stdout.toString('binary').replace(/\r\n/g, '\n'), 'binary');
+          }
+          await fs.writeFile(destPath, cleanBuffer);
+        } catch (adbErr) {
+          return {
+            success: false,
+            error: `ADB Mobile Vision Capture Failed: ${adbErr.message}. Ensure device is connected via ADB USB/WiFi.`
+          };
+        }
+      } else {
+        // Desktop OS Screen Capture
+        try {
+          if (process.platform === 'darwin') {
+            await execFileAsync('screencapture', ['-x', destPath]);
+          } else if (process.platform === 'win32') {
+            const psCmd = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing; $screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds; $bitmap = New-Object System.Drawing.Bitmap $screen.Width, $screen.Height; $graphics = [System.Drawing.Graphics]::FromImage($bitmap); $graphics.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size); $bitmap.Save('${destPath.replace(/\\/g, '\\\\')}', [System.Drawing.Imaging.ImageFormat]::Png); $graphics.Dispose(); $bitmap.Dispose();`;
+            await execFileAsync('powershell.exe', ['-NoLogo', '-NoProfile', '-Command', psCmd]);
+          } else {
+            // macOS and Windows capture natively above; only this branch needs
+            // the provisioned package.
+            const vision = await ensureCapability('vision');
+            if (!vision.ok) throw new Error(vision.reason);
+            const screenshotDesktop = await loadCapabilityPackage('screenshot-desktop');
+            await screenshotDesktop({ filename: destPath });
+          }
+        } catch (captureErr) {
+          
+          if (captureErr.message && (captureErr.message.includes('could not create image from display') || captureErr.message.includes('No display') || captureErr.message.includes('xclip'))) {
+            // Check if any existing buffer image exists in tempDir to inspect
+            const existingFiles = fsSync.readdirSync(tempDir).filter(f => f.endsWith('.png'));
+            if (existingFiles.length > 0) {
+              const fallbackFile = path.join(tempDir, existingFiles[existingFiles.length - 1]);
+              return {
+                success: true,
+                output: JSON.stringify({
+                  status: 'Headless environment detected: GUI capture restricted. Returned latest buffered workspace visual frame.',
+                  target_device: target,
+                  verification_prompt: prompt,
+                  filepath: fallbackFile,
+                  workspace_boundary_safe: true,
+                  headless_notice: captureErr.message
+                }, null, 2)
+              };
+            }
+            return {
+              success: true,
+              output: JSON.stringify({
+                status: 'Live GUI capture is unavailable in this desktop session. Connect an active display or use an ADB mobile target.',
+                target_device: target,
+                verification_prompt: prompt,
+                headless_notice: captureErr.message
+              }, null, 2)
+            };
+          }
+          throw captureErr;
+        }
+      }
+
+      // Check spatial OCR / bounding box extraction
+      let textMap = '';
+      try {
+        const ocr = await ensureCapability('ocr');
+        if (!ocr.ok) throw new Error(ocr.reason);
+        const Tesseract = await loadCapabilityPackage('tesseract.js');
+        const worker = await Tesseract.createWorker('eng');
+        const { data: { words } } = await worker.recognize(destPath);
+        await worker.terminate();
+
+        const confidentWords = (words || []).filter(w => w.confidence > 75).slice(0, 30);
+        if (confidentWords.length > 0) {
+          textMap = confidentWords.map(w => {
+            const centerX = Math.floor((w.bbox.x0 + w.bbox.x1) / 2);
+            const centerY = Math.floor((w.bbox.y0 + w.bbox.y1) / 2);
+            return `- [${w.text}] X:${centerX}, Y:${centerY}`;
+          }).join('\n');
+        }
+      } catch (ocrErr) {
+        textMap = `[OCR Text Bounding extraction skipped: ${ocrErr.message}]`;
+      }
+
+      // Route notification to mobile app (`AgentScreen.kt`)
+
+      return {
+        success: true,
+        output: JSON.stringify({
+          status: 'Visual inspection frame captured cleanly inside workspace buffer',
+          target_device: target,
+          verification_prompt: prompt,
+          filepath: destPath,
+          workspace_boundary_safe: true,
+          detected_spatial_elements: textMap || 'No confident OCR text tokens detected.'
+        }, null, 2)
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/webFetch.js

@@ -0,0 +1,74 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+// Phase 3 AGI Upgrade: HTML Cleanup to Markdown
+function htmlToText(html) {
+  // AGI Optimization: Aggressively strip scripts, styles, svg, and tags
+  let text = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '');
+  text = text.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '');
+  text = text.replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, '');
+  text = text.replace(/<[^>]+>/g, ' '); // Strip HTML tags
+  text = text.replace(/&nbsp;/g, ' '); // Decode basic entities
+  text = text.replace(/\s{2,}/g, ' '); // Normalize spaces
+  text = text.replace(/\n\s*\n/g, '\n\n'); // Normalize line breaks
+  return text.trim();
+}
+
+export const webFetch = {
+  schema: {
+    name: 'web.fetch',
+    description: 'Make HTTP requests. Automatically strips raw HTML into clean text to protect Context Window.',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: { type: 'string' },
+        method: { type: 'string' },
+        headers: { type: 'object' },
+        body: { type: 'string' },
+        outputFile: { type: 'string', description: 'If provided, saves as a binary file instead of returning text' }
+      },
+      required: ['url']
+    }
+  },
+  async execute(args) {
+    try {
+      const options = {
+        method: args.method || 'GET',
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Chrome/120.0.0.0 Safari/537.36',
+          ...args.headers
+        }
+      };
+      
+      if (args.body) options.body = args.body;
+      
+      const response = await fetch(args.url, options);
+      
+      if (args.outputFile) {
+        const target = args.outputFile.replace(/^~\//, os.homedir() + '/');
+        const buffer = await response.arrayBuffer();
+        await fs.writeFile(target, Buffer.from(buffer));
+        return { success: true, output: `Downloaded ${buffer.byteLength} bytes to ${args.outputFile}`, status: response.status };
+      }
+      
+      const text = await response.text();
+      
+      // Phase 3 AGI Upgrade: Clean HTML unless it's an API JSON response
+      let cleanOutput = text;
+      const contentType = response.headers.get('content-type') || '';
+      if (contentType.includes('text/html')) {
+        cleanOutput = htmlToText(text);
+      }
+      
+      // Strict Context Paging Protection
+      if (cleanOutput.length > 50000) {
+        cleanOutput = cleanOutput.substring(0, 50000) + '\n\n[... OUTPUT TRUNCATED TO 50KB ...]';
+      }
+
+      return { success: true, output: cleanOutput, status: response.status };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/webSearch.js

@@ -0,0 +1,82 @@
+export const webSearch = {
+  schema: {
+    name: 'web_search',
+    description: 'High-Precision SERP Router. Searches the web and extracts top organic results.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'The search query.'
+        }
+      },
+      required: ['query']
+    }
+  },
+  
+  execute: async (args) => {
+    try {
+      // Phase 7 AGI Upgrade: Zero-Dependency Native Fetch Scraper
+      // Skipping Google's aggressive 429 Blocks by utilizing Yahoo Search HTML parsing.
+      const url = 'https://search.yahoo.com/search?p=' + encodeURIComponent(args.query);
+      
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+          'Accept-Language': 'en-US,en;q=0.5'
+        }
+      });
+      
+      if (!response.ok) {
+        throw new Error(`HTTP Error ${response.status}`);
+      }
+      
+      const html = await response.text();
+      const results = [];
+      
+      // Robust Regex to extract Yahoo organic results
+      const regex = /<div class=\"compTitle[^>]*>.*?<h3[^>]*>.*?<a[^>]*href=\"([^\"]+)\"[^>]*>(.*?)<\/a>.*?<\/h3>.*?<div class=\"compText[^>]*>(.*?)<\/div>/gs;
+      
+      let match;
+      while ((match = regex.exec(html)) !== null && results.length < 8) {
+        let link = match[1];
+        
+        // Yahoo heavily redirects via RU=..., decode it to get the raw clean URL
+        if (link.includes('RU=')) {
+          const ruMatch = link.match(/RU=([^/]+)\//);
+          if (ruMatch) link = decodeURIComponent(ruMatch[1]);
+        }
+        
+        // Skip sponsored Bing/Yahoo Ads
+        if (link.includes('bing.com/aclick') || link.includes('yahoo.com/yhs/')) {
+          continue;
+        }
+        
+        results.push({ 
+          url: link, 
+          title: match[2].replace(/<[^>]+>/g, '').trim(),
+          snippet: match[3].replace(/<[^>]+>/g, '').trim()
+        });
+      }
+      
+      if (results.length === 0) {
+        return { success: true, output: "No organic results found. Try using web.fetch on known direct domains." };
+      }
+      
+      let outputString = `🔍 SERP Results for "${args.query}":\n\n`;
+      outputString += `[TOP WEB RESULTS]\n`;
+      results.forEach((r, idx) => {
+        outputString += `${idx + 1}. ${r.title}\n   URL: ${r.url}\n   Snippet: ${r.snippet}\n\n`;
+      });
+      
+      return { success: true, output: outputString.trim() };
+      
+    } catch (error) {
+      return { 
+        success: false, 
+        error: `Search Engine Blocked Request: ${error.message}. Do NOT guess random API URLs. Instead, use the web_fetch tool directly on known sites (e.g. finance.yahoo.com, coinmarketcap.com, wikipedia.org).` 
+      };
+    }
+  }
+};