@wentorai/research-plugins 1.3.1 → 1.4.0

package/src/tools/europe-pmc.ts

@@ -0,0 +1,159 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://www.ebi.ac.uk/europepmc/webservices/rest";
+
+export function createEuropePmcTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_europe_pmc",
+      label: "Search Articles (Europe PMC)",
+      description:
+        "Search Europe PMC biomedical literature. Covers 33M+ articles including full PubMed, with open access full text, citation counts, and MeSH terms.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports field tags: TITLE:, AUTH:, JOURNAL:, DOI:, and boolean AND/OR/NOT.",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 1000)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description: "Sort by: 'RELEVANCE', 'DATE_DESC', 'CITED'",
+          }),
+        ),
+        cursor: Type.Optional(
+          Type.String({ description: "Pagination cursor (use value from previous response)" }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        max_results?: number;
+        sort?: string;
+        cursor?: string;
+      }) => {
+        const params = new URLSearchParams({
+          query: input.query,
+          format: "json",
+          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 tracked = await trackedFetch("europe_pmc", `${BASE}/search?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const results = (data.resultList?.result ?? []).map(
+          (r: Record<string, unknown>) => ({
+            pmid: r.pmid,
+            pmcid: r.pmcid,
+            doi: r.doi,
+            title: r.title,
+            authors: r.authorString,
+            journal: (r.journalInfo as Record<string, unknown>)?.journal
+              ? ((r.journalInfo as Record<string, unknown>).journal as Record<string, unknown>)?.title
+              : undefined,
+            year: r.pubYear,
+            abstract: r.abstractText,
+            is_oa: r.isOpenAccess === "Y",
+            cited_by_count: r.citedByCount,
+            source: r.source,
+            url: r.doi ? `https://doi.org/${r.doi}` : `https://europepmc.org/article/${r.source}/${r.id}`,
+          }),
+        );
+
+        return toolResult({
+          total_results: data.hitCount,
+          next_cursor: data.nextCursorMark,
+          articles: results,
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+    {
+      name: "get_epmc_citations",
+      label: "Get Citations (Europe PMC)",
+      description:
+        "Get papers that cite a given article. Forward citation tracking for biomedical literature.",
+      parameters: Type.Object({
+        pmid: Type.String({
+          description: "PubMed ID of the article",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max citations to return (default 25)" }),
+        ),
+        page: Type.Optional(Type.Number({ description: "Page number (default 1)" })),
+      }),
+      execute: async (input: { pmid: string; max_results?: number; page?: number }) => {
+        const params = new URLSearchParams({
+          format: "json",
+          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;
+        const data = await tracked.res.json();
+
+        return toolResult({
+          total_citations: data.hitCount,
+          citations: (data.citationList?.citation ?? []).map(
+            (c: Record<string, unknown>) => ({
+              pmid: c.id,
+              source: c.source,
+              title: c.title,
+              authors: c.authorString,
+              journal: c.journalAbbreviation,
+              year: c.pubYear,
+              cited_by_count: c.citedByCount,
+            }),
+          ),
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+    {
+      name: "get_epmc_references",
+      label: "Get References (Europe PMC)",
+      description:
+        "Get the reference list of a paper. Shows what a paper cites.",
+      parameters: Type.Object({
+        pmid: Type.String({ description: "PubMed ID of the article" }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max references to return (default 25)" }),
+        ),
+      }),
+      execute: async (input: { pmid: string; max_results?: number }) => {
+        const params = new URLSearchParams({
+          format: "json",
+          pageSize: String(input.max_results ?? 25),
+        });
+        const tracked = await trackedFetch("europe_pmc", `${BASE}/MED/${input.pmid}/references?${params}`);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        return toolResult({
+          total_references: data.hitCount,
+          references: (data.referenceList?.reference ?? []).map(
+            (r: Record<string, unknown>) => ({
+              pmid: r.id,
+              source: r.source,
+              title: r.title,
+              authors: r.authorString,
+              journal: r.journalAbbreviation,
+              year: r.pubYear,
+              order: r.citedOrder,
+            }),
+          ),
+          _source_health: { source: "europe_pmc", latency_ms: tracked.latency_ms },
+        });
+      },
+    },
+  ];
+}

package/src/tools/hal.ts

@@ -0,0 +1,118 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://api.archives-ouvertes.fr";
+
+/** Default fields to request from HAL Solr API */
+const DEFAULT_FIELDS = [
+  "title_s",
+  "authFullName_s",
+  "doiId_s",
+  "producedDate_s",
+  "uri_s",
+  "abstract_s",
+  "journalTitle_s",
+  "keyword_s",
+  "docType_s",
+  "halId_s",
+].join(",");
+
+export function createHalTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_hal",
+      label: "Search Publications (HAL)",
+      description:
+        "Search HAL (Hyper Articles en Ligne), the French open archive for scholarly publications. Covers 4M+ documents with strong coverage of French and European research across all disciplines.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports Solr syntax: field:value, AND/OR/NOT, quoted phrases.",
+        }),
+        rows: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort: 'producedDate_s desc' (newest), 'producedDate_s asc' (oldest). Default: relevance.",
+          }),
+        ),
+        doc_type: Type.Optional(
+          Type.String({
+            description:
+              "Document type filter: 'ART' (journal article), 'COMM' (conference paper), 'THESE' (thesis), 'COUV' (book chapter), 'OUV' (book), 'REPORT', 'HDR', 'POSTER'",
+          }),
+        ),
+      }),
+      execute: async (input: {
+        query: string;
+        rows?: number;
+        sort?: string;
+        doc_type?: string;
+      }) => {
+        let q = input.query;
+        if (input.doc_type) {
+          q = `(${q}) AND docType_s:${input.doc_type}`;
+        }
+
+        const params = new URLSearchParams({
+          q,
+          fl: DEFAULT_FIELDS,
+          rows: String(Math.min(input.rows ?? 10, 100)),
+          wt: "json",
+        });
+        if (input.sort) params.set("sort", input.sort);
+
+        const result = await trackedFetch(
+          "hal",
+          `${BASE}/search/?${params}`,
+          undefined,
+          10_000,
+        );
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        const response = data.response as Record<string, unknown> | undefined;
+        const docs = response?.docs as Array<Record<string, unknown>> | undefined;
+
+        return toolResult({
+          total_results: response?.numFound,
+          source: "hal",
+          papers: (docs ?? []).map((doc) => {
+            // HAL returns title_s and authFullName_s as arrays
+            const titles = doc.title_s as string[] | undefined;
+            const authors = doc.authFullName_s as string[] | undefined;
+            const keywords = doc.keyword_s as string[] | undefined;
+            const abstracts = doc.abstract_s as string[] | undefined;
+            const doi = doc.doiId_s as string | undefined;
+
+            return {
+              title: titles?.[0],
+              authors,
+              doi,
+              year: doc.producedDate_s
+                ? String(doc.producedDate_s).slice(0, 4)
+                : undefined,
+              publication_date: doc.producedDate_s,
+              journal: doc.journalTitle_s,
+              doc_type: doc.docType_s,
+              keywords,
+              abstract: abstracts?.[0]
+                ? String(abstracts[0]).slice(0, 500)
+                : undefined,
+              url: (doc.uri_s as string) ?? (doi ? `https://doi.org/${doi}` : undefined),
+              hal_id: doc.halId_s,
+              source: "hal",
+            };
+          }),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+  ];
+}

package/src/tools/inspire-hep.ts

@@ -0,0 +1,165 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://inspirehep.net/api";
+
+interface InspireAuthor {
+  full_name: string;
+  first_name?: string;
+  last_name?: string;
+}
+
+interface InspireTitle {
+  title: string;
+  source?: string;
+}
+
+interface InspireAbstract {
+  value: string;
+  source?: string;
+}
+
+interface InspireArxivEprint {
+  value: string;
+  categories?: string[];
+}
+
+interface InspireDoi {
+  value: string;
+}
+
+interface InspirePublicationInfo {
+  year?: number;
+  journal_title?: string;
+  journal_volume?: string;
+  page_start?: string;
+  page_end?: string;
+  artid?: string;
+}
+
+function normalizeHit(meta: Record<string, unknown>): Record<string, unknown> {
+  const titles = meta.titles as InspireTitle[] | undefined;
+  const authors = meta.authors as InspireAuthor[] | undefined;
+  const arxivEprints = meta.arxiv_eprints as InspireArxivEprint[] | undefined;
+  const dois = meta.dois as InspireDoi[] | undefined;
+  const abstracts = meta.abstracts as InspireAbstract[] | undefined;
+  const pubInfo = meta.publication_info as InspirePublicationInfo[] | undefined;
+
+  const arxivId = arxivEprints?.[0]?.value;
+  const doi = dois?.[0]?.value;
+
+  return {
+    title: titles?.[0]?.title,
+    authors: authors?.slice(0, 10).map((a) => a.full_name),
+    author_count: authors?.length ?? meta.author_count,
+    doi,
+    arxiv_id: arxivId,
+    arxiv_categories: arxivEprints?.[0]?.categories,
+    year: pubInfo?.[0]?.year ?? (meta.earliest_date ? String(meta.earliest_date).slice(0, 4) : undefined),
+    journal: pubInfo?.[0]?.journal_title,
+    journal_volume: pubInfo?.[0]?.journal_volume,
+    citation_count: meta.citation_count,
+    abstract: abstracts?.[0]?.value,
+    url: doi
+      ? `https://doi.org/${doi}`
+      : arxivId
+        ? `https://arxiv.org/abs/${arxivId}`
+        : undefined,
+    inspire_url: meta.control_number
+      ? `https://inspirehep.net/literature/${meta.control_number}`
+      : undefined,
+    source: "inspire_hep",
+  };
+}
+
+export function createInspireHepTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_inspire",
+      label: "Search Papers (INSPIRE-HEP)",
+      description:
+        "Search INSPIRE-HEP for high-energy physics literature. The primary database for particle physics, astrophysics, and related fields. Covers 1.5M+ records with citation tracking.",
+      parameters: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports SPIRES-style: 'find a einstein and t relativity', or keywords like 'higgs boson'. Field search: a (author), t (title), j (journal), eprint (arXiv ID).",
+        }),
+        size: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort by: 'mostrecent' (newest), 'mostcited', 'bestmatch' (relevance)",
+          }),
+        ),
+      }),
+      execute: async (input: { query: string; size?: number; sort?: string }) => {
+        const params = new URLSearchParams({
+          q: input.query,
+          size: String(Math.min(input.size ?? 10, 100)),
+          sort: input.sort ?? "bestmatch",
+        });
+
+        const result = await trackedFetch(
+          "inspire_hep",
+          `${BASE}/literature?${params}`,
+          undefined,
+          10_000,
+        );
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        return toolResult({
+          total_results: data.hits?.total,
+          source: "inspire_hep",
+          papers: data.hits?.hits?.map(
+            (h: Record<string, unknown>) =>
+              normalizeHit(h.metadata as Record<string, unknown>),
+          ),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+    {
+      name: "get_inspire_paper",
+      label: "Get Paper Details (INSPIRE-HEP)",
+      description:
+        "Get detailed information about a specific paper from INSPIRE-HEP by arXiv ID or DOI.",
+      parameters: Type.Object({
+        identifier: Type.String({
+          description:
+            "Paper identifier: arXiv ID (e.g. '1207.7214') or DOI (e.g. '10.1016/j.physletb.2012.08.020')",
+        }),
+      }),
+      execute: async (input: { identifier: string }) => {
+        // Determine if it's a DOI or arXiv ID
+        const id = input.identifier.trim();
+        let url: string;
+        if (id.startsWith("10.")) {
+          url = `${BASE}/doi/${encodeURIComponent(id)}`;
+        } else {
+          // arXiv ID — strip any "arXiv:" prefix
+          const arxivId = id.replace(/^arXiv:/i, "");
+          url = `${BASE}/arxiv/${encodeURIComponent(arxivId)}`;
+        }
+
+        const result = await trackedFetch("inspire_hep", url, undefined, 10_000);
+        if (isTrackedError(result)) return result;
+        const data = await result.res.json();
+
+        const meta = data.metadata as Record<string, unknown> | undefined;
+        if (!meta) return toolResult({ error: "Paper not found", source: "inspire_hep" });
+
+        return toolResult({
+          ...normalizeHit(meta),
+          _latency_ms: result.latency_ms,
+        });
+      },
+    },
+  ];
+}

package/src/tools/openaire.ts

@@ -0,0 +1,158 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
+
+const BASE = "https://api.openaire.eu";
+
+/**
+ * Parse OpenAIRE XML response wrapped in JSON.
+ * OpenAIRE returns XML by default; with format=json it wraps XML nodes in JSON objects.
+ */
+function parseOpenAireResult(result: Record<string, unknown>): Record<string, unknown> {
+  const metadata = result.metadata as Record<string, unknown> | undefined;
+  const oafEntity = metadata?.["oaf:entity"] as Record<string, unknown> | undefined;
+  const oafResult = oafEntity?.["oaf:result"] as Record<string, unknown> | undefined;
+
+  if (!oafResult) {
+    // Flat JSON format (newer API versions)
+    return {
+      title: result.title,
+      authors: result.authors,
+      doi: result.doi,
+      url: result.url,
+    };
+  }
+
+  // Extract title
+  const titleRaw = oafResult.title;
+  let title = "";
+  if (Array.isArray(titleRaw)) {
+    const main = titleRaw.find((t: Record<string, string>) => t["@classid"] === "main title");
+    title = (main ?? titleRaw[0])?.["$"] ?? "";
+  } else if (typeof titleRaw === "object" && titleRaw !== null) {
+    title = (titleRaw as Record<string, string>)["$"] ?? "";
+  }
+
+  // Extract authors
+  const creatorsRaw = oafResult.creator;
+  const authors: string[] = [];
+  if (Array.isArray(creatorsRaw)) {
+    for (const c of creatorsRaw) {
+      const name = typeof c === "string" ? c : (c as Record<string, string>)["$"];
+      if (name) authors.push(name);
+    }
+  } else if (creatorsRaw) {
+    const name = typeof creatorsRaw === "string" ? creatorsRaw : (creatorsRaw as Record<string, string>)["$"];
+    if (name) authors.push(name);
+  }
+
+  // Extract DOI and other identifiers
+  const pidRaw = oafResult.pid;
+  let doi: string | undefined;
+  if (Array.isArray(pidRaw)) {
+    const doiPid = pidRaw.find((p: Record<string, string>) => p["@classid"] === "doi");
+    doi = (doiPid as Record<string, string> | undefined)?.["$"];
+  } else if (typeof pidRaw === "object" && pidRaw !== null) {
+    if ((pidRaw as Record<string, string>)["@classid"] === "doi") {
+      doi = (pidRaw as Record<string, string>)["$"];
+    }
+  }
+
+  // Extract dates
+  const dateRaw = oafResult.dateofacceptance;
+  const date = typeof dateRaw === "string" ? dateRaw : (dateRaw as Record<string, string> | undefined)?.["$"];
+
+  // Extract best access right
+  const accessRaw = oafResult.bestaccessright;
+  const isOa = typeof accessRaw === "object" && accessRaw !== null
+    ? (accessRaw as Record<string, string>)["@classid"] === "OPEN"
+    : false;
+
+  return {
+    title,
+    authors,
+    doi,
+    date,
+    is_oa: isOa,
+    url: doi ? `https://doi.org/${doi}` : undefined,
+  };
+}
+
+export function createOpenAireTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_openaire",
+      label: "Search Publications (OpenAIRE)",
+      description:
+        "Search OpenAIRE for publications (170M+ records). Uniquely supports filtering by EU funding source (EC, NSF, etc.) and project ID.",
+      parameters: Type.Object({
+        keywords: Type.String({
+          description: "Search keywords",
+        }),
+        author: Type.Optional(Type.String({ description: "Author name" })),
+        doi: Type.Optional(Type.String({ description: "DOI" })),
+        from_date: Type.Optional(
+          Type.String({ description: "From date (YYYY-MM-DD)" }),
+        ),
+        to_date: Type.Optional(
+          Type.String({ description: "To date (YYYY-MM-DD)" }),
+        ),
+        oa_only: Type.Optional(
+          Type.Boolean({ description: "Only open access results" }),
+        ),
+        funder: Type.Optional(
+          Type.String({
+            description: "Funder abbreviation: 'EC' (EU), 'NSF', 'NIH', 'UKRI', 'DFG', etc.",
+          }),
+        ),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 50)" }),
+        ),
+      }),
+      execute: async (input: {
+        keywords: string;
+        author?: string;
+        doi?: string;
+        from_date?: string;
+        to_date?: string;
+        oa_only?: boolean;
+        funder?: string;
+        max_results?: number;
+      }) => {
+        const params = new URLSearchParams({
+          keywords: input.keywords,
+          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);
+        if (input.oa_only) params.set("OA", "true");
+        if (input.funder) params.set("funder", input.funder);
+
+        const tracked = await trackedFetch("openaire", `${BASE}/search/publications?${params}`, undefined, 15_000);
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
+
+        const response = data.response as Record<string, unknown> | undefined;
+        const header = response?.header as Record<string, unknown> | undefined;
+        const total = header?.total as Record<string, string> | undefined;
+        const results = response?.results as Record<string, unknown> | undefined;
+        const resultList = results?.result;
+
+        const papers = (Array.isArray(resultList) ? resultList : []).map(
+          (r: Record<string, unknown>) => parseOpenAireResult(r),
+        );
+
+        return toolResult({
+          total_results: total?.["$"] ? parseInt(total["$"], 10) : papers.length,
+          papers,
+        });
+      },
+    },
+  ];
+}

package/src/tools/openalex.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
-import { toolResult } from "./util.js";
+import { toolResult, trackedFetch, isTrackedError } from "./util.js";
 
 const BASE = "https://api.openalex.org";
 
@@ -58,9 +58,9 @@ export function createOpenAlexTools(
         if (filters.length > 0) params.set("filter", filters.join(","));
         if (input.sort_by) params.set("sort", input.sort_by);
 
-        const res = await fetch(`${BASE}/works?${params}`, { headers });
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const data = await res.json();
+        const tracked = await trackedFetch("openalex", `${BASE}/works?${params}`, { headers });
+        if (isTrackedError(tracked)) return tracked;
+        const data = await tracked.res.json();
         return toolResult({
           total_count: data.meta?.count,
           results: data.results?.map((w: Record<string, unknown>) => ({
@@ -78,6 +78,7 @@ export function createOpenAlexTools(
                 )
               : [],
           })),
+          _source_health: { source: "openalex", latency_ms: tracked.latency_ms },
         });
       },
     },
@@ -96,11 +97,9 @@ export function createOpenAlexTools(
         const id = input.work_id.startsWith("10.")
           ? `https://doi.org/${input.work_id}`
           : input.work_id;
-        const res = await fetch(`${BASE}/works/${encodeURIComponent(id)}`, {
-          headers,
-        });
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const w = await res.json();
+        const tracked = await trackedFetch("openalex", `${BASE}/works/${encodeURIComponent(id)}`, { headers });
+        if (isTrackedError(tracked)) return tracked;
+        const w = await tracked.res.json();
         return toolResult({
           id: w.id,
           doi: w.doi,
@@ -120,6 +119,7 @@ export function createOpenAlexTools(
             ?.slice(0, 10)
             .map((c: Record<string, unknown>) => c.display_name),
           referenced_works_count: w.referenced_works?.length,
+          _source_health: { source: "openalex", latency_ms: tracked.latency_ms },
         });
       },
     },
@@ -148,14 +148,18 @@ export function createOpenAlexTools(
             search: input.author_id,
             per_page: "5",
           });
-          const res = await fetch(`${BASE}/authors?${params}`, { headers });
-          if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-          return toolResult(await res.json());
+          const tracked = await trackedFetch("openalex", `${BASE}/authors?${params}`, { headers });
+          if (isTrackedError(tracked)) return tracked;
+          const data = await tracked.res.json();
+          return toolResult({
+            ...data,
+            _source_health: { source: "openalex", latency_ms: tracked.latency_ms },
+          });
         }
 
-        const res = await fetch(url, { headers });
-        if (!res.ok) return toolResult({ error: `API error: ${res.status} ${res.statusText}` });
-        const a = await res.json();
+        const tracked = await trackedFetch("openalex", url, { headers });
+        if (isTrackedError(tracked)) return tracked;
+        const a = await tracked.res.json();
         return toolResult({
           id: a.id,
           display_name: a.display_name,
@@ -171,6 +175,7 @@ export function createOpenAlexTools(
           top_concepts: a.x_concepts
             ?.slice(0, 5)
             .map((c: Record<string, unknown>) => c.display_name),
+          _source_health: { source: "openalex", latency_ms: tracked.latency_ms },
         });
       },
     },