freeform-modeling-mcp 1.0.26

package/src/tools/basic-tools.ts

@@ -0,0 +1,531 @@
+// src/tools/basic-tools.ts
+import { Context } from '../types';
+import { z } from 'zod';
+import logger from '../lib/logger';
+import { llmClient } from '../llmClient';
+
+// getSceneInfo 工具
+export const getSceneInfoTool = {
+    name: 'get_scene_info',
+    description: 'Get detailed information about the current Koomaster scene',
+    parameters: z.object({}),
+    execute: async (_args: {}, context: Context): Promise<string> => {
+        logger.info(`Tool executed: get_scene_info`);
+
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn('No Koomaster clients connected when attempting to get scene info');
+                return "No Koomaster clients connected. Please start the Koomaster addon and connect to this server.";
+            }
+
+            logger.debug(`Sending 'get_scene_info' command to Koomaster`);
+            const result = await llmClient.sendCommand("get_scene_info");
+            return result
+        } catch (e) {
+            const errorMessage = `Error getting scene info from Koomaster: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error getting scene info: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+// getObjectsInfo 工具
+export const getObjectsInfoTool = {
+    name: 'get_objects_info',
+    description: 'Get detailed information about specific objects in the Koomaster scene',
+    parameters: z.object({
+        names: z.array(z.string()).describe('Array of object names to get information about'),
+        type: z.enum(['face', 'group', 'auxiliary_curve']).describe('The type of objects to get information for')
+    }),
+    execute: async (args: { names: string[], type: 'face' | 'group' | 'auxiliary_curve' }, context: Context): Promise<string> => {
+        logger.info(`Tool executed: get_objects_info for ${args.names.length} objects of type "${args.type}"`);
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn('No Koomaster clients connected when attempting to get objects info');
+                return "No Koomaster clients connected. Please start the Koomaster addon and connect to this server.";
+            }
+            
+            // 将type字符串映射到ObjectType枚举
+            
+            logger.debug(`Sending 'get_objects_info' command for ${args.names.length} objects of type "${args.type}" to Koomaster`);
+            const result = await llmClient.sendCommand("get_objects_info",args);
+            
+            return result;
+        } catch (e) {
+            const errorMessage = `Error getting info for objects of type "${args.type}" from Koomaster: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error getting objects info: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+
+// createObject 工具
+const DEFAULT_TORUS_SIZE = { ring: 500, pipe: 100 };
+const DEFAULT_TORUS_SEGMENTS = { ring: 32, pipe: 16 };
+const TORUS_RING_RADIUS_RANGE = { min: 0, max: 1000000, step: 50, minOpen: true };
+const TORUS_RING_SEG_RANGE = { min: 3, max: 64, step: 1 };
+const TORUS_PIPE_RADIUS_RANGE = { min: 0, max: 1000000, step: 10, minOpen: true };
+const TORUS_PIPE_SEG_RANGE = { min: 3, max: 64, step: 1 };
+
+const SLICE_RANGE = { min: 0, max: 360, step: 10 }; // degree
+const DEFAULT_SLICE = { f: 0, t: 180 };
+
+// createObject 工具 - 使用绝对尺寸替代缩放
+export const createObjectTool = {
+    name: 'create_object',
+    description: 'Create a new object in the koo master scene',
+    parameters: z.object({
+        type: z.string().describe('Object type (CUBE, SPHERE, CYLINDER, PLANE, CONE, TORUS, EMPTY, CAMERA, LIGHT)').default("CUBE"),
+        name: z.string().optional().describe('Optional name for the object'),
+        location: z.array(z.number()).optional().describe('Optional [x, y, z] center location coordinates'),
+        rotation: z.array(z.number()).optional().describe('Optional [x, y, z] rotation in degrees. Following the Z-up coordinate system: rotation around X-axis tilts the object left/right (like nodding sideways), rotation around Y-axis tilts the object forward/backward (like nodding), and rotation around Z-axis rotates the object in the horizontal plane (like spinning on the ground). Positive values follow the right-hand rule: point thumb in positive axis direction, fingers show positive rotation direction.'),
+
+        // 使用绝对尺寸替代缩放
+        dimensions: z.array(z.number()).describe('Optional [width, height, depth] absolute dimensions').optional()
+            .default(undefined),
+
+        // 圆环特有参数 - 验证器链修复，default() 放在最后
+        slice_from: z.number()
+            .min(SLICE_RANGE.min)
+            .max(SLICE_RANGE.max)
+            .describe(`Torus only: Starting angle of the slice in degrees (${SLICE_RANGE.min}-${SLICE_RANGE.max}), step ${SLICE_RANGE.step}`)
+            .default(DEFAULT_SLICE.f),
+
+        slice_to: z.number()
+            .min(SLICE_RANGE.min)
+            .max(SLICE_RANGE.max)
+            .describe(`Torus only: Ending angle of the slice in degrees (${SLICE_RANGE.min}-${SLICE_RANGE.max}), step ${SLICE_RANGE.step}`)
+            .default(DEFAULT_SLICE.t),
+
+        ring_radius: z.number()
+            .gt(0)
+            .max(TORUS_RING_RADIUS_RANGE.max)
+            .describe(`Torus only: Radius of the ring (0-${TORUS_RING_RADIUS_RANGE.max}), step ${TORUS_RING_RADIUS_RANGE.step}`)
+            .default(DEFAULT_TORUS_SIZE.ring),
+
+        ring_segments: z.number()
+            .min(TORUS_RING_SEG_RANGE.min)
+            .max(TORUS_RING_SEG_RANGE.max)
+            .int()
+            .describe(`Torus only: Number of segments for the ring (${TORUS_RING_SEG_RANGE.min}-${TORUS_RING_SEG_RANGE.max}), integers only`)
+            .default(DEFAULT_TORUS_SEGMENTS.ring),
+
+        pipe_radius: z.number()
+            .gt(0)
+            .max(TORUS_PIPE_RADIUS_RANGE.max)
+            .describe(`Torus only: Radius of the pipe/tube (0-${TORUS_PIPE_RADIUS_RANGE.max}), step ${TORUS_PIPE_RADIUS_RANGE.step}`)
+            .default(DEFAULT_TORUS_SIZE.pipe),
+
+        pipe_segments: z.number()
+            .min(TORUS_PIPE_SEG_RANGE.min)
+            .max(TORUS_PIPE_SEG_RANGE.max)
+            .int()
+            .describe(`Torus only: Number of segments for the pipe (${TORUS_PIPE_SEG_RANGE.min}-${TORUS_PIPE_SEG_RANGE.max}), integers only`)
+            .default(DEFAULT_TORUS_SEGMENTS.pipe),
+
+        // 其他特有参数
+        // radius: z.number().optional().describe('Sphere only: Radius of the sphere'),
+        // base_radius: z.number().optional().describe('Cone only: Radius of the base'),
+        // top_radius: z.number().optional().describe('Cylinder/Cone only: Radius of the top (0 for cone point)'),
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: create_object of type "${args.type}"${args.name ? ` with name "${args.name}"` : ''}`);
+
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No Koomaster clients connected when attempting to create object of type "${args.type}"`);
+                return "No Koomaster clients connected. Please start the modeling software and connect to this server.";
+            }
+
+            // 设置位置和旋转的默认值
+            const loc = args.location || [0, 0, 0];
+            const rot = args.rotation || [0, 0, 0];
+
+            logger.debug(`Creating object with location=${JSON.stringify(loc)}, rotation=${JSON.stringify(rot)}`);
+
+            const params: Record<string, any> = {
+                type: args.type,
+                location: loc,
+                rotation: rot,
+            };
+
+            if (args.name) {
+                params.name = args.name;
+                logger.debug(`Using custom name: "${args.name}"`);
+            }
+
+            // 添加尺寸参数（如果提供）
+            if (args.dimensions) {
+                params.dimensions = args.dimensions;
+                logger.debug(`Setting dimensions to [${args.dimensions.join(', ')}]`);
+            }
+
+            // 根据对象类型添加特定参数
+            switch (args.type) {
+                case "TORUS":
+                    // 检查 slice_from 是否小于 slice_to
+                    if (args.slice_from >= args.slice_to) {
+                        const errorMsg = `Invalid slice range: slice_from (${args.slice_from}) must be less than slice_to (${args.slice_to})`;
+                        logger.warn(errorMsg);
+                        return errorMsg;
+                    }
+
+                    // 确保分段值为整数
+                    const ringSegments = Math.round(args.ring_segments);
+                    const pipeSegments = Math.round(args.pipe_segments);
+
+                    logger.debug(`Creating torus with: ring_radius=${args.ring_radius}, ring_segments=${ringSegments}, pipe_radius=${args.pipe_radius}, pipe_segments=${pipeSegments}`);
+                    logger.debug(`Slice parameters: from=${args.slice_from}°, to=${args.slice_to}°`);
+
+                    // 添加圆环特有参数
+                    params.slice_from = args.slice_from;
+                    params.slice_to = args.slice_to;
+                    params.ring_radius = args.ring_radius;
+                    params.ring_segments = ringSegments;
+                    params.pipe_radius = args.pipe_radius;
+                    params.pipe_segments = pipeSegments;
+                    break;
+
+                case "SPHERE":
+                    if (args.radius) {
+                        params.radius = args.radius;
+                        logger.debug(`Creating sphere with radius=${args.radius}`);
+                    }
+                    if (args.segments) {
+                        params.segments = args.segments;
+                        logger.debug(`Sphere segments=${args.segments}`);
+                    }
+                    break;
+
+                case "CYLINDER":
+                    if (args.height) {
+                        params.height = args.height;
+                        logger.debug(`Cylinder height=${args.height}`);
+                    }
+                    if (args.top_radius) {
+                        params.top_radius = args.top_radius;
+                        logger.debug(`Cylinder top_radius=${args.top_radius}`);
+                    }
+                    if (args.segments) {
+                        params.segments = args.segments;
+                        logger.debug(`Cylinder segments=${args.segments}`);
+                    }
+                    break;
+
+                case "CONE":
+                    if (args.height) {
+                        params.height = args.height;
+                        logger.debug(`Cone height=${args.height}`);
+                    }
+                    if (args.base_radius) {
+                        params.base_radius = args.base_radius;
+                        logger.debug(`Cone base_radius=${args.base_radius}`);
+                    }
+                    if (args.top_radius !== undefined) {
+                        params.top_radius = args.top_radius;
+                        logger.debug(`Cone top_radius=${args.top_radius}`);
+                    }
+                    if (args.segments) {
+                        params.segments = args.segments;
+                        logger.debug(`Cone segments=${args.segments}`);
+                    }
+                    break;
+
+                case "PLANE":
+                    if (args.width) {
+                        params.width = args.width;
+                        logger.debug(`Plane width=${args.width}`);
+                    }
+                    if (args.length) {
+                        params.length = args.length;
+                        logger.debug(`Plane length=${args.length}`);
+                    }
+                    break;
+            }
+
+            logger.debug(`Sending 'create_object' command for ${args.type} with ${Object.keys(params).length} parameters`);
+            const result = await llmClient.sendCommand("create_object", params);
+            logger.info(`Created ${args.type.toLowerCase()} object: "${result.name}" at [${loc.join(', ')}]`);
+            return `Created ${args.type} object: ${result.name}`;
+        } catch (e) {
+            const errorMessage = `Error creating object of type "${args.type}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error creating object: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+
+// modifyObject 工具
+export const modifyObjectTool = {
+    name: 'modify_object',
+    description: 'Modify an existing object in the scene',
+    parameters: z.object({
+        name: z.string().describe('Name of the object to modify'),
+        location: z.array(z.number()).optional().describe('Optional [x, y, z] center location coordinates'),
+        rotation: z.array(z.number()).optional().describe('Optional [x, y, z] rotation in degrees. Following the Z-up coordinate system: rotation around X-axis tilts the object left/right (like nodding sideways), rotation around Y-axis tilts the object forward/backward (like nodding), and rotation around Z-axis rotates the object in the horizontal plane (like spinning on the ground). Positive values follow the right-hand rule: point thumb in positive axis direction, fingers show positive rotation direction.'),
+
+        // 使用绝对尺寸替代缩放
+        dimensions: z.array(z.number()).optional().describe('Optional [width, height, depth] absolute dimensions'),
+
+        // 其他可能需要修改的特定参数
+        visible: z.boolean().optional().describe('Optional boolean to set visibility'),
+
+        // 圆环特有参数
+        slice_from: z.number().optional().describe('Torus only: Starting angle of the slice in degrees (0-360)'),
+        slice_to: z.number().optional().describe('Torus only: Ending angle of the slice in degrees (0-360)'),
+        ring_radius: z.number().optional().describe('Torus only: Radius of the ring'),
+        pipe_radius: z.number().optional().describe('Torus only: Radius of the pipe/tube'),
+
+        // 基本几何参数，适用于不同的对象
+        radius: z.number().optional().describe('Sphere/Cylinder/Cone: Radius value'),
+        height: z.number().optional().describe('Cylinder/Cone: Height value'),
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: modify_object for object "${args.name}"`);
+
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to modify object "${args.name}"`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            const params: Record<string, any> = { name: args.name };
+            const modifiedProps: string[] = [];
+
+            // 添加位置和旋转参数
+            if (args.location !== undefined) {
+                params.location = args.location;
+                logger.debug(`Setting location to [${args.location.join(', ')}]`);
+                modifiedProps.push("location");
+            }
+
+            if (args.rotation !== undefined) {
+                params.rotation = args.rotation;
+                logger.debug(`Setting rotation to [${args.rotation.join(', ')}]`);
+                modifiedProps.push("rotation");
+            }
+
+            // 添加尺寸参数（如果提供）
+            if (args.dimensions !== undefined) {
+                params.dimensions = args.dimensions;
+                logger.debug(`Setting dimensions to [${args.dimensions.join(', ')}]`);
+                modifiedProps.push("dimensions");
+            }
+
+            // 添加可见性参数
+            if (args.visible !== undefined) {
+                params.visible = args.visible;
+                logger.debug(`Setting visibility to ${args.visible}`);
+                modifiedProps.push("visibility");
+            }
+
+            // 添加圆环特有参数
+            if (args.slice_from !== undefined) {
+                params.slice_from = args.slice_from;
+                modifiedProps.push("slice_from");
+            }
+
+            if (args.slice_to !== undefined) {
+                params.slice_to = args.slice_to;
+                modifiedProps.push("slice_to");
+            }
+
+            if (args.ring_radius !== undefined) {
+                params.ring_radius = args.ring_radius;
+                modifiedProps.push("ring_radius");
+            }
+
+            if (args.pipe_radius !== undefined) {
+                params.pipe_radius = args.pipe_radius;
+                modifiedProps.push("pipe_radius");
+            }
+
+            // 添加其他几何参数
+            if (args.radius !== undefined) {
+                params.radius = args.radius;
+                modifiedProps.push("radius");
+            }
+
+            if (args.height !== undefined) {
+                params.height = args.height;
+                modifiedProps.push("height");
+            }
+
+            // 如果没有参数修改，返回提示
+            if (modifiedProps.length === 0) {
+                return `No properties specified to modify for object: ${args.name}`;
+            }
+
+            logger.debug(`Sending 'modify_object' command for "${args.name}" with properties: ${modifiedProps.join(', ')}`);
+            const result = await llmClient.sendCommand("modify_object", params);
+
+            logger.info(`Modified object: "${result.name || args.name}" (${modifiedProps.join(', ')})`);
+            return `Modified object ${args.name}: updated ${modifiedProps.join(', ')}`;
+        } catch (e) {
+            const errorMessage = `Error modifying object "${args.name}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error modifying object: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+export const deleteObjectsTool = {
+    name: 'delete_objects',
+    description: 'Delete objects from the Koomaster scene by name',
+    parameters: z.object({
+        names: z.array(z.string())
+            .min(1, "At least one object name must be provided")
+            .describe('Array of object names to delete'),
+        type: z.enum(['group', 'face', 'auxiliary_curve'])
+            .describe('Type of objects to delete: "group" for KJL models, Tripo3D models and basic geometry; "face" for individual faces; "auxiliary_curve" for reference curves')
+    }),
+    execute: async (args: { names: string[], type: 'group' | 'face' | 'auxiliary_curve' }, context: Context): Promise<string> => {
+        const objectNames = args.names.join(', ');
+        const objectCount = args.names.length;
+        
+        logger.info(`Tool executed: delete_objects for ${objectCount} ${args.type}(s): "${objectNames}"`);
+        
+        try {
+            // Check if Koomaster client is connected
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                const errorMsg = `No Koomaster clients connected when attempting to delete ${objectCount} ${args.type}(s)`;
+                logger.warn(errorMsg);
+                return "No Koomaster clients connected. Please start the Koomaster addon and connect to this server.";
+            }
+            
+            // Input validation
+            if (args.names.length === 0) {
+                return "Error: No object names provided. Please specify at least one object to delete.";
+            }
+            
+            // Send the delete command
+            logger.debug(`Sending 'delete_objects' command for ${objectCount} ${args.type}(s): "${objectNames}"`);
+            
+            const response = await llmClient.sendCommand("delete_objects", {
+                names: args.names,
+                type: args.type
+            });
+            
+            return response;
+        } catch (e) {
+            // Handle exception with improved error reporting
+            const errorMessage = `Error deleting ${objectCount} ${args.type}(s) "${objectNames}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            
+            // Provide a more user-friendly error message
+            return `Failed to delete ${args.type}(s). Error: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+
+// copyObject 工具
+export const copyObjectTool = {
+    name: 'copy_object',
+    description: '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).',
+    parameters: z.object({
+        name: z.string().describe('Name of the group object to copy'),
+        newName: z.string().describe('Name for the new copied group object'),
+        location: z.array(z.number()).optional().describe('Optional [x, y, z] center location coordinates for the new object'),
+        rotation: z.array(z.number()).optional().describe('Optional [x, y, z] rotation in degrees. Following the Z-up coordinate system: rotation around X-axis tilts the object left/right (like nodding sideways), rotation around Y-axis tilts the object forward/backward (like nodding), and rotation around Z-axis rotates the object in the horizontal plane (like spinning on the ground). Positive values follow the right-hand rule: point thumb in positive axis direction, fingers show positive rotation direction.'),
+        dimensions: z.array(z.number()).optional().describe('Optional [width, height, depth] dimensions for the new object')
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: copy_object from "${args.name}" to "${args.newName}"`);
+
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to copy object "${args.name}"`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            // 准备参数，仅包含提供的属性
+            const params: Record<string, any> = {
+                name: args.name,
+                newName: args.newName
+            };
+
+            // 添加可选参数（如果提供）
+            if (args.location !== undefined) {
+                params.location = args.location;
+                logger.debug(`Setting location for new object to [${args.location.join(', ')}]`);
+            }
+
+            if (args.rotation !== undefined) {
+                params.rotation = args.rotation;
+                logger.debug(`Setting rotation for new object to [${args.rotation.join(', ')}]`);
+            }
+
+            if (args.dimensions !== undefined) {
+                params.dimensions = args.dimensions;
+                logger.debug(`Setting dimensions for new object to [${args.dimensions.join(', ')}]`);
+            }
+
+            logger.debug(`Sending 'copy_object' command for "${args.name}" with new name "${args.newName}"`);
+
+            const result = await llmClient.sendCommand("copy_object", params);
+
+            logger.info(`Successfully copied object from "${args.name}" to "${args.newName}"`);
+            return `Successfully copied object "${args.name}" to a new object named "${args.newName}".\n${result}`;
+
+        } catch (e) {
+            const errorMessage = `Error copying object "${args.name}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error copying object: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+
+// Tool: Get Selection Details
+export const getSelectionTool = {
+    name: 'get_selection',
+    description: '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).',
+    parameters: z.object({
+        type: z.enum(['face', 'group', 'auxiliary_curve']).describe('The type of selection to analyze. "face" returns geometry data for selected faces. "group" returns information about selected objects. "auxiliary_curve" returns IDs and details of selected path curves.')
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: get_selection with type "${args.type}"`);
+        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.";
+            }
+
+            // Send the get_selection command to the client
+            const result = await llmClient.sendCommand('get_selection', args);
+
+            // If no selection, provide a helpful message
+            if (!result || result.trim() === '' || result.includes('No objects are currently selected')) {
+                if (args.type === 'face') {
+                    return "No faces are currently selected. Please select one or more faces in the scene and try again.";
+                } else if (args.type === 'group') {
+                    return "No groups are currently selected. Please select one or more objects or groups in the scene and try again.";
+                } else if (args.type === 'auxiliary_curve') {
+                    return "No auxiliary curves are currently selected. Please ask the user to select one or more auxiliary curves in the scene, or create some using the create_auxiliary_curve tool.";
+                }
+                return "No objects of the requested type are currently selected. Please make a selection and try again.";
+            }
+
+            // Return the selection details
+            return result;
+
+        } catch (e) {
+            const errorMessage = `Error retrieving selection information: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};
+
+// 导出所有工具
+export const basicTools = {
+    getSceneInfoTool,
+    getObjectsInfoTool,
+    createObjectTool,
+    modifyObjectTool,
+    deleteObjectTool: deleteObjectsTool,
+};

package/src/tools/index.ts

@@ -0,0 +1,2 @@
+// src/tools/index.ts
+export * from './basic-tools';

package/src/tools/material-tools.ts

@@ -0,0 +1,88 @@
+import { Context } from '../types';
+import { z } from 'zod';
+import logger from '../lib/logger';
+import { llmClient } from '../llmClient';
+
+export const getMaterialNames = {
+    name: 'get_material_names',
+    description: 'Retrieves a list of all available material names from the connected 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.',
+    parameters: z.object({}),
+    execute: async (args, context: Context): Promise<string> => {
+
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to set material for model "${args.modelName}"`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            const result = await llmClient.sendCommand("get_material_names");
+
+            return result;
+
+        } catch (e) {
+            const errorMessage = `Error setting material for model "${args.modelName}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return `Error setting material: ${e instanceof Error ? e.message : String(e)}`;
+        }
+    }
+};
+
+export const setFaceMaterialTool = {
+    name: 'set_face_material',
+    description: '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.',
+    parameters: z.object({
+        faceName: z.string().describe('The name of the face to apply material to. This should be the full face name (e.g., "face_wall1"). You can get face names from previously created faces or by using tools that provide model information.'),
+        materialName: z.string().describe('The name of the material to apply to the face. Use the get_material_names function first to retrieve a list of all available materials in the current scene. Only materials returned by get_material_names can be successfully applied.')
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to set material for face "${args.faceName}"`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            const result = await llmClient.sendCommand("set_face_material", args);
+
+            return result;
+        } catch (e) {
+            const errorMessage = `Error setting material for face "${args.faceName}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+
+            if (String(e).includes("Face not found")) {
+                return `Error: Face "${args.faceName}" not found in the model. Please verify the face name is correct and that the face exists.`;
+            } else if (String(e).includes("Material not found")) {
+                return `Error: Material "${args.materialName}" not found. Use the get_material_names function to see available materials.`;
+            }
+
+            return errorMessage;
+        }
+    }
+};
+
+export const setGroupMaterialTool = {
+    name: 'set_group_material',
+    description: '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.',
+    parameters: z.object({
+        modelName: z.string().describe('The name of the group or model to apply material to. This should be the name you assigned when creating the group or importing the model. You can get model names using tools that provide scene information.'),
+        materialName: z.string().describe('The name of the material to apply to the entire group. Use the get_material_names function first to retrieve a list of all available materials in the current scene. Only materials returned by get_material_names can be successfully applied.')
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        try {
+            if (!llmClient.hasConnectedKoomasterClients()) {
+                logger.warn(`No clients connected when attempting to set material for group "${args.modelName}"`);
+                return "No modeling software clients connected. Please start the software and connect to this server.";
+            }
+
+            const result = await llmClient.sendCommand("set_group_material", args);
+
+            return result;
+        } catch (e) {
+            const errorMessage = `Error setting material for group "${args.modelName}": ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};

package/src/tools/modeling/auxiliary-curve-tool.ts

@@ -0,0 +1,44 @@
+import { Context } from "../../types";
+import { z } from "zod";
+import logger from "../../lib/logger";
+import { llmClient } from "../../llmClient";
+import { parseSvgPath3D } from "./utils";
+
+export const createAuxiliaryCurve = {
+    name: 'create_auxiliary_curve',
+    description: 'Creates an auxiliary 3D curve using SVG-like path commands with explicit 3D coordinates. Auxiliary curves can be used for sweep operations, as guides, or for visualization purposes.',
+    parameters: 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 (optional for auxiliary curves)\n\nIMPORTANT NOTES:\n1. CRITICAL: For Bezier curves (C command), ALL POINTS (start, control points, and end) MUST be coplanar (lie on the same plane). Non-planar Bezier curves will fail to create\n2. Unlike faces, auxiliary curves as a whole do NOT need to be closed or planar\n3. For connected curve segments used in sweep operations, ensure endpoints match exactly\n4. The arc command uses a custom 3-point format (not standard SVG arc)\n5. For arcs, the three points must not be collinear\n6. For a circle, use 3-4 arcs connecting points along the circumference\n\nEXAMPLES:\n- Straight line: "M 0,0,0 L 100,0,0"\n- Polyline: "M 0,0,0 L 50,50,50 L 100,0,100"\n- Arc: "M 0,0,0 A 50,50,50 100,0,0"\n- Planar Bezier curve: "M 0,0,0 C 25,25,0 75,75,0 100,100,0" (note all z-values are 0, ensuring coplanarity)\n- Closed shape: "M 0,0,0 L 100,0,0 L 100,100,0 L 0,100,0 Z"\n- Complex path (arcs and lines): "M 0,0,0 L 100,0,0 A 150,50,0 200,0,0 L 200,100,0 L 0,100,0 Z"'),
+    }),
+    execute: async (args, context: Context): Promise<string> => {
+        logger.info(`Tool executed: create_auxiliary_curve with path "${args.path}" and name "${args.name}"`);
+        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.";
+            }
+
+            // Parse the SVG path into 3D curve segments
+            try {
+                // Parse the path
+                const pathCurves = parseSvgPath3D(args.path);
+
+                // Send the command to create the auxiliary curve
+                const result = await llmClient.sendCommand('create_auxiliary_curve', {
+                    ...args,
+                    path: pathCurves,
+                });
+
+                return result;
+            } catch (parseError) {
+                return `Error parsing SVG path: ${parseError instanceof Error ? parseError.message : String(parseError)}`;
+            }
+
+        } catch (e) {
+            const errorMessage = `Error creating auxiliary curve: ${e instanceof Error ? e.message : String(e)}`;
+            logger.error(errorMessage);
+            context.log.error(errorMessage);
+            return errorMessage;
+        }
+    }
+};