agent-search-mcp 2.1.0

package/dist/aggregation/scorer.js

@@ -0,0 +1,110 @@
+/**
+ * Enhanced scoring with token-based ranking and weighted confidence.
+ * From ddgs SimpleFilterRanker: classify results into buckets.
+ */
+export function scoreAndRank(results, query, weights = {}, frequencies) {
+    const tokens = query.toLowerCase().split(/\W+/).filter(t => t.length >= 3);
+    // Calculate max possible weight for normalization
+    const maxWeightSum = Math.max(...Object.values(weights), 0.5) * Math.max(tokens.length, 1);
+    return results
+        .map(r => {
+        const normalizedUrl = normalizeUrl(r.url);
+        const freq = frequencies?.get(normalizedUrl) || 1;
+        return {
+            ...r,
+            confidence: calculateWeightedConfidence(r, weights, maxWeightSum),
+            score: calculateScore(r, tokens, weights, freq),
+        };
+    })
+        .sort((a, b) => {
+        // 1. Primary: confidence (weighted quality signal)
+        if (b.confidence !== a.confidence)
+            return b.confidence - a.confidence;
+        // 2. Secondary: score
+        return b.score - a.score;
+    });
+}
+/**
+ * Calculate weighted confidence score (0-1) based on engine weights.
+ * Instead of raw engine count, uses sum of weights / max possible weight.
+ *
+ * Example: Brave (0.95) + Exa (0.92) = (0.95+0.92)/max_possible
+ *          vs Sogou (0.80) + Baidu (0.75) = (0.80+0.75)/max_possible
+ * The first pair gets higher confidence.
+ */
+function calculateWeightedConfidence(result, weights, maxWeightSum) {
+    const engines = result.engines || [];
+    if (engines.length === 0) {
+        // No engine info, use source weight as fallback
+        const sourceWeight = weights[result.source] || 0.5;
+        return sourceWeight * 0.5; // Lower confidence for unknown source
+    }
+    // Sum weights for engines that returned this result
+    const weightSum = engines.reduce((sum, engine) => {
+        return sum + (weights[engine] || 0.5);
+    }, 0);
+    // Normalize: divide by max possible weight sum (considering count)
+    const normalizedConfidence = Math.min(weightSum / (maxWeightSum * engines.length), 1.0);
+    // Apply count bonus (more engines still matters, but with diminishing returns)
+    const countBonus = Math.min(engines.length * 0.1, 0.3);
+    return Math.min(normalizedConfidence + countBonus, 1.0);
+}
+function normalizeUrl(url) {
+    try {
+        const u = new URL(url);
+        return `${u.hostname}${u.pathname.replace(/\/$/, '')}`.toLowerCase();
+    }
+    catch {
+        return url.toLowerCase();
+    }
+}
+/**
+ * Token-based scoring inspired by ddgs SimpleFilterRanker.
+ *
+ * Buckets:
+ * - Wikipedia boost: +0.15
+ * - Both title+body match: +0.4
+ * - Title only match: +0.3
+ * - Body only match: +0.2
+ * - Neither: 0
+ *
+ * Then multiply by frequency bonus and engine weight.
+ */
+function calculateScore(result, tokens, weights, frequency) {
+    if (tokens.length === 0)
+        return 0.3;
+    const titleLower = result.title.toLowerCase();
+    const bodyLower = (result.snippet || '').toLowerCase();
+    // Count token matches
+    const titleMatches = tokens.filter(t => titleLower.includes(t)).length;
+    const bodyMatches = tokens.filter(t => bodyLower.includes(t)).length;
+    // Bucket classification
+    let bucketScore = 0;
+    const hasTitle = titleMatches > 0;
+    const hasBody = bodyMatches > 0;
+    if (hasTitle && hasBody) {
+        bucketScore = 0.4; // Both match
+    }
+    else if (hasTitle) {
+        bucketScore = 0.3; // Title only
+    }
+    else if (hasBody) {
+        bucketScore = 0.2; // Body only
+    }
+    // Wikipedia boost
+    if (result.url.includes('wikipedia.org')) {
+        bucketScore += 0.15;
+    }
+    // GitHub boost (high quality for code queries)
+    if (result.url.includes('github.com')) {
+        bucketScore += 0.05;
+    }
+    // Frequency bonus (from ddgs: more engines = more trustworthy)
+    const freqBonus = Math.min(frequency * 0.1, 0.3); // Cap at 0.3
+    // Engine weight
+    const maxWeight = Math.max(...(result.engines || [result.source]).map(e => weights[e] || 0.5));
+    // Final score: base + bucket + frequency, then apply weight
+    let score = 0.1 + bucketScore + freqBonus;
+    score *= maxWeight;
+    return Math.min(score, 1.0);
+}

package/dist/cli.js

@@ -0,0 +1,169 @@
+import { searchWithFallback } from './tools/free-search.js';
+import { createHttpServer } from './infrastructure/http.js';
+import { loadConfig } from './infrastructure/config.js';
+const VALID_COMMANDS = ['search', 'extract', 'serve'];
+const VALID_ENGINES = ['duckduckgo', 'sogou', 'bing', 'baidu', 'brave', 'tavily', 'exa'];
+export function parseArgs(argv) {
+    const args = argv.slice(2); // skip node and script path
+    const result = { command: 'search' };
+    if (args.length === 0 || args.includes('--help')) {
+        result.help = true;
+        return result;
+    }
+    if (args.includes('--version')) {
+        result.version = true;
+        return result;
+    }
+    let i = 0;
+    // First arg is command or query
+    const first = args[0];
+    if (VALID_COMMANDS.includes(first)) {
+        result.command = first;
+        i = 1;
+    }
+    else {
+        // Default to search, first arg is query
+        result.command = 'search';
+    }
+    // Parse remaining args
+    for (; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--count' && args[i + 1]) {
+            result.count = parseInt(args[++i], 10);
+        }
+        else if (arg === '--engines' && args[i + 1]) {
+            const engineList = args[++i].split(',');
+            result.engines = engineList.filter((e) => VALID_ENGINES.includes(e));
+        }
+        else if (arg === '--port' && args[i + 1]) {
+            result.port = parseInt(args[++i], 10);
+        }
+        else if (arg === '--json') {
+            result.json = true;
+        }
+        else if (arg === '--proxy' && args[i + 1]) {
+            result.proxy = args[++i];
+        }
+        else if (!arg.startsWith('--')) {
+            // Positional arg
+            if (result.command === 'search' && !result.query) {
+                result.query = arg;
+            }
+            else if (result.command === 'extract' && !result.url) {
+                result.url = arg;
+            }
+        }
+    }
+    return result;
+}
+function showHelp() {
+    console.log(`
+free-agent-search-mcp CLI v2.1.0
+
+Usage:
+  fasm search <query> [options]    Search the web
+  fasm extract <url> [options]     Extract page content
+  fasm serve [options]             Start HTTP server
+  fasm --help                      Show this help
+  fasm --version                   Show version
+
+Search Options:
+  --count <n>          Number of results (1-50, default: 10)
+  --engines <list>     Comma-separated engines (duckduckgo,sogou,bing,baidu,brave,tavily,exa)
+  --json               Output as JSON
+  --proxy <url>        HTTP proxy URL (e.g., http://127.0.0.1:7890)
+
+Extract Options:
+  --json               Output as JSON
+  --proxy <url>        HTTP proxy URL
+
+Serve Options:
+  --port <n>           HTTP port (default: 3000)
+
+Examples:
+  fasm search "TypeScript MCP server"
+  fasm search "query" --count 5 --engines bing,baidu
+  fasm extract "https://example.com" --json
+  fasm serve --port 8080
+  fasm search "query" --proxy http://127.0.0.1:7890
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv);
+    if (args.help) {
+        showHelp();
+        process.exit(0);
+    }
+    if (args.version) {
+        console.log('free-agent-search-mcp v2.1.0');
+        process.exit(0);
+    }
+    // Set proxy if provided
+    if (args.proxy) {
+        process.env.HTTP_PROXY = args.proxy;
+        process.env.HTTPS_PROXY = args.proxy;
+    }
+    if (args.command === 'search') {
+        if (!args.query) {
+            console.error('Error: search command requires a query');
+            process.exit(1);
+        }
+        const results = await searchWithFallback({
+            query: args.query,
+            count: args.count || 10,
+            engines: args.engines || ['duckduckgo', 'sogou'],
+        });
+        if (args.json) {
+            console.log(JSON.stringify(results, null, 2));
+        }
+        else {
+            console.log(`\nSearch: "${results.query}"`);
+            console.log(`Engines: ${results.engines.join(', ')}`);
+            console.log(`Results: ${results.meta.total}\n`);
+            for (const r of results.results) {
+                console.log(`  ${r.title}`);
+                console.log(`  ${r.url}`);
+                console.log(`  ${r.snippet}`);
+                console.log();
+            }
+        }
+    }
+    else if (args.command === 'extract') {
+        if (!args.url) {
+            console.error('Error: extract command requires a URL');
+            process.exit(1);
+        }
+        const res = await fetch(`https://r.jina.ai/${args.url}`, {
+            headers: { 'Accept': 'text/markdown' },
+            signal: AbortSignal.timeout(10000),
+        });
+        const content = await res.text();
+        if (args.json) {
+            console.log(JSON.stringify({ url: args.url, content }, null, 2));
+        }
+        else {
+            console.log(content);
+        }
+    }
+    else if (args.command === 'serve') {
+        const config = loadConfig();
+        const port = args.port || config.port;
+        const server = createHttpServer({
+            port,
+            enableCors: config.enableCors,
+            corsOrigin: config.corsOrigin,
+        });
+        await server.listen();
+        console.log(`Server running on http://localhost:${port}`);
+        console.log('Press Ctrl+C to stop');
+    }
+}
+// Run main only when executed directly (not when imported)
+const isMainModule = process.argv[1] && (process.argv[1].endsWith('/cli.js') ||
+    process.argv[1].endsWith('/cli.ts'));
+if (isMainModule) {
+    main().catch((error) => {
+        console.error('Error:', error.message);
+        process.exit(1);
+    });
+}

package/dist/engines/baidu.js

@@ -0,0 +1,56 @@
+import { decodeHTMLTags } from '../infrastructure/html-utils.js';
+export const baiduProvider = {
+    id: 'baidu',
+    name: 'Baidu',
+    isFree: true,
+    languages: ['zh'],
+};
+export async function searchBaidu(query, limit = 10) {
+    try {
+        const url = `https://www.baidu.com/s?wd=${encodeURIComponent(query)}&rn=${limit}`;
+        const res = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml',
+                'Accept-Language': 'zh-CN,zh;q=0.9',
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok) {
+            console.error(`Baidu: HTTP ${res.status}`);
+            return [];
+        }
+        const html = await res.text();
+        return parseBaiduResults(html, limit);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('timeout')) {
+            console.error('Baidu: Search timed out');
+        }
+        else {
+            console.error('Baidu search failed:', msg.slice(0, 200));
+        }
+        return [];
+    }
+}
+function parseBaiduResults(html, limit) {
+    const results = [];
+    // Fallback: use simpler h3 > a pattern (more robust)
+    const simpleRegex = /<h3[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a><\/h3>/g;
+    let match;
+    while ((match = simpleRegex.exec(html)) && results.length < limit) {
+        const url = match[1];
+        const title = decodeHTMLTags(match[2]);
+        if (url && title && !url.includes('baidu.com')) {
+            results.push({
+                title,
+                url,
+                snippet: '',
+                source: 'baidu',
+                engines: ['baidu'],
+            });
+        }
+    }
+    return results;
+}

package/dist/engines/bing.js

@@ -0,0 +1,58 @@
+import { decodeHTMLTags } from '../infrastructure/html-utils.js';
+export const bingProvider = {
+    id: 'bing',
+    name: 'Bing',
+    isFree: true,
+    languages: ['en', 'zh'],
+};
+export async function searchBing(query, limit = 10) {
+    try {
+        const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}&count=${limit}`;
+        const res = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml',
+                'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8',
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok) {
+            console.error(`Bing: HTTP ${res.status}`);
+            return [];
+        }
+        const html = await res.text();
+        return parseBingResults(html, limit);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('timeout')) {
+            console.error('Bing: Search timed out');
+        }
+        else {
+            console.error('Bing search failed:', msg.slice(0, 200));
+        }
+        return [];
+    }
+}
+function parseBingResults(html, limit) {
+    const results = [];
+    // Parse Bing HTML results
+    // Pattern: <li class="b_algo"><h2><a href="URL">TITLE</a></h2><p>SNIPPET</p></li>
+    const resultRegex = /<li class="b_algo">[\s\S]*?<h2><a href="([^"]+)"[^>]*>([\s\S]*?)<\/a><\/h2>[\s\S]*?<p[^>]*>([\s\S]*?)<\/p>/g;
+    let match;
+    while ((match = resultRegex.exec(html)) && results.length < limit) {
+        const url = match[1];
+        const title = decodeHTMLTags(match[2]);
+        const snippet = decodeHTMLTags(match[3]);
+        if (url && title) {
+            results.push({
+                title,
+                url,
+                snippet: snippet || '',
+                source: 'bing',
+                engines: ['bing'],
+            });
+        }
+    }
+    return results;
+}

package/dist/engines/brave.js

@@ -0,0 +1,33 @@
+export class BraveProvider {
+    id = 'brave';
+    name = 'Brave Search';
+    isFree = false;
+    languages = ['en', 'zh'];
+    async search(query, count) {
+        const apiKey = process.env.BRAVE_API_KEY;
+        if (!apiKey)
+            return [];
+        const url = new URL('https://api.search.brave.com/res/v1/web/search');
+        url.searchParams.set('q', query);
+        url.searchParams.set('count', String(count));
+        const res = await fetch(url.toString(), {
+            headers: {
+                'Accept': 'application/json',
+                'Accept-Encoding': 'gzip',
+                'X-Subscription-Token': apiKey,
+            },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            throw new Error(`Brave returned ${res.status}`);
+        const data = await res.json();
+        return (data.web?.results || []).map((r) => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.description || '',
+            source: 'brave',
+            engines: ['brave'],
+        }));
+    }
+}
+export const braveProvider = new BraveProvider();

package/dist/engines/duckduckgo.js

@@ -0,0 +1,47 @@
+import { execFileSync } from 'child_process';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const SCRIPT_PATH = resolve(__dirname, '../../scripts/ddg-search.py');
+export const duckduckgoProvider = {
+    id: 'duckduckgo',
+    name: 'DuckDuckGo',
+    isFree: true,
+    languages: ['en'],
+};
+/**
+ * Search DuckDuckGo using ddgs Python library (bypasses anti-bot).
+ * Falls back to empty array if Python/ddgs not available.
+ */
+export async function searchDuckDuckGo(query, limit = 10) {
+    try {
+        // Use execFileSync to avoid shell injection (query passed as argument, not shell-interpolated)
+        const output = execFileSync('/usr/bin/python3', [SCRIPT_PATH, query, String(limit)], {
+            timeout: 15000, // 15s timeout
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const results = JSON.parse(output.trim());
+        return results.map((r) => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.snippet || '',
+            source: r.source || 'duckduckgo',
+            engines: ['duckduckgo'],
+        }));
+    }
+    catch (error) {
+        // Python/ddgs not available or timed out
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('ENOENT') || msg.includes('python3')) {
+            console.error('DDG: Python3 not found, skipping');
+        }
+        else if (msg.includes('timeout')) {
+            console.error('DDG: Search timed out');
+        }
+        else {
+            console.error('DDG search failed:', msg.slice(0, 200));
+        }
+        return [];
+    }
+}

package/dist/engines/exa.js

@@ -0,0 +1,46 @@
+export const exaProvider = {
+    id: 'exa',
+    name: 'Exa Search',
+    isFree: false,
+    languages: ['en', 'zh'],
+};
+export async function searchExa(options) {
+    const { query, count = 10, apiKey } = options;
+    if (!apiKey) {
+        console.warn('Exa: No API key provided');
+        return [];
+    }
+    try {
+        const response = await fetch('https://api.exa.ai/search', {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                query,
+                numResults: count,
+                contents: {
+                    highlights: true,
+                },
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) {
+            console.error(`Exa: HTTP ${response.status}`);
+            return [];
+        }
+        const data = await response.json();
+        return data.results.map((result) => ({
+            title: result.title,
+            url: result.url,
+            snippet: result.highlights?.[0] || result.text?.substring(0, 200) || '',
+            source: `Exa${result.author ? ` (${result.author})` : ''}`,
+            engines: ['exa'],
+        }));
+    }
+    catch (error) {
+        console.error('Exa search failed:', error);
+        return [];
+    }
+}

package/dist/engines/index.js

@@ -0,0 +1,25 @@
+export { searchDuckDuckGo, duckduckgoProvider } from './duckduckgo.js';
+export { searchSogou, sogouProvider } from './sogou.js';
+export { searchBing, bingProvider } from './bing.js';
+export { searchBaidu, baiduProvider } from './baidu.js';
+export { braveProvider } from './brave.js';
+export { tavilyProvider } from './tavily.js';
+export { searchExa, exaProvider } from './exa.js';
+/**
+ * All registered engine providers with metadata.
+ * Free engines: DDG, Sogou, Bing, Baidu
+ * Paid engines: Brave, Tavily, Exa (require API keys)
+ */
+export const engines = {
+    duckduckgo: { id: 'duckduckgo', name: 'DuckDuckGo', isFree: true, languages: ['en'] },
+    sogou: { id: 'sogou', name: 'Sogou Search', isFree: true, languages: ['zh'] },
+    bing: { id: 'bing', name: 'Bing', isFree: true, languages: ['en', 'zh'] },
+    baidu: { id: 'baidu', name: 'Baidu', isFree: true, languages: ['zh'] },
+    brave: { id: 'brave', name: 'Brave Search', isFree: false, languages: ['en', 'zh'] },
+    tavily: { id: 'tavily', name: 'Tavily Search', isFree: false, languages: ['en', 'zh'] },
+    exa: { id: 'exa', name: 'Exa Search', isFree: false, languages: ['en', 'zh'] },
+};
+/** Free engines that always work without API keys */
+export const freeEngines = ['duckduckgo', 'sogou', 'bing', 'baidu'];
+/** Paid engines that require API keys */
+export const paidEngines = ['brave', 'tavily', 'exa'];

package/dist/engines/sogou.js

@@ -0,0 +1,132 @@
+const SOGOU_SEARCH_URL = 'https://www.sogou.com/web';
+const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+/**
+ * Parse Sogou search results HTML using regex
+ */
+function parseSogouHtml(html) {
+    const results = [];
+    const seenUrls = new Set();
+    // Try to find result blocks
+    // Sogou typically has: <div class="vrwrap"> or <div class="rb"> containing the results
+    const blockRegex = /<div[^>]*(?:class="[^"]*vr(?:wrap|5)[^"]*"|class="[^"]*\brb\b[^"]*"|id="[^"]*result[^"]*")[^>]*>([\s\S]*?)<\/div>\s*<\/div>/gis;
+    let blockMatch;
+    while ((blockMatch = blockRegex.exec(html)) !== null) {
+        const block = blockMatch[1];
+        // Extract title link (h3 or h2 containing a link)
+        const titleLinkRegex = /<h[23][^>]*>.*?<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i;
+        const titleMatch = block.match(titleLinkRegex);
+        if (!titleMatch)
+            continue;
+        const rawUrl = titleMatch[1]?.trim() || '';
+        const title = titleMatch[2]?.replace(/<[^>]+>/g, '').trim() || '';
+        if (!title || !rawUrl)
+            continue;
+        // Resolve the actual URL (Sogou wraps URLs in redirects)
+        let url = rawUrl;
+        try {
+            const parsed = new URL(rawUrl, SOGOU_SEARCH_URL);
+            const target = parsed.searchParams.get('url') || parsed.searchParams.get('u') || parsed.searchParams.get('link');
+            if (target && /^https?:\/\//i.test(target)) {
+                url = target;
+            }
+            else {
+                url = parsed.toString();
+            }
+        }
+        catch {
+            // keep rawUrl
+        }
+        if (seenUrls.has(url))
+            continue;
+        seenUrls.add(url);
+        // Extract snippet
+        const descMatch = block.match(/<p[^>]*class="[^"]*str_info[^"]*"[^>]*>([\s\S]*?)<\/p>/i)
+            || block.match(/<div[^>]*class="[^"]*str_info[^"]*"[^>]*>([\s\S]*?)<\/div>/i)
+            || block.match(/class="[^"]*(?:str_info|ft|text-layout)[^"]*"[^>]*>([\s\S]*?)<\//i);
+        const snippet = descMatch?.[1]?.replace(/<[^>]+>/g, '').trim() || '';
+        // Extract source
+        const srcMatch = block.match(/<cite[^>]*>([\s\S]*?)<\/cite>/i)
+            || block.match(/class="[^"]*(?:citeurl|g|url)[^"]*"[^>]*>([\s\S]*?)<\//i);
+        let source = srcMatch?.[1]?.replace(/<[^>]+>/g, '').trim() || '';
+        if (!source) {
+            try {
+                source = new URL(url).hostname;
+            }
+            catch {
+                source = '';
+            }
+        }
+        results.push({ title, url, snippet, source, engines: ['sogou'] });
+    }
+    // Fallback: broader extraction for different page layouts
+    if (results.length === 0) {
+        const altBlockRegex = /<div[^>]*class="[^"]*vrwrap[^"]*"[^>]*>([\s\S]*?)<\/div>\s*<\/div>/gis;
+        let altBlockMatch;
+        while ((altBlockMatch = altBlockRegex.exec(html)) !== null) {
+            const block = altBlockMatch[1];
+            const aMatch = block.match(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/i);
+            if (!aMatch)
+                continue;
+            const rawUrl = aMatch[1]?.trim() || '';
+            const title = aMatch[2]?.replace(/<[^>]+>/g, '').trim() || '';
+            if (!title || !rawUrl || seenUrls.has(rawUrl))
+                continue;
+            seenUrls.add(rawUrl);
+            let url = rawUrl;
+            try {
+                const parsed = new URL(rawUrl, SOGOU_SEARCH_URL);
+                const target = parsed.searchParams.get('url') || parsed.searchParams.get('u');
+                if (target && /^https?:\/\//i.test(target))
+                    url = target;
+            }
+            catch { /* keep rawUrl */ }
+            const descMatch = block.match(/(?:str_info|ft)[^>]*>([\s\S]*?)<\//i);
+            const snippet = descMatch?.[1]?.replace(/<[^>]+>/g, '').trim() || '';
+            let source = '';
+            try {
+                source = new URL(url).hostname;
+            }
+            catch { /* ignore */ }
+            results.push({ title, url, snippet, source, engines: ['sogou'] });
+        }
+    }
+    return results;
+}
+export const sogouProvider = {
+    id: 'sogou',
+    name: 'Sogou Search',
+    isFree: true,
+    languages: ['zh'],
+};
+export async function searchSogou(query, limit = 10) {
+    try {
+        const url = new URL(SOGOU_SEARCH_URL);
+        url.searchParams.set('query', query);
+        url.searchParams.set('ie', 'utf8');
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+                'Referer': 'https://www.sogou.com/',
+            },
+            redirect: 'follow',
+        });
+        if (!response.ok) {
+            throw new Error(`Sogou returned status ${response.status}`);
+        }
+        const html = await response.text();
+        // Check for anti-bot page
+        if (html.toLowerCase().includes('antispider') || html.includes('请输入验证码') || html.includes('访问过于频繁')) {
+            console.warn('Sogou returned an anti-bot challenge page');
+            return [];
+        }
+        const results = parseSogouHtml(html);
+        return results.slice(0, limit);
+    }
+    catch (error) {
+        console.error('Sogou search failed:', error instanceof Error ? error.message : String(error));
+        return [];
+    }
+}