profclaw 0.0.1-beta.1

package/dist/chat/execution/tools/test-run.js

@@ -0,0 +1,391 @@
+/**
+ * Test Run Tool
+ *
+ * Structured test runner with auto-detection and parsed output.
+ */
+import { z } from 'zod';
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const TestRunParamsSchema = z.object({
+    command: z.string().optional().describe('Test command override (auto-detected if omitted)'),
+    file: z.string().optional().describe('Specific test file to run'),
+    grep: z.string().optional().describe('Filter by test name pattern'),
+    coverage: z.boolean().optional().default(false).describe('Enable coverage reporting'),
+});
+// Constants
+const TEST_TIMEOUT_MS = 120_000; // 2 minutes
+const MAX_OUTPUT_CHARS = 200_000;
+// Tool Definition
+export const testRunTool = {
+    name: 'test_run',
+    description: `Run tests with structured output. Auto-detects the test framework (vitest, jest, pytest, go test, etc.) from project config.
+Returns parsed results: pass/fail/skip counts, failure details with file:line locations.
+Optionally filter by file or test name pattern.`,
+    category: 'execution',
+    securityLevel: 'moderate',
+    allowedHosts: ['sandbox', 'gateway', 'local'],
+    parameters: TestRunParamsSchema,
+    examples: [
+        { description: 'Run all tests', params: {} },
+        { description: 'Run a specific file', params: { file: 'src/utils.test.ts' } },
+        { description: 'Run tests matching pattern', params: { grep: 'auth' } },
+        { description: 'Run with coverage', params: { coverage: true } },
+    ],
+    async execute(context, params) {
+        try {
+            const framework = params.command
+                ? await detectFramework(context.workdir).catch(() => ({
+                    name: 'manual',
+                    runner: 'manual',
+                    args: [],
+                }))
+                : await detectFramework(context.workdir);
+            const command = params.command ?? buildTestCommand(framework, params);
+            logger.debug(`[TestRun] Running: ${command} (framework: ${framework.name})`, { component: 'TestRun' });
+            const rawOutput = await runCommand(command, context.workdir);
+            const parsed = parseTestOutput(rawOutput, framework);
+            const summary = [
+                `Framework: ${framework.name}`,
+                `Results: ${parsed.passed} passed, ${parsed.failed} failed, ${parsed.skipped} skipped (${parsed.total} total)`,
+            ];
+            if (parsed.failures.length > 0) {
+                summary.push('', 'Failures:');
+                for (const f of parsed.failures) {
+                    const location = f.file ? `  ${f.file}${f.line ? `:${f.line}` : ''}` : '';
+                    summary.push(`  - ${f.name}${location}`);
+                    if (f.message)
+                        summary.push(`    ${f.message}`);
+                }
+            }
+            if (parsed.coverage !== undefined) {
+                summary.push(`\nCoverage: ${parsed.coverage}%`);
+            }
+            const output = summary.join('\n');
+            return {
+                success: parsed.failed === 0,
+                data: parsed,
+                output: parsed.failed === 0
+                    ? output
+                    : `${output}\n\n--- Raw Output ---\n${rawOutput.slice(-5000)}`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                error: { code: 'TEST_ERROR', message: `Test execution failed: ${message}` },
+            };
+        }
+    },
+};
+async function detectFramework(workdir) {
+    // Check package.json for Node.js projects
+    try {
+        const pkgPath = path.join(workdir, 'package.json');
+        const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(pkgContent);
+        const devDeps = (pkg.devDependencies ?? {});
+        const deps = (pkg.dependencies ?? {});
+        const scripts = (pkg.scripts ?? {});
+        // Detect package manager
+        const pm = await detectPackageManager(workdir);
+        if (devDeps.vitest || deps.vitest) {
+            return { name: 'vitest', runner: pm, args: ['test', '--reporter=verbose'] };
+        }
+        if (devDeps.jest || deps.jest) {
+            return { name: 'jest', runner: pm, args: ['test', '--', '--verbose'] };
+        }
+        if (scripts.test) {
+            return { name: 'npm-script', runner: pm, args: ['test'] };
+        }
+    }
+    catch {
+        // Not a Node.js project
+    }
+    // Check for Python
+    try {
+        await fs.access(path.join(workdir, 'pyproject.toml'));
+        return { name: 'pytest', runner: 'python', args: ['-m', 'pytest', '-v'] };
+    }
+    catch {
+        // Not a Python project
+    }
+    try {
+        await fs.access(path.join(workdir, 'setup.py'));
+        return { name: 'pytest', runner: 'python', args: ['-m', 'pytest', '-v'] };
+    }
+    catch {
+        // Not a Python project
+    }
+    // Check for Go
+    try {
+        await fs.access(path.join(workdir, 'go.mod'));
+        return { name: 'go-test', runner: 'go', args: ['test', '-v', './...'] };
+    }
+    catch {
+        // Not a Go project
+    }
+    // Check for Rust
+    try {
+        await fs.access(path.join(workdir, 'Cargo.toml'));
+        return { name: 'cargo-test', runner: 'cargo', args: ['test'] };
+    }
+    catch {
+        // Not a Rust project
+    }
+    // Check for Makefile with test target
+    try {
+        const makefile = await fs.readFile(path.join(workdir, 'Makefile'), 'utf-8');
+        if (makefile.includes('test:')) {
+            return { name: 'make', runner: 'make', args: ['test'] };
+        }
+    }
+    catch {
+        // No Makefile
+    }
+    throw new Error('Could not detect test framework. Specify a command manually with the "command" parameter.');
+}
+async function detectPackageManager(workdir) {
+    try {
+        await fs.access(path.join(workdir, 'pnpm-lock.yaml'));
+        return 'pnpm';
+    }
+    catch {
+        // Not pnpm
+    }
+    try {
+        await fs.access(path.join(workdir, 'yarn.lock'));
+        return 'yarn';
+    }
+    catch {
+        // Not yarn
+    }
+    try {
+        await fs.access(path.join(workdir, 'bun.lockb'));
+        return 'bun';
+    }
+    catch {
+        // Not bun
+    }
+    return 'npm';
+}
+// Command Building
+function buildTestCommand(framework, params) {
+    const args = [...framework.args];
+    if (params.file) {
+        if (framework.name === 'vitest' || framework.name === 'jest') {
+            args.push(params.file);
+        }
+        else if (framework.name === 'pytest') {
+            args.push(params.file);
+        }
+        else if (framework.name === 'go-test') {
+            // Replace ./... with specific package
+            const idx = args.indexOf('./...');
+            if (idx !== -1)
+                args[idx] = `./${path.dirname(params.file)}/...`;
+        }
+        else {
+            args.push(params.file);
+        }
+    }
+    if (params.grep) {
+        if (framework.name === 'vitest' || framework.name === 'jest') {
+            args.push('-t', params.grep);
+        }
+        else if (framework.name === 'pytest') {
+            args.push('-k', params.grep);
+        }
+        else if (framework.name === 'go-test') {
+            args.push('-run', params.grep);
+        }
+    }
+    if (params.coverage) {
+        if (framework.name === 'vitest') {
+            args.push('--coverage');
+        }
+        else if (framework.name === 'jest') {
+            args.push('--coverage');
+        }
+        else if (framework.name === 'pytest') {
+            args.push('--cov');
+        }
+        else if (framework.name === 'go-test') {
+            args.push('-cover');
+        }
+    }
+    return `${framework.runner} ${args.join(' ')}`;
+}
+// Command Execution
+function runCommand(command, cwd) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('/bin/bash', ['-c', command], {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+        });
+        let output = '';
+        const timeout = setTimeout(() => {
+            proc.kill('SIGKILL');
+            reject(new Error(`Test command timed out after ${TEST_TIMEOUT_MS / 1000}s`));
+        }, TEST_TIMEOUT_MS);
+        proc.stdout?.on('data', (data) => {
+            output += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            output += data.toString();
+        });
+        proc.on('close', (_code) => {
+            clearTimeout(timeout);
+            // Tests can exit non-zero on failure, that's expected
+            if (output.length > MAX_OUTPUT_CHARS) {
+                output = output.slice(-MAX_OUTPUT_CHARS);
+            }
+            resolve(output);
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}
+// Output Parsing
+function parseTestOutput(output, framework) {
+    const result = {
+        framework: framework.name,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        total: 0,
+        failures: [],
+        duration_ms: 0,
+    };
+    if (framework.name === 'vitest' || framework.name === 'jest') {
+        parseNodeTestOutput(output, result);
+    }
+    else if (framework.name === 'pytest') {
+        parsePytestOutput(output, result);
+    }
+    else if (framework.name === 'go-test') {
+        parseGoTestOutput(output, result);
+    }
+    else {
+        // Generic: try to extract counts from common patterns
+        parseGenericOutput(output, result);
+    }
+    result.total = result.passed + result.failed + result.skipped;
+    return result;
+}
+function parseNodeTestOutput(output, result) {
+    // Vitest/Jest summary line: "Tests: 3 passed, 1 failed, 4 total" or "Test Suites: ..."
+    const testSummary = output.match(/Tests?\s*:?\s*(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+skipped,?\s*)?(?:(\d+)\s+passed,?\s*)?(\d+)\s+total/i);
+    if (testSummary) {
+        result.failed = parseInt(testSummary[1] ?? '0', 10);
+        result.skipped = parseInt(testSummary[2] ?? '0', 10);
+        result.passed = parseInt(testSummary[3] ?? '0', 10);
+    }
+    // Duration
+    const duration = output.match(/(?:Time|Duration)[:\s]+([0-9.]+)\s*(s|ms|m)/i);
+    if (duration) {
+        const value = parseFloat(duration[1]);
+        const unit = duration[2];
+        result.duration_ms = unit === 'ms' ? value : unit === 'm' ? value * 60000 : value * 1000;
+    }
+    // Parse individual failures
+    const failPattern = /(?:FAIL|x)\s+(.+?)(?:\s+\((\d+)\s*ms\))?$/gm;
+    let match;
+    while ((match = failPattern.exec(output)) !== null) {
+        const rawName = match[1].trim();
+        const vitestStyleFailure = rawName.match(/^(\S+\.(?:test|spec)\.\w+)\s*>\s*(.+)$/);
+        if (vitestStyleFailure) {
+            result.failures.push({
+                name: vitestStyleFailure[2].trim(),
+                file: vitestStyleFailure[1],
+            });
+            continue;
+        }
+        result.failures.push({ name: rawName });
+    }
+    // Parse vitest-style failure blocks
+    const vitestFailPattern = /(?:FAIL\s+)?(\S+\.(?:test|spec)\.\w+)\s*>\s*(.+?)$/gm;
+    while ((match = vitestFailPattern.exec(output)) !== null) {
+        const file = match[1];
+        const name = match[2].trim();
+        const existing = result.failures.find((f) => (f.name === name && (!f.file || f.file === file)) ||
+            f.name === `${file} > ${name}`);
+        if (!existing) {
+            result.failures.push({ name, file });
+        }
+        else {
+            existing.name = name;
+            existing.file = file;
+        }
+    }
+    // Coverage percentage
+    const coverageMatch = output.match(/All files\s*\|\s*([0-9.]+)/);
+    if (coverageMatch) {
+        result.coverage = parseFloat(coverageMatch[1]);
+    }
+}
+function parsePytestOutput(output, result) {
+    // Pytest summary: "3 passed, 1 failed, 2 skipped"
+    const passed = output.match(/(\d+)\s+passed/);
+    const failed = output.match(/(\d+)\s+failed/);
+    const skipped = output.match(/(\d+)\s+skipped/);
+    if (passed)
+        result.passed = parseInt(passed[1], 10);
+    if (failed)
+        result.failed = parseInt(failed[1], 10);
+    if (skipped)
+        result.skipped = parseInt(skipped[1], 10);
+    // Duration
+    const duration = output.match(/in\s+([0-9.]+)s/);
+    if (duration)
+        result.duration_ms = parseFloat(duration[1]) * 1000;
+    // Parse failures: "FAILED tests/test_foo.py::test_bar"
+    const failPattern = /FAILED\s+(\S+?)::(\S+)/g;
+    let match;
+    while ((match = failPattern.exec(output)) !== null) {
+        result.failures.push({ name: match[2], file: match[1] });
+    }
+}
+function parseGoTestOutput(output, result) {
+    const passPattern = /--- PASS:\s+(\S+)/g;
+    const failPattern = /--- FAIL:\s+(\S+)/g;
+    const skipPattern = /--- SKIP:\s+(\S+)/g;
+    let match;
+    while ((match = passPattern.exec(output)) !== null)
+        result.passed++;
+    while ((match = failPattern.exec(output)) !== null) {
+        result.failed++;
+        result.failures.push({ name: match[1] });
+    }
+    while ((match = skipPattern.exec(output)) !== null)
+        result.skipped++;
+    // Go test file:line in failure output
+    const locationPattern = /(\S+_test\.go):(\d+):/g;
+    let locIdx = 0;
+    while ((match = locationPattern.exec(output)) !== null) {
+        if (locIdx < result.failures.length) {
+            result.failures[locIdx].file = match[1];
+            result.failures[locIdx].line = parseInt(match[2], 10);
+            locIdx++;
+        }
+    }
+}
+function parseGenericOutput(output, result) {
+    // Try common patterns
+    const passed = output.match(/(\d+)\s+(?:pass(?:ed|ing)?|ok|success)/i);
+    const failed = output.match(/(\d+)\s+(?:fail(?:ed|ing|ure)?|error)/i);
+    const skipped = output.match(/(\d+)\s+(?:skip(?:ped)?|pending|todo)/i);
+    if (passed)
+        result.passed = parseInt(passed[1], 10);
+    if (failed)
+        result.failed = parseInt(failed[1], 10);
+    if (skipped)
+        result.skipped = parseInt(skipped[1], 10);
+}
+//# sourceMappingURL=test-run.js.map

package/dist/chat/execution/tools/tts-speak.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Text-to-Speech Tool
+ *
+ * Convert text to speech using OpenAI TTS API or system TTS as fallback.
+ * macOS: `say`, Linux: `espeak`. Always available.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const TtsSpeakParamsSchema: z.ZodObject<{
+    text: z.ZodString;
+    voice: z.ZodDefault<z.ZodOptional<z.ZodEnum<["alloy", "echo", "fable", "onyx", "nova", "shimmer"]>>>;
+    speed: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["mp3", "wav", "opus", "aac", "flac"]>>>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    speed: number;
+    format: "opus" | "mp3" | "wav" | "aac" | "flac";
+    voice: "echo" | "alloy" | "fable" | "onyx" | "nova" | "shimmer";
+    outputPath?: string | undefined;
+}, {
+    text: string;
+    speed?: number | undefined;
+    format?: "opus" | "mp3" | "wav" | "aac" | "flac" | undefined;
+    voice?: "echo" | "alloy" | "fable" | "onyx" | "nova" | "shimmer" | undefined;
+    outputPath?: string | undefined;
+}>;
+export type TtsSpeakParams = z.infer<typeof TtsSpeakParamsSchema>;
+export interface TtsSpeakResult {
+    audioPath: string;
+    durationEstimate: number;
+    engine: 'openai' | 'macos-say' | 'espeak';
+    format: string;
+    voice?: string;
+    charCount: number;
+}
+export declare const ttsSpeakTool: ToolDefinition<TtsSpeakParams, TtsSpeakResult>;
+export {};
+//# sourceMappingURL=tts-speak.d.ts.map

package/dist/chat/execution/tools/tts-speak.js

@@ -0,0 +1,199 @@
+/**
+ * Text-to-Speech Tool
+ *
+ * Convert text to speech using OpenAI TTS API or system TTS as fallback.
+ * macOS: `say`, Linux: `espeak`. Always available.
+ */
+import { z } from 'zod';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import os from 'os';
+import fs from 'fs/promises';
+import { logger } from '../../../utils/logger.js';
+const execAsync = promisify(exec);
+// Schema
+const TtsSpeakParamsSchema = z.object({
+    text: z.string().min(1).max(4096).describe('Text to convert to speech'),
+    voice: z
+        .enum(['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'])
+        .optional()
+        .default('nova')
+        .describe('Voice to use (OpenAI TTS only)'),
+    speed: z
+        .number()
+        .min(0.25)
+        .max(4.0)
+        .optional()
+        .default(1.0)
+        .describe('Playback speed (0.25 - 4.0, default 1.0)'),
+    format: z
+        .enum(['mp3', 'wav', 'opus', 'aac', 'flac'])
+        .optional()
+        .default('mp3')
+        .describe('Output audio format'),
+    outputPath: z.string().optional().describe('File path to save audio (auto-generated if not set)'),
+});
+// Helpers
+function estimateDurationSec(text, speed) {
+    // Average speaking rate is about 130 words/min, ~5 chars/word
+    const words = text.length / 5;
+    const baseDurationSec = (words / 130) * 60;
+    return Math.round(baseDurationSec / speed);
+}
+async function generateOutputPath(format) {
+    const tmpDir = os.tmpdir();
+    const timestamp = Date.now();
+    return path.join(tmpDir, `tts-${timestamp}.${format}`);
+}
+async function speakWithOpenAI(text, params, apiKey, outputPath) {
+    const response = await fetch('https://api.openai.com/v1/audio/speech', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model: 'tts-1',
+            input: text,
+            voice: params.voice ?? 'nova',
+            speed: params.speed ?? 1.0,
+            response_format: params.format ?? 'mp3',
+        }),
+    });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`OpenAI TTS API error ${response.status}: ${errText.slice(0, 200)}`);
+    }
+    const buffer = await response.arrayBuffer();
+    await fs.writeFile(outputPath, Buffer.from(buffer));
+}
+async function speakWithSystemTts(text, outputPath) {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        // macOS `say` command - output as AIFF then convert path
+        const aiffPath = outputPath.replace(/\.[^.]+$/, '.aiff');
+        await execAsync(`say -o "${aiffPath}" "${text.replace(/"/g, '\\"')}"`);
+        // Rename to requested path (say always writes AIFF)
+        await fs.rename(aiffPath, outputPath).catch(async () => {
+            // If format differs, just keep as-is and update outputPath
+            await fs.copyFile(aiffPath, outputPath).catch(() => { });
+        });
+        return 'macos-say';
+    }
+    else {
+        // Linux fallback: espeak
+        await execAsync(`espeak "${text.replace(/"/g, '\\"')}" --stdout > "${outputPath}"`);
+        return 'espeak';
+    }
+}
+// Tool Definition
+export const ttsSpeakTool = {
+    name: 'tts_speak',
+    description: `Convert text to speech audio.
+
+Uses OpenAI TTS API (if configured) for high-quality voice synthesis with multiple
+voice options and formats. Falls back to system TTS (macOS \`say\`, Linux \`espeak\`)
+if OpenAI is not available - system TTS is always available.
+
+Returns the path to the generated audio file and an estimated duration.
+
+Voices (OpenAI only): alloy, echo, fable, onyx, nova, shimmer`,
+    category: 'custom',
+    securityLevel: 'safe',
+    requiresApproval: false,
+    parameters: TtsSpeakParamsSchema,
+    isAvailable() {
+        return { available: true };
+    },
+    examples: [
+        {
+            description: 'Speak a simple message',
+            params: { text: 'Hello! Task completed successfully.' },
+        },
+        {
+            description: 'High-quality voice with specific settings',
+            params: {
+                text: 'The deployment has finished. All services are healthy.',
+                voice: 'onyx',
+                speed: 1.2,
+                format: 'mp3',
+            },
+        },
+        {
+            description: 'Save to specific file',
+            params: {
+                text: 'Weekly report is ready for review.',
+                outputPath: '/tmp/weekly-report-notification.mp3',
+                voice: 'nova',
+            },
+        },
+    ],
+    async execute(context, params) {
+        const apiKey = process.env.OPENAI_API_KEY ?? '';
+        const outputPath = params.outputPath ?? await generateOutputPath(params.format ?? 'mp3');
+        const speed = params.speed ?? 1.0;
+        let engine;
+        logger.info(`[TtsSpeak] Converting ${params.text.length} chars to speech`, {
+            component: 'TtsSpeak',
+        });
+        try {
+            if (apiKey) {
+                try {
+                    await speakWithOpenAI(params.text, params, apiKey, outputPath);
+                    engine = 'openai';
+                    logger.info('[TtsSpeak] Generated with OpenAI TTS', { component: 'TtsSpeak' });
+                }
+                catch (openaiError) {
+                    const errMsg = openaiError instanceof Error ? openaiError.message : 'Unknown';
+                    logger.warn(`[TtsSpeak] OpenAI TTS failed, falling back to system TTS: ${errMsg}`, {
+                        component: 'TtsSpeak',
+                    });
+                    engine = await speakWithSystemTts(params.text, outputPath);
+                }
+            }
+            else {
+                engine = await speakWithSystemTts(params.text, outputPath);
+                logger.info(`[TtsSpeak] Generated with system TTS (${engine})`, { component: 'TtsSpeak' });
+            }
+            const durationEstimate = estimateDurationSec(params.text, speed);
+            const result = {
+                audioPath: outputPath,
+                durationEstimate,
+                engine,
+                format: params.format ?? (engine === 'macos-say' ? 'aiff' : 'mp3'),
+                voice: engine === 'openai' ? (params.voice ?? 'nova') : undefined,
+                charCount: params.text.length,
+            };
+            const lines = [
+                '## Text-to-Speech Generated\n',
+                `**Audio File**: \`${outputPath}\``,
+                `**Engine**: ${engine}`,
+                `**Estimated Duration**: ~${durationEstimate}s`,
+                `**Format**: ${result.format}`,
+            ];
+            if (result.voice) {
+                lines.push(`**Voice**: ${result.voice}`);
+            }
+            lines.push(`**Characters**: ${params.text.length}`);
+            return {
+                success: true,
+                data: result,
+                output: lines.join('\n'),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[TtsSpeak] Failed: ${message}`, { component: 'TtsSpeak' });
+            return {
+                success: false,
+                error: {
+                    code: 'TTS_FAILED',
+                    message: `Text-to-speech failed: ${message}`,
+                    retryable: false,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=tts-speak.js.map

package/dist/chat/execution/tools/web-fetch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Web Fetch Tool
+ *
+ * Fetch content from URLs with safety controls.
+ * Supports various content types and HTML to markdown conversion.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const WebFetchParamsSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    extractText: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    timeout?: number | undefined;
+    body?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    extractText?: boolean | undefined;
+}, {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
+    timeout?: number | undefined;
+    body?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    extractText?: boolean | undefined;
+}>;
+export type WebFetchParams = z.infer<typeof WebFetchParamsSchema>;
+export declare const webFetchTool: ToolDefinition<WebFetchParams, WebFetchResult>;
+export interface WebFetchResult {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    contentType: string;
+    body: string;
+    url: string;
+}
+export {};
+//# sourceMappingURL=web-fetch.d.ts.map