@causyne/agent 1.10.13 → 1.10.17

package/src/tools/subagentOrchestrator.js

@@ -1,4 +1,10 @@
 import { TokenTracker } from '../tokenTracker.js';
+import { listAgentProfiles, loadAgentProfile } from '../agentProfiles.js';
+import {
+  completeSubagentJournal,
+  failSubagentJournal,
+  startSubagentJournal
+} from '../subagentJournal.js';
 
 // Subagent delegation.
 //
@@ -67,6 +73,8 @@ async function executeSubagent(record, parentLoop) {
   const child = new AgentLoop(transport, record.subagentId, record.prompt);
 
   // A delegated task is a bounded errand, not a second full session.
+  child.maxStepsCeiling = record.maxSteps;
+  child.taskTokenLimit = record.maxTokens;
   child.maxSteps = Math.min(child.maxSteps || 25, record.maxSteps);
   child.maxCircuitBreaker = child.maxSteps;
   child.messages = [];
@@ -78,8 +86,16 @@ async function executeSubagent(record, parentLoop) {
 
   record.loop = child;
   record.startedAtMs = Date.now();
+  record.journalStarted = startSubagentJournal(record);
 
-  await child.run();
+  try {
+    await child.run();
+  } catch (error) {
+    if (record.journalStarted) {
+      failSubagentJournal(record.subagentId, error instanceof Error ? error.message : String(error));
+    }
+    throw error;
+  }
 
   const finalAssistant = [...child.messages].reverse()
     .find(m => m.role === 'assistant' && typeof m.content === 'string' && m.content.trim());
@@ -88,7 +104,7 @@ async function executeSubagent(record, parentLoop) {
     try { return JSON.parse(m.content).success === false; } catch (e) { return false; }
   });
 
-  return {
+  const result = {
     subagentId: record.subagentId,
     name: record.name,
     stepsCompleted: child.stepsCompleted,
@@ -100,6 +116,8 @@ async function executeSubagent(record, parentLoop) {
     summary: finalAssistant ? finalAssistant.content : null,
     stoppedEarly: child.stepsCompleted >= child.maxSteps
   };
+  if (record.journalStarted) completeSubagentJournal(record.subagentId, child.messages, result);
+  return result;
 }
 
 export const subagentOrchestrator = {
@@ -111,15 +129,16 @@ export const subagentOrchestrator = {
       properties: {
         action: {
           type: 'string',
-          enum: ['spawn', 'list', 'kill', 'delegate_and_wait'],
-          description: 'spawn (start in the background and return immediately), list (show active subagents), kill (stop one), delegate_and_wait (run it and return the result).'
+          enum: ['spawn', 'list', 'list_profiles', 'kill', 'delegate_and_wait'],
+          description: 'spawn (start in the background), list (show active subagents), list_profiles (show static user-defined agent profiles), kill (stop one), or delegate_and_wait (run and return the result).'
         },
         name: { type: 'string', description: 'A short name for the subagent, e.g. Audit_Worker.' },
         prompt: { type: 'string', description: 'The complete instruction for the subagent. It has no memory of this conversation, so it must be self-contained.' },
+        profile: { type: 'string', description: 'Optional profile name from ~/.causyne/agents/<name>.json. Its tool and budget limits cannot be widened by the call.' },
         subagentId: { type: 'string', description: 'Target subagent for the kill action.' },
         toolScope: { type: 'array', items: { type: 'string' }, description: 'Catalogue tool names the subagent may use. Defaults to read-only inspection tools. It can never receive the delegation tool itself.' },
-        maxSteps: { type: 'integer', description: 'Step ceiling for the subagent. Defaults to 25.' },
-        maxTokens: { type: 'integer', description: 'Advisory token budget for this subagent. Defaults to 50000.' },
+        maxSteps: { type: 'integer', description: 'Hard step ceiling for the subagent. Defaults to 25.' },
+        maxTokens: { type: 'integer', description: 'Hard per-task token ceiling for the subagent. Defaults to 50000.' },
         depth: { type: 'integer', description: 'Hierarchy depth. 0 = master, 1 = worker. Subagents cannot spawn subagents.' }
       },
       required: ['action']
@@ -153,6 +172,23 @@ export const subagentOrchestrator = {
         };
       }
 
+      if (action === 'list_profiles') {
+        const { profiles, problems } = listAgentProfiles();
+        return {
+          success: true,
+          output: JSON.stringify({
+            profiles: profiles.map(profile => ({
+              name: profile.name,
+              description: profile.description,
+              toolScope: profile.toolScope,
+              maxSteps: profile.maxSteps,
+              maxTokens: profile.maxTokens
+            })),
+            problems
+          }, null, 2)
+        };
+      }
+
       if (action === 'kill') {
         const id = args.subagentId || args.name;
         if (!id) return { success: false, error: 'subagentId or name is required to stop a subagent.' };
@@ -173,7 +209,17 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown action: ${action}` };
       }
 
-      const prompt = args.prompt;
+      let profile = null;
+      if (args.profile !== undefined) {
+        const loaded = loadAgentProfile(args.profile);
+        if (!loaded.ok) return { success: false, error: `Agent profile ${JSON.stringify(args.profile)}: ${loaded.error}` };
+        profile = loaded.profile;
+      }
+
+      const requestedPrompt = args.prompt;
+      const prompt = profile
+        ? `${profile.instructions}\n\nDelegated task:\n${String(requestedPrompt || '')}`
+        : requestedPrompt;
       if (!prompt) return { success: false, error: 'A prompt is required to delegate a task.' };
 
       const depth = args.depth !== undefined ? args.depth : 1;
@@ -195,11 +241,19 @@ export const subagentOrchestrator = {
         };
       }
 
-      const name = args.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
+      const name = args.name || profile?.name || `Worker_${Math.random().toString(36).slice(2, 7)}`;
       const subagentId = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-      const requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
+      let requestedScope = Array.isArray(args.toolScope) && args.toolScope.length > 0
         ? args.toolScope
-        : DEFAULT_TOOL_SCOPE;
+        : profile?.toolScope || DEFAULT_TOOL_SCOPE;
+      if (profile) {
+        const ceiling = new Set(profile.toolScope);
+        requestedScope = requestedScope.filter(tool => ceiling.has(String(tool).replace(/\./g, '_')));
+        if (requestedScope.length === 0) {
+          return { success: false, error: `Agent profile ${profile.name} permits none of the requested tools.` };
+        }
+      }
+      requestedScope = [...new Set(requestedScope.map(tool => String(tool).replace(/\./g, '_')))];
 
       // Reject an unknown tool name instead of silently accepting it. The old
       // implementation accepted anything, which is easy to do when the scope is
@@ -211,14 +265,21 @@ export const subagentOrchestrator = {
         return { success: false, error: `Unknown tools in toolScope: ${unknown.join(', ')}.` };
       }
 
+      const requestedMaxSteps = Number.isInteger(args.maxSteps)
+        ? Math.max(1, Math.min(args.maxSteps, 100))
+        : profile?.maxSteps || 25;
+      const requestedMaxTokens = Number.isInteger(args.maxTokens)
+        ? Math.max(1_000, Math.min(args.maxTokens, 200_000))
+        : profile?.maxTokens || 50_000;
       const record = {
         subagentId,
         name,
         prompt,
         toolScope: requestedScope,
         depth,
-        maxSteps: args.maxSteps || 25,
-        maxTokens: args.maxTokens || 50000,
+        maxSteps: Math.min(requestedMaxSteps, profile?.maxSteps || 100),
+        maxTokens: Math.min(requestedMaxTokens, profile?.maxTokens || 200_000),
+        profile: profile?.name || null,
         status: 'running',
         startTime: new Date().toISOString(),
         summary: null,

package/src/tools/webFetch.js

@@ -1,74 +1,189 @@
-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();
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { BrowserCapabilityError, causyneBrowser } from '../browser/causyneBrowser.js';
+import { assertPublicWebUrl } from '../browser/urlPolicy.js';
+const MAX_REDIRECTS = 5;
+const MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
+const MAX_OUTPUT_CHARS = 80_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+function decodeEntities(text) {
+    const named = { amp: '&', apos: "'", gt: '>', lt: '<', nbsp: ' ', quot: '"' };
+    return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (full, entity) => {
+        if (entity.startsWith('#x'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        if (entity.startsWith('#'))
+            return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        return named[entity.toLowerCase()] ?? full;
+    });
 }
-
-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']
+export function htmlToReadableText(html) {
+    return decodeEntities(String(html ?? ''))
+        .replace(/<(script|style|svg|noscript)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<\s*br\s*\/?>/gi, '\n')
+        .replace(/<\/(p|div|article|section|li|h[1-6]|tr)>/gi, '\n')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/[ \t]+/g, ' ')
+        .replace(/ *\n */g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function validatedHeaders(value) {
+    if (value === undefined)
+        return {};
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('headers must be an object');
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== 'string' || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(key) || /[\r\n]/.test(item)) {
+            throw new Error('headers contain an invalid name or value');
+        }
+        result[key] = item;
     }
-  },
-  async execute(args) {
+    return result;
+}
+async function fetchFollowingSafeRedirects(urlValue, options) {
+    let url = await assertPublicWebUrl(urlValue);
+    let request = { ...options };
+    for (let redirect = 0; redirect <= MAX_REDIRECTS; redirect++) {
+        const response = await fetch(url, { ...request, redirect: 'manual' });
+        if (![301, 302, 303, 307, 308].includes(response.status))
+            return { response, finalUrl: url };
+        if (redirect === MAX_REDIRECTS)
+            throw new Error(`Too many redirects (maximum ${MAX_REDIRECTS})`);
+        const location = response.headers.get('location');
+        if (!location)
+            throw new Error(`HTTP ${response.status} redirect has no Location header`);
+        await response.body?.cancel().catch(() => { });
+        url = await assertPublicWebUrl(new URL(location, url).href);
+        if (response.status === 303 || ([301, 302].includes(response.status) && request.method === 'POST')) {
+            const redirectedHeaders = new Headers(request.headers);
+            redirectedHeaders.delete('content-length');
+            redirectedHeaders.delete('content-type');
+            const { body: _discardedBody, ...redirectedRequest } = request;
+            request = { ...redirectedRequest, method: 'GET', headers: redirectedHeaders };
+        }
+    }
+    throw new Error('Redirect handling failed');
+}
+async function readBoundedBody(response) {
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
     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
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > MAX_RESPONSE_BYTES) {
+                await reader.cancel(`Response exceeds ${MAX_RESPONSE_BYTES} bytes`).catch(() => { });
+                throw new Error(`Response exceeds ${MAX_RESPONSE_BYTES} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map(chunk => Buffer.from(chunk)), size);
+}
+async function browserFallback(url) {
+    try {
+        const results = await causyneBrowser().run([{ type: 'goto', url }, { type: 'extract', selector: 'body' }]);
+        const output = results.find(result => result.action === 'extract')?.output;
+        return output ? { success: true, output } : { success: false, error: 'Browser loaded the page but extracted no readable content' };
+    }
+    catch (error) {
+        if (error instanceof BrowserCapabilityError) {
+            return { success: false, error: error.message, requiresConsent: error.requiresConsent };
+        }
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export const webFetch = {
+    schema: {
+        name: 'web.fetch',
+        description: 'Fetch a public HTTP(S) resource with redirect-by-redirect SSRF checks, bounded output, browser fallback for blocked HTML, and atomic workspace-scoped downloads.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string' },
+                method: { type: 'string', enum: ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+                headers: { type: 'object', additionalProperties: { type: 'string' } },
+                body: { type: 'string' },
+                outputFile: { type: 'string', description: 'File destination inside the selected workspace.' }
+            },
+            required: ['url'],
+            additionalProperties: false
+        }
+    },
+    async execute(args) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            if (!args.url)
+                return { success: false, error: 'url is required' };
+            const method = (args.method ?? 'GET').toUpperCase();
+            const headers = {
+                'User-Agent': 'Causyne-Agent/1.10 (+https://causyne.com)',
+                Accept: 'text/html,application/xhtml+xml,application/json,text/plain,*/*;q=0.8',
+                ...validatedHeaders(args.headers)
+            };
+            const request = { method, headers, signal: controller.signal };
+            if (args.body !== undefined && method !== 'GET' && method !== 'HEAD')
+                request.body = args.body;
+            const { response, finalUrl } = await fetchFollowingSafeRedirects(args.url, request);
+            const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+            if (!response.ok && !args.outputFile && contentType.includes('text/html') && [401, 403, 429, 503].includes(response.status)) {
+                const fallback = await browserFallback(finalUrl.href);
+                if (fallback.success)
+                    return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'camoufox' };
+                return { success: false, error: `HTTP ${response.status}; browser fallback failed: ${fallback.error}`, requiresConsent: fallback.requiresConsent };
+            }
+            if (!response.ok)
+                return { success: false, error: `HTTP ${response.status} ${response.statusText}`.trim(), status: response.status, finalUrl: finalUrl.href };
+            const declaredLength = Number(response.headers.get('content-length') ?? '0');
+            if (Number.isFinite(declaredLength) && declaredLength > MAX_RESPONSE_BYTES) {
+                return { success: false, error: `Response exceeds ${MAX_RESPONSE_BYTES} bytes` };
+            }
+            const bytes = await readBoundedBody(response);
+            if (args.outputFile) {
+                const workspace = path.resolve(process.cwd());
+                const target = path.resolve(workspace, args.outputFile);
+                if (!isWithin(workspace, target))
+                    return { success: false, error: 'Download target must stay inside the selected workspace' };
+                const temporary = `${target}.part-${crypto.randomUUID()}`;
+                await fs.mkdir(path.dirname(target), { recursive: true });
+                try {
+                    await fs.writeFile(temporary, bytes, { mode: 0o600 });
+                    await fs.rename(temporary, target);
+                }
+                finally {
+                    await fs.unlink(temporary).catch(() => { });
+                }
+                return { success: true, output: `Downloaded ${bytes.length} bytes to ${target}`, status: response.status, finalUrl: finalUrl.href };
+            }
+            const decoded = bytes.toString('utf8');
+            const readable = contentType.includes('text/html') ? htmlToReadableText(decoded) : decoded;
+            const output = readable.length > MAX_OUTPUT_CHARS
+                ? `${readable.slice(0, MAX_OUTPUT_CHARS)}\n\n[Web output truncated at ${MAX_OUTPUT_CHARS} characters]`
+                : readable;
+            return { success: true, output, status: response.status, finalUrl: finalUrl.href, contentType };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const timedOut = error instanceof Error && (error.name === 'AbortError' || message === 'This operation was aborted');
+            return { success: false, error: timedOut ? `Request timed out after ${REQUEST_TIMEOUT_MS}ms` : message };
+        }
+        finally {
+            clearTimeout(timer);
         }
-      };
-      
-      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/webFetch.ts

@@ -0,0 +1,185 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { BrowserCapabilityError, causyneBrowser } from '../browser/causyneBrowser.js';
+import { assertPublicWebUrl } from '../browser/urlPolicy.js';
+
+const MAX_REDIRECTS = 5;
+const MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
+const MAX_OUTPUT_CHARS = 80_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+
+function decodeEntities(text: string): string {
+  const named: Record<string, string> = { amp: '&', apos: "'", gt: '>', lt: '<', nbsp: ' ', quot: '"' };
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (full, entity: string) => {
+    if (entity.startsWith('#x')) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+    if (entity.startsWith('#')) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+    return named[entity.toLowerCase()] ?? full;
+  });
+}
+
+export function htmlToReadableText(html: string): string {
+  return decodeEntities(String(html ?? ''))
+    .replace(/<(script|style|svg|noscript)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+    .replace(/<\s*br\s*\/?>/gi, '\n')
+    .replace(/<\/(p|div|article|section|li|h[1-6]|tr)>/gi, '\n')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/[ \t]+/g, ' ')
+    .replace(/ *\n */g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function validatedHeaders(value: unknown): Record<string, string> {
+  if (value === undefined) return {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('headers must be an object');
+  const result: Record<string, string> = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item !== 'string' || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(key) || /[\r\n]/.test(item)) {
+      throw new Error('headers contain an invalid name or value');
+    }
+    result[key] = item;
+  }
+  return result;
+}
+
+async function fetchFollowingSafeRedirects(urlValue: string, options: RequestInit): Promise<{ response: Response; finalUrl: URL }> {
+  let url = await assertPublicWebUrl(urlValue);
+  let request = { ...options };
+  for (let redirect = 0; redirect <= MAX_REDIRECTS; redirect++) {
+    const response = await fetch(url, { ...request, redirect: 'manual' });
+    if (![301, 302, 303, 307, 308].includes(response.status)) return { response, finalUrl: url };
+    if (redirect === MAX_REDIRECTS) throw new Error(`Too many redirects (maximum ${MAX_REDIRECTS})`);
+    const location = response.headers.get('location');
+    if (!location) throw new Error(`HTTP ${response.status} redirect has no Location header`);
+    await response.body?.cancel().catch(() => {});
+    url = await assertPublicWebUrl(new URL(location, url).href);
+    if (response.status === 303 || ([301, 302].includes(response.status) && request.method === 'POST')) {
+      const redirectedHeaders = new Headers(request.headers);
+      redirectedHeaders.delete('content-length');
+      redirectedHeaders.delete('content-type');
+      const { body: _discardedBody, ...redirectedRequest } = request;
+      request = { ...redirectedRequest, method: 'GET', headers: redirectedHeaders };
+    }
+  }
+  throw new Error('Redirect handling failed');
+}
+
+async function readBoundedBody(response: Response): Promise<Buffer> {
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > MAX_RESPONSE_BYTES) {
+        await reader.cancel(`Response exceeds ${MAX_RESPONSE_BYTES} bytes`).catch(() => {});
+        throw new Error(`Response exceeds ${MAX_RESPONSE_BYTES} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks.map(chunk => Buffer.from(chunk)), size);
+}
+
+async function browserFallback(url: string): Promise<{ success: boolean; output?: string; error?: string; requiresConsent?: boolean }> {
+  try {
+    const results = await causyneBrowser().run([{ type: 'goto', url }, { type: 'extract', selector: 'body' }]);
+    const output = results.find(result => result.action === 'extract')?.output;
+    return output ? { success: true, output } : { success: false, error: 'Browser loaded the page but extracted no readable content' };
+  } catch (error) {
+    if (error instanceof BrowserCapabilityError) {
+      return { success: false, error: error.message, requiresConsent: error.requiresConsent };
+    }
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export const webFetch = {
+  schema: {
+    name: 'web.fetch',
+    description: 'Fetch a public HTTP(S) resource with redirect-by-redirect SSRF checks, bounded output, browser fallback for blocked HTML, and atomic workspace-scoped downloads.',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: { type: 'string' },
+        method: { type: 'string', enum: ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+        headers: { type: 'object', additionalProperties: { type: 'string' } },
+        body: { type: 'string' },
+        outputFile: { type: 'string', description: 'File destination inside the selected workspace.' }
+      },
+      required: ['url'],
+      additionalProperties: false
+    }
+  },
+
+  async execute(args: { url?: string; method?: string; headers?: unknown; body?: string; outputFile?: string }) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      if (!args.url) return { success: false, error: 'url is required' };
+      const method = (args.method ?? 'GET').toUpperCase();
+      const headers = {
+        'User-Agent': 'Causyne-Agent/1.10 (+https://causyne.com)',
+        Accept: 'text/html,application/xhtml+xml,application/json,text/plain,*/*;q=0.8',
+        ...validatedHeaders(args.headers)
+      };
+      const request: RequestInit = { method, headers, signal: controller.signal };
+      if (args.body !== undefined && method !== 'GET' && method !== 'HEAD') request.body = args.body;
+      const { response, finalUrl } = await fetchFollowingSafeRedirects(args.url, request);
+      const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+
+      if (!response.ok && !args.outputFile && contentType.includes('text/html') && [401, 403, 429, 503].includes(response.status)) {
+        const fallback = await browserFallback(finalUrl.href);
+        if (fallback.success) return { ...fallback, status: response.status, finalUrl: finalUrl.href, via: 'camoufox' };
+        return { success: false, error: `HTTP ${response.status}; browser fallback failed: ${fallback.error}`, requiresConsent: fallback.requiresConsent };
+      }
+      if (!response.ok) return { success: false, error: `HTTP ${response.status} ${response.statusText}`.trim(), status: response.status, finalUrl: finalUrl.href };
+
+      const declaredLength = Number(response.headers.get('content-length') ?? '0');
+      if (Number.isFinite(declaredLength) && declaredLength > MAX_RESPONSE_BYTES) {
+        return { success: false, error: `Response exceeds ${MAX_RESPONSE_BYTES} bytes` };
+      }
+      const bytes = await readBoundedBody(response);
+
+      if (args.outputFile) {
+        const workspace = path.resolve(process.cwd());
+        const target = path.resolve(workspace, args.outputFile);
+        if (!isWithin(workspace, target)) return { success: false, error: 'Download target must stay inside the selected workspace' };
+        const temporary = `${target}.part-${crypto.randomUUID()}`;
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        try {
+          await fs.writeFile(temporary, bytes, { mode: 0o600 });
+          await fs.rename(temporary, target);
+        } finally {
+          await fs.unlink(temporary).catch(() => {});
+        }
+        return { success: true, output: `Downloaded ${bytes.length} bytes to ${target}`, status: response.status, finalUrl: finalUrl.href };
+      }
+
+      const decoded = bytes.toString('utf8');
+      const readable = contentType.includes('text/html') ? htmlToReadableText(decoded) : decoded;
+      const output = readable.length > MAX_OUTPUT_CHARS
+        ? `${readable.slice(0, MAX_OUTPUT_CHARS)}\n\n[Web output truncated at ${MAX_OUTPUT_CHARS} characters]`
+        : readable;
+      return { success: true, output, status: response.status, finalUrl: finalUrl.href, contentType };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const timedOut = error instanceof Error && (error.name === 'AbortError' || message === 'This operation was aborted');
+      return { success: false, error: timedOut ? `Request timed out after ${REQUEST_TIMEOUT_MS}ms` : message };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};