@cyanheads/pubmed-mcp-server 1.1.4 → 1.2.2

package/README.md

@@ -1,8 +1,8 @@
 # PubMed MCP Server
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-^5.8.3-blue.svg)](https://www.typescriptlang.org/)
-[![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.12.1-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-1.1.4-blue.svg)](./CHANGELOG.md)
+[![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.13.0-green.svg)](https://modelcontextprotocol.io/)
+[![Version](https://img.shields.io/badge/Version-1.2.2-blue.svg)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/pubmed-mcp-server/issues)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/pubmed-mcp-server?style=social)](https://github.com/cyanheads/pubmed-mcp-server)
@@ -23,7 +23,7 @@ This server equips your AI with specialized tools to interact with PubMed:
 | [`fetch_pubmed_content`](./src/mcp-server/tools/fetchPubMedContent/)                    | Retrieves detailed information for PubMed articles. Can use a list of PMIDs or ESearch history (queryKey/webEnv) with pagination. (See [Example](./examples/fetch_pubmed_content_example.md))                | - Flexible `detailLevel`: `abstract_plus` (parsed details, optional MeSH/grant), `full_xml` (JSON representation of the PubMedArticle XML structure), `medline_text` (MEDLINE format), `citation_data` (minimal for citations).<br/>- Supports direct PMID list or `queryKey`/`webEnv` from ESearch history.<br/>- Supports `retstart`/`retmax` for pagination with history.<br/>- Uses NCBI EFetch. |
 | [`get_pubmed_article_connections`](./src/mcp-server/tools/getPubMedArticleConnections/) | Finds related articles (cited by, similar, references) or formats citations for a PMID. (See [Ex.1](./examples/get_pubmed_article_connections_1.md), [Ex.2](./examples/get_pubmed_article_connections_2.md)) | - Uses NCBI ELink for relationships.<br/>- Uses NCBI EFetch for citation data (RIS, BibTeX, APA, MLA).<br/>- Filter by max related results.                                                                                                                                                                                                                                                          |
 | [`pubmed_research_agent`](./src/mcp-server/tools/pubmedResearchAgent/)                  | Generates a standardized JSON research plan outline from component details. (See [Example](./examples/pubmed_research_agent_example.md))                                                                     | - Accepts granular inputs for all research phases.<br/>- Optionally embeds instructive prompts for agent execution.<br/>- Structures rough ideas into a formal, machine-readable plan for further processing.                                                                                                                                                                                        |
-| [`generate_pubmed_chart`](./src/mcp-server/tools/generatePubMedChart/)                  | Generates a chart image (PNG) from given input data. (See [Examples](./examples/))                                                                                                                           | - Supports 'bar', 'line', and 'scatter' chart types.<br/>- Takes data values and field specifications for axes and encoding.<br/>- Constructs a Vega-Lite specification internally and renders it as a PNG using a canvas renderer.                                                                                                                                                                  |
+| [`generate_pubmed_chart`](./src/mcp-server/tools/generatePubMedChart/)                  | Generates a chart image (PNG) from given input data. (See [Examples](./examples/generate_pubmed_chart))                                                                                                      | - Supports a wide range of chart types: `bar`, `line`, `scatter`, `pie`, `doughnut`, `bubble`, `radar`, and `polarArea`.<br/>- Takes data values and field specifications for axes and series.<br/>- Uses `Chart.js` and `chartjs-node-canvas` for direct server-side rendering.                                                                                                                     |
 
 ---
 
@@ -62,7 +62,7 @@ Leverages the robust utilities provided by the `mcp-ts-template`:
 - **Input Validation/Sanitization**: Uses `zod` for schema validation and custom sanitization logic.
 - **Request Context**: Tracking and correlation of operations via unique request IDs using `AsyncLocalStorage`.
 - **Type Safety**: Strong typing enforced by TypeScript and Zod schemas.
-- **HTTP Transport**: High-performance HTTP server using **Hono**, featuring session management with garbage collection, CORS, and IP-based rate limiting.
+- **HTTP Transport**: High-performance HTTP server using **Hono**, featuring session management with garbage collection and CORS support.
 - **Authentication**: Robust authentication layer supporting JWT and OAuth 2.1, with fine-grained scope enforcement.
 - **Deployment**: Multi-stage `Dockerfile` for creating small, secure production images with native dependency support.
 
@@ -73,7 +73,7 @@ Leverages the robust utilities provided by the `mcp-ts-template`:
 - **Full Article Metadata**: Retrieve complete publication data including abstracts, authors, affiliations, journal information, DOIs, and citation data.
 - **Citation Network Analysis**: Find related articles, citing articles, and reference lists through ELink integration.
 - **Research Planning**: Generate structured research plans with automated literature search strategies.
-- **Data Visualization**: Create PNG charts from publication metadata (bar charts, line graphs, scatter plots).
+- **Data Visualization**: Create PNG charts from publication metadata (bar, line, scatter, pie, bubble, radar, polarArea).
 - **Multiple Output Formats**: Support for JSON, MEDLINE text, full XML, and formatted citations (RIS, BibTeX, APA, MLA).
 - **Batch Processing**: Efficient handling of multiple PMIDs with pagination support.
 
@@ -135,14 +135,14 @@ Configure the server using environment variables. These environmental variables
 
 ### MCP Client Settings
 
-Add to your MCP client settings (e.g., `cline_mcp_settings.json`):
+Add the following to your MCP client's configuration file (e.g., `cline_mcp_settings.json`). This configuration uses `npx` to run the server, which will automatically install the package if not already present:
 
 ```json
 {
   "mcpServers": {
     "pubmed-mcp-server": {
-      "command": "node",
-      "args": ["/path/to/your/pubmed-mcp-server/dist/index.js"],
+      "command": "npx",
+      "args": ["@cyanheads/pubmed-mcp-server"],
       "env": {
         "NCBI_API_KEY": "your_ncbi_api_key_here"
       },
@@ -153,8 +153,6 @@ Add to your MCP client settings (e.g., `cline_mcp_settings.json`):
 }
 ```
 
-**Note**: You can see [mcp.json](mcp.json) for an example MCP client configuration file that includes the PubMed MCP Server.
-
 ## Project Structure
 
 The codebase follows a modular structure within the `src/` directory:
@@ -187,7 +185,7 @@ The PubMed MCP Server provides a comprehensive suite of tools for biomedical lit
 | `fetch_pubmed_content`           | Fetches detailed article information using PMIDs or search history.    | `pmids?`, `queryKey?`, `webEnv?`, `detailLevel?`, `includeMeshTerms?`, `includeGrantInfo?`                |
 | `get_pubmed_article_connections` | Finds related articles, citations, and references for a given PMID.    | `sourcePmid`, `relationshipType?`, `maxRelatedResults?`, `citationStyles?`                                |
 | `pubmed_research_agent`          | Generates structured research plans with literature search strategies. | `project_title_suggestion`, `primary_research_goal`, `research_keywords`, `organism_focus?`, `p1_*`, etc. |
-| `generate_pubmed_chart`          | Creates customizable PNG charts from structured publication data.      | `chartType`, `dataValues`, `xField`, `yField`, `title?`, `colorField?`, `seriesField?`, `sizeField?`      |
+| `generate_pubmed_chart`          | Creates customizable PNG charts from structured publication data.      | `chartType`, `dataValues`, `xField`, `yField`, `title?`, `seriesField?`, `sizeField?`                     |
 
 _Note: All tools support comprehensive error handling and return structured JSON responses._
 
@@ -199,7 +197,7 @@ Comprehensive usage examples are available in the [`examples/`](examples/) direc
 - [Fetch Article Content](examples/fetch_pubmed_content_example.md)
 - [Article Connections](examples/get_pubmed_article_connections_1.md)
 - [Research Planning](examples/pubmed_research_agent_example.md)
-- [Chart Generation](examples/) - Generated chart examples (bar, line, scatter) are available in the `examples/` directory.
+- [Chart Generation](./examples/generate_pubmed_chart/) - Generated chart examples (bar, line, scatter, pie, bubble, radar, polarArea) are available in the `examples/generate_pubmed_chart/` directory.
 
 ## Development
 

package/dist/mcp-server/server.d.ts

@@ -18,12 +18,5 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 /**
  * Main application entry point. Initializes and starts the MCP server.
  * Orchestrates server startup, transport selection, and top-level error handling.
- *
- * MCP Spec Relevance:
- * - Manages server startup, leading to a server ready for MCP messages.
- * - Handles critical startup failures, ensuring appropriate process exit.
- *
- * @returns For 'stdio', resolves with `McpServer`. For 'http', resolves with `http.Server`.
- *   Rejects on critical failure, leading to process exit.
  */
 export declare function initializeAndStartServer(): Promise<void | McpServer | ServerType>;

package/dist/mcp-server/server.js

@@ -16,6 +16,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { config, environment } from "../config/index.js";
 import { ErrorHandler, logger, requestContextService } from "../utils/index.js";
+import { BaseErrorCode } from "../types-global/errors.js";
 import { registerFetchPubMedContentTool } from "./tools/fetchPubMedContent/index.js";
 import { registerGeneratePubMedChartTool } from "./tools/generatePubMedChart/index.js";
 import { registerGetPubMedArticleConnectionsTool } from "./tools/getPubMedArticleConnections/index.js";
@@ -34,10 +35,8 @@ import { connectStdioTransport } from "./transports/stdioTransport.js";
  * - Capabilities Declaration: Declares supported features (logging, dynamic resources/tools).
  * - Resource/Tool Registration: Makes capabilities discoverable and invocable.
  *
- * Design Note: This factory is called once for 'stdio' transport and per session for 'http' transport.
- *
  * @returns A promise resolving with the configured `McpServer` instance.
- * @throws {Error} If any resource or tool registration fails.
+ * @throws {McpError} If any resource or tool registration fails.
  * @private
  */
 async function createMcpServerInstance() {
@@ -50,18 +49,6 @@ async function createMcpServerInstance() {
         appVersion: config.mcpServerVersion,
         environment,
     });
-    logger.debug("Instantiating McpServer with capabilities", {
-        ...context,
-        serverInfo: {
-            name: config.mcpServerName,
-            version: config.mcpServerVersion,
-        },
-        capabilities: {
-            logging: {},
-            resources: { listChanged: true },
-            tools: { listChanged: true },
-        },
-    });
     const server = new McpServer({ name: config.mcpServerName, version: config.mcpServerVersion }, {
         capabilities: {
             logging: {}, // Server can receive logging/setLevel and send notifications/message
@@ -69,7 +56,7 @@ async function createMcpServerInstance() {
             tools: { listChanged: true }, // Server supports dynamic tool lists
         },
     });
-    try {
+    await ErrorHandler.tryCatch(async () => {
         logger.debug("Registering resources and tools...", context);
         // IMPORTANT: Keep tool registrations in alphabetical order. Do not remove this comment.
         await registerFetchPubMedContentTool(server);
@@ -77,17 +64,13 @@ async function createMcpServerInstance() {
         await registerGetPubMedArticleConnectionsTool(server);
         await registerPubMedResearchAgentTool(server);
         await registerSearchPubMedArticlesTool(server);
-        // Add other tool/resource registrations here
         logger.info("Resources and tools registered successfully", context);
-    }
-    catch (err) {
-        logger.error("Failed to register resources/tools", {
-            ...context,
-            error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : undefined,
-        });
-        throw err;
-    }
+    }, {
+        operation: "registerAllTools",
+        context,
+        errorCode: BaseErrorCode.INITIALIZATION_FAILED,
+        critical: true,
+    });
     return server;
 }
 /**
@@ -98,7 +81,7 @@ async function createMcpServerInstance() {
  * - Transport Connection: Calls dedicated functions for chosen transport.
  * - Server Instance Lifecycle: Single instance for 'stdio', per-session for 'http'.
  *
- * @returns Resolves with `McpServer` for 'stdio', `http.Server` for 'http', or `void` if http transport manages its own lifecycle without returning a server.
+ * @returns Resolves with `McpServer` for 'stdio', `http.Server` for 'http', or `void`.
  * @throws {Error} If transport type is unsupported or setup fails.
  * @private
  */
@@ -110,32 +93,18 @@ async function startTransport() {
     });
     logger.info(`Starting transport: ${transportType}`, context);
     if (transportType === "http") {
-        logger.debug("Delegating to startHttpTransport...", context);
-        // For HTTP, startHttpTransport now returns the http.Server instance.
-        const httpServerInstance = await startHttpTransport(createMcpServerInstance, context);
-        return httpServerInstance;
+        return startHttpTransport(createMcpServerInstance, context);
     }
     if (transportType === "stdio") {
-        logger.debug("Creating single McpServer instance for stdio transport...", context);
         const server = await createMcpServerInstance();
-        logger.debug("Delegating to connectStdioTransport...", context);
         await connectStdioTransport(server, context);
-        return server; // Return the single McpServer instance for stdio.
+        return server;
     }
-    // Should not be reached if config validation is effective.
-    logger.fatal(`Unsupported transport type configured: ${transportType}`, context);
     throw new Error(`Unsupported transport type: ${transportType}. Must be 'stdio' or 'http'.`);
 }
 /**
  * Main application entry point. Initializes and starts the MCP server.
  * Orchestrates server startup, transport selection, and top-level error handling.
- *
- * MCP Spec Relevance:
- * - Manages server startup, leading to a server ready for MCP messages.
- * - Handles critical startup failures, ensuring appropriate process exit.
- *
- * @returns For 'stdio', resolves with `McpServer`. For 'http', resolves with `http.Server`.
- *   Rejects on critical failure, leading to process exit.
  */
 export async function initializeAndStartServer() {
     const context = requestContextService.createRequestContext({
@@ -148,18 +117,13 @@ export async function initializeAndStartServer() {
         return result;
     }
     catch (err) {
-        logger.fatal("Critical error during MCP server initialization.", {
-            ...context,
-            error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : undefined,
-        });
-        // Ensure the error is handled by our centralized handler, which might log more details or perform cleanup.
         ErrorHandler.handleError(err, {
-            operation: "initializeAndStartServer", // More specific operation
-            context: context, // Pass the existing context
-            critical: true, // This is a critical failure
+            operation: "initializeAndStartServer",
+            context: context,
+            critical: true,
+            rethrow: false, // Ensure we don't rethrow, so we can exit gracefully.
         });
         logger.info("Exiting process due to critical initialization error.", context);
-        process.exit(1); // Exit with a non-zero code to indicate failure.
+        process.exit(1);
     }
 }

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

@@ -5,7 +5,6 @@
  * MEDLINE text, and citation data.
  * @module src/mcp-server/tools/fetchPubMedContent/logic
  */
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { RequestContext } from "../../../utils/index.js";
 export declare const FetchPubMedContentInputSchema: z.ZodEffects<z.ZodObject<{
@@ -60,4 +59,9 @@ export declare const FetchPubMedContentInputSchema: z.ZodEffects<z.ZodObject<{
     outputFormat?: "json" | "raw_text" | undefined;
 }>;
 export type FetchPubMedContentInput = z.infer<typeof FetchPubMedContentInputSchema>;
-export declare function fetchPubMedContentLogic(input: FetchPubMedContentInput, parentRequestContext: RequestContext): Promise<CallToolResult>;
+export type FetchPubMedContentOutput = {
+    content: string;
+    articlesReturned: number;
+    eFetchUrl: string;
+};
+export declare function fetchPubMedContentLogic(input: FetchPubMedContentInput, parentRequestContext: RequestContext): Promise<FetchPubMedContentOutput>;

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

@@ -106,48 +106,28 @@ function parsePubMedArticleSet(xmlData, input, parentContext) {
     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;
     const articleSet = typedXmlData.PubmedArticleSet;
     if (!articleSet || !articleSet.PubmedArticle) {
-        logger.warning("PubmedArticleSet or PubmedArticle array not found in EFetch XML response.", {
-            ...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);
-    const totalArticlesInXml = pubmedArticlesXml.length;
     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);
-        if (!pmid) {
-            logger.warning("Could not extract PMID from MedlineCitation, skipping.", {
-                ...operationContext,
-                medlineCitationPreview: sanitizeInputForLogging(JSON.stringify(medlineCitation).substring(0, 200)),
-            });
+        if (!pmid)
             continue;
-        }
         const articleNode = medlineCitation.Article;
         const parsedArticle = {
             pmid: pmid,
@@ -186,11 +166,6 @@ function parsePubMedArticleSet(xmlData, input, parentContext) {
         }
         articles.push(parsedArticle);
     }
-    logger.debug(`Successfully parsed ${articles.length} of ${totalArticlesInXml} articles from XML.`, {
-        ...operationContext,
-        parsedCount: articles.length,
-        totalInXml: totalArticlesInXml,
-    });
     return articles;
 }
 export async function fetchPubMedContentLogic(input, parentRequestContext) {
@@ -199,26 +174,9 @@ export async function fetchPubMedContentLogic(input, parentRequestContext) {
         operation: "fetchPubMedContentLogic",
         input: sanitizeInputForLogging(input),
     });
-    // Manual validation safeguard
     const validationResult = FetchPubMedContentInputSchema.safeParse(input);
     if (!validationResult.success) {
-        const errorMessage = validationResult.error.errors[0]?.message || "Invalid input";
-        logger.warning(`Input validation failed pre-check: ${errorMessage}`, toolLogicContext);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: BaseErrorCode.VALIDATION_ERROR,
-                            message: errorMessage,
-                            details: validationResult.error.flatten(),
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
+        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);
@@ -228,12 +186,10 @@ export async function fetchPubMedContentLogic(input, parentRequestContext) {
         usingHistory = true;
         eFetchParams.query_key = input.queryKey;
         eFetchParams.WebEnv = input.webEnv;
-        if (input.retstart !== undefined) {
+        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(",");
@@ -256,163 +212,99 @@ export async function fetchPubMedContentLogic(input, parentRequestContext) {
     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}`;
-        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;
-        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]);
-            }
-            articlesCount = foundPmidsInMedline.size;
-            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",
-                },
-            };
-            finalOutputText =
-                input.outputFormat === "raw_text"
-                    ? medlineText
-                    : 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") {
-                finalOutputText = String(eFetchResponseData);
-                articlesCount = (finalOutputText.match(/<PubmedArticle>/g) || []).length;
-            }
-            else {
-                const articlesXml = ensureArray(eFetchResponseData?.PubmedArticleSet?.PubmedArticle || []);
-                articlesCount = articlesXml.length;
-                const articlesPayload = [];
-                const foundPmidsInXml = new Set();
-                for (const articleXml of articlesXml) {
-                    const pmid = extractPmid(articleXml.MedlineCitation) || "unknown_pmid";
-                    if (pmid !== "unknown_pmid")
-                        foundPmidsInXml.add(pmid);
-                    articlesPayload.push({ pmid, fullXmlContent: articleXml });
-                }
-                const notFoundPmids = input.pmids && input.pmids.length > 0
-                    ? input.pmids.filter((pmid) => !foundPmidsInXml.has(pmid))
-                    : "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
-            const parsedArticles = parsePubMedArticleSet(eFetchResponseData, input, toolLogicContext);
-            articlesCount = parsedArticles.length;
-            const foundPmids = new Set(parsedArticles.map((p) => p.pmid));
-            const notFoundPmids = input.pmids && input.pmids.length > 0
-                ? input.pmids.filter((pmid) => !foundPmids.has(pmid))
-                : "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,
-                    ...(input.includeMeshTerms && { meshTerms: article.meshTerms }),
-                }));
-            }
-            finalOutputText = JSON.stringify(structuredResponseData);
+                eFetchDetails: { urls: [eFetchUrl] },
+            });
         }
-        logger.notice("Successfully executed fetch_pubmed_content tool.", {
-            ...toolLogicContext,
-            detailLevel: input.detailLevel,
-            outputFormat: input.outputFormat,
-            articlesReturned: articlesCount,
-            usingHistory,
-        });
-        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,
+    };
 }