@standby/mcp-server-chart 0.9.10

package/build/charts/word-cloud.js

@@ -0,0 +1,44 @@
+"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),
+    annotations: {
+        title: "Generate Word Cloud Chart",
+        readOnlyHint: true,
+    },
+};
+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 `@standby/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 `@standby/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,151 @@
+"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 image_server_1 = require("./utils/image-server.js");
+const local_render_1 = require("./utils/local-render.js");
+const logger_1 = require("./utils/logger.js");
+/**
+ * Initialize local rendering.
+ * Starts the image server and waits for it to be ready.
+ */
+function initLocalRendering() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const customDir = (0, env_1.getChartImageDir)();
+        if (customDir) {
+            (0, local_render_1.setOutputDir)(customDir);
+        }
+        const port = (0, env_1.getImageServerPort)();
+        yield (0, image_server_1.startImageServer)("localhost", port);
+        logger_1.logger.info(`Local rendering mode enabled (image server port: ${port})`);
+    });
+}
+/**
+ * Creates and configures an MCP server for chart generation.
+ */
+function createServer() {
+    const server = new index_js_1.Server({
+        name: "mcp-server-chart",
+        version: "0.8.x",
+    }, {
+        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* () {
+        yield initLocalRendering();
+        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") {
+        yield initLocalRendering();
+        yield (0, services_1.startSSEMcpServer)(createServer, 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 initLocalRendering();
+        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";

package/build/services/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHTTPStreamableServer = exports.startSSEMcpServer = exports.startStdioMcpServer = void 0;
+var stdio_1 = require("./stdio.js");
+Object.defineProperty(exports, "startStdioMcpServer", { enumerable: true, get: function () { return stdio_1.startStdioMcpServer; } });
+var sse_1 = require("./sse.js");
+Object.defineProperty(exports, "startSSEMcpServer", { enumerable: true, get: function () { return sse_1.startSSEMcpServer; } });
+var streamable_1 = require("./streamable.js");
+Object.defineProperty(exports, "startHTTPStreamableServer", { enumerable: true, get: function () { return streamable_1.startHTTPStreamableServer; } });

package/build/services/sse.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare const startSSEMcpServer: (createServer: () => Server, endpoint?: string, port?: number, host?: string) => Promise<void>;

package/build/services/sse.js

@@ -0,0 +1,59 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSSEMcpServer = void 0;
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const express_1 = __importDefault(require("express"));
+const logger_1 = require("../utils/logger.js");
+const startSSEMcpServer = (createServer_1, ...args_1) => __awaiter(void 0, [createServer_1, ...args_1], void 0, function* (createServer, endpoint = "/sse", port = 1122, host = "localhost") {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    const connections = {};
+    app.get(endpoint, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const server = createServer();
+        const transport = new sse_js_1.SSEServerTransport("/messages", res);
+        connections[transport.sessionId] = transport;
+        transport.onclose = () => {
+            delete connections[transport.sessionId];
+            logger_1.logger.info(`SSE Server disconnected: sessionId=${transport.sessionId}`);
+        };
+        yield server.connect(transport);
+        logger_1.logger.info(`SSE Server connected: sessionId=${transport.sessionId}`);
+    }));
+    app.post("/messages", (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const sessionId = req.query.sessionId;
+        if (!sessionId) {
+            logger_1.logger.warn("SSE Server sessionId parameter is missing");
+            return res.status(400).send("Missing sessionId parameter");
+        }
+        const transport = connections[sessionId];
+        if (!transport) {
+            logger_1.logger.warn(`SSE Server session not found: sessionId=${sessionId}`);
+            return res.status(404).send("Session not found");
+        }
+        try {
+            logger_1.logger.info(`SSE Server handling message: sessionId=${sessionId}`);
+            yield transport.handlePostMessage(req, res, req.body);
+        }
+        catch (e) {
+            logger_1.logger.error("SSE Server error handling message", e);
+            if (!res.headersSent)
+                res.status(500).send("Error handling request");
+        }
+    }));
+    app.listen(port, host, () => {
+        logger_1.logger.success(`SSE Server listening on http://${host}:${port}${endpoint}`);
+    });
+});
+exports.startSSEMcpServer = startSSEMcpServer;

package/build/services/stdio.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function startStdioMcpServer(server: Server): Promise<void>;

package/build/services/stdio.js

@@ -0,0 +1,21 @@
+"use strict";
+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.startStdioMcpServer = startStdioMcpServer;
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_1 = require("../utils/logger.js");
+function startStdioMcpServer(server) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const transport = new stdio_js_1.StdioServerTransport();
+        yield server.connect(transport);
+        logger_1.logger.success("Stdio MCP Server started");
+    });
+}

package/build/services/streamable.d.ts

@@ -0,0 +1,2 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare const startHTTPStreamableServer: (createServer: () => Server, endpoint?: string, port?: number, host?: string) => Promise<void>;

package/build/services/streamable.js

@@ -0,0 +1,58 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHTTPStreamableServer = void 0;
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const logger_1 = require("../utils/logger.js");
+const startHTTPStreamableServer = (createServer_1, ...args_1) => __awaiter(void 0, [createServer_1, ...args_1], void 0, function* (createServer, endpoint = "/mcp", port = 1122, host = "localhost") {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    app.use((0, cors_1.default)({ origin: "*", exposedHeaders: ["Mcp-Session-Id"] }));
+    app.post(endpoint, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        // In stateless mode, create a new transport for each request to prevent
+        // request ID collisions. Different clients may use the same JSON-RPC request IDs,
+        // which would cause responses to be routed to the wrong HTTP connections if
+        // the transport state is shared.
+        try {
+            const server = createServer();
+            const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true,
+            });
+            res.on("close", () => {
+                transport.close();
+                logger_1.logger.info("HTTP Streamable Server response closed");
+            });
+            yield server.connect(transport);
+            yield transport.handleRequest(req, res, req.body);
+            logger_1.logger.info("HTTP Streamable Server response connected");
+        }
+        catch (e) {
+            logger_1.logger.error("HTTP Streamable Server response error", e);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null,
+                });
+            }
+        }
+    }));
+    app.listen(port, host, () => {
+        logger_1.logger.success(`Streamable HTTP Server listening on http://${host}:${port}${endpoint}`);
+    });
+});
+exports.startHTTPStreamableServer = startHTTPStreamableServer;

package/build/utils/callTool.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Call a tool to generate a chart based on the provided name and arguments.
+ * @param tool The name of the tool to call, e.g., "generate_area_chart".
+ * @param args The arguments for the tool, which should match the expected schema for the chart type.
+ * @returns
+ */
+export declare function callTool(tool: string, args?: object): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    _meta: {
+        description: string;
+        spec: {
+            type: "line" | "area" | "sankey" | "treemap" | "bar" | "column" | "scatter" | "pie" | "funnel" | "radar" | "histogram" | "boxplot" | "violin" | "waterfall" | "liquid" | "word-cloud" | "venn" | "dual-axes" | "network-graph" | "mind-map" | "organization-chart" | "flow-diagram" | "fishbone-diagram";
+        };
+    };
+}>;

package/build/utils/callTool.js

@@ -0,0 +1,129 @@
+"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.callTool = callTool;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_1 = require("zod");
+const Charts = __importStar(require("../charts/index.js"));
+const generate_1 = require("./generate.js");
+const logger_1 = require("./logger.js");
+const validator_1 = require("./validator.js");
+// Chart type mapping
+const CHART_TYPE_MAP = {
+    generate_area_chart: "area",
+    generate_bar_chart: "bar",
+    generate_boxplot_chart: "boxplot",
+    generate_column_chart: "column",
+    generate_dual_axes_chart: "dual-axes",
+    generate_fishbone_diagram: "fishbone-diagram",
+    generate_flow_diagram: "flow-diagram",
+    generate_funnel_chart: "funnel",
+    generate_histogram_chart: "histogram",
+    generate_line_chart: "line",
+    generate_liquid_chart: "liquid",
+    generate_mind_map: "mind-map",
+    generate_network_graph: "network-graph",
+    generate_organization_chart: "organization-chart",
+    generate_pie_chart: "pie",
+    generate_radar_chart: "radar",
+    generate_sankey_chart: "sankey",
+    generate_scatter_chart: "scatter",
+    generate_treemap_chart: "treemap",
+    generate_venn_chart: "venn",
+    generate_violin_chart: "violin",
+    generate_waterfall_chart: "waterfall",
+    generate_word_cloud_chart: "word-cloud",
+};
+/**
+ * Call a tool to generate a chart based on the provided name and arguments.
+ * @param tool The name of the tool to call, e.g., "generate_area_chart".
+ * @param args The arguments for the tool, which should match the expected schema for the chart type.
+ * @returns
+ */
+function callTool(tool_1) {
+    return __awaiter(this, arguments, void 0, function* (tool, args = {}) {
+        logger_1.logger.info(`Calling tool: ${tool}`);
+        const chartType = CHART_TYPE_MAP[tool];
+        if (!chartType) {
+            logger_1.logger.error(`Unknown tool: ${tool}`);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${tool}.`);
+        }
+        try {
+            // Validate input using Zod before sending to API.
+            // Select the appropriate schema based on the chart type.
+            const schema = Charts[chartType].schema;
+            if (schema) {
+                // Use safeParse instead of parse and try-catch.
+                const result = zod_1.z.object(schema).safeParse(args);
+                if (!result.success) {
+                    logger_1.logger.error(`Invalid parameters: ${result.error.message}`);
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Invalid parameters: ${result.error.message}`);
+                }
+            }
+            const url = yield (0, generate_1.generateChartUrl)(chartType, args);
+            logger_1.logger.info(`Generated chart URL: ${url}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: url,
+                    },
+                ],
+                _meta: {
+                    description: "This is the chart's spec and configuration, which can be renderred to corresponding chart by AntV GPT-Vis chart components.",
+                    spec: Object.assign({ type: chartType }, args),
+                },
+            };
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to generate chart: ${error.message || "Unknown error"}.`);
+            if (error instanceof types_js_1.McpError)
+                throw error;
+            if (error instanceof validator_1.ValidateError)
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, error.message);
+            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to generate chart: ${(error === null || error === void 0 ? void 0 : error.message) || "Unknown error."}`);
+        }
+    });
+}

package/build/utils/env.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get the list of disabled tools from environment variables.
+ */
+export declare function getDisabledTools(): string[];
+/**
+ * Get the custom output directory for chart images, if set.
+ */
+export declare function getChartImageDir(): string | undefined;
+/**
+ * Get the port for the local image server.
+ */
+export declare function getImageServerPort(): number;