@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/index.js

@@ -0,0 +1,291 @@
+/**
+ * WebPeel - Fast web fetcher for AI agents
+ *
+ * Main library export
+ */
+import { cleanup, warmup, closePool, scrollAndWait, closeProfileBrowser } from './core/fetcher.js';
+import { createContext, normalizeOptions, handleYouTube, fetchContent, detectContentType, parseContent, postProcess, finalize, buildResult, } from './core/pipeline.js';
+import { checkUrlSafety } from './core/safe-browsing.js';
+export * from './types.js';
+export { WebPeelError as TypedWebPeelError, Errors, isRetryable, } from './errors.js';
+export { withRetry, DomainRateLimiter, domainLimiter } from './core/retry.js';
+// Domain extractors — compiled JS ships in npm, TypeScript source is .gitignore'd.
+// Re-export types from the basic stub (always available), runtime functions via lazy wrapper.
+export { getDomainExtractor, extractDomainData } from './ee/domain-extractors.js';
+export { crawl } from './core/crawler.js';
+export { discoverSitemap } from './core/sitemap.js';
+export { mapDomain } from './core/map.js';
+export { extractBranding } from './core/branding.js';
+export { trackChange, getSnapshot, clearSnapshots } from './core/change-tracking.js';
+export { extractWithLLM } from './core/extract.js';
+export { extractDocumentToFormat, isPdfContentType, isDocxContentType } from './core/documents.js';
+export { extractInlineJson } from './core/extract-inline.js';
+export { runAgent } from './core/agent.js';
+export { summarizeContent } from './core/summarize.js';
+export { getSearchProvider, DuckDuckGoProvider, BraveSearchProvider, providerStats, } from './core/search-provider.js';
+export { BaiduSearchProvider, YandexSearchProvider, NaverSearchProvider, YahooJapanSearchProvider } from './core/search-engines.js';
+export { crossVerifySearch } from './core/cross-verify.js';
+export { answerQuestion, } from './core/answer.js';
+export { parseGoogleSerp } from './core/google-serp-parser.js';
+export { searchJobs } from './core/jobs.js';
+export { RateGovernor, formatDuration, } from './core/rate-governor.js';
+export { ApplicationTracker, } from './core/application-tracker.js';
+export { applyToJob, loadApplications, saveApplication, getApplicationsToday, updateApplicationStatus, } from './core/apply.js';
+// Human behavior exports — see bottom of file for full export
+export { extractListings } from './core/extract-listings.js';
+export { parseYouTubeUrl, extractVideoInfo, extractPlayerResponse, parseCaptionXml, decodeHtmlEntities, getYouTubeTranscript, } from './core/youtube.js';
+export { formatTable } from './core/table-format.js';
+export { findNextPageUrl } from './core/paginate.js';
+export { distillToBudget, budgetListings, TOKENS_PER_LISTING_ITEM } from './core/budget.js';
+export { watch, parseDuration, parseAssertion, } from './core/watch.js';
+export { observe, } from './core/observe.js';
+export { diffUrl, } from './core/diff.js';
+export { extractReadableContent } from './core/readability.js';
+export { quickAnswer } from './core/quick-answer.js';
+export { extractValueFromPassage, smartExtractSchemaFields } from './core/schema-postprocess.js';
+export { Timer } from './core/timing.js';
+export { chunkContent } from './core/chunker.js';
+export async function searchFallback(..._args) {
+    // @ts-ignore — proprietary module, gitignored
+    try {
+        const m = await import('./core/search-fallback.js');
+        return m.searchFallback(..._args);
+    }
+    catch {
+        return null;
+    }
+}
+export { peelTLSFetch, isPeelTLSAvailable, shutdownPeelTLS } from './core/peel-tls.js';
+export { sanitizeForLLM } from './core/prompt-guard.js';
+export { getSourceCredibility } from './core/source-credibility.js';
+export { verifyDomain } from './core/domain-verify.js';
+export { checkUrlSafety } from './core/safe-browsing.js';
+export { checkThreatFeeds } from './core/threat-feeds.js';
+export { detectLanguageFromUrl, buildAcceptLanguageHeader } from './core/language-detect.js';
+export { localSearch } from './core/local-search.js';
+export { getBusinessIntel } from './core/business-intel.js';
+export { CircuitBreaker, browserCircuitBreaker } from './core/circuit-breaker.js';
+export { checkMemoryPressure } from './core/browser-pool.js';
+export { searchShopping, searchNews, searchImages, searchVideos } from './core/vertical-search.js';
+/**
+ * Fetch and extract content from a URL
+ *
+ * @param url - URL to fetch
+ * @param options - Fetch options
+ * @returns Extracted content and metadata
+ *
+ * @example
+ * ```typescript
+ * import { peel } from 'webpeel';
+ *
+ * const result = await peel('https://example.com');
+ * console.log(result.content); // Markdown content
+ * console.log(result.metadata); // Structured metadata
+ * ```
+ */
+export async function peel(url, options = {}) {
+    const ctx = createContext(url, options);
+    normalizeOptions(ctx);
+    // Safe Browsing check — runs before any HTTP request, non-blocking
+    const sbResult = await checkUrlSafety(url, process.env.SAFE_BROWSING_API_KEY);
+    ctx.safeBrowsingResult = sbResult;
+    if (!sbResult.safe) {
+        const threatList = sbResult.threats.join(', ');
+        ctx.warnings.push(`⚠️ URL flagged by Safe Browsing: ${threatList}`);
+    }
+    const ytResult = await handleYouTube(ctx);
+    if (ytResult) {
+        // Attach safe browsing to YouTube results too
+        return {
+            ...ytResult,
+            safeBrowsing: sbResult,
+            ...(ytResult.warnings || ctx.warnings.length > 0
+                ? { warnings: [...(ytResult.warnings ?? []), ...ctx.warnings.filter(w => !ytResult.warnings?.includes(w))] }
+                : {}),
+        };
+    }
+    try {
+        await fetchContent(ctx);
+        detectContentType(ctx);
+        await parseContent(ctx);
+        await postProcess(ctx);
+        await finalize(ctx);
+        const result = buildResult(ctx);
+        // Attach safe browsing result
+        result.safeBrowsing = sbResult;
+        // ── Auto-render escalation (post-processing) ────────────────────────
+        // If final content is thin and we did NOT use browser rendering,
+        // retry with render=true. This catches SPAs that return enough SSR
+        // HTML to pass the fetch-time thin-content check but produce sparse
+        // extracted content (e.g. React shells with nav chrome only).
+        // Only escalate when: (a) not already rendered, (b) not explicitly
+        // opted out (noEscalate), (c) not a domain-extracted result, (d) HTML
+        // content type, (e) not a retry already.
+        const contentTokens = result.tokens ?? Math.ceil((result.content?.length ?? 0) / 4);
+        const wasRendered = ctx.render || options.render;
+        const hasDomainData = !!ctx.domainData;
+        const isHtml = (ctx.fetchResult?.contentType || '').includes('html');
+        const noEscalate = !!options.noEscalate;
+        const isRetry = !!options._autoRenderRetry;
+        // Don't escalate when user explicitly limited output size
+        const hasTokenBudget = !!(options.budget || options.maxTokens);
+        // Don't escalate if browser/stealth was already used — can't go higher
+        const fetchMethod = ctx.fetchResult?.method ?? '';
+        const alreadyBrowserOrStealth = fetchMethod === 'browser' || fetchMethod === 'stealth' ||
+            fetchMethod === 'browser-with-wait' || wasRendered;
+        if (contentTokens < 80 &&
+            !alreadyBrowserOrStealth &&
+            !hasDomainData &&
+            isHtml &&
+            !noEscalate &&
+            !isRetry &&
+            !hasTokenBudget &&
+            result.content &&
+            result.content.length < 400) {
+            // Retry with render — this is a one-shot escalation, not a loop
+            const retryResult = await peel(url, {
+                ...options,
+                render: true,
+                noCache: true,
+                _autoRenderRetry: true,
+            });
+            // Only use the retry if it produced more content
+            if ((retryResult.tokens ?? 0) > contentTokens) {
+                retryResult.warnings = [
+                    ...(retryResult.warnings || []),
+                    'Auto-escalated to browser rendering (initial fetch produced sparse content)',
+                ];
+                return retryResult;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        // Clean up browser resources on error
+        await cleanup();
+        throw error;
+    }
+}
+/**
+ * Fetch multiple URLs in batch with concurrency control
+ *
+ * @param urls - Array of URLs to fetch
+ * @param options - Fetch options (including concurrency)
+ * @returns Array of results or errors
+ *
+ * @example
+ * ```typescript
+ * import { peelBatch } from 'webpeel';
+ *
+ * const urls = ['https://example.com', 'https://example.org'];
+ * const results = await peelBatch(urls, { concurrency: 3 });
+ * ```
+ */
+export async function peelBatch(urls, options = {}) {
+    const { concurrency = 3, onProgress, ...peelOpts } = options;
+    const results = new Array(urls.length);
+    let nextIndex = 0;
+    let completedCount = 0;
+    async function worker() {
+        while (nextIndex < urls.length) {
+            const index = nextIndex++;
+            const url = urls[index];
+            try {
+                results[index] = await peel(url, peelOpts);
+            }
+            catch (error) {
+                results[index] = {
+                    url,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+            completedCount++;
+            onProgress?.(completedCount, urls.length);
+        }
+    }
+    // Launch concurrent workers (true worker-pool, not sequential batches)
+    const workerCount = Math.min(concurrency, urls.length);
+    if (workerCount > 0) {
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    }
+    return results;
+}
+/**
+ * Clean up any browser resources
+ * Call this when you're done using WebPeel
+ */
+export { cleanup, warmup, closePool, scrollAndWait, closeProfileBrowser };
+export { getCached, setCached, clearCache, setCacheTTL } from './core/cache.js';
+export { getRealisticUserAgent, getRandomUA, REALISTIC_USER_AGENTS, } from './core/user-agents.js';
+export { humanDelay, humanMouseMove, humanRead, warmupBrowse, humanType, humanClearAndType, humanClick, humanScroll, humanScrollToElement, warmupSession, humanSelect, humanUploadFile, humanToggle, } from './core/human.js';
+export { SCHEMA_TEMPLATES, getSchemaTemplate, listSchemaTemplates } from './core/schema-templates.js';
+// Framework integrations
+export { WebPeelLoader } from './integrations/langchain.js';
+export { WebPeelReader } from './integrations/llamaindex.js';
+// Advanced stealth utilities — for power users who want to apply extra evasions
+// to their own Playwright pages.
+// stealth-patches: proprietary module, loaded at runtime only
+export async function applyStealthPatches(page) {
+    // @ts-ignore — proprietary module, gitignored
+    try {
+        const m = await import('./core/stealth-patches.js');
+        await m.applyStealthPatches(page);
+    }
+    catch { /* not available */ }
+}
+export async function applyAcceptLanguageHeader(page, lang) {
+    // @ts-ignore — proprietary module, gitignored
+    try {
+        const m = await import('./core/stealth-patches.js');
+        await m.applyAcceptLanguageHeader(page, lang);
+    }
+    catch { /* not available */ }
+}
+// Google Cache fallback — fetch cached copies of blocked pages
+export { fetchGoogleCache, isGoogleCacheAvailable } from './core/google-cache.js';
+export { cfWorkerFetch, isCfWorkerAvailable } from './core/cf-worker-proxy.js';
+/**
+ * WebPeel client class — alternative OOP interface over the functional API.
+ * Provides the same capabilities as the standalone functions but with
+ * a configured client instance.
+ *
+ * @example
+ * import { WebPeel } from 'webpeel';
+ * const wp = new WebPeel({ apiKey: process.env.WEBPEEL_API_KEY });
+ * const result = await wp.fetch('https://stripe.com');
+ */
+export class WebPeel {
+    apiKey;
+    constructor(config) {
+        if (!config.apiKey)
+            throw new Error('WebPeel: apiKey is required');
+        this.apiKey = config.apiKey;
+        // apiUrl reserved for future use (remote API proxy mode)
+        void config.apiUrl;
+    }
+    /** Fetch and extract content from a URL */
+    async fetch(url, options = {}) {
+        return peel(url, { ...options });
+    }
+    /** Search the web */
+    async search(query, options = {}) {
+        const { getSearchProvider } = await import('./core/search-provider.js');
+        const provider = getSearchProvider({ ...options });
+        return provider.searchWeb(query, options);
+    }
+    /** Crawl a site */
+    async crawl(startUrl, options = {}) {
+        const { crawl: crawlFn } = await import('./core/crawler.js');
+        return crawlFn(startUrl, { ...options, apiKey: this.apiKey });
+    }
+    /** Map a domain's pages */
+    async map(url, options = {}) {
+        const { mapDomain } = await import('./core/map.js');
+        return mapDomain(url, { ...options });
+    }
+    /** Extract structured data */
+    async extract(url, _schema, options = {}) {
+        const result = await peel(url, { ...options });
+        return result;
+    }
+}

package/dist/integrations/index.d.ts

@@ -0,0 +1,2 @@
+export { WebPeelLoader, type WebPeelLoaderOptions, type Document } from './langchain.js';
+export { WebPeelReader, type WebPeelReaderOptions, type LlamaDocument } from './llamaindex.js';

package/dist/integrations/index.js

@@ -0,0 +1,2 @@
+export { WebPeelLoader } from './langchain.js';
+export { WebPeelReader } from './llamaindex.js';

package/dist/integrations/langchain.d.ts

@@ -0,0 +1,64 @@
+/**
+ * WebPeel LangChain.js Document Loader
+ *
+ * Usage:
+ *   import { WebPeelLoader } from 'webpeel/integrations/langchain';
+ *   const loader = new WebPeelLoader({ url: 'https://example.com' });
+ *   const docs = await loader.load();
+ */
+import type { PeelOptions } from '../types.js';
+/** LangChain Document interface (we define our own to avoid the dependency) */
+export interface Document {
+    pageContent: string;
+    metadata: Record<string, any>;
+}
+export interface WebPeelLoaderOptions {
+    /** URL to fetch */
+    url: string;
+    /** Multiple URLs to fetch */
+    urls?: string[];
+    /** Scraping mode: 'scrape' for single page, 'crawl' for following links */
+    mode?: 'scrape' | 'crawl';
+    /** Output format */
+    format?: 'markdown' | 'text' | 'html' | 'clean';
+    /** Use headless browser */
+    render?: boolean;
+    /** Stealth mode for anti-bot */
+    stealth?: boolean;
+    /** Token budget per page */
+    budget?: number;
+    /** Proxy URL */
+    proxy?: string;
+    /** Multiple proxies for rotation */
+    proxies?: string[];
+    /** CSS selector to extract */
+    selector?: string;
+    /** Enable chunking for RAG */
+    chunk?: boolean;
+    /** Max tokens per chunk (default: 512) */
+    chunkSize?: number;
+    /** Chunk overlap tokens (default: 50) */
+    chunkOverlap?: number;
+    /** Additional PeelOptions */
+    peelOptions?: Partial<PeelOptions>;
+}
+/**
+ * WebPeel Document Loader for LangChain.js
+ *
+ * Compatible with LangChain's BaseDocumentLoader interface.
+ * Returns Document[] with pageContent and metadata.
+ */
+export declare class WebPeelLoader {
+    private options;
+    constructor(options: WebPeelLoaderOptions);
+    /**
+     * Load documents from the configured URL(s).
+     * If chunking is enabled, each chunk becomes a separate Document.
+     */
+    load(): Promise<Document[]>;
+    /**
+     * Lazy load documents one at a time (async generator).
+     * Useful for large URL lists to avoid memory pressure.
+     */
+    lazyLoad(): AsyncGenerator<Document>;
+}

package/dist/integrations/langchain.js

@@ -0,0 +1,115 @@
+/**
+ * WebPeel LangChain.js Document Loader
+ *
+ * Usage:
+ *   import { WebPeelLoader } from 'webpeel/integrations/langchain';
+ *   const loader = new WebPeelLoader({ url: 'https://example.com' });
+ *   const docs = await loader.load();
+ */
+import { peel } from '../index.js';
+import { chunkContent } from '../core/chunker.js';
+/**
+ * WebPeel Document Loader for LangChain.js
+ *
+ * Compatible with LangChain's BaseDocumentLoader interface.
+ * Returns Document[] with pageContent and metadata.
+ */
+export class WebPeelLoader {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Load documents from the configured URL(s).
+     * If chunking is enabled, each chunk becomes a separate Document.
+     */
+    async load() {
+        const urls = this.options.urls || [this.options.url];
+        const documents = [];
+        for (const url of urls) {
+            try {
+                const peelOpts = {
+                    format: this.options.format || 'markdown',
+                    render: this.options.render,
+                    stealth: this.options.stealth,
+                    budget: this.options.budget,
+                    proxy: this.options.proxy,
+                    proxies: this.options.proxies,
+                    selector: this.options.selector,
+                    ...this.options.peelOptions,
+                };
+                // Remove undefined values
+                Object.keys(peelOpts).forEach(key => {
+                    if (peelOpts[key] === undefined)
+                        delete peelOpts[key];
+                });
+                const result = await peel(url, peelOpts);
+                if (this.options.chunk) {
+                    // Split into chunks, each becomes a Document
+                    const chunkResult = chunkContent(result.content, {
+                        maxTokens: this.options.chunkSize || 512,
+                        overlap: this.options.chunkOverlap || 50,
+                        strategy: 'section',
+                    });
+                    for (const chunk of chunkResult.chunks) {
+                        documents.push({
+                            pageContent: chunk.text,
+                            metadata: {
+                                source: url,
+                                title: result.metadata?.title || '',
+                                description: result.metadata?.description || '',
+                                chunkIndex: chunk.index,
+                                totalChunks: chunkResult.totalChunks,
+                                section: chunk.section,
+                                sectionDepth: chunk.sectionDepth,
+                                tokenCount: chunk.tokenCount,
+                                wordCount: chunk.wordCount,
+                                fetchedAt: result.metadata?.fetchedAt || new Date().toISOString(),
+                                method: result.metadata?.method || 'unknown',
+                            },
+                        });
+                    }
+                }
+                else {
+                    // Single document per URL
+                    documents.push({
+                        pageContent: result.content,
+                        metadata: {
+                            source: url,
+                            title: result.metadata?.title || '',
+                            description: result.metadata?.description || '',
+                            wordCount: result.metadata?.wordCount || 0,
+                            language: result.metadata?.language || '',
+                            fetchedAt: result.metadata?.fetchedAt || new Date().toISOString(),
+                            method: result.metadata?.method || 'unknown',
+                            contentType: result.metadata?.contentType || '',
+                            statusCode: result.metadata?.statusCode || 0,
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                // Include failed URLs as empty documents with error metadata
+                documents.push({
+                    pageContent: '',
+                    metadata: {
+                        source: url,
+                        error: error instanceof Error ? error.message : String(error),
+                        fetchedAt: new Date().toISOString(),
+                    },
+                });
+            }
+        }
+        return documents;
+    }
+    /**
+     * Lazy load documents one at a time (async generator).
+     * Useful for large URL lists to avoid memory pressure.
+     */
+    async *lazyLoad() {
+        const docs = await this.load();
+        for (const doc of docs) {
+            yield doc;
+        }
+    }
+}

package/dist/integrations/llamaindex.d.ts

@@ -0,0 +1,50 @@
+/**
+ * WebPeel LlamaIndex Reader
+ *
+ * Usage:
+ *   import { WebPeelReader } from 'webpeel/integrations/llamaindex';
+ *   const reader = new WebPeelReader();
+ *   const docs = await reader.loadData('https://example.com');
+ */
+import type { PeelOptions } from '../types.js';
+/** LlamaIndex Document interface */
+export interface LlamaDocument {
+    text: string;
+    metadata: Record<string, any>;
+    id_?: string;
+}
+export interface WebPeelReaderOptions {
+    /** Output format */
+    format?: 'markdown' | 'text' | 'html' | 'clean';
+    /** Use headless browser */
+    render?: boolean;
+    /** Stealth mode */
+    stealth?: boolean;
+    /** Token budget */
+    budget?: number;
+    /** Enable chunking */
+    chunk?: boolean;
+    /** Max tokens per chunk */
+    chunkSize?: number;
+    /** Chunk overlap */
+    chunkOverlap?: number;
+    /** Proxy URL */
+    proxy?: string;
+    /** Multiple proxies */
+    proxies?: string[];
+    /** Additional PeelOptions */
+    peelOptions?: Partial<PeelOptions>;
+}
+/**
+ * WebPeel Reader for LlamaIndex
+ *
+ * Compatible with LlamaIndex's BaseReader interface.
+ */
+export declare class WebPeelReader {
+    private options;
+    constructor(options?: WebPeelReaderOptions);
+    /**
+     * Load data from one or more URLs.
+     */
+    loadData(urlOrUrls: string | string[]): Promise<LlamaDocument[]>;
+}

package/dist/integrations/llamaindex.js

@@ -0,0 +1,91 @@
+/**
+ * WebPeel LlamaIndex Reader
+ *
+ * Usage:
+ *   import { WebPeelReader } from 'webpeel/integrations/llamaindex';
+ *   const reader = new WebPeelReader();
+ *   const docs = await reader.loadData('https://example.com');
+ */
+import { peel } from '../index.js';
+import { chunkContent } from '../core/chunker.js';
+/**
+ * WebPeel Reader for LlamaIndex
+ *
+ * Compatible with LlamaIndex's BaseReader interface.
+ */
+export class WebPeelReader {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Load data from one or more URLs.
+     */
+    async loadData(urlOrUrls) {
+        const urls = Array.isArray(urlOrUrls) ? urlOrUrls : [urlOrUrls];
+        const documents = [];
+        for (const url of urls) {
+            try {
+                const peelOpts = {
+                    format: this.options.format || 'markdown',
+                    render: this.options.render,
+                    stealth: this.options.stealth,
+                    budget: this.options.budget,
+                    proxy: this.options.proxy,
+                    proxies: this.options.proxies,
+                    ...this.options.peelOptions,
+                };
+                Object.keys(peelOpts).forEach(key => {
+                    if (peelOpts[key] === undefined)
+                        delete peelOpts[key];
+                });
+                const result = await peel(url, peelOpts);
+                if (this.options.chunk) {
+                    const chunkResult = chunkContent(result.content, {
+                        maxTokens: this.options.chunkSize || 512,
+                        overlap: this.options.chunkOverlap || 50,
+                        strategy: 'section',
+                    });
+                    for (const chunk of chunkResult.chunks) {
+                        documents.push({
+                            text: chunk.text,
+                            id_: `${url}#chunk-${chunk.index}`,
+                            metadata: {
+                                url,
+                                title: result.metadata?.title || '',
+                                chunkIndex: chunk.index,
+                                totalChunks: chunkResult.totalChunks,
+                                section: chunk.section,
+                                tokenCount: chunk.tokenCount,
+                            },
+                        });
+                    }
+                }
+                else {
+                    documents.push({
+                        text: result.content,
+                        id_: url,
+                        metadata: {
+                            url,
+                            title: result.metadata?.title || '',
+                            description: result.metadata?.description || '',
+                            wordCount: result.metadata?.wordCount || 0,
+                            language: result.metadata?.language || '',
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                documents.push({
+                    text: '',
+                    id_: url,
+                    metadata: {
+                        url,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+        }
+        return documents;
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * handleAct — perform browser actions on a page, then optionally extract content.
+ */
+import { type McpHandler } from './types.js';
+export declare const handleAct: McpHandler;

package/dist/mcp/handlers/act.js

@@ -0,0 +1,34 @@
+/**
+ * handleAct — perform browser actions on a page, then optionally extract content.
+ */
+import { peel } from '../../index.js';
+import { normalizeActions } from '../../core/actions.js';
+import { textResult, safeStringify } from './types.js';
+export const handleAct = async (args, _ctx) => {
+    const url = args.url;
+    const rawActions = args.actions || [];
+    const extract = args.extract !== false; // default true
+    const screenshot = Boolean(args.screenshot);
+    if (!url)
+        return textResult(safeStringify({ error: 'url is required' }));
+    if (!rawActions.length)
+        return textResult(safeStringify({ error: 'actions array is required' }));
+    // Normalize actions (handles Firecrawl-style aliases)
+    const actions = normalizeActions(rawActions) || [];
+    const result = await peel(url, {
+        render: true, // actions always require browser
+        actions,
+        screenshot,
+        format: 'markdown',
+        budget: 4000,
+        timeout: 60000,
+    });
+    return textResult(safeStringify({
+        url: result.url,
+        title: result.title,
+        content: extract ? result.content : undefined,
+        screenshot: result.screenshot,
+        method: result.method,
+        elapsed: result.elapsed,
+    }));
+};

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

@@ -0,0 +1,6 @@
+/**
+ * Tool schema definitions — single source of truth for both transports.
+ * Imported by the standalone MCP server and the HTTP MCP route for tools/list.
+ */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const toolDefinitions: Tool[];