@wentorai/research-plugins 1.4.3 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wentorai/research-plugins",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "type": "module",
   "description": "438 academic research skills, 34 agent tools across 18 API modules, and 6 curated lists for Research-Claw and AI agents",
   "keywords": [

package/skills/literature/search/arxiv-api/SKILL.md

@@ -24,12 +24,21 @@ The API is free to use with no authentication required. It supports complex bool
 
 No authentication required. The arXiv API is fully open. However, users must respect the rate limit of 3 requests per second. Excessive usage may result in temporary IP-based blocking. Including a descriptive User-Agent header is considered good practice.
 
-## Core Endpoints
+## Using the `search_arxiv` Tool
+
+**IMPORTANT:** When calling the `search_arxiv` tool, use parameter name `query` (NOT
+`search_query`). The raw API uses `search_query`, but the tool wrapper accepts `query`.
+
+```
+search_arxiv({ query: "ti:transformer AND cat:cs.CL", sort_by: "submittedDate" })
+```
+
+## Core Endpoints (Raw API Reference)
 
 ### Query: Search for Articles
 
 - **URL**: `GET http://export.arxiv.org/api/query`
-- **Parameters**:
+- **Parameters** (raw API — the `search_arxiv` tool wraps these automatically):
   | Param | Type | Required | Description |
   |-------|------|----------|-------------|
   | search_query | string | Yes | Query string using arXiv field prefixes (ti, au, abs, cat, id) |

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, validEnum } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum, validParam } from "./util.js";
 
 const BASE = "https://export.arxiv.org/api/query";
 
@@ -103,21 +103,27 @@ export function createArxivTools(
           Type.String({ description: "Sort order: 'ascending' or 'descending'" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         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 query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Use the tool parameter 'query' (not 'search_query'). " +
+              "Example: search_arxiv({ query: \"ti:transformer AND cat:cs.CL\" })",
+          });
         }
 
         const SORT_BY = ["relevance", "lastUpdatedDate", "submittedDate"] as const;
         const SORT_ORDER = ["ascending", "descending"] as const;
 
         const params = new URLSearchParams({
-          search_query: input.query,
+          search_query: query,
           max_results: String(Math.min(input.max_results ?? 10, 50)),
           sortBy: validEnum(input.sort_by, SORT_BY, "relevance"),
           sortOrder: validEnum(input.sort_order, SORT_ORDER, "descending"),
@@ -157,7 +163,7 @@ export function createArxivTools(
           description: "arXiv paper ID, e.g. '2301.00001' or '2301.00001v2'",
         }),
       }),
-      execute: async (input: { arxiv_id: string }) => {
+      execute: async (_toolCallId: string, input: { arxiv_id: string }) => {
         if (!input?.arxiv_id) {
           return toolResult({ error: 'arxiv_id parameter is required (e.g., "2301.00001" or "2301.00001v2")' });
         }

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, validEnum } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum, validParam } from "./util.js";
 
 const BASE = "https://api.biorxiv.org";
 
@@ -23,16 +23,17 @@ export function createBiorxivTools(
           Type.Number({ description: "Pagination offset (default 0, each page returns up to 100)" }),
         ),
       }),
-      execute: async (input: { interval: string; cursor?: number }) => {
-        if (!input?.interval) {
+      execute: async (_toolCallId: string, input: { interval: string; cursor?: number }) => {
+        const interval = validParam(input?.interval);
+        if (!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")` });
+        if (!/^\d{4}-\d{2}-\d{2}\/\d{4}-\d{2}-\d{2}$/.test(interval)) {
+          return toolResult({ error: `Invalid interval format "${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);
+        const cursor = input?.cursor ?? 0;
+        const tracked = await trackedFetch("biorxiv", `${BASE}/details/biorxiv/${interval}/${cursor}/json`, undefined, 30_000);
         if (isTrackedError(tracked)) return tracked;
         const data = await tracked.res.json();
 
@@ -76,15 +77,16 @@ export function createBiorxivTools(
           Type.Number({ description: "Pagination offset (default 0)" }),
         ),
       }),
-      execute: async (input: { interval: string; cursor?: number }) => {
-        if (!input?.interval) {
+      execute: async (_toolCallId: string, input: { interval: string; cursor?: number }) => {
+        const interval = validParam(input?.interval);
+        if (!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")` });
+        if (!/^\d{4}-\d{2}-\d{2}\/\d{4}-\d{2}-\d{2}$/.test(interval)) {
+          return toolResult({ error: `Invalid interval format "${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);
+        const cursor = input?.cursor ?? 0;
+        const tracked = await trackedFetch("medrxiv", `${BASE}/details/medrxiv/${interval}/${cursor}/json`, undefined, 30_000);
         if (isTrackedError(tracked)) return tracked;
         const data = await tracked.res.json();
 
@@ -124,7 +126,7 @@ export function createBiorxivTools(
           Type.String({ description: "Server: 'biorxiv' or 'medrxiv' (default: biorxiv)" }),
         ),
       }),
-      execute: async (input: { doi: string; server?: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string; server?: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1101/2024.01.15.575123")' });
         }

package/src/tools/crossref.ts

@@ -23,7 +23,7 @@ export function createCrossRefTools(
           description: "DOI to resolve, e.g. '10.1038/nature12373'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
         }
@@ -94,7 +94,7 @@ export function createCrossRefTools(
           Type.Number({ description: "Max results (default 10, max 100)" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         journal?: string;
         issn?: string;
@@ -105,8 +105,17 @@ export function createCrossRefTools(
         sort?: string;
         limit?: number;
       }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_crossref({ query: \"PFAS machine learning\", from_year: 2023 })",
+          });
+        }
+
         const params = new URLSearchParams({
-          query: input.query,
+          query,
           rows: String(Math.min(input.limit ?? 10, 100)),
         });
 

package/src/tools/datacite.ts

@@ -31,23 +31,31 @@ export function createDataCiteTools(
           Type.Number({ description: "Published from this year onward" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         resource_type?: string;
         from_year?: number;
       }) => {
-        const pageSize = Math.min(input.max_results ?? 10, 100);
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_datacite({ query: \"climate dataset\" })",
+          });
+        }
+        const pageSize = Math.min(input?.max_results ?? 10, 100);
         const params = new URLSearchParams({
-          query: input.query,
+          query,
           "page[size]": String(pageSize),
         });
         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 *]`);
+        if (input?.from_year) {
+          params.set("query", `${query} AND publicationYear:[${input.from_year} TO *]`);
         }
 
         const tracked = await trackedFetch("datacite", `${BASE}/dois?${params}`, undefined, 15_000);
@@ -118,7 +126,7 @@ export function createDataCiteTools(
           description: "DOI to resolve, e.g. '10.5281/zenodo.1234567'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.5281/zenodo.1234567")' });
         }

package/src/tools/dblp.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";
 
 export function createDblpTools(
   _ctx: OpenClawPluginToolContext,
@@ -23,13 +23,20 @@ export function createDblpTools(
           Type.Number({ description: "Result offset for pagination" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         offset?: number;
       }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error: "query parameter is required and must not be empty.",
+          });
+        }
+
         const params = new URLSearchParams({
-          q: input.query,
+          q: query,
           format: "json",
           h: String(Math.min(input.max_results ?? 10, 1000)),
         });
@@ -90,9 +97,16 @@ export function createDblpTools(
           Type.Number({ description: "Max results (default 10)" }),
         ),
       }),
-      execute: async (input: { query: string; max_results?: number }) => {
+      execute: async (_toolCallId: string, input: { query: string; max_results?: number }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error: "query parameter is required and must not be empty.",
+          });
+        }
+
         const params = new URLSearchParams({
-          q: input.query,
+          q: query,
           format: "json",
           h: String(Math.min(input.max_results ?? 10, 100)),
         });

package/src/tools/doaj.ts

@@ -29,16 +29,24 @@ export function createDoajTools(
           Type.String({ description: "Sort field, e.g. 'created_date:desc'" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         page?: number;
         sort?: string;
       }) => {
-        const pageSize = Math.min(input.max_results ?? 10, 100);
-        const page = input.page ?? 1;
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_doaj({ query: \"open access genomics\" })",
+          });
+        }
+        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}`;
+        let url = `${BASE}/search/articles/${encodeURIComponent(query)}?page=${page}&pageSize=${pageSize}`;
         const sort = validParam(input.sort);
         if (sort) url += `&sort=${encodeURIComponent(sort)}`;
 

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, validParam, validEnum } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validParam } from "./util.js";
 
 const BASE = "https://www.ebi.ac.uk/europepmc/webservices/rest";
 
@@ -31,14 +31,22 @@ export function createEuropePmcTools(
           Type.String({ description: "Pagination cursor (use value from previous response)" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         sort?: string;
         cursor?: string;
       }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_europe_pmc({ query: \"CRISPR gene editing\" })",
+          });
+        }
         const params = new URLSearchParams({
-          query: input.query,
+          query,
           format: "json",
           pageSize: String(Math.min(input.max_results ?? 10, 1000)),
           resultType: "core",
@@ -92,11 +100,14 @@ export function createEuropePmcTools(
         ),
         page: Type.Optional(Type.Number({ description: "Page number (default 1)" })),
       }),
-      execute: async (input: { pmid: string; max_results?: number; page?: number }) => {
+      execute: async (_toolCallId: string, input: { pmid: string; max_results?: number; page?: number }) => {
+        if (!input?.pmid) {
+          return toolResult({ error: 'pmid parameter is required (PubMed ID, e.g., "33116299")' });
+        }
         const params = new URLSearchParams({
           format: "json",
-          pageSize: String(input.max_results ?? 25),
-          page: String(input.page ?? 1),
+          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;
@@ -130,10 +141,13 @@ export function createEuropePmcTools(
           Type.Number({ description: "Max references to return (default 25)" }),
         ),
       }),
-      execute: async (input: { pmid: string; max_results?: number }) => {
+      execute: async (_toolCallId: string, input: { pmid: string; max_results?: number }) => {
+        if (!input?.pmid) {
+          return toolResult({ error: 'pmid parameter is required (PubMed ID, e.g., "33116299")' });
+        }
         const params = new URLSearchParams({
           format: "json",
-          pageSize: String(input.max_results ?? 25),
+          pageSize: String(input?.max_results ?? 25),
         });
         const tracked = await trackedFetch("europe_pmc", `${BASE}/MED/${input.pmid}/references?${params}`);
         if (isTrackedError(tracked)) return tracked;

package/src/tools/hal.ts

@@ -49,13 +49,21 @@ export function createHalTools(
           }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         rows?: number;
         sort?: string;
         doc_type?: string;
       }) => {
-        let q = input.query;
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_hal({ query: \"machine learning\" })",
+          });
+        }
+        let q = query;
         const docType = validParam(input.doc_type);
         if (docType) {
           q = `(${q}) AND docType_s:${docType}`;

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, validEnum } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError, validEnum, validParam } from "./util.js";
 
 const BASE = "https://inspirehep.net/api";
 
@@ -98,10 +98,17 @@ export function createInspireHepTools(
           }),
         ),
       }),
-      execute: async (input: { query: string; size?: number; sort?: string }) => {
+      execute: async (_toolCallId: string, input: { query: string; size?: number; sort?: string }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error: "query parameter is required and must not be empty.",
+          });
+        }
+
         const sort = validEnum(input.sort, ["mostrecent", "mostcited", "bestmatch"] as const, "bestmatch");
         const params = new URLSearchParams({
-          q: input.query,
+          q: query,
           size: String(Math.min(input.size ?? 10, 100)),
           sort,
         });
@@ -137,7 +144,10 @@ export function createInspireHepTools(
             "Paper identifier: arXiv ID (e.g. '1207.7214') or DOI (e.g. '10.1016/j.physletb.2012.08.020')",
         }),
       }),
-      execute: async (input: { identifier: string }) => {
+      execute: async (_toolCallId: string, input: { identifier: string }) => {
+        if (!input?.identifier) {
+          return toolResult({ error: 'identifier parameter is required (arXiv ID e.g. "1207.7214" or DOI e.g. "10.1016/j.physletb.2012.08.020")' });
+        }
         // Determine if it's a DOI or arXiv ID
         const id = input.identifier.trim();
         let url: string;

package/src/tools/openaire.ts

@@ -112,7 +112,7 @@ export function createOpenAireTools(
           Type.Number({ description: "Max results (default 10, max 50)" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         keywords: string;
         author?: string;
         doi?: string;
@@ -122,8 +122,16 @@ export function createOpenAireTools(
         funder?: string;
         max_results?: number;
       }) => {
+        const keywords = validParam(input?.keywords);
+        if (!keywords) {
+          return toolResult({
+            error:
+              "keywords parameter is required and must not be empty. " +
+              "Example: search_openaire({ keywords: \"machine learning\" })",
+          });
+        }
         const params = new URLSearchParams({
-          keywords: input.keywords,
+          keywords,
           format: "json",
           size: String(Math.min(input.max_results ?? 10, 50)),
         });

package/src/tools/openalex.ts

@@ -38,7 +38,7 @@ export function createOpenAlexTools(
           }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         limit?: number;
         from_year?: number;
@@ -46,7 +46,8 @@ export function createOpenAlexTools(
         open_access?: boolean;
         sort_by?: string;
       }) => {
-        if (!input?.query || input.query.trim() === "" || input.query === "undefined") {
+        const query = validParam(input?.query);
+        if (!query) {
           return toolResult({ error: "query parameter is required and must not be empty" });
         }
 
@@ -58,7 +59,7 @@ export function createOpenAlexTools(
         if (input.open_access) filters.push("is_oa:true");
 
         const params = new URLSearchParams({
-          search: input.query,
+          search: query,
           per_page: String(Math.min(input.limit ?? 10, 200)),
         });
         if (filters.length > 0) params.set("filter", filters.join(","));
@@ -102,7 +103,7 @@ export function createOpenAlexTools(
             "Work identifier: OpenAlex ID (e.g. 'W2741809807'), DOI URL, or PMID",
         }),
       }),
-      execute: async (input: { work_id: string }) => {
+      execute: async (_toolCallId: string, 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")' });
         }
@@ -146,7 +147,7 @@ export function createOpenAlexTools(
             "Author identifier: OpenAlex ID (e.g. 'A5023888391'), ORCID, or name search",
         }),
       }),
-      execute: async (input: { author_id: string }) => {
+      execute: async (_toolCallId: string, 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)' });
         }

package/src/tools/opencitations.ts

@@ -28,7 +28,7 @@ export function createOpenCitationsTools(
           description: "DOI of the paper, e.g. '10.1038/nature12373'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
         }
@@ -60,7 +60,7 @@ export function createOpenCitationsTools(
           description: "DOI of the paper, e.g. '10.1038/nature12373'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
         }
@@ -92,7 +92,7 @@ export function createOpenCitationsTools(
           description: "DOI of the paper, e.g. '10.1038/nature12373'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
         }

package/src/tools/orcid.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://pub.orcid.org/v3.0";
 
@@ -27,9 +27,16 @@ export function createOrcidTools(
           Type.Number({ description: "Max results (default 10, max 100)" }),
         ),
       }),
-      execute: async (input: { query: string; limit?: number }) => {
+      execute: async (_toolCallId: string, input: { query: string; limit?: number }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error: "query parameter is required and must not be empty.",
+          });
+        }
+
         const params = new URLSearchParams({
-          q: input.query,
+          q: query,
           rows: String(Math.min(input.limit ?? 10, 100)),
         });
 
@@ -71,7 +78,7 @@ export function createOrcidTools(
           description: "ORCID iD, e.g. '0000-0002-1825-0097'",
         }),
       }),
-      execute: async (input: { orcid: string }) => {
+      execute: async (_toolCallId: string, input: { orcid: string }) => {
         if (!input?.orcid) {
           return toolResult({ error: 'orcid parameter is required (e.g., "0000-0002-1825-0097")' });
         }

package/src/tools/osf-preprints.ts

@@ -28,17 +28,17 @@ export function createOsfPreprintsTools(
           Type.Number({ description: "Page number (default 1)" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         provider?: string;
         size?: number;
         page?: number;
       }) => {
         const params = new URLSearchParams({
-          "page[size]": String(Math.min(input.size ?? 10, 100)),
+          "page[size]": String(Math.min(input?.size ?? 10, 100)),
         });
-        const provider = validParam(input.provider);
+        const provider = validParam(input?.provider);
         if (provider) params.set("filter[provider]", provider);
-        if (input.page) params.set("page", String(input.page));
+        if (input?.page) params.set("page", String(input.page));
 
         const result = await trackedFetch(
           "osf_preprints",
@@ -58,7 +58,7 @@ export function createOsfPreprintsTools(
 
         return toolResult({
           total_results: linksMeta?.total,
-          page: input.page ?? 1,
+          page: input?.page ?? 1,
           source: "osf_preprints",
           preprints: (items ?? []).map((item) => {
             const attrs = item.attributes as Record<string, unknown> | undefined;

package/src/tools/pubmed.ts

@@ -34,20 +34,29 @@ export function createPubMedTools(
           Type.String({ description: "Max publication date (YYYY/MM/DD)" }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         max_results?: number;
         sort?: string;
         min_date?: string;
         max_date?: string;
       }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_pubmed({ query: \"CRISPR[Title] AND 2024[PDAT]\" })",
+          });
+        }
+
         const sort = validEnum(input.sort, ["relevance", "pub_date"] as const, "relevance");
         const minDate = validParam(input.min_date);
         const maxDate = validParam(input.max_date);
 
         const searchParams = new URLSearchParams({
           db: "pubmed",
-          term: input.query,
+          term: query,
           retmax: String(Math.min(input.max_results ?? 10, 100)),
           retmode: "json",
           sort,
@@ -112,7 +121,7 @@ export function createPubMedTools(
       parameters: Type.Object({
         pmid: Type.String({ description: "PubMed ID (numeric string)" }),
       }),
-      execute: async (input: { pmid: string }) => {
+      execute: async (_toolCallId: string, input: { pmid: string }) => {
         if (!input?.pmid) {
           return toolResult({ error: 'pmid parameter is required (numeric PubMed ID, e.g., "33116299")' });
         }

package/src/tools/ror.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.ror.org/v2";
 
@@ -22,9 +22,16 @@ export function createRorTools(
           Type.Number({ description: "Max results (default 10, max 50)" }),
         ),
       }),
-      execute: async (input: { query: string; max_results?: number }) => {
+      execute: async (_toolCallId: string, input: { query: string; max_results?: number }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error: "query parameter is required and must not be empty.",
+          });
+        }
+
         const params = new URLSearchParams({
-          query: input.query,
+          query,
         });
 
         const tracked = await trackedFetch("ror", `${BASE}/organizations?${params}`, undefined, 10_000);

package/src/tools/unpaywall.ts

@@ -21,7 +21,7 @@ export function createUnpaywallTools(
           description: "DOI of the paper, e.g. '10.1038/nature12373'",
         }),
       }),
-      execute: async (input: { doi: string }) => {
+      execute: async (_toolCallId: string, input: { doi: string }) => {
         if (!input?.doi) {
           return toolResult({ error: 'doi parameter is required (e.g., "10.1038/nature12373")' });
         }

package/src/tools/zenodo.ts

@@ -37,15 +37,23 @@ export function createZenodoTools(
           }),
         ),
       }),
-      execute: async (input: {
+      execute: async (_toolCallId: string, input: {
         query: string;
         type?: string;
         size?: number;
         sort?: string;
         access_right?: string;
       }) => {
+        const query = validParam(input?.query);
+        if (!query) {
+          return toolResult({
+            error:
+              "query parameter is required and must not be empty. " +
+              "Example: search_zenodo({ query: \"climate dataset\" })",
+          });
+        }
         const params = new URLSearchParams({
-          q: input.query,
+          q: query,
           size: String(Math.min(input.size ?? 10, 100)),
         });
         const type = validParam(input.type);
@@ -105,7 +113,7 @@ export function createZenodoTools(
           description: "Zenodo record ID (numeric), e.g. '7042164'",
         }),
       }),
-      execute: async (input: { record_id: string }) => {
+      execute: async (_toolCallId: string, input: { record_id: string }) => {
         if (!input?.record_id) {
           return toolResult({ error: 'record_id parameter is required (e.g., "1234567")' });
         }