@wentorai/research-plugins 1.3.1 → 1.4.0

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 },
+        });
+      },
+    },
+  ];
+}

package/src/tools/dblp.ts

@@ -0,0 +1,125 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+export function createDblpTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_dblp",
+      label: "Search CS Papers (dblp)",
+      description:
+        "Search dblp computer science bibliography (7M+ records). Covers conferences (NeurIPS, ICML, ACL, etc.) and journals. Best for CS venue-specific search.",
+      parameters: Type.Object({
+        query: Type.String({
+          description: "Search query for publications",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 1000)" }),
+        ),
+        offset: Type.Optional(
+          Type.Number({ description: "Result offset for pagination" }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        max_results?: number;
+        offset?: number;
+      }) => {
+        const params = new URLSearchParams({
+          q: input.query,
+          format: "json",
+          h: String(Math.min(input.max_results ?? 10, 1000)),
+        });
+        if (input.offset) params.set("f", String(input.offset));
+
+        const tracked = await trackedFetch("dblp", `https://dblp.org/search/publ/api?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const hits = data.result?.hits;
+        if (!hits) return toolResult({ total_results: 0, papers: [] });
+
+        const papers = (hits.hit ?? []).map(
+          (h: Record<string, unknown>) => {
+            const info = h.info as Record<string, unknown>;
+            if (!info) return {};
+
+            const authorsRaw = info.authors as Record<string, unknown> | undefined;
+            let authors: string[] = [];
+            if (authorsRaw?.author) {
+              const authorList = authorsRaw.author;
+              if (Array.isArray(authorList)) {
+                authors = authorList.map((a: Record<string, string> | string) =>
+                  typeof a === "string" ? a : a.text ?? "",
+                );
+              } else if (typeof authorList === "object") {
+                authors = [(authorList as Record<string, string>).text ?? ""];
+              }
+            }
+
+            return {
+              title: info.title,
+              authors,
+              venue: info.venue,
+              year: info.year ? parseInt(info.year as string, 10) : undefined,
+              type: info.type,
+              doi: info.doi,
+              url: info.ee ?? info.url,
+              dblp_url: info.url,
+            };
+          },
+        );
+
+        return toolResult({
+          total_results: parseInt(hits["@total"] ?? "0", 10),
+          papers,
+        });
+      },
+    },
+    {
+      name: "search_dblp_author",
+      label: "Search Authors (dblp)",
+      description:
+        "Search dblp for computer science authors and their publication profiles.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Author name to search" }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10)" }),
+        ),
+      }),
+      execute: async (input: { query: string; max_results?: number }) => {
+        const params = new URLSearchParams({
+          q: input.query,
+          format: "json",
+          h: String(Math.min(input.max_results ?? 10, 100)),
+        });
+
+        const tracked = await trackedFetch("dblp", `https://dblp.org/search/author/api?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const hits = data.result?.hits;
+        if (!hits) return toolResult({ total_results: 0, authors: [] });
+
+        const authors = (hits.hit ?? []).map(
+          (h: Record<string, unknown>) => {
+            const info = h.info as Record<string, unknown>;
+            return {
+              name: info?.author,
+              url: info?.url,
+              notes: info?.notes,
+            };
+          },
+        );
+
+        return toolResult({
+          total_results: parseInt(hits["@total"] ?? "0", 10),
+          authors,
+        });
+      },
+    },
+  ];
+}

package/src/tools/doaj.ts

@@ -0,0 +1,82 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://doaj.org/api";
+
+export function createDoajTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_doaj",
+      label: "Search Open Access Articles (DOAJ)",
+      description:
+        "Search DOAJ for verified open access articles (9M+ articles from 20K+ OA journals). All results are guaranteed open access.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports field search: bibjson.title:, bibjson.author.name:, bibjson.keywords:, doi:, bibjson.year:. Boolean AND/OR supported.",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        page: Type.Optional(
+          Type.Number({ description: "Page number (starts from 1)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({ description: "Sort field, e.g. 'created_date:desc'" }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        max_results?: number;
+        page?: number;
+        sort?: string;
+      }) => {
+        const pageSize = Math.min(input.max_results ?? 10, 100);
+        const page = input.page ?? 1;
+
+        let url = `${BASE}/search/articles/${encodeURIComponent(input.query)}?page=${page}&pageSize=${pageSize}`;
+        if (input.sort) url += `&sort=${encodeURIComponent(input.sort)}`;
+
+        const tracked = await trackedFetch("doaj", url);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const articles = (data.results ?? []).map(
+          (r: Record<string, unknown>) => {
+            const bib = r.bibjson as Record<string, unknown> | undefined;
+            if (!bib) return { id: r.id };
+
+            const identifiers = bib.identifier as Array<{ type: string; id: string }> | undefined;
+            const doi = identifiers?.find((i) => i.type === "doi")?.id;
+            const links = bib.link as Array<{ url: string; type: string }> | undefined;
+            const journal = bib.journal as Record<string, unknown> | undefined;
+
+            return {
+              title: bib.title,
+              abstract: bib.abstract,
+              authors: (bib.author as Array<{ name: string }> | undefined)
+                ?.map((a) => a.name),
+              year: bib.year,
+              doi,
+              journal: journal?.title,
+              publisher: journal?.publisher,
+              keywords: bib.keywords,
+              url: links?.[0]?.url ?? (doi ? `https://doi.org/${doi}` : undefined),
+              is_oa: true,
+            };
+          },
+        );
+
+        return toolResult({
+          total_results: data.total,
+          page,
+          articles,
+        });
+      },
+    },
+  ];
+}