@wentorai/research-plugins 1.0.0

package/src/tools/pubmed.ts

@@ -0,0 +1,166 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils";
+
+export function createPubMedTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_pubmed",
+      description:
+        "Search PubMed biomedical literature database. Covers 36M+ citations from MEDLINE, life science journals, and online books.",
+      inputSchema: Type.Object({
+        query: Type.String({
+          description:
+            "PubMed search query. Supports MeSH terms and field tags, e.g. 'CRISPR[Title] AND 2024[PDAT]'",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description: "Sort by: 'relevance' or 'pub_date'",
+          }),
+        ),
+        min_date: Type.Optional(
+          Type.String({ description: "Min publication date (YYYY/MM/DD)" }),
+        ),
+        max_date: Type.Optional(
+          Type.String({ description: "Max publication date (YYYY/MM/DD)" }),
+        ),
+      }),
+      handler: async (input: {
+        query: string;
+        max_results?: number;
+        sort?: string;
+        min_date?: string;
+        max_date?: string;
+      }) => {
+        const searchParams = new URLSearchParams({
+          db: "pubmed",
+          term: input.query,
+          retmax: String(Math.min(input.max_results ?? 10, 100)),
+          retmode: "json",
+          sort: input.sort ?? "relevance",
+          usehistory: "y",
+        });
+        if (input.min_date) searchParams.set("mindate", input.min_date);
+        if (input.max_date) searchParams.set("maxdate", input.max_date);
+        if (input.min_date || input.max_date) searchParams.set("datetype", "pdat");
+
+        const searchRes = await fetch(`${EUTILS}/esearch.fcgi?${searchParams}`);
+        if (!searchRes.ok)
+          return { error: `Search error: ${searchRes.status} ${searchRes.statusText}` };
+        const searchData = await searchRes.json();
+        const ids: string[] = searchData.esearchresult?.idlist ?? [];
+
+        if (ids.length === 0) return { total_count: searchData.esearchresult?.count ?? 0, articles: [] };
+
+        const summaryParams = new URLSearchParams({
+          db: "pubmed",
+          id: ids.join(","),
+          retmode: "json",
+        });
+        const summaryRes = await fetch(`${EUTILS}/esummary.fcgi?${summaryParams}`);
+        if (!summaryRes.ok)
+          return { error: `Summary error: ${summaryRes.status} ${summaryRes.statusText}` };
+        const summaryData = await summaryRes.json();
+
+        const articles = ids.map((id) => {
+          const doc = summaryData.result?.[id];
+          if (!doc) return { pmid: id };
+          return {
+            pmid: id,
+            title: doc.title,
+            authors: doc.authors
+              ?.slice(0, 5)
+              .map((a: Record<string, string>) => a.name),
+            source: doc.source,
+            pub_date: doc.pubdate,
+            doi: doc.elocationid?.replace("doi: ", ""),
+            pmc: doc.articleids?.find(
+              (a: Record<string, string>) => a.idtype === "pmc",
+            )?.value,
+          };
+        });
+
+        return {
+          total_count: parseInt(searchData.esearchresult?.count ?? "0", 10),
+          articles,
+        };
+      },
+    },
+    {
+      name: "get_article",
+      description:
+        "Get detailed article metadata from PubMed by PMID, including abstract.",
+      inputSchema: Type.Object({
+        pmid: Type.String({ description: "PubMed ID (numeric string)" }),
+      }),
+      handler: async (input: { pmid: string }) => {
+        const params = new URLSearchParams({
+          db: "pubmed",
+          id: input.pmid,
+          retmode: "xml",
+        });
+        const res = await fetch(`${EUTILS}/efetch.fcgi?${params}`);
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const xml = await res.text();
+
+        const getText = (tag: string) => {
+          const m = xml.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+          return m ? m[1].trim() : "";
+        };
+
+        const getAbstract = () => {
+          const m = xml.match(/<AbstractText[^>]*>([\s\S]*?)<\/AbstractText>/g);
+          if (!m) return "";
+          return m
+            .map((s) => s.replace(/<\/?AbstractText[^>]*>/g, "").trim())
+            .join(" ");
+        };
+
+        const getAuthors = () => {
+          const authors: string[] = [];
+          const re = /<Author[^>]*>[\s\S]*?<LastName>([\s\S]*?)<\/LastName>[\s\S]*?<ForeName>([\s\S]*?)<\/ForeName>[\s\S]*?<\/Author>/g;
+          let m;
+          while ((m = re.exec(xml)) !== null) {
+            authors.push(`${m[2].trim()} ${m[1].trim()}`);
+          }
+          return authors;
+        };
+
+        const getMesh = () => {
+          const terms: string[] = [];
+          const re = /<DescriptorName[^>]*>([\s\S]*?)<\/DescriptorName>/g;
+          let m;
+          while ((m = re.exec(xml)) !== null) terms.push(m[1].trim());
+          return terms;
+        };
+
+        const doi =
+          xml.match(/<ArticleId IdType="doi">([\s\S]*?)<\/ArticleId>/)?.[1]?.trim() ??
+          "";
+        const pmc =
+          xml.match(/<ArticleId IdType="pmc">([\s\S]*?)<\/ArticleId>/)?.[1]?.trim() ??
+          "";
+
+        return {
+          pmid: input.pmid,
+          title: getText("ArticleTitle"),
+          abstract: getAbstract(),
+          authors: getAuthors(),
+          journal: getText("Title"),
+          pub_date: `${getText("Year")}-${getText("Month")}`,
+          doi,
+          pmc,
+          mesh_terms: getMesh(),
+          url: `https://pubmed.ncbi.nlm.nih.gov/${input.pmid}/`,
+        };
+      },
+    },
+  ];
+}

package/src/tools/semantic-scholar.ts

@@ -0,0 +1,108 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const BASE = "https://api.semanticscholar.org/graph/v1";
+
+export function createSemanticScholarTools(
+  ctx: OpenClawPluginToolContext,
+  api: OpenClawPluginApi,
+) {
+  const apiKey =
+    ctx.config?.get?.("plugins.entries.research-plugins.semanticScholarApiKey") ?? "";
+
+  const headers: Record<string, string> = apiKey ? { "x-api-key": apiKey } : {};
+
+  return [
+    {
+      name: "search_papers",
+      description:
+        "Search academic papers on Semantic Scholar. Returns titles, abstracts, authors, citation counts.",
+      inputSchema: Type.Object({
+        query: Type.String({ description: "Search query keywords" }),
+        limit: Type.Optional(
+          Type.Number({ description: "Max results to return (default 10, max 100)" }),
+        ),
+        year: Type.Optional(
+          Type.String({ description: "Year filter, e.g. '2024' or '2020-2024'" }),
+        ),
+        fields_of_study: Type.Optional(
+          Type.String({
+            description:
+              "Comma-separated fields, e.g. 'Computer Science,Mathematics'",
+          }),
+        ),
+        open_access_only: Type.Optional(
+          Type.Boolean({ description: "Only return open access papers" }),
+        ),
+      }),
+      handler: async (input: {
+        query: string;
+        limit?: number;
+        year?: string;
+        fields_of_study?: string;
+        open_access_only?: boolean;
+      }) => {
+        const params = new URLSearchParams({
+          query: input.query,
+          limit: String(Math.min(input.limit ?? 10, 100)),
+          fields:
+            "title,abstract,authors,year,citationCount,referenceCount,url,isOpenAccess,openAccessPdf",
+        });
+        if (input.year) params.set("year", input.year);
+        if (input.fields_of_study)
+          params.set("fieldsOfStudy", input.fields_of_study);
+        if (input.open_access_only) params.set("openAccessPdf", "");
+
+        const res = await fetch(`${BASE}/paper/search?${params}`, { headers });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        return res.json();
+      },
+    },
+    {
+      name: "get_paper",
+      description:
+        "Get detailed information about a specific paper by its Semantic Scholar ID, DOI, or ArXiv ID.",
+      inputSchema: Type.Object({
+        paper_id: Type.String({
+          description:
+            "Paper identifier: Semantic Scholar ID, DOI (e.g. '10.1234/...'), or ArXiv ID (e.g. 'arXiv:2301.00001')",
+        }),
+      }),
+      handler: async (input: { paper_id: string }) => {
+        const fields =
+          "title,abstract,authors,year,citationCount,referenceCount,tldr,url,venue,isOpenAccess,openAccessPdf,fieldsOfStudy,publicationDate";
+        const res = await fetch(
+          `${BASE}/paper/${encodeURIComponent(input.paper_id)}?fields=${fields}`,
+          { headers },
+        );
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        return res.json();
+      },
+    },
+    {
+      name: "get_citations",
+      description:
+        "Get papers that cite a given paper. Useful for forward citation tracking.",
+      inputSchema: Type.Object({
+        paper_id: Type.String({ description: "Paper identifier (S2 ID, DOI, or ArXiv ID)" }),
+        limit: Type.Optional(
+          Type.Number({ description: "Max citations to return (default 20, max 100)" }),
+        ),
+        offset: Type.Optional(
+          Type.Number({ description: "Pagination offset" }),
+        ),
+      }),
+      handler: async (input: { paper_id: string; limit?: number; offset?: number }) => {
+        const fields = "title,authors,year,citationCount,url,abstract";
+        const limit = Math.min(input.limit ?? 20, 100);
+        const offset = input.offset ?? 0;
+        const res = await fetch(
+          `${BASE}/paper/${encodeURIComponent(input.paper_id)}/citations?fields=${fields}&limit=${limit}&offset=${offset}`,
+          { headers },
+        );
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        return res.json();
+      },
+    },
+  ];
+}

package/src/tools/unpaywall.ts

@@ -0,0 +1,58 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const BASE = "https://api.unpaywall.org/v2";
+
+export function createUnpaywallTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  const email = "research-plugins@wentor.ai";
+
+  return [
+    {
+      name: "find_oa_version",
+      description:
+        "Find open access versions of a paper by DOI using Unpaywall. Returns free PDF links from repositories, preprint servers, and publisher OA pages.",
+      inputSchema: Type.Object({
+        doi: Type.String({
+          description: "DOI of the paper, e.g. '10.1038/nature12373'",
+        }),
+      }),
+      handler: async (input: { doi: string }) => {
+        const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
+        const res = await fetch(
+          `${BASE}/${encodeURIComponent(doi)}?email=${email}`,
+        );
+        if (!res.ok) {
+          if (res.status === 404) return { error: "DOI not found in Unpaywall" };
+          return { error: `API error: ${res.status} ${res.statusText}` };
+        }
+        const data = await res.json();
+
+        const oaLocations = (
+          data.oa_locations as Record<string, unknown>[] | undefined
+        )?.map((loc) => ({
+          url: loc.url,
+          url_for_pdf: loc.url_for_pdf,
+          host_type: loc.host_type,
+          license: loc.license,
+          version: loc.version,
+        }));
+
+        return {
+          doi: data.doi,
+          title: data.title,
+          is_oa: data.is_oa,
+          oa_status: data.oa_status,
+          best_oa_url: data.best_oa_location?.url,
+          best_oa_pdf: data.best_oa_location?.url_for_pdf,
+          journal: data.journal_name,
+          publisher: data.publisher,
+          published_date: data.published_date,
+          oa_locations: oaLocations,
+        };
+      },
+    },
+  ];
+}