@cyanheads/pubmed-mcp-server 1.1.2 → 1.2.1

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

@@ -1,12 +1,26 @@
-import * as vega from "vega";
-import * as vegaLite from "vega-lite";
+/**
+ * @fileoverview Core logic for the generate_pubmed_chart tool.
+ * Generates charts from parameterized input by creating Chart.js configurations
+ * and rendering them on the server using chartjs-node-canvas.
+ * @module src/mcp-server/tools/generatePubMedChart/logic
+ */
+import { ChartJSNodeCanvas } from "chartjs-node-canvas";
 import { z } from "zod";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { logger, requestContextService, sanitizeInputForLogging, } from "../../../utils/index.js";
 export const GeneratePubMedChartInputSchema = z.object({
     chartType: z
-        .enum(["bar", "line", "scatter"])
-        .describe("Required. Specifies the type of chart to generate. Options: 'bar', 'line', 'scatter'."),
+        .enum([
+        "bar",
+        "line",
+        "scatter",
+        "pie",
+        "doughnut",
+        "bubble",
+        "radar",
+        "polarArea",
+    ])
+        .describe("Required. Specifies the type of chart to generate. Options: 'bar', 'line', 'scatter', 'pie', 'doughnut', 'bubble', 'radar', 'polarArea'."),
     title: z
         .string()
         .optional()
@@ -16,22 +30,22 @@ export const GeneratePubMedChartInputSchema = z.object({
         .int()
         .positive()
         .optional()
-        .default(400)
-        .describe("Optional. The width of the chart canvas in pixels. Must be a positive integer. Default: 400."),
+        .default(800)
+        .describe("Optional. The width of the chart canvas in pixels. Must be a positive integer. Default: 800."),
     height: z
         .number()
         .int()
         .positive()
         .optional()
-        .default(300)
-        .describe("Optional. The height of the chart canvas in pixels. Must be a positive integer. Default: 300."),
+        .default(600)
+        .describe("Optional. The height of the chart canvas in pixels. Must be a positive integer. Default: 600."),
     dataValues: z
         .array(z.record(z.string(), z.any()))
         .min(1)
         .describe("Required. An array of data objects used to plot the chart. Each object represents a data point or bar, structured as key-value pairs (e.g., [{ 'year': '2020', 'articles': 150 }, { 'year': '2021', 'articles': 180 }]). Must contain at least one data object."),
     outputFormat: z
-        .enum(["png"]) // Changed from svg to png
-        .default("png") // Changed default to png
+        .enum(["png"])
+        .default("png")
         .describe("Specifies the output format for the chart. Currently, only 'png' (Portable Network Graphics) is supported and is the default."),
     xField: z
         .string()
@@ -39,216 +53,141 @@ export const GeneratePubMedChartInputSchema = z.object({
     yField: z
         .string()
         .describe("Required. The name of the field in `dataValues` to be used for the Y-axis (vertical). This field determines the values plotted upwards on the chart (e.g., 'articles', 'expressionLevel', 'citationCount')."),
-    xFieldType: z
-        .enum(["nominal", "ordinal", "quantitative", "temporal"])
-        .optional()
-        .describe("Optional. Specifies the data type of the X-axis field. Options: 'nominal' (categories), 'ordinal' (ordered categories), 'quantitative' (numerical), 'temporal' (dates/times). If omitted, a suitable default is chosen based on `chartType` (e.g., 'nominal' for bar charts, 'temporal' for line charts, 'quantitative' for scatter plots)."),
-    yFieldType: z
-        .enum(["nominal", "ordinal", "quantitative", "temporal"])
-        .optional()
-        .describe("Optional. Specifies the data type of the Y-axis field. Options: 'nominal', 'ordinal', 'quantitative', 'temporal'. Defaults to 'quantitative' if omitted."),
-    // Optional fields for various chart types
-    colorField: z
-        .string()
-        .optional()
-        .describe("Optional. The name of the field in `dataValues` to use for color encoding. This can differentiate bars, lines, or points by color based on the values in this field (e.g., 'studyType', 'country')."),
-    colorFieldType: z
-        .enum(["nominal", "ordinal", "quantitative", "temporal"])
-        .optional()
-        .describe("Optional. Specifies the data type of the `colorField`. Options: 'nominal', 'ordinal', 'quantitative', 'temporal'. Defaults to 'nominal' if `colorField` is provided and this is omitted."),
     seriesField: z
         .string()
         .optional()
-        .describe("Optional. Primarily for line charts. The name of the field in `dataValues` used to create multiple distinct lines (series) on the same chart. Each unique value in this field will correspond to a separate line (e.g., 'drugName' to plot different drug efficacy trends). Often used with `colorField` implicitly or explicitly."),
-    seriesFieldType: z
-        .enum(["nominal", "ordinal", "quantitative", "temporal"])
-        .optional()
-        .describe("Optional. Specifies the data type of the `seriesField`. Options: 'nominal', 'ordinal', 'quantitative', 'temporal'. Defaults to 'nominal' if `seriesField` is provided and this is omitted."),
-    // Scatter plot specific optional fields (can be expanded)
+        .describe("Optional. The name of the field in `dataValues` used to create multiple distinct lines or bar groups (series) on the same chart. Each unique value in this field will correspond to a separate dataset."),
     sizeField: z
         .string()
         .optional()
-        .describe("Optional. For scatter plots. The name of the field in `dataValues` to use for encoding the size of the points. Larger values in this field will result in larger points on the scatter plot (e.g., 'sampleSize', 'effectMagnitude')."),
-    sizeFieldType: z
-        .enum(["quantitative", "ordinal"])
-        .optional()
-        .describe("Optional. Specifies the data type of the `sizeField`. Options: 'quantitative', 'ordinal'. Defaults to 'quantitative' if `sizeField` is provided and this is omitted."),
-    // shapeField: z.string().optional().describe("Optional field for encoding point shape in scatter plots."), // Future enhancement
-    // shapeFieldType: z.enum(["nominal", "ordinal"]).optional().describe("Type of the shape field."), // Future enhancement
+        .describe("Optional. For bubble charts. The name of the field in `dataValues` to use for encoding the size of the bubbles. Larger values in this field will result in larger bubbles (e.g., 'sampleSize', 'effectMagnitude')."),
 });
+// Helper to group data by a series field
+function groupDataBySeries(data, xField, yField, seriesField) {
+    const series = new Map();
+    for (const item of data) {
+        const seriesName = item[seriesField];
+        if (!series.has(seriesName)) {
+            series.set(seriesName, []);
+        }
+        series.get(seriesName).push({ x: item[xField], y: item[yField] });
+    }
+    return series;
+}
 export async function generatePubMedChartLogic(input, parentRequestContext) {
     const operationContext = requestContextService.createRequestContext({
         parentRequestId: parentRequestContext.requestId,
         operation: "generatePubMedChartLogicExecution",
         input: sanitizeInputForLogging(input),
     });
-    logger.info(`Executing 'generate_pubmed_chart'. Chart type: ${input.chartType}, Output format: ${input.outputFormat}`, operationContext);
-    if (input.outputFormat !== "png") {
-        // Changed from svg to png
-        const unsupportedFormatError = new McpError(BaseErrorCode.VALIDATION_ERROR, `Unsupported output format: ${input.outputFormat}. Currently, only 'png' is supported.`, // Changed message
-        { requestedFormat: input.outputFormat });
-        logger.warning(unsupportedFormatError.message, operationContext);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: unsupportedFormatError.code,
-                            message: unsupportedFormatError.message,
-                            details: unsupportedFormatError.details,
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
+    logger.info(`Executing 'generate_pubmed_chart' with Chart.js. Chart type: ${input.chartType}`, operationContext);
+    const { width, height, chartType, dataValues, xField, yField, title, seriesField, sizeField, } = input;
+    const chartJSNodeCanvas = new ChartJSNodeCanvas({
+        width,
+        height,
+        chartCallback: (ChartJS) => {
+            ChartJS.defaults.responsive = false;
+            ChartJS.defaults.maintainAspectRatio = false;
+        },
+    });
+    const labels = [...new Set(dataValues.map((item) => item[xField]))];
+    let datasets;
+    if (seriesField) {
+        const groupedData = groupDataBySeries(dataValues, xField, yField, seriesField);
+        datasets = Array.from(groupedData.entries()).map(([seriesName, data]) => ({
+            label: seriesName,
+            data: labels.map(label => {
+                const point = data.find(p => p.x === label);
+                return point ? point.y : null;
+            }),
+            // You can add backgroundColor, borderColor etc. here for styling
+        }));
     }
-    try {
-        let vegaLiteSpec = {
-            $schema: "https://vega.github.io/schema/vega-lite/v5.json",
-            title: input.title,
-            width: input.width,
-            height: input.height,
-            data: { values: input.dataValues },
-            encoding: {}, // To be populated by chart type specific logic
-        };
-        // Default field types if not provided
-        const yEncType = input.yFieldType || "quantitative";
-        const colorEncType = input.colorFieldType || "nominal";
-        const seriesEncType = input.seriesFieldType || "nominal";
-        const sizeEncType = input.sizeFieldType || "quantitative";
-        let xEncType;
-        switch (input.chartType) {
-            case "bar":
-                xEncType = input.xFieldType || "nominal";
-                vegaLiteSpec.mark = "bar";
-                vegaLiteSpec.encoding = {
-                    x: {
-                        field: input.xField,
-                        type: xEncType,
-                        axis: { title: input.xField },
-                    },
-                    y: {
-                        field: input.yField,
-                        type: yEncType,
-                        axis: { title: input.yField },
-                    },
-                };
-                if (input.colorField) {
-                    vegaLiteSpec.encoding.color = {
-                        field: input.colorField,
-                        type: colorEncType,
-                    };
-                }
-                break;
-            case "line":
-                xEncType = input.xFieldType || "temporal";
-                vegaLiteSpec.mark = "line";
-                vegaLiteSpec.encoding = {
-                    x: {
-                        field: input.xField,
-                        type: xEncType,
-                        axis: { title: input.xField },
-                    },
-                    y: {
-                        field: input.yField,
-                        type: yEncType,
-                        axis: { title: input.yField },
-                    },
-                };
-                if (input.seriesField) {
-                    // For line charts, seriesField is typically used for color
-                    vegaLiteSpec.encoding.color = {
-                        field: input.seriesField,
-                        type: seriesEncType,
-                    };
-                }
-                else if (input.colorField) {
-                    // Allow direct colorField as well
-                    vegaLiteSpec.encoding.color = {
-                        field: input.colorField,
-                        type: colorEncType,
-                    };
-                }
-                break;
-            case "scatter":
-                xEncType = input.xFieldType || "quantitative";
-                vegaLiteSpec.mark = "point"; // "circle" is also an option
-                vegaLiteSpec.encoding = {
+    else {
+        datasets = [
+            {
+                label: yField,
+                data: labels.map(label => {
+                    const item = dataValues.find(d => d[xField] === label);
+                    return item ? item[yField] : null;
+                }),
+            },
+        ];
+    }
+    // For scatter and bubble charts, the data format is different
+    if (chartType === 'scatter' || chartType === 'bubble') {
+        if (seriesField) {
+            const groupedData = groupDataBySeries(dataValues, xField, yField, seriesField);
+            datasets = Array.from(groupedData.entries()).map(([seriesName, data]) => ({
+                label: seriesName,
+                data: data.map(point => ({
+                    x: point.x,
+                    y: point.y,
+                    r: chartType === 'bubble' && sizeField ? dataValues.find(d => d[xField] === point.x)[sizeField] : undefined
+                })),
+            }));
+        }
+        else {
+            datasets = [{
+                    label: yField,
+                    data: dataValues.map(item => ({
+                        x: item[xField],
+                        y: item[yField],
+                        r: chartType === 'bubble' && sizeField ? item[sizeField] : undefined
+                    })),
+                }];
+        }
+    }
+    const configuration = {
+        type: chartType,
+        data: {
+            labels: (chartType !== 'scatter' && chartType !== 'bubble') ? labels : undefined,
+            datasets: datasets,
+        },
+        options: {
+            plugins: {
+                title: {
+                    display: !!title,
+                    text: title,
+                },
+            },
+            scales: chartType === "pie" || chartType === "doughnut" || chartType === "polarArea"
+                ? undefined
+                : {
                     x: {
-                        field: input.xField,
-                        type: xEncType,
-                        axis: { title: input.xField },
+                        title: {
+                            display: true,
+                            text: xField,
+                        },
                     },
                     y: {
-                        field: input.yField,
-                        type: yEncType,
-                        axis: { title: input.yField },
+                        title: {
+                            display: true,
+                            text: yField,
+                        },
                     },
-                };
-                if (input.colorField) {
-                    vegaLiteSpec.encoding.color = {
-                        field: input.colorField,
-                        type: colorEncType,
-                    };
-                }
-                if (input.sizeField) {
-                    vegaLiteSpec.encoding.size = {
-                        field: input.sizeField,
-                        type: sizeEncType,
-                    };
-                }
-                // Add shape encoding here if shapeField is implemented
-                break;
-            // No default case needed as chartType is an enum and Zod validates it.
-        }
-        const compiledVegaSpec = vegaLite.compile(vegaLiteSpec).spec;
-        const view = new vega.View(vega.parse(compiledVegaSpec), {
-            renderer: "canvas", // Explicitly set renderer to 'canvas'
-        });
-        // const svgString = await view.toSVG(); // Old SVG method
-        // New PNG method
-        // Initialize the view to ensure canvas is ready
-        await view.runAsync(); // Initialize and run the view
-        const canvas = await view.toCanvas(); // Render to canvas
-        // Cast to 'any' to access toBuffer, assuming it's a Node Canvas instance at runtime
-        const imageBuffer = await canvas.toBuffer("image/png"); // Get PNG buffer from canvas
+                },
+        },
+    };
+    try {
+        const imageBuffer = await chartJSNodeCanvas.renderToBuffer(configuration);
         const base64Data = imageBuffer.toString("base64");
+        logger.notice("Successfully generated chart with Chart.js.", {
+            ...operationContext,
+            chartType: input.chartType,
+            dataPoints: input.dataValues.length,
+        });
         return {
-            content: [
-                {
-                    type: "image",
-                    data: base64Data,
-                    mimeType: "image/png", // Changed MIME type to image/png
-                },
-            ],
-            isError: false,
+            base64Data,
+            chartType: input.chartType,
+            dataPoints: input.dataValues.length,
         };
     }
     catch (error) {
-        logger.error("Execution failed for 'generate_pubmed_chart'", error, operationContext);
-        const mcpError = error instanceof McpError
-            ? error
-            : new McpError(BaseErrorCode.INTERNAL_ERROR, `'generate_pubmed_chart' failed: ${error.message || "Internal server error during chart generation."}`, {
-                originalErrorName: error.name,
-                originalErrorMessage: error.message,
-                requestId: operationContext.requestId,
-            });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        error: {
-                            code: mcpError.code,
-                            message: mcpError.message,
-                            details: mcpError.details,
-                        },
-                    }),
-                },
-            ],
-            isError: true,
-        };
+        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Chart generation failed: ${error.message || "Internal server error during chart generation."}`, {
+            ...operationContext,
+            originalErrorName: error.name,
+            originalErrorMessage: error.message,
+        });
     }
 }

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

@@ -4,4 +4,4 @@
  * @module src/mcp-server/tools/generatePubMedChart/registration
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerGeneratePubMedChartTool(server: McpServer): void;
+export declare function registerGeneratePubMedChartTool(server: McpServer): Promise<void>;

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

@@ -1,36 +1,71 @@
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
 import { GeneratePubMedChartInputSchema, generatePubMedChartLogic, } from "./logic.js";
-export function registerGeneratePubMedChartTool(server) {
+export async function registerGeneratePubMedChartTool(server) {
     const operation = "registerGeneratePubMedChartTool";
-    const regContext = requestContextService.createRequestContext({ operation });
-    try {
-        server.tool("generate_pubmed_chart", "Generates a customizable chart (PNG) from structured data. " +
-            "Supports 'bar', 'line', and 'scatter' plots. " +
-            "Requires data values and field mappings for axes. " +
-            "Optional parameters allow for titles, dimensions, and color/size/series encoding. " +
-            "Internally uses Vega-Lite and a canvas renderer to produce a Base64-encoded PNG image.", GeneratePubMedChartInputSchema.shape, async (validatedInput, mcpProvidedContext) => {
-            const handlerRequestContext = requestContextService.createRequestContext({
-                parentRequestId: regContext.requestId,
+    const toolName = "generate_pubmed_chart";
+    const toolDescription = "Generates a customizable chart (PNG) from structured data. " +
+        "Supports 'bar', 'line', 'scatter', 'pie', 'doughnut', 'bubble', 'radar', and 'polarArea' plots. " +
+        "Requires data values and field mappings for axes. " +
+        "Optional parameters allow for titles and dimensions. " +
+        "Internally uses Chart.js and chartjs-node-canvas to produce a Base64-encoded PNG image.";
+    const context = requestContextService.createRequestContext({ operation });
+    await ErrorHandler.tryCatch(async () => {
+        server.tool(toolName, toolDescription, GeneratePubMedChartInputSchema.shape, async (input, mcpProvidedContext) => {
+            const richContext = requestContextService.createRequestContext({
+                parentRequestId: context.requestId,
                 operation: "generatePubMedChartToolHandler",
                 mcpToolContext: mcpProvidedContext,
+                input,
             });
-            return generatePubMedChartLogic(validatedInput, handlerRequestContext);
+            try {
+                const result = await generatePubMedChartLogic(input, richContext);
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: result.base64Data,
+                            mimeType: "image/png",
+                        },
+                    ],
+                    isError: false,
+                };
+            }
+            catch (error) {
+                const handledError = ErrorHandler.handleError(error, {
+                    operation: "generatePubMedChartToolHandler",
+                    context: richContext,
+                    input,
+                    rethrow: false,
+                });
+                const mcpError = handledError instanceof McpError
+                    ? handledError
+                    : new McpError(BaseErrorCode.INTERNAL_ERROR, "An unexpected error occurred while generating the chart.", {
+                        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,
+                };
+            }
         });
-        logger.notice(`Tool 'generate_pubmed_chart' registered with updated schema (added scatter).`, regContext);
-    }
-    catch (error) {
-        const mcpError = error instanceof McpError
-            ? error
-            : new McpError(BaseErrorCode.INITIALIZATION_FAILED, `Failed to register 'generate_pubmed_chart': ${error instanceof Error ? error.message : String(error)}`, {
-                originalErrorName: error instanceof Error ? error.name : "UnknownError",
-                details: "Error during server.tool() call for generate_pubmed_chart.",
-            });
-        ErrorHandler.handleError(mcpError, {
-            operation,
-            context: regContext,
-            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/getPubMedArticleConnections/logic/citationFormatter.d.ts

@@ -4,6 +4,6 @@
  * @module src/mcp-server/tools/getPubMedArticleConnections/logic/citationFormatter
  */
 import { RequestContext } from "../../../../utils/index.js";
-import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+import type { GetPubMedArticleConnectionsInput } from "./index.js";
 import type { ToolOutputData } from "./types.js";
 export declare function handleCitationFormats(input: GetPubMedArticleConnectionsInput, outputData: ToolOutputData, context: RequestContext): Promise<void>;

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/citationFormatter.js

@@ -199,8 +199,8 @@ function formatAsAPA(article, context) {
     }
     const year = journalInfo?.publicationDate?.year || "n.d.";
     const apaTitle = titleText.charAt(0).toUpperCase() + titleText.slice(1); // APA typically sentence case for article titles.
-    const journal = journalInfo?.title ? `<em>${journalInfo.title}</em>` : "N/A";
-    const volume = journalInfo?.volume ? `<em>${journalInfo.volume}</em>` : "";
+    const journal = journalInfo?.title || "N/A";
+    const volume = journalInfo?.volume || "";
     const issue = journalInfo?.issue ? `(${journalInfo.issue})` : "";
     const pages = journalInfo?.pages || "";
     const doiLink = doi ? ` https://doi.org/${doi}` : "";
@@ -253,7 +253,7 @@ function formatAsMLA(article, context) {
         }
     }
     const title = titleText ? `"${titleText}."` : "N/A.";
-    const journal = journalInfo?.title ? `<em>${journalInfo.title}</em>` : "N/A";
+    const journal = journalInfo?.title || "N/A";
     let publicationDateString = journalInfo?.publicationDate?.year || "";
     if (journalInfo?.publicationDate?.month && journalInfo.publicationDate.year) {
         const month = journalInfo.publicationDate.month.substring(0, 3) + "."; // Abbreviate month

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler.d.ts

@@ -4,6 +4,6 @@
  * @module src/mcp-server/tools/getPubMedArticleConnections/logic/elinkHandler
  */
 import { RequestContext } from "../../../../utils/index.js";
-import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+import type { GetPubMedArticleConnectionsInput } from "./index.js";
 import type { ToolOutputData } from "./types.js";
 export declare function handleELinkRelationships(input: GetPubMedArticleConnectionsInput, outputData: ToolOutputData, context: RequestContext): Promise<void>;

package/dist/mcp-server/tools/getPubMedArticleConnections/logic/index.d.ts

@@ -3,13 +3,36 @@
  * Orchestrates calls to ELink or citation formatting handlers.
  * @module src/mcp-server/tools/getPubMedArticleConnections/logic/index
  */
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
 import { RequestContext } from "../../../../utils/index.js";
-import type { GetPubMedArticleConnectionsInput } from "../registration.js";
+import type { ToolOutputData } from "./types.js";
+/**
+ * Zod schema for the input parameters of the 'get_pubmed_article_connections' tool.
+ */
+export declare const GetPubMedArticleConnectionsInputSchema: z.ZodObject<{
+    sourcePmid: z.ZodString;
+    relationshipType: z.ZodDefault<z.ZodEnum<["pubmed_similar_articles", "pubmed_citedin", "pubmed_references", "citation_formats"]>>;
+    maxRelatedResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    citationStyles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["ris", "bibtex", "apa_string", "mla_string"]>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    sourcePmid: string;
+    relationshipType: "pubmed_similar_articles" | "pubmed_citedin" | "pubmed_references" | "citation_formats";
+    maxRelatedResults: number;
+    citationStyles: ("ris" | "bibtex" | "apa_string" | "mla_string")[];
+}, {
+    sourcePmid: string;
+    relationshipType?: "pubmed_similar_articles" | "pubmed_citedin" | "pubmed_references" | "citation_formats" | undefined;
+    maxRelatedResults?: number | undefined;
+    citationStyles?: ("ris" | "bibtex" | "apa_string" | "mla_string")[] | undefined;
+}>;
+/**
+ * Type alias for the validated input of the 'get_pubmed_article_connections' tool.
+ */
+export type GetPubMedArticleConnectionsInput = z.infer<typeof GetPubMedArticleConnectionsInputSchema>;
 /**
  * Main handler for the 'get_pubmed_article_connections' tool.
  * @param {GetPubMedArticleConnectionsInput} input - Validated input parameters.
  * @param {RequestContext} context - The request context for this tool invocation.
- * @returns {Promise<CallToolResult>} The result of the tool call.
+ * @returns {Promise<ToolOutputData>} The result of the tool call.
  */
-export declare function handleGetPubMedArticleConnections(input: GetPubMedArticleConnectionsInput, context: RequestContext): Promise<CallToolResult>;
+export declare function handleGetPubMedArticleConnections(input: GetPubMedArticleConnectionsInput, context: RequestContext): Promise<ToolOutputData>;