]*>([\s\S]*?)<\/div>/gi;
+ let m;
+ while ((m = cardRe.exec(text)) && hits.length < max) pushHit(hits, seen, m[1], m[2], '', max);
+ const deskRe = /
]*class="[^"]*yuRUbf[^"]*"[^>]*>[\s\S]*?]+href="([^"]+)"[^>]*>[\s\S]*?]*>([\s\S]*?)<\/h3>/gi;
+ while ((m = deskRe.exec(text)) && hits.length < max) pushHit(hits, seen, m[1], m[2], '', max);
+ const urlqRe = /\/url\?q=(https?:\/\/[^&"'<>]+)/gi;
+ while ((m = urlqRe.exec(text)) && hits.length < max) {
+ let dest = m[1];
+ try {
+ dest = decodeURIComponent(dest);
+ } catch (_) {}
+ pushHit(hits, seen, dest, dest, '', max);
+ }
+ return hits.slice(0, max);
+}
+
+function parseBingHits(html, limit) {
+ const text = String(html || '');
+ const max = clampLimit(limit);
+ const hits = [];
+ const seen = new Set();
+ const re = /]*>[\s\S]*?]*>\s*]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+ let m;
+ while ((m = re.exec(text)) && hits.length < max) {
+ const url = decodeBingClickUrl(m[1]);
+ if (!isOrganicResultUrl(url)) continue;
+ const key = url.split('#')[0];
+ if (seen.has(key)) continue;
+ seen.add(key);
+ hits.push({ url, title: stripSearchHtml(m[2]) || url });
+ }
+ return hits;
+}
+
+function parseDdgHtmlHits(html, limit) {
+ const text = String(html || '');
+ const max = clampLimit(limit);
+ const hits = [];
+ const seen = new Set();
+ const re = /]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+ let m;
+ while ((m = re.exec(text)) && hits.length < max) {
+ const after = text.slice(m.index, m.index + 800);
+ const snip = (after.match(/class="result__snippet[^"]*"[^>]*>([\s\S]*?)<\/(?:td|div|a|span)>/i) || [])[1] || '';
+ pushHit(hits, seen, m[1], m[2], snip, max);
+ }
+ return hits;
+}
+
+function parseDdgLiteHits(html, limit) {
+ const text = String(html || '');
+ const max = clampLimit(limit);
+ const hits = [];
+ const seen = new Set();
+ const re = /]+(?:class="[^"]*result-link[^"]*"|rel="nofollow")[^>]*href="(https?:[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+ let m;
+ while ((m = re.exec(text)) && hits.length < max) pushHit(hits, seen, m[1], m[2], '', max);
+ return hits;
+}
+
+function parseRssItems(xml, limit) {
+ const text = String(xml || '');
+ const max = clampLimit(limit);
+ const hits = [];
+ const seen = new Set();
+ const re = /- ([\s\S]*?)<\/item>/gi;
+ let m;
+ while ((m = re.exec(text)) && hits.length < max) {
+ const block = m[1];
+ const title = stripSearchHtml((block.match(/([\s\S]*?)<\/title>/i) || [])[1] || '');
+ let link = stripSearchHtml((block.match(/<link>([\s\S]*?)<\/link>/i) || [])[1] || '');
+ const desc = stripSearchHtml((block.match(/<description>([\s\S]*?)<\/description>/i) || [])[1] || '');
+ if (!link) continue;
+ link = decodeBingClickUrl(link);
+ if (!isOrganicResultUrl(link)) continue;
+ const key = link.split('#')[0];
+ if (seen.has(key)) continue;
+ seen.add(key);
+ const item = { url: link, title: title || link };
+ if (desc) item.snippet = desc.slice(0, 280);
+ hits.push(item);
+ }
+ return hits;
+}
+
+function parseAtomEntries(xml, limit) {
+ const text = String(xml || '');
+ const max = clampLimit(limit);
+ const hits = [];
+ const re = /<entry>([\s\S]*?)<\/entry>/gi;
+ let m;
+ while ((m = re.exec(text)) && hits.length < max) {
+ const block = m[1];
+ const title = stripSearchHtml((block.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '');
+ const linkM = block.match(/<link[^>]+href="([^"]+)"/i) || block.match(/<id>([\s\S]*?)<\/id>/i);
+ const url = linkM ? String(linkM[1]).trim() : '';
+ const summary = stripSearchHtml((block.match(/<(?:summary|content)[^>]*>([\s\S]*?)<\/(?:summary|content)>/i) || [])[1] || '');
+ if (!url || !/^https?:\/\//i.test(url)) continue;
+ const item = { url, title: title || url };
+ if (summary) item.snippet = summary.slice(0, 280);
+ hits.push(item);
+ }
+ return hits;
+}
+
+function isDdgChallenge(html) {
+ const text = String(html || '');
+ return /anomaly-modal|Unfortunately, bots use DuckDuckGo/i.test(text) && !/result__a/i.test(text);
+}
+
+async function duckDuckGoSearch(query, timeoutMs, limit) {
+ const url = 'https://html.duckduckgo.com/html/';
+ const body = 'q=' + encodeURIComponent(query) + '&b=&kl=us-en';
+ let page = await fetchText(url, timeoutMs, {
+ method: 'POST',
+ headers: {
+ 'content-type': 'application/x-www-form-urlencoded',
+ 'user-agent': BROWSER_UA,
+ accept: 'text/html',
+ },
+ body,
+ });
+ if (!page.error) {
+ if (isDdgChallenge(page.text)) return { error: 'duckduckgo bot challenge', url: page.url, status: page.status };
+ const posted = parseDdgHtmlHits(page.text, limit);
+ if (searchHasHits(posted)) return posted;
+ }
+ page = await fetchText(url + '?q=' + encodeURIComponent(query), timeoutMs);
+ if (page.error) return page;
+ if (isDdgChallenge(page.text)) return { error: 'duckduckgo bot challenge', url: page.url, status: page.status };
+ return parseDdgHtmlHits(page.text, limit);
+}
+
+async function ddgLiteSearch(query, timeoutMs, limit) {
+ const url = 'https://lite.duckduckgo.com/lite/?q=' + encodeURIComponent(query);
+ const page = await fetchText(url, timeoutMs);
+ if (page.error) return page;
+ if (isDdgChallenge(page.text)) return { error: 'duckduckgo bot challenge', url: page.url, status: page.status };
+ const hits = parseDdgLiteHits(page.text, limit);
+ if (searchHasHits(hits)) return hits;
+ return parseDdgHtmlHits(page.text, limit);
+}
+
+async function ddgInstantSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://api.duckduckgo.com/?q=' +
+ encodeURIComponent(query) +
+ '&format=json&no_html=1&skip_disambig=1';
+ const page = await fetchJson(url, timeoutMs, { headers: { accept: 'application/json', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ const j = page.json || {};
+ const hits = [];
+ if (j.AbstractURL && (j.AbstractText || j.Heading)) {
+ hits.push({
+ url: j.AbstractURL,
+ title: j.Heading || j.AbstractURL,
+ snippet: j.AbstractText || '',
+ });
+ }
+ const related = j.RelatedTopics || [];
+ for (let i = 0; i < related.length && hits.length < clampLimit(limit); i++) {
+ const row = related[i];
+ const topics = row.Topics || [row];
+ for (let t = 0; t < topics.length && hits.length < clampLimit(limit); t++) {
+ const item = topics[t];
+ if (!item || !item.FirstURL) continue;
+ hits.push({ url: item.FirstURL, title: stripSearchHtml(item.Text || item.FirstURL), snippet: item.Text || '' });
+ }
+ }
+ return hits;
+}
+
+async function googleSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://www.google.com/search?q=' +
+ encodeURIComponent(query) +
+ '&num=' +
+ clampLimit(limit) +
+ '&hl=en&pws=0&gbv=1';
+ const page = await fetchText(url, timeoutMs, { headers: { 'user-agent': GOOGLE_UA } });
+ if (page.error) return page;
+ const hits = parseGoogleHits(page.text, limit);
+ if (searchHasHits(hits)) return hits;
+ if (/enablejs|Please click/i.test(page.text || '')) return { error: 'google javascript challenge', url: page.url };
+ return hits;
+}
+
+async function bingSearch(query, timeoutMs, limit) {
+ const url = 'https://www.bing.com/search?q=' + encodeURIComponent(query);
+ const page = await fetchText(url, timeoutMs);
+ if (page.error) return page;
+ return parseBingHits(page.text, limit);
+}
+
+async function bingRssSearch(query, timeoutMs, limit) {
+ const url = 'https://www.bing.com/search?q=' + encodeURIComponent(query) + '&format=rss';
+ const page = await fetchText(url, timeoutMs, { headers: { accept: 'application/rss+xml, application/xml, text/xml, */*' } });
+ if (page.error) return page;
+ return parseRssItems(page.text, limit);
+}
+
+async function jinaSearch(query, timeoutMs, limit) {
+ const url = 'https://s.jina.ai/' + encodeURIComponent(query);
+ const page = await fetchJson(url, timeoutMs, {
+ headers: { accept: 'application/json', 'user-agent': AGENT_UA },
+ });
+ if (page.error) return page;
+ const j = page.json || {};
+ let rows = j.data || j.results || [];
+ if (rows && !Array.isArray(rows) && Array.isArray(rows.results)) rows = rows.results;
+ if (!Array.isArray(rows)) rows = [];
+ return rows.slice(0, clampLimit(limit)).map((row) => ({
+ url: row.url || row.link,
+ title: row.title || row.url,
+ snippet: stripSearchHtml(row.description || row.content || '').slice(0, 280),
+ })).filter((h) => h.url);
+}
+
+async function wikiSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=' +
+ encodeURIComponent(query) +
+ '&srlimit=' +
+ clampLimit(limit) +
+ '&format=json&utf8=1';
+ const page = await fetchJson(url, timeoutMs, {
+ headers: { accept: 'application/json', 'user-agent': AGENT_UA },
+ });
+ if (page.error) return page;
+ const rows = (page.json && page.json.query && page.json.query.search) || [];
+ return rows.map((row) => ({
+ url: 'https://en.wikipedia.org/wiki/' + encodeURIComponent(String(row.title || '').replace(/ /g, '_')),
+ title: row.title,
+ snippet: stripSearchHtml(row.snippet || ''),
+ }));
+}
+
+async function hnSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://hn.algolia.com/api/v1/search?query=' +
+ encodeURIComponent(query) +
+ '&tags=story&hitsPerPage=' +
+ clampLimit(limit);
+ const page = await fetchJson(url, timeoutMs, { headers: { accept: 'application/json', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ const rows = (page.json && page.json.hits) || [];
+ return rows.map((row) => ({
+ url: row.url || 'https://news.ycombinator.com/item?id=' + row.objectID,
+ title: row.title || row.story_title || String(row.objectID),
+ snippet: (row.author ? 'by ' + row.author + '. ' : '') + (row.points != null ? row.points + ' points' : ''),
+ points: row.points,
+ comments: row.num_comments,
+ }));
+}
+
+async function githubSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://api.github.com/search/repositories?q=' +
+ encodeURIComponent(query) +
+ '&per_page=' +
+ clampLimit(limit);
+ const page = await fetchJson(url, timeoutMs, {
+ headers: {
+ 'user-agent': AGENT_UA,
+ accept: 'application/vnd.github+json',
+ },
+ });
+ if (page.error) return page;
+ const rows = (page.json && page.json.items) || [];
+ return rows.map((row) => ({
+ url: row.html_url,
+ title: row.full_name || row.name,
+ snippet: row.description || '',
+ }));
+}
+
+async function npmSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://registry.npmjs.org/-/v1/search?text=' +
+ encodeURIComponent(query) +
+ '&size=' +
+ clampLimit(limit);
+ const page = await fetchJson(url, timeoutMs, { headers: { accept: 'application/json', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ const rows = (page.json && page.json.objects) || [];
+ return rows.map((row) => {
+ const pkg = row.package || {};
+ return {
+ url: 'https://www.npmjs.com/package/' + pkg.name,
+ title: pkg.name,
+ snippet: pkg.description || '',
+ version: pkg.version,
+ };
+ });
+}
+
+async function mdnSearch(query, timeoutMs, limit) {
+ const url = 'https://developer.mozilla.org/api/v1/search?q=' + encodeURIComponent(query);
+ const page = await fetchJson(url, timeoutMs, { headers: { accept: 'application/json', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ const rows = (page.json && page.json.documents) || [];
+ return rows.slice(0, clampLimit(limit)).map((row) => ({
+ url: row.mdn_url ? 'https://developer.mozilla.org' + row.mdn_url : row.url,
+ title: row.title,
+ snippet: stripSearchHtml(row.summary || ''),
+ })).filter((h) => h.url);
+}
+
+async function stackOverflowSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&site=stackoverflow&q=' +
+ encodeURIComponent(query) +
+ '&pagesize=' +
+ clampLimit(limit);
+ const page = await fetchJson(url, timeoutMs, { headers: { accept: 'application/json', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ const rows = (page.json && page.json.items) || [];
+ return rows.map((row) => ({
+ url: row.link,
+ title: stripSearchHtml(row.title || ''),
+ snippet: row.score != null ? String(row.score) + ' score' : '',
+ })).filter((h) => h.url);
+}
+
+async function arxivSearch(query, timeoutMs, limit) {
+ const url =
+ 'https://export.arxiv.org/api/query?search_query=all:' +
+ encodeURIComponent(query) +
+ '&start=0&max_results=' +
+ clampLimit(limit);
+ const page = await fetchText(url, timeoutMs, { headers: { accept: 'application/atom+xml, application/xml, text/xml', 'user-agent': AGENT_UA } });
+ if (page.error) return page;
+ return parseAtomEntries(page.text, limit);
+}
+
+const SEARCH_ENGINES = {
+ duckduckgo: duckDuckGoSearch,
+ ddg_lite: ddgLiteSearch,
+ ddg_instant: ddgInstantSearch,
+ google: googleSearch,
+ bing: bingSearch,
+ bing_rss: bingRssSearch,
+ jina: jinaSearch,
+ wikipedia: wikiSearch,
+ hn: hnSearch,
+ github: githubSearch,
+ npm: npmSearch,
+ mdn: mdnSearch,
+ stackoverflow: stackOverflowSearch,
+ arxiv: arxivSearch,
+};
+
+function resolveEngine(name) {
+ const raw = String(name || 'auto').trim().toLowerCase();
+ if (!raw || raw === 'auto') return 'auto';
+ return ENGINE_ALIASES[raw] || raw;
+}
+
+async function runWebSearch(query, opts) {
+ opts = opts || {};
+ const q = String(query || '').trim();
+ if (!q) return { error: 'query required' };
+ const limit = clampLimit(opts.limit);
+ const timeoutMs = opts.timeoutMs;
+ const engine = resolveEngine(opts.engine);
+ if (engine !== 'auto') {
+ const fn = SEARCH_ENGINES[engine];
+ if (!fn) return { error: 'unknown engine', engine: opts.engine, engines: ENGINE_NAMES };
+ const result = await fn(q, timeoutMs, limit);
+ if (searchHasHits(result)) return tagSearchHits(result, engine).slice(0, limit);
+ return {
+ error: (result && result.error) || 'no search results',
+ url: result && result.url,
+ tried: [engine],
+ engines: ENGINE_NAMES,
+ };
+ }
+ const prefer = Array.isArray(opts.prefer) ? opts.prefer.map(resolveEngine).filter((n) => SEARCH_ENGINES[n]) : [];
+ const chain = prefer.concat(AUTO_ENGINES.filter((name) => prefer.indexOf(name) < 0));
+ const tried = [];
+ const errors = {};
+ for (let i = 0; i < chain.length; i++) {
+ const name = chain[i];
+ tried.push(name);
+ const result = await SEARCH_ENGINES[name](q, timeoutMs, limit);
+ if (searchHasHits(result)) return tagSearchHits(result, name).slice(0, limit);
+ errors[name] = result && result.error ? result.error : 'no results';
+ }
+ return { error: 'no search results', tried, errors, engines: ENGINE_NAMES };
+}
+
+async function googleSearchWithFallback(query, timeoutMs) {
+ return runWebSearch(query, { timeoutMs, prefer: ['google'] });
+}
+
+async function webSearch(query, timeoutMs) {
+ return runWebSearch(query, { timeoutMs });
+}
+
+async function codeSearch(query, timeoutMs, limit) {
+ const q = String(query || '').trim();
+ if (!q) return { error: 'query required' };
+ const [github, npm, mdn] = await Promise.all([
+ githubSearch(q, timeoutMs, limit),
+ npmSearch(q, timeoutMs, limit),
+ mdnSearch(q, timeoutMs, limit),
+ ]);
+ const out = { github: [], npm: [], mdn: [] };
+ if (searchHasHits(github)) out.github = tagSearchHits(github, 'github');
+ else if (github && github.error) out.github_error = github.error;
+ if (searchHasHits(npm)) out.npm = tagSearchHits(npm, 'npm');
+ else if (npm && npm.error) out.npm_error = npm.error;
+ if (searchHasHits(mdn)) out.mdn = tagSearchHits(mdn, 'mdn');
+ else if (mdn && mdn.error) out.mdn_error = mdn.error;
+ if (!out.github.length && !out.npm.length && !out.mdn.length) {
+ return { error: 'no code search results', github_error: out.github_error, npm_error: out.npm_error, mdn_error: out.mdn_error };
+ }
+ return out;
+}
+
+async function webFetch(url, timeoutMs) {
+ try {
+ net.assertHttpUrl(url);
+ } catch (err) {
+ return { error: String(err && err.message || err), url: String(url || '') };
+ }
+ try {
+ const res = await fetchWithTimeout(url, {}, timeoutMs);
+ let text = htmlToText(await readBodyWithTimeout(res, timeoutMs));
+ text = truncate.truncateWithMarker(text, 12000);
+ const href = String(res.url || url);
+ if (res.status >= 400) {
+ return { error: 'HTTP ' + res.status, url: href, status: res.status, text, via: 'raw' };
+ }
+ return { status: res.status, url: href, text, via: 'raw' };
+ } catch (err) {
+ return { error: String(err && err.message || err), url: String(url), via: 'raw' };
+ }
+}
+
+async function fetchPage(url, timeoutMs) {
+ try {
+ net.assertHttpUrl(url);
+ } catch (err) {
+ return { error: String(err && err.message || err), url: String(url || '') };
+ }
+ const target = String(url);
+ const jinaUrl = 'https://r.jina.ai/' + target;
+ const ms = Number(timeoutMs) > 0 ? Number(timeoutMs) : PAGE_TIMEOUT_MS;
+ try {
+ net.assertPublicHttpUrl(jinaUrl);
+ const res = await fetchWithTimeout(jinaUrl, { headers: { accept: 'text/plain', 'user-agent': AGENT_UA } }, ms);
+ if (res.status < 400) {
+ let text = await readBodyWithTimeout(res, ms);
+ text = truncate.truncateWithMarker(text, 12000);
+ if (text && text.length > 24 && !/verifying you are (a )?human/i.test(text)) {
+ return { status: res.status, url: target, text, via: 'jina' };
+ }
+ }
+ } catch (_) {}
+ const raw = await webFetch(target, timeoutMs);
+ if (raw && !raw.via) raw.via = 'raw';
+ return raw;
+}
+
+module.exports = {
+ WEB_TIMEOUT_MS,
+ PAGE_TIMEOUT_MS,
+ BROWSER_UA,
+ GOOGLE_UA,
+ AGENT_UA,
+ ENGINE_NAMES,
+ AUTO_ENGINES,
+ SEARCH_ENGINES,
+ fetchWithTimeout,
+ readBodyWithTimeout,
+ stripSearchHtml,
+ htmlToText,
+ decodeSearchUrl,
+ decodeBingClickUrl,
+ parseGoogleHits,
+ parseBingHits,
+ parseDdgHtmlHits,
+ parseDdgLiteHits,
+ parseRssItems,
+ parseAtomEntries,
+ duckDuckGoSearch,
+ ddgLiteSearch,
+ ddgInstantSearch,
+ googleSearch,
+ bingSearch,
+ bingRssSearch,
+ jinaSearch,
+ wikiSearch,
+ hnSearch,
+ githubSearch,
+ npmSearch,
+ mdnSearch,
+ stackOverflowSearch,
+ arxivSearch,
+ runWebSearch,
+ googleSearchWithFallback,
+ webSearch,
+ codeSearch,
+ webFetch,
+ fetchPage,
+};
diff --git a/vendor/agent-harness/test/test.js b/vendor/agent-harness/test/test.js
index 622b662..ea5211c 100644
--- a/vendor/agent-harness/test/test.js
+++ b/vendor/agent-harness/test/test.js
@@ -262,7 +262,9 @@ testTruncateAndPerm();
testPaths();
testQvacWorkerDeps();
testDevicePrefersGpu();
+testGoogleSearchParseAndFallback();
testWebFetchTimeout()
+ .then(() => testGoogleSearchFallsBackToDuckDuckGo())
.then(() => {
console.log('ok');
})
@@ -310,3 +312,98 @@ async function testWebFetchTimeout() {
globalThis.fetch = orig;
}
}
+
+function testGoogleSearchParseAndFallback() {
+ const parsed = tools.parseGoogleHits(
+ '<a href="/url?q=https://example.com/page&sa=U"><div class="BNeawe vvjwJb AP7Wnd">Example Domain</div></a>'
+ );
+ assert.strictEqual(parsed.length, 1);
+ assert.strictEqual(parsed[0].url, 'https://example.com/page');
+ assert.strictEqual(parsed[0].title, 'Example Domain');
+ assert.strictEqual(tools.parseGoogleHits('<title>Google Search').length, 0);
+ assert.ok(tools.SCHEMAS.find((t) => t.name === 'google_search'));
+ assert.ok(tools.SCHEMAS.find((t) => t.name === 'fetch_page'));
+ assert.ok(tools.SCHEMAS.find((t) => t.name === 'wiki_search'));
+ const rss = require('../agent/web-search.js').parseRssItems(
+ '
- Examplehttps://example.com/rss
'
+ );
+ assert.strictEqual(rss[0].url, 'https://example.com/rss');
+}
+
+async function testGoogleSearchFallsBackToDuckDuckGo() {
+ const orig = globalThis.fetch;
+ globalThis.fetch = async (url) => {
+ const href = String(url);
+ if (href.indexOf('google.com') >= 0) {
+ return {
+ status: 200,
+ url: href,
+ text: async () => 'Google Search',
+ };
+ }
+ return {
+ status: 200,
+ url: href,
+ text: async () => 'DDG Example',
+ };
+ };
+ try {
+ const hits = await tools.webSearch('example domain', 200);
+ assert.ok(Array.isArray(hits));
+ assert.strictEqual(hits.length, 1);
+ assert.strictEqual(hits[0].source, 'duckduckgo');
+ assert.strictEqual(hits[0].url, 'https://example.com/ddg');
+ assert.strictEqual(hits[0].title, 'DDG Example');
+ } finally {
+ globalThis.fetch = orig;
+ }
+
+ globalThis.fetch = async (url) => {
+ const href = String(url);
+ if (href.indexOf('google.com') >= 0) {
+ return {
+ status: 200,
+ url: href,
+ text: async () =>
+ 'From Google
',
+ };
+ }
+ throw new Error('duckduckgo should not run when google hits');
+ };
+ try {
+ const hits = await tools.googleSearchWithFallback('example domain', 200);
+ assert.strictEqual(hits[0].source, 'google');
+ assert.strictEqual(hits[0].url, 'https://example.com/google');
+ assert.strictEqual(hits[0].title, 'From Google');
+ } finally {
+ globalThis.fetch = orig;
+ }
+
+ const bingHref =
+ 'https://www.bing.com/ck/a?!&&p=ae&u=a1aHR0cDovL3d3dy5leGFtcGxlLmNvbS8&ntb=1';
+ globalThis.fetch = async (url) => {
+ const href = String(url);
+ if (href.indexOf('google.com') >= 0) {
+ return { status: 200, url: href, text: async () => 'Google Search' };
+ }
+ if (href.indexOf('duckduckgo.com') >= 0) {
+ return {
+ status: 202,
+ url: href,
+ text: async () => 'Unfortunately, bots use DuckDuckGo too.
',
+ };
+ }
+ return {
+ status: 200,
+ url: href,
+ text: async () => '',
+ };
+ };
+ try {
+ const hits = await tools.googleSearchWithFallback('example domain', 200);
+ assert.strictEqual(hits[0].source, 'bing');
+ assert.strictEqual(hits[0].url, 'http://www.example.com/');
+ } finally {
+ globalThis.fetch = orig;
+ }
+}