@tool-bridge/server 0.1.0 → 0.3.0

package/dist/pubmed-3SGOE24Q.js

@@ -0,0 +1,1052 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/pubmed/api.ts
+var EUTILS_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/";
+var CITATION_MATCHER_URL = "https://pubmed.ncbi.nlm.nih.gov/api/citmatch/";
+var ID_CONVERTER_URL = "https://pmc.ncbi.nlm.nih.gov/tools/idconv/api/v1/articles/";
+var TOOL_NAME = "tool-bridge";
+var REQUEST_TIMEOUT_MS = 3e4;
+var MAX_JSON_RESPONSE_BYTES = 1024 * 1024;
+var MAX_XML_RESPONSE_BYTES = 10 * 1024 * 1024;
+var ESEARCH_POST_TERM_LENGTH = 500;
+var MAX_SEARCH_WINDOW = 1e4;
+var SORT_VALUES = {
+  first_author: "Author",
+  journal: "JournalName",
+  publication_date: "pub date",
+  relevance: "relevance"
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function text(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function invalidInput(message) {
+  return new TBError("invalid_argument", message);
+}
+function invalidResponse(message) {
+  return new TBError("unavailable", message, { retryable: true });
+}
+function requireRecord(value, label) {
+  const result = record(value);
+  if (result === void 0) throw invalidResponse(`${label} \u4E0D\u662F\u5BF9\u8C61`);
+  return result;
+}
+function requireObjectArray(value, label) {
+  if (!Array.isArray(value)) throw invalidResponse(`${label} \u4E0D\u662F\u6570\u7EC4`);
+  return value.map((item, index) => requireRecord(item, `${label}[${index}]`));
+}
+function requireStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw invalidResponse(`${label} \u4E0D\u662F\u5B57\u7B26\u4E32\u6570\u7EC4`);
+  }
+  return value;
+}
+function requireInputText(value, field) {
+  const result = text(value);
+  if (result === void 0) throw invalidInput(`${field} is required.`);
+  return result;
+}
+function readPmid(value, field) {
+  const pmid = requireInputText(value, field);
+  if (!/^\d+$/u.test(pmid)) throw invalidInput(`${field} must contain only digits`);
+  return pmid;
+}
+function readPmidArray(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 50) {
+    throw invalidInput("pmids must contain between 1 and 50 PubMed IDs");
+  }
+  return value.map((pmid, index) => readPmid(pmid, `pmids[${index}]`));
+}
+function readLimit(value) {
+  const limit = typeof value === "number" && Number.isInteger(value) ? value : 10;
+  if (limit < 1 || limit > 50) throw invalidInput("limit must be between 1 and 50");
+  return limit;
+}
+function readArticleIds(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 200) {
+    throw invalidInput("ids must contain between 1 and 200 article identifiers");
+  }
+  return value.map((id, index) => requireInputText(id, `ids[${index}]`));
+}
+function readIdType(value) {
+  const idType = requireInputText(value, "idType");
+  if (idType === "doi" || idType === "mid" || idType === "pmcid" || idType === "pmid") return idType;
+  throw invalidInput("idType must be doi, mid, pmcid, or pmid");
+}
+function readSort(value) {
+  const sort = text(value);
+  if (sort === void 0) return void 0;
+  const mapped = SORT_VALUES[sort];
+  if (mapped === void 0) throw invalidInput("sort is not supported by PubMed");
+  return mapped;
+}
+function readPublicationDateRange(value) {
+  const range = record(value);
+  if (range === void 0) return void 0;
+  const from = requireInputText(range.from, "publicationDateRange.from");
+  const to = requireInputText(range.to, "publicationDateRange.to");
+  if (from > to) {
+    throw invalidInput("publicationDateRange.from must not be after publicationDateRange.to");
+  }
+  return { from, to };
+}
+function ncbiDate(value) {
+  return value?.replaceAll("-", "/");
+}
+async function readBoundedText(response, maxBytes, source) {
+  const tooLarge = () => invalidInput(
+    `${source} \u54CD\u5E94\u8D85\u8FC7 ${maxBytes} \u5B57\u8282\u4E0A\u9650:\u628A limit / pmids / ids \u8C03\u5C0F\u540E\u91CD\u8BD5`
+  );
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isSafeInteger(declared) && declared > maxBytes) throw tooLarge();
+  if (response.body === null) {
+    const bytes2 = new Uint8Array(await response.arrayBuffer());
+    if (bytes2.byteLength > maxBytes) throw tooLarge();
+    return new TextDecoder().decode(bytes2);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw tooLarge();
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+function extractError(body) {
+  const trimmed = body.trim();
+  if (trimmed === "") return void 0;
+  try {
+    const payload = record(JSON.parse(trimmed));
+    const direct = text(payload?.error);
+    if (direct !== void 0) return direct;
+    const errors = payload?.errors;
+    if (Array.isArray(errors)) {
+      return errors.filter((item) => typeof item === "string").join("; ") || void 0;
+    }
+  } catch {
+    return trimmed.slice(0, 500);
+  }
+  return trimmed.slice(0, 500);
+}
+async function requestText(input) {
+  const headers = { accept: input.accept };
+  if (input.body !== void 0) headers["content-type"] = "application/x-www-form-urlencoded";
+  let response;
+  try {
+    response = await guardedFetch(input.url.toString(), {
+      method: input.body === void 0 ? "GET" : "POST",
+      headers,
+      body: input.body,
+      // 不设超时会让一个挂死的 NCBI 端点拖住整个调用;上游同样给了 30s 的独立预算。
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (error) {
+    if (error instanceof TBError) throw error;
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw upstreamError(504, `${input.source} request timed out`);
+    }
+    const message = error instanceof Error ? error.message : "unknown network error";
+    throw upstreamError(502, `${input.source} request failed: ${message}`);
+  }
+  const body = await readBoundedText(response, input.maxBytes, input.source);
+  if (!response.ok) {
+    throw upstreamError(
+      response.status,
+      extractError(body) ?? `${input.source} request failed with HTTP ${response.status}`
+    );
+  }
+  return body;
+}
+function parseJson(body, source) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw invalidResponse(`${source} returned malformed JSON`);
+  }
+}
+async function eutils(ctx, utility, query, options) {
+  const url = new URL(utility, EUTILS_BASE);
+  url.searchParams.set("db", "pubmed");
+  url.searchParams.set("tool", TOOL_NAME);
+  for (const [name, value] of Object.entries(query)) {
+    if (value !== void 0) url.searchParams.set(name, value);
+  }
+  const apiKey = text(ctx.upstreamAuth);
+  if (apiKey !== void 0) url.searchParams.set("api_key", apiKey);
+  const usePost = utility === "esearch.fcgi" && (query.term?.length ?? 0) > ESEARCH_POST_TERM_LENGTH;
+  let body;
+  if (usePost) {
+    body = new URLSearchParams(url.searchParams);
+    url.search = "";
+  }
+  return requestText({ url, body, source: "PubMed", accept: options.accept, maxBytes: options.maxBytes });
+}
+async function eutilsJson(ctx, utility, query) {
+  const body = await eutils(ctx, utility, { ...query, retmode: "json" }, {
+    accept: "application/json",
+    maxBytes: MAX_JSON_RESPONSE_BYTES
+  });
+  return requireRecord(parseJson(body, `PubMed ${utility}`), `PubMed ${utility} \u54CD\u5E94`);
+}
+async function ncbiJson(url, source) {
+  const body = await requestText({
+    url,
+    source,
+    accept: "application/json",
+    maxBytes: MAX_JSON_RESPONSE_BYTES
+  });
+  return requireRecord(parseJson(body, source), `${source} \u54CD\u5E94`);
+}
+function malformedXml() {
+  return invalidResponse("PubMed returned malformed article XML");
+}
+var NAMED_ENTITIES = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  quot: '"'
+};
+function decodeEntities(value) {
+  return value.replace(/&(?:#(?:x([\da-f]+)|(\d+))|([a-z]+));/giu, (reference, hex, decimal, name) => {
+    if (typeof name === "string") return NAMED_ENTITIES[name.toLowerCase()] ?? reference;
+    const codePoint = Number.parseInt(hex ?? decimal, hex === void 0 ? 10 : 16);
+    return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 1114111 ? String.fromCodePoint(codePoint) : reference;
+  });
+}
+function decodeNumericEntities(value) {
+  return value.replace(/&#(?:x([\da-f]+)|(\d+));/giu, (reference, hex, decimal) => {
+    const codePoint = Number.parseInt(hex ?? decimal, hex === void 0 ? 10 : 16);
+    return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 1114111 ? String.fromCodePoint(codePoint) : reference;
+  });
+}
+function isNameChar(char) {
+  return !/[\s/>=]/u.test(char);
+}
+function skipWhitespace(cursor) {
+  while (cursor.index < cursor.source.length && /\s/u.test(cursor.source[cursor.index])) cursor.index += 1;
+}
+function skipProlog(cursor) {
+  for (; ; ) {
+    skipWhitespace(cursor);
+    const rest = cursor.source.slice(cursor.index);
+    if (rest.startsWith("<?")) {
+      const end = cursor.source.indexOf("?>", cursor.index);
+      if (end < 0) throw malformedXml();
+      cursor.index = end + 2;
+      continue;
+    }
+    if (rest.startsWith("<!--")) {
+      const end = cursor.source.indexOf("-->", cursor.index);
+      if (end < 0) throw malformedXml();
+      cursor.index = end + 3;
+      continue;
+    }
+    if (rest.startsWith("<!")) {
+      let depth = 0;
+      let index = cursor.index + 2;
+      for (; index < cursor.source.length; index += 1) {
+        const char = cursor.source[index];
+        if (char === "[") depth += 1;
+        else if (char === "]") depth -= 1;
+        else if (char === ">" && depth <= 0) break;
+      }
+      if (index >= cursor.source.length) throw malformedXml();
+      cursor.index = index + 1;
+      continue;
+    }
+    return;
+  }
+}
+function readName(cursor) {
+  const start = cursor.index;
+  while (cursor.index < cursor.source.length && isNameChar(cursor.source[cursor.index])) cursor.index += 1;
+  const name = cursor.source.slice(start, cursor.index);
+  if (name === "") throw malformedXml();
+  return name;
+}
+function readAttributes(cursor) {
+  const attributes = {};
+  for (; ; ) {
+    skipWhitespace(cursor);
+    const rest = cursor.source.slice(cursor.index);
+    if (rest.startsWith("/>")) {
+      cursor.index += 2;
+      return { attributes, selfClosing: true };
+    }
+    if (rest.startsWith(">")) {
+      cursor.index += 1;
+      return { attributes, selfClosing: false };
+    }
+    if (cursor.index >= cursor.source.length) throw malformedXml();
+    const name = readName(cursor);
+    skipWhitespace(cursor);
+    if (cursor.source[cursor.index] !== "=") throw malformedXml();
+    cursor.index += 1;
+    skipWhitespace(cursor);
+    const quote = cursor.source[cursor.index];
+    if (quote !== '"' && quote !== "'") throw malformedXml();
+    cursor.index += 1;
+    const end = cursor.source.indexOf(quote, cursor.index);
+    if (end < 0) throw malformedXml();
+    attributes[name] = decodeEntities(cursor.source.slice(cursor.index, end));
+    cursor.index = end + 1;
+  }
+}
+function parseElement(cursor) {
+  if (cursor.source[cursor.index] !== "<") throw malformedXml();
+  cursor.index += 1;
+  const name = readName(cursor);
+  const { attributes, selfClosing } = readAttributes(cursor);
+  const element = { name, attributes, children: [] };
+  if (selfClosing) return element;
+  for (; ; ) {
+    if (cursor.index >= cursor.source.length) throw malformedXml();
+    const rest = cursor.source.slice(cursor.index);
+    if (rest.startsWith("</")) {
+      cursor.index += 2;
+      const closing = readName(cursor);
+      skipWhitespace(cursor);
+      if (closing !== name || cursor.source[cursor.index] !== ">") throw malformedXml();
+      cursor.index += 1;
+      return element;
+    }
+    if (rest.startsWith("<![CDATA[")) {
+      const end2 = cursor.source.indexOf("]]>", cursor.index);
+      if (end2 < 0) throw malformedXml();
+      element.children.push(cursor.source.slice(cursor.index + 9, end2));
+      cursor.index = end2 + 3;
+      continue;
+    }
+    if (rest.startsWith("<!--")) {
+      const end2 = cursor.source.indexOf("-->", cursor.index);
+      if (end2 < 0) throw malformedXml();
+      cursor.index = end2 + 3;
+      continue;
+    }
+    if (rest.startsWith("<?")) {
+      const end2 = cursor.source.indexOf("?>", cursor.index);
+      if (end2 < 0) throw malformedXml();
+      cursor.index = end2 + 2;
+      continue;
+    }
+    if (rest.startsWith("<")) {
+      element.children.push(parseElement(cursor));
+      continue;
+    }
+    const next = cursor.source.indexOf("<", cursor.index);
+    const end = next < 0 ? cursor.source.length : next;
+    element.children.push(decodeEntities(cursor.source.slice(cursor.index, end)));
+    cursor.index = end;
+  }
+}
+function parseXml(source) {
+  const cursor = { source, index: 0 };
+  skipProlog(cursor);
+  const root = parseElement(cursor);
+  return root;
+}
+function elements(parent, name) {
+  if (parent === void 0) return [];
+  return parent.children.filter(
+    (child) => typeof child !== "string" && child.name === name
+  );
+}
+function firstElement(parent, name) {
+  return elements(parent, name)[0];
+}
+function attribute(element, name) {
+  return text(element.attributes[name]);
+}
+function textOf(element) {
+  if (element === void 0) return "";
+  const collect = (node) => typeof node === "string" ? node : node.children.map(collect).join("");
+  const raw = element.children.map(collect).join("");
+  return decodeNumericEntities(raw).replace(/\s+/gu, " ").trim();
+}
+function childText(parent, name) {
+  const value = textOf(firstElement(parent, name));
+  return value === "" ? void 0 : value;
+}
+function childTexts(parent, name) {
+  return elements(parent, name).map((child) => textOf(child)).filter((value) => value !== "");
+}
+function requireChild(parent, name, source) {
+  const child = firstElement(parent, name);
+  if (child === void 0) throw invalidResponse(`${source} is missing ${name}`);
+  return child;
+}
+function requireChildText(parent, name, source) {
+  const value = childText(parent, name);
+  if (value === void 0) throw invalidResponse(`${source} is missing ${name}`);
+  return value;
+}
+var MONTH_NUMBERS = {
+  apr: "04",
+  aug: "08",
+  dec: "12",
+  feb: "02",
+  jan: "01",
+  jul: "07",
+  jun: "06",
+  mar: "03",
+  may: "05",
+  nov: "11",
+  oct: "10",
+  sep: "09"
+};
+function normalizeMonth(value) {
+  if (value === void 0) return void 0;
+  if (/^\d{1,2}$/u.test(value)) return value.padStart(2, "0");
+  return MONTH_NUMBERS[value.slice(0, 3).toLowerCase()];
+}
+function normalizeDay(value) {
+  return value !== void 0 && /^\d{1,2}$/u.test(value) ? value.padStart(2, "0") : void 0;
+}
+function readDate(pubDate) {
+  if (pubDate === void 0) return null;
+  const medlineDate = childText(pubDate, "MedlineDate");
+  if (medlineDate !== void 0) return medlineDate;
+  const year = childText(pubDate, "Year");
+  if (year === void 0) return null;
+  const season = childText(pubDate, "Season");
+  if (season !== void 0) return `${year} ${season}`;
+  const month = normalizeMonth(childText(pubDate, "Month"));
+  const day = normalizeDay(childText(pubDate, "Day"));
+  return [year, month, day].filter((value) => value !== void 0).join("-");
+}
+function readAbstract(parent) {
+  return elements(firstElement(parent, "Abstract"), "AbstractText").map((section) => ({
+    label: attribute(section, "Label") ?? attribute(section, "NlmCategory") ?? null,
+    text: textOf(section)
+  })).filter((section) => section.text.length > 0);
+}
+function readAuthors(parent) {
+  return elements(firstElement(parent, "AuthorList"), "Author").flatMap((author) => {
+    const collectiveName = childText(author, "CollectiveName");
+    const familyName = childText(author, "LastName");
+    const givenName = childText(author, "ForeName") ?? childText(author, "Initials");
+    const name = collectiveName ?? [givenName, familyName].filter(Boolean).join(" ");
+    if (name === "") return [];
+    const orcid = elements(author, "Identifier").find((identifier) => attribute(identifier, "Source")?.toLowerCase() === "orcid");
+    return [{
+      name,
+      orcid: orcid === void 0 ? null : textOf(orcid) || null,
+      affiliations: elements(author, "AffiliationInfo").map((info) => childText(info, "Affiliation")).filter((value) => value !== void 0)
+    }];
+  });
+}
+function readJournal(journal) {
+  const issue = firstElement(journal, "JournalIssue");
+  return {
+    title: childText(journal, "Title") ?? null,
+    abbreviation: childText(journal, "ISOAbbreviation") ?? null,
+    issn: childText(journal, "ISSN") ?? null,
+    volume: childText(issue, "Volume") ?? null,
+    issue: childText(issue, "Issue") ?? null
+  };
+}
+function addIdentifiers(identifiers, list) {
+  for (const identifier of elements(list, "ArticleId")) {
+    const type = attribute(identifier, "IdType")?.toLowerCase();
+    const value = textOf(identifier);
+    if (type !== void 0 && value !== "") identifiers.set(type, value);
+  }
+}
+function readElectronicDoi(parent) {
+  const location = elements(parent, "ELocationID").find((identifier) => attribute(identifier, "EIdType")?.toLowerCase() === "doi");
+  return location === void 0 ? null : textOf(location) || null;
+}
+function articleUrls(pmid, pmcid) {
+  return {
+    pubmedUrl: `https://pubmed.ncbi.nlm.nih.gov/${pmid}/`,
+    pmcUrl: pmcid === null ? null : `https://pmc.ncbi.nlm.nih.gov/articles/${pmcid}/`
+  };
+}
+function parseArticle(pubmedArticle) {
+  const citation = requireChild(pubmedArticle, "MedlineCitation", "PubMed article");
+  const article = requireChild(citation, "Article", "PubMed citation");
+  const pmid = requireChildText(citation, "PMID", "PubMed citation");
+  const journal = firstElement(article, "Journal");
+  const identifiers = /* @__PURE__ */ new Map();
+  addIdentifiers(identifiers, firstElement(firstElement(pubmedArticle, "PubmedData"), "ArticleIdList"));
+  const pmcid = identifiers.get("pmc") ?? null;
+  return {
+    pmid,
+    title: childText(article, "ArticleTitle") ?? "",
+    abstract: readAbstract(article),
+    authors: readAuthors(article),
+    journal: readJournal(journal),
+    publicationDate: readDate(firstElement(firstElement(journal, "JournalIssue"), "PubDate")),
+    publicationTypes: childTexts(firstElement(article, "PublicationTypeList"), "PublicationType"),
+    meshTerms: elements(firstElement(citation, "MeshHeadingList"), "MeshHeading").map((heading) => childText(heading, "DescriptorName")).filter((value) => value !== void 0),
+    keywords: elements(citation, "KeywordList").flatMap((list) => childTexts(list, "Keyword")),
+    languages: childTexts(article, "Language"),
+    doi: identifiers.get("doi") ?? readElectronicDoi(article),
+    pmcid,
+    ...articleUrls(pmid, pmcid)
+  };
+}
+function parseBookArticle(pubmedBookArticle) {
+  const document = requireChild(pubmedBookArticle, "BookDocument", "PubMed book article");
+  const book = requireChild(document, "Book", "PubMed book document");
+  const pmid = requireChildText(document, "PMID", "PubMed book document");
+  const identifiers = /* @__PURE__ */ new Map();
+  addIdentifiers(identifiers, firstElement(document, "ArticleIdList"));
+  addIdentifiers(identifiers, firstElement(firstElement(pubmedBookArticle, "PubmedBookData"), "ArticleIdList"));
+  const pmcid = identifiers.get("pmc") ?? null;
+  return {
+    pmid,
+    title: childText(document, "ArticleTitle") ?? childText(book, "BookTitle") ?? "",
+    abstract: readAbstract(document),
+    authors: readAuthors(document),
+    journal: {
+      title: childText(book, "BookTitle") ?? null,
+      abbreviation: null,
+      issn: null,
+      volume: childText(book, "Volume") ?? null,
+      issue: null
+    },
+    publicationDate: readDate(firstElement(book, "PubDate")),
+    publicationTypes: childTexts(document, "PublicationType"),
+    meshTerms: [],
+    keywords: elements(document, "KeywordList").flatMap((list) => childTexts(list, "Keyword")),
+    languages: childTexts(document, "Language"),
+    doi: identifiers.get("doi") ?? readElectronicDoi(book),
+    pmcid,
+    ...articleUrls(pmid, pmcid)
+  };
+}
+function parseArticleSet(xml) {
+  const root = parseXml(xml);
+  if (root.name !== "PubmedArticleSet") {
+    throw invalidResponse("PubMed returned an article response without PubmedArticleSet");
+  }
+  return root.children.flatMap((node) => {
+    if (typeof node === "string") return [];
+    if (node.name === "PubmedArticle") return [parseArticle(node)];
+    if (node.name === "PubmedBookArticle") return [parseBookArticle(node)];
+    return [];
+  });
+}
+async function fetchArticles(ctx, pmids) {
+  const xml = await eutils(ctx, "efetch.fcgi", { id: pmids.join(","), retmode: "xml" }, {
+    accept: "application/xml, text/xml",
+    maxBytes: MAX_XML_RESPONSE_BYTES
+  });
+  return parseArticleSet(xml);
+}
+function readLinkedPmids(payload, linkName, label) {
+  const linksets = Array.isArray(payload.linksets) ? requireObjectArray(payload.linksets, `${label} linkset`) : [];
+  for (const linkset of linksets) {
+    const databases = Array.isArray(linkset.linksetdbs) ? requireObjectArray(linkset.linksetdbs, `${label} database`) : [];
+    const related = databases.find((database) => text(database.linkname) === linkName);
+    if (related !== void 0) return requireStringArray(related.links, label);
+  }
+  return [];
+}
+async function linkedArticles(ctx, sourcePmid, linkName, limit) {
+  const payload = await eutilsJson(ctx, "elink.fcgi", {
+    dbfrom: "pubmed",
+    id: sourcePmid,
+    linkname: linkName,
+    cmd: "neighbor"
+  });
+  const pmids = readLinkedPmids(payload, linkName, `PubMed ${linkName} links`).slice(0, limit);
+  return {
+    sourcePmid,
+    articles: pmids.length > 0 ? await fetchArticles(ctx, pmids) : []
+  };
+}
+function readIntegerString(value, label) {
+  const raw = text(value);
+  const parsed = raw === void 0 ? Number.NaN : Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) throw invalidResponse(`${label} is malformed`);
+  return parsed;
+}
+function optionalIdentifier(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return String(value);
+  return text(value) ?? null;
+}
+async function searchArticles(input, ctx) {
+  const query = requireInputText(input.query, "query");
+  const offset = input.offset ?? 0;
+  const limit = input.limit ?? 10;
+  if (offset + limit > MAX_SEARCH_WINDOW) {
+    throw invalidInput(`offset plus limit must not exceed ${MAX_SEARCH_WINDOW} for PubMed searches`);
+  }
+  const sort = readSort(input.sort);
+  const range = readPublicationDateRange(input.publicationDateRange);
+  const payload = await eutilsJson(ctx, "esearch.fcgi", {
+    term: query,
+    retstart: String(offset),
+    retmax: String(limit),
+    sort,
+    // datetype 只在给了区间时才发,否则 NCBI 会按默认日期字段过滤掉本该命中的记录。
+    datetype: range === void 0 ? void 0 : "pdat",
+    mindate: ncbiDate(range?.from),
+    maxdate: ncbiDate(range?.to)
+  });
+  const result = requireRecord(payload.esearchresult, "PubMed esearchresult");
+  const pmids = requireStringArray(result.idlist, "PubMed search idlist");
+  return {
+    total: readIntegerString(result.count, "PubMed search count"),
+    offset,
+    limit,
+    queryTranslation: text(result.querytranslation) ?? null,
+    articles: pmids.length > 0 ? await fetchArticles(ctx, pmids) : []
+  };
+}
+async function getArticle(input, ctx) {
+  const articles = await fetchArticles(ctx, [readPmid(input.pmid, "pmid")]);
+  return { found: articles.length > 0, article: articles[0] ?? null };
+}
+async function getArticles(input, ctx) {
+  const pmids = readPmidArray(input.pmids);
+  const articles = await fetchArticles(ctx, pmids);
+  const returned = new Set(articles.map((article) => article.pmid));
+  return { articles, notFoundPmids: pmids.filter((pmid) => !returned.has(pmid)) };
+}
+async function findRelatedArticles(input, ctx) {
+  const sourcePmid = readPmid(input.pmid, "pmid");
+  const limit = readLimit(input.limit);
+  const payload = await eutilsJson(ctx, "elink.fcgi", {
+    dbfrom: "pubmed",
+    id: sourcePmid,
+    linkname: "pubmed_pubmed",
+    cmd: "neighbor"
+  });
+  const related = readLinkedPmids(payload, "pubmed_pubmed", "PubMed related article links").filter((pmid) => pmid !== sourcePmid).slice(0, limit);
+  return {
+    sourcePmid,
+    articles: related.length > 0 ? await fetchArticles(ctx, related) : []
+  };
+}
+async function getCitingArticles(input, ctx) {
+  return linkedArticles(ctx, readPmid(input.pmid, "pmid"), "pubmed_pubmed_citedin", readLimit(input.limit));
+}
+async function getArticleReferences(input, ctx) {
+  return linkedArticles(ctx, readPmid(input.pmid, "pmid"), "pubmed_pubmed_refs", readLimit(input.limit));
+}
+async function matchCitation(input, ctx) {
+  const citation = requireInputText(input.citation, "citation");
+  const url = new URL(CITATION_MATCHER_URL);
+  url.searchParams.set("method", "heuristic");
+  url.searchParams.set("raw-text", citation);
+  const payload = await ncbiJson(url, "PubMed Citation Matcher");
+  if (payload.success !== true) {
+    throw invalidResponse("PubMed Citation Matcher reported an unsuccessful response");
+  }
+  const result = requireRecord(payload.result, "PubMed Citation Matcher result");
+  const pmids = requireObjectArray(result.uids, "PubMed Citation Matcher UIDs").map((uid, index) => readPmid(uid.pubmed, `PubMed Citation Matcher UIDs[${index}].pubmed`));
+  return {
+    matched: pmids.length > 0,
+    articles: pmids.length > 0 ? await fetchArticles(ctx, pmids) : []
+  };
+}
+async function convertArticleIds(input) {
+  const ids = readArticleIds(input.ids);
+  const idType = readIdType(input.idType);
+  const url = new URL(ID_CONVERTER_URL);
+  url.searchParams.set("ids", ids.join(","));
+  url.searchParams.set("idtype", idType);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("tool", TOOL_NAME);
+  const payload = await ncbiJson(url, "PMC ID Converter");
+  const records = requireObjectArray(payload.records, "PMC ID Converter records");
+  return {
+    records: records.map((item, index) => {
+      const requestedId = optionalIdentifier(item["requested-id"]);
+      if (requestedId === null) {
+        throw invalidResponse(`PMC ID Converter records[${index}].requested-id is malformed`);
+      }
+      return {
+        requestedId,
+        pmid: optionalIdentifier(item.pmid),
+        pmcid: text(item.pmcid) ?? null,
+        doi: text(item.doi) ?? null,
+        mid: text(item.mid) ?? null,
+        // PMC 用 `errmsg` 报"这个 id 解析不了",是逐条结果的一部分,不是整体失败。
+        error: text(item.errmsg) ?? null
+      };
+    })
+  };
+}
+
+// ../plugins/src/pubmed/schema.ts
+var searchArticlesInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("The PubMed query, including optional official field tags and Boolean operators such as cancer[Title] AND 2025[pdat]."),
+  offset: external_exports.int().min(0).max(9999).default(0).describe("The zero-based search result offset.").optional(),
+  limit: external_exports.int().min(1).max(50).default(10).describe("The maximum number of articles to return.").optional(),
+  sort: external_exports.enum(["relevance", "publication_date", "first_author", "journal"]).describe("The PubMed result sort order.").optional(),
+  publicationDateRange: external_exports.strictObject({
+    from: external_exports.iso.date().describe("The earliest publication date to include.").optional(),
+    to: external_exports.iso.date().describe("The latest publication date to include.").optional()
+  }).describe("An inclusive PubMed publication date range.").optional()
+}).describe("Input parameters for searching PubMed articles.");
+var searchArticlesOutput = external_exports.strictObject({
+  total: external_exports.int().min(0).describe("The total number of matching PubMed records.").optional(),
+  offset: external_exports.int().min(0).describe("The zero-based result offset.").optional(),
+  limit: external_exports.int().min(1).describe("The requested page size.").optional(),
+  queryTranslation: external_exports.string().describe("The query translation reported by PubMed.").nullable().optional(),
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The normalized articles in this page.").optional()
+}).describe("A page of normalized PubMed search results.");
+var matchCitationInput = external_exports.strictObject({
+  citation: external_exports.string().min(1).describe("The citation text to match, such as an article title followed by its journal, year, volume, and pages.").optional()
+}).describe("Input parameters for matching one citation.");
+var matchCitationOutput = external_exports.strictObject({
+  matched: external_exports.boolean().describe("Whether PubMed returned at least one candidate article.").optional(),
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The normalized candidate articles returned by PubMed.").optional()
+}).describe("The PubMed articles matched from the citation text.");
+var getArticleInput = external_exports.strictObject({
+  pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional()
+}).describe("Input parameters for getting one PubMed article.");
+var getArticleOutput = external_exports.strictObject({
+  found: external_exports.boolean().describe("Whether PubMed returned the requested record.").optional(),
+  article: external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.").nullable().optional()
+}).describe("The result of retrieving one PubMed article.");
+var getArticlesInput = external_exports.strictObject({
+  pmids: external_exports.array(external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).")).min(1).max(50).describe("The PubMed identifiers to retrieve.").optional()
+}).describe("Input parameters for getting multiple PubMed articles.");
+var getArticlesOutput = external_exports.strictObject({
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The PubMed records that were found.").optional(),
+  notFoundPmids: external_exports.array(external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).")).describe("The requested PMIDs that PubMed did not return.").optional()
+}).describe("The result of retrieving multiple PubMed articles.");
+var findRelatedArticlesInput = external_exports.strictObject({
+  pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID)."),
+  limit: external_exports.int().min(1).max(50).default(10).describe("The maximum number of articles to return.").optional()
+}).describe("Input parameters for finding related PubMed articles.");
+var findRelatedArticlesOutput = external_exports.strictObject({
+  sourcePmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The normalized related PubMed articles.").optional()
+}).describe("The related PubMed articles returned for one source record.");
+var getCitingArticlesInput = external_exports.strictObject({
+  pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID)."),
+  limit: external_exports.int().min(1).max(50).default(10).describe("The maximum number of articles to return.").optional()
+}).describe("Input parameters for getting articles that cite a source PubMed record.");
+var getCitingArticlesOutput = external_exports.strictObject({
+  sourcePmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The normalized articles known to cite the source record.").optional()
+}).describe("The citing PubMed articles returned for one source record.");
+var getArticleReferencesInput = external_exports.strictObject({
+  pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID)."),
+  limit: external_exports.int().min(1).max(50).default(10).describe("The maximum number of articles to return.").optional()
+}).describe("Input parameters for getting references from a source PubMed record.");
+var getArticleReferencesOutput = external_exports.strictObject({
+  sourcePmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+  articles: external_exports.array(external_exports.strictObject({
+    pmid: external_exports.string().min(1).regex(new RegExp("^[0-9]+$")).describe("The numeric PubMed identifier (PMID).").optional(),
+    title: external_exports.string().describe("The article title.").optional(),
+    abstract: external_exports.array(external_exports.strictObject({
+      label: external_exports.string().describe("The structured abstract section label when present.").nullable().optional(),
+      text: external_exports.string().describe("The normalized abstract section text.").optional()
+    }).describe("One section of a PubMed abstract.")).describe("The structured or unstructured abstract sections.").optional(),
+    authors: external_exports.array(external_exports.strictObject({
+      name: external_exports.string().describe("The author or collective author name.").optional(),
+      orcid: external_exports.string().describe("The author's ORCID when present.").nullable().optional(),
+      affiliations: external_exports.array(external_exports.string().describe("One affiliation.")).describe("The author's affiliations.").optional()
+    }).describe("A normalized PubMed author or author group.")).describe("The article authors.").optional(),
+    journal: external_exports.strictObject({
+      title: external_exports.string().describe("The full journal title.").nullable().optional(),
+      abbreviation: external_exports.string().describe("The NLM journal abbreviation.").nullable().optional(),
+      issn: external_exports.string().describe("The journal ISSN returned by PubMed.").nullable().optional(),
+      volume: external_exports.string().describe("The journal volume.").nullable().optional(),
+      issue: external_exports.string().describe("The journal issue.").nullable().optional()
+    }).describe("The journal information attached to a PubMed record.").optional(),
+    publicationDate: external_exports.string().describe("The publication date or source Medline date.").nullable().optional(),
+    publicationTypes: external_exports.array(external_exports.string().describe("One publication type.")).describe("The PubMed publication types.").optional(),
+    meshTerms: external_exports.array(external_exports.string().describe("One MeSH descriptor.")).describe("The assigned Medical Subject Headings.").optional(),
+    keywords: external_exports.array(external_exports.string().describe("One keyword.")).describe("The keywords attached to the PubMed record.").optional(),
+    languages: external_exports.array(external_exports.string().describe("One language code.")).describe("The article language codes returned by PubMed.").optional(),
+    doi: external_exports.string().describe("The article DOI when present.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when present.").nullable().optional(),
+    pubmedUrl: external_exports.url().describe("The canonical PubMed record URL.").optional(),
+    pmcUrl: external_exports.url().describe("The PubMed Central article URL when available.").nullable().optional()
+  }).describe("A normalized PubMed article record.")).describe("The normalized PubMed articles referenced by the source record.").optional()
+}).describe("The PubMed references returned for one source record.");
+var convertArticleIdsInput = external_exports.strictObject({
+  ids: external_exports.array(external_exports.string().min(1).describe("One PMID, PMCID, DOI, or author manuscript identifier.")).min(1).max(200).describe("The article identifiers to convert. Every identifier must have the same idType.").optional(),
+  idType: external_exports.enum(["pmid", "pmcid", "doi", "mid"]).describe("The type shared by every input article identifier.").optional()
+}).describe("Input parameters for converting article identifiers.");
+var convertArticleIdsOutput = external_exports.strictObject({
+  records: external_exports.array(external_exports.strictObject({
+    requestedId: external_exports.string().describe("The original identifier from the request.").optional(),
+    pmid: external_exports.string().describe("The PubMed identifier when the article has one.").nullable().optional(),
+    pmcid: external_exports.string().describe("The PubMed Central identifier when the article is represented in PMC.").nullable().optional(),
+    doi: external_exports.string().describe("The DOI when PMC reports one.").nullable().optional(),
+    mid: external_exports.string().describe("The author manuscript identifier when PMC reports one.").nullable().optional(),
+    error: external_exports.string().describe("The PMC ID Converter error when the requested identifier could not be resolved.").nullable().optional()
+  }).describe("The available identifiers for one requested article.")).describe("One conversion result for each identifier returned by PMC.").optional()
+}).describe("The available identifier mappings returned by PMC.");
+var pubmedActions = {
+  search_articles: {
+    description: "Search PubMed with the official query syntax and return normalized article records.",
+    effect: "read",
+    inputSchema: searchArticlesInput,
+    outputSchema: external_exports.toJSONSchema(searchArticlesOutput, { io: "output", unrepresentable: "any" })
+  },
+  match_citation: {
+    description: "Match one raw biomedical citation to PubMed and return normalized candidate articles.",
+    effect: "write",
+    inputSchema: matchCitationInput,
+    outputSchema: external_exports.toJSONSchema(matchCitationOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_article: {
+    description: "Get one normalized PubMed article by PMID.",
+    effect: "read",
+    inputSchema: getArticleInput,
+    outputSchema: external_exports.toJSONSchema(getArticleOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_articles: {
+    description: "Get multiple normalized PubMed articles by PMID in one request.",
+    effect: "read",
+    inputSchema: getArticlesInput,
+    outputSchema: external_exports.toJSONSchema(getArticlesOutput, { io: "output", unrepresentable: "any" })
+  },
+  find_related_articles: {
+    description: "Find normalized PubMed articles related to one source PMID.",
+    effect: "read",
+    inputSchema: findRelatedArticlesInput,
+    outputSchema: external_exports.toJSONSchema(findRelatedArticlesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_citing_articles: {
+    description: "Get normalized PubMed articles known to cite one source PMID. PubMed citation coverage depends on data supplied by publishers and NCBI sources and may be incomplete.",
+    effect: "read",
+    inputSchema: getCitingArticlesInput,
+    outputSchema: external_exports.toJSONSchema(getCitingArticlesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_article_references: {
+    description: "Get normalized PubMed references for one source PMID. References are available only when supplied by publishers or recoverable from PMC data.",
+    effect: "read",
+    inputSchema: getArticleReferencesInput,
+    outputSchema: external_exports.toJSONSchema(getArticleReferencesOutput, { io: "output", unrepresentable: "any" })
+  },
+  convert_article_ids: {
+    description: "Convert PMID, PMCID, DOI, or author manuscript identifiers with the PMC ID Converter. Complete mappings are available only for articles represented in PubMed Central.",
+    effect: "write",
+    inputSchema: convertArticleIdsInput,
+    outputSchema: external_exports.toJSONSchema(convertArticleIdsOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/pubmed/index.ts
+function createPubmedPlugin() {
+  return createProviderPlugin({
+    description: "PubMed",
+    actions: pubmedActions,
+    handlers: {
+      search_articles: searchArticles,
+      match_citation: matchCitation,
+      get_article: getArticle,
+      get_articles: getArticles,
+      find_related_articles: findRelatedArticles,
+      get_citing_articles: getCitingArticles,
+      get_article_references: getArticleReferences,
+      convert_article_ids: convertArticleIds
+    }
+  });
+}
+var pubmed_default = createPubmedPlugin();
+export {
+  createPubmedPlugin,
+  pubmed_default as default
+};