@wentorai/research-plugins 1.3.1 → 1.4.0

package/src/tools/util.ts

@@ -9,3 +9,144 @@ export function toolResult(data: unknown) {
   const text = JSON.stringify(data, null, 2);
   return { content: [{ type: "text" as const, text }], details: data };
 }
+
+// ── Source Health Tracking ───────────────────────────────────────────────
+
+interface SourceHealthEntry {
+  source: string;
+  total_calls: number;
+  successes: number;
+  failures: number;
+  last_status: number | null;
+  last_latency_ms: number | null;
+  last_error: string | null;
+  avg_latency_ms: number;
+  last_called: string | null;
+}
+
+const healthRegistry = new Map<string, SourceHealthEntry>();
+
+function getOrCreateEntry(source: string): SourceHealthEntry {
+  let entry = healthRegistry.get(source);
+  if (!entry) {
+    entry = {
+      source,
+      total_calls: 0,
+      successes: 0,
+      failures: 0,
+      last_status: null,
+      last_latency_ms: null,
+      last_error: null,
+      avg_latency_ms: 0,
+      last_called: null,
+    };
+    healthRegistry.set(source, entry);
+  }
+  return entry;
+}
+
+function recordSuccess(entry: SourceHealthEntry, status: number, latencyMs: number) {
+  entry.total_calls++;
+  entry.successes++;
+  entry.last_status = status;
+  entry.last_latency_ms = latencyMs;
+  entry.last_error = null;
+  entry.last_called = new Date().toISOString();
+  entry.avg_latency_ms = Math.round(
+    (entry.avg_latency_ms * (entry.total_calls - 1) + latencyMs) / entry.total_calls,
+  );
+}
+
+function recordFailure(entry: SourceHealthEntry, error: string, status?: number) {
+  entry.total_calls++;
+  entry.failures++;
+  entry.last_status = status ?? null;
+  entry.last_error = error;
+  entry.last_called = new Date().toISOString();
+}
+
+export interface TrackedResponse {
+  res: Response;
+  latency_ms: number;
+  source: string;
+}
+
+/**
+ * Fetch with automatic source health tracking, timeout, and error handling.
+ *
+ * @param source - Source identifier (e.g. "europe_pmc", "dblp")
+ * @param url - Request URL
+ * @param options - Fetch options
+ * @param timeoutMs - Timeout in milliseconds (default: 10000)
+ * @returns TrackedResponse on success, or a toolResult error on failure
+ */
+export async function trackedFetch(
+  source: string,
+  url: string,
+  options?: RequestInit,
+  timeoutMs = 10_000,
+): Promise<TrackedResponse | ReturnType<typeof toolResult>> {
+  const entry = getOrCreateEntry(source);
+  const start = Date.now();
+
+  try {
+    const res = await fetch(url, {
+      ...options,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    const latency = Date.now() - start;
+
+    if (!res.ok) {
+      recordFailure(entry, `HTTP ${res.status} ${res.statusText}`, res.status);
+      return toolResult({
+        error: `${source} API error: ${res.status} ${res.statusText}`,
+        _source_health: {
+          source,
+          status: res.status,
+          latency_ms: latency,
+          success_rate: entry.total_calls > 0
+            ? `${Math.round((entry.successes / entry.total_calls) * 100)}%`
+            : "N/A",
+        },
+      });
+    }
+
+    recordSuccess(entry, res.status, latency);
+    return { res, latency_ms: latency, source };
+  } catch (err) {
+    const latency = Date.now() - start;
+    const message = err instanceof Error ? err.message : String(err);
+    const isTimeout = message.includes("abort") || message.includes("timeout");
+    recordFailure(entry, isTimeout ? `Timeout after ${timeoutMs}ms` : message);
+
+    return toolResult({
+      error: `${source} ${isTimeout ? "timeout" : "network error"}: ${message}`,
+      _source_health: {
+        source,
+        latency_ms: latency,
+        success_rate: entry.total_calls > 0
+          ? `${Math.round((entry.successes / entry.total_calls) * 100)}%`
+          : "N/A",
+        suggestion: isTimeout
+          ? "This source is slow. Try a different source or reduce result count."
+          : "This source may be temporarily unavailable. Try an alternative.",
+      },
+    });
+  }
+}
+
+/**
+ * Get health status for all tracked sources. Useful for agent decision-making.
+ */
+export function getSourceHealth(): SourceHealthEntry[] {
+  return Array.from(healthRegistry.values());
+}
+
+/**
+ * Check if a tracked fetch result is an error (toolResult) or success (TrackedResponse).
+ */
+export function isTrackedError(
+  result: TrackedResponse | ReturnType<typeof toolResult>,
+): result is ReturnType<typeof toolResult> {
+  return "content" in result && "details" in result;
+}

package/src/tools/zenodo.ts

@@ -0,0 +1,154 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://zenodo.org/api";
+
+export function createZenodoTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_zenodo",
+      label: "Search Records (Zenodo)",
+      description:
+        "Search Zenodo for open research data, software, publications, and other research outputs. Covers 3M+ records with DOIs. Uniquely includes datasets, software, presentations, and other non-publication outputs.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Search query" }),
+        type: Type.Optional(
+          Type.String({
+            description:
+              "Resource type filter: 'publication', 'dataset', 'software', 'image', 'video', 'lesson', 'poster', 'presentation'",
+          }),
+        ),
+        size: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort by: 'bestmatch' (relevance), 'mostrecent', '-mostrecent' (oldest first)",
+          }),
+        ),
+        access_right: Type.Optional(
+          Type.String({
+            description: "Access filter: 'open', 'embargoed', 'restricted', 'closed'",
+          }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        type?: string;
+        size?: number;
+        sort?: string;
+        access_right?: string;
+      }) => {
+        const params = new URLSearchParams({
+          q: input.query,
+          size: String(Math.min(input.size ?? 10, 100)),
+        });
+        if (input.type) params.set("type", input.type);
+        if (input.sort) params.set("sort", input.sort);
+        if (input.access_right) params.set("access_right", input.access_right);
+
+        const result = await trackedFetch("zenodo", `${BASE}/records?${params}`, undefined, 10_000);
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        return toolResult({
+          total_results: data.hits?.total,
+          source: "zenodo",
+          records: data.hits?.hits?.map(
+            (h: Record<string, unknown>) => {
+              const meta = h.metadata as Record<string, unknown> | undefined;
+              const creators = meta?.creators as Array<{ name: string; affiliation?: string }> | undefined;
+              const resourceType = meta?.resource_type as Record<string, string> | undefined;
+              const license = meta?.license as Record<string, string> | undefined;
+
+              return {
+                id: h.id,
+                doi: meta?.doi ?? h.doi,
+                title: meta?.title ?? h.title,
+                authors: creators?.map((c) => c.name),
+                year: meta?.publication_date
+                  ? String(meta.publication_date).slice(0, 4)
+                  : undefined,
+                publication_date: meta?.publication_date,
+                resource_type: resourceType?.type,
+                access_right: meta?.access_right,
+                keywords: meta?.keywords,
+                license: license?.id,
+                description: meta?.description
+                  ? String(meta.description).replace(/<[^>]*>/g, "").slice(0, 300)
+                  : undefined,
+                url: (h.links as Record<string, string>)?.self_html
+                  ?? `https://zenodo.org/records/${h.id}`,
+                source: "zenodo",
+              };
+            },
+          ),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+    {
+      name: "get_zenodo_record",
+      label: "Get Record Details (Zenodo)",
+      description:
+        "Get full details of a specific Zenodo record by its numeric ID. Returns metadata, files, and download links.",
+      parameters: Type.Object({
+        record_id: Type.String({
+          description: "Zenodo record ID (numeric), e.g. '7042164'",
+        }),
+      }),
+      execute: async (input: { record_id: string }) => {
+        const id = input.record_id.replace(/\D/g, "");
+        const result = await trackedFetch("zenodo", `${BASE}/records/${id}`, undefined, 10_000);
+        if (isTrackedError(result)) return result;
+        const h = await result.res.json();
+
+        const meta = h.metadata as Record<string, unknown> | undefined;
+        const creators = meta?.creators as Array<{ name: string; affiliation?: string }> | undefined;
+        const resourceType = meta?.resource_type as Record<string, string> | undefined;
+        const license = meta?.license as Record<string, string> | undefined;
+        const files = h.files as Array<{ key: string; size: number; links?: Record<string, string> }> | undefined;
+        const stats = h.stats as Record<string, number> | undefined;
+
+        return toolResult({
+          id: h.id,
+          doi: meta?.doi ?? h.doi,
+          title: meta?.title ?? h.title,
+          authors: creators?.map((c) => c.name),
+          year: meta?.publication_date
+            ? String(meta.publication_date).slice(0, 4)
+            : undefined,
+          publication_date: meta?.publication_date,
+          description: meta?.description
+            ? String(meta.description).replace(/<[^>]*>/g, "")
+            : undefined,
+          resource_type: resourceType?.type,
+          access_right: meta?.access_right,
+          keywords: meta?.keywords,
+          license: license?.id,
+          version: meta?.version,
+          files: files?.map((f) => ({
+            filename: f.key,
+            size_bytes: f.size,
+            download_url: f.links?.self,
+          })),
+          stats: stats
+            ? {
+                downloads: stats.downloads,
+                views: stats.views,
+              }
+            : undefined,
+          url: (h.links as Record<string, string>)?.self_html
+            ?? `https://zenodo.org/records/${h.id}`,
+          source: "zenodo",
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+  ];
+}

package/mcp-configs/academic-db/ChatSpatial.json

@@ -1,17 +0,0 @@
-{
-  "id": "ChatSpatial",
-  "name": "ChatSpatial",
-  "description": "Spatial transcriptomics analysis via natural language",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "ChatSpatial",
-    "command": "pip install ChatSpatial"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["load_data", "identify_domains", "visualize"],
-  "verified": false,
-  "source": "https://github.com/cafferychen777/ChatSpatial"
-}

package/mcp-configs/academic-db/academia-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "academia-mcp",
-  "name": "Academia MCP",
-  "description": "Tools for automatic scientific research",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "academia-mcp",
-    "command": "pip install academia-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search", "analyze"],
-  "verified": false,
-  "source": "https://github.com/IlyaGusev/academia_mcp"
-}

package/mcp-configs/academic-db/academic-paper-explorer.json

@@ -1,17 +0,0 @@
-{
-  "id": "academic-paper-explorer",
-  "name": "Academic Paper Explorer",
-  "description": "Academic paper discovery via arXiv and Semantic Scholar",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "academic-paper-explorer",
-    "command": "npm install -g academic-paper-explorer"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search", "read_paper", "find_code"],
-  "verified": false,
-  "source": "https://github.com/Leonard013/academic-paper-explorer"
-}

package/mcp-configs/academic-db/academic-search-mcp-server.json

@@ -1,17 +0,0 @@
-{
-  "id": "academic-search-mcp-server",
-  "name": "Academic Paper Search",
-  "description": "Academic Paper Search MCP for Semantic Scholar and Crossref APIs",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "academic-search-mcp-server",
-    "command": "pip install academic-search-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_papers", "fetch_paper_details", "search_by_topic"],
-  "verified": false,
-  "source": "https://github.com/afrise/academic-search-mcp-server"
-}

package/mcp-configs/academic-db/agentinterviews-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "agentinterviews-mcp",
-  "name": "Agent Interviews",
-  "description": "AI-powered qualitative research interviews at scale",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "agentinterviews-mcp",
-    "command": "pip install agentinterviews-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["create_interviewer", "manage_project", "analyze_data"],
-  "verified": false,
-  "source": "https://github.com/thinkchainai/agentinterviews_mcp"
-}

package/mcp-configs/academic-db/all-in-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "all-in-mcp",
-  "name": "All-in MCP",
-  "description": "Academic paper search and PDF processing",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "all-in-mcp",
-    "command": "pip install all-in-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search", "process_pdf"],
-  "verified": false,
-  "source": "https://github.com/isomoes/all-in-mcp"
-}

package/mcp-configs/academic-db/alphafold-mcp.json

@@ -1,20 +0,0 @@
-{
-  "id": "alphafold-mcp",
-  "name": "AlphaFold MCP",
-  "description": "AlphaFold Protein Structure Database for structure prediction",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "alphafold-mcp-server",
-    "command": "npm install -g alphafold-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": [
-    "get_structure",
-    "search_protein"
-  ],
-  "verified": false,
-  "source": "https://github.com/ac3xx/AlphaFold-MCP-Server"
-}

package/mcp-configs/academic-db/apple-health-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "apple-health-mcp",
-  "name": "Apple Health Data",
-  "description": "Access exported Apple Health data with analytics",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "apple-health-mcp-server",
-    "command": "pip install apple-health-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["read_health_data", "analyze_trends", "export_data"],
-  "verified": false,
-  "source": "https://github.com/the-momentum/apple-health-mcp-server"
-}

package/mcp-configs/academic-db/arxiv-latex-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "arxiv-latex-mcp",
-  "name": "arXiv LaTeX Source",
-  "description": "Access arXiv papers via LaTeX source for better math handling",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "arxiv-latex-mcp",
-    "command": "pip install arxiv-latex-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["get_paper_prompt", "get_paper_abstract", "list_paper_sections", "get_paper_section"],
-  "verified": false,
-  "source": "https://github.com/takashiishida/arxiv-latex-mcp"
-}

package/mcp-configs/academic-db/arxiv-mcp-server.json

@@ -1,17 +0,0 @@
-{
-  "id": "arxiv-mcp-server",
-  "name": "arXiv Search",
-  "description": "Search ArXiv research papers",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "arxiv-mcp-server",
-    "command": "pip install arxiv-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_arxiv"],
-  "verified": false,
-  "source": "https://github.com/blazickjp/arxiv-mcp-server"
-}

package/mcp-configs/academic-db/bgpt-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "bgpt-mcp",
-  "name": "BGPT Paper Search",
-  "description": "Search paper data from any AI tool",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "bgpt-mcp",
-    "command": "npm install -g bgpt-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_papers"],
-  "verified": false,
-  "source": "https://github.com/connerlambden/bgpt-mcp"
-}

package/mcp-configs/academic-db/biomcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "biomcp",
-  "name": "BioMCP",
-  "description": "Biomedical research MCP for PubMed, ClinicalTrials, and MyVariant",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "biomcp",
-    "command": "pip install biomcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_pubmed", "search_clinical_trials", "search_variants"],
-  "verified": false,
-  "source": "https://github.com/genomoncology/biomcp"
-}

package/mcp-configs/academic-db/biothings-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "biothings-mcp",
-  "name": "BioThings API",
-  "description": "BioThings API for genes, variants, drugs, and taxonomy",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "biothings-mcp",
-    "command": "pip install biothings-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["gene_query", "variant_query", "drug_query"],
-  "verified": false,
-  "source": "https://github.com/longevity-genie/biothings-mcp"
-}

package/mcp-configs/academic-db/brightspace-mcp.json

@@ -1,21 +0,0 @@
-{
-  "id": "brightspace-mcp",
-  "name": "Brightspace LMS MCP",
-  "description": "D2L Brightspace LMS: grades, assignments, announcements",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "brightspace-mcp-server",
-    "command": "npm install -g brightspace-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": [
-    "get_grades",
-    "get_assignments",
-    "get_announcements"
-  ],
-  "verified": false,
-  "source": "https://github.com/jjohare/brightspace-mcp-server"
-}

package/mcp-configs/academic-db/catalysishub-mcp-server.json

@@ -1,17 +0,0 @@
-{
-  "id": "catalysishub-mcp-server",
-  "name": "Catalysis Hub",
-  "description": "Search Catalysis Hub database for computational catalysis",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "catalysishub-mcp-server",
-    "command": "pip install catalysishub-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_reactions", "get_surface_data"],
-  "verified": false,
-  "source": "https://github.com/QuentinCody/catalysishub-mcp-server"
-}

package/mcp-configs/academic-db/climatiq-mcp.json

@@ -1,20 +0,0 @@
-{
-  "id": "climatiq-mcp",
-  "name": "Climatiq Carbon MCP",
-  "description": "Carbon emissions calculations via Climatiq API",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "climatiq-mcp-server",
-    "command": "npm install -g climatiq-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": [
-    "estimate",
-    "get_factors"
-  ],
-  "verified": false,
-  "source": "https://github.com/Climatiq/climatiq-mcp-server"
-}

package/mcp-configs/academic-db/clinicaltrialsgov-mcp-server.json

@@ -1,17 +0,0 @@
-{
-  "id": "clinicaltrialsgov-mcp-server",
-  "name": "ClinicalTrials.gov",
-  "description": "ClinicalTrials.gov v2 API search and analysis",
-  "category": "academic-db",
-  "install": {
-    "runtime": "node",
-    "package": "clinicaltrialsgov-mcp-server",
-    "command": "npm install -g clinicaltrialsgov-mcp-server"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["search_studies", "get_study", "analyze_trends", "compare_studies", "find_eligible_studies"],
-  "verified": false,
-  "source": "https://github.com/cyanheads/clinicaltrialsgov-mcp-server"
-}

package/mcp-configs/academic-db/deep-research-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "deep-research-mcp",
-  "name": "Deep Research",
-  "description": "Deep research via OpenAI or open models",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "deep-research-mcp",
-    "command": "pip install deep-research-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["conduct_research", "analyze_sources", "generate_report"],
-  "verified": false,
-  "source": "https://github.com/pminervini/deep-research-mcp"
-}

package/mcp-configs/academic-db/dicom-mcp.json

@@ -1,17 +0,0 @@
-{
-  "id": "dicom-mcp",
-  "name": "DICOM Medical Imaging",
-  "description": "DICOM integration for medical imaging",
-  "category": "academic-db",
-  "install": {
-    "runtime": "python",
-    "package": "dicom-mcp",
-    "command": "pip install dicom-mcp"
-  },
-  "config": {
-    "env": {}
-  },
-  "tools": ["query_studies", "get_images", "move_images"],
-  "verified": false,
-  "source": "https://github.com/ChristianHinge/dicom-mcp"
-}