opc-agent 4.0.0 → 4.0.2

package/dist/tools/builtin/index.d.ts

@@ -9,6 +9,7 @@ export { fileTool, webTool, shellTool, datetimeTool, browserTools, BrowserManage
 export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool };
 export { rlTools } from './rl-tools';
 export { homeAssistantTools, configureHomeAssistant } from './home-assistant';
+export { webSearchTools, webSearchTool, webReadTool } from './web-search';
 /**
  * Get all built-in tools.
  */

package/dist/tools/builtin/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureHomeAssistant = exports.homeAssistantTools = exports.rlTools = exports.visionCompareTool = exports.visionExtractTextTool = exports.visionAnalyzeTool = exports.visionTools = exports.browserManager = exports.BrowserManager = exports.browserTools = exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
+exports.webReadTool = exports.webSearchTool = exports.webSearchTools = exports.configureHomeAssistant = exports.homeAssistantTools = exports.rlTools = exports.visionCompareTool = exports.visionExtractTextTool = exports.visionAnalyzeTool = exports.visionTools = exports.browserManager = exports.BrowserManager = exports.browserTools = exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
 exports.getBuiltinTools = getBuiltinTools;
 exports.getBuiltinToolsByName = getBuiltinToolsByName;
 const file_1 = require("./file");
@@ -22,12 +22,17 @@ Object.defineProperty(exports, "visionExtractTextTool", { enumerable: true, get:
 Object.defineProperty(exports, "visionCompareTool", { enumerable: true, get: function () { return vision_1.visionCompareTool; } });
 const rl_tools_1 = require("./rl-tools");
 const home_assistant_1 = require("./home-assistant");
+const web_search_1 = require("./web-search");
 var rl_tools_2 = require("./rl-tools");
 Object.defineProperty(exports, "rlTools", { enumerable: true, get: function () { return rl_tools_2.rlTools; } });
 var home_assistant_2 = require("./home-assistant");
 Object.defineProperty(exports, "homeAssistantTools", { enumerable: true, get: function () { return home_assistant_2.homeAssistantTools; } });
 Object.defineProperty(exports, "configureHomeAssistant", { enumerable: true, get: function () { return home_assistant_2.configureHomeAssistant; } });
-const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool, ...browser_1.browserTools, ...vision_1.visionTools, ...rl_tools_1.rlTools, ...home_assistant_1.homeAssistantTools];
+var web_search_2 = require("./web-search");
+Object.defineProperty(exports, "webSearchTools", { enumerable: true, get: function () { return web_search_2.webSearchTools; } });
+Object.defineProperty(exports, "webSearchTool", { enumerable: true, get: function () { return web_search_2.webSearchTool; } });
+Object.defineProperty(exports, "webReadTool", { enumerable: true, get: function () { return web_search_2.webReadTool; } });
+const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool, ...browser_1.browserTools, ...vision_1.visionTools, ...rl_tools_1.rlTools, ...home_assistant_1.homeAssistantTools, ...web_search_1.webSearchTools];
 const BUILTIN_MAP = new Map(ALL_BUILTIN_TOOLS.map(t => [t.name, t]));
 /**
  * Get all built-in tools.

package/dist/tools/builtin/web-search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Web Search & Read Built-in Tools - v0.10.0
+ * Registers web_search and web_read as agent-callable tools.
+ */
+import type { MCPTool } from '../mcp';
+export declare const webSearchTool: MCPTool;
+export declare const webReadTool: MCPTool;
+export declare const webSearchTools: MCPTool[];
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/builtin/web-search.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Web Search & Read Built-in Tools - v0.10.0
+ * Registers web_search and web_read as agent-callable tools.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTools = exports.webReadTool = exports.webSearchTool = void 0;
+const web_search_1 = require("../web-search");
+const web_scraper_1 = require("../web-scraper");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os = __importStar(require("os"));
+function loadSearchConfig() {
+    try {
+        const cfgPath = (0, path_1.join)(os.homedir(), '.opc', 'config.json');
+        if ((0, fs_1.existsSync)(cfgPath)) {
+            const cfg = JSON.parse((0, fs_1.readFileSync)(cfgPath, 'utf-8'));
+            if (cfg.webSearch) {
+                return { ...web_search_1.DEFAULT_SEARCH_CONFIG, ...cfg.webSearch };
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return web_search_1.DEFAULT_SEARCH_CONFIG;
+}
+exports.webSearchTool = {
+    name: 'web_search',
+    description: 'Search the internet for information. Returns titles, URLs, and snippets from search results. Use when you need current information or facts you\'re unsure about.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search query string',
+            },
+            maxResults: {
+                type: 'number',
+                description: 'Maximum number of results to return (default: 5)',
+            },
+            engine: {
+                type: 'string',
+                enum: ['duckduckgo', 'brave', 'searxng', 'google'],
+                description: 'Search engine to use (default: configured engine)',
+            },
+        },
+        required: ['query'],
+    },
+    async execute(input) {
+        const query = String(input.query ?? '');
+        if (!query.trim()) {
+            return { content: 'Error: empty search query', isError: true };
+        }
+        const config = loadSearchConfig();
+        if (!config.enabled) {
+            return { content: 'Web search is disabled in settings.', isError: true };
+        }
+        try {
+            const results = await (0, web_search_1.webSearch)(query, config, {
+                maxResults: input.maxResults || 5,
+                engine: input.engine,
+            });
+            if (results.length === 0) {
+                return { content: `No results found for: ${query}` };
+            }
+            const formatted = results.map((r, i) => `${i + 1}. **${r.title}**\n   ${r.url}\n   ${r.snippet}`).join('\n\n');
+            return {
+                content: `Search results for "${query}":\n\n${formatted}`,
+                metadata: { resultCount: results.length, query },
+            };
+        }
+        catch (err) {
+            return {
+                content: `Search error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+    },
+};
+exports.webReadTool = {
+    name: 'web_read',
+    description: 'Read and extract the main content from a web page URL. Returns clean markdown text. Use to get detailed information from a specific page.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: 'URL of the web page to read',
+            },
+            maxLength: {
+                type: 'number',
+                description: 'Maximum content length in characters (default: 5000)',
+            },
+        },
+        required: ['url'],
+    },
+    async execute(input) {
+        const url = String(input.url ?? '');
+        if (!url.trim()) {
+            return { content: 'Error: empty URL', isError: true };
+        }
+        try {
+            const result = await (0, web_scraper_1.scrapeUrl)(url, input.maxLength || 5000);
+            return {
+                content: `# ${result.title}\n\nSource: ${result.url}\nWords: ${result.wordCount}\n\n---\n\n${result.content}`,
+                metadata: { title: result.title, url: result.url, wordCount: result.wordCount },
+            };
+        }
+        catch (err) {
+            return {
+                content: `Scrape error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
+        }
+    },
+};
+exports.webSearchTools = [exports.webSearchTool, exports.webReadTool];
+//# sourceMappingURL=web-search.js.map

package/dist/tools/document-processor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Document Processor - Parse and chunk documents for knowledge learning
+ * Supports: PDF, TXT, MD, DOCX, CSV, JSON
+ */
+export interface DocumentChunk {
+    title: string;
+    content: string;
+    metadata: {
+        source: string;
+        format: string;
+        chunkIndex: number;
+        totalChunks?: number;
+        page?: number;
+    };
+}
+export interface ProcessedDocument {
+    id: string;
+    filename: string;
+    format: string;
+    size: number;
+    chunks: DocumentChunk[];
+    processedAt: string;
+}
+export declare class DocumentProcessor {
+    /**
+     * Process a file buffer into chunks
+     */
+    process(buffer: Buffer, filename: string): Promise<ProcessedDocument>;
+    private parsePDF;
+    private parseDOCX;
+    private parseCSV;
+    private parseCSVLine;
+    private parseJSON;
+    /**
+     * Smart chunking: split by headings/paragraphs, respecting size limits
+     */
+    private chunkText;
+}
+//# sourceMappingURL=document-processor.d.ts.map

package/dist/tools/document-processor.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Document Processor - Parse and chunk documents for knowledge learning
+ * Supports: PDF, TXT, MD, DOCX, CSV, JSON
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentProcessor = void 0;
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
+const CHUNK_TARGET_CHARS = 2000; // ~500 tokens
+const CHUNK_MAX_CHARS = 4000; // ~1000 tokens
+class DocumentProcessor {
+    /**
+     * Process a file buffer into chunks
+     */
+    async process(buffer, filename) {
+        if (buffer.length > MAX_FILE_SIZE) {
+            throw new Error(`File too large: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (max 50MB)`);
+        }
+        const ext = filename.split('.').pop()?.toLowerCase() || '';
+        let rawText;
+        switch (ext) {
+            case 'pdf':
+                rawText = await this.parsePDF(buffer);
+                break;
+            case 'docx':
+                rawText = await this.parseDOCX(buffer);
+                break;
+            case 'csv':
+                rawText = this.parseCSV(buffer.toString('utf-8'));
+                break;
+            case 'json':
+                rawText = this.parseJSON(buffer.toString('utf-8'));
+                break;
+            case 'txt':
+            case 'md':
+            case 'markdown':
+                rawText = buffer.toString('utf-8');
+                break;
+            default:
+                // Try as plain text
+                rawText = buffer.toString('utf-8');
+        }
+        const chunks = this.chunkText(rawText, filename, ext);
+        return {
+            id: `doc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            filename,
+            format: ext,
+            size: buffer.length,
+            chunks,
+            processedAt: new Date().toISOString(),
+        };
+    }
+    async parsePDF(buffer) {
+        try {
+            const pdfParse = require('pdf-parse');
+            const data = await pdfParse(buffer);
+            return data.text || '';
+        }
+        catch (e) {
+            throw new Error(`PDF parse failed: ${e.message}`);
+        }
+    }
+    async parseDOCX(buffer) {
+        try {
+            const mammoth = require('mammoth');
+            const result = await mammoth.extractRawText({ buffer });
+            return result.value || '';
+        }
+        catch (e) {
+            throw new Error(`DOCX parse failed: ${e.message}`);
+        }
+    }
+    parseCSV(text) {
+        const lines = text.split('\n').filter(l => l.trim());
+        if (lines.length === 0)
+            return '';
+        const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+        const rows = lines.slice(1);
+        // Convert CSV to readable text
+        return rows.map((row, i) => {
+            const values = this.parseCSVLine(row);
+            const pairs = headers.map((h, j) => `${h}: ${values[j] || ''}`);
+            return `Record ${i + 1}:\n${pairs.join('\n')}`;
+        }).join('\n\n');
+    }
+    parseCSVLine(line) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (const ch of line) {
+            if (ch === '"') {
+                inQuotes = !inQuotes;
+            }
+            else if (ch === ',' && !inQuotes) {
+                result.push(current.trim());
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+        result.push(current.trim());
+        return result;
+    }
+    parseJSON(text) {
+        try {
+            const data = JSON.parse(text);
+            if (Array.isArray(data)) {
+                return data.map((item, i) => `Item ${i + 1}:\n${JSON.stringify(item, null, 2)}`).join('\n\n');
+            }
+            return JSON.stringify(data, null, 2);
+        }
+        catch {
+            return text;
+        }
+    }
+    /**
+     * Smart chunking: split by headings/paragraphs, respecting size limits
+     */
+    chunkText(text, filename, format) {
+        if (!text.trim())
+            return [];
+        // Split by markdown headings or double newlines
+        const sections = text.split(/\n(?=#{1,3}\s)|(?:\n\s*\n)/).filter(s => s.trim());
+        const chunks = [];
+        let currentChunk = '';
+        let currentTitle = filename;
+        for (const section of sections) {
+            const headingMatch = section.match(/^(#{1,3})\s+(.+)/);
+            if (headingMatch) {
+                currentTitle = headingMatch[2].trim();
+            }
+            if (currentChunk.length + section.length > CHUNK_MAX_CHARS && currentChunk.length > 0) {
+                chunks.push({
+                    title: currentTitle,
+                    content: currentChunk.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+                currentChunk = '';
+            }
+            currentChunk += section + '\n\n';
+            if (currentChunk.length >= CHUNK_TARGET_CHARS) {
+                chunks.push({
+                    title: currentTitle,
+                    content: currentChunk.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+                currentChunk = '';
+            }
+        }
+        if (currentChunk.trim()) {
+            chunks.push({
+                title: currentTitle,
+                content: currentChunk.trim(),
+                metadata: { source: filename, format, chunkIndex: chunks.length },
+            });
+        }
+        // If we got no chunks from section splitting (e.g. dense text), force-split
+        if (chunks.length === 0 && text.trim()) {
+            const words = text.split(/\s+/);
+            let buf = '';
+            for (const w of words) {
+                if (buf.length + w.length + 1 > CHUNK_MAX_CHARS && buf) {
+                    chunks.push({
+                        title: filename,
+                        content: buf.trim(),
+                        metadata: { source: filename, format, chunkIndex: chunks.length },
+                    });
+                    buf = '';
+                }
+                buf += w + ' ';
+            }
+            if (buf.trim()) {
+                chunks.push({
+                    title: filename,
+                    content: buf.trim(),
+                    metadata: { source: filename, format, chunkIndex: chunks.length },
+                });
+            }
+        }
+        // Set totalChunks
+        for (const c of chunks)
+            c.metadata.totalChunks = chunks.length;
+        return chunks;
+    }
+}
+exports.DocumentProcessor = DocumentProcessor;
+//# sourceMappingURL=document-processor.js.map

package/dist/tools/image-generator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Image Generator — multi-backend image generation tool.
+ * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
+ */
+export interface ImageGenConfig {
+    provider?: 'dalle' | 'stable-diffusion' | 'replicate';
+    openaiApiKey?: string;
+    replicateApiKey?: string;
+    sdApiUrl?: string;
+    defaultModel?: string;
+    defaultSize?: string;
+}
+export interface ImageGenResult {
+    success: boolean;
+    url?: string;
+    base64?: string;
+    error?: string;
+    provider: string;
+}
+export declare class ImageGenerator {
+    private config;
+    constructor(config?: ImageGenConfig);
+    /** Auto-detect best available provider */
+    detectProvider(): string | null;
+    /** Get configuration status for the settings UI */
+    getStatus(): {
+        configured: boolean;
+        providers: {
+            name: string;
+            configured: boolean;
+        }[];
+    };
+    generate(prompt: string, options?: {
+        provider?: string;
+        size?: string;
+        model?: string;
+    }): Promise<ImageGenResult>;
+    private generateDalle;
+    private generateSD;
+    private generateReplicate;
+}
+//# sourceMappingURL=image-generator.d.ts.map

package/dist/tools/image-generator.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Image Generator — multi-backend image generation tool.
+ * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenerator = void 0;
+class ImageGenerator {
+    config;
+    constructor(config) {
+        this.config = {
+            provider: config?.provider,
+            openaiApiKey: config?.openaiApiKey || process.env.OPENAI_API_KEY,
+            replicateApiKey: config?.replicateApiKey || process.env.REPLICATE_API_TOKEN,
+            sdApiUrl: config?.sdApiUrl || process.env.SD_API_URL,
+            defaultModel: config?.defaultModel || 'dall-e-3',
+            defaultSize: config?.defaultSize || '1024x1024',
+        };
+    }
+    /** Auto-detect best available provider */
+    detectProvider() {
+        if (this.config.openaiApiKey)
+            return 'dalle';
+        if (this.config.sdApiUrl)
+            return 'stable-diffusion';
+        if (this.config.replicateApiKey)
+            return 'replicate';
+        return null;
+    }
+    /** Get configuration status for the settings UI */
+    getStatus() {
+        return {
+            configured: !!this.detectProvider(),
+            providers: [
+                { name: 'dalle', configured: !!this.config.openaiApiKey },
+                { name: 'stable-diffusion', configured: !!this.config.sdApiUrl },
+                { name: 'replicate', configured: !!this.config.replicateApiKey },
+            ],
+        };
+    }
+    async generate(prompt, options) {
+        const provider = options?.provider || this.config.provider || this.detectProvider();
+        if (!provider) {
+            return { success: false, error: 'No image generation provider configured. Please set OPENAI_API_KEY, SD_API_URL, or REPLICATE_API_TOKEN.', provider: 'none' };
+        }
+        switch (provider) {
+            case 'dalle': return this.generateDalle(prompt, options);
+            case 'stable-diffusion': return this.generateSD(prompt, options);
+            case 'replicate': return this.generateReplicate(prompt, options);
+            default: return { success: false, error: `Unknown provider: ${provider}`, provider };
+        }
+    }
+    async generateDalle(prompt, options) {
+        const apiKey = this.config.openaiApiKey;
+        if (!apiKey)
+            return { success: false, error: 'OPENAI_API_KEY not configured', provider: 'dalle' };
+        try {
+            const res = await fetch('https://api.openai.com/v1/images/generations', {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: options?.model || this.config.defaultModel || 'dall-e-3',
+                    prompt,
+                    size: options?.size || this.config.defaultSize || '1024x1024',
+                    n: 1,
+                }),
+            });
+            const data = await res.json();
+            if (data.error)
+                return { success: false, error: data.error.message, provider: 'dalle' };
+            const url = data.data?.[0]?.url;
+            return url ? { success: true, url, provider: 'dalle' } : { success: false, error: 'No image returned', provider: 'dalle' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'dalle' };
+        }
+    }
+    async generateSD(prompt, options) {
+        const apiUrl = this.config.sdApiUrl;
+        if (!apiUrl)
+            return { success: false, error: 'SD_API_URL not configured', provider: 'stable-diffusion' };
+        try {
+            const [w, h] = (options?.size || '1024x1024').split('x').map(Number);
+            const res = await fetch(`${apiUrl}/sdapi/v1/txt2img`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ prompt, width: w || 1024, height: h || 1024 }),
+            });
+            const data = await res.json();
+            if (data.images?.length) {
+                return { success: true, base64: data.images[0], provider: 'stable-diffusion' };
+            }
+            return { success: false, error: 'No image generated', provider: 'stable-diffusion' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'stable-diffusion' };
+        }
+    }
+    async generateReplicate(prompt, _options) {
+        const apiKey = this.config.replicateApiKey;
+        if (!apiKey)
+            return { success: false, error: 'REPLICATE_API_TOKEN not configured', provider: 'replicate' };
+        try {
+            const res = await fetch('https://api.replicate.com/v1/predictions', {
+                method: 'POST',
+                headers: { 'Authorization': `Token ${apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    version: 'stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b',
+                    input: { prompt },
+                }),
+            });
+            const prediction = await res.json();
+            if (prediction.error)
+                return { success: false, error: prediction.error, provider: 'replicate' };
+            // Poll for completion (max 60s)
+            const getUrl = prediction.urls?.get || `https://api.replicate.com/v1/predictions/${prediction.id}`;
+            for (let i = 0; i < 30; i++) {
+                await new Promise(r => setTimeout(r, 2000));
+                const poll = await fetch(getUrl, { headers: { 'Authorization': `Token ${apiKey}` } });
+                const result = await poll.json();
+                if (result.status === 'succeeded' && result.output?.length) {
+                    return { success: true, url: result.output[0], provider: 'replicate' };
+                }
+                if (result.status === 'failed') {
+                    return { success: false, error: result.error || 'Generation failed', provider: 'replicate' };
+                }
+            }
+            return { success: false, error: 'Timeout waiting for image generation', provider: 'replicate' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'replicate' };
+        }
+    }
+}
+exports.ImageGenerator = ImageGenerator;
+//# sourceMappingURL=image-generator.js.map

package/dist/tools/web-scraper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Web Scraper - v0.10.0
+ * Fetch URL content and extract readable text in markdown format.
+ * Uses a simple readability-style extraction (no external dependencies).
+ */
+export interface ScrapedContent {
+    title: string;
+    content: string;
+    url: string;
+    wordCount: number;
+}
+/**
+ * Fetch a URL and extract readable content as markdown.
+ */
+export declare function scrapeUrl(url: string, maxLength?: number): Promise<ScrapedContent>;
+/**
+ * Extract readable content from HTML using simple heuristics.
+ */
+export declare function extractReadableContent(html: string, url: string, maxLength?: number): ScrapedContent;
+//# sourceMappingURL=web-scraper.d.ts.map