@wentorai/research-plugins 1.4.0 → 1.4.3

package/skills/writing/citation/citation-assistant-skill/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: citation-assistant-skill
-description: "Claude Code skill for citation workflow via Semantic Scholar"
+description: "Claude Code skill for citation workflow via OpenAlex and CrossRef"
 metadata:
   openclaw:
     emoji: "📎"
     category: "writing"
     subcategory: "citation"
-    keywords: ["citation assistant", "Semantic Scholar", "Claude Code skill", "reference lookup", "academic citation"]
+    keywords: ["citation assistant", "OpenAlex", "Claude Code skill", "reference lookup", "academic citation"]
     source: "https://github.com/ZhangNy301/citation-assistant"
 ---
 
@@ -14,7 +14,7 @@ metadata:
 
 ## Overview
 
-Citation Assistant is a Claude Code skill that integrates Semantic Scholar API into the coding workflow for instant paper lookup, citation formatting, and reference management. Search for papers by title or keyword, get formatted BibTeX entries, find related works, and insert citations — all without leaving the terminal. Designed for researchers writing papers in LaTeX or Markdown.
+Citation Assistant is a Claude Code skill that integrates OpenAlex and CrossRef APIs into the coding workflow for instant paper lookup, citation formatting, and reference management. Search for papers by title or keyword, get formatted BibTeX entries, find related works, and insert citations — all without leaving the terminal. Designed for researchers writing papers in LaTeX or Markdown.
 
 ## Installation
 
@@ -32,106 +32,118 @@ openclaw skills install citation-assistant
 ```python
 import requests
 
-S2_API = "https://api.semanticscholar.org/graph/v1"
+OA_API = "https://api.openalex.org"
 
 def search_papers(query, limit=5):
-    """Search Semantic Scholar for papers."""
+    """Search OpenAlex for papers."""
     resp = requests.get(
-        f"{S2_API}/paper/search",
+        f"{OA_API}/works",
         params={
-            "query": query,
-            "limit": limit,
-            "fields": "title,authors,year,citationCount,"
-                      "externalIds,abstract,venue",
+            "search": query,
+            "per_page": limit,
         },
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"},
     )
-    return resp.json().get("data", [])
+    return resp.json().get("results", [])
 
 papers = search_papers("attention mechanism transformer")
 for p in papers:
-    authors = ", ".join(a["name"] for a in p["authors"][:3])
-    print(f"[{p['year']}] {p['title']}")
-    print(f"  {authors} — Citations: {p['citationCount']}")
-    print(f"  DOI: {p.get('externalIds', {}).get('DOI', 'N/A')}")
+    authors = [a["author"]["display_name"] for a in p.get("authorships", [])[:3]]
+    print(f"[{p.get('publication_year')}] {p.get('title')}")
+    print(f"  {', '.join(authors)} — Citations: {p.get('cited_by_count')}")
+    print(f"  DOI: {p.get('doi', 'N/A')}")
 ```
 
 ### BibTeX Generation
 
 ```python
-def get_bibtex(paper_id):
-    """Get BibTeX for a Semantic Scholar paper."""
+def get_bibtex(doi):
+    """Get BibTeX for a paper via CrossRef DOI resolution."""
     resp = requests.get(
-        f"{S2_API}/paper/{paper_id}",
-        params={
-            "fields": "title,authors,year,venue,externalIds,"
-                      "journal,publicationTypes",
-        },
+        f"https://api.crossref.org/works/{doi}",
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai; mailto:dev@wentor.ai)"},
     )
-    paper = resp.json()
+    msg = resp.json().get("message", {})
 
     # Generate citation key
-    first_author = paper["authors"][0]["name"].split()[-1].lower()
-    key = f"{first_author}{paper['year']}"
+    authors = msg.get("author", [])
+    first_author = authors[0].get("family", "unknown").lower() if authors else "unknown"
+    year = str(msg.get("published", {}).get("date-parts", [[""]])[0][0])
+    key = f"{first_author}{year}"
 
     # Build BibTeX
-    authors_str = " and ".join(a["name"] for a in paper["authors"])
-    doi = paper.get("externalIds", {}).get("DOI", "")
+    authors_str = " and ".join(f"{a.get('given', '')} {a.get('family', '')}".strip() for a in authors)
+    doi_str = msg.get("DOI", "")
+
+    title = msg.get("title", [""])[0] if isinstance(msg.get("title"), list) else msg.get("title", "")
+    journal = msg.get("container-title", [""])[0] if msg.get("container-title") else ""
 
     bibtex = f"""@article{{{key},
-  title = {{{paper['title']}}},
+  title = {{{title}}},
   author = {{{authors_str}}},
-  year = {{{paper['year']}}},
-  journal = {{{paper.get('venue', '')}}},
-  doi = {{{doi}}},
+  year = {{{year}}},
+  journal = {{{journal}}},
+  doi = {{{doi_str}}},
 }}"""
     return bibtex
 
 # Example
-bibtex = get_bibtex("204e3073870fae3d05bcbc2f6a8e263d9b72e776")
+bibtex = get_bibtex("10.18653/v1/N19-1423")
 print(bibtex)
 ```
 
 ### Citation Context
 
 ```python
-def get_citation_context(paper_id, limit=10):
-    """Get papers that cite this work with context."""
+def get_citing_works(openalex_id, limit=10):
+    """Get papers that cite this work via OpenAlex."""
     resp = requests.get(
-        f"{S2_API}/paper/{paper_id}/citations",
+        f"{OA_API}/works",
         params={
-            "fields": "title,year,contexts,intents",
-            "limit": limit,
+            "filter": f"cites:{openalex_id}",
+            "per_page": limit,
+            "sort": "cited_by_count:desc",
         },
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"},
     )
-    citations = resp.json().get("data", [])
+    results = resp.json().get("results", [])
 
-    for cit in citations:
-        paper = cit["citingPaper"]
-        print(f"\n{paper['title']} ({paper.get('year', '?')})")
-        for ctx in cit.get("contexts", [])[:2]:
-            print(f"  Context: ...{ctx[:100]}...")
-        print(f"  Intent: {cit.get('intents', ['unknown'])}")
+    for paper in results:
+        authors = [a["author"]["display_name"] for a in paper.get("authorships", [])[:3]]
+        print(f"\n{paper.get('title')} ({paper.get('publication_year', '?')})")
+        print(f"  Authors: {', '.join(authors)}")
+        print(f"  Citations: {paper.get('cited_by_count', 0)}")
 
-get_citation_context("204e3073870fae3d05bcbc2f6a8e263d9b72e776")
+get_citing_works("W2741809807")
 ```
 
 ### Related Paper Discovery
 
 ```python
-def find_related(paper_id, limit=10):
-    """Find papers related to a given paper."""
+def find_related(openalex_id, limit=10):
+    """Find papers related to a given paper via OpenAlex."""
+    # Get the paper's concepts, then search for similar works
     resp = requests.get(
-        f"{S2_API}/paper/{paper_id}/recommendations",
+        f"{OA_API}/works/{openalex_id}",
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"},
+    )
+    paper = resp.json()
+    concepts = [c["display_name"] for c in paper.get("concepts", [])[:3]]
+
+    related_resp = requests.get(
+        f"{OA_API}/works",
         params={
-            "fields": "title,authors,year,citationCount",
-            "limit": limit,
+            "search": " ".join(concepts),
+            "per_page": limit,
+            "sort": "cited_by_count:desc",
         },
+        headers={"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"},
     )
-    return resp.json().get("recommendedPapers", [])
+    return related_resp.json().get("results", [])
 
-related = find_related("204e3073870fae3d05bcbc2f6a8e263d9b72e776")
+related = find_related("W2741809807")
 for p in related:
-    print(f"[{p['year']}] {p['title']} ({p['citationCount']} cites)")
+    print(f"[{p.get('publication_year')}] {p.get('title')} ({p.get('cited_by_count')} cites)")
 ```
 
 ## Workflow Integration
@@ -161,10 +173,11 @@ def build_bibliography(queries, output_file="refs.bib"):
     for query in queries:
         papers = search_papers(query, limit=3)
         for paper in papers:
-            pid = paper.get("paperId")
-            if pid and pid not in seen_ids:
-                seen_ids.add(pid)
-                bibtex = get_bibtex(pid)
+            doi = paper.get("doi")
+            if doi and doi not in seen_ids:
+                seen_ids.add(doi)
+                bibtex = get_bibtex(doi.replace("https://doi.org/", ""))
+
                 all_bibtex.append(bibtex)
 
     with open(output_file, "w") as f:
@@ -189,4 +202,5 @@ build_bibliography([
 ## References
 
 - [Citation Assistant GitHub](https://github.com/ZhangNy301/citation-assistant)
-- [Semantic Scholar API](https://api.semanticscholar.org/)
+- [OpenAlex API](https://api.openalex.org/)
+- [CrossRef API](https://api.crossref.org/)

package/skills/writing/citation/onecite-reference-guide/SKILL.md

@@ -14,7 +14,7 @@ metadata:
 
 ## Overview
 
-OneCite is an AI-powered toolkit for parsing, completing, and formatting academic references. Given incomplete or messy citation strings, it extracts structured metadata, fills in missing fields via API lookups (CrossRef, Semantic Scholar), and outputs clean formatted references in any style (APA, MLA, BibTeX, Chicago). Available as a Python library and MCP server for agent integration.
+OneCite is an AI-powered toolkit for parsing, completing, and formatting academic references. Given incomplete or messy citation strings, it extracts structured metadata, fills in missing fields via API lookups (CrossRef, OpenAlex), and outputs clean formatted references in any style (APA, MLA, BibTeX, Chicago). Available as a Python library and MCP server for agent integration.
 
 ## Installation
 

package/skills/writing/citation/zotero-reference-guide/SKILL.md

@@ -38,7 +38,7 @@ The plugin is particularly powerful for literature reviews, where you need to sy
 - Identifies DOIs, arXiv IDs, and other persistent identifiers within references
 
 **Database Matching**
-- Matches parsed references against Crossref, Semantic Scholar, and other academic databases
+- Matches parsed references against Crossref, OpenAlex, and other academic databases
 - Retrieves complete metadata for matched references (abstract, keywords, citation count)
 - Displays match confidence to help users verify correct identification
 - Supports manual correction when automatic matching fails

package/skills/writing/citation/zotero-scholar-guide/SKILL.md

@@ -16,7 +16,7 @@ metadata:
 
 Zotero is the most widely used open-source reference manager in academia, offering a powerful combination of local storage, cloud sync, browser integration, and a comprehensive API. While most researchers use Zotero through its desktop application and browser connector, the Zotero API enables programmatic access that is essential for automated research workflows—saving papers from scripts, batch-importing search results, organizing libraries algorithmically, and integrating reference management into custom research pipelines.
 
-This skill covers using the Zotero Web API to create, read, update, and organize library items programmatically. It is designed for researchers who want to automate parts of their reference management workflow: importing papers from arXiv or Semantic Scholar searches directly into Zotero, auto-tagging papers based on content analysis, organizing collections programmatically, and exporting citations in various formats.
+This skill covers using the Zotero Web API to create, read, update, and organize library items programmatically. It is designed for researchers who want to automate parts of their reference management workflow: importing papers from arXiv or OpenAlex searches directly into Zotero, auto-tagging papers based on content analysis, organizing collections programmatically, and exporting citations in various formats.
 
 The skill complements the existing `zotero-api` skill by focusing specifically on practical scholar workflows—the common patterns a researcher uses when integrating Zotero into their daily literature management.
 

package/src/tools/arxiv.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum } from "./util.js";
 
 const BASE = "https://export.arxiv.org/api/query";
 
@@ -109,11 +109,18 @@ export function createArxivTools(
         sort_by?: string;
         sort_order?: string;
       }) => {
+        if (!input?.query || input.query.trim() === "" || input.query === "undefined") {
+          return toolResult({ error: "query parameter is required and must not be empty" });
+        }
+
+        const SORT_BY = ["relevance", "lastUpdatedDate", "submittedDate"] as const;
+        const SORT_ORDER = ["ascending", "descending"] as const;
+
         const params = new URLSearchParams({
           search_query: input.query,
           max_results: String(Math.min(input.max_results ?? 10, 50)),
-          sortBy: input.sort_by ?? "relevance",
-          sortOrder: input.sort_order ?? "descending",
+          sortBy: validEnum(input.sort_by, SORT_BY, "relevance"),
+          sortOrder: validEnum(input.sort_order, SORT_ORDER, "descending"),
         });
 
         const tracked = await trackedFetch("arxiv", `${BASE}?${params}`, undefined, 15_000);
@@ -151,6 +158,9 @@ export function createArxivTools(
         }),
       }),
       execute: async (input: { arxiv_id: string }) => {
+        if (!input?.arxiv_id) {
+          return toolResult({ error: 'arxiv_id parameter is required (e.g., "2301.00001" or "2301.00001v2")' });
+        }
         const id = input.arxiv_id.replace("arXiv:", "").replace(/https?:\/\/arxiv\.org\/abs\//, "");
         const params = new URLSearchParams({ id_list: id });
 

package/src/tools/biorxiv.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum } from "./util.js";
 
 const BASE = "https://api.biorxiv.org";
 
@@ -13,17 +13,24 @@ export function createBiorxivTools(
       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').",
+        "Get recent bioRxiv preprints by date range. Covers biology preprints (300K+). Use a date range like '2026-03-01/2026-03-18'. Returns up to 100 preprints per page.",
       parameters: Type.Object({
         interval: Type.String({
           description:
-            "Date range 'YYYY-MM-DD/YYYY-MM-DD', recent count '50', or recent days '7d'",
+            "Date range in YYYY-MM-DD/YYYY-MM-DD format (e.g. '2026-03-01/2026-03-18'). Use today's date for most recent.",
         }),
         cursor: Type.Optional(
           Type.Number({ description: "Pagination offset (default 0, each page returns up to 100)" }),
         ),
       }),
       execute: async (input: { interval: string; cursor?: number }) => {
+        if (!input?.interval) {
+          return toolResult({ error: 'interval parameter is required (date range in YYYY-MM-DD/YYYY-MM-DD format, e.g. "2026-03-01/2026-03-18")' });
+        }
+        // Validate date range format — bioRxiv API only accepts YYYY-MM-DD/YYYY-MM-DD
+        if (!/^\d{4}-\d{2}-\d{2}\/\d{4}-\d{2}-\d{2}$/.test(input.interval)) {
+          return toolResult({ error: `Invalid interval format "${input.interval}". Must be YYYY-MM-DD/YYYY-MM-DD (e.g. "2026-03-01/2026-03-18")` });
+        }
         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;
@@ -63,13 +70,19 @@ export function createBiorxivTools(
       parameters: Type.Object({
         interval: Type.String({
           description:
-            "Date range 'YYYY-MM-DD/YYYY-MM-DD', recent count '50', or recent days '7d'",
+            "Date range in YYYY-MM-DD/YYYY-MM-DD format (e.g. '2026-03-01/2026-03-18'). Use today's date for most recent.",
         }),
         cursor: Type.Optional(
           Type.Number({ description: "Pagination offset (default 0)" }),
         ),
       }),
       execute: async (input: { interval: string; cursor?: number }) => {
+        if (!input?.interval) {
+          return toolResult({ error: 'interval parameter is required (date range in YYYY-MM-DD/YYYY-MM-DD format, e.g. "2026-03-01/2026-03-18")' });
+        }
+        if (!/^\d{4}-\d{2}-\d{2}\/\d{4}-\d{2}-\d{2}$/.test(input.interval)) {
+          return toolResult({ error: `Invalid interval format "${input.interval}". Must be YYYY-MM-DD/YYYY-MM-DD (e.g. "2026-03-01/2026-03-18")` });
+        }
         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;
@@ -112,7 +125,10 @@ export function createBiorxivTools(
         ),
       }),
       execute: async (input: { doi: string; server?: string }) => {
-        const server = input.server ?? "biorxiv";
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1101/2024.01.15.575123")' });
+        }
+        const server = validEnum(input.server, ["biorxiv", "medrxiv"] as const, "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;

package/src/tools/crossref.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam } from "./util.js";
 
 const BASE = "https://api.crossref.org";
 
@@ -24,6 +24,9 @@ export function createCrossRefTools(
         }),
       }),
       execute: async (input: { doi: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
+        }
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
         const tracked = await trackedFetch("crossref", `${BASE}/works/${encodeURIComponent(doi)}`, { headers });
         if (isTrackedError(tracked)) return tracked;
@@ -111,16 +114,20 @@ export function createCrossRefTools(
         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}`);
+        const type = validParam(input.type);
+        if (type) filters.push(`type:${type}`);
         if (input.has_abstract) filters.push("has-abstract:true");
-        if (input.issn) filters.push(`issn:${input.issn}`);
+        const issn = validParam(input.issn);
+        if (issn) filters.push(`issn:${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);
+        const journal = validParam(input.journal);
+        if (journal) params.set("query.container-title", journal);
 
-        if (input.sort) {
-          params.set("sort", input.sort);
+        const sort = validParam(input.sort);
+        if (sort) {
+          params.set("sort", sort);
           params.set("order", "desc");
         }
 

package/src/tools/datacite.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam } from "./util.js";
 
 const BASE = "https://api.datacite.org";
 
@@ -42,8 +42,9 @@ export function createDataCiteTools(
           query: input.query,
           "page[size]": String(pageSize),
         });
-        if (input.resource_type) {
-          params.set("resource-type-id", input.resource_type.toLowerCase());
+        const resourceType = validParam(input.resource_type);
+        if (resourceType) {
+          params.set("resource-type-id", resourceType.toLowerCase());
         }
         if (input.from_year) {
           params.set("query", `${input.query} AND publicationYear:[${input.from_year} TO *]`);
@@ -118,6 +119,9 @@ export function createDataCiteTools(
         }),
       }),
       execute: async (input: { doi: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.5281/zenodo.1234567")' });
+        }
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
 
         const tracked = await trackedFetch(

package/src/tools/doaj.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam } from "./util.js";
 
 const BASE = "https://doaj.org/api";
 
@@ -39,7 +39,8 @@ export function createDoajTools(
         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 sort = validParam(input.sort);
+        if (sort) url += `&sort=${encodeURIComponent(sort)}`;
 
         const tracked = await trackedFetch("doaj", url);
         if (isTrackedError(tracked)) return tracked;

package/src/tools/europe-pmc.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam, validEnum } from "./util.js";
 
 const BASE = "https://www.ebi.ac.uk/europepmc/webservices/rest";
 
@@ -43,8 +43,9 @@ export function createEuropePmcTools(
           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 sort = validParam(input.sort);
+        if (sort) params.set("sort", sort);
+        params.set("cursorMark", validParam(input.cursor) ?? "*");
 
         const tracked = await trackedFetch("europe_pmc", `${BASE}/search?${params}`);
         if (isTrackedError(tracked)) return tracked;

package/src/tools/hal.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam, validEnum } from "./util.js";
 
 const BASE = "https://api.archives-ouvertes.fr";
 
@@ -56,8 +56,9 @@ export function createHalTools(
         doc_type?: string;
       }) => {
         let q = input.query;
-        if (input.doc_type) {
-          q = `(${q}) AND docType_s:${input.doc_type}`;
+        const docType = validParam(input.doc_type);
+        if (docType) {
+          q = `(${q}) AND docType_s:${docType}`;
         }
 
         const params = new URLSearchParams({
@@ -66,7 +67,8 @@ export function createHalTools(
           rows: String(Math.min(input.rows ?? 10, 100)),
           wt: "json",
         });
-        if (input.sort) params.set("sort", input.sort);
+        const sort = validParam(input.sort);
+        if (sort) params.set("sort", sort);
 
         const result = await trackedFetch(
           "hal",

package/src/tools/inspire-hep.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum } from "./util.js";
 
 const BASE = "https://inspirehep.net/api";
 
@@ -99,10 +99,11 @@ export function createInspireHepTools(
         ),
       }),
       execute: async (input: { query: string; size?: number; sort?: string }) => {
+        const sort = validEnum(input.sort, ["mostrecent", "mostcited", "bestmatch"] as const, "bestmatch");
         const params = new URLSearchParams({
           q: input.query,
           size: String(Math.min(input.size ?? 10, 100)),
-          sort: input.sort ?? "bestmatch",
+          sort,
         });
 
         const result = await trackedFetch(

package/src/tools/openaire.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam } from "./util.js";
 
 const BASE = "https://api.openaire.eu";
 
@@ -127,12 +127,17 @@ export function createOpenAireTools(
           format: "json",
           size: String(Math.min(input.max_results ?? 10, 50)),
         });
-        if (input.author) params.set("author", input.author);
-        if (input.doi) params.set("doi", input.doi);
-        if (input.from_date) params.set("fromDateAccepted", input.from_date);
-        if (input.to_date) params.set("toDateAccepted", input.to_date);
+        const author = validParam(input.author);
+        if (author) params.set("author", author);
+        const doi = validParam(input.doi);
+        if (doi) params.set("doi", doi);
+        const fromDate = validParam(input.from_date);
+        if (fromDate) params.set("fromDateAccepted", fromDate);
+        const toDate = validParam(input.to_date);
+        if (toDate) params.set("toDateAccepted", toDate);
         if (input.oa_only) params.set("OA", "true");
-        if (input.funder) params.set("funder", input.funder);
+        const funder = validParam(input.funder);
+        if (funder) params.set("funder", funder);
 
         const tracked = await trackedFetch("openaire", `${BASE}/search/publications?${params}`, undefined, 15_000);
         if (isTrackedError(tracked)) return tracked;

package/src/tools/openalex.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam, validEnum } from "./util.js";
 
 const BASE = "https://api.openalex.org";
 
@@ -46,6 +46,12 @@ export function createOpenAlexTools(
         open_access?: boolean;
         sort_by?: string;
       }) => {
+        if (!input?.query || input.query.trim() === "" || input.query === "undefined") {
+          return toolResult({ error: "query parameter is required and must not be empty" });
+        }
+
+        const SORT_BY = ["cited_by_count", "publication_date", "relevance_score"] as const;
+
         const filters: string[] = [];
         if (input.from_year) filters.push(`from_publication_date:${input.from_year}-01-01`);
         if (input.to_year) filters.push(`to_publication_date:${input.to_year}-12-31`);
@@ -56,7 +62,10 @@ export function createOpenAlexTools(
           per_page: String(Math.min(input.limit ?? 10, 200)),
         });
         if (filters.length > 0) params.set("filter", filters.join(","));
-        if (input.sort_by) params.set("sort", input.sort_by);
+        const sortBy = validParam(input.sort_by);
+        if (sortBy && (SORT_BY as readonly string[]).includes(sortBy)) {
+          params.set("sort", sortBy);
+        }
 
         const tracked = await trackedFetch("openalex", `${BASE}/works?${params}`, { headers });
         if (isTrackedError(tracked)) return tracked;
@@ -94,6 +103,9 @@ export function createOpenAlexTools(
         }),
       }),
       execute: async (input: { work_id: string }) => {
+        if (!input?.work_id) {
+          return toolResult({ error: 'work_id parameter is required (e.g., "W2741809807" or a DOI like "10.1234/example")' });
+        }
         const id = input.work_id.startsWith("10.")
           ? `https://doi.org/${input.work_id}`
           : input.work_id;
@@ -135,6 +147,9 @@ export function createOpenAlexTools(
         }),
       }),
       execute: async (input: { author_id: string }) => {
+        if (!input?.author_id) {
+          return toolResult({ error: 'author_id parameter is required (OpenAlex ID e.g. "A5023888391", ORCID, or author name)' });
+        }
         let url: string;
         if (
           input.author_id.startsWith("A") ||

package/src/tools/opencitations.ts

@@ -29,6 +29,9 @@ export function createOpenCitationsTools(
         }),
       }),
       execute: async (input: { doi: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
+        }
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
         const tracked = await trackedFetch("opencitations", `${BASE}/index/v2/citations/doi:${encodeURIComponent(doi)}`);
         if (isTrackedError(tracked)) return tracked;
@@ -58,6 +61,9 @@ export function createOpenCitationsTools(
         }),
       }),
       execute: async (input: { doi: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
+        }
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
         const tracked = await trackedFetch("opencitations", `${BASE}/index/v2/references/doi:${encodeURIComponent(doi)}`);
         if (isTrackedError(tracked)) return tracked;
@@ -87,6 +93,9 @@ export function createOpenCitationsTools(
         }),
       }),
       execute: async (input: { doi: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
+        }
         const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
         const tracked = await trackedFetch("opencitations", `${BASE}/index/v2/citation-count/doi:${encodeURIComponent(doi)}`);
         if (isTrackedError(tracked)) return tracked;