freeform-modeling-mcp 1.0.26

package/src/tools/modeling/find-face.ts

@@ -0,0 +1,38 @@
+import { Context } from "../../types";
+import { z } from "zod";
+import logger from "../../lib/logger";
+import { llmClient } from "../../llmClient";
+
+export const findFaceByMultiplePointsTool = {
+    name: "find_face_by_points",
+    description:
+        "Finds a face by specifying multiple points that lie on the face. By providing 1-5 points that lie on the target face, you can identify faces reliably even when topology changes occur.  Returns the face's information including its ID, normal vector, area, and other properties.",
+    parameters: z.object({
+        points: z.array(
+            z.object({
+                x: z.number().describe("X coordinate of a point on the face"),
+                y: z.number().describe("Y coordinate of a point on the face"),
+                z: z.number().describe("Z coordinate of a point on the face"),
+            })
+        ).min(1).max(5)
+            .describe("Array of points that lie on the face you want to find. More points increase finding accuracy."),
+        tolerance: z.number().positive().optional().default(0.001)
+            .describe("Maximum distance between points and face for matching to occur (default: 0.001 model units)")
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to find face by points`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+            const result = await llmClient.sendCommand("find_face_by_points", args);
+            return result;
+        } catch (e) {
+            const errorMessage = `Error during face finding by points: ${e instanceof Error ? e.message : String(e)
+                }`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    },
+};

package/src/tools/modeling/sweep-tool.ts

@@ -0,0 +1,60 @@
+import { Context } from "../../types";
+import { z } from "zod";
+import logger from "../../lib/logger";
+import { llmClient } from "../../llmClient";
+
+// Tool: Sweep Face Along Auxiliary Curves
+export const sweepTool = {
+    name: 'sweep',
+    description: 'Creates a 3D solid by sweeping a FACE along auxiliary curves. NOTE: This tool operates ONLY on faces, not on entire objects or groups. The face can be either selected by the user or created programmatically. IMPORTANT: The face being swept (profile) must NOT be parallel to the auxiliary curves (path) - the sweep direction must have some component perpendicular to the face normal for the operation to succeed. After the sweep operation completes, the original face (profile) will be automatically deleted from the model. If you need to perform multiple sweep operations with the same profile, you will need to recreate the face after each sweep operation using add_faces or other face creation methods.',
+    parameters: z.object({
+        face_id: z.string()
+            .describe('ID of the face to sweep. You can obtain this ID by: 1) Using get_selection with type="face" to get a user-selected face, 2) Creating a new face with add_faces and using the returned face ID, or 3) Using find_face_by_points tool to locate a face when model geometry has been modified or split. IMPORTANT: The face being swept (profile) must NOT be parallel to the auxiliary curves (path) - there must be some angle between the face normal and the path direction, otherwise the sweep operation will fail.'),
+        auxiliary_curve_ids: z.array(z.string())
+            .describe('IDs of auxiliary curves to use as the sweep path. Obtain these either from user-selected curves (get_selection) or by creating new curves (create_auxiliary_curve). IMPORTANT: The curves must connect end-to-end in a continuous path (each curve must start where the previous one ends), though they do not need to form a closed loop. Disconnected curves will cause the sweep operation to fail.'),
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: sweep with face_id "${args.face_id}" and auxiliary curve IDs ${JSON.stringify(args.auxiliary_curve_ids)}`);
+        try {
+            // Check if any modeling software clients are connected
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            // Validate parameters
+            if (!args.face_id) {
+                return `Error: You must provide a face_id to sweep. You can:
+
+1. Ask the user to select a face in the scene, then use get_selection tool with type="face" to obtain the ID of the selected face, OR
+2. Create a new face using the add_faces tool and use the returned face ID.`;
+            }
+
+            if (!args.auxiliary_curve_ids || args.auxiliary_curve_ids.length === 0) {
+                return `Error: You must provide at least one auxiliary curve ID for the sweep path. Follow these steps:
+
+1. First use get_selection to check if the user has already selected any auxiliary curves.
+2. If no auxiliary curves are selected, create them using the create_auxiliary_curve tool with a 3D path.
+3. Once you have the auxiliary curve IDs (either from get_selection or create_auxiliary_curve), use them in this tool.
+
+Example workflow:
+- Get face ID: either get_selection with type="face" or create with add_faces
+- Get curve IDs: either get_selection or create_auxiliary_curve
+- Sweep: use this tool with the obtained face_id and auxiliary_curve_ids`;
+            }
+
+            // Send the sweep command
+            const result = await llmClient.sendCommand('sweep', args);
+
+            // Return success message with information from the result
+            return `${result}
+The sweep operation used face ${args.face_id} and swept it along the path defined by auxiliary curve(s): ${args.auxiliary_curve_ids.join(', ')}.
+`;
+            // Note: To see the result, use the get_scene_screenshot tool to capture an image of the scene.
+        } catch (e) {
+            const errorMessage = `Error creating swept object: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};

package/src/tools/modeling/utils.ts

@@ -0,0 +1,181 @@
+
+export function parseSvgPath3D(pathString: string) {
+    // 移除多余空格并标准化
+    const normalizedPath = pathString.trim().replace(/\s+/g, ' ');
+    // 用于存储解析后的路径段
+    const pathSegments = [];
+    // 当前点的位置
+    let currentX = 0, currentY = 0, currentZ = 0;
+    // 记录路径起始点，用于闭合路径
+    let startX = 0, startY = 0, startZ = 0;
+    // 辅助函数：解析坐标字符串为数字数组
+    const parseCoords = (coordStr: string): number[] => {
+        // Replace commas with spaces, then split by spaces and filter out empty strings
+        return coordStr.replace(/,/g, ' ')
+            .split(/\s+/)
+            .filter(s => s.length > 0)
+            .map(coord => parseFloat(coord.trim()));
+    };
+
+    // 将路径字符串分解为命令和参数 - 只关注M, L, C, A, Z命令
+    const tokens = normalizedPath.match(/([MLCAZmlcaz])\s*([^MLCAZmlcaz]*)/g) || [];
+
+    for (const token of tokens) {
+        const command = token[0].toUpperCase();
+        const paramsStr = token.substring(1).trim();
+
+        switch (command) {
+            case 'M': // 移动到
+                {
+                    const coords = parseCoords(paramsStr);
+                    if (coords.length !== 3) {
+                        throw new Error(`Invalid M command. Expected 3 coordinates, got ${coords.length}.`);
+                    }
+                    currentX = coords[0];
+                    currentY = coords[1];
+                    currentZ = coords[2];
+                    // 记录起始点，用于Z命令
+                    startX = currentX;
+                    startY = currentY;
+                    startZ = currentZ;
+                }
+                break;
+
+            case 'L': // 线段
+                {
+                    const coords = parseCoords(paramsStr);
+                    if (coords.length !== 3) {
+                        throw new Error(`Invalid L command. Expected 3 coordinates, got ${coords.length}.`);
+                    }
+                    // 创建线段
+                    pathSegments.push({
+                        type: 'line',
+                        startPoint: [currentX, currentY, currentZ],
+                        endPoint: [coords[0], coords[1], coords[2]]
+                    });
+                    // 更新当前点
+                    currentX = coords[0];
+                    currentY = coords[1];
+                    currentZ = coords[2];
+                }
+                break;
+
+            case 'C': // 三次贝塞尔曲线
+                {
+                    const coords = parseCoords(paramsStr);
+                    if (coords.length !== 9) {
+                        throw new Error(`Invalid C command. Expected 9 coordinates (3 points), got ${coords.length}.`);
+                    }
+
+                    // 创建3D贝塞尔曲线
+                    pathSegments.push({
+                        type: 'bezier',
+                        startPoint: [currentX, currentY, currentZ],
+                        controlPoint1: [coords[0], coords[1], coords[2]],
+                        controlPoint2: [coords[3], coords[4], coords[5]],
+                        endPoint: [coords[6], coords[7], coords[8]]
+                    });
+
+                    // 更新当前点为终点
+                    currentX = coords[6];
+                    currentY = coords[7];
+                    currentZ = coords[8];
+                }
+                break;
+
+            case 'A': // 通过三点定义的圆弧
+                {
+                    // A midX,midY,midZ endX,endY,endZ
+                    const coords = parseCoords(paramsStr);
+                    if (coords.length !== 6) {
+                        throw new Error(`Invalid A command. Expected 6 coordinates, got ${coords.length}.`);
+                    }
+                    const midX = coords[0];
+                    const midY = coords[1];
+                    const midZ = coords[2];
+                    const endX = coords[3];
+                    const endY = coords[4];
+                    const endZ = coords[5];
+                    // 起点(当前位置)
+                    const startPoint = [currentX, currentY, currentZ];
+                    // 弧上的中间点
+                    const midPoint = [midX, midY, midZ];
+                    // 终点
+                    const endPoint = [endX, endY, endZ];
+                    // 检查三点是否共线
+                    const isCollinear = checkCollinear(startPoint, midPoint, endPoint);
+                    if (isCollinear) {
+                        // 如果共线，改为创建线段
+                        pathSegments.push({
+                            type: 'line',
+                            startPoint: startPoint,
+                            endPoint: endPoint
+                        });
+                    } else {
+                        // 创建圆弧
+                        pathSegments.push({
+                            type: 'arc',
+                            startPoint: startPoint,
+                            centerPoint: midPoint, // 这是弧上的中点
+                            endPoint: endPoint
+                        });
+                    }
+                    // 更新当前点
+                    currentX = endX;
+                    currentY = endY;
+                    currentZ = endZ;
+                }
+                break;
+
+            case 'Z': // 闭合路径
+                // 添加一个线段闭合路径
+                if (
+                    Math.abs(currentX - startX) > 0.0001 ||
+                    Math.abs(currentY - startY) > 0.0001 ||
+                    Math.abs(currentZ - startZ) > 0.0001
+                ) {
+                    pathSegments.push({
+                        type: 'line',
+                        startPoint: [currentX, currentY, currentZ],
+                        endPoint: [startX, startY, startZ]
+                    });
+                }
+                // 更新当前点为起始点
+                currentX = startX;
+                currentY = startY;
+                currentZ = startZ;
+                break;
+
+            default:
+                throw new Error(`Unsupported path command: ${command}. Only M, L, C, A, and Z commands are supported.`);
+        }
+    }
+
+    return pathSegments;
+}
+
+// 检查三点是否共线
+function checkCollinear(p1, p2, p3, tolerance = 0.0001) {
+    // 计算向量p1->p2和p1->p3
+    const v1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+    const v2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
+
+    // 计算向量的叉积
+    const cross = [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0]
+    ];
+
+    // 计算叉积的大小
+    const crossLength = Math.sqrt(cross[0] * cross[0] + cross[1] * cross[1] + cross[2] * cross[2]);
+
+    // 计算向量v1和v2的长度
+    const v1Length = Math.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]);
+    const v2Length = Math.sqrt(v2[0] * v2[0] + v2[1] * v2[1] + v2[2] * v2[2]);
+
+    // 计算sin值，如果接近0则三点共线
+    const sinValue = crossLength / (v1Length * v2Length);
+
+    return sinValue < tolerance;
+}

package/src/tools/modeling-tools.ts

@@ -0,0 +1,135 @@
+import { Context } from "../types";
+import { z } from "zod";
+import logger from "../lib/logger";
+import { llmClient } from "../llmClient";
+import { parseSvgPath3D } from "./modeling/utils";
+import { UserError } from "fastmcp";
+
+export const addFacesTool = {
+  name: "add_faces",
+  description:
+    "Creates new faces in the 3D model using SVG-style path notation. Each face must form a closed planar boundary - all points defining a single face MUST be coplanar (lie exactly on the same plane). IMPORTANT: When a new face intersects or overlaps with existing faces, Koomaster will automatically split those faces, which may cause the original face IDs to change or become invalid. After adding faces that might cause splits, use the 'find_face_by_points' tool to locate the resulting faces by specifying points that lie on them. ",
+  parameters: z.object({
+    faces: z
+      .array(
+        z.object({
+          path: z
+            .string()
+            .describe('3D curve path defined using SVG path commands:\n- M x,y,z: Move to initial point\n- L x,y,z: Line to point\n- C cp1x,cp1y,cp1z cp2x,cp2y,cp2z endX,endY,endZ: Cubic Bezier curve with two control points\n- A midX,midY,midZ endX,endY,endZ: Arc defined by three points\n  - Current position is the start point\n  - midX,midY,midZ: A point ON THE ARC between start and end (NOT the center)\n  - endX,endY,endZ: End point of the arc\n- Z: Close path\n\nIMPORTANT NOTES:\n1. The path MUST form a closed shape (use Z command at the end)\n2. All points MUST be coplanar (on the same plane)\n3. The arc command uses a custom 3-point format (not standard SVG arc)\n4. For arcs, the three points must not be collinear\n5. For a circle, use 3-4 arcs connecting points along the circumference\n\nEXAMPLES:\n- Square: "M 0,0,0 L 100,0,0 L 100,100,0 L 0,100,0 Z"\n- Rectangle with rounded corner: "M 0,0,0 L 100,0,0 L 100,80,0 A 90,90,0 80,100,0 L 0,100,0 Z"\n- Circle approximation: "M 100,0,0 A 70.7,70.7,0 0,100,0 A -70.7,70.7,0 -100,0,0 A -70.7,-70.7,0 0,-100,0 A 70.7,-70.7,0 100,0,0 Z"\n- Curved path: "M 0,0,0 C 30,10,0 60,30,0 100,0,0 L 100,100,0 L 0,100,0 Z"'),
+        })
+      )
+      .min(1)
+      .describe(
+        "An array of face definitions, each with an SVG-style path string that defines a closed, planar boundary. Multiple faces can be created in a single operation. Each created face will receive a unique ID that can be used in other operations."
+      ),
+  }),
+  execute: async (args, context: Context): Promise<string> => {
+    if (!llmClient.hasConnectedKoomasterClients()) {
+      logger.warn("No clients connected when attempting to add faces");
+      return "No modeling software clients connected. Please start the software and connect to this server.";
+    }
+
+    try {
+      const processedArgs = {
+        faces: args.faces.map(face => {
+          try {
+            // 解析SVG路径字符串
+            const pathCurves = parseSvgPath3D(face.path);
+            return {
+              // faceName: face.faceName,
+              path: pathCurves
+            };
+          } catch (parseError) {
+            throw new Error(`Error parsing SVG path for face "${face.path}": ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+          }
+        })
+      };
+
+      const result = await llmClient.sendCommand("add_faces", processedArgs);
+
+      return result;
+    } catch (e) {
+      const errorMessage = `Error adding faces: ${e instanceof Error ? e.message : String(e)}`;
+      logger.error(errorMessage);
+      context.log.error(errorMessage);
+      return `Failed to create faces: ${e instanceof Error ? e.message : String(e)}. Common issues include:
+- Non-coplanar points: All points defining a face MUST lie exactly on the same plane
+- Path does not form a closed loop (ensure it ends with Z command)
+- Invalid arc definition (check A command parameters)
+- Self-intersecting boundaries
+- Invalid SVG path syntax
+- Missing or incorrect coordinates`;
+    }
+  },
+};
+export const getFacePathTool = {
+  name: "get_face_path",
+  description:
+    "Retrieves the SVG-style path representation of a face's boundary. This tool extracts the geometric outline of a face and returns it as a path string that can be used for visualization or further operations. The path includes all curves that form the outer boundary of the face.",
+  parameters: z.object({
+    name: z
+      .string()
+      .describe(
+        'ID of the face to extract the path from. You can obtain this ID by: 1) Using get_selection with type="face" to get a user-selected face, 2) Creating a new face with add_faces and using the returned face ID, or 3) Using find_face_by_points tool to locate a face when model geometry has been modified or split.'
+      ),
+  }),
+  execute: async (args, context: Context): Promise<string> => {
+    try {
+      if (!llmClient.hasConnectedKoomasterClients()) {
+        logger.warn(`No clients connected when attempting to get face path`);
+        throw new UserError("No modeling software clients connected. Please start the software and connect to this server.");
+      }
+
+      const result = await llmClient.sendCommand("get_face_path", args);
+      return result;
+    } catch (e) {
+      const errorMessage = `Error retrieving face path: ${e instanceof Error ? e.message : String(e)
+        }`;
+      logger.error(errorMessage);
+      context.log.error(errorMessage);
+      return errorMessage;
+    }
+  },
+};
+
+export const pullFacesTool = {
+  name: "pull_faces",
+  description:
+    "Performs a push/pull operation on one or more faces to create or modify 3D shapes. This tool allows you to extrude faces along their normal direction to add or remove volume from a model.",
+  parameters: z.object({
+    faceNames: z
+      .array(z.string())
+      .min(1)
+      .describe(
+        'Array of face names to push/pull. These should be the face identifiers that you want to extrude. You can get face names from previously created faces, by using tools that provide model information, or specifically by using the "find_face_by_points" tool to locate faces when model geometry has been modified or split.'
+      ),
+    distance: z
+      .number()
+      .describe(
+        "The distance to push/pull the face(s), measured in model units. Use positive values to extrude outward (adding volume) or negative values to extrude inward (removing volume if possible)."
+      ),
+    separator: z
+      .boolean()
+      .describe(
+        "Whether to keep the original face(s) unchanged. If true, a new face will be created at the end of the extrusion while preserving the original face. If false, the original face will be moved to the new position."
+      ),
+  }),
+  execute: async (args, context: Context): Promise<string> => {
+    try {
+      if (!llmClient.hasConnectedKoomasterClients()) {
+        logger.warn(`No clients connected when attempting to pull faces`);
+        return "No modeling software clients connected. Please start the software and connect to this server.";
+      }
+
+      const result = await llmClient.sendCommand("pull_faces", args);
+
+      return result;
+    } catch (e) {
+      const errorMessage = `Error during push/pull operation: ${e instanceof Error ? e.message : String(e)
+        }`;
+      logger.error(errorMessage);
+      context.log.error(errorMessage);
+      return errorMessage;
+    }
+  },
+};

package/src/tools/screenshot-tools.ts

@@ -0,0 +1,107 @@
+import { Context } from "../types";
+import { z } from "zod";
+import logger from "../lib/logger";
+import { llmClient } from "../llmClient";
+
+export const getObjectsScreenshotTool = {
+    name: 'get_objects_screenshot',
+    description: 'Captures a screenshot of the specific objects from different view angles. Note: Only supports KJL models, Tripo3D models, and basic geometric shapes - face screenshots are not supported.',
+    parameters: z.object({
+        view_angle: z.enum(['front', 'back', 'left', 'right', 'top', 'bottom']).default('top')
+            .describe('Camera angle for the screenshot. Options: standard orthographic views (front, back, left, right, top, bottom) .'),
+        groupNames: z.array(z.string())
+            .describe('array of group names to capture.')
+    }),
+    execute: async (args, context: Context): Promise<any> => {
+        logger.info(`Tool executed: get_scene_screenshot with view_angle "${args.view_angle}"`);
+        try {
+            // Check if any modeling software clients are connected
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            // Capture the screenshot using getModelSnapshot
+            const result = await llmClient.sendCommand('get_objects_screenshot', args);
+
+            if (!result) {
+                return "Failed to capture screenshot.";
+            }
+
+            if (!result.startsWith("data:")) {
+                return result;
+            }
+
+            let base64Data = result;
+            // Extract base64 data if it includes data URL format (data:image/png;base64,)
+            if (base64Data.includes(',')) {
+                base64Data = base64Data.split(',')[1];
+            }
+
+            return {
+                content: [
+                    {
+                        type: "image",
+                        data: base64Data,
+                        mimeType: "image/png",
+                    },
+                ],
+            };
+        } catch (e) {
+            const errorMessage = `Error capturing screenshot: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};
+
+export const getSceneScreenshotTool = {
+    name: 'get_scene_screenshot',
+    description: 'Captures a screenshot of the entire 3D scene from the specified view angle. Note: the screenshot result may appear upside-down compared to the actual scene orientation.',
+    parameters: z.object({
+        view_angle: z.enum(['front', 'back', 'left', 'right', 'top', 'bottom', 'auto']).default('auto')
+            .describe('Camera angle for the screenshot. Standard orthographic views available, or select "auto" to automatically calculate an optimal angle that includes all objects in the scene. The "auto" view positions the camera at a diagonal angle (from the top-right-front quadrant) to provide a comprehensive overview of the scene.'),
+    }),
+    execute: async (args, context: Context): Promise<any> => {
+        logger.info(`Tool executed: get_scene_screenshot with view_angle "${args.view_angle}"`);
+        try {
+            // Check if any modeling software clients are connected
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            // Capture the screenshot using getModelSnapshot
+            const result = await llmClient.sendCommand('get_scene_screenshot', args);
+
+            if (!result) {
+                return "Failed to capture screenshot.";
+            }
+
+            if (!result.startsWith("data:")) {
+                return result;
+            }
+
+            let base64Data = result;
+            // Extract base64 data if it includes data URL format (data:image/png;base64,)
+            if (base64Data.includes(',')) {
+                base64Data = base64Data.split(',')[1];
+            }
+
+            return {
+                content: [
+                    {
+                        type: "image",
+                        data: base64Data,
+                        mimeType: "image/png",
+                    },
+                ],
+            };
+        } catch (e) {
+            const errorMessage = `Error capturing screenshot: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};
+

package/src/tools/tools-info.ts

@@ -0,0 +1,107 @@
+import logger from "../lib/logger";
+import { z } from "zod";
+import { Context } from "../types";
+import { llmClient } from "../llmClient";
+import { MainStrategy } from "../prompt";
+
+// 更高级的帮助工具 - 获取可用的工具列表和使用信息
+export const getToolsInfoTool = {
+    name: "get_tools_info",
+    description:
+        "CRITICAL FIRST STEP: Returns comprehensive documentation about all available KooMaster(酷大师) tools, coordinate system specifications, measurement units, and best practices. Must be called before using any other functions to ensure proper model placement and prevent clipping issues. Provides essential information about the Z-up right-handed coordinate system and proper object positioning.",
+    parameters: z.object({}),
+    execute: async (_args: {}, _context: Context): Promise<string> => {
+        logger.info(`Tool executed: get_tools_info`);
+
+        try {
+            // 组织工具信息
+            const toolsInfo = {
+                basic: [
+                    "get_scene_info - Get detailed information about the current Koomaster scene",
+                    "get_objects_info - Get detailed information about specific objects in the Koomaster scene",
+                    "create_object - Create primitive objects (cube, sphere, etc.)",
+                    "modify_object - Change object properties (location, rotation, scale)",
+                    "delete_objects - Delete objects from the Koomaster scene by name",
+                    "copy_object - Create a copy of an existing object with a new name and transform properties. Currently only supports copying \"group\" type objects (KJL models, Tripo3D models, and basic geometry)",
+                    "get_selection - Get detailed information about the currently selected objects in the scene. Supports analyzing selected faces (with vertex coordinates and bounding boxes) or selected groups (with transform and hierarchy information).",
+                    "get_objects_screenshot - Captures a screenshot of the specific objects from different view angles. Note: Only supports KJL models, Tripo3D models, and basic geometric shapes - face screenshots are not supported.",
+                    "get_scene_screenshot - Captures a screenshot of the entire 3D scene from the specified view angle. Note: the screenshot result may appear upside-down compared to the actual scene orientation."
+                ],
+                material: [
+                    "get_material_names - Retrieves a list of all available material names from the connected koomaster client. This function queries the active connection to obtain the names of all materials that can be applied to 3D models. Returns the complete list of material names as a string, with materials typically separated by a delimiter. Useful for discovering what materials are available before applying them to specific models.",
+                    "set_face_material - Applies a specific material to an existing face in the 3D model. This tool allows you to change the appearance of a face by assigning a different material to it.",
+                    "set_group_material - Applies a specific material to an entire group of objects in the 3D model. This tool changes the appearance of all elements within the named group by assigning a different material to them.",
+                ],
+                modeling: [
+                    "add_faces - Creates new faces in the 3D model using SVG-style path notation. Each face must form a closed planar boundary - all points defining a single face MUST be coplanar (lie exactly on the same plane). IMPORTANT: When a new face intersects or overlaps with existing faces, Koomaster will automatically split those faces, which may cause the original face IDs to change or become invalid. After adding faces that might cause splits, use the 'find_face_by_points' tool to locate the resulting faces by specifying points that lie on them. TIP: If creating faces for sweep operations, consider creating them in empty space away from your main model to avoid unintended face splitting. During sweep operations, the source face will be automatically removed after the sweep completes.",
+                    "find_face_by_points - Finds a face by specifying multiple points that lie on the face. By providing 1-5 points that lie on the target face, you can identify faces reliably even when topology changes occur.  Returns the face's information including its ID, normal vector, area, and other properties.",
+                    "get_face_path - Retrieves the SVG-style path representation of a face's boundary. This tool extracts the geometric outline of a face and returns it as a path string that can be used for visualization or further operations. The path includes all curves that form the outer boundary of the face.",
+                    "pull_faces - Performs a push/pull operation on one or more faces to create or modify 3D shapes. This tool allows you to extrude faces along their normal direction to add or remove volume from a model.",
+                    "create_auxiliary_curve - Creates an auxiliary 3D curve using SVG-like path commands with explicit 3D coordinates.",
+                    "sweep - Creates a 3D solid by sweeping a FACE along auxiliary curves. NOTE: This tool operates ONLY on faces, not on entire objects or groups. The face can be either selected by the user or created programmatically. IMPORTANT: The face being swept (profile) must NOT be parallel to the auxiliary curves (path) - the sweep direction must have some component perpendicular to the face normal for the operation to succeed. After the sweep operation completes, the original face (profile) will be automatically deleted from the model.",
+                ],
+                // tripo3d: [
+                //     "get_tripo3d_status - Check if Tripo3D is configured and available for use by verifying the presence of required API keys and configuration",
+                //     "create_tripo3d_job - Generate a 3D model using Fal.ai Tripo3D service from text or images",
+                //     "poll_tripo3d_job_status - Check the status of a Tripo3D 3D model generation job",
+                //     "import_generated_asset - Import a 3D model generated by Tripo3D into the scene",
+                //     "poll_tripo3d_import_status - Query the progress status of importing a Tripo3D-generated 3D model into the Koomaster scene"
+                // ],
+                assets: [
+                    "batch_search_kjl_assets - Performs a concurrent batch search for multiple 3D models and assets in the KJL(酷家乐) database. Returns a combined list of models that match each search term, including their names, IDs, categories, and dimensions. Use this when you need to search for multiple different types of models at once.",
+                    "batch_get_kjl_asset_snapshot - Retrieves preview images for multiple KJL(酷家乐) asset models concurrently based on their model IDs. This helps visualize multiple assets before placing them in the scene. Use this tool to efficiently examine the appearance and style of several models at once to ensure they match your design requirements.",
+                    // "search_kjl_assets - Searches for 3D models and assets in the KJL database based on a text description. Returns a list of models that match the search criteria, including their names, IDs, categories, and dimensions.",
+                    // "get_kjl_asset_snapshot - Retrieves a preview image for a specific KJL(酷家乐) asset model based on its model ID. This helps visualize the asset before placing it in the scene. Use this tool to examine the appearance and style of a model to ensure it matches your design requirements.",
+                    "place_kjl_asset - Places a 3D model from the KJL(酷家乐) asset library into the current scene with specified position, rotation, and scale. Before placing, analyze the model\'s bounding box dimensions to determine proper orientation - elongated objects like wall panels may require 90° rotation based on intended function. Ensure bottoms align with the ground plane (z=0) by setting z-value to half the model\'s height. After placement, verify no clipping with existing objects and confirm dimensions match real-world proportions.",
+                    "replace_kjl_asset - Replaces an existing object in the scene with a new 3D model from the KJL(酷家乐) asset library. The replacement maintains the position, rotation, aligning the centers of both models. After replacement, review the scene to ensure no intersections or clipping with other objects."
+                ],
+            };
+
+            // 连接状态信息
+            const connectionStatus = llmClient.hasConnectedKoomasterClients()
+                ? `✅ Connected to Koomaster client`
+                : "❌ Not connected to Koomaster";
+
+            // 格式化工具信息
+            let result = `# KoomasterMCP Tools Overview\n\n`;
+            result += `${connectionStatus}\n\n`;
+            result += `## Basic Tools\n\n`;
+            toolsInfo.basic.forEach((tool) => {
+                result += `- ${tool}\n`;
+            });
+
+            result += `\n## Assets Tools\n\n`;
+            toolsInfo.assets.forEach((tool) => {
+                result += `- ${tool}\n`;
+            });
+
+            result += `\n## Tripo3D Integration\n\n`;
+            toolsInfo.tripo3d.forEach((tool) => {
+                result += `- ${tool}\n`;
+            });
+
+            result += `\n## Modeling Tools\n\n`;
+            toolsInfo.modeling.forEach((tool) => {
+                result += `- ${tool}\n`;
+            });
+
+            result += `\n## Material Tools\n\n`;
+            toolsInfo.material.forEach((tool) => {
+                result += `- ${tool}\n`;
+            });
+
+            result += MainStrategy;
+
+            logger.debug(
+                `Generated tools info summary (${result.length} characters)`
+            );
+            return result;
+        } catch (e) {
+            const errorMessage = `Error getting tools info: ${e instanceof Error ? e.message : String(e)
+                }`;
+            logger.error(errorMessage);
+            return `Error getting tools info: ${e instanceof Error ? e.message : String(e)
+                }`;
+        }
+    },
+};