@wentorai/research-plugins 1.3.2 → 1.4.0

package/src/tools/arxiv.ts

@@ -1,43 +1,65 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
 
 const BASE = "https://export.arxiv.org/api/query";
 
-function parseArxivXml(xml: string) {
+/**
+ * Parse arXiv Atom XML response into structured paper objects.
+ *
+ * Uses regex-based extraction (arXiv returns Atom 1.0 XML).
+ * Handles edge cases: namespace prefixes, missing fields, HTML error pages.
+ */
+function parseArxivXml(xml: string): Record<string, unknown>[] {
+  // Guard: if arXiv returned an error page (HTML) or empty response
+  if (!xml || !xml.includes("<entry>")) return [];
+
   const entries: Record<string, unknown>[] = [];
-  const entryBlocks = xml.split("<entry>").slice(1);
 
-  for (const block of entryBlocks) {
-    const getText = (tag: string) => {
+  // Use regex to extract <entry>...</entry> blocks robustly
+  const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
+  let entryMatch: RegExpExecArray | null;
+
+  while ((entryMatch = entryRegex.exec(xml)) !== null) {
+    const block = entryMatch[1];
+
+    const getText = (tag: string): string => {
+      // Match tags with or without namespace prefixes and attributes
       const m = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
       return m ? m[1].trim() : "";
     };
 
-    const getAll = (tag: string) => {
+    const getAll = (tag: string): string[] => {
       const results: string[] = [];
       const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "g");
-      let m;
+      let m: RegExpExecArray | null;
       while ((m = re.exec(block)) !== null) results.push(m[1].trim());
       return results;
     };
 
-    const getAttr = (tag: string, attr: string) => {
-      const m = block.match(new RegExp(`<${tag}[^>]*${attr}="([^"]*)"[^>]*/?>`, "g"));
-      return m
-        ? m.map((s) => {
-            const am = s.match(new RegExp(`${attr}="([^"]*)"`));
-            return am ? am[1] : "";
-          })
-        : [];
+    const getAttr = (tag: string, attr: string): string[] => {
+      const results: string[] = [];
+      const re = new RegExp(`<${tag}[^>]*?${attr}="([^"]*)"[^>]*/?>`, "g");
+      let m: RegExpExecArray | null;
+      while ((m = re.exec(block)) !== null) {
+        if (m[1]) results.push(m[1]);
+      }
+      return results;
     };
 
-    const id = getText("id");
-    const arxivId = id.replace("http://arxiv.org/abs/", "").replace(/v\d+$/, "");
+    const rawId = getText("id");
+    if (!rawId) continue; // skip malformed entries
+
+    const arxivId = rawId
+      .replace(/https?:\/\/arxiv\.org\/abs\//, "")
+      .replace(/v\d+$/, "");
+
+    const title = getText("title").replace(/\s+/g, " ");
+    if (!title) continue; // skip entries without title
 
     entries.push({
       arxiv_id: arxivId,
-      title: getText("title").replace(/\s+/g, " "),
+      title,
       summary: getText("summary").replace(/\s+/g, " "),
       authors: getAll("name"),
       published: getText("published"),
@@ -45,8 +67,8 @@ function parseArxivXml(xml: string) {
       categories: getAttr("category", "term"),
       pdf_url: `https://arxiv.org/pdf/${arxivId}`,
       abs_url: `https://arxiv.org/abs/${arxivId}`,
-      doi: getText("arxiv:doi"),
-      comment: getText("arxiv:comment"),
+      doi: getText("arxiv:doi") || undefined,
+      comment: getText("arxiv:comment") || undefined,
     });
   }
 
@@ -62,7 +84,7 @@ export function createArxivTools(
       name: "search_arxiv",
       label: "Search Papers (arXiv)",
       description:
-        "Search arXiv preprint repository. Covers physics, math, CS, biology, quantitative finance, statistics, and more.",
+        "Search arXiv preprint repository. Covers physics, math, CS, biology, quantitative finance, statistics, and more. All results are open access.",
       parameters: Type.Object({
         query: Type.String({
           description:
@@ -94,9 +116,17 @@ export function createArxivTools(
           sortOrder: input.sort_order ?? "descending",
         });
 
-        const res = await fetch(`${BASE}?${params}`);
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const xml = await res.text();
+        const tracked = await trackedFetch("arxiv", `${BASE}?${params}`, undefined, 15_000);
+        if (isTrackedError(tracked)) return tracked;
+        const xml = await tracked.res.text();
+
+        // Check if response is actually XML (not HTML error page)
+        if (!xml.includes("<feed")) {
+          return toolResult({
+            error: "arXiv returned non-XML response (possibly rate-limited or error page)",
+            _source_health: { source: "arxiv", latency_ms: tracked.latency_ms },
+          });
+        }
 
         const totalMatch = xml.match(
           /<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/,
@@ -106,6 +136,7 @@ export function createArxivTools(
         return toolResult({
           total_results: total,
           papers: parseArxivXml(xml),
+          _source_health: { source: "arxiv", latency_ms: tracked.latency_ms },
         });
       },
     },
@@ -120,14 +151,31 @@ export function createArxivTools(
         }),
       }),
       execute: async (input: { arxiv_id: string }) => {
-        const id = input.arxiv_id.replace("arXiv:", "");
+        const id = input.arxiv_id.replace("arXiv:", "").replace(/https?:\/\/arxiv\.org\/abs\//, "");
         const params = new URLSearchParams({ id_list: id });
-        const res = await fetch(`${BASE}?${params}`);
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const xml = await res.text();
+
+        const tracked = await trackedFetch("arxiv", `${BASE}?${params}`, undefined, 15_000);
+        if (isTrackedError(tracked)) return tracked;
+        const xml = await tracked.res.text();
+
+        if (!xml.includes("<feed")) {
+          return toolResult({
+            error: "arXiv returned non-XML response",
+            _source_health: { source: "arxiv", latency_ms: tracked.latency_ms },
+          });
+        }
+
         const papers = parseArxivXml(xml);
-        if (papers.length === 0) return toolResult({ error: "Paper not found" });
-        return toolResult(papers[0]);
+        if (papers.length === 0) {
+          return toolResult({
+            error: `Paper not found: ${id}`,
+            _source_health: { source: "arxiv", latency_ms: tracked.latency_ms },
+          });
+        }
+        return toolResult({
+          ...papers[0],
+          _source_health: { source: "arxiv", latency_ms: tracked.latency_ms },
+        });
       },
     },
   ];

package/src/tools/biorxiv.ts

@@ -0,0 +1,142 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://api.biorxiv.org";
+
+export function createBiorxivTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_biorxiv",
+      label: "Search Preprints (bioRxiv)",
+      description:
+        "Get recent bioRxiv preprints by date range. Covers biology preprints (300K+). Use date range (e.g. '2026-03-01/2026-03-18'), recent count (e.g. '50'), or recent days (e.g. '7d').",
+      parameters: Type.Object({
+        interval: Type.String({
+          description:
+            "Date range 'YYYY-MM-DD/YYYY-MM-DD', recent count '50', or recent days '7d'",
+        }),
+        cursor: Type.Optional(
+          Type.Number({ description: "Pagination offset (default 0, each page returns up to 100)" }),
+        ),
+      }),
+      execute: async (input: { interval: string; cursor?: number }) => {
+        const cursor = input.cursor ?? 0;
+        const tracked = await trackedFetch("biorxiv", `${BASE}/details/biorxiv/${input.interval}/${cursor}/json`, undefined, 30_000);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const meta = data.messages?.[0];
+        const papers = (data.collection ?? []).map(
+          (p: Record<string, unknown>) => ({
+            doi: p.doi,
+            title: p.title,
+            authors: typeof p.authors === "string"
+              ? (p.authors as string).split("; ").filter(Boolean)
+              : [],
+            abstract: p.abstract,
+            date: p.date,
+            category: p.category,
+            version: p.version,
+            license: p.license,
+            url: p.doi ? `https://www.biorxiv.org/content/${p.doi}` : undefined,
+            pdf_url: p.doi ? `https://www.biorxiv.org/content/${p.doi}v${p.version ?? 1}.full.pdf` : undefined,
+            source: "biorxiv",
+          }),
+        );
+
+        return toolResult({
+          total_results: meta?.total ?? papers.length,
+          cursor: meta?.cursor,
+          papers,
+        });
+      },
+    },
+    {
+      name: "search_medrxiv",
+      label: "Search Preprints (medRxiv)",
+      description:
+        "Get recent medRxiv preprints by date range. Covers medical/health science preprints (100K+).",
+      parameters: Type.Object({
+        interval: Type.String({
+          description:
+            "Date range 'YYYY-MM-DD/YYYY-MM-DD', recent count '50', or recent days '7d'",
+        }),
+        cursor: Type.Optional(
+          Type.Number({ description: "Pagination offset (default 0)" }),
+        ),
+      }),
+      execute: async (input: { interval: string; cursor?: number }) => {
+        const cursor = input.cursor ?? 0;
+        const tracked = await trackedFetch("medrxiv", `${BASE}/details/medrxiv/${input.interval}/${cursor}/json`, undefined, 30_000);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const meta = data.messages?.[0];
+        const papers = (data.collection ?? []).map(
+          (p: Record<string, unknown>) => ({
+            doi: p.doi,
+            title: p.title,
+            authors: typeof p.authors === "string"
+              ? (p.authors as string).split("; ").filter(Boolean)
+              : [],
+            abstract: p.abstract,
+            date: p.date,
+            category: p.category,
+            version: p.version,
+            url: p.doi ? `https://www.medrxiv.org/content/${p.doi}` : undefined,
+            pdf_url: p.doi ? `https://www.medrxiv.org/content/${p.doi}v${p.version ?? 1}.full.pdf` : undefined,
+            source: "medrxiv",
+          }),
+        );
+
+        return toolResult({
+          total_results: meta?.total ?? papers.length,
+          cursor: meta?.cursor,
+          papers,
+        });
+      },
+    },
+    {
+      name: "get_preprint_by_doi",
+      label: "Get Preprint by DOI (bioRxiv/medRxiv)",
+      description:
+        "Get a specific bioRxiv or medRxiv preprint by its DOI.",
+      parameters: Type.Object({
+        doi: Type.String({ description: "DOI of the preprint (e.g. '10.1101/2024.01.15.575123')" }),
+        server: Type.Optional(
+          Type.String({ description: "Server: 'biorxiv' or 'medrxiv' (default: biorxiv)" }),
+        ),
+      }),
+      execute: async (input: { doi: string; server?: string }) => {
+        const server = input.server ?? "biorxiv";
+        const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
+        const tracked = await trackedFetch(server, `${BASE}/details/${server}/${doi}/na/json`, undefined, 15_000);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+        const papers = data.collection ?? [];
+        if (papers.length === 0) return toolResult({ error: "Preprint not found" });
+
+        const p = papers[0] as Record<string, unknown>;
+        return toolResult({
+          doi: p.doi,
+          title: p.title,
+          authors: typeof p.authors === "string"
+            ? (p.authors as string).split("; ").filter(Boolean)
+            : [],
+          abstract: p.abstract,
+          date: p.date,
+          category: p.category,
+          version: p.version,
+          license: p.license,
+          url: `https://www.${server}.org/content/${p.doi}`,
+          pdf_url: `https://www.${server}.org/content/${p.doi}v${p.version ?? 1}.full.pdf`,
+          source: server,
+        });
+      },
+    },
+  ];
+}

package/src/tools/crossref.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
 
 const BASE = "https://api.crossref.org";
 
@@ -25,11 +25,9 @@ export function createCrossRefTools(
       }),
       execute: async (input: { doi: string }) => {
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
-        const res = await fetch(`${BASE}/works/${encodeURIComponent(doi)}`, {
-          headers,
-        });
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const data = await res.json();
+        const tracked = await trackedFetch("crossref", `${BASE}/works/${encodeURIComponent(doi)}`, { headers });
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
         const w = data.message;
         return toolResult({
           doi: w.DOI,
@@ -46,6 +44,7 @@ export function createCrossRefTools(
           url: w.URL,
           abstract: w.abstract,
           license: w.license?.[0]?.URL,
+          _source_health: { source: "crossref", latency_ms: tracked.latency_ms },
         });
       },
     },
@@ -53,47 +52,82 @@ export function createCrossRefTools(
       name: "search_crossref",
       label: "Search Works (CrossRef)",
       description:
-        "Search CrossRef for scholarly works by query. Covers 150M+ DOIs across all publishers.",
+        "Search CrossRef for scholarly works. Covers 150M+ DOIs across ALL publishers and disciplines. Supports journal/ISSN filtering, year range, work type, and citation-count sorting. Best general-purpose academic search tool.",
       parameters: Type.Object({
-        query: Type.String({ description: "Search query" }),
-        limit: Type.Optional(
-          Type.Number({ description: "Max results (default 10, max 100)" }),
+        query: Type.String({ description: "Search query (keywords)" }),
+        journal: Type.Optional(
+          Type.String({
+            description:
+              "Journal name filter (container-title). E.g. 'Nature', 'American Economic Review', 'The Lancet'",
+          }),
+        ),
+        issn: Type.Optional(
+          Type.String({
+            description: "Journal ISSN filter. E.g. '0028-0836' for Nature, '0002-8282' for AER",
+          }),
         ),
         from_year: Type.Optional(
-          Type.Number({ description: "Published from this year onward" }),
+          Type.Number({ description: "Published from this year onward (inclusive)" }),
+        ),
+        until_year: Type.Optional(
+          Type.Number({ description: "Published until this year (inclusive)" }),
         ),
         type: Type.Optional(
           Type.String({
             description:
-              "Work type filter: 'journal-article', 'book-chapter', 'proceedings-article', etc.",
+              "Work type: 'journal-article', 'book-chapter', 'proceedings-article', 'posted-content' (preprint), 'dissertation'",
           }),
         ),
+        has_abstract: Type.Optional(
+          Type.Boolean({ description: "Only results with abstracts" }),
+        ),
         sort: Type.Optional(
           Type.String({
-            description: "Sort by: 'relevance', 'published', 'is-referenced-by-count'",
+            description:
+              "Sort by: 'relevance' (default), 'published' (newest first), 'is-referenced-by-count' (most cited)",
           }),
         ),
+        limit: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
       }),
       execute: async (input: {
         query: string;
-        limit?: number;
+        journal?: string;
+        issn?: string;
         from_year?: number;
+        until_year?: number;
         type?: string;
+        has_abstract?: boolean;
         sort?: string;
+        limit?: number;
       }) => {
         const params = new URLSearchParams({
           query: input.query,
           rows: String(Math.min(input.limit ?? 10, 100)),
         });
-        if (input.from_year)
-          params.set("filter", `from-pub-date:${input.from_year}`);
-        if (input.type)
-          params.append("filter", `type:${input.type}`);
-        if (input.sort) params.set("sort", input.sort);
 
-        const res = await fetch(`${BASE}/works?${params}`, { headers });
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const data = await res.json();
+        // Build filter chain
+        const filters: string[] = [];
+        if (input.from_year) filters.push(`from-pub-date:${input.from_year}`);
+        if (input.until_year) filters.push(`until-pub-date:${input.until_year}`);
+        if (input.type) filters.push(`type:${input.type}`);
+        if (input.has_abstract) filters.push("has-abstract:true");
+        if (input.issn) filters.push(`issn:${input.issn}`);
+        if (filters.length > 0) params.set("filter", filters.join(","));
+
+        // Journal name as query.container-title (separate from filter)
+        if (input.journal) params.set("query.container-title", input.journal);
+
+        if (input.sort) {
+          params.set("sort", input.sort);
+          params.set("order", "desc");
+        }
+
+        const tracked = await trackedFetch("crossref", `${BASE}/works?${params}`, { headers });
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
         return toolResult({
           total_results: data.message?.["total-results"],
           items: data.message?.items?.map((w: Record<string, unknown>) => ({
@@ -107,7 +141,11 @@ export function createCrossRefTools(
               (w.published as Record<string, unknown>)?.["date-parts"],
             type: w.type,
             cited_by: w["is-referenced-by-count"],
+            abstract: typeof w.abstract === "string"
+              ? (w.abstract as string).replace(/<[^>]*>/g, "").slice(0, 300)
+              : undefined,
           })),
+          _source_health: { source: "crossref", latency_ms: tracked.latency_ms },
         });
       },
     },

package/src/tools/datacite.ts

@@ -0,0 +1,188 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://api.datacite.org";
+
+export function createDataCiteTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_datacite",
+      label: "Search Datasets & DOIs (DataCite)",
+      description:
+        "Search DataCite for datasets, software, and other research outputs (50M+ DOIs). Covers Zenodo, Figshare, Dryad, and 2000+ repositories. Best for finding datasets, software, and non-journal outputs.",
+      parameters: Type.Object({
+        query: Type.String({
+          description: "Search query for datasets, software, or other research outputs",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        resource_type: Type.Optional(
+          Type.String({
+            description:
+              "Filter by type: 'Dataset', 'Software', 'Text', 'Collection', 'Audiovisual', 'Image', etc.",
+          }),
+        ),
+        from_year: Type.Optional(
+          Type.Number({ description: "Published from this year onward" }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        max_results?: number;
+        resource_type?: string;
+        from_year?: number;
+      }) => {
+        const pageSize = Math.min(input.max_results ?? 10, 100);
+        const params = new URLSearchParams({
+          query: input.query,
+          "page[size]": String(pageSize),
+        });
+        if (input.resource_type) {
+          params.set("resource-type-id", input.resource_type.toLowerCase());
+        }
+        if (input.from_year) {
+          params.set("query", `${input.query} AND publicationYear:[${input.from_year} TO *]`);
+        }
+
+        const tracked = await trackedFetch("datacite", `${BASE}/dois?${params}`, undefined, 15_000);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const items = (data.data ?? []).map(
+          (item: Record<string, unknown>) => {
+            const attrs = item.attributes as Record<string, unknown> | undefined;
+            if (!attrs) return { id: item.id };
+
+            const titles = attrs.titles as Array<{ title: string }> | undefined;
+            const creators = attrs.creators as Array<{
+              name: string;
+              nameType?: string;
+              givenName?: string;
+              familyName?: string;
+            }> | undefined;
+            const types = attrs.types as Record<string, string> | undefined;
+            const descriptions = attrs.descriptions as Array<{
+              description: string;
+              descriptionType: string;
+            }> | undefined;
+            const dates = attrs.dates as Array<{
+              date: string;
+              dateType: string;
+            }> | undefined;
+
+            const issuedDate = dates?.find((d) => d.dateType === "Issued")?.date;
+
+            return {
+              doi: attrs.doi,
+              title: titles?.[0]?.title,
+              creators: creators?.slice(0, 5).map((c) =>
+                c.givenName && c.familyName
+                  ? `${c.givenName} ${c.familyName}`
+                  : c.name,
+              ),
+              publisher: attrs.publisher,
+              publication_year: attrs.publicationYear,
+              resource_type: types?.resourceTypeGeneral,
+              description: descriptions?.find(
+                (d) => d.descriptionType === "Abstract",
+              )?.description,
+              url: attrs.url,
+              issued_date: issuedDate,
+              citation_count: attrs.citationCount,
+              view_count: attrs.viewCount,
+              download_count: attrs.downloadCount,
+            };
+          },
+        );
+
+        return toolResult({
+          total_results: data.meta?.total,
+          items,
+          _source_health: { source: "datacite", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+    {
+      name: "resolve_datacite_doi",
+      label: "Resolve DOI (DataCite)",
+      description:
+        "Resolve a DataCite DOI to get full metadata. Best for DOIs from Zenodo, Figshare, Dryad, and other data repositories (10.5281/*, 10.6084/*, etc.).",
+      parameters: Type.Object({
+        doi: Type.String({
+          description: "DOI to resolve, e.g. '10.5281/zenodo.1234567'",
+        }),
+      }),
+      execute: async (input: { doi: string }) => {
+        const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
+
+        const tracked = await trackedFetch(
+          "datacite",
+          `${BASE}/dois/${encodeURIComponent(doi)}`,
+          undefined,
+          15_000,
+        );
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const attrs = data.data?.attributes as Record<string, unknown> | undefined;
+        if (!attrs) return toolResult({ error: "DOI not found or no attributes" });
+
+        const titles = attrs.titles as Array<{ title: string }> | undefined;
+        const creators = attrs.creators as Array<{
+          name: string;
+          givenName?: string;
+          familyName?: string;
+        }> | undefined;
+        const types = attrs.types as Record<string, string> | undefined;
+        const descriptions = attrs.descriptions as Array<{
+          description: string;
+          descriptionType: string;
+        }> | undefined;
+        const dates = attrs.dates as Array<{
+          date: string;
+          dateType: string;
+        }> | undefined;
+        const rights = attrs.rightsList as Array<{
+          rights: string;
+          rightsUri?: string;
+          rightsIdentifier?: string;
+        }> | undefined;
+        const subjects = attrs.subjects as Array<{
+          subject: string;
+        }> | undefined;
+
+        return toolResult({
+          doi: attrs.doi,
+          title: titles?.[0]?.title,
+          creators: creators?.map((c) =>
+            c.givenName && c.familyName
+              ? `${c.givenName} ${c.familyName}`
+              : c.name,
+          ),
+          publisher: attrs.publisher,
+          publication_year: attrs.publicationYear,
+          resource_type: types?.resourceTypeGeneral,
+          resource_type_specific: types?.resourceType || undefined,
+          description: descriptions?.find(
+            (d) => d.descriptionType === "Abstract",
+          )?.description,
+          url: attrs.url,
+          dates: dates?.map((d) => ({ date: d.date, type: d.dateType })),
+          license: rights?.[0]?.rightsIdentifier ?? rights?.[0]?.rights,
+          license_url: rights?.[0]?.rightsUri,
+          subjects: subjects?.map((s) => s.subject),
+          citation_count: attrs.citationCount,
+          view_count: attrs.viewCount,
+          download_count: attrs.downloadCount,
+          version: attrs.version,
+          _source_health: { source: "datacite", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+  ];
+}