@staticn0va/wigolo 0.3.1 → 0.5.1

package/dist/search/sampling.js

@@ -0,0 +1,52 @@
+import { createLogger } from '../logger.js';
+const log = createLogger('search');
+export function checkSamplingSupport(server) {
+    try {
+        const capabilities = server.getClientCapabilities();
+        if (!capabilities)
+            return false;
+        return capabilities.sampling !== undefined;
+    }
+    catch (err) {
+        log.debug('sampling support check failed', { error: String(err) });
+        return false;
+    }
+}
+export async function requestSampling(server, messages, maxTokens) {
+    if (!checkSamplingSupport(server)) {
+        throw new Error('Client does not support MCP sampling');
+    }
+    log.debug('sending sampling request', {
+        messageCount: messages.length,
+        maxTokens,
+    });
+    const response = await server.createMessage({
+        messages,
+        maxTokens,
+    });
+    log.debug('sampling response received', {
+        model: response?.model,
+        contentType: response?.content?.type,
+        textLength: response?.content?.text?.length ?? 0,
+    });
+    return response;
+}
+export function extractTextFromSamplingResponse(response) {
+    try {
+        if (!response || typeof response !== 'object')
+            return '';
+        const resp = response;
+        const content = resp.content;
+        if (!content)
+            return '';
+        if (content.type === 'text' && typeof content.text === 'string') {
+            return content.text.trim();
+        }
+        return '';
+    }
+    catch (err) {
+        log.debug('failed to extract text from sampling response', { error: String(err) });
+        return '';
+    }
+}
+//# sourceMappingURL=sampling.js.map

package/dist/search/sampling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.js","sourceRoot":"","sources":["../../src/search/sampling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;AAoBnC,MAAM,UAAU,oBAAoB,CAAC,MAA6B;IAChE,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QACpD,IAAI,CAAC,YAAY;YAAE,OAAO,KAAK,CAAC;QAChC,OAAO,YAAY,CAAC,QAAQ,KAAK,SAAS,CAAC;IAC7C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,KAAK,CAAC,+BAA+B,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAA6B,EAC7B,QAA2B,EAC3B,SAAiB;IAEjB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;IAC1D,CAAC;IAED,GAAG,CAAC,KAAK,CAAC,0BAA0B,EAAE;QACpC,YAAY,EAAE,QAAQ,CAAC,MAAM;QAC7B,SAAS;KACV,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC;QAC1C,QAAQ;QACR,SAAS;KACV,CAAC,CAAC;IAEH,GAAG,CAAC,KAAK,CAAC,4BAA4B,EAAE;QACtC,KAAK,EAAE,QAAQ,EAAE,KAAK;QACtB,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI;QACpC,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;KACjD,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,+BAA+B,CAC7C,QAAiB;IAEjB,IAAI,CAAC;QACH,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ;YAAE,OAAO,EAAE,CAAC;QAEzD,MAAM,IAAI,GAAG,QAAmC,CAAC;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAqD,CAAC;QAC3E,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,CAAC;QAExB,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAChE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC7B,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,KAAK,CAAC,+CAA+C,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACnF,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/server.d.ts

@@ -1,2 +1,19 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SmartRouter } from './fetch/router.js';
+import { MultiBrowserPool } from './fetch/browser-pool.js';
+import { BackendStatus } from './server/backend-status.js';
+import { PluginRegistry } from './plugins/registry.js';
+import type { SearchEngine } from './types.js';
+export interface Subsystems {
+    searchEngines: SearchEngine[];
+    browserPool: MultiBrowserPool;
+    router: SmartRouter;
+    backendStatus: BackendStatus;
+    pluginRegistry: PluginRegistry;
+    shutdown: () => Promise<void>;
+    bootstrapSearxng: () => Promise<void>;
+}
+export declare function initSubsystems(): Promise<Subsystems>;
+export declare function createMcpServer(subsystems: Subsystems): Server;
 export declare function startServer(): Promise<void>;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAsMA,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CA8OjD"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAMnE,OAAO,EAAE,WAAW,EAAmB,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAmB3D,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAK3D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,KAAK,EAA2B,YAAY,EAAqF,MAAM,YAAY,CAAC;AAiV3J,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,WAAW,EAAE,gBAAgB,CAAC;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,UAAU,CAAC,CAqK1D;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAkJ9D;AAED,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBjD"}

package/dist/server.js

@@ -5,7 +5,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { SmartRouter } from './fetch/router.js';
-import { BrowserPool } from './fetch/browser-pool.js';
+import { MultiBrowserPool } from './fetch/browser-pool.js';
 import { httpFetch } from './fetch/http-client.js';
 import { initDatabase, closeDatabase } from './cache/db.js';
 import { handleFetch } from './tools/fetch.js';
@@ -13,6 +13,9 @@ import { handleSearch } from './tools/search.js';
 import { handleCrawl } from './tools/crawl.js';
 import { handleCache } from './tools/cache.js';
 import { handleExtract } from './tools/extract.js';
+import { handleFindSimilar } from './tools/find-similar.js';
+import { handleResearch } from './tools/research.js';
+import { handleAgent } from './tools/agent.js';
 import { SearxngClient } from './search/searxng.js';
 import { DuckDuckGoEngine } from './search/engines/duckduckgo.js';
 import { BingEngine } from './search/engines/bing.js';
@@ -23,6 +26,10 @@ import { DockerSearxng } from './searxng/docker.js';
 import { BackendStatus } from './server/backend-status.js';
 import { getConfig } from './config.js';
 import { createLogger } from './logger.js';
+import { WIGOLO_INSTRUCTIONS, TOOL_DESCRIPTIONS } from './instructions.js';
+import { loadPlugins } from './plugins/loader.js';
+import { PluginRegistry } from './plugins/registry.js';
+import { registerExtractor } from './extraction/pipeline.js';
 const log = createLogger('server');
 function readPackageVersion() {
     try {
@@ -71,13 +78,64 @@ const FETCH_TOOL_SCHEMA = {
             description: 'Additional HTTP headers',
             additionalProperties: { type: 'string' },
         },
+        actions: {
+            type: 'array',
+            description: 'Sequential browser actions to perform before extracting content. ' +
+                'When present, forces Playwright rendering (bypasses HTTP-first routing).',
+            items: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['click', 'type', 'wait', 'wait_for', 'scroll', 'screenshot'],
+                        description: 'Action type',
+                    },
+                    selector: {
+                        type: 'string',
+                        description: 'CSS selector (required for click, type, wait_for)',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Text to type (required for type action)',
+                    },
+                    ms: {
+                        type: 'number',
+                        description: 'Milliseconds to wait (required for wait action)',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in ms for wait_for action (default: 5000)',
+                    },
+                    direction: {
+                        type: 'string',
+                        enum: ['down', 'up'],
+                        description: 'Scroll direction (required for scroll action)',
+                    },
+                    amount: {
+                        type: 'number',
+                        description: 'Scroll amount in pixels (default: viewport height)',
+                    },
+                },
+                required: ['type'],
+            },
+        },
     },
     required: ['url'],
 };
 const SEARCH_TOOL_SCHEMA = {
     type: 'object',
     properties: {
-        query: { type: 'string', description: 'Search query' },
+        query: {
+            oneOf: [
+                { type: 'string', description: 'Search query' },
+                {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of query variants to search in parallel, deduplicate, and rerank',
+                },
+            ],
+            description: 'Search query — a single string or array of query variants for parallel multi-query search',
+        },
         max_results: { type: 'number', description: 'Max results to return (default 5, max 20)' },
         include_content: { type: 'boolean', description: 'Fetch full content for results (default true)' },
         content_max_chars: { type: 'number', description: 'Max chars per result content (default 30000)' },
@@ -108,6 +166,11 @@ const SEARCH_TOOL_SCHEMA = {
             enum: ['general', 'news', 'code', 'docs', 'papers', 'images'],
             description: 'Category of search (general, news, code, docs, papers, images)',
         },
+        format: {
+            type: 'string',
+            enum: ['full', 'context', 'answer', 'stream_answer'],
+            description: "Output format: 'full' returns structured results (default), 'context' returns a single token-budgeted string for LLM injection, 'answer' synthesizes a direct answer with citations via MCP sampling, 'stream_answer' same as answer with streaming flag",
+        },
     },
     required: ['query'],
 };
@@ -158,6 +221,12 @@ const CACHE_TOOL_SCHEMA = {
             type: 'boolean',
             description: 'Return cache statistics (total URLs, size, date range)',
         },
+        check_changes: {
+            type: 'boolean',
+            description: 'Re-fetch all matching cached URLs and report which ones have changed. ' +
+                'Returns a list of URLs with changed/unchanged status and diff summaries. ' +
+                'Use with query or url_pattern to scope which cached entries to check.',
+        },
     },
 };
 const EXTRACT_TOOL_SCHEMA = {
@@ -184,123 +253,161 @@ const EXTRACT_TOOL_SCHEMA = {
         },
     },
 };
-export async function startServer() {
+const FIND_SIMILAR_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        url: {
+            type: 'string',
+            description: 'Find pages similar to this URL. The page is fetched (or read from cache) and its content analyzed for key terms.',
+        },
+        concept: {
+            type: 'string',
+            description: 'Find pages related to this concept or topic description. Use when you don\'t have a specific URL.',
+        },
+        max_results: {
+            type: 'number',
+            description: 'Maximum results to return (default 10, max 50)',
+        },
+        include_domains: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Only return results from these domains',
+        },
+        exclude_domains: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Never return results from these domains',
+        },
+        include_cache: {
+            type: 'boolean',
+            description: 'Search local cache for similar pages (default: true)',
+        },
+        include_web: {
+            type: 'boolean',
+            description: 'Supplement with web search if needed (default: true)',
+        },
+    },
+};
+const RESEARCH_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        question: { type: 'string', description: 'The research question to investigate' },
+        depth: {
+            type: 'string',
+            enum: ['quick', 'standard', 'comprehensive'],
+            description: 'Research depth: quick (~15s), standard (~40s, default), comprehensive (~80s)',
+        },
+        max_sources: {
+            type: 'number',
+            description: 'Override the default source count for the chosen depth (max 50)',
+        },
+        include_domains: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Only search results from these domains',
+        },
+        exclude_domains: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Exclude results from these domains',
+        },
+        schema: {
+            type: 'object',
+            description: 'Optional JSON Schema -- structure the report to extract these fields',
+        },
+        stream: {
+            type: 'boolean',
+            description: 'Send progress notifications as each research phase completes',
+        },
+    },
+    required: ['question'],
+};
+const AGENT_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        prompt: {
+            type: 'string',
+            description: 'Natural-language description of what data to gather',
+        },
+        urls: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Specific URLs to include in the data gathering',
+        },
+        schema: {
+            type: 'object',
+            description: 'Optional JSON Schema -- extract structured data matching this schema from each page',
+        },
+        max_pages: {
+            type: 'number',
+            description: 'Maximum pages to fetch (default 10, max 100)',
+        },
+        max_time_ms: {
+            type: 'number',
+            description: 'Maximum execution time in milliseconds (default 60000)',
+        },
+        stream: {
+            type: 'boolean',
+            description: 'Send progress notifications as each step completes',
+        },
+    },
+    required: ['prompt'],
+};
+export async function initSubsystems() {
     const config = getConfig();
     mkdirSync(config.dataDir, { recursive: true });
     initDatabase(join(config.dataDir, 'wigolo.db'));
     const httpClient = {
         fetch: (url, options) => httpFetch(url, options),
     };
-    const browserPool = new BrowserPool();
+    const browserPool = new MultiBrowserPool({
+        browserTypes: config.browserTypes,
+        selectionStrategy: 'round-robin',
+    });
     const router = new SmartRouter(httpClient, browserPool);
+    if (config.lightpandaEnabled && config.lightpandaUrl) {
+        log.info('lightpanda browser backend enabled', {
+            url: config.lightpandaUrl,
+            failureThreshold: config.lightpandaFailureThreshold,
+        });
+    }
     const backendStatus = new BackendStatus();
-    // Direct scraping engines work without any bootstrap — always available so
-    // search() succeeds immediately even before SearXNG finishes setup.
     const searchEngines = [
         new BingEngine(),
         new DuckDuckGoEngine(),
         new StartpageEngine(),
     ];
-    let searxngProcess = null;
-    let dockerSearxng = null;
-    const server = new Server({ name: 'wigolo', version: SERVER_VERSION }, { capabilities: { tools: {} } });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [
-            {
-                name: 'fetch',
-                description: 'Fetch a web page and return its content as clean markdown. ' +
-                    'Supports JavaScript rendering, auth, section extraction, and caching.',
-                inputSchema: FETCH_TOOL_SCHEMA,
-            },
-            {
-                name: 'search',
-                description: 'Search the web and return results with optional full content extraction. ' +
-                    'One call: query in, clean markdown out.',
-                inputSchema: SEARCH_TOOL_SCHEMA,
-            },
-            {
-                name: 'crawl',
-                description: 'Crawl a website starting from a seed URL. Supports BFS, DFS, and sitemap strategies ' +
-                    'with depth/page limits, URL filtering, and cross-page content deduplication.',
-                inputSchema: CRAWL_TOOL_SCHEMA,
-            },
-            {
-                name: 'cache',
-                description: 'Query the local knowledge base of previously fetched content. ' +
-                    'Search cached pages by full-text query, URL pattern, or date. ' +
-                    'Can also return cache statistics or clear entries.',
-                inputSchema: CACHE_TOOL_SCHEMA,
-            },
-            {
-                name: 'extract',
-                description: 'Extract structured data from a web page. Supports CSS selector extraction, ' +
-                    'table-to-JSON conversion, metadata extraction (title, author, date, JSON-LD), ' +
-                    'and schema-based extraction (provide a JSON Schema to heuristically extract matching fields).',
-                inputSchema: EXTRACT_TOOL_SCHEMA,
-            },
-        ],
-    }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        if (name === 'fetch') {
-            const input = (args ?? {});
-            const result = await handleFetch(input, router);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                isError: !!result.error,
-            };
+    // Load plugins from ~/.wigolo/plugins/
+    const pluginRegistry = new PluginRegistry();
+    try {
+        const pluginResult = await loadPlugins();
+        for (const ext of pluginResult.extractors) {
+            pluginRegistry.registerExtractor(ext, ext.name);
+            registerExtractor(ext);
         }
-        if (name === 'search') {
-            const input = (args ?? {});
-            const result = await handleSearch(input, searchEngines, router, backendStatus);
-            const blocks = [];
-            if (result.warning) {
-                blocks.push({ type: 'text', text: `[wigolo notice] ${result.warning}` });
-            }
-            blocks.push({ type: 'text', text: JSON.stringify(result, null, 2) });
-            return {
-                content: blocks,
-                isError: !!result.error,
-            };
+        for (const eng of pluginResult.searchEngines) {
+            pluginRegistry.registerSearchEngine(eng, eng.name);
+            searchEngines.push(eng);
         }
-        if (name === 'crawl') {
-            const input = (args ?? {});
-            const result = await handleCrawl(input, router);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                isError: !!result.error,
-            };
+        if (pluginResult.errors.length > 0) {
+            log.warn('some plugins failed to load', {
+                errors: pluginResult.errors.map(e => `${e.pluginName}: ${e.message}`),
+            });
         }
-        if (name === 'cache') {
-            const input = (args ?? {});
-            const result = handleCache(input);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                isError: !!result.error,
-            };
+        if (pluginResult.loaded.length > 0) {
+            log.info('plugins loaded', {
+                count: pluginResult.loaded.length,
+                names: pluginResult.loaded.map(p => p.name),
+            });
         }
-        if (name === 'extract') {
-            const input = (args ?? {});
-            const result = await handleExtract(input, router);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                isError: !!result.error,
-            };
-        }
-        return {
-            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-            isError: true,
-        };
-    });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    log.info('MCP server started');
-    // Bootstrap SearXNG in the background. The MCP server is already responding
-    // to initialize/tools/list/tools/call. search() falls back to direct engines
-    // until SearXNG becomes available, at which point it is unshifted to the
-    // front of the engine list and used preferentially on subsequent calls.
+    }
+    catch (err) {
+        log.error('plugin loading failed', { error: String(err) });
+    }
+    let searxngProcess = null;
+    let dockerSearxng = null;
     let searxngBootstrap = null;
-    searxngBootstrap = (async () => {
+    async function bootstrapSearxng() {
         try {
             const backend = await resolveSearchBackend();
             if (backend.type === 'external' && backend.url) {
@@ -379,12 +486,10 @@ export async function startServer() {
             log.warn('background backend setup failed', { error: String(err) });
             backendStatus.markUnhealthy(`backend setup failed: ${String(err)}`);
         }
-    })();
-    const shutdown = async () => {
+    }
+    async function shutdown() {
         log.info('Shutting down');
         if (searxngBootstrap) {
-            // Let an in-flight bootstrap settle so we don't kill venv/pip mid-install
-            // and corrupt ~/.wigolo/searxng. Bounded so we don't hang forever.
             await Promise.race([
                 searxngBootstrap.catch(() => { }),
                 new Promise((r) => setTimeout(r, 2000)),
@@ -396,6 +501,162 @@ export async function startServer() {
             await dockerSearxng.stop();
         await browserPool.shutdown();
         closeDatabase();
+    }
+    return {
+        searchEngines,
+        browserPool,
+        router,
+        backendStatus,
+        pluginRegistry,
+        shutdown,
+        bootstrapSearxng: () => {
+            searxngBootstrap = bootstrapSearxng();
+            return searxngBootstrap;
+        },
+    };
+}
+export function createMcpServer(subsystems) {
+    const { searchEngines, router, backendStatus } = subsystems;
+    const server = new Server({ name: 'wigolo', version: SERVER_VERSION }, {
+        capabilities: { tools: {} },
+        instructions: WIGOLO_INSTRUCTIONS,
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'fetch',
+                description: TOOL_DESCRIPTIONS.fetch,
+                inputSchema: FETCH_TOOL_SCHEMA,
+            },
+            {
+                name: 'search',
+                description: TOOL_DESCRIPTIONS.search,
+                inputSchema: SEARCH_TOOL_SCHEMA,
+            },
+            {
+                name: 'crawl',
+                description: TOOL_DESCRIPTIONS.crawl,
+                inputSchema: CRAWL_TOOL_SCHEMA,
+            },
+            {
+                name: 'cache',
+                description: TOOL_DESCRIPTIONS.cache,
+                inputSchema: CACHE_TOOL_SCHEMA,
+            },
+            {
+                name: 'extract',
+                description: TOOL_DESCRIPTIONS.extract,
+                inputSchema: EXTRACT_TOOL_SCHEMA,
+            },
+            {
+                name: 'find_similar',
+                description: TOOL_DESCRIPTIONS.find_similar,
+                inputSchema: FIND_SIMILAR_TOOL_SCHEMA,
+            },
+            {
+                name: 'research',
+                description: TOOL_DESCRIPTIONS.research,
+                inputSchema: RESEARCH_TOOL_SCHEMA,
+            },
+            {
+                name: 'agent',
+                description: TOOL_DESCRIPTIONS.agent,
+                inputSchema: AGENT_TOOL_SCHEMA,
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name === 'fetch') {
+            const input = (args ?? {});
+            const result = await handleFetch(input, router);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'search') {
+            const input = (args ?? {});
+            const samplingServer = server;
+            const result = await handleSearch(input, searchEngines, router, backendStatus, samplingServer);
+            const blocks = [];
+            if (result.warning) {
+                blocks.push({ type: 'text', text: `[wigolo notice] ${result.warning}` });
+            }
+            blocks.push({ type: 'text', text: JSON.stringify(result, null, 2) });
+            return {
+                content: blocks,
+                isError: !!result.error,
+            };
+        }
+        if (name === 'crawl') {
+            const input = (args ?? {});
+            const result = await handleCrawl(input, router);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'cache') {
+            const input = (args ?? {});
+            const result = await handleCache(input, router);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'extract') {
+            const input = (args ?? {});
+            const result = await handleExtract(input, router);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'find_similar') {
+            const input = (args ?? {});
+            const result = await handleFindSimilar(input, searchEngines, router, backendStatus);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'research') {
+            const input = (args ?? {});
+            const samplingServer = server;
+            const result = await handleResearch(input, searchEngines, router, backendStatus, samplingServer);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        if (name === 'agent') {
+            const input = (args ?? {});
+            const samplingServer = server;
+            const result = await handleAgent(input, searchEngines, router, backendStatus, samplingServer);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                isError: !!result.error,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+            isError: true,
+        };
+    });
+    return server;
+}
+export async function startServer() {
+    const subs = await initSubsystems();
+    const server = createMcpServer(subs);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log.info('MCP server started');
+    subs.bootstrapSearxng().catch((err) => {
+        log.warn('SearXNG bootstrap failed', { error: String(err) });
+    });
+    const shutdown = async () => {
+        await subs.shutdown();
         await server.close();
         process.exit(0);
     };