@umengfe/mcp-server-chart 0.0.1

package/build/charts/boxplot.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boxplot = 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 boxplot."),
+});
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for boxplot chart, such as, [{ category: '分类一', value: 10 }] or [{ category: '分类二', value: 20, group: '组别一' }].")
+        .nonempty({ message: "Boxplot 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_boxplot_chart",
+    description: "Generate a boxplot 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.boxplot = {
+    schema,
+    tool,
+};

package/build/charts/column.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const column: {
+    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">;
+        group: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        stack: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        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/column.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.column = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Column chart data schema
+const data = zod_1.z.object({
+    category: zod_1.z.string(),
+    value: zod_1.z.number(),
+    group: zod_1.z.string().optional(),
+});
+// Column chart input schema
+const schema = {
+    data: zod_1.z
+        .array(data)
+        .describe("Data for column chart, such as, [{ category: '分类一', value: 10 }, { category: '分类二', value: 20 }], when grouping or stacking is needed for column, the data should contain a `group` field, such as, when [{ category: '北京', value: 825, group: '油车' }, { category: '北京', value: 1000, group: '电车' }].")
+        .nonempty({ message: "Column chart data cannot be empty." }),
+    group: zod_1.z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Whether grouping is enabled. When enabled, column charts require a 'group' field in the data. When `group` is true, `stack` should be false."),
+    stack: zod_1.z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Whether stacking is enabled. When enabled, column charts require a 'group' field in the data. When `stack` is true, `group` should be false."),
+    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,
+};
+// Column chart tool descriptor
+const tool = {
+    name: "generate_column_chart",
+    description: "Generate a column chart, which are best for comparing categorical data, such as, when values are close, column charts are preferable because our eyes are better at judging height than other visual elements like area or angles.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.column = {
+    schema,
+    tool,
+};

package/build/charts/district-map.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export declare const districtMap: {
+    schema: {
+        title: z.ZodString;
+        data: z.ZodObject<{
+            name: z.ZodString;
+            style: z.ZodOptional<z.ZodObject<{
+                fillColor: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                fillColor?: string | undefined;
+            }, {
+                fillColor?: string | undefined;
+            }>>;
+            colors: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+            dataType: z.ZodOptional<z.ZodEnum<["number", "enum"]>>;
+            dataLabel: z.ZodOptional<z.ZodString>;
+            dataValue: z.ZodOptional<z.ZodString>;
+            dataValueUnit: z.ZodOptional<z.ZodString>;
+            showAllSubdistricts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            subdistricts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                dataValue: z.ZodOptional<z.ZodString>;
+                style: z.ZodOptional<z.ZodObject<{
+                    fillColor: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    fillColor?: string | undefined;
+                }, {
+                    fillColor?: string | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                style?: {
+                    fillColor?: string | undefined;
+                } | undefined;
+                dataValue?: string | undefined;
+            }, {
+                name: string;
+                style?: {
+                    fillColor?: string | undefined;
+                } | undefined;
+                dataValue?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            showAllSubdistricts: boolean;
+            style?: {
+                fillColor?: string | undefined;
+            } | undefined;
+            colors?: string[] | undefined;
+            dataType?: "number" | "enum" | undefined;
+            dataLabel?: string | undefined;
+            dataValue?: string | undefined;
+            dataValueUnit?: string | undefined;
+            subdistricts?: {
+                name: string;
+                style?: {
+                    fillColor?: string | undefined;
+                } | undefined;
+                dataValue?: string | undefined;
+            }[] | undefined;
+        }, {
+            name: string;
+            style?: {
+                fillColor?: string | undefined;
+            } | undefined;
+            colors?: string[] | undefined;
+            dataType?: "number" | "enum" | undefined;
+            dataLabel?: string | undefined;
+            dataValue?: string | undefined;
+            dataValueUnit?: string | undefined;
+            showAllSubdistricts?: boolean | undefined;
+            subdistricts?: {
+                name: string;
+                style?: {
+                    fillColor?: string | undefined;
+                } | undefined;
+                dataValue?: string | undefined;
+            }[] | undefined;
+        }>;
+        width: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        height: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    };
+    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/district-map.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.districtMap = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+const DistrictNameSchema = zod_1.z
+    .string()
+    .describe('Keywords for the Chinese name of an administrative region (must be within China), and must be one of China, province, city, district, or county. The name should be more specific and add attributive descriptions, for example, "西安市" is better than "西安", "杭州西湖区" is better than "西湖区". It cannot be a specific place name or a vague name, such as "其它".');
+const StyleSchema = zod_1.z
+    .object({
+    fillColor: zod_1.z
+        .string()
+        .optional()
+        .describe("Fill color, rgb or rgba format."),
+})
+    .optional()
+    .describe("Style settings.");
+const SubDistrictSchema = zod_1.z.object({
+    name: DistrictNameSchema,
+    dataValue: zod_1.z
+        .string()
+        .optional()
+        .describe("Data value, numeric string or enumeration string."),
+    style: StyleSchema,
+});
+const schema = {
+    title: base_1.MapTitleSchema,
+    data: zod_1.z
+        .object({
+        name: DistrictNameSchema,
+        style: StyleSchema,
+        colors: zod_1.z
+            .array(zod_1.z.string())
+            .default([
+            "#1783FF",
+            "#00C9C9",
+            "#F0884D",
+            "#D580FF",
+            "#7863FF",
+            "#60C42D",
+            "#BD8F24",
+            "#FF80CA",
+            "#2491B3",
+            "#17C76F",
+        ])
+            .optional()
+            .describe("Data color list, in rgb or rgba format."),
+        dataType: zod_1.z
+            .enum(["number", "enum"])
+            .optional()
+            .describe("The type of the data value, numeric or enumeration type"),
+        dataLabel: zod_1.z.string().optional().describe('Data label, such as "GDP"'),
+        dataValue: zod_1.z
+            .string()
+            .optional()
+            .describe("Data value, numeric string or enumeration string."),
+        dataValueUnit: zod_1.z
+            .string()
+            .optional()
+            .describe('Data unit, such as "万亿"'),
+        showAllSubdistricts: zod_1.z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Whether to display all subdistricts."),
+        subdistricts: zod_1.z
+            .array(SubDistrictSchema)
+            .optional()
+            .describe("Sub-administrative regions are used to display the regional composition or regional distribution of related data."),
+    })
+        .describe('Administrative division data, lower-level administrative divisions are optional. There are usually two scenarios: one is to simply display the regional composition, only `fillColor` needs to be configured, and all administrative divisions are consistent, representing that all blocks are connected as one; the other is the regional data distribution scenario, first determine the `dataType`, `dataValueUnit` and `dataLabel` configurations, `dataValue` should be a meaningful value and consistent with the meaning of dataType, and then determine the style configuration. The `fillColor` configuration represents the default fill color for areas without data. Lower-level administrative divisions do not need `fillColor` configuration, and their fill colors are determined by the `colors` configuration (If `dataType` is "number", only one base color (warm color) is needed in the list to calculate the continuous data mapping color band; if `dataType` is "enum", the number of color values in the list is equal to the number of enumeration values (contrast colors)). If `subdistricts` has a value, `showAllSubdistricts` must be set to true. For example, {"title": "陕西省地级市分布图", "data": {"name": "陕西省", "showAllSubdistricts": true, "dataLabel": "城市", "dataType": "enum", "colors": ["#4ECDC4", "#A5D8FF"], "subdistricts": [{"name": "西安市", "dataValue": "省会"}, {"name": "宝鸡市", "dataValue": "地级市"}, {"name": "咸阳市", "dataValue": "地级市"}, {"name": "铜川市", "dataValue": "地级市"}, {"name": "渭南市", "dataValue": "地级市"}, {"name": "延安市", "dataValue": "地级市"}, {"name": "榆林市", "dataValue": "地级市"}, {"name": "汉中市", "dataValue": "地级市"}, {"name": "安康市", "dataValue": "地级市"}, {"name": "商洛市", "dataValue": "地级市"}]}, "width": 1000, "height": 1000}.'),
+    width: base_1.MapWidthSchema,
+    height: base_1.MapHeightSchema,
+};
+// https://modelcontextprotocol.io/specification/2025-03-26/server/tools#listing-tools
+const tool = {
+    name: "generate_district_map",
+    description: "Generates regional distribution maps, which are usually used to show the administrative divisions and coverage of a dataset. It is not suitable for showing the distribution of specific locations, such as urban administrative divisions, GDP distribution maps of provinces and cities across the country, etc. This tool is limited to generating data maps within China.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.districtMap = {
+    schema,
+    tool,
+};

package/build/charts/dual-axes.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const dualAxes: {
+    schema: {
+        categories: z.ZodArray<z.ZodString, "atleastone">;
+        series: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["column", "line"]>;
+            data: z.ZodArray<z.ZodNumber, "many">;
+            axisYTitle: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "column" | "line";
+            data: number[];
+            axisYTitle?: string | undefined;
+        }, {
+            type: "column" | "line";
+            data: number[];
+            axisYTitle?: 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>>;
+    };
+    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/dual-axes.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dualAxes = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const base_1 = require("./base.js");
+// Dual axes series schema
+const DualAxesSeriesSchema = zod_1.z.object({
+    type: zod_1.z
+        .enum(["column", "line"])
+        .describe("The optional value can be 'column' or 'line'."),
+    data: zod_1.z
+        .array(zod_1.z.number())
+        .describe("When type is column, the data represents quantities, such as [91.9, 99.1, 101.6, 114.4, 121]. When type is line, the data represents ratios and its values are recommended to be less than 1, such as [0.055, 0.06, 0.062, 0.07, 0.075]."),
+    axisYTitle: zod_1.z
+        .string()
+        .default("")
+        .describe("Set the y-axis title of the chart series, such as, axisYTitle: '销售额'.")
+        .optional(),
+});
+// Dual axes chart input schema
+const schema = {
+    categories: zod_1.z
+        .array(zod_1.z.string())
+        .describe("Categories for dual axes chart, such as, ['2015', '2016', '2017'].")
+        .nonempty({ message: "Dual axes chart categories cannot be empty." }),
+    series: zod_1.z
+        .array(DualAxesSeriesSchema)
+        .describe("Series for dual axes chart, such as, [{ type: 'column', data: [91.9, 99.1, 101.6, 114.4, 121], axisYTitle: '销售额' }, { type: 'line', data: [0.055, 0.06, 0.062, 0.07, 0.075], 'axisYTitle': '利润率' }].")
+        .nonempty({ message: "Dual axes chart series 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,
+};
+// Dual axes chart tool descriptor
+const tool = {
+    name: "generate_dual_axes_chart",
+    description: "Generate a dual axes chart which is a combination chart that integrates two different chart types, typically combining a bar chart with a line chart to display both the trend and comparison of data, such as, the trend of sales and profit over time.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.dualAxes = {
+    schema,
+    tool,
+};

package/build/charts/fishbone-diagram.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { type TreeDataType } from "../utils/validator";
+export declare const FishboneNodeSchema: z.ZodType<TreeDataType>;
+export declare const fishboneDiagram: {
+    schema: {
+        data: z.ZodEffects<z.ZodType<TreeDataType, z.ZodTypeDef, TreeDataType>, TreeDataType, TreeDataType>;
+        style: z.ZodOptional<z.ZodObject<{
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+        }, {
+            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>>;
+    };
+    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/fishbone-diagram.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fishboneDiagram = exports.FishboneNodeSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const validator_1 = require("../utils/validator.js");
+const base_1 = require("./base.js");
+// Fishbone node schema
+// 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
+exports.FishboneNodeSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    children: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string(),
+        children: zod_1.z
+            .array(zod_1.z.object({
+            name: zod_1.z.string(),
+            children: zod_1.z
+                .array(zod_1.z.object({
+                name: zod_1.z.string(),
+            }))
+                .optional(),
+        }))
+            .optional(),
+    }))
+        .optional(),
+});
+// Fishbone diagram input schema
+const schema = {
+    data: exports.FishboneNodeSchema.describe("Data for fishbone diagram chart which is a hierarchical structure, such as, { name: 'main topic', children: [{ name: 'topic 1', children: [{ name: 'subtopic 1-1' }] }] }, and the maximum depth is 3.").refine(validator_1.validatedTreeDataSchema, {
+        message: "Invalid parameters: node name is not unique.",
+        path: ["data"],
+    }),
+    style: zod_1.z
+        .object({
+        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,
+};
+// Fishbone diagram tool descriptor
+const tool = {
+    name: "generate_fishbone_diagram",
+    description: "Generate a fishbone diagram chart to uses a fish skeleton, like structure to display the causes or effects of a core problem, with the problem as the fish head and the causes/effects as the fish bones. It suits problems that can be split into multiple related factors.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.fishboneDiagram = {
+    schema,
+    tool,
+};

package/build/charts/flow-diagram.d.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export declare const flowDiagram: {
+    schema: {
+        data: z.ZodEffects<z.ZodObject<{
+            nodes: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>, "atleastone">;
+            edges: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                name: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                target: string;
+                source: string;
+            }, {
+                target: string;
+                source: string;
+                name?: string | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            nodes: [{
+                name: string;
+            }, ...{
+                name: string;
+            }[]];
+            edges: {
+                name: string;
+                target: string;
+                source: string;
+            }[];
+        }, {
+            nodes: [{
+                name: string;
+            }, ...{
+                name: string;
+            }[]];
+            edges: {
+                target: string;
+                source: string;
+                name?: string | undefined;
+            }[];
+        }>, {
+            nodes: [{
+                name: string;
+            }, ...{
+                name: string;
+            }[]];
+            edges: {
+                name: string;
+                target: string;
+                source: string;
+            }[];
+        }, {
+            nodes: [{
+                name: string;
+            }, ...{
+                name: string;
+            }[]];
+            edges: {
+                target: string;
+                source: string;
+                name?: string | undefined;
+            }[];
+        }>;
+        style: z.ZodOptional<z.ZodObject<{
+            texture: z.ZodDefault<z.ZodOptional<z.ZodEnum<["default", "rough"]>>>;
+        }, "strip", z.ZodTypeAny, {
+            texture: "default" | "rough";
+        }, {
+            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>>;
+    };
+    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/flow-diagram.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowDiagram = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils/index.js");
+const validator_1 = require("../utils/validator.js");
+const base_1 = require("./base.js");
+// Flow diagram input schema
+const schema = {
+    data: zod_1.z
+        .object({
+        nodes: zod_1.z
+            .array(base_1.NodeSchema)
+            .nonempty({ message: "At least one node is required." }),
+        edges: zod_1.z.array(base_1.EdgeSchema),
+    })
+        .describe("Data for flow diagram chart, such as, { nodes: [{ name: 'node1' }, { name: 'node2' }], edges: [{ source: 'node1', target: 'node2', name: 'edge1' }] }.")
+        .refine(validator_1.validatedNodeEdgeDataSchema, {
+        message: "Invalid parameters",
+        path: ["data", "edges"],
+    }),
+    style: zod_1.z
+        .object({
+        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,
+};
+// Flow diagram tool descriptor
+const tool = {
+    name: "generate_flow_diagram",
+    description: "Generate a flow diagram chart to show the steps and decision points of a process or system, such as, scenarios requiring linear process presentation.",
+    inputSchema: (0, utils_1.zodToJsonSchema)(schema),
+};
+exports.flowDiagram = {
+    schema,
+    tool,
+};