@cyanheads/pubmed-mcp-server 1.1.4 → 1.2.2

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

@@ -2,7 +2,7 @@
  * @fileoverview Registration for the fetch_pubmed_content MCP tool.
  * @module src/mcp-server/tools/fetchPubMedContent/registration
  */
-import { BaseErrorCode } from "../../../types-global/errors.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
 import { FetchPubMedContentInputSchema, fetchPubMedContentLogic, } from "./logic.js";
 /**
@@ -11,19 +11,55 @@ import { FetchPubMedContentInputSchema, fetchPubMedContentLogic, } from "./logic
  */
 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 });
-    await ErrorHandler.tryCatch(() => {
-        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,
+                };
+            }
         });
-        logger.notice("Tool 'fetch_pubmed_content' registered.", context);
+        logger.notice(`Tool '${toolName}' registered.`, context);
     }, {
         operation,
         context,

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>;

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

@@ -1,17 +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";
-// IMPORTANT DEPLOYMENT NOTE:
-// This tool uses the 'canvas' package to render PNG images on the server.
-// The 'canvas' package has native system dependencies (e.g., cairo, pango, libjpeg).
-// Ensure these are installed on the deployment environment.
-// See: https://www.npmjs.com/package/canvas#compiling
 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()
@@ -21,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()
@@ -44,209 +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."),
+        .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") {
-        const unsupportedFormatError = new McpError(BaseErrorCode.VALIDATION_ERROR, `Unsupported output format: ${input.outputFormat}. Currently, only 'png' is supported.`, { 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 {
-        const 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: {},
-        };
-        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) {
-                    vegaLiteSpec.encoding.color = {
-                        field: input.seriesField,
-                        type: seriesEncType,
-                    };
-                }
-                else if (input.colorField) {
-                    vegaLiteSpec.encoding.color = {
-                        field: input.colorField,
-                        type: colorEncType,
-                    };
-                }
-                break;
-            case "scatter":
-                xEncType = input.xFieldType || "quantitative";
-                vegaLiteSpec.mark = "point";
-                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,
-                    };
-                }
-                break;
-        }
-        const compiledVegaSpec = vegaLite.compile(vegaLiteSpec).spec;
-        const view = new vega.View(vega.parse(compiledVegaSpec), {
-            renderer: "canvas",
-        });
-        await view.runAsync();
-        const canvas = await view.toCanvas();
-        const imageBuffer = await canvas.toBuffer("image/png");
+                },
+        },
+    };
+    try {
+        const imageBuffer = await chartJSNodeCanvas.renderToBuffer(configuration);
         const base64Data = imageBuffer.toString("base64");
-        logger.notice("Successfully generated chart.", {
+        logger.notice("Successfully generated chart with Chart.js.", {
             ...operationContext,
             chartType: input.chartType,
-            outputFormat: input.outputFormat,
             dataPoints: input.dataValues.length,
         });
         return {
-            content: [
-                {
-                    type: "image",
-                    data: base64Data,
-                    mimeType: "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.js

@@ -1,26 +1,70 @@
-import { BaseErrorCode } from "../../../types-global/errors.js";
+import { BaseErrorCode, McpError } from "../../../types-global/errors.js";
 import { ErrorHandler, logger, requestContextService, } from "../../../utils/index.js";
 import { GeneratePubMedChartInputSchema, generatePubMedChartLogic, } from "./logic.js";
 export async function registerGeneratePubMedChartTool(server) {
     const operation = "registerGeneratePubMedChartTool";
-    const regContext = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(() => {
-        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.", regContext);
+        logger.notice(`Tool '${toolName}' registered.`, context);
     }, {
         operation,
-        context: regContext,
+        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/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>;