@wentorai/research-plugins 1.3.2 → 1.4.2

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

package/src/tools/europe-pmc.ts

@@ -0,0 +1,159 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://www.ebi.ac.uk/europepmc/webservices/rest";
+
+export function createEuropePmcTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_europe_pmc",
+      label: "Search Articles (Europe PMC)",
+      description:
+        "Search Europe PMC biomedical literature. Covers 33M+ articles including full PubMed, with open access full text, citation counts, and MeSH terms.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports field tags: TITLE:, AUTH:, JOURNAL:, DOI:, and boolean AND/OR/NOT.",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 1000)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description: "Sort by: 'RELEVANCE', 'DATE_DESC', 'CITED'",
+          }),
+        ),
+        cursor: Type.Optional(
+          Type.String({ description: "Pagination cursor (use value from previous response)" }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        max_results?: number;
+        sort?: string;
+        cursor?: string;
+      }) => {
+        const params = new URLSearchParams({
+          query: input.query,
+          format: "json",
+          pageSize: String(Math.min(input.max_results ?? 10, 1000)),
+          resultType: "core",
+        });
+        if (input.sort) params.set("sort", input.sort);
+        params.set("cursorMark", input.cursor ?? "*");
+
+        const tracked = await trackedFetch("europe_pmc", `${BASE}/search?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const results = (data.resultList?.result ?? []).map(
+          (r: Record<string, unknown>) => ({
+            pmid: r.pmid,
+            pmcid: r.pmcid,
+            doi: r.doi,
+            title: r.title,
+            authors: r.authorString,
+            journal: (r.journalInfo as Record<string, unknown>)?.journal
+              ? ((r.journalInfo as Record<string, unknown>).journal as Record<string, unknown>)?.title
+              : undefined,
+            year: r.pubYear,
+            abstract: r.abstractText,
+            is_oa: r.isOpenAccess === "Y",
+            cited_by_count: r.citedByCount,
+            source: r.source,
+            url: r.doi ? `https://doi.org/${r.doi}` : `https://europepmc.org/article/${r.source}/${r.id}`,
+          }),
+        );
+
+        return toolResult({
+          total_results: data.hitCount,
+          next_cursor: data.nextCursorMark,
+          articles: results,
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+    {
+      name: "get_epmc_citations",
+      label: "Get Citations (Europe PMC)",
+      description:
+        "Get papers that cite a given article. Forward citation tracking for biomedical literature.",
+      parameters: Type.Object({
+        pmid: Type.String({
+          description: "PubMed ID of the article",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max citations to return (default 25)" }),
+        ),
+        page: Type.Optional(Type.Number({ description: "Page number (default 1)" })),
+      }),
+      execute: async (input: { pmid: string; max_results?: number; page?: number }) => {
+        const params = new URLSearchParams({
+          format: "json",
+          pageSize: String(input.max_results ?? 25),
+          page: String(input.page ?? 1),
+        });
+        const tracked = await trackedFetch("europe_pmc", `${BASE}/MED/${input.pmid}/citations?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        return toolResult({
+          total_citations: data.hitCount,
+          citations: (data.citationList?.citation ?? []).map(
+            (c: Record<string, unknown>) => ({
+              pmid: c.id,
+              source: c.source,
+              title: c.title,
+              authors: c.authorString,
+              journal: c.journalAbbreviation,
+              year: c.pubYear,
+              cited_by_count: c.citedByCount,
+            }),
+          ),
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+    {
+      name: "get_epmc_references",
+      label: "Get References (Europe PMC)",
+      description:
+        "Get the reference list of a paper. Shows what a paper cites.",
+      parameters: Type.Object({
+        pmid: Type.String({ description: "PubMed ID of the article" }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max references to return (default 25)" }),
+        ),
+      }),
+      execute: async (input: { pmid: string; max_results?: number }) => {
+        const params = new URLSearchParams({
+          format: "json",
+          pageSize: String(input.max_results ?? 25),
+        });
+        const tracked = await trackedFetch("europe_pmc", `${BASE}/MED/${input.pmid}/references?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        return toolResult({
+          total_references: data.hitCount,
+          references: (data.referenceList?.reference ?? []).map(
+            (r: Record<string, unknown>) => ({
+              pmid: r.id,
+              source: r.source,
+              title: r.title,
+              authors: r.authorString,
+              journal: r.journalAbbreviation,
+              year: r.pubYear,
+              order: r.citedOrder,
+            }),
+          ),
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+  ];
+}

package/src/tools/hal.ts

@@ -0,0 +1,118 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://api.archives-ouvertes.fr";
+
+/** Default fields to request from HAL Solr API */
+const DEFAULT_FIELDS = [
+  "title_s",
+  "authFullName_s",
+  "doiId_s",
+  "producedDate_s",
+  "uri_s",
+  "abstract_s",
+  "journalTitle_s",
+  "keyword_s",
+  "docType_s",
+  "halId_s",
+].join(",");
+
+export function createHalTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_hal",
+      label: "Search Publications (HAL)",
+      description:
+        "Search HAL (Hyper Articles en Ligne), the French open archive for scholarly publications. Covers 4M+ documents with strong coverage of French and European research across all disciplines.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports Solr syntax: field:value, AND/OR/NOT, quoted phrases.",
+        }),
+        rows: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort: 'producedDate_s desc' (newest), 'producedDate_s asc' (oldest). Default: relevance.",
+          }),
+        ),
+        doc_type: Type.Optional(
+          Type.String({
+            description:
+              "Document type filter: 'ART' (journal article), 'COMM' (conference paper), 'THESE' (thesis), 'COUV' (book chapter), 'OUV' (book), 'REPORT', 'HDR', 'POSTER'",
+          }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        rows?: number;
+        sort?: string;
+        doc_type?: string;
+      }) => {
+        let q = input.query;
+        if (input.doc_type) {
+          q = `(${q}) AND docType_s:${input.doc_type}`;
+        }
+
+        const params = new URLSearchParams({
+          q,
+          fl: DEFAULT_FIELDS,
+          rows: String(Math.min(input.rows ?? 10, 100)),
+          wt: "json",
+        });
+        if (input.sort) params.set("sort", input.sort);
+
+        const result = await trackedFetch(
+          "hal",
+          `${BASE}/search/?${params}`,
+          undefined,
+          10_000,
+        );
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        const response = data.response as Record<string, unknown> | undefined;
+        const docs = response?.docs as Array<Record<string, unknown>> | undefined;
+
+        return toolResult({
+          total_results: response?.numFound,
+          source: "hal",
+          papers: (docs ?? []).map((doc) => {
+            // HAL returns title_s and authFullName_s as arrays
+            const titles = doc.title_s as string[] | undefined;
+            const authors = doc.authFullName_s as string[] | undefined;
+            const keywords = doc.keyword_s as string[] | undefined;
+            const abstracts = doc.abstract_s as string[] | undefined;
+            const doi = doc.doiId_s as string | undefined;
+
+            return {
+              title: titles?.[0],
+              authors,
+              doi,
+              year: doc.producedDate_s
+                ? String(doc.producedDate_s).slice(0, 4)
+                : undefined,
+              publication_date: doc.producedDate_s,
+              journal: doc.journalTitle_s,
+              doc_type: doc.docType_s,
+              keywords,
+              abstract: abstracts?.[0]
+                ? String(abstracts[0]).slice(0, 500)
+                : undefined,
+              url: (doc.uri_s as string) ?? (doi ? `https://doi.org/${doi}` : undefined),
+              hal_id: doc.halId_s,
+              source: "hal",
+            };
+          }),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+  ];
+}

package/src/tools/inspire-hep.ts

@@ -0,0 +1,165 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://inspirehep.net/api";
+
+interface InspireAuthor {
+  full_name: string;
+  first_name?: string;
+  last_name?: string;
+}
+
+interface InspireTitle {
+  title: string;
+  source?: string;
+}
+
+interface InspireAbstract {
+  value: string;
+  source?: string;
+}
+
+interface InspireArxivEprint {
+  value: string;
+  categories?: string[];
+}
+
+interface InspireDoi {
+  value: string;
+}
+
+interface InspirePublicationInfo {
+  year?: number;
+  journal_title?: string;
+  journal_volume?: string;
+  page_start?: string;
+  page_end?: string;
+  artid?: string;
+}
+
+function normalizeHit(meta: Record<string, unknown>): Record<string, unknown> {
+  const titles = meta.titles as InspireTitle[] | undefined;
+  const authors = meta.authors as InspireAuthor[] | undefined;
+  const arxivEprints = meta.arxiv_eprints as InspireArxivEprint[] | undefined;
+  const dois = meta.dois as InspireDoi[] | undefined;
+  const abstracts = meta.abstracts as InspireAbstract[] | undefined;
+  const pubInfo = meta.publication_info as InspirePublicationInfo[] | undefined;
+
+  const arxivId = arxivEprints?.[0]?.value;
+  const doi = dois?.[0]?.value;
+
+  return {
+    title: titles?.[0]?.title,
+    authors: authors?.slice(0, 10).map((a) => a.full_name),
+    author_count: authors?.length ?? meta.author_count,
+    doi,
+    arxiv_id: arxivId,
+    arxiv_categories: arxivEprints?.[0]?.categories,
+    year: pubInfo?.[0]?.year ?? (meta.earliest_date ? String(meta.earliest_date).slice(0, 4) : undefined),
+    journal: pubInfo?.[0]?.journal_title,
+    journal_volume: pubInfo?.[0]?.journal_volume,
+    citation_count: meta.citation_count,
+    abstract: abstracts?.[0]?.value,
+    url: doi
+      ? `https://doi.org/${doi}`
+      : arxivId
+        ? `https://arxiv.org/abs/${arxivId}`
+        : undefined,
+    inspire_url: meta.control_number
+      ? `https://inspirehep.net/literature/${meta.control_number}`
+      : undefined,
+    source: "inspire_hep",
+  };
+}
+
+export function createInspireHepTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_inspire",
+      label: "Search Papers (INSPIRE-HEP)",
+      description:
+        "Search INSPIRE-HEP for high-energy physics literature. The primary database for particle physics, astrophysics, and related fields. Covers 1.5M+ records with citation tracking.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports SPIRES-style: 'find a einstein and t relativity', or keywords like 'higgs boson'. Field search: a (author), t (title), j (journal), eprint (arXiv ID).",
+        }),
+        size: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort by: 'mostrecent' (newest), 'mostcited', 'bestmatch' (relevance)",
+          }),
+        ),
+      }),
+      execute: async (input: { query: string; size?: number; sort?: string }) => {
+        const params = new URLSearchParams({
+          q: input.query,
+          size: String(Math.min(input.size ?? 10, 100)),
+          sort: input.sort ?? "bestmatch",
+        });
+
+        const result = await trackedFetch(
+          "inspire_hep",
+          `${BASE}/literature?${params}`,
+          undefined,
+          10_000,
+        );
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        return toolResult({
+          total_results: data.hits?.total,
+          source: "inspire_hep",
+          papers: data.hits?.hits?.map(
+            (h: Record<string, unknown>) =>
+              normalizeHit(h.metadata as Record<string, unknown>),
+          ),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+    {
+      name: "get_inspire_paper",
+      label: "Get Paper Details (INSPIRE-HEP)",
+      description:
+        "Get detailed information about a specific paper from INSPIRE-HEP by arXiv ID or DOI.",
+      parameters: Type.Object({
+        identifier: Type.String({
+          description:
+            "Paper identifier: arXiv ID (e.g. '1207.7214') or DOI (e.g. '10.1016/j.physletb.2012.08.020')",
+        }),
+      }),
+      execute: async (input: { identifier: string }) => {
+        // Determine if it's a DOI or arXiv ID
+        const id = input.identifier.trim();
+        let url: string;
+        if (id.startsWith("10.")) {
+          url = `${BASE}/doi/${encodeURIComponent(id)}`;
+        } else {
+          // arXiv ID — strip any "arXiv:" prefix
+          const arxivId = id.replace(/^arXiv:/i, "");
+          url = `${BASE}/arxiv/${encodeURIComponent(arxivId)}`;
+        }
+
+        const result = await trackedFetch("inspire_hep", url, undefined, 10_000);
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        const meta = data.metadata as Record<string, unknown> | undefined;
+        if (!meta) return toolResult({ error: "Paper not found", source: "inspire_hep" });
+
+        return toolResult({
+          ...normalizeHit(meta),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+  ];
+}