@wentorai/research-plugins 1.4.0 → 1.4.2

package/skills/tools/scraping/google-scholar-scraper/SKILL.md

@@ -41,7 +41,7 @@ Ethical guidelines:
     OpenAlex could answer it instead
 
 Official and semi-official alternatives:
-  - Semantic Scholar API: free, 100 requests/sec, excellent coverage
+  - OpenAlex API: free, no key required, excellent coverage
   - OpenAlex API: free, comprehensive, well-documented
   - Crossref API: free, DOI-based metadata and citation counts
   - CORE API: free, full-text open access content
@@ -232,12 +232,12 @@ OpenAlex (openalex.org):
   - Data: titles, abstracts, citations, authors, institutions
   - Best for: large-scale bibliometric analysis
 
-Semantic Scholar (semanticscholar.org):
-  - Coverage: 200M+ papers
-  - API: REST, free key available
-  - Rate limit: 100 requests/sec with API key
-  - Data: titles, abstracts, citations, citation contexts, TLDR
-  - Best for: citation analysis, NLP on papers
+OpenAlex (openalex.org):
+  - Coverage: 250M+ works, all disciplines
+  - API: REST, no key required
+  - Rate limit: ~10 requests/sec polite
+  - Data: titles, abstracts, citations, concepts, author profiles
+  - Best for: cross-disciplinary analysis, open data research
 
 Crossref (crossref.org):
   - Coverage: 130M+ DOIs

package/skills/writing/citation/SKILL.md

@@ -11,7 +11,7 @@ Select the skill matching the user's need, then `read` its SKILL.md.
 |-------|-------------|
 | [academic-citation-manager](./academic-citation-manager/SKILL.md) | Manage academic citations across BibTeX, APA, MLA, and Chicago formats |
 | [bibtex-management-guide](./bibtex-management-guide/SKILL.md) | Clean, format, deduplicate, and manage BibTeX bibliography files for LaTeX |
-| [citation-assistant-skill](./citation-assistant-skill/SKILL.md) | Claude Code skill for citation workflow via Semantic Scholar |
+| [citation-assistant-skill](./citation-assistant-skill/SKILL.md) | Claude Code skill for citation workflow via OpenAlex and CrossRef |
 | [citation-style-guide](./citation-style-guide/SKILL.md) | APA, MLA, Chicago citation format guide with CSL configuration |
 | [jabref-reference-guide](./jabref-reference-guide/SKILL.md) | Guide to JabRef open-source BibTeX and BibLaTeX reference manager |
 | [jasminum-zotero-guide](./jasminum-zotero-guide/SKILL.md) | Guide to Jasminum for retrieving CNKI Chinese academic metadata in Zotero |

package/skills/writing/citation/academic-citation-manager/SKILL.md

@@ -18,7 +18,7 @@ Manage academic citations across multiple formats (BibTeX, APA 7th, MLA 9th, Chi
 
 Citation management is a persistent friction point in academic writing. Researchers collect references from multiple sources (databases, PDFs, colleagues, web pages), store them in different formats, and must output them in the specific style required by each target journal. Errors in citations -- misspelled author names, incorrect years, broken DOIs, inconsistent formatting -- are among the most common reasons for desk rejection and reviewer criticism.
 
-This skill provides a comprehensive citation management workflow that goes beyond what GUI reference managers offer. It can retrieve complete metadata from a DOI in seconds, convert between any citation format, detect and merge duplicate entries, validate entries against CrossRef and Semantic Scholar databases, and generate properly formatted bibliographies for any major citation style.
+This skill provides a comprehensive citation management workflow that goes beyond what GUI reference managers offer. It can retrieve complete metadata from a DOI in seconds, convert between any citation format, detect and merge duplicate entries, validate entries against CrossRef and OpenAlex databases, and generate properly formatted bibliographies for any major citation style.
 
 The approach is text-based and scriptable, making it ideal for integration with LaTeX workflows, Markdown writing pipelines, and automated document generation. All citation data is stored in standard BibTeX format as the canonical source, with on-demand conversion to other formats for specific manuscript requirements.
 
@@ -52,33 +52,36 @@ print(bibtex)
 # }
 ```
 
-### From Semantic Scholar
+### From OpenAlex
 
 ```python
-def get_citation_from_s2(paper_id):
-    """Retrieve citation data from Semantic Scholar API."""
-    url = f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}"
-    params = {"fields": "title,authors,year,venue,doi,citationCount,externalIds"}
-    response = requests.get(url, params=params)
+def get_citation_from_openalex(work_id):
+    """Retrieve citation data from OpenAlex API."""
+    url = f"https://api.openalex.org/works/{work_id}"
+    headers = {"User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)"}
+    response = requests.get(url, headers=headers)
     if response.status_code == 200:
         data = response.json()
         return format_as_bibtex(data)
     return None
 
-def format_as_bibtex(s2_data):
-    """Convert Semantic Scholar data to BibTeX."""
-    authors = s2_data.get("authors", [])
-    author_str = " and ".join(a["name"] for a in authors)
-    first_author = authors[0]["name"].split()[-1] if authors else "Unknown"
-    year = s2_data.get("year", "")
+def format_as_bibtex(oa_data):
+    """Convert OpenAlex data to BibTeX."""
+    authorships = oa_data.get("authorships", [])
+    author_str = " and ".join(a["author"]["display_name"] for a in authorships)
+    first_author = authorships[0]["author"]["display_name"].split()[-1] if authorships else "Unknown"
+    year = str(oa_data.get("publication_year", ""))
     key = f"{first_author}_{year}"
 
+    venue = oa_data.get("primary_location", {}) or {}
+    journal = (venue.get("source") or {}).get("display_name", "")
+
     return f"""@article{{{key},
-  title={{{s2_data.get('title', '')}}},
+  title={{{oa_data.get('title', '')}}},
   author={{{author_str}}},
   year={{{year}}},
-  journal={{{s2_data.get('venue', '')}}},
-  doi={{{s2_data.get('doi', '')}}}
+  journal={{{journal}}},
+  doi={{{oa_data.get('doi', '')}}}
 }}"""
 ```
 
@@ -308,7 +311,7 @@ pandoc paper.md --citeproc --bibliography=references.bib \
 ## References
 
 - CrossRef API: https://api.crossref.org
-- Semantic Scholar API: https://api.semanticscholar.org
+- OpenAlex API: https://api.openalex.org
 - APA 7th Edition Manual: https://apastyle.apa.org/products/publication-manual-7th-edition
 - BibTeX documentation: http://www.bibtex.org
 - CSL styles repository: https://github.com/citation-style-language/styles

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

@@ -151,6 +151,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

@@ -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,6 +125,9 @@ export function createBiorxivTools(
         ),
       }),
       execute: async (input: { doi: string; server?: string }) => {
+        if (!input?.doi) {
+          return toolResult({ error: 'doi parameter is required (e.g., "10.1101/2024.01.15.575123")' });
+        }
         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);

package/src/tools/crossref.ts

@@ -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;

package/src/tools/datacite.ts

@@ -118,6 +118,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/openalex.ts

@@ -94,6 +94,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 +138,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;

package/src/tools/orcid.ts

@@ -72,6 +72,9 @@ export function createOrcidTools(
         }),
       }),
       execute: async (input: { orcid: string }) => {
+        if (!input?.orcid) {
+          return toolResult({ error: 'orcid parameter is required (e.g., "0000-0002-1825-0097")' });
+        }
         const orcid = input.orcid.replace(/^https?:\/\/orcid\.org\//, "");
 
         const result = await trackedFetch(

package/src/tools/pubmed.ts

@@ -109,6 +109,9 @@ export function createPubMedTools(
         pmid: Type.String({ description: "PubMed ID (numeric string)" }),
       }),
       execute: async (input: { pmid: string }) => {
+        if (!input?.pmid) {
+          return toolResult({ error: 'pmid parameter is required (numeric PubMed ID, e.g., "33116299")' });
+        }
         const params = new URLSearchParams({
           db: "pubmed",
           id: input.pmid,

package/src/tools/unpaywall.ts

@@ -22,6 +22,9 @@ export function createUnpaywallTools(
         }),
       }),
       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(
           "unpaywall",

package/src/tools/zenodo.ts

@@ -103,6 +103,9 @@ export function createZenodoTools(
         }),
       }),
       execute: async (input: { record_id: string }) => {
+        if (!input?.record_id) {
+          return toolResult({ error: 'record_id parameter is required (e.g., "1234567")' });
+        }
         const id = input.record_id.replace(/\D/g, "");
         const result = await trackedFetch("zenodo", `${BASE}/records/${id}`, undefined, 10_000);
         if (isTrackedError(result)) return result;