@browserwright/pi 0.0.1

package/providers/browserwright-search.ts

@@ -0,0 +1,427 @@
+/**
+ * The `web_search` rung: drive a real search engine in the user's own Chrome.
+ *
+ * This is a `kind: "module"` provider rather than a `kind: "command"` one
+ * because a search is not one shot at a subprocess. It is: mint a session,
+ * navigate, extract from the live DOM, tear the session down — with a retry in
+ * the middle and a guaranteed teardown at the end. A shell script can express
+ * that, and one used to (`.retired/browserwright.sh`, 122 lines), which is
+ * exactly the experience this file exists to avoid repeating.
+ *
+ * Six measured behaviours of the executor are designed around here. They are
+ * not hypothetical; each one produced a silent wrong answer at least once:
+ *
+ *  1. Executor stdout is truncated at ~10KB SILENTLY, with exit 0. So the
+ *     payload never travels on stdout — the script writes it to a file and
+ *     prints only a byte count, which we verify. This mirrors what the
+ *     `browserwright markdown` command does internally for the same reason.
+ *  2. `sys.exit()` inside the executor KILLS it, and the next call fails with
+ *     ExecutorUnavailable. The script therefore never calls it; "no results" is
+ *     data that comes back, not an exit status.
+ *  3. Chrome serves its own `neterror` page through a *successful* navigation,
+ *     so `page.content()` returns an error document rather than raising.
+ *  4. The executor can die mid-call. One `session reset` + retry recovers it.
+ *  5. browserwright reports errors as one JSON object per line on stderr;
+ *     unwrapped here so the chain trace reads as a sentence.
+ *  6. A session that is not ended leaks a Chrome tab group into the user's
+ *     window, so teardown lives in a `finally` that runs on every path.
+ */
+
+import { spawn } from "node:child_process";
+import { readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { normalizeSearchPayload } from "../core/results.ts";
+import type { ModuleContext, ProviderOutcome, SearchPayload } from "../core/types.ts";
+
+const BIN = "browserwright";
+const READY_MARKER = "BW_SEARCH_OK";
+
+/** Error types that mean "the plumbing broke", not "the page said no". */
+const TRANSIENT = new Set(["ExecutorUnavailable", "PageBindTimeout", "DaemonUnavailable", "CDPError"]);
+
+interface Run {
+	code: number | null;
+	stdout: string;
+	stderr: string;
+}
+
+function run(args: string[], options: { input?: string; signal?: AbortSignal; timeoutMs: number }): Promise<Run> {
+	// Adding an "abort" listener to an ALREADY-aborted signal never fires it, so
+	// without this check a cancelled call still spawns a process and waits out
+	// the full timeout. Teardown deliberately passes no signal so it still runs.
+	if (options.signal?.aborted) {
+		return Promise.resolve({ code: null, stdout: "", stderr: "aborted" });
+	}
+	return new Promise((resolve) => {
+		const child = spawn(BIN, args, { stdio: ["pipe", "pipe", "pipe"] });
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+
+		const finish = (result: Run) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", onAbort);
+			resolve(result);
+		};
+
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			finish({ code: null, stdout, stderr: `${stderr}\ntimeout after ${options.timeoutMs}ms` });
+		}, options.timeoutMs);
+
+		const onAbort = () => {
+			child.kill("SIGKILL");
+			finish({ code: null, stdout, stderr: `${stderr}\naborted` });
+		};
+		options.signal?.addEventListener("abort", onAbort, { once: true });
+
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => finish({ code: null, stdout, stderr: `spawn failed: ${error.message}` }));
+		child.on("close", (code) => finish({ code, stdout, stderr }));
+
+		if (options.input !== undefined) child.stdin.end(options.input);
+		else child.stdin.end();
+	});
+}
+
+/**
+ * browserwright writes one JSON object per line on stderr for its own errors,
+ * but a generic exception arrives as a bare Python traceback and a usage error
+ * as plain text. Pull out a sentence whichever shape it is.
+ */
+export function explain(stderr: string): { message: string; type?: string; retryable?: boolean } {
+	const lines = stderr
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+
+	for (const line of [...lines].reverse()) {
+		if (!line.startsWith("{")) continue;
+		try {
+			const parsed = JSON.parse(line) as { msg?: string; type?: string; retryable?: boolean };
+			if (parsed.msg) return { message: parsed.msg, type: parsed.type, retryable: parsed.retryable };
+		} catch {
+			// Not the envelope — keep scanning older lines.
+		}
+	}
+	return { message: lines.at(-1) ?? "no output" };
+}
+
+function isTransient(info: { type?: string; retryable?: boolean; message: string }): boolean {
+	if (info.retryable) return true;
+	if (info.type && TRANSIENT.has(info.type)) return true;
+	return /executor/i.test(info.message);
+}
+
+/**
+ * The extraction script, run inside the session's executor.
+ *
+ * Selectors live here rather than in the Python package on purpose: a Google
+ * layout change is then a `npm publish` of this package, not a PyPI release of
+ * browserwright plus an upgrade on every machine.
+ */
+function buildScript(query: string, limit: number, outPath: string, searchUrl: string): string {
+	// Every extractor is independently guarded. Google restyles constantly, and
+	// the failure mode that matters is one changed container silently taking the
+	// whole search down with it — organic rows must survive a broken AI-Overview
+	// selector, and vice versa.
+	const js = `() => {
+  const QUERY = ${JSON.stringify(query)}.toLowerCase();
+  const attempt = (fn, fallback) => { try { return fn(); } catch (e) { return fallback; } };
+  const clean = (s) => (s || '')
+    .replace(/\\s*\\bRead more\\s*$/i, '')
+    .replace(/\\s*\\bShow more\\s*$/i, '')
+    .replace(/\\s+/g, ' ')
+    .trim();
+
+  // --- organic rows ------------------------------------------------------
+  const results = attempt(() => {
+    const rows = [];
+    document.querySelectorAll('#search a h3').forEach((h3) => {
+      const a = h3.closest('a');
+      if (!a || !a.href) return;
+      const block = h3.closest('div[data-hveid]');
+      let snippet = '';
+      if (block) {
+        const sn = block.querySelector('div[data-sncf], div[style*="-webkit-line-clamp"]');
+        snippet = sn ? sn.innerText : '';
+        if (!snippet) {
+          const long = (block.innerText || '').split('\\n').filter((s) => s.length > 40);
+          snippet = long[0] || '';
+        }
+      }
+      // Google prefixes dated results with "Mar 5, 2025 — ". Promote that to a
+      // field so the model can judge freshness without parsing prose.
+      let date = null;
+      const m = snippet.match(/^([A-Z][a-z]{2} \\d{1,2}, \\d{4})\\s*[—·\\-]\\s*/);
+      if (m) { date = m[1]; snippet = snippet.slice(m[0].length); }
+      rows.push({ title: clean(h3.innerText), url: a.href, snippet: clean(snippet).slice(0, 400), date });
+    });
+    return rows;
+  }, []);
+
+  // --- answer box / AI Overview -----------------------------------------
+  // Class names here are obfuscated and rotate, so anchor on the accessible
+  // heading instead and walk up until the container actually holds the body.
+  const answerBox = attempt(() => {
+    const head = [...document.querySelectorAll('[role="heading"]')]
+      .find((e) => (e.innerText || '').trim() === 'AI Overview');
+    if (!head) return null;
+    let node = head;
+    for (let i = 0; i < 8 && node; i++) {
+      const t = node.innerText || '';
+      if (t.length >= 150) {
+        const body = clean(t.replace(/^AI Overview\\s*/, ''))
+          .replace(/AI responses may include mistakes.*$/i, '')
+          // innerText splices the citation chips into the prose ("Reddit +2").
+          // The bare counters are pure noise; the source names are left alone.
+          .replace(/\\s\\+\\d+\\b/g, '')
+          .trim();
+        return body ? { kind: 'ai-overview', text: body.slice(0, 4000) } : null;
+      }
+      node = node.parentElement;
+    }
+    return null;
+  }, null);
+
+  // --- knowledge panel ---------------------------------------------------
+  // data-attrid is semantic markup rather than a styling class, which makes it
+  // the one stable hook on this page.
+  const knowledgeGraph = attempt(() => {
+    const pick = (sel) => {
+      const e = document.querySelector('[data-attrid="' + sel + '"]');
+      return e ? clean(e.innerText).slice(0, 300) : undefined;
+    };
+    const title = pick('title');
+    const subtitle = pick('subtitle');
+    const description = pick('wa:/description') || pick('description');
+    const attributes = {};
+    document.querySelectorAll('[data-attrid]').forEach((e) => {
+      const id = e.getAttribute('data-attrid') || '';
+      // Keep only labelled facts: "kc:/…:label" style ids carry real values,
+      // the rest are layout containers and image slots.
+      if (!/^kc:/.test(id)) return;
+      const label = id.split(':').pop() || id;
+      // Google renders the label above the value, so innerText yields
+      // "Programming language TypeScript" for a key already named
+      // programming_language. Drop the echoed label.
+      // Built with plain string ops rather than a constructed RegExp: the label
+      // is engine-supplied, and a metacharacter in it would either throw (which
+      // the guard above would silently swallow) or match the wrong thing.
+      const human = label.replace(/_/g, ' ').toLowerCase();
+      let text = clean(e.innerText);
+      if (text.toLowerCase().startsWith(human)) {
+        text = text.slice(human.length).replace(/^[\\s:\\uff1a]+/, '');
+      }
+      if (!text || text.length > 160) return;
+      if (!attributes[label]) attributes[label] = text;
+    });
+    if (!title && !description && Object.keys(attributes).length === 0) return null;
+    const out = { title, subtitle, description };
+    if (Object.keys(attributes).length) out.attributes = attributes;
+    return out;
+  }, null);
+
+  // --- people also ask ---------------------------------------------------
+  // data-q also carries the original query on the search box, so drop anything
+  // that just echoes what was asked.
+  const peopleAlsoAsk = attempt(() => {
+    const seen = new Set();
+    const out = [];
+    document.querySelectorAll('[data-q]').forEach((e) => {
+      const q = clean(e.getAttribute('data-q'));
+      if (!q || q.toLowerCase() === QUERY) return;
+      if (seen.has(q.toLowerCase())) return;
+      seen.add(q.toLowerCase());
+      out.push(q);
+    });
+    return out.slice(0, 10);
+  }, []);
+
+  // --- related searches --------------------------------------------------
+  // Scoped to #botstuff: the same href pattern at the top of the page is
+  // Google's own tab bar ("Images", "News", "Past hour"), not a related query.
+  const relatedSearches = attempt(() => {
+    const bot = document.querySelector('#botstuff');
+    if (!bot) return [];
+    const seen = new Set();
+    const out = [];
+    bot.querySelectorAll('a[href*="/search?"]').forEach((a) => {
+      const t = clean(a.innerText);
+      // Pagination shares this selector: bare page numbers plus the nav labels.
+      if (!t || /^\\d+$/.test(t) || t.length < 3 || t.length > 80) return;
+      if (/^(next|previous|prev|more results?)$/i.test(t)) return;
+      if (t.toLowerCase() === QUERY || seen.has(t.toLowerCase())) return;
+      seen.add(t.toLowerCase());
+      out.push(t);
+    });
+    return out.slice(0, 10);
+  }, []);
+
+  return { results, answerBox, knowledgeGraph, peopleAlsoAsk, relatedSearches };
+}`;
+
+	// json.dumps gives us correctly escaped Python string literals for free, so
+	// a query containing quotes or newlines cannot break out of the script.
+	return [
+		"import json",
+		`QUERY = ${JSON.stringify(query)}`,
+		`LIMIT = ${limit}`,
+		`OUT = ${JSON.stringify(outPath)}`,
+		`URL = ${JSON.stringify(searchUrl)}`,
+		`JS = ${JSON.stringify(js)}`,
+		"payload = {}",
+		"try:",
+		"    page.goto(URL)",
+		"    html = None",
+		"    data = None",
+		// A search engine can bounce the page right after load (consent, region
+		// redirect), which destroys the execution context mid-evaluate. Observed
+		// while mapping these selectors; one settle-and-retry clears it.
+		"    for _ in range(2):",
+		"        try:",
+		"            html = page.content()",
+		"            data = page.evaluate(JS)",
+		"            break",
+		"        except Exception as e:",
+		'            if "ontext was destroyed" not in str(e):',
+		"                raise",
+		'            page.wait_for_load_state("domcontentloaded")',
+		"            page.wait_for_timeout(800)",
+		"    if data is None:",
+		'        payload = {"failed": "the page kept navigating; could not read results"}',
+		// (3) Chrome's own error document arrives through a successful navigation.
+		'    elif "neterror" in html and "error-code" in html:',
+		'        payload = {"blocked": "the browser could not reach the search engine"}',
+		"    else:",
+		"        rows = data.get(\"results\") or []",
+		"        payload = {",
+		'            "results": rows[:LIMIT],',
+		'            "url": page.url,',
+		'            "answerBox": data.get("answerBox"),',
+		'            "knowledgeGraph": data.get("knowledgeGraph"),',
+		'            "peopleAlsoAsk": data.get("peopleAlsoAsk") or [],',
+		'            "relatedSearches": data.get("relatedSearches") or [],',
+		"        }",
+		"        if not rows:",
+		// An interstitial parses fine and yields zero rows; say which kind it was.
+		"            low = html.lower()",
+		'            for needle in ("recaptcha", "unusual traffic", "detected unusual"):',
+		"                if needle in low:",
+		'                    payload = {"blocked": "search engine returned an interstitial (%s)" % needle}',
+		"                    break",
+		"except Exception as e:",
+		// (2) never sys.exit() — a raise would kill the executor for the next call.
+		'    payload = {"failed": "%s: %s" % (type(e).__name__, e)}',
+		"data = json.dumps(payload, ensure_ascii=False)",
+		'with open(OUT, "w", encoding="utf-8") as fh:',
+		"    fh.write(data)",
+		// (1) only a byte count travels on stdout, never the payload itself.
+		`print(${JSON.stringify(READY_MARKER)}, len(data.encode("utf-8")))`,
+	].join("\n");
+}
+
+interface Attempted {
+	ok: boolean;
+	payload?: SearchPayload;
+	reason?: string;
+	transient?: boolean;
+}
+
+async function attempt(sid: string, script: string, outPath: string, ctx: ModuleContext): Promise<Attempted> {
+	const exec = await run(["-s", sid, "--code-stdin"], {
+		input: script,
+		signal: ctx.signal,
+		timeoutMs: ctx.timeoutMs,
+	});
+
+	if (exec.code !== 0) {
+		const info = explain(exec.stderr);
+		return { ok: false, reason: info.message, transient: isTransient(info) };
+	}
+
+	const marker = exec.stdout.match(new RegExp(`${READY_MARKER}\\s+(\\d+)`));
+	if (!marker) {
+		return { ok: false, reason: "extraction script produced no completion marker", transient: true };
+	}
+
+	let raw: string;
+	try {
+		raw = readFileSync(outPath, "utf8");
+	} catch (error) {
+		return { ok: false, reason: `could not read extraction output: ${(error as Error).message}` };
+	}
+
+	// (1) The byte count is the whole point of writing to a file: a short read
+	// here is the signature of the silent stdout truncation this avoids.
+	const expected = Number(marker[1]);
+	const actual = Buffer.byteLength(raw, "utf8");
+	if (actual !== expected) {
+		return { ok: false, reason: `truncated transfer: expected ${expected} bytes, read ${actual}` };
+	}
+
+	const body = JSON.parse(raw) as { blocked?: string; failed?: string };
+	if (body.blocked) return { ok: false, reason: body.blocked };
+	if (body.failed) return { ok: false, reason: body.failed };
+
+	// The script emits exactly the key names normalizeSearchPayload aliases, so
+	// the browser rung and a hosted JSON rung land on the same shape.
+	return { ok: true, payload: normalizeSearchPayload(body) };
+}
+
+const runner = async (query: string, ctx: ModuleContext): Promise<ProviderOutcome<SearchPayload>> => {
+	const limit = Number(ctx.options.limit ?? 10);
+	const template = String(
+		ctx.options.searchUrl ?? "https://www.google.com/search?q={queryEncoded}&hl=en&num={limit}",
+	);
+	const searchUrl = template
+		.replaceAll("{queryEncoded}", encodeURIComponent(query))
+		.replaceAll("{limit}", String(limit));
+
+	const outPath = join(tmpdir(), `bw-search-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+	const script = buildScript(query, limit, outPath, searchUrl);
+
+	ctx.onProgress?.("opening a search session");
+	const created = await run(
+		["session", "new", "--backend=extension", "--name=pi-websearch"],
+		{ signal: ctx.signal, timeoutMs: ctx.timeoutMs },
+	);
+	if (created.code !== 0) {
+		return { ok: false, reason: explain(created.stderr).message };
+	}
+	// stdout is the bare session id and nothing else; the human-readable
+	// "OK: session N created" goes to stderr. Reading "the last line" of the
+	// two streams merged is what the retired wrapper did, and why it was fragile.
+	const sid = created.stdout.trim();
+	if (!sid) return { ok: false, reason: "session new printed no id" };
+
+	try {
+		ctx.onProgress?.(`searching (session ${sid})`);
+		let result = await attempt(sid, script, outPath, ctx);
+
+		// (4) One recycle-and-retry. Only for plumbing failures — a page that
+		// said no will say no again, and retrying it just costs the user a tab.
+		if (!result.ok && result.transient && !ctx.signal?.aborted) {
+			ctx.onProgress?.("executor died, recycling and retrying once");
+			await run(["session", "reset", sid], { signal: ctx.signal, timeoutMs: 30_000 });
+			result = await attempt(sid, script, outPath, ctx);
+		}
+
+		if (!result.ok) return { ok: false, reason: result.reason ?? "search failed" };
+		return { ok: true, content: result.payload ?? { results: [] } };
+	} finally {
+		// (6) Always. A leaked session is a tab group left in the user's window.
+		await run(["session", "end", `--session=${sid}`], { timeoutMs: 30_000 });
+		rmSync(outPath, { force: true });
+	}
+};
+
+export default runner;

package/providers/browserwright.json

@@ -0,0 +1,54 @@
+{
+  "name": "browserwright",
+  "label": "browserwright (your Chrome)",
+  "role": "fetch",
+  "kind": "command",
+  "command": [
+    "browserwright",
+    "markdown",
+    "{url}",
+    "--max-chars=0",
+    "--name=pi-webfetch"
+  ],
+  "returns": "markdown",
+  "timeoutMs": 90000,
+  "retries": 1,
+  "retryWhen": [
+    "PageBindTimeout",
+    "retryable"
+  ],
+  "failWhen": {
+    "matches": []
+  },
+  "_note": [
+    "browserwright >= 0.9.0 has a native one-shot markdown command that owns its",
+    "whole lifecycle: it creates a throwaway session, navigates, converts, and",
+    "tears the session down. Verified 2026-08-09: no leaked sessions afterwards.",
+    "--backend defaults to `extension`, the user's real Chrome, which is what we",
+    "want: the isolated cdp backend would launch a new Chrome and steal the macOS",
+    "active window. Do-not-disturb outranks isolation. It also means this rung",
+    "carries the user's login state, which is the whole reason it is worth having.",
+    "--max-chars=0 disables its 8000-char print cap. Measured: a Wikipedia article",
+    "comes through stdout at 46,033 bytes, so the ~10KB executor stdout truncation",
+    "that forced the old wrapper script does not apply on this path.",
+    "--mode defaults to `auto`: extract the main content, and fall back to the",
+    "page minus nav/aside/footer if extraction collapses. Switch to --mode=full",
+    "here if a docs or API-reference page ever comes back missing its tables or",
+    "code blocks — that is readability's known weak spot, and `full` keeps every",
+    "link.",
+    "failWhen.matches: [] switches OFF the core default list, and the probe on",
+    "2026-08-09 says keep it that way: every case that returned content returned",
+    "genuine content, including x.com, where this rung got a real logged-in",
+    "profile view (2199 chars) that an anonymous fetch is refused.",
+    "This is the ONLY fetch rung this package ships, so a false rejection here",
+    "fails the whole call rather than dropping to something else. That asymmetry",
+    "is why the bar for rejecting is deliberately high. Drop your own provider",
+    "JSON into this directory to add a cheaper or anonymous rung ahead of it.",
+    "Observed but deliberately accepted: g2.com returns a 1330-char skip-links",
+    "stub after 62 seconds — thin, and uncomfortably close to the 90s timeout.",
+    "Known upstream bug (2026-08-09): a PDF URL exits 3 with a raw",
+    "`TargetClosedError` traceback, not the documented UnsupportedContentType",
+    "refusal, so the chain trace carries a Playwright stack instead of a sentence.",
+    "retries/retryWhen: measured 2026-08-09, PageBindTimeout ('timed out binding Playwright to session target ... no replacement page was created') fires intermittently on a healthy daemon and the CLI itself marks it retryable:true. With one rung per tool there is nothing to fall through to, so one retry here is the difference between a blip and a failed call. Scoped by retryWhen so a 404 or an auth wall is not retried."
+  ]
+}

package/verify.ts

@@ -0,0 +1,91 @@
+/**
+ * Live verification harness. Runs the real chains against real inputs without
+ * pi and without an LLM, so "does each rung actually work" is answerable
+ * cheaply — including the search rung, which no unit test can exercise because
+ * it needs a browser and the user's Chrome.
+ *
+ *   node verify.ts                              # fetch example.com + a canned search
+ *   node verify.ts https://example.com          # fetch a specific URL
+ *   node verify.ts --search "playwright aria"   # search a specific query
+ */
+
+import { makeExecutor, runChain } from "./core/chain.ts";
+import { EXTENSION_DIR, loadConfig, loadProviders } from "./core/config.ts";
+import { renderFailure, renderResults, renderSuccess } from "./core/format.ts";
+import { inspectSearch, inspectText, providersForRole } from "./core/predicates.ts";
+import type { SearchPayload } from "./core/types.ts";
+
+const config = loadConfig();
+const providers = loadProviders();
+
+const args = process.argv.slice(2);
+const searchAt = args.indexOf("--search");
+const query = searchAt >= 0 ? (args[searchAt + 1] ?? "playwright aria snapshot") : undefined;
+const url = searchAt >= 0 ? undefined : (args[0] ?? "https://example.com");
+
+console.log(`providers loaded: ${[...providers.keys()].join(", ")}`);
+console.log(`fetch order:  ${config.order.fetch.join(" → ")}`);
+console.log(`search order: ${config.order.search.join(" → ")}\n`);
+
+if (url !== undefined) {
+	console.log(`── fetch chain: ${url} ──`);
+	const chained = await runChain<string>({
+		providers,
+		config,
+		role: "fetch",
+		subject: url,
+		inspect: inspectText,
+		executor: makeExecutor<string>(config, { dir: EXTENSION_DIR, role: "fetch" }),
+		onAttempt: (provider) => console.log(`   trying ${provider.name}…`),
+	});
+	console.log(
+		chained.ok
+			? `${renderSuccess(chained, { url, maxBytes: config.maxBytes, maxLines: config.maxLines }).slice(0, 600)}\n`
+			: `${renderFailure(chained, url, { tool: "web_fetch", alternatives: [...providersForRole(providers, "fetch").keys()] })}\n`,
+	);
+
+	console.log("── each fetch provider in isolation ──");
+	for (const name of providersForRole(providers, "fetch").keys()) {
+		const forced = await runChain<string>({
+			providers,
+			config,
+			role: "fetch",
+			subject: url,
+			inspect: inspectText,
+			forced: name,
+			executor: makeExecutor<string>(config, { dir: EXTENSION_DIR, role: "fetch" }),
+		});
+		const attempt = forced.attempts.at(-1);
+		const ms = attempt ? `${(attempt.ms / 1000).toFixed(1)}s` : "-";
+		console.log(
+			forced.ok
+				? `✓ ${name.padEnd(22)} ${ms.padStart(6)}  ${forced.content?.length} chars (${forced.format})`
+				: `✗ ${name.padEnd(22)} ${ms.padStart(6)}  ${attempt?.reason}`,
+		);
+	}
+}
+
+if (query !== undefined) {
+	console.log(`── search chain: ${JSON.stringify(query)} ──`);
+	const searched = await runChain<SearchPayload>({
+		providers,
+		config,
+		role: "search",
+		subject: query,
+		inspect: inspectSearch,
+		executor: makeExecutor<SearchPayload>(config, {
+			dir: EXTENSION_DIR,
+			role: "search",
+			onProgress: (text) => console.log(`   ${text}`),
+		}),
+		onAttempt: (provider) => console.log(`   trying ${provider.name}…`),
+	});
+	console.log(
+		searched.ok
+			? renderResults(searched, query)
+			: renderFailure(searched, query, {
+					tool: "web_search",
+					alternatives: [...providersForRole(providers, "search").keys()],
+				}),
+	);
+}