@zenalexa/unicli 0.220.1 → 0.221.0

package/src/adapters/google-patents-web/_shared.ts

@@ -0,0 +1,242 @@
+/**
+ * @owner       src::adapters::google-patents-web::_shared
+ * @does        Shared HTTP helpers and types for the KEYLESS Google Patents web adapter — distinct from the BigQuery-backed google-patents-bq adapter (which requires a billed GCP project). This adapter uses the public XHR endpoint that drives patents.google.com and the SSR /patent/<id>/en bibliography page, both of which are reachable with only a real-browser User-Agent header.
+ * @needs       src/engine/normalizer/patent-envelope.ts, src/types/patent.ts, node:fetch (global)
+ * @feeds       src/adapters/google-patents-web/search.yaml, src/adapters/google-patents-web/get.ts
+ * @breaks      throws GooglePatentsHttpError when the endpoint returns non-2xx or unparseable JSON; callers surface PATENT_API_DEPRECATED to the meta-command
+ * @invariants  every outbound request carries a real-browser User-Agent — Google rejects bare `node-fetch`/`python-requests`; the @keyless-best-effort verification tag is emitted in adapter file headers
+ * @side-effects HTTPS egress to patents.google.com only; no env reads, no cookies
+ * @perf        single request per call; XHR responses are ~40-100 KB
+ * @concurrency safe — pure functions plus stateless `fetch`
+ * @test        covered transitively via tests/unit/adapters/google-patents-web/*.test.ts (none yet — adapters ship with live verification proof in docs/skills/patent-cookbook.md)
+ * @stability   experimental — Google does not publish a stability contract for this XHR
+ * @since       2026-05-18
+ * @verification keyless-best-effort
+ */
+
+import type { PatentRecord } from "../../types/patent.js";
+
+/**
+ * Local verification-status alias for the keyless-web adapter family.
+ *
+ * Distinct from the canonical `PatentVerificationStatus` union in
+ * `src/types/patent.ts` — adding a new variant there is owned by another
+ * agent in this batch, so we expose it as a *local* string-literal type
+ * alias the file headers can advertise without forcing a cross-cutting
+ * type change. The meta-command does not branch on this value; it is
+ * documentation-grade only.
+ */
+export type KeylessBestEffortStatus = "keyless-best-effort";
+export const KEYLESS_BEST_EFFORT: KeylessBestEffortStatus =
+  "keyless-best-effort";
+
+/**
+ * Real-browser User-Agent string. Google's XHR endpoint returns 403 for the
+ * default `node/undici` UA; a Chrome string fixes that. Mirror the version
+ * Chrome currently ships rather than freezing on an old number so the header
+ * stays plausible if Google starts UA-version-gating in future.
+ */
+export const GOOGLE_PATENTS_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36";
+
+export class GooglePatentsHttpError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly url: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "GooglePatentsHttpError";
+  }
+}
+
+/**
+ * GET <url> with a real-browser UA. Returns parsed JSON; throws
+ * GooglePatentsHttpError on non-2xx or JSON parse failure.
+ */
+export async function fetchGooglePatentsJson<T>(url: string): Promise<T> {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "User-Agent": GOOGLE_PATENTS_UA,
+      Accept: "application/json",
+    },
+  });
+  if (!response.ok) {
+    throw new GooglePatentsHttpError(
+      response.status,
+      url,
+      `Google Patents XHR returned HTTP ${response.status}`,
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = await response.json();
+  } catch (err) {
+    throw new GooglePatentsHttpError(
+      response.status,
+      url,
+      `Google Patents XHR returned non-JSON body: ${(err as Error).message}`,
+    );
+  }
+  return parsed as T;
+}
+
+/**
+ * GET <url> with a real-browser UA, return raw HTML text. Throws
+ * GooglePatentsHttpError on non-2xx.
+ */
+export async function fetchGooglePatentsHtml(url: string): Promise<string> {
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "User-Agent": GOOGLE_PATENTS_UA,
+      Accept: "text/html,application/xhtml+xml",
+    },
+  });
+  if (!response.ok) {
+    throw new GooglePatentsHttpError(
+      response.status,
+      url,
+      `Google Patents detail page returned HTTP ${response.status}`,
+    );
+  }
+  return await response.text();
+}
+
+/**
+ * Build the public XHR query URL. Accepts a plain free-text query string and
+ * an optional limit (`num` parameter) and earliest-publication-year filter.
+ *
+ * The XHR endpoint expects a percent-encoded *inner* query string under the
+ * `url` parameter — the outer query is `?url=q%3Dfoo&exp=`. We percent-encode
+ * the inner once.
+ */
+export function buildGooglePatentsXhrUrl(
+  query: string,
+  limit?: number,
+  sinceYear?: string,
+): string {
+  const cleaned = query.trim();
+  let inner = `q=${cleaned.replace(/\s+/g, "+")}`;
+  if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
+    inner += `&num=${Math.min(100, Math.max(1, Math.floor(limit)))}`;
+  }
+  if (sinceYear && /^\d{4}$/.test(sinceYear)) {
+    inner += `&after=publication:${sinceYear}0101`;
+  }
+  return `https://patents.google.com/xhr/query?url=${encodeURIComponent(inner)}&exp=`;
+}
+
+/**
+ * Build the public detail page URL for a given publication number. Google
+ * accepts the segmented form `US-11741188-B2` and the compact form
+ * `US11741188B2`; we send the compact form to keep the URL short.
+ */
+export function buildGooglePatentsDetailUrl(pubNo: string): string {
+  const compact = pubNo.replace(/-/g, "").toUpperCase();
+  return `https://patents.google.com/patent/${encodeURIComponent(compact)}/en`;
+}
+
+/**
+ * XHR response shape. We intentionally type only the fields we read —
+ * Google ships many more (figure thumbnails, family metadata, language) that
+ * we either ignore or carry through verbatim in `raw`.
+ */
+export interface GoogleXhrResultRow {
+  id: string;
+  rank?: number;
+  patent?: {
+    title?: string;
+    snippet?: string;
+    publication_number?: string;
+    inventor?: string;
+    assignee?: string;
+    filing_date?: string;
+    publication_date?: string;
+    grant_date?: string;
+    priority_date?: string;
+    language?: string;
+  };
+}
+
+export interface GoogleXhrResponse {
+  results?: {
+    cluster?: Array<{ result?: GoogleXhrResultRow[] }>;
+    total_num_results?: number;
+  };
+}
+
+/**
+ * Flatten the nested `results.cluster[].result[]` into a single array, in
+ * server-supplied order.
+ */
+export function flattenGoogleXhrResults(
+  body: GoogleXhrResponse,
+): GoogleXhrResultRow[] {
+  const clusters = body.results?.cluster ?? [];
+  const out: GoogleXhrResultRow[] = [];
+  for (const cluster of clusters) {
+    const rows = cluster.result ?? [];
+    for (const row of rows) out.push(row);
+  }
+  return out;
+}
+
+/**
+ * Project a single XHR row to the upstream-facing partial-PatentRecord
+ * shape. Empty / missing fields are left undefined rather than synthesised.
+ * Snippets contain HTML markup (e.g. `<b>` tags) which we strip.
+ */
+export function projectGoogleRowToRecord(
+  row: GoogleXhrResultRow,
+  sourceUrl: string,
+): Partial<PatentRecord> & {
+  publication_number: string;
+  source_adapter: string;
+} {
+  const patent = row.patent ?? {};
+  const pubNo =
+    (typeof patent.publication_number === "string" &&
+      patent.publication_number) ||
+    deriveCanonicalFromId(row.id);
+  const cleanSnippet = patent.snippet ? stripHtml(patent.snippet) : undefined;
+  return {
+    publication_number: pubNo,
+    title: patent.title ? patent.title.trim() : undefined,
+    abstract: cleanSnippet,
+    inventors: patent.inventor ? [{ name: patent.inventor.trim() }] : undefined,
+    assignees: patent.assignee ? [{ name: patent.assignee.trim() }] : undefined,
+    filing_date: patent.filing_date || undefined,
+    publication_date: patent.publication_date || undefined,
+    grant_date: patent.grant_date || undefined,
+    priority_date: patent.priority_date || undefined,
+    source_adapter: "google-patents-web",
+    source_url: sourceUrl,
+  };
+}
+
+/** `patent/US11741188B2/en` → `US11741188B2`. */
+function deriveCanonicalFromId(id: string): string {
+  const match = /patent\/([^/]+)/.exec(id);
+  return match ? match[1] : id;
+}
+
+const TAG_RE = /<[^>]+>/g;
+const ENTITY_MAP: Record<string, string> = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&hellip;": "…",
+  "&nbsp;": " ",
+};
+
+export function stripHtml(input: string): string {
+  return input
+    .replace(TAG_RE, "")
+    .replace(/&(?:amp|lt|gt|quot|#39|hellip|nbsp);/g, (m) => ENTITY_MAP[m] ?? m)
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/src/adapters/google-patents-web/get.ts

@@ -0,0 +1,224 @@
+/**
+ * @owner       src::adapters::google-patents-web::get
+ * @does        Keyless single-publication detail fetch — parses the SSR meta-tag and `<abstract>` block on https://patents.google.com/patent/<id>/en using regex projection (no DOM, no Chrome).
+ * @needs       src/adapters/google-patents-web/_shared.ts, src/engine/normalizer/patent-envelope.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.get)
+ * @breaks      PATENT_NOT_FOUND when the detail page returns 200 but carries no DC.title; PATENT_INVALID_NUMBER for empty input; PATENT_API_DEPRECATED on non-2xx HTTP
+ * @invariants  output is a single canonical PatentRecord; abstract whitespace is normalised; HTML entities decoded; source_url is the literal page we hit
+ * @side-effects HTTPS egress to patents.google.com only
+ * @perf        single page load (~350 KB); regex parse is linear in document length
+ * @concurrency safe — stateless
+ * @test        verification proof in docs/skills/patent-cookbook.md
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification keyless-best-effort
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import { buildPatentEnvelope } from "../../engine/normalizer/patent-envelope.js";
+import {
+  GooglePatentsHttpError,
+  buildGooglePatentsDetailUrl,
+  fetchGooglePatentsHtml,
+  stripHtml,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/google-patents-web/get.ts";
+
+interface DetailPageFields {
+  title?: string;
+  abstract?: string;
+  inventors: string[];
+  assignees: string[];
+  filing_date?: string;
+  publication_date?: string;
+  application_number?: string;
+}
+
+function extractMetaContent(html: string, name: string): string[] {
+  const out: string[] = [];
+  const re = new RegExp(
+    `<meta[^>]+name=["']${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'][^>]*content=["']([^"']*)["']`,
+    "gi",
+  );
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(html)) !== null) {
+    if (match[1]) out.push(match[1].trim());
+  }
+  return out;
+}
+
+/**
+ * Parse the Google Patents detail HTML into the subset of fields we surface
+ * on PatentRecord. The DC.* meta tags are the documented machine-readable
+ * surface (Dublin Core), and citation_* mirrors what Google Scholar's
+ * indexing crawler consumes.
+ */
+export function parseGooglePatentsDetail(html: string): DetailPageFields {
+  const titleRaw =
+    extractMetaContent(html, "DC.title")[0] ??
+    extractMetaContent(html, "citation_title")[0];
+  const dcDates = extractMetaContent(html, "DC.date");
+  const dcContributors = extractMetaContent(html, "DC.contributor");
+
+  // DC.date is emitted twice on Google Patents: filing then publication.
+  const filingDate = dcDates[0];
+  const publicationDate = dcDates[1];
+
+  // DC.contributor mixes inventors (personal names) and assignees (org
+  // names). Google's convention is inventors first, the assignee last —
+  // approximate that, with the last-item-is-assignee heuristic.
+  const inventors: string[] = [];
+  let assignee: string | undefined;
+  if (dcContributors.length > 0) {
+    assignee = dcContributors[dcContributors.length - 1];
+    for (let i = 0; i < dcContributors.length - 1; i++) {
+      inventors.push(dcContributors[i]);
+    }
+  }
+
+  const applicationNumber = extractMetaContent(
+    html,
+    "citation_patent_application_number",
+  )[0];
+
+  // The bibliographic abstract sits in a single `<abstract …>...</abstract>`
+  // element. Use a non-greedy match because some pages embed multiple
+  // localised abstracts; we want the first.
+  let abstractText: string | undefined;
+  const abstractMatch = /<abstract\b[^>]*>([\s\S]*?)<\/abstract>/i.exec(html);
+  if (abstractMatch) {
+    const cleaned = stripHtml(abstractMatch[1]);
+    if (cleaned.length > 0) abstractText = cleaned;
+  }
+
+  return {
+    title: titleRaw ? titleRaw.trim() : undefined,
+    abstract: abstractText,
+    inventors,
+    assignees: assignee ? [assignee] : [],
+    filing_date: filingDate,
+    publication_date: publicationDate,
+    application_number: applicationNumber,
+  };
+}
+
+export async function runGooglePatentsWebGet(kwargs: {
+  publication_number?: unknown;
+}): Promise<unknown[]> {
+  const raw = String(kwargs.publication_number ?? "").trim();
+  if (raw.length === 0) {
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_INVALID_NUMBER",
+          adapter_path: ADAPTER_PATH,
+          step: "validate",
+          suggestion:
+            "google-patents-web get requires a publication_number (e.g. US11741188B2)",
+        }),
+      },
+    ];
+  }
+  const url = buildGooglePatentsDetailUrl(raw);
+  let html: string;
+  try {
+    html = await fetchGooglePatentsHtml(url);
+  } catch (err) {
+    if (err instanceof GooglePatentsHttpError) {
+      return [
+        {
+          envelope: buildPatentEnvelope({
+            code:
+              err.status === 404 ? "PATENT_NOT_FOUND" : "PATENT_API_DEPRECATED",
+            adapter_path: ADAPTER_PATH,
+            step: "fetch",
+            suggestion: `Google Patents detail page returned HTTP ${err.status}; verify the publication number or retry against --sources espacenet`,
+            alternatives: ["espacenet", "freepatentsonline-web"],
+          }),
+        },
+      ];
+    }
+    throw err;
+  }
+  const detail = parseGooglePatentsDetail(html);
+  if (!detail.title) {
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_NOT_FOUND",
+          adapter_path: ADAPTER_PATH,
+          step: "select",
+          suggestion: `google-patents-web detail page for "${raw}" yielded no DC.title meta tag`,
+          alternatives: ["espacenet", "freepatentsonline-web"],
+        }),
+      },
+    ];
+  }
+  try {
+    return [
+      assemblePatentRecord({
+        publication_number: raw,
+        application_number: detail.application_number || undefined,
+        title: detail.title,
+        abstract: detail.abstract,
+        inventors:
+          detail.inventors.length > 0
+            ? detail.inventors.map((name) => ({ name }))
+            : undefined,
+        assignees:
+          detail.assignees.length > 0
+            ? detail.assignees.map((name) => ({ name }))
+            : undefined,
+        filing_date: detail.filing_date,
+        publication_date: detail.publication_date,
+        source_adapter: "google-patents-web",
+        source_url: url,
+      } as Parameters<typeof assemblePatentRecord>[0]),
+    ];
+  } catch {
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_NOT_FOUND",
+          adapter_path: ADAPTER_PATH,
+          step: "normalize",
+          suggestion: `google-patents-web detail page for "${raw}" did not yield a canonicalisable publication_number`,
+          alternatives: ["espacenet"],
+        }),
+      },
+    ];
+  }
+}
+
+cli({
+  site: "google-patents-web",
+  name: "get",
+  description:
+    "Retrieve a single Google Patents bibliographic record (keyless, no Chrome)",
+  domain: "patents.google.com",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description:
+        "ST.16 publication number, compact or segmented (e.g. US11741188B2 or US-11741188-B2)",
+    },
+  ],
+  columns: [
+    "publication_number",
+    "title",
+    "publication_date",
+    "assignees",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "patent.get"],
+  minimum_capability: "http.fetch",
+  func: async (_page, kwargs) =>
+    runGooglePatentsWebGet(kwargs as { publication_number?: unknown }),
+});

package/src/adapters/google-patents-web/search.ts

@@ -0,0 +1,196 @@
+/**
+ * @owner       src::adapters::google-patents-web::search
+ * @does        Keyless free-text patent search via the public XHR endpoint that drives patents.google.com — distinct from src/adapters/google-patents-bq which talks to BigQuery and needs a billed GCP project.
+ * @needs       src/adapters/google-patents-web/_shared.ts, src/engine/normalizer/patent-envelope.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.search)
+ * @breaks      PATENT_API_DEPRECATED with status code embedded when the XHR returns non-2xx (typically 403 → suspected UA gating); PATENT_NOT_FOUND on empty result; PATENT_SCHEMA_DRIFT when the JSON shape no longer carries results.cluster[].result[]
+ * @invariants  output rows are canonical PatentRecord; source_adapter='google-patents-web'; results are server-ordered (Google's relevance ranking)
+ * @side-effects HTTPS egress to patents.google.com only — no env reads, no cookies, no auth
+ * @perf        single XHR request, ~40-100 KB; results capped at min(limit, 100) per call
+ * @concurrency safe — stateless
+ * @test        verification proof captured in docs/skills/patent-cookbook.md (recipe: day-zero search)
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification keyless-best-effort — Google does not publish a stability contract for this XHR; we live-call it from the same User-Agent the public site uses
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import { buildPatentEnvelope } from "../../engine/normalizer/patent-envelope.js";
+import {
+  GooglePatentsHttpError,
+  buildGooglePatentsXhrUrl,
+  fetchGooglePatentsJson,
+  flattenGoogleXhrResults,
+  projectGoogleRowToRecord,
+  type GoogleXhrResponse,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/google-patents-web/search.ts";
+
+interface SearchArgs {
+  query?: unknown;
+  limit?: unknown;
+  since?: unknown;
+}
+
+function clampLimit(raw: unknown): number {
+  const num = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(num) || num <= 0) return 25;
+  return Math.min(100, Math.max(1, Math.floor(num)));
+}
+
+function normaliseSince(raw: unknown): string | undefined {
+  if (typeof raw !== "string") return undefined;
+  const trimmed = raw.trim();
+  return /^\d{4}$/.test(trimmed) ? trimmed : undefined;
+}
+
+export async function runGooglePatentsWebSearch(
+  kwargs: SearchArgs,
+): Promise<unknown[]> {
+  const query = String(kwargs.query ?? "").trim();
+  if (query.length === 0) {
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_UNSUPPORTED_QUERY",
+          adapter_path: ADAPTER_PATH,
+          step: "validate",
+          suggestion: "google-patents-web search requires a non-empty query",
+          alternatives: ["freepatentsonline-web"],
+        }),
+      },
+    ];
+  }
+  const limit = clampLimit(kwargs.limit);
+  const since = normaliseSince(kwargs.since);
+  const url = buildGooglePatentsXhrUrl(query, limit, since);
+
+  let body: GoogleXhrResponse;
+  try {
+    body = await fetchGooglePatentsJson<GoogleXhrResponse>(url);
+  } catch (err) {
+    if (err instanceof GooglePatentsHttpError) {
+      return [
+        {
+          envelope: buildPatentEnvelope({
+            code:
+              err.status === 429
+                ? "PATENT_RATE_LIMIT"
+                : err.status === 403
+                  ? "PATENT_REGION_BLOCKED"
+                  : "PATENT_API_DEPRECATED",
+            adapter_path: ADAPTER_PATH,
+            step: "fetch",
+            suggestion: `Google Patents XHR returned HTTP ${err.status} for ${err.url}; retry with --sources freepatentsonline-web, or check if Google now requires a session cookie`,
+            alternatives: ["freepatentsonline-web", "espacenet"],
+            retryable: err.status === 429,
+          }),
+        },
+      ];
+    }
+    throw err;
+  }
+
+  const rows = flattenGoogleXhrResults(body);
+  if (rows.length === 0) {
+    if (!body.results || !Array.isArray(body.results.cluster)) {
+      return [
+        {
+          envelope: buildPatentEnvelope({
+            code: "PATENT_SCHEMA_DRIFT",
+            adapter_path: ADAPTER_PATH,
+            step: "select",
+            suggestion:
+              "Google Patents XHR no longer carries results.cluster[].result[]; the adapter's flattenGoogleXhrResults projection needs updating",
+            alternatives: ["freepatentsonline-web"],
+          }),
+        },
+      ];
+    }
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_NOT_FOUND",
+          adapter_path: ADAPTER_PATH,
+          step: "select",
+          suggestion: `google-patents-web returned no rows for "${query}"`,
+          alternatives: ["freepatentsonline-web", "espacenet"],
+        }),
+      },
+    ];
+  }
+
+  const out: unknown[] = [];
+  for (const row of rows.slice(0, limit)) {
+    const partial = projectGoogleRowToRecord(row, url);
+    if (!partial.publication_number) continue;
+    try {
+      out.push(
+        assemblePatentRecord(
+          partial as Parameters<typeof assemblePatentRecord>[0],
+        ),
+      );
+    } catch {
+      // Rows whose publication_number cannot be canonicalised are skipped
+      // rather than synthesised — we never invent ST.16 fields.
+    }
+  }
+  if (out.length === 0) {
+    return [
+      {
+        envelope: buildPatentEnvelope({
+          code: "PATENT_NOT_FOUND",
+          adapter_path: ADAPTER_PATH,
+          step: "normalize",
+          suggestion: `google-patents-web returned ${rows.length} rows but none carried a canonicalisable publication_number`,
+          alternatives: ["freepatentsonline-web", "espacenet"],
+        }),
+      },
+    ];
+  }
+  return out;
+}
+
+cli({
+  site: "google-patents-web",
+  name: "search",
+  description:
+    "Keyless Google Patents search via the public XHR endpoint (no API key, no Chrome required)",
+  domain: "patents.google.com",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Free-text query (Google Patents smart-search syntax)",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 25,
+      description: "Max results to return (1-100)",
+    },
+    {
+      name: "since",
+      type: "str",
+      description:
+        "Earliest publication year (YYYY); translated to after:publication:YYYY0101",
+    },
+  ],
+  columns: [
+    "publication_number",
+    "title",
+    "publication_date",
+    "assignees",
+    "source_url",
+  ],
+  capabilities: ["http.fetch", "patent.search"],
+  minimum_capability: "http.fetch",
+  func: async (_page, kwargs) =>
+    runGooglePatentsWebSearch(kwargs as SearchArgs),
+});