@zenalexa/unicli 0.220.1 → 0.221.0

package/src/adapters/cipo/search.ts

@@ -0,0 +1,195 @@
+/**
+ * @owner       src::adapters::cipo::search
+ * @does        Browser-driven search of the Canadian Patents Database at cipo.ic.gc.ca/opic-cipo/cpd/eng/ — CIPO exposes no general open API for the patents corpus, so the browser route is the only programmatic surface.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cipo/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.search)
+ * @breaks      PATENT_UNSUPPORTED_QUERY (empty), PATENT_NOT_FOUND (empty result), PATENT_API_DEPRECATED with MCP_BUS_MISSING (no outbound MCP transport)
+ * @invariants  rows are canonical PatentRecord; source_adapter='cipo'
+ * @side-effects controls Chrome via MCP
+ * @perf        single navigate + evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cipo/search.test.ts
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import {
+  cipoEnvelope,
+  cipoNavigateAndExtract,
+  transportErrorToCipoEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cipo/search.ts";
+const CIPO_SEARCH_URL =
+  "https://cipo.ic.gc.ca/opic-cipo/cpd/eng/search/basic.html";
+
+interface CipoRow {
+  publication_number: string;
+  title?: string;
+  applicant?: string;
+  publication_date?: string;
+  source_url?: string;
+}
+
+const EXTRACTOR = `(() => {
+  const rows = Array.from(
+    document.querySelectorAll('table.results tr.result-row, .search-results .result')
+  ).map((el) => {
+    const text = (sel) => {
+      const node = el.querySelector(sel);
+      return node ? (node.textContent || '').trim() : '';
+    };
+    const linkEl = el.querySelector('a[href*="patent/"], a[href]');
+    return {
+      publication_number: text('.patent-number, td.patent-no, [data-field="patentNo"]'),
+      title: text('.patent-title, td.title, [data-field="title"]'),
+      applicant: text('.applicant-name, td.applicant, [data-field="applicant"]'),
+      publication_date: text('.publication-date, td.pubDate, [data-field="pubDate"]'),
+      source_url: linkEl ? linkEl.href : '',
+    };
+  });
+  return { rows };
+})()`;
+
+function buildSearchUrl(query: string): string {
+  const params = new URLSearchParams({ search: query });
+  return `${CIPO_SEARCH_URL}?${params.toString()}`;
+}
+
+export async function runCipoSearch(kwargs: {
+  query: string;
+  limit?: number;
+}): Promise<unknown[]> {
+  const limit =
+    typeof kwargs.limit === "number" && Number.isFinite(kwargs.limit)
+      ? Math.max(1, Math.min(100, Math.floor(kwargs.limit)))
+      : 25;
+  const query = String(kwargs.query ?? "").trim();
+  if (query.length === 0) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_UNSUPPORTED_QUERY",
+          ADAPTER_PATH,
+          "validate",
+          "cipo search requires a non-empty query",
+        ),
+      },
+    ];
+  }
+  const url = buildSearchUrl(query);
+  let extract: { rows: CipoRow[] };
+  try {
+    const result = await cipoNavigateAndExtract<{ rows: CipoRow[] }>(
+      url,
+      EXTRACTOR,
+    );
+    if (!result.data) {
+      return [
+        {
+          envelope: cipoEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "cipo evaluate returned no data; selector schema likely changed",
+          ),
+        },
+      ];
+    }
+    extract = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToCipoEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+  if (extract.rows.length === 0) {
+    return [
+      {
+        envelope: cipoEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "evaluate",
+          `cipo returned no rows for query "${query}"`,
+          ["uspto", "epo"],
+        ),
+      },
+    ];
+  }
+  const out: unknown[] = [];
+  for (const row of extract.rows.slice(0, limit)) {
+    if (!row.publication_number) continue;
+    const normalizedPub = /^CA[-]?/.test(row.publication_number)
+      ? row.publication_number
+      : `CA${row.publication_number}`;
+    try {
+      out.push(
+        assemblePatentRecord({
+          publication_number: normalizedPub,
+          title: row.title || undefined,
+          assignees: row.applicant
+            ? [{ name: row.applicant, country: "CA" }]
+            : undefined,
+          publication_date: row.publication_date || undefined,
+          source_adapter: "cipo",
+          source_url: row.source_url || url,
+        } as Parameters<typeof assemblePatentRecord>[0]),
+      );
+    } catch {
+      // Skip malformed rows.
+    }
+  }
+  if (out.length === 0) {
+    out.push({
+      envelope: cipoEnvelope(
+        "PATENT_NOT_FOUND",
+        ADAPTER_PATH,
+        "normalize",
+        "cipo returned rows but none carried a valid publication_number",
+        ["uspto"],
+      ),
+    });
+  }
+  return out;
+}
+
+cli({
+  site: "cipo",
+  name: "search",
+  description: "Search the Canadian Patents Database (CIPO, browser, no API)",
+  domain: "cipo.ic.gc.ca",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "query",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Free-text query — matched on title/abstract/applicant",
+    },
+    {
+      name: "limit",
+      type: "int",
+      default: 25,
+      description: "Max results (1-100)",
+    },
+  ],
+  columns: ["publication_number", "title", "publication_date", "source_url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "patent.search",
+  ],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCipoSearch(kwargs as { query: string; limit?: number }),
+});

package/src/adapters/cnipa/_shared.ts

@@ -0,0 +1,138 @@
+/**
+ * @owner       src::adapters::cnipa::_shared
+ * @does        Shared helpers for CNIPA browser-driven adapter commands — emits structured PATENT_BROWSER_CAPTCHA / MCP_BUS_MISSING / PATENT_NOT_FOUND error rows so adapters never synthesize results from a failed page.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/types/patent.ts
+ * @feeds       src/adapters/cnipa/search.ts, src/adapters/cnipa/get.ts, src/adapters/cnipa/legal-status.ts
+ * @breaks      none — pure helpers; bubble TransportError out to the registry func contract
+ * @invariants  every error path maps to a PatentEnvelope with adapter_path stamped; no silent fallbacks
+ * @side-effects none
+ * @perf        n/a
+ * @concurrency safe
+ * @test        covered transitively by src/adapters/cnipa/*.test.ts
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import {
+  TransportError,
+  initMcpBrowserTransport,
+  mcpBrowserEvaluate,
+  mcpBrowserNavigate,
+  type McpBrowserResult,
+} from "../../engine/transport/mcp-browser.js";
+import { buildPatentEnvelope } from "../../engine/normalizer/patent-envelope.js";
+import type { PatentEnvelope, PatentErrorCode } from "../../types/patent.js";
+
+export interface CnipaErrorRow {
+  publication_number: string;
+  title: string;
+  envelope: PatentEnvelope;
+}
+
+export function cnipaEnvelope(
+  code: PatentErrorCode,
+  adapter_path: string,
+  step: string,
+  suggestion: string,
+  alternatives: string[] = [],
+): PatentEnvelope {
+  return buildPatentEnvelope({
+    code,
+    adapter_path,
+    step,
+    suggestion,
+    alternatives,
+    retryable: code === "PATENT_BROWSER_CAPTCHA" ? true : false,
+  });
+}
+
+/**
+ * Wrap a TransportError from mcp-browser into a PatentEnvelope row.
+ * MCP_BUS_MISSING is the production state today — surfaced honestly so the
+ * agent's repair loop knows the engine is missing the outbound MCP transport.
+ */
+export function transportErrorToEnvelope(
+  err: TransportError,
+  adapter_path: string,
+  step: string,
+): PatentEnvelope {
+  if (err.code === "MCP_BUS_MISSING") {
+    return buildPatentEnvelope({
+      code: "PATENT_API_DEPRECATED",
+      adapter_path,
+      step,
+      suggestion:
+        "engine has no outbound MCP transport wired into the bus today; install an McpResolver via src/engine/transport/mcp-browser.installMcpResolver() before invoking this adapter, or try a non-browser source first",
+      alternatives: ["uspto", "epo", "lens"],
+      retryable: false,
+    });
+  }
+  return buildPatentEnvelope({
+    code: "PATENT_API_DEPRECATED",
+    adapter_path,
+    step,
+    suggestion: `mcp-browser transport error (${err.code}): ${err.message}`,
+    alternatives: ["uspto", "epo"],
+    retryable: false,
+  });
+}
+
+/**
+ * Navigate then evaluate a DOM-extraction expression. Returns the evaluate
+ * result on the happy path, or throws a TransportError with a structured
+ * code so callers map to a PatentEnvelope row.
+ *
+ * Adapters MUST treat the result as untrusted and validate shape before
+ * normalization — captcha pages tend to return zero-length arrays without
+ * throwing.
+ */
+export async function navigateAndExtract<T>(
+  url: string,
+  expression: string,
+): Promise<McpBrowserResult<T>> {
+  const init = await initMcpBrowserTransport();
+  if (init.active_server === "none") {
+    const code =
+      init.reason === "bus-missing" ? "MCP_BUS_MISSING" : "MCP_NO_SERVER";
+    throw new TransportError(code, `mcp-browser unavailable (${init.reason})`);
+  }
+  const navResult = await mcpBrowserNavigate({ url });
+  if (!navResult.ok) {
+    throw new TransportError(
+      navResult.code ?? "MCP_NAVIGATE_FAILED",
+      navResult.message ?? "navigate did not succeed",
+    );
+  }
+  const evalResult = await mcpBrowserEvaluate<T>({
+    expression,
+    tab: navResult.tab,
+  });
+  if (!evalResult.ok) {
+    throw new TransportError(
+      evalResult.code ?? "MCP_EVALUATE_FAILED",
+      evalResult.message ?? "evaluate did not succeed",
+    );
+  }
+  return evalResult;
+}
+
+/**
+ * Heuristic — CNIPA public-search captcha is a 验证码 iframe. When the
+ * evaluator returns a zero-length result array, the safest assumption is
+ * captcha; emit a structured envelope rather than a "no results" message
+ * the agent cannot disambiguate.
+ */
+export function looksLikeCaptcha(
+  rowCount: number,
+  htmlMarker?: string,
+): boolean {
+  if (rowCount > 0) return false;
+  if (!htmlMarker) return true; // empty result on a browser path = assume captcha
+  const lowered = htmlMarker.toLowerCase();
+  return (
+    lowered.includes("captcha") ||
+    lowered.includes("验证码") ||
+    lowered.includes("verifycode")
+  );
+}

package/src/adapters/cnipa/get.ts

@@ -0,0 +1,199 @@
+/**
+ * @owner       src::adapters::cnipa::get
+ * @does        Browser-driven retrieval of a single CNIPA patent document by publication number; loads the detail page through the mcp-browser transport and extracts the bibliographic fields into a PatentRecord.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cnipa/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.get)
+ * @breaks      emits PATENT_INVALID_NUMBER when input is empty or fails canonicalization; emits PATENT_NOT_FOUND when the detail page returns no fields; PATENT_BROWSER_CAPTCHA when the page is captcha-gated; PATENT_API_DEPRECATED with MCP_BUS_MISSING context when no outbound MCP transport is registered
+ * @invariants  output is a single PatentRecord row when the upstream answers; never falls back to a stub record
+ * @side-effects controls the user's Chrome via MCP
+ * @perf        single navigate + one evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cnipa/search.test.ts (transport-error path) — get-specific tests deferred to integration
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import { assemblePatentRecord } from "../../engine/normalizer/patent-envelope.js";
+import {
+  cnipaEnvelope,
+  looksLikeCaptcha,
+  navigateAndExtract,
+  transportErrorToEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cnipa/get.ts";
+const CNIPA_DETAIL_URL =
+  "https://pss-system.cponline.cnipa.gov.cn/conventionalDetail";
+
+interface CnipaDetail {
+  publication_number?: string;
+  application_number?: string;
+  title?: string;
+  abstract?: string;
+  applicant?: string;
+  inventor?: string;
+  publication_date?: string;
+  filing_date?: string;
+  grant_date?: string;
+  legal_status?: string;
+  source_url?: string;
+  html_marker?: string;
+}
+
+const DETAIL_EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('[data-field="pubNo"], .publication-number'),
+    application_number: text('[data-field="appNo"], .application-number'),
+    title: text('[data-field="title"], h1.title, .invention-title'),
+    abstract: text('[data-field="abstract"], .abstract'),
+    applicant: text('[data-field="applicant"], .applicant'),
+    inventor: text('[data-field="inventor"], .inventor'),
+    publication_date: text('[data-field="pubDate"], .publication-date'),
+    filing_date: text('[data-field="appDate"], .filing-date'),
+    grant_date: text('[data-field="grantDate"], .grant-date'),
+    legal_status: text('[data-field="legalStatus"], .legal-status'),
+    source_url: location.href,
+    html_marker: document.body && document.body.innerText
+      ? document.body.innerText.slice(0, 200)
+      : '',
+  };
+})()`;
+
+export async function runCnipaGet(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cnipa get requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = `${CNIPA_DETAIL_URL}?pubNo=${encodeURIComponent(pubNo)}`;
+  let detail: CnipaDetail;
+  try {
+    const result = await navigateAndExtract<CnipaDetail>(url, DETAIL_EXTRACTOR);
+    if (!result.data) {
+      return [
+        {
+          envelope: cnipaEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "mcp-browser evaluate returned no data; check selector schema in src/adapters/cnipa/get.ts",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+
+  // Captcha heuristic: detail page returned without any of the expected
+  // bibliographic fields → almost certainly captcha-gated.
+  const fieldCount = [
+    detail.publication_number,
+    detail.title,
+    detail.application_number,
+    detail.publication_date,
+  ].filter(Boolean).length;
+  if (looksLikeCaptcha(fieldCount, detail.html_marker)) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_BROWSER_CAPTCHA",
+          ADAPTER_PATH,
+          "evaluate",
+          "CNIPA detail page returned no bibliographic fields; solve the 验证码 in the open browser tab and re-run",
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+
+  const canonicalPubNo = detail.publication_number || pubNo;
+  try {
+    return [
+      assemblePatentRecord({
+        publication_number: canonicalPubNo,
+        application_number: detail.application_number || undefined,
+        title: detail.title || undefined,
+        abstract: detail.abstract || undefined,
+        assignees: detail.applicant
+          ? [{ name: detail.applicant, country: "CN" }]
+          : undefined,
+        inventors: detail.inventor
+          ? [{ name: detail.inventor, country: "CN" }]
+          : undefined,
+        publication_date: detail.publication_date || undefined,
+        filing_date: detail.filing_date || undefined,
+        grant_date: detail.grant_date || undefined,
+        legal_status: detail.legal_status || undefined,
+        source_adapter: "cnipa",
+        source_url: detail.source_url || url,
+      } as Parameters<typeof assemblePatentRecord>[0]),
+    ];
+  } catch {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "normalize",
+          `cnipa detail page did not yield a valid publication_number for "${pubNo}"`,
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+}
+
+cli({
+  site: "cnipa",
+  name: "get",
+  description: "Retrieve a single CNIPA patent document by publication number",
+  domain: "pss-system.cponline.cnipa.gov.cn",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "ST.16 publication number (e.g. CN114123456A)",
+    },
+  ],
+  columns: [
+    "publication_number",
+    "title",
+    "publication_date",
+    "legal_status",
+    "source_url",
+  ],
+  capabilities: ["mcp-browser.navigate", "mcp-browser.evaluate", "patent.get"],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCnipaGet(kwargs as { publication_number: string }),
+});

package/src/adapters/cnipa/legal-status.ts

@@ -0,0 +1,162 @@
+/**
+ * @owner       src::adapters::cnipa::legal-status
+ * @does        Browser-driven CNIPA legal-status lookup — scrapes the prosecution timeline + grant status from the 公众查询 detail page; emits structured envelopes for captcha / not-found / MCP-bus gaps.
+ * @needs       src/engine/transport/mcp-browser.ts, src/engine/normalizer/patent-envelope.ts, src/adapters/cnipa/_shared.ts, src/registry.ts
+ * @feeds       src/commands/patent.ts (capability tag patent.legal-status)
+ * @breaks      emits PATENT_INVALID_NUMBER, PATENT_BROWSER_CAPTCHA, PATENT_API_DEPRECATED (with MCP_BUS_MISSING context); never synthesizes a status
+ * @invariants  output row carries `legal_status` exactly as scraped; no normalization beyond trim
+ * @side-effects controls Chrome via MCP
+ * @perf        single navigate + evaluate
+ * @concurrency safe
+ * @test        tests/unit/adapters/cnipa/search.test.ts (shared transport-error path)
+ * @stability   experimental
+ * @since       2026-05-18
+ * @verification browser-only
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { TransportError } from "../../engine/transport/mcp-browser.js";
+import {
+  cnipaEnvelope,
+  looksLikeCaptcha,
+  navigateAndExtract,
+  transportErrorToEnvelope,
+} from "./_shared.js";
+
+const ADAPTER_PATH = "src/adapters/cnipa/legal-status.ts";
+const CNIPA_LEGAL_URL = "https://pss-system.cponline.cnipa.gov.cn/legalStatus";
+
+interface CnipaLegalRow {
+  publication_number: string;
+  legal_status?: string;
+  status_date?: string;
+  source_url?: string;
+  html_marker?: string;
+}
+
+const EXTRACTOR = `(() => {
+  const text = (sel) => {
+    const node = document.querySelector(sel);
+    return node ? (node.textContent || '').trim() : '';
+  };
+  return {
+    publication_number: text('[data-field="pubNo"], .publication-number'),
+    legal_status: text('[data-field="legalStatus"], .legal-status'),
+    status_date: text('[data-field="statusDate"], .status-date'),
+    source_url: location.href,
+    html_marker: document.body && document.body.innerText
+      ? document.body.innerText.slice(0, 200)
+      : '',
+  };
+})()`;
+
+export async function runCnipaLegalStatus(kwargs: {
+  publication_number: string;
+}): Promise<unknown[]> {
+  const pubNo = String(kwargs.publication_number ?? "").trim();
+  if (pubNo.length === 0) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_INVALID_NUMBER",
+          ADAPTER_PATH,
+          "validate",
+          "cnipa legal-status requires a non-empty publication_number",
+        ),
+      },
+    ];
+  }
+  const url = `${CNIPA_LEGAL_URL}?pubNo=${encodeURIComponent(pubNo)}`;
+  let detail: CnipaLegalRow;
+  try {
+    const result = await navigateAndExtract<CnipaLegalRow>(url, EXTRACTOR);
+    if (!result.data) {
+      return [
+        {
+          envelope: cnipaEnvelope(
+            "PATENT_SCHEMA_DRIFT",
+            ADAPTER_PATH,
+            "evaluate",
+            "mcp-browser evaluate returned no data",
+          ),
+        },
+      ];
+    }
+    detail = result.data;
+  } catch (err) {
+    if (err instanceof TransportError) {
+      return [
+        {
+          envelope: transportErrorToEnvelope(err, ADAPTER_PATH, "navigate"),
+        },
+      ];
+    }
+    throw err;
+  }
+  const fieldCount = [detail.publication_number, detail.legal_status].filter(
+    Boolean,
+  ).length;
+  if (looksLikeCaptcha(fieldCount, detail.html_marker)) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_BROWSER_CAPTCHA",
+          ADAPTER_PATH,
+          "evaluate",
+          "CNIPA legal-status page returned no fields; solve the 验证码 and re-run",
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+  if (!detail.legal_status) {
+    return [
+      {
+        envelope: cnipaEnvelope(
+          "PATENT_NOT_FOUND",
+          ADAPTER_PATH,
+          "normalize",
+          `cnipa returned no legal_status for "${pubNo}"`,
+          ["espacenet"],
+        ),
+      },
+    ];
+  }
+  return [
+    {
+      publication_number: detail.publication_number || pubNo,
+      legal_status: detail.legal_status,
+      status_date: detail.status_date,
+      source_adapter: "cnipa",
+      source_url: detail.source_url || url,
+      retrieved_at: new Date().toISOString(),
+    },
+  ];
+}
+
+cli({
+  site: "cnipa",
+  name: "legal-status",
+  description: "CNIPA legal-status / prosecution timeline lookup (browser)",
+  domain: "pss-system.cponline.cnipa.gov.cn",
+  strategy: Strategy.PUBLIC,
+  adapter_path: ADAPTER_PATH,
+  args: [
+    {
+      name: "publication_number",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "ST.16 publication number",
+    },
+  ],
+  columns: ["publication_number", "legal_status", "status_date", "source_url"],
+  capabilities: [
+    "mcp-browser.navigate",
+    "mcp-browser.evaluate",
+    "patent.legal-status",
+  ],
+  minimum_capability: "mcp-browser.evaluate",
+  func: async (_page, kwargs) =>
+    runCnipaLegalStatus(kwargs as { publication_number: string }),
+});