@cyanheads/pubmed-mcp-server 1.1.2 → 1.2.1

package/dist/mcp-server/tools/fetchPubMedContent/logic.js

@@ -97,70 +97,35 @@ export const FetchPubMedContentInputSchema = z
         });
     }
 });
-function parsePubMedArticleSet(xmlData, // Changed from { PubmedArticleSet?: XmlPubmedArticleSet } | any
-input, parentContext) {
+function parsePubMedArticleSet(xmlData, input, parentContext) {
     const articles = [];
     const operationContext = requestContextService.createRequestContext({
         parentRequestId: parentContext.requestId,
         operation: "parsePubMedArticleSet",
     });
-    // Type guard for xmlData
     if (!xmlData ||
         typeof xmlData !== "object" ||
         !("PubmedArticleSet" in xmlData)) {
-        logger.warning("Invalid or unexpected structure for xmlData in parsePubMedArticleSet.", {
+        throw new McpError(BaseErrorCode.PARSING_ERROR, "Invalid or unexpected structure for xmlData in parsePubMedArticleSet.", {
             ...operationContext,
             xmlDataType: typeof xmlData,
             xmlDataPreview: sanitizeInputForLogging(JSON.stringify(xmlData).substring(0, 200)),
         });
-        return articles;
     }
-    const typedXmlData = xmlData; // Cast after check
+    const typedXmlData = xmlData;
     const articleSet = typedXmlData.PubmedArticleSet;
     if (!articleSet || !articleSet.PubmedArticle) {
-        logger.warning("PubmedArticleSet or PubmedArticle array not found in EFetch XML response.", requestContextService.createRequestContext({
-            ...operationContext,
-            xmlDataPreview: sanitizeInputForLogging(JSON.stringify(typedXmlData).substring(0, 200)),
-        }));
+        logger.warning("PubmedArticleSet or PubmedArticle array not found in EFetch XML response.", operationContext);
         return articles;
     }
     const pubmedArticlesXml = ensureArray(articleSet.PubmedArticle);
-    logger.debug("Result of ensureArray(articleSet.PubmedArticle):", {
-        ...operationContext,
-        pubmedArticlesXmlPreview: sanitizeInputForLogging(JSON.stringify(pubmedArticlesXml).substring(0, 500)),
-        isPubmedArticlesXmlArray: Array.isArray(pubmedArticlesXml),
-        pubmedArticlesXmlLength: Array.isArray(pubmedArticlesXml)
-            ? pubmedArticlesXml.length
-            : undefined,
-    });
-    if (Array.isArray(pubmedArticlesXml) && pubmedArticlesXml.length > 0) {
-        logger.debug("First item of pubmedArticlesXml:", {
-            ...operationContext,
-            firstItemPreview: sanitizeInputForLogging(JSON.stringify(pubmedArticlesXml[0]).substring(0, 500)),
-        });
-    }
     for (const articleXml of pubmedArticlesXml) {
-        if (!articleXml || typeof articleXml !== "object") {
-            logger.warning("Skipping invalid articleXml item in pubmedArticlesXml array", {
-                ...operationContext,
-                articleXmlItem: sanitizeInputForLogging(articleXml),
-            });
+        if (!articleXml || typeof articleXml !== "object")
             continue;
-        }
         const medlineCitation = articleXml.MedlineCitation;
-        if (!medlineCitation) {
-            logger.warning("MedlineCitation not found in articleXml, skipping.", {
-                ...operationContext,
-                articleXmlPreview: sanitizeInputForLogging(JSON.stringify(articleXml).substring(0, 200)),
-            });
+        if (!medlineCitation)
             continue;
-        }
         const pmid = extractPmid(medlineCitation);
-        logger.debug("Extracted PMID from MedlineCitation:", {
-            ...operationContext,
-            extractedPmid: pmid,
-            medlineCitationPreview: sanitizeInputForLogging(JSON.stringify(medlineCitation).substring(0, 200)),
-        });
         if (!pmid)
             continue;
         const articleNode = medlineCitation.Article;
@@ -204,121 +169,33 @@ input, parentContext) {
     return articles;
 }
 export async function fetchPubMedContentLogic(input, parentRequestContext) {
-    // Manual validation for conditions superRefine should catch,
-    // as SDK might call handler even with refinement issues.
-    if (input.queryKey && !input.webEnv) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: "webEnv is required if queryKey is provided.",
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    if (!input.queryKey && input.webEnv) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: "queryKey is required if webEnv is provided.",
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    if (input.pmids &&
-        input.pmids.length > 0 &&
-        (input.queryKey || input.webEnv)) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: "Cannot use pmids and queryKey/webEnv simultaneously. Please choose one method.",
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    if ((input.retstart !== undefined || input.retmax !== undefined) &&
-        !(input.queryKey && input.webEnv)) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: "retstart/retmax can only be used with queryKey and webEnv.",
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    // SuperRefine also checks: if ((!data.pmids || data.pmids.length === 0) && !(data.queryKey && data.webEnv))
-    // This should ideally be caught before handler, but as a safeguard:
-    if ((!input.pmids || input.pmids.length === 0) &&
-        !(input.queryKey && input.webEnv)) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: "Either pmids (non-empty array) or both queryKey and webEnv must be provided.",
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
-    }
-    const ncbiService = getNcbiService();
     const toolLogicContext = requestContextService.createRequestContext({
         parentRequestId: parentRequestContext.requestId,
         operation: "fetchPubMedContentLogic",
         input: sanitizeInputForLogging(input),
     });
+    const validationResult = FetchPubMedContentInputSchema.safeParse(input);
+    if (!validationResult.success) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, validationResult.error.errors[0]?.message || "Invalid input", { ...toolLogicContext, details: validationResult.error.flatten() });
+    }
+    const ncbiService = getNcbiService();
     logger.info("Executing fetch_pubmed_content tool", toolLogicContext);
     const eFetchParams = { db: "pubmed" };
     let usingHistory = false;
     if (input.queryKey && input.webEnv) {
         usingHistory = true;
         eFetchParams.query_key = input.queryKey;
-        eFetchParams.WebEnv = input.webEnv; // NCBI uses WebEnv with capital E
-        if (input.retstart !== undefined) {
+        eFetchParams.WebEnv = input.webEnv;
+        if (input.retstart !== undefined)
             eFetchParams.retstart = String(input.retstart);
-        }
-        if (input.retmax !== undefined) {
+        if (input.retmax !== undefined)
             eFetchParams.retmax = String(input.retmax);
-        }
     }
     else if (input.pmids && input.pmids.length > 0) {
         eFetchParams.id = input.pmids.join(",");
     }
-    // The superRefine ensures that either pmids or (queryKey & webEnv) is provided.
-    let serviceRetmode = "xml"; // Renamed to avoid conflict with local retmode variable if any
+    let serviceRetmode = "xml";
     let rettype;
-    // responseContentType is determined by input.outputFormat at the end
     switch (input.detailLevel) {
         case "full_xml":
             serviceRetmode = "xml";
@@ -329,191 +206,105 @@ export async function fetchPubMedContentLogic(input, parentRequestContext) {
             break;
         case "abstract_plus":
         case "citation_data":
-            serviceRetmode = "xml"; // Parsed by server, so fetch XML
+            serviceRetmode = "xml";
             break;
     }
     eFetchParams.retmode = serviceRetmode;
     if (rettype)
         eFetchParams.rettype = rettype;
-    let eFetchUrl = "";
-    try {
-        const eFetchBase = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi";
-        const eFetchQueryString = new URLSearchParams(eFetchParams).toString();
-        eFetchUrl = `${eFetchBase}?${eFetchQueryString}`;
-        // Determine if raw XML should be fetched
-        const shouldReturnRawXml = input.detailLevel === "full_xml" && input.outputFormat === "raw_text";
-        const eFetchResponseData = await ncbiService.eFetch(eFetchParams, toolLogicContext, { retmode: serviceRetmode, rettype, returnRawXml: shouldReturnRawXml });
-        let finalOutputText;
-        let structuredResponseData; // Used for building the JSON response
-        if (input.detailLevel === "medline_text") {
-            const medlineText = String(eFetchResponseData);
-            const foundPmidsInMedline = new Set();
-            const pmidRegex = /^PMID- (\d+)/gm;
-            let match;
-            while ((match = pmidRegex.exec(medlineText)) !== null) {
-                foundPmidsInMedline.add(match[1]);
-            }
-            let notFoundPmids = [];
-            if (input.pmids && input.pmids.length > 0) {
-                notFoundPmids = input.pmids.filter((pmid) => !foundPmidsInMedline.has(pmid));
-            }
-            structuredResponseData = {
-                requestedPmids: input.pmids || "N/A (used history query)",
-                articles: [
-                    {
-                        pmids: input.pmids || "N/A (used history query)",
-                        medlineText: medlineText,
-                    },
-                ],
-                notFoundPmids: usingHistory
-                    ? "N/A (used history query)"
-                    : notFoundPmids,
-                eFetchDetails: {
-                    urls: [eFetchUrl],
-                    requestMethod: input.pmids && input.pmids.length > 200 && !usingHistory
-                        ? "POST"
-                        : "GET",
-                },
-            };
-            if (input.outputFormat === "raw_text") {
-                finalOutputText = String(eFetchResponseData);
-            }
-            else {
-                finalOutputText = JSON.stringify(structuredResponseData);
-            }
+    const eFetchBase = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi";
+    const eFetchQueryString = new URLSearchParams(eFetchParams).toString();
+    const eFetchUrl = `${eFetchBase}?${eFetchQueryString}`;
+    const shouldReturnRawXml = input.detailLevel === "full_xml" && input.outputFormat === "raw_text";
+    const eFetchResponseData = await ncbiService.eFetch(eFetchParams, toolLogicContext, { retmode: serviceRetmode, rettype, returnRawXml: shouldReturnRawXml });
+    let finalOutputText;
+    let articlesCount = 0;
+    if (input.detailLevel === "medline_text") {
+        const medlineText = String(eFetchResponseData);
+        const foundPmidsInMedline = new Set();
+        const pmidRegex = /^PMID- (\d+)/gm;
+        let match;
+        while ((match = pmidRegex.exec(medlineText)) !== null) {
+            foundPmidsInMedline.add(match[1]);
         }
-        else if (input.detailLevel === "full_xml") {
-            if (input.outputFormat === "raw_text") {
-                // eFetchResponseData is already the raw XML string due to returnRawXml: true
-                finalOutputText = String(eFetchResponseData);
-                // Optionally, wrap it in a minimal JSON structure if that's preferred for raw_text output consistency
-                // For now, returning the direct XML string as per user expectation for "raw_text"
-            }
-            else {
-                // outputFormat is 'json', so eFetchResponseData is the parsed XML object
-                const articlesXml = ensureArray(eFetchResponseData?.PubmedArticleSet?.PubmedArticle || []);
-                const articlesPayload = [];
-                const foundPmidsInXml = new Set();
-                for (const articleXml of articlesXml) {
-                    let pmid = "unknown_pmid";
-                    if (articleXml?.MedlineCitation) {
-                        const extracted = extractPmid(articleXml.MedlineCitation);
-                        if (extracted) {
-                            pmid = extracted;
-                        }
-                    }
-                    if (pmid !== "unknown_pmid") {
-                        foundPmidsInXml.add(pmid);
-                    }
-                    articlesPayload.push({
-                        pmid: pmid,
-                        fullXmlContent: articleXml,
-                    });
-                }
-                let notFoundPmids = [];
-                if (input.pmids && input.pmids.length > 0) {
-                    notFoundPmids = input.pmids.filter((pmid) => !foundPmidsInXml.has(pmid));
-                }
-                else if (usingHistory) {
-                    notFoundPmids = "N/A (used history query)";
-                }
-                structuredResponseData = {
-                    requestedPmids: input.pmids || "N/A (used history query)",
-                    articles: articlesPayload,
-                    notFoundPmids,
-                    eFetchDetails: {
-                        urls: [eFetchUrl],
-                        requestMethod: input.pmids && input.pmids.length > 200 && !usingHistory
-                            ? "POST"
-                            : "GET",
-                    },
-                };
-                finalOutputText = JSON.stringify(structuredResponseData);
-            }
+        articlesCount = foundPmidsInMedline.size;
+        if (input.outputFormat === "raw_text") {
+            finalOutputText = medlineText;
         }
         else {
-            // abstract_plus or citation_data (outputFormat is always 'json' effectively)
-            // eFetchResponseData is the parsed XML object
-            const parsedArticles = parsePubMedArticleSet(eFetchResponseData, input, toolLogicContext);
-            const foundPmids = new Set(parsedArticles.map((p) => p.pmid));
-            let notFoundPmids = [];
-            if (input.pmids && input.pmids.length > 0) {
-                notFoundPmids = input.pmids.filter((pmid) => !foundPmids.has(pmid));
-            }
-            else if (usingHistory) {
-                notFoundPmids = "N/A (used history query)";
-            }
-            structuredResponseData = {
-                requestedPmids: input.pmids || "N/A (used history query)",
-                articles: parsedArticles,
+            const notFoundPmids = input.pmids?.filter((pmid) => !foundPmidsInMedline.has(pmid)) || [];
+            finalOutputText = JSON.stringify({
+                requestedPmids: input.pmids || "N/A (history query)",
+                articles: [{ medlineText }],
                 notFoundPmids,
-                eFetchDetails: {
-                    urls: [eFetchUrl],
-                    requestMethod: input.pmids && input.pmids.length > 200 && !usingHistory
-                        ? "POST"
-                        : "GET",
-                },
-            };
-            if (input.detailLevel === "citation_data") {
-                structuredResponseData.articles = structuredResponseData.articles.map((article) => ({
-                    pmid: article.pmid,
-                    title: article.title,
-                    authors: article.authors?.map((a) => ({
-                        lastName: a.lastName,
-                        initials: a.initials,
-                    })),
-                    journalInfo: {
-                        title: article.journalInfo?.title,
-                        isoAbbreviation: article.journalInfo?.isoAbbreviation,
-                        volume: article.journalInfo?.volume,
-                        issue: article.journalInfo?.issue,
-                        pages: article.journalInfo?.pages,
-                        year: article.journalInfo?.publicationDate?.year,
-                    },
-                    doi: article.doi,
-                    // Conditionally include meshTerms if the input flag was set (it defaults to true)
-                    ...(input.includeMeshTerms && { meshTerms: article.meshTerms }),
-                }));
-            }
-            // For abstract_plus and citation_data, outputFormat 'raw_text' doesn't make sense,
-            // as the data is inherently structured. So, always output JSON.
-            finalOutputText = JSON.stringify(structuredResponseData);
+                eFetchDetails: { urls: [eFetchUrl] },
+            });
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: finalOutputText,
-                },
-            ],
-            isError: false,
-        };
     }
-    catch (error) {
-        logger.error("Error in fetch_pubmed_content logic", error, toolLogicContext);
-        const mcpError = error instanceof McpError
-            ? error
-            : new McpError(BaseErrorCode.INTERNAL_ERROR, "Failed to fetch PubMed content.", {
-                originalErrorName: error.name,
-                originalErrorMessage: error.message,
-                requestId: toolLogicContext.requestId,
+    else if (input.detailLevel === "full_xml") {
+        if (input.outputFormat === "raw_text") {
+            finalOutputText = String(eFetchResponseData);
+            articlesCount = (finalOutputText.match(/<PubmedArticle>/g) || []).length;
+        }
+        else {
+            const articlesXml = ensureArray(eFetchResponseData?.PubmedArticleSet?.PubmedArticle || []);
+            articlesCount = articlesXml.length;
+            const foundPmidsInXml = new Set();
+            const articlesPayload = articlesXml.map((articleXml) => {
+                const pmid = extractPmid(articleXml.MedlineCitation) || "unknown_pmid";
+                if (pmid !== "unknown_pmid")
+                    foundPmidsInXml.add(pmid);
+                return { pmid, fullXmlContent: articleXml };
+            });
+            const notFoundPmids = input.pmids?.filter((pmid) => !foundPmidsInXml.has(pmid)) || [];
+            finalOutputText = JSON.stringify({
+                requestedPmids: input.pmids || "N/A (history query)",
+                articles: articlesPayload,
+                notFoundPmids,
+                eFetchDetails: { urls: [eFetchUrl] },
             });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: mcpError.code,
-                            message: mcpError.message,
-                            details: mcpError.details,
-                        },
-                        requestedPmids: input.pmids || "N/A (used history query)",
-                        eFetchUrl,
-                    }),
+        }
+    }
+    else {
+        const parsedArticles = parsePubMedArticleSet(eFetchResponseData, input, toolLogicContext);
+        articlesCount = parsedArticles.length;
+        const foundPmids = new Set(parsedArticles.map((p) => p.pmid));
+        const notFoundPmids = input.pmids?.filter((pmid) => !foundPmids.has(pmid)) || [];
+        let articlesToReturn = parsedArticles;
+        if (input.detailLevel === "citation_data") {
+            articlesToReturn = parsedArticles.map((article) => ({
+                pmid: article.pmid,
+                title: article.title,
+                authors: article.authors?.map((a) => ({
+                    lastName: a.lastName,
+                    initials: a.initials,
+                })),
+                journalInfo: {
+                    title: article.journalInfo?.title,
+                    isoAbbreviation: article.journalInfo?.isoAbbreviation,
+                    volume: article.journalInfo?.volume,
+                    issue: article.journalInfo?.issue,
+                    pages: article.journalInfo?.pages,
+                    year: article.journalInfo?.publicationDate?.year,
                 },
-            ],
-            isError: true,
-        };
+                doi: article.doi,
+                ...(input.includeMeshTerms && { meshTerms: article.meshTerms }),
+            }));
+        }
+        finalOutputText = JSON.stringify({
+            requestedPmids: input.pmids || "N/A (history query)",
+            articles: articlesToReturn,
+            notFoundPmids,
+            eFetchDetails: { urls: [eFetchUrl] },
+        });
     }
+    logger.notice("Successfully executed fetch_pubmed_content tool.", {
+        ...toolLogicContext,
+        articlesReturned: articlesCount,
+    });
+    return {
+        content: finalOutputText,
+        articlesReturned: articlesCount,
+        eFetchUrl,
+    };
 }

package/dist/mcp-server/tools/fetchPubMedContent/registration.d.ts

@@ -7,4 +7,4 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
  * Registers the fetch_pubmed_content tool with the MCP server.
  * @param server - The McpServer instance.
  */
-export declare function registerFetchPubMedContentTool(server: McpServer): void;
+export declare function registerFetchPubMedContentTool(server: McpServer): Promise<void>;

package/dist/mcp-server/tools/fetchPubMedContent/registration.js

@@ -3,35 +3,67 @@
  * @module src/mcp-server/tools/fetchPubMedContent/registration
  */
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
-import { ErrorHandler, requestContextService } from "../../../utils/index.js";
+import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
 import { FetchPubMedContentInputSchema, fetchPubMedContentLogic, } from "./logic.js";
 /**
  * Registers the fetch_pubmed_content tool with the MCP server.
  * @param server - The McpServer instance.
  */
-export function registerFetchPubMedContentTool(server) {
+export async function registerFetchPubMedContentTool(server) {
     const operation = "registerFetchPubMedContentTool";
+    const toolName = "fetch_pubmed_content";
+    const toolDescription = "Fetches detailed information from PubMed using NCBI EFetch. Can be used with a direct list of PMIDs or with queryKey/webEnv from an ESearch history entry. Supports pagination (retstart, retmax) when using history. Available 'detailLevel' options: 'abstract_plus' (parsed title, abstract, authors, journal, keywords, DOI, optional MeSH/grant info), 'full_xml' (JSON representation of the PubMedArticle XML structure), 'medline_text' (MEDLINE format), or 'citation_data' (minimal data for citations). Returns a JSON object containing results, any PMIDs not found (if applicable), and EFetch details.";
     const context = requestContextService.createRequestContext({ operation });
-    try {
-        server.tool("fetch_pubmed_content", "Fetches detailed information from PubMed using NCBI EFetch. Can be used with a direct list of PMIDs or with queryKey/webEnv from an ESearch history entry. Supports pagination (retstart, retmax) when using history. Available 'detailLevel' options: 'abstract_plus' (parsed title, abstract, authors, journal, keywords, DOI, optional MeSH/grant info), 'full_xml' (JSON representation of the PubMedArticle XML structure), 'medline_text' (MEDLINE format), or 'citation_data' (minimal data for citations). Returns a JSON object containing results, any PMIDs not found (if applicable), and EFetch details.", FetchPubMedContentInputSchema._def.schema.shape, // Access .shape from the ZodObject before superRefine
-        async (input, toolContext) => {
-            // Added 'any' type for toolContext
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(toolName, toolDescription, FetchPubMedContentInputSchema._def.schema.shape, async (input, toolContext) => {
             const richContext = requestContextService.createRequestContext({
                 parentRequestId: context.requestId,
                 operation: "fetchPubMedContentToolHandler",
                 mcpToolContext: toolContext,
+                input,
             });
-            return fetchPubMedContentLogic(input, richContext);
+            try {
+                const result = await fetchPubMedContentLogic(input, richContext);
+                return {
+                    content: [{ type: "text", text: result.content }],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const handledError = ErrorHandler.handleError(error, {
+                    operation: "fetchPubMedContentToolHandler",
+                    context: richContext,
+                    input,
+                    rethrow: false,
+                });
+                const mcpError = handledError instanceof McpError
+                    ? handledError
+                    : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred while fetching PubMed content.", {
+                        originalErrorName: handledError.name,
+                        originalErrorMessage: handledError.message,
+                    });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                error: {
+                                    code: mcpError.code,
+                                    message: mcpError.message,
+                                    details: mcpError.details,
+                                },
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
         });
-    }
-    catch (error) {
-        ErrorHandler.handleError(new McpError(BaseErrorCode.INITIALIZATION_FAILED, "Failed to register fetch_pubmed_content tool", {
-            originalError: error instanceof Error ? error.message : String(error),
-        }), {
-            operation,
-            context,
-            errorCode: BaseErrorCode.INITIALIZATION_FAILED,
-            critical: true,
-        });
-    }
+        logger.notice(`Tool '${toolName}' registered.`, context);
+    }, {
+        operation,
+        context,
+        errorCode: BaseErrorCode.INITIALIZATION_FAILED,
+        critical: true,
+    });
 }

package/dist/mcp-server/tools/generatePubMedChart/logic.d.ts

@@ -1,13 +1,7 @@
-/**
- * @fileoverview Core logic for the generate_pubmed_chart tool.
- * Generates charts from parameterized input by creating Vega-Lite specifications.
- * @module src/mcp-server/tools/generatePubMedChart/logic
- */
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { RequestContext } from "../../../utils/index.js";
 export declare const GeneratePubMedChartInputSchema: z.ZodObject<{
-    chartType: z.ZodEnum<["bar", "line", "scatter"]>;
+    chartType: z.ZodEnum<["bar", "line", "scatter", "pie", "doughnut", "bubble", "radar", "polarArea"]>;
     title: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -15,33 +9,21 @@ export declare const GeneratePubMedChartInputSchema: z.ZodObject<{
     outputFormat: z.ZodDefault<z.ZodEnum<["png"]>>;
     xField: z.ZodString;
     yField: z.ZodString;
-    xFieldType: z.ZodOptional<z.ZodEnum<["nominal", "ordinal", "quantitative", "temporal"]>>;
-    yFieldType: z.ZodOptional<z.ZodEnum<["nominal", "ordinal", "quantitative", "temporal"]>>;
-    colorField: z.ZodOptional<z.ZodString>;
-    colorFieldType: z.ZodOptional<z.ZodEnum<["nominal", "ordinal", "quantitative", "temporal"]>>;
     seriesField: z.ZodOptional<z.ZodString>;
-    seriesFieldType: z.ZodOptional<z.ZodEnum<["nominal", "ordinal", "quantitative", "temporal"]>>;
     sizeField: z.ZodOptional<z.ZodString>;
-    sizeFieldType: z.ZodOptional<z.ZodEnum<["quantitative", "ordinal"]>>;
 }, "strip", z.ZodTypeAny, {
     width: number;
     height: number;
     outputFormat: "png";
-    chartType: "bar" | "line" | "scatter";
+    chartType: "bar" | "line" | "scatter" | "pie" | "doughnut" | "bubble" | "radar" | "polarArea";
     dataValues: Record<string, any>[];
     xField: string;
     yField: string;
     title?: string | undefined;
-    xFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
-    yFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
-    colorField?: string | undefined;
-    colorFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
     seriesField?: string | undefined;
-    seriesFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
     sizeField?: string | undefined;
-    sizeFieldType?: "ordinal" | "quantitative" | undefined;
 }, {
-    chartType: "bar" | "line" | "scatter";
+    chartType: "bar" | "line" | "scatter" | "pie" | "doughnut" | "bubble" | "radar" | "polarArea";
     dataValues: Record<string, any>[];
     xField: string;
     yField: string;
@@ -49,14 +31,13 @@ export declare const GeneratePubMedChartInputSchema: z.ZodObject<{
     width?: number | undefined;
     height?: number | undefined;
     outputFormat?: "png" | undefined;
-    xFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
-    yFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
-    colorField?: string | undefined;
-    colorFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
     seriesField?: string | undefined;
-    seriesFieldType?: "nominal" | "ordinal" | "quantitative" | "temporal" | undefined;
     sizeField?: string | undefined;
-    sizeFieldType?: "ordinal" | "quantitative" | undefined;
 }>;
 export type GeneratePubMedChartInput = z.infer<typeof GeneratePubMedChartInputSchema>;
-export declare function generatePubMedChartLogic(input: GeneratePubMedChartInput, parentRequestContext: RequestContext): Promise<CallToolResult>;
+export type GeneratePubMedChartOutput = {
+    base64Data: string;
+    chartType: string;
+    dataPoints: number;
+};
+export declare function generatePubMedChartLogic(input: GeneratePubMedChartInput, parentRequestContext: RequestContext): Promise<GeneratePubMedChartOutput>;