@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/mcp/handlers/definitions.js

@@ -0,0 +1,395 @@
+/**
+ * Tool schema definitions — single source of truth for both transports.
+ * Imported by the standalone MCP server and the HTTP MCP route for tools/list.
+ */
+export const toolDefinitions = [
+    {
+        name: 'webpeel',
+        description: "Your complete web toolkit — fetch, search, screenshot, extract, monitor, and interact with any website. " +
+            "Handles JS rendering, Cloudflare, CAPTCHAs, and 55+ domain extractors automatically. 65-98% token savings. " +
+            "Describe what you want in plain English. " +
+            "Examples: 'read https://stripe.com/pricing', 'screenshot bbc.com on mobile', " +
+            "'search for best AI frameworks 2024', 'extract product prices from amazon.com/dp/...', " +
+            "'watch stripe.com/pricing for price changes', 'get YouTube transcript from youtu.be/...'. " +
+            "For JavaScript-heavy SPAs (React, Vue, Next.js, Polymarket, Airbnb, etc.), mention 'render' or 'use browser' in your task. " +
+            "For infinite scroll or lazy-loaded content, say 'scroll to bottom'. " +
+            "For bot-protected sites (Cloudflare), say 'stealth mode'. " +
+            "If you get sparse or empty content, retry and mention 'render' — the site likely requires JavaScript.",
+        annotations: {
+            title: 'WebPeel Smart Web Tool',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task: {
+                    type: 'string',
+                    description: 'Plain English description of what you want to do with the web.',
+                },
+                llmProvider: {
+                    type: 'string',
+                    enum: ['openai', 'anthropic', 'google'],
+                    description: 'LLM provider for schema extraction (BYOK). Pass when asking for structured data extraction.',
+                },
+                llmApiKey: {
+                    type: 'string',
+                    description: 'Your LLM API key (BYOK). Pass when asking for structured data extraction with llmProvider.',
+                },
+                llmModel: {
+                    type: 'string',
+                    description: 'LLM model name (optional). Defaults: gpt-4o-mini (OpenAI), claude-haiku-4-5 (Anthropic), gemini-2.0-flash (Google).',
+                },
+                llmBaseUrl: {
+                    type: 'string',
+                    description: 'Custom OpenAI-compatible API base URL. Use for OpenRouter, Glama, or self-hosted models.',
+                },
+            },
+            required: ['task'],
+        },
+    },
+    {
+        name: 'webpeel_read',
+        description: 'Fetch any URL and return clean, LLM-optimized markdown. 65-98% fewer tokens than raw HTML. ' +
+            'Automatically handles: web pages, YouTube transcripts (with timestamps), PDFs, ' +
+            'JS-rendered SPAs, Cloudflare-protected sites, and 55+ domain-specific extractors (Amazon, Reddit, GitHub, etc.). ' +
+            'IMPORTANT: Use render=true for ANY JavaScript-heavy site (React, Vue, Angular, Svelte, Next.js, SPAs). ' +
+            'Known SPAs that need render=true: Polymarket, Airbnb, Booking.com, Expedia, Indeed, Zillow, Google, and more. ' +
+            'If content is sparse or empty, ALWAYS retry with render=true before concluding the page has no content. ' +
+            'Use actions= to interact with the page before extraction (scroll, click, type, wait). ' +
+            'Use stealth=true for Cloudflare-protected or bot-blocked sites (auto-enables render). ' +
+            'Use question= for instant Q&A (no LLM needed). ' +
+            'Use summary=true for a short summary. Use budget=N to distill to N tokens.',
+        annotations: {
+            title: 'Read Web Page',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to fetch' },
+                format: {
+                    type: 'string',
+                    enum: ['markdown', 'text', 'html'],
+                    description: 'Output format (default: markdown)',
+                    default: 'markdown',
+                },
+                render: {
+                    type: 'boolean',
+                    description: 'Force browser rendering for JS-heavy sites',
+                    default: false,
+                },
+                question: {
+                    type: 'string',
+                    description: 'Ask a question about the page content (BM25, no LLM needed)',
+                },
+                summary: {
+                    type: 'boolean',
+                    description: 'Return a summary instead of full content',
+                    default: false,
+                },
+                budget: {
+                    type: 'number',
+                    description: 'Smart token budget — distill content to N tokens',
+                },
+                readable: {
+                    type: 'boolean',
+                    description: 'Reader mode — extract only article content',
+                    default: false,
+                },
+                actions: {
+                    type: 'array',
+                    description: 'Browser actions to perform before extracting content. Requires render=true (auto-enabled). ' +
+                        'Each action is a string: "scroll:bottom" (infinite scroll), "wait:2000" (wait 2s), ' +
+                        '"click:.selector" (click element), "type:#input:text" (type into field), ' +
+                        '"waitFor:.selector" (wait for element), "hover:.element" (hover), ' +
+                        '"scroll:down:500" (scroll 500px), "scroll:0,1500" (scroll to coords). ' +
+                        'Chain multiple actions: ["scroll:bottom", "wait:2000"] to load lazy content.',
+                    items: { type: 'string' },
+                },
+                stealth: {
+                    type: 'boolean',
+                    description: 'Stealth mode for bot-protected sites (Cloudflare, fingerprinting, rate limiting). ' +
+                        'Use when render=true still returns a challenge page or access denied. Auto-enables render.',
+                    default: false,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'webpeel_see',
+        description: "Capture a screenshot of any web page. Returns the page as an image for visual inspection. " +
+            "Supports mobile, tablet, and desktop viewports. " +
+            "Use mode='design' for AI-powered design analysis and suggestions. " +
+            "Use mode='compare' with compare_url to diff two pages visually. " +
+            "Use full_page=true to capture the entire scrollable page.",
+        annotations: {
+            title: 'See Page Visually',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to screenshot' },
+                mode: {
+                    type: 'string',
+                    enum: ['screenshot', 'design', 'compare'],
+                    description: "Mode: 'screenshot' (default), 'design' (analysis), 'compare' (visual diff)",
+                    default: 'screenshot',
+                },
+                compare_url: {
+                    type: 'string',
+                    description: "Second URL to compare against (for mode='compare')",
+                },
+                viewport: {
+                    description: "Viewport size: 'mobile' | 'tablet' | {width, height}",
+                    oneOf: [
+                        { type: 'string', enum: ['mobile', 'tablet', 'desktop'] },
+                        {
+                            type: 'object',
+                            properties: {
+                                width: { type: 'number' },
+                                height: { type: 'number' },
+                            },
+                            required: ['width', 'height'],
+                        },
+                    ],
+                },
+                full_page: {
+                    type: 'boolean',
+                    description: 'Capture the full scrollable page',
+                    default: false,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'webpeel_find',
+        description: "Search the web or discover all pages on a site. " +
+            "Pass query= to search the web and get ranked results with titles, URLs, and snippets. " +
+            "Pass url= to map/crawl a domain and discover all its pages. " +
+            "Use depth='deep' for multi-source research that synthesizes answers from multiple pages. " +
+            "Smart search detects intent for restaurants, products, flights, hotels, and more.",
+        annotations: {
+            title: 'Find on the Web',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                url: { type: 'string', description: 'Domain URL to map/discover all pages' },
+                depth: {
+                    type: 'string',
+                    enum: ['quick', 'deep'],
+                    description: "Search depth: 'quick' = single search, 'deep' = multi-source research",
+                    default: 'quick',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results to return (default: 5)',
+                    default: 5,
+                },
+            },
+        },
+    },
+    {
+        name: 'webpeel_extract',
+        description: "Extract structured JSON data from any URL. No LLM needed for built-in schemas. " +
+            "Pass fields=['price','title','description'] to extract specific named fields. " +
+            "Pass schema={...} with a full JSON schema for custom structured output. " +
+            "Built-in schemas: product, article, recipe, job, event, contact, business, review, listing. " +
+            "Works on Amazon, Yelp, LinkedIn, job boards, e-commerce sites, and any web page.",
+        annotations: {
+            title: 'Extract Structured Data',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to extract from' },
+                schema: { type: 'object', description: 'JSON schema describing desired output structure' },
+                fields: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: "Specific fields to extract, e.g. ['price', 'title', 'description']",
+                },
+                format: {
+                    type: 'string',
+                    enum: ['json', 'markdown'],
+                    description: 'Output format (default: json)',
+                    default: 'json',
+                },
+                llmProvider: {
+                    type: 'string',
+                    enum: ['openai', 'anthropic', 'google'],
+                    description: 'LLM provider for schema extraction (BYOK). Required when using custom schema.',
+                },
+                llmApiKey: {
+                    type: 'string',
+                    description: 'Your LLM API key (BYOK). Required when using custom schema with llmProvider.',
+                },
+                llmModel: {
+                    type: 'string',
+                    description: 'LLM model name (optional). Defaults: gpt-4o-mini (OpenAI), claude-haiku-4-5 (Anthropic), gemini-2.0-flash (Google).',
+                },
+                llmBaseUrl: {
+                    type: 'string',
+                    description: 'Custom OpenAI-compatible API base URL. Use for OpenRouter, Glama, or self-hosted models.',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'webpeel_monitor',
+        description: "Track a web page for content changes over time. Call once to take a snapshot, call again to get a diff. " +
+            "Use selector= to monitor a specific CSS element (e.g. a price, a status badge). " +
+            "Use webhook= for persistent monitoring with automatic notifications when content changes. " +
+            "Use interval= to set how frequently to check ('1h', '30m', '1d'). " +
+            "Ideal for: price tracking, job listing changes, release monitoring, competitor updates.",
+        annotations: {
+            title: 'Monitor URL for Changes',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to monitor' },
+                webhook: {
+                    type: 'string',
+                    description: 'Webhook URL to notify when content changes',
+                },
+                interval: {
+                    type: 'string',
+                    description: "Check interval, e.g. '1h', '30m', '1d'",
+                    default: '1h',
+                },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector to monitor a specific part of the page',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'webpeel_observe',
+        description: "Give yourself eyes — discover all interactive elements on a web page without needing a vision model. " +
+            "Returns structured data: links, buttons, inputs, forms, selects, and media with CSS selectors and text labels. " +
+            "Each element has a ref (e.g. 'button-0', 'input-2') for easy reference in follow-up actions. " +
+            "Use this BEFORE webpeel_act to discover what's on the page. " +
+            "The observe → decide → act → observe loop gives agents full web autonomy. " +
+            "Use viewport='mobile' or 'tablet' to see responsive layouts. " +
+            "Use selector= to scope observation to a specific part of the page.",
+        annotations: {
+            title: 'Observe Page Elements',
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to observe' },
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector to scope observation (e.g. "main", "#content")',
+                },
+                viewport: {
+                    type: 'string',
+                    enum: ['desktop', 'mobile', 'tablet'],
+                    description: "Viewport to use (default: 'desktop')",
+                    default: 'desktop',
+                },
+                screenshot: {
+                    type: 'boolean',
+                    description: 'Include a screenshot alongside structured element data',
+                    default: false,
+                },
+                max_elements: {
+                    type: 'number',
+                    description: 'Max elements per category (default: 50)',
+                    default: 50,
+                },
+                stealth: {
+                    type: 'boolean',
+                    description: 'Use stealth mode for bot-protected sites',
+                    default: false,
+                },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'webpeel_act',
+        description: "Automate interactions with any web page using a real browser. " +
+            "Click buttons, fill forms, select dropdowns, scroll, wait for elements, and press keys. " +
+            "Returns extracted content and optionally a screenshot after all actions complete. " +
+            "Use for: logging into sites, submitting forms, navigating multi-step flows, " +
+            "interacting with dynamic content that requires user input. " +
+            "Actions: click, type, fill, scroll, wait, press, hover, select.",
+        annotations: {
+            title: 'Act on Web Page',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to interact with' },
+                actions: {
+                    type: 'array',
+                    description: 'Actions to perform, e.g. [{type:"click",selector:".btn"}, {type:"type",selector:"#q",value:"hello"}]',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['click', 'type', 'fill', 'scroll', 'wait', 'press', 'hover', 'select'],
+                            },
+                            selector: { type: 'string' },
+                            value: { type: 'string' },
+                            key: { type: 'string' },
+                            milliseconds: { type: 'number' },
+                        },
+                        required: ['type'],
+                    },
+                },
+                extract_after: {
+                    type: 'boolean',
+                    description: 'Extract content after actions complete',
+                    default: true,
+                },
+                screenshot_after: {
+                    type: 'boolean',
+                    description: 'Take screenshot after actions complete',
+                    default: false,
+                },
+            },
+            required: ['url', 'actions'],
+        },
+    },
+];

package/dist/mcp/handlers/extract.d.ts

@@ -0,0 +1,7 @@
+/**
+ * handleExtract — extract structured data from a URL.
+ * Supports auto-detection, field lists, schema, and brand presets.
+ * Supports LLM-based extraction via llmProvider + llmApiKey.
+ */
+import { type McpHandler } from './types.js';
+export declare const handleExtract: McpHandler;

package/dist/mcp/handlers/extract.js

@@ -0,0 +1,135 @@
+/**
+ * handleExtract — extract structured data from a URL.
+ * Supports auto-detection, field lists, schema, and brand presets.
+ * Supports LLM-based extraction via llmProvider + llmApiKey.
+ */
+import { peel } from '../../index.js';
+import { textResult, safeStringify, timeout } from './types.js';
+import { extractWithLLM } from '../../core/llm-extract.js';
+function extractColorsFromContent(content) {
+    const hexRegex = /#[0-9A-Fa-f]{6}|#[0-9A-Fa-f]{3}/g;
+    const matches = content.match(hexRegex);
+    return matches ? [...new Set(matches)].slice(0, 10) : [];
+}
+function extractFontsFromContent(content) {
+    const fontRegex = /font-family:\s*([^;}"'\n]+)/gi;
+    const fonts = [];
+    let match;
+    while ((match = fontRegex.exec(content)) !== null) {
+        fonts.push(match[1].trim());
+    }
+    return [...new Set(fonts)].slice(0, 5);
+}
+export const handleExtract = async (args, _ctx) => {
+    const url = args['url'];
+    if (!url || typeof url !== 'string')
+        throw new Error('url is required');
+    if (url.length > 2048)
+        throw new Error('URL too long (max 2048 characters)');
+    const schema = args['schema'];
+    const fields = args['fields'];
+    const render = args['render'] || false;
+    const llmApiKey = args['llmApiKey'];
+    const llmProvider = args['llmProvider'];
+    const llmModel = args['llmModel'];
+    const llmBaseUrl = args['llmBaseUrl'];
+    const prompt = args['prompt'];
+    // LLM-based extraction: when llmApiKey (and optionally llmProvider) are provided
+    if (llmApiKey && (schema || prompt)) {
+        const peelResult = await Promise.race([
+            peel(url, { format: 'markdown', render }),
+            timeout(60000, 'LLM extract fetch'),
+        ]);
+        const extractResult = await extractWithLLM({
+            content: peelResult.content,
+            schema: schema,
+            prompt,
+            llmApiKey,
+            llmProvider: llmProvider || 'openai',
+            llmModel,
+            baseUrl: llmBaseUrl,
+        });
+        return textResult(safeStringify({
+            success: true,
+            url: peelResult.url,
+            data: extractResult.items.length === 1 ? extractResult.items[0] : extractResult.items,
+            llm: {
+                provider: extractResult.provider || llmProvider || 'openai',
+                model: extractResult.model,
+                tokens: extractResult.tokensUsed,
+            },
+        }));
+    }
+    // Brand preset: fields=['name','logo','colors','fonts','socials'] or _brand flag
+    const isBrandPreset = args['_brand'] ||
+        (Array.isArray(fields) &&
+            ['name', 'logo', 'colors', 'fonts', 'socials'].every((f) => fields.includes(f)));
+    if (isBrandPreset) {
+        const options = {
+            render,
+            extract: {
+                selectors: {
+                    primaryColor: 'meta[name="theme-color"]',
+                    title: 'title',
+                    logo: 'img[class*="logo"], img[alt*="logo"]',
+                },
+            },
+        };
+        const result = await Promise.race([
+            peel(url, options),
+            timeout(60000, 'Brand extraction'),
+        ]);
+        return textResult(safeStringify({
+            url: result.url,
+            title: result.title,
+            extracted: result.extracted,
+            metadata: result.metadata,
+            colors: extractColorsFromContent(result.content || ''),
+            fonts: extractFontsFromContent(result.content || ''),
+        }));
+    }
+    // Auto-extract when no schema provided
+    if (!schema && (!fields || fields.length === 0)) {
+        const htmlResult = await Promise.race([
+            peel(url, { format: 'html', render }),
+            timeout(60000, 'Auto-extract fetch'),
+        ]);
+        const { autoExtract } = await import('../../core/auto-extract.js');
+        const extracted = autoExtract(htmlResult.content || '', url);
+        return textResult(safeStringify({ url, pageType: extracted.type, structured: extracted }));
+    }
+    // Field-based extraction (CSS selectors from field names)
+    if (fields && fields.length > 0 && !schema) {
+        const fieldSelectorMap = {
+            price: '[class*="price"], [data-price]',
+            title: 'h1, title',
+            description: '[class*="description"], [class*="summary"]',
+            image: 'img[class*="main"], img[class*="hero"]',
+            name: 'h1, [class*="name"]',
+            logo: 'img[class*="logo"], img[alt*="logo"]',
+            colors: 'meta[name="theme-color"]',
+            fonts: 'link[rel="stylesheet"]',
+            socials: 'a[href*="twitter.com"], a[href*="linkedin.com"], a[href*="github.com"]',
+        };
+        const selectors = {};
+        for (const field of fields) {
+            selectors[field] = fieldSelectorMap[field] || `[class*="${field}"], [id*="${field}"]`;
+        }
+        const options = { render, extract: { selectors } };
+        const result = await Promise.race([
+            peel(url, options),
+            timeout(60000, 'Field extraction'),
+        ]);
+        return textResult(safeStringify(result));
+    }
+    // Schema-based extraction
+    const options = {
+        render,
+        extract: { schema },
+    };
+    const result = await Promise.race([
+        peel(url, options),
+        timeout(60000, 'Schema extraction'),
+    ]);
+    return textResult(safeStringify(result));
+};

package/dist/mcp/handlers/fetch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * handleFetch — the full-featured webpeel_fetch handler.
+ * Supports all options: render, stealth, actions, inline LLM extraction, etc.
+ */
+import { type McpHandler } from './types.js';
+export declare const handleFetch: McpHandler;

package/dist/mcp/handlers/fetch.js

@@ -0,0 +1,98 @@
+/**
+ * handleFetch — the full-featured webpeel_fetch handler.
+ * Supports all options: render, stealth, actions, inline LLM extraction, etc.
+ */
+import { peel } from '../../index.js';
+import { normalizeActions } from '../../core/actions.js';
+import { extractInlineJson } from '../../core/extract-inline.js';
+import { textResult, safeStringify, timeout } from './types.js';
+export const handleFetch = async (args, _ctx) => {
+    const { url, render, stealth, wait, format, screenshot: ssFlag, screenshotFullPage, selector, exclude, includeTags, excludeTags, images, location, headers, actions: rawActions, autoScroll: autoScrollParam, maxTokens, extract, inlineExtract, llmProvider, llmApiKey, llmModel, question, budget: budgetArg, readable, } = args;
+    if (!url || typeof url !== 'string')
+        throw new Error('Invalid URL parameter');
+    if (url.length > 2048)
+        throw new Error('URL too long (max 2048 characters)');
+    const normalizedActions = rawActions ? normalizeActions(rawActions) : undefined;
+    const hasActions = normalizedActions && normalizedActions.length > 0;
+    const options = {
+        render: render || hasActions || !!autoScrollParam || false,
+        stealth: stealth || false,
+        wait: wait || 0,
+        format: format || 'markdown',
+        screenshot: ssFlag || false,
+        screenshotFullPage: screenshotFullPage || false,
+        selector,
+        exclude,
+        includeTags,
+        excludeTags,
+        images,
+        location: location ? { country: location } : undefined,
+        headers,
+        actions: normalizedActions,
+        autoScroll: autoScrollParam,
+        maxTokens,
+        extract,
+        readable: readable || false,
+        lite: args['lite'] || false,
+        question,
+        budget: args['lite'] ? undefined : (budgetArg ?? (maxTokens === undefined ? 4000 : undefined)),
+    };
+    const peeled = await Promise.race([
+        peel(url, options),
+        timeout(60000, 'MCP operation'),
+    ]);
+    // Allow mutable result for inline extraction annotations
+    const result = peeled;
+    // Inline LLM extraction (BYOK)
+    if (inlineExtract && (inlineExtract.schema || inlineExtract.prompt) && llmApiKey && llmProvider) {
+        const validProviders = ['openai', 'anthropic', 'google'];
+        if (validProviders.includes(llmProvider)) {
+            const extractResult = await extractInlineJson(result.content, {
+                schema: inlineExtract.schema,
+                prompt: inlineExtract.prompt,
+                llmProvider: llmProvider,
+                llmApiKey,
+                llmModel,
+            });
+            result.json = extractResult.data;
+            result.extractTokensUsed = extractResult.tokensUsed;
+        }
+    }
+    const out = {
+        url: result.url || url,
+        title: result.title || result.metadata?.title || '',
+        tokens: result.tokens || 0,
+        content: result.content,
+    };
+    if (result.metadata)
+        out['metadata'] = result.metadata;
+    if (result.domainData)
+        out['domainData'] = result.domainData;
+    if (result.readability) {
+        out['readability'] = {
+            readingTime: result.readability.readingTime,
+            wordCount: result.readability.wordCount,
+        };
+    }
+    if (result.quickAnswer)
+        out['quickAnswer'] = result.quickAnswer;
+    if (result.json)
+        out['json'] = result.json;
+    if (result.extracted)
+        out['extracted'] = result.extracted;
+    if (result.images?.length)
+        out['images'] = result.images;
+    if (result.screenshot)
+        out['screenshot'] = result.screenshot;
+    if (result.fingerprint)
+        out['fingerprint'] = result.fingerprint;
+    if (result.extractTokensUsed)
+        out['extractTokensUsed'] = result.extractTokensUsed;
+    if (result.quality !== undefined)
+        out['quality'] = result.quality;
+    if (result.timing)
+        out['timing'] = result.timing;
+    if (result.method)
+        out['method'] = result.method;
+    return textResult(safeStringify(out));
+};

package/dist/mcp/handlers/find.d.ts

@@ -0,0 +1,5 @@
+/**
+ * handleFind — search the web, discover domain URLs, or do deep research.
+ */
+import { type McpHandler } from './types.js';
+export declare const handleFind: McpHandler;