@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/plugins/walkie-talkie/wire.js

@@ -0,0 +1,136 @@
+import b4a from 'b4a';
+import { raw } from 'compact-encoding';
+import crypto from 'hypercore-crypto';
+import Protomux from 'protomux';
+import { isRecord } from '../../lib/guards.js';
+const PROTOCOL = 'qvac/walkie-talkie/1';
+const STATUSES = {
+    answered: 'answered',
+    denied: 'denied',
+    aborted: 'aborted',
+    budget: 'budget',
+    error: 'error'
+};
+const EVENTS = {
+    message: 'message',
+    thought: 'thought',
+    tool: 'tool',
+    permission: 'permission',
+    usage: 'usage',
+    end: 'end',
+    error: 'error'
+};
+const USAGE = ['inputTokens', 'outputTokens', 'costUsd', 'turns'];
+function proof(team, connection) {
+    return b4a.toHex(crypto.hash([team, connection.handshakeHash]));
+}
+export function openLine(connection, options) {
+    const { team, me, onOpen, onFrame, onClose } = options;
+    let line = null;
+    const channel = Protomux.from(connection).createChannel({
+        protocol: PROTOCOL,
+        id: crypto.discoveryKey(team),
+        onclose: () => line && onClose(line)
+    });
+    if (!channel) {
+        return;
+    }
+    const onmessage = ({ head, bodies }) => {
+        const message = parse(head);
+        if (line && message && message.type !== 'hello') {
+            onFrame(line, { message, bodies });
+        }
+        else if (!line && message?.type === 'hello' && message.proof === proof(team, connection)) {
+            const { name, agents, people } = message;
+            line = { name, agents, people, send, close: () => channel.close() };
+            onOpen(line);
+        }
+        else if (!line) {
+            connection.destroy();
+        }
+    };
+    const out = channel.addMessage({
+        encoding: raw,
+        onmessage: (packed) => onmessage(unpack(packed))
+    });
+    const send = (message, bodies = []) => out.send(pack({ head: message, bodies }));
+    connection.on('error', noop);
+    channel.open();
+    send({ type: 'hello', ...me, agents: [...me.agents], proof: proof(team, connection) });
+}
+function pack({ head, bodies }) {
+    const parts = [b4a.from(JSON.stringify(head)), ...bodies];
+    return b4a.concat(parts.flatMap((part) => [length(part.byteLength), part]));
+}
+function unpack(packed) {
+    const view = new DataView(packed.buffer, packed.byteOffset, packed.byteLength);
+    const parts = [];
+    for (let at = 0; at + 4 <= packed.byteLength;) {
+        const size = view.getUint32(at);
+        parts.push(packed.subarray(at + 4, at + 4 + size));
+        at += 4 + size;
+    }
+    const [head, ...bodies] = parts;
+    return { head: head ? JSON.parse(b4a.toString(head)) : null, bodies };
+}
+function length(size) {
+    const out = b4a.alloc(4);
+    new DataView(out.buffer, out.byteOffset, 4).setUint32(0, size);
+    return out;
+}
+function parse(head) {
+    if (!isRecord(head)) {
+        return null;
+    }
+    if (head.type === 'hello') {
+        const agents = Array.isArray(head.agents) ? head.agents : [];
+        const infos = agents
+            .filter(isRecord)
+            .map(({ name, description }) => ({ name: String(name), description: String(description) }));
+        const [name, given] = [text(head.name), text(head.proof)];
+        const people = head.people === true;
+        return name && given ? { type: 'hello', name, agents: infos, people, proof: given } : null;
+    }
+    const id = text(head.id);
+    return id ? addressed(head, id) : null;
+}
+function addressed(head, id) {
+    const { type } = head;
+    if (type === 'cancel' || type === 'settled') {
+        return { type, id };
+    }
+    const files = Array.isArray(head.files) ? head.files.map(String) : [];
+    if (type === 'message') {
+        const [to, body] = [text(head.to), text(head.text)];
+        return to && body !== null ? { type, id, to, text: body, files } : null;
+    }
+    if (type === 'reply') {
+        const status = STATUSES[String(head.status)] ?? 'error';
+        return { type, id, status, text: text(head.text) ?? '', usage: usage(head.usage), files };
+    }
+    if (type === 'event') {
+        const event = isRecord(head.event) ? head.event : {};
+        const kind = EVENTS[String(event.type)];
+        return kind ? { type, id, event: { ...event, type: kind } } : null;
+    }
+    const question = text(head.question);
+    if (type === 'ask') {
+        return question ? { type, id, question } : null;
+    }
+    return type === 'answer' ? { type, id, text: text(head.text) } : null;
+}
+function usage(value) {
+    const given = isRecord(value) ? value : {};
+    const out = {};
+    for (const key of USAGE) {
+        const count = given[key];
+        if (typeof count === 'number') {
+            out[key] = count;
+        }
+    }
+    return out;
+}
+function text(value) {
+    return typeof value === 'string' ? value : null;
+}
+function noop() { }

package/dist-lib/plugins/weather/geocode.d.ts

@@ -0,0 +1,25 @@
+import { type AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { ToolFetch } from '../../lib/contract/index.ts';
+import { type ResolvedPlace } from './place.ts';
+export declare const GEOCODER_HOST = "geocoding-api.open-meteo.com";
+export declare const GEOCODE_TIMEOUT_MS = 5000;
+export interface Candidate extends ResolvedPlace {
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly population: number | undefined;
+}
+export interface Chosen {
+    readonly place: Candidate;
+    readonly verified: boolean;
+}
+export type Choice = Chosen | {
+    readonly contenders: readonly Candidate[];
+};
+export interface GeocodeRequest {
+    readonly fetch: ToolFetch;
+    readonly signal: BareAbortSignal;
+    readonly timeoutMs: number;
+}
+export declare function geocode(city: string, lookup: GeocodeRequest): Promise<Candidate[]>;
+export declare function geocoderUrl(city: string): URL;
+export declare function choose(city: string, qualifier: string | null, candidates: readonly Candidate[]): Choice | null;

package/dist-lib/plugins/weather/geocode.js

@@ -0,0 +1,101 @@
+import { AbortController } from 'bare-abort-controller';
+import { z } from 'zod';
+import { checkQualifier, describePlace, fold } from './place.js';
+export const GEOCODER_HOST = 'geocoding-api.open-meteo.com';
+export const GEOCODE_TIMEOUT_MS = 5_000;
+const CONTENDER_RATIO = 10;
+const MAX_LISTED = 4;
+const GeocodeSchema = z.object({
+    results: z
+        .array(z.object({
+        name: z.string(),
+        latitude: z.number(),
+        longitude: z.number(),
+        country: z.string().optional(),
+        admin1: z.string().optional(),
+        population: z.number().optional()
+    }))
+        .optional()
+});
+export async function geocode(city, lookup) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(undefined), lookup.timeoutMs);
+    const onLookupAbort = () => controller.abort(undefined);
+    lookup.signal.addEventListener('abort', onLookupAbort);
+    try {
+        return await search(city, lookup, controller.signal);
+    }
+    catch (err) {
+        if (lookup.signal.aborted) {
+            throw err;
+        }
+        return [];
+    }
+    finally {
+        clearTimeout(timeout);
+        lookup.signal.removeEventListener('abort', onLookupAbort);
+    }
+}
+export function geocoderUrl(city) {
+    const query = `name=${encodeURIComponent(city)}&count=10&language=en&format=json`;
+    return new URL(`https://${GEOCODER_HOST}/v1/search?${query}`);
+}
+async function search(city, { fetch }, signal) {
+    const response = await fetch(geocoderUrl(city), {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        signal,
+        redirect: 'manual'
+    });
+    if (response.status !== 200) {
+        throw new Error(`geocoder answered HTTP ${response.status}`);
+    }
+    const { results = [] } = GeocodeSchema.parse(JSON.parse(await response.text()));
+    return results.map((result) => ({
+        area: result.name,
+        region: result.admin1 ?? '',
+        country: result.country ?? '',
+        latitude: result.latitude,
+        longitude: result.longitude,
+        population: result.population
+    }));
+}
+export function choose(city, qualifier, candidates) {
+    const exact = candidates.filter((candidate) => fold(candidate.area) === fold(city));
+    const top = byPopulation(exact)[0] ?? candidates[0];
+    if (top === undefined) {
+        return null;
+    }
+    if (qualifier !== null) {
+        return qualified(qualifier, { exact, candidates, top });
+    }
+    const contenders = contendersOf(exact);
+    if (contenders.length > 1) {
+        return { contenders };
+    }
+    return { place: top, verified: exact.includes(top) };
+}
+function qualified(qualifier, { exact, candidates, top }) {
+    const named = (pool) => pool.find((candidate) => checkQualifier(qualifier, candidate) === 'match');
+    const namesake = named(byPopulation(exact));
+    if (namesake !== undefined) {
+        return { place: namesake, verified: true };
+    }
+    return { place: named(candidates) ?? top, verified: false };
+}
+function contendersOf(exact) {
+    const pool = byPopulation(exact);
+    const top = pool[0]?.population;
+    if (top === undefined) {
+        return [];
+    }
+    const lines = pool.map(describePlace);
+    return pool
+        .filter((candidate, index) => candidate.population !== undefined &&
+        candidate.population * CONTENDER_RATIO >= top &&
+        lines.indexOf(describePlace(candidate)) === index)
+        .slice(0, MAX_LISTED);
+}
+function byPopulation(candidates) {
+    return [...candidates].sort((a, b) => (b.population ?? -1) - (a.population ?? -1));
+}

package/dist-lib/plugins/weather/index.d.ts

@@ -0,0 +1,15 @@
+import type { HarnessPlugin, PluginSetup } from '../../lib/plugins/index.ts';
+export { weatherLookupTool } from './lookup.ts';
+export { checkQualifier, cityMatches, fold, qualifierOf } from './place.ts';
+export interface WeatherOptions {
+    readonly read?: readonly string[];
+    readonly geocodeTimeoutMs?: number;
+}
+export declare class Weather implements HarnessPlugin {
+    readonly name = "weather";
+    readonly api = 1;
+    readonly read: readonly string[] | undefined;
+    private readonly _geocodeTimeoutMs;
+    constructor({ read, geocodeTimeoutMs }?: WeatherOptions);
+    setup(): PluginSetup;
+}

package/dist-lib/plugins/weather/index.js

@@ -0,0 +1,17 @@
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { createWeatherLookupTool } from './lookup.js';
+export { weatherLookupTool } from './lookup.js';
+export { checkQualifier, cityMatches, fold, qualifierOf } from './place.js';
+export class Weather {
+    name = 'weather';
+    api = PluginRegistry.API_VERSION;
+    read;
+    _geocodeTimeoutMs;
+    constructor({ read, geocodeTimeoutMs } = {}) {
+        this.read = read;
+        this._geocodeTimeoutMs = geocodeTimeoutMs;
+    }
+    setup() {
+        return { tools: [createWeatherLookupTool({ geocodeTimeoutMs: this._geocodeTimeoutMs })] };
+    }
+}

package/dist-lib/plugins/weather/lookup.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from '../../lib/contract/index.ts';
+export interface WeatherLookupToolOptions {
+    readonly geocodeTimeoutMs?: number | undefined;
+}
+export declare function createWeatherLookupTool({ geocodeTimeoutMs }?: WeatherLookupToolOptions): ToolDefinition;
+export declare const weatherLookupTool: ToolDefinition;

package/dist-lib/plugins/weather/lookup.js

@@ -0,0 +1,169 @@
+import { AbortController } from 'bare-abort-controller';
+import { errorMessage } from '../../lib/guards.js';
+import { choose, geocode, GEOCODE_TIMEOUT_MS, GEOCODER_HOST, geocoderUrl } from './geocode.js';
+import { checkQualifier, cityMatches, describePlace, qualifierOf } from './place.js';
+import { placeOf, renderReport, WeatherJsonSchema } from './report.js';
+const WEATHER_HOST = 'wttr.in';
+const LOOKUP_TIMEOUT_MS = 15_000;
+function forecastUrl(path) {
+    return new URL(`https://${WEATHER_HOST}/${path}?format=j1`);
+}
+function cityOf(location) {
+    return (location.split(',')[0] ?? '').trim();
+}
+function egress(args) {
+    if (typeof args.location !== 'string' || args.location.trim().length === 0) {
+        return null;
+    }
+    const location = args.location.trim();
+    const byName = forecastUrl(encodeURIComponent(location)).href;
+    const city = cityOf(location);
+    return city.length === 0 ? [byName] : [geocoderUrl(city).href, byName];
+}
+export function createWeatherLookupTool({ geocodeTimeoutMs = GEOCODE_TIMEOUT_MS } = {}) {
+    return {
+        name: 'weather_lookup',
+        toolset: 'http-request',
+        skillGated: true,
+        autoApprove: true,
+        description: 'Look up the current weather and a three-day forecast for a place, via wttr.in. ' +
+            'Returns the place the service resolved on its first line, then the conditions now and ' +
+            'one line per day. Use it for any question about weather, temperature or forecast. ' +
+            'When a name matches several places it answers with a question listing them.',
+        parameters: {
+            type: 'object',
+            properties: {
+                location: {
+                    type: 'string',
+                    description: 'The place exactly as the user wrote it, including any country or state: ' +
+                        '"Nassau, Bahamas", "Paris, Texas", "London"'
+                }
+            },
+            required: ['location']
+        },
+        effect: () => 'read',
+        resource: () => ({ kind: 'host', label: `${GEOCODER_HOST}, ${WEATHER_HOST}` }),
+        egress,
+        execute: (args, ctx) => execute(args.location, {
+            fetch: ctx?.fetch,
+            signal: ctx?.signal,
+            timeoutMs: geocodeTimeoutMs
+        })
+    };
+}
+export const weatherLookupTool = createWeatherLookupTool();
+async function execute(raw, { fetch, signal, timeoutMs }) {
+    if (typeof raw !== 'string' || raw.trim().length === 0) {
+        return { error: 'location must be a non-empty string' };
+    }
+    const location = raw.trim();
+    if (signal?.aborted) {
+        return { error: 'weather_lookup cancelled' };
+    }
+    if (!fetch) {
+        return { error: 'weather_lookup has no network access' };
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(undefined), LOOKUP_TIMEOUT_MS);
+    const onCallerAbort = () => controller.abort(undefined);
+    signal?.addEventListener('abort', onCallerAbort);
+    try {
+        return await lookup(location, { fetch, signal: controller.signal, timeoutMs });
+    }
+    catch (err) {
+        return failure(err, controller.signal, signal);
+    }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener('abort', onCallerAbort);
+    }
+}
+async function lookup(location, request) {
+    const city = cityOf(location);
+    const candidates = city.length === 0 ? [] : await geocode(city, request);
+    const choice = choose(city, qualifierOf(location), candidates);
+    if (choice === null) {
+        return byName(location, request);
+    }
+    if ('contenders' in choice) {
+        return reply(which(city, choice.contenders));
+    }
+    return byCoordinates(location, choice, request);
+}
+async function byCoordinates(location, { place, verified }, request) {
+    const fetched = await forecast(`${place.latitude},${place.longitude}`, location, request);
+    if (!('json' in fetched)) {
+        return fetched;
+    }
+    return { content: renderReport(fetched.json, place, { asked: location, verified }) };
+}
+async function byName(location, request) {
+    const fetched = await forecast(encodeURIComponent(location), location, request);
+    if (!('json' in fetched)) {
+        return fetched;
+    }
+    const place = placeOf(fetched.json);
+    if (place === null) {
+        return reply(notFound(location));
+    }
+    const qualifier = qualifierOf(location);
+    const verdict = qualifier === null ? null : checkQualifier(qualifier, place);
+    const named = cityMatches(location, place);
+    if (verdict === 'contradiction' && !named) {
+        return reply(`No such place: "${location}". ${WEATHER_HOST} resolved it to ` +
+            `${describePlace(place)}, which is somewhere else.`);
+    }
+    const verified = qualifier === null ? named : verdict === 'match';
+    return { content: renderReport(fetched.json, place, { asked: location, verified }) };
+}
+async function forecast(path, location, { fetch, signal }) {
+    const response = await fetch(forecastUrl(path), {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        signal,
+        redirect: 'manual'
+    });
+    if (response.status >= 300 && response.status < 400) {
+        return { error: `${WEATHER_HOST} redirected the lookup for "${location}"` };
+    }
+    return readForecast(response.status, await response.text(), location);
+}
+function readForecast(status, body, location) {
+    if (/location not found/i.test(body)) {
+        return reply(notFound(location));
+    }
+    if (status !== 200) {
+        return { error: unavailable(`it answered HTTP ${status}`), code: 'transport' };
+    }
+    try {
+        return { json: WeatherJsonSchema.parse(JSON.parse(body)) };
+    }
+    catch {
+        return { error: unavailable('it did not return a forecast') };
+    }
+}
+function failure(err, signal, callerSignal) {
+    if (callerSignal?.aborted) {
+        return { error: 'weather_lookup cancelled' };
+    }
+    if (signal.aborted) {
+        return { error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms`, code: 'timeout' };
+    }
+    const message = errorMessage(err);
+    if (err instanceof TypeError && message.startsWith('fetch refused')) {
+        return { error: message };
+    }
+    return { error: unavailable(message), code: 'transport' };
+}
+function unavailable(reason) {
+    return `The weather service could not be reached: ${reason}.`;
+}
+function reply(content) {
+    return { content, answer: true };
+}
+function notFound(location) {
+    return `No such place: "${location}". ${WEATHER_HOST} does not know it.`;
+}
+function which(city, places) {
+    return `Which ${city}: ${places.map(describePlace).join('; ')}?`;
+}

package/dist-lib/{lib/tools/weather-lookup → plugins/weather}/place.js

@@ -17,6 +17,8 @@ const QUALIFIER_ALIASES = [
     ['united arab emirates', 'united arab emirates'],
     ['uae', 'united arab emirates'],
     ['holland', 'netherlands'],
+    ['schweiz', 'switzerland'],
+    ['suisse', 'switzerland'],
     ['deutschland', 'germany'],
     ['espana', 'spain'],
     ['italia', 'italy']
@@ -103,7 +105,9 @@ export function fold(value) {
         .trim();
 }
 export function describePlace(place) {
-    return [place.area, place.region, place.country].filter((part) => part.length > 0).join(', ');
+    return [place.area, place.region, place.country]
+        .filter((part, index, parts) => part.length > 0 && parts.indexOf(part) === index)
+        .join(', ');
 }
 export function qualifierOf(location) {
     const comma = location.indexOf(',');

package/dist-lib/plugins/web-search/engine-registry.d.ts

@@ -0,0 +1,44 @@
+import type { SearchEngine } from './types.ts';
+import { aolUrl, searchAol } from './engines/aol.ts';
+import { bingUrl, searchBing } from './engines/bing.ts';
+import { braveUrl, searchBrave } from './engines/brave.ts';
+import { duckDuckGoUrl, searchDuckDuckGo } from './engines/duckduckgo.ts';
+import { googleUrl, searchGoogle } from './engines/google.ts';
+import { searchWikipedia, wikipediaUrl } from './engines/wikipedia.ts';
+import { searchYahoo, yahooUrl } from './engines/yahoo.ts';
+export interface EngineEntry {
+    readonly name: string;
+    readonly url: (query: string) => string;
+    readonly search: SearchEngine;
+}
+export declare const DEFAULT_MAX_RESULTS = 8;
+export declare const ENGINES: readonly [{
+    readonly name: 'duckduckgo';
+    readonly url: typeof duckDuckGoUrl;
+    readonly search: typeof searchDuckDuckGo;
+}, {
+    readonly name: 'brave';
+    readonly url: typeof braveUrl;
+    readonly search: typeof searchBrave;
+}, {
+    readonly name: 'google';
+    readonly url: typeof googleUrl;
+    readonly search: typeof searchGoogle;
+}, {
+    readonly name: 'yahoo';
+    readonly url: typeof yahooUrl;
+    readonly search: typeof searchYahoo;
+}, {
+    readonly name: 'aol';
+    readonly url: typeof aolUrl;
+    readonly search: typeof searchAol;
+}, {
+    readonly name: 'bing';
+    readonly url: typeof bingUrl;
+    readonly search: typeof searchBing;
+}, {
+    readonly name: 'wikipedia';
+    readonly url: typeof wikipediaUrl;
+    readonly search: typeof searchWikipedia;
+}];
+export type EngineName = (typeof ENGINES)[number]['name'];

package/dist-lib/plugins/web-search/engine-registry.js

@@ -0,0 +1,17 @@
+import { aolUrl, searchAol } from './engines/aol.js';
+import { bingUrl, searchBing } from './engines/bing.js';
+import { braveUrl, searchBrave } from './engines/brave.js';
+import { duckDuckGoUrl, searchDuckDuckGo } from './engines/duckduckgo.js';
+import { googleUrl, searchGoogle } from './engines/google.js';
+import { searchWikipedia, wikipediaUrl } from './engines/wikipedia.js';
+import { searchYahoo, yahooUrl } from './engines/yahoo.js';
+export const DEFAULT_MAX_RESULTS = 8;
+export const ENGINES = [
+    { name: 'duckduckgo', url: duckDuckGoUrl, search: searchDuckDuckGo },
+    { name: 'brave', url: braveUrl, search: searchBrave },
+    { name: 'google', url: googleUrl, search: searchGoogle },
+    { name: 'yahoo', url: yahooUrl, search: searchYahoo },
+    { name: 'aol', url: aolUrl, search: searchAol },
+    { name: 'bing', url: bingUrl, search: searchBing },
+    { name: 'wikipedia', url: wikipediaUrl, search: searchWikipedia }
+];

package/dist-lib/{lib → plugins}/web-search/engines/aol.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function aolUrl(query: string): string;
 export declare function searchAol(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/aol.js

@@ -1,5 +1,5 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 import { urlMatchesHost } from '../url-helpers.js';
 function decodeRuUrl(encoded) {
     try {
@@ -70,9 +70,11 @@ function parseRuFallback(html) {
     }
     return results;
 }
+export function aolUrl(query) {
+    return `https://search.aol.com/aol/search?q=${encodeURIComponent(query)}`;
+}
 export async function searchAol(query, fetcher, signal) {
-    const url = `https://search.aol.com/aol/search?q=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, { signal });
+    const html = await fetchHtml(fetcher, aolUrl(query), { signal });
     const primary = parseAlgoBlocks(html);
     if (primary.length > 0) {
         return primary;

package/dist-lib/{lib → plugins}/web-search/engines/bing.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function bingUrl(query: string): string;
 export declare function searchBing(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/bing.js

@@ -1,7 +1,7 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 import { urlMatchesHost } from '../url-helpers.js';
-import { SAFARI_UA } from '../user-agents.js';
+import { SAFARI_UA } from '../../../lib/helpers/user-agents.js';
 function isOrganicBingUrl(url) {
     return url.startsWith('http') && !urlMatchesHost(url, 'bing.com') && !url.includes('msockid=');
 }
@@ -97,9 +97,14 @@ function parseH2Fallback(html) {
     }
     return results;
 }
+export function bingUrl(query) {
+    return `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
+}
 export async function searchBing(query, fetcher, signal) {
-    const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
-    const html = await fetchHtml(fetcher, url, { headers: { 'User-Agent': SAFARI_UA }, signal });
+    const html = await fetchHtml(fetcher, bingUrl(query), {
+        headers: { 'User-Agent': SAFARI_UA },
+        signal
+    });
     if (html.includes('captcha') || html.includes('challenge/verify') || html.includes('Turnstile')) {
         throw new Error('Bing CAPTCHA detected');
     }

package/dist-lib/{lib → plugins}/web-search/engines/brave.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function braveUrl(query: string): string;
 export declare function searchBrave(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/{lib → plugins}/web-search/engines/brave.js

@@ -1,5 +1,5 @@
 import { fetchHtml } from '../fetch-html.js';
-import { clean } from '../html-helpers.js';
+import { clean } from '../../../lib/helpers/html-helpers.js';
 function parseSnippetBlock(inner) {
     const urlMatch = inner.match(/<a[^>]*href="(https?:\/\/(?!imgs\.search\.brave)[^"]*)"[^>]*>/i);
     if (!urlMatch) {
@@ -48,9 +48,11 @@ function parseLinkFallback(html) {
     }
     return results;
 }
+export function braveUrl(query) {
+    return `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`;
+}
 export async function searchBrave(query, fetcher, signal) {
-    const url = `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`;
-    const html = await fetchHtml(fetcher, url, {
+    const html = await fetchHtml(fetcher, braveUrl(query), {
         cookies: { safesearch: 'off', useLocation: '0', summarizer: '0', country: 'us' },
         signal
     });

package/dist-lib/{lib → plugins}/web-search/engines/duckduckgo.d.ts

@@ -1,3 +1,4 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { Fetcher, RankedResult } from '../types.ts';
+export declare function duckDuckGoUrl(): string;
 export declare function searchDuckDuckGo(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;