@umengfe/mcp-server-chart 0.0.1

package/build/charts/treemap.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+export declare const treemap: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNumber;
+            children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodNumber;
+                children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    value: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    value: number;
+                    name: string;
+                }, {
+                    value: number;
+                    name: string;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                value: number;
+                name: string;
+                children?: {
+                    value: number;
+                    name: string;
+                }[] | undefined;
+            }, {
+                value: number;
+                name: string;
+                children?: {
+                    value: number;
+                    name: string;
+                }[] | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            name: string;
+            children?: {
+                value: number;
+                name: string;
+                children?: {
+                    value: number;
+                    name: string;
+                }[] | undefined;
+            }[] | undefined;
+        }, {
+            value: number;
+            name: string;
+            children?: {
+                value: number;
+                name: string;
+                children?: {
+                    value: number;
+                    name: string;
+                }[] | undefined;
+            }[] | undefined;
+        }>, "atleastone">;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+        }, {
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+            texture?: "default" | "rough" | undefined;
+        }>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "academy", "dark"]>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: import("zod-to-json-schema").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+            } | undefined;
+        };
+    };
+};

package/build/charts/treemap.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.treemap = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Define recursive schema for hierarchical data.
+// The recursive schema is not supported by gemini, and other clients, so we use a non-recursive schema which can represent a tree structure with a fixed depth.
+// Ref: https://github.com/antvis/mcp-server-chart/issues/155
+// Ref: https://github.com/antvis/mcp-server-chart/issues/132
+const TreeNodeSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    value: zod_1.z.number(),
+    children: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        value: zod_1.z.number(),
+        children: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string(),
+            value: zod_1.z.number(),
+        }))
+            .optional(),
+    }))
+        .optional(),
+});
+// Treemap chart input schema
+const schema = {
+    data: zod_1.z
+        .array(TreeNodeSchema)
+        .describe("Data for treemap chart which is a hierarchical structure, such as, [{ name: 'Design', value: 70, children: [{ name: 'Tech', value: 20 }] }], and the maximum depth is 3.")
+        .nonempty({ message: "Treemap chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+// Treemap chart tool descriptor
+const tool = {
+    name: "generate_treemap_chart",
+    description: "Generate a treemap chart to display hierarchical data and can intuitively show comparisons between items at the same level, such as, show disk space usage with treemap.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.treemap = {
+    schema,
+    tool,
+};

package/build/charts/venn.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export declare const venn: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            value: z.ZodNumber;
+            sets: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            sets: string[];
+            label?: string | undefined;
+        }, {
+            value: number;
+            sets: string[];
+            label?: string | undefined;
+        }>, "atleastone">;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+        }, {
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+            texture?: "default" | "rough" | undefined;
+        }>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "academy", "dark"]>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: import("zod-to-json-schema").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+            } | undefined;
+        };
+    };
+};

package/build/charts/venn.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.venn = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z.object({
+    label: zod_1.z
+        .string()
+        .optional()
+        .describe("Label for the venn chart segment, such as 'A', 'B', or 'C'."),
+    value: zod_1.z
+        .number()
+        .describe("Value for the venn chart segment, such as 10, 20, or 30."),
+    sets: zod_1.z
+        .array(zod_1.z.string())
+        .describe("Array of set names that this segment belongs to, such as ['A', 'B'] for an intersection between sets A and B."),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for venn chart, such as, [{ label: 'A', value: 10, sets: ['A'] }, { label: 'B', value: 20, sets: ['B'] }, { label: 'C', value: 30, sets: ['C'] }, { label: 'AB', value: 5, sets: ['A', 'B'] }].")
+        .nonempty({ message: "Venn chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+const tool = {
+    name: "generate_venn_chart",
+    description: "Generate a Venn diagram to visualize the relationships between different sets, showing how they intersect and overlap, such as the commonalities and differences between various groups.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.venn = {
+    schema,
+    tool,
+};

package/build/charts/violin.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const violin: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            value: z.ZodNumber;
+            group: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            category: string;
+            group?: string | undefined;
+        }, {
+            value: number;
+            category: string;
+            group?: string | undefined;
+        }>, "atleastone">;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+        }, {
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+            texture?: "default" | "rough" | undefined;
+        }>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "academy", "dark"]>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisXTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        axisYTitle: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: import("zod-to-json-schema").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+            } | undefined;
+        };
+    };
+};

package/build/charts/violin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.violin = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const data = zod_1.z.object({
+    category: zod_1.z
+        .string()
+        .describe("Category of the data point, such as '分类一'."),
+    value: zod_1.z.number().describe("Value of the data point, such as 10."),
+    group: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional group for the data point, used for grouping in the violin chart."),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for violin chart, such as, [{ category: '分类一', value: 10 }] or [{ category: '分类二', value: 20, group: '组别一' }].")
+        .nonempty({ message: "Violin chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+    axisXTitle: base_1.AxisXTitleSchema,
+    axisYTitle: base_1.AxisYTitleSchema,
+};
+const tool = {
+    name: "generate_violin_chart",
+    description: "Generate a violin chart to show data for statistical summaries among different categories, such as, comparing the distribution of data points across categories.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.violin = {
+    schema,
+    tool,
+};

package/build/charts/word-cloud.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const wordCloud: {
+    schema: {
+        data: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            value: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: number;
+            text: string;
+        }, {
+            value: number;
+            text: string;
+        }>, "atleastone">;
+        style: z.ZodOptional<z.ZodObject<{
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            palette: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+        }, {
+            backgroundColor?: string | undefined;
+            palette?: string[] | undefined;
+            texture?: "default" | "rough" | undefined;
+        }>>;
+        theme: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "academy", "dark"]>>>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    };
+    tool: {
+        name: string;
+        description: string;
+        inputSchema: import("zod-to-json-schema").JsonSchema7Type & {
+            $schema?: string | undefined;
+            definitions?: {
+                [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+            } | undefined;
+        };
+    };
+};

package/build/charts/word-cloud.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordCloud = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Word cloud data schema
+const data = zod_1.z.object({
+    text: zod_1.z.string(),
+    value: zod_1.z.number(),
+});
+// Word cloud input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for word cloud chart, it should be an array of objects, each object contains a `text` field and a `value` field, such as, [{ value: 4.272, text: '形成' }].")
+        .nonempty({ message: "Word cloud chart data cannot be empty." }),
+    style: zod_1.z
+        .object({
+        backgroundColor: base_1.BackgroundColorSchema,
+        palette: base_1.PaletteSchema,
+        texture: base_1.TextureSchema,
+    })
+        .optional()
+        .describe("Style configuration for the chart with a JSON object, optional."),
+    theme: base_1.ThemeSchema,
+    width: base_1.WidthSchema,
+    height: base_1.HeightSchema,
+    title: base_1.TitleSchema,
+};
+// Word cloud tool descriptor
+const tool = {
+    name: "generate_word_cloud_chart",
+    description: "Generate a word cloud chart to show word frequency or weight through text size variation, such as, analyzing common words in social media, reviews, or feedback.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.wordCloud = {
+    schema,
+    tool,
+};

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = require("node:util");
+const server_1 = require("./server.js");
+const logger_1 = require("./utils/logger.js");
+// Parse command line arguments
+const { values } = (0, node_util_1.parseArgs)({
+    options: {
+        transport: {
+            type: "string",
+            short: "t",
+            default: "stdio",
+        },
+        host: {
+            type: "string",
+            short: "h",
+            default: "localhost",
+        },
+        port: {
+            type: "string",
+            short: "p",
+            default: "1122",
+        },
+        endpoint: {
+            type: "string",
+            short: "e",
+            default: "", // We'll handle defaults per transport type
+        },
+        help: {
+            type: "boolean",
+            short: "H",
+        },
+    },
+});
+// Display help information if requested
+if (values.help) {
+    console.log(`
+MCP Server Chart CLI
+
+Options:
+  --transport, -t  Specify the transport protocol: "stdio", "sse", or "streamable" (default: "stdio")
+  --host, -h       Specify the host for SSE or streamable transport (default: localhost)
+  --port, -p       Specify the port for SSE or streamable transport (default: 1122)
+  --endpoint, -e   Specify the endpoint for the transport:
+                   - For SSE: default is "/sse"
+                   - For streamable: default is "/mcp"
+  --help, -H       Show this help message
+  `);
+    process.exit(0);
+}
+// Run in the specified transport mode
+const transport = values.transport.toLowerCase();
+if (transport === "sse") {
+    logger_1.logger.setIsStdio(false);
+    const port = Number.parseInt(values.port, 10);
+    // Use provided endpoint or default to "/sse" for SSE
+    const endpoint = values.endpoint || "/sse";
+    const host = values.host || "localhost";
+    (0, server_1.runSSEServer)(host, port, endpoint).catch(console.error);
+}
+else if (transport === "streamable") {
+    logger_1.logger.setIsStdio(false);
+    const port = Number.parseInt(values.port, 10);
+    // Use provided endpoint or default to "/mcp" for streamable
+    const endpoint = values.endpoint || "/mcp";
+    const host = values.host || "localhost";
+    (0, server_1.runHTTPStreamableServer)(host, port, endpoint).catch(console.error);
+}
+else {
+    logger_1.logger.setIsStdio(true);
+    (0, server_1.runStdioServer)().catch(console.error);
+}

package/build/sdk.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Exports the API for the `@antv/mcp-server-chart` package.
+ * This includes chart generation capabilities and utility functions.
+ */
+export * from "./charts";
+export { callTool } from "./utils";

package/build/sdk.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callTool = void 0;
+/**
+ * Exports the API for the `@antv/mcp-server-chart` package.
+ * This includes chart generation capabilities and utility functions.
+ */
+__exportStar(require("./charts/index.js"), exports);
+var utils_1 = require("./utils/index.js");
+Object.defineProperty(exports, "callTool", { enumerable: true, get: function () { return utils_1.callTool; } });

package/build/server.d.ts

@@ -0,0 +1,17 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Creates and configures an MCP server for chart generation.
+ */
+export declare function createServer(): Server;
+/**
+ * Runs the server with stdio transport.
+ */
+export declare function runStdioServer(): Promise<void>;
+/**
+ * Runs the server with SSE transport.
+ */
+export declare function runSSEServer(host?: string, port?: number, endpoint?: string): Promise<void>;
+/**
+ * Runs the server with HTTP streamable transport.
+ */
+export declare function runHTTPStreamableServer(host?: string, port?: number, endpoint?: string): Promise<void>;

package/build/server.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+exports.runStdioServer = runStdioServer;
+exports.runSSEServer = runSSEServer;
+exports.runHTTPStreamableServer = runHTTPStreamableServer;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const Charts = __importStar(require("./charts/index.js"));
+const services_1 = require("./services/index.js");
+const callTool_1 = require("./utils/callTool.js");
+const env_1 = require("./utils/env.js");
+const logger_1 = require("./utils/logger.js");
+/**
+ * Creates and configures an MCP server for chart generation.
+ */
+function createServer() {
+    const server = new index_js_1.Server({
+        name: "umeng-mcp-server-chart",
+        version: "0.0.1",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    setupToolHandlers(server);
+    server.onerror = (e) => {
+        logger_1.logger.error("Server encountered an error, shutting down", e);
+    };
+    process.on("SIGINT", () => __awaiter(this, void 0, void 0, function* () {
+        logger_1.logger.info("SIGINT received, shutting down server...");
+        yield server.close();
+        process.exit(0);
+    }));
+    return server;
+}
+/**
+ * Gets enabled tools based on environment variables.
+ */
+function getEnabledTools() {
+    const disabledTools = (0, env_1.getDisabledTools)();
+    const allCharts = Object.values(Charts);
+    if (disabledTools.length === 0) {
+        return allCharts;
+    }
+    return allCharts.filter((chart) => !disabledTools.includes(chart.tool.name));
+}
+/**
+ * Sets up tool handlers for the MCP server.
+ */
+function setupToolHandlers(server) {
+    logger_1.logger.info("setting up tool handlers...");
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, () => __awaiter(this, void 0, void 0, function* () {
+        return ({
+            tools: getEnabledTools().map((chart) => chart.tool),
+        });
+    }));
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, (request) => __awaiter(this, void 0, void 0, function* () {
+        logger_1.logger.info("calling tool", request.params.name, request.params.arguments);
+        return yield (0, callTool_1.callTool)(request.params.name, request.params.arguments);
+    }));
+    logger_1.logger.info("tool handlers set up");
+}
+/**
+ * Runs the server with stdio transport.
+ */
+function runStdioServer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const server = createServer();
+        yield (0, services_1.startStdioMcpServer)(server);
+    });
+}
+/**
+ * Runs the server with SSE transport.
+ */
+function runSSEServer() {
+    return __awaiter(this, arguments, void 0, function* (host = "localhost", port = 1122, endpoint = "/sse") {
+        const server = createServer();
+        yield (0, services_1.startSSEMcpServer)(server, endpoint, port, host);
+    });
+}
+/**
+ * Runs the server with HTTP streamable transport.
+ */
+function runHTTPStreamableServer() {
+    return __awaiter(this, arguments, void 0, function* (host = "localhost", port = 1122, endpoint = "/mcp") {
+        yield (0, services_1.startHTTPStreamableServer)(createServer, endpoint, port, host);
+    });
+}

package/build/services/index.d.ts

@@ -0,0 +1,3 @@
+export { startStdioMcpServer } from "./stdio";
+export { startSSEMcpServer } from "./sse";
+export { startHTTPStreamableServer } from "./streamable";