robloxstudio-mcp 2.3.0 → 2.4.0

package/dist/index.js

@@ -1,1071 +1,3517 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { createRequire } from 'module';
-import { createHttpServer } from './http-server.js';
-import { RobloxStudioTools } from './tools/index.js';
-import { BridgeService } from './bridge-service.js';
-const require = createRequire(import.meta.url);
-const { version: VERSION } = require('../package.json');
-class RobloxStudioMCPServer {
-    server;
-    tools;
-    bridge;
-    constructor() {
-        this.server = new Server({
-            name: 'robloxstudio-mcp',
-            version: VERSION,
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.bridge = new BridgeService();
-        this.tools = new RobloxStudioTools(this.bridge);
-        this.setupToolHandlers();
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: 'get_file_tree',
-                        description: 'Get the Roblox instance hierarchy tree from Roblox Studio. Returns game instances (Parts, Scripts, Models, Folders, etc.) as a tree structure. NOTE: This operates on Roblox Studio instances, NOT local filesystem files.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                path: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to start from using dot notation (e.g., "game.Workspace", "game.ServerScriptService"). Defaults to game root if empty.',
-                                    default: ''
-                                }
-                            }
-                        }
-                    },
-                    {
-                        name: 'search_files',
-                        description: 'Search for Roblox instances by name, class type, or script content. NOTE: This searches Roblox Studio instances, NOT local filesystem files.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                query: {
-                                    type: 'string',
-                                    description: 'Search query - instance name, class type (e.g., "Script", "Part"), or Lua code pattern'
-                                },
-                                searchType: {
-                                    type: 'string',
-                                    enum: ['name', 'type', 'content'],
-                                    description: 'Type of search: "name" for instance names, "type" for class names, "content" for script source code',
-                                    default: 'name'
-                                }
-                            },
-                            required: ['query']
-                        }
-                    },
-                    {
-                        name: 'get_place_info',
-                        description: 'Get place ID, name, and game settings',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    },
-                    {
-                        name: 'get_services',
-                        description: 'Get available Roblox services and their children',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                serviceName: {
-                                    type: 'string',
-                                    description: 'Optional specific service name to query'
-                                }
-                            }
-                        }
-                    },
-                    {
-                        name: 'search_objects',
-                        description: 'Find instances by name, class, or properties',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                query: {
-                                    type: 'string',
-                                    description: 'Search query'
-                                },
-                                searchType: {
-                                    type: 'string',
-                                    enum: ['name', 'class', 'property'],
-                                    description: 'Type of search to perform',
-                                    default: 'name'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Property name when searchType is "property"'
-                                }
-                            },
-                            required: ['query']
-                        }
-                    },
-                    {
-                        name: 'get_instance_properties',
-                        description: 'Get all properties of a specific Roblox instance in Studio',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part", "game.ServerScriptService.MainScript", "game.ReplicatedStorage.ModuleScript")'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'get_instance_children',
-                        description: 'Get child instances and their class types from a Roblox parent instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace", "game.ServerScriptService")'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'search_by_property',
-                        description: 'Find objects with specific property values',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to search'
-                                },
-                                propertyValue: {
-                                    type: 'string',
-                                    description: 'Value to search for'
-                                }
-                            },
-                            required: ['propertyName', 'propertyValue']
-                        }
-                    },
-                    {
-                        name: 'get_class_info',
-                        description: 'Get available properties/methods for Roblox classes',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                className: {
-                                    type: 'string',
-                                    description: 'Roblox class name'
-                                }
-                            },
-                            required: ['className']
-                        }
-                    },
-                    {
-                        name: 'get_project_structure',
-                        description: 'Get complete game hierarchy. IMPORTANT: Use maxDepth parameter (default: 3) to explore deeper levels of the hierarchy. Set higher values like 5-10 for comprehensive exploration',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                path: {
-                                    type: 'string',
-                                    description: 'Optional path to start from (defaults to workspace root)',
-                                    default: ''
-                                },
-                                maxDepth: {
-                                    type: 'number',
-                                    description: 'Maximum depth to traverse (default: 3). RECOMMENDED: Use 5-10 for thorough exploration. Higher values provide more complete structure',
-                                    default: 3
-                                },
-                                scriptsOnly: {
-                                    type: 'boolean',
-                                    description: 'Show only scripts and script containers',
-                                    default: false
-                                }
-                            }
-                        }
-                    },
-                    {
-                        name: 'set_property',
-                        description: 'Set a property on any Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Path to the instance (e.g., "game.Workspace.Part")'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to set'
-                                },
-                                propertyValue: {
-                                    description: 'Value to set the property to (any type)'
-                                }
-                            },
-                            required: ['instancePath', 'propertyName', 'propertyValue']
-                        }
-                    },
-                    {
-                        name: 'mass_set_property',
-                        description: 'Set the same property on multiple instances at once',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                paths: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'Array of instance paths to modify'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to set'
-                                },
-                                propertyValue: {
-                                    description: 'Value to set the property to (any type)'
-                                }
-                            },
-                            required: ['paths', 'propertyName', 'propertyValue']
-                        }
-                    },
-                    {
-                        name: 'mass_get_property',
-                        description: 'Get the same property from multiple instances at once',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                paths: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'Array of instance paths to read from'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to get'
-                                }
-                            },
-                            required: ['paths', 'propertyName']
-                        }
-                    },
-                    {
-                        name: 'create_object',
-                        description: 'Create a new Roblox object instance (basic, without properties)',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                className: {
-                                    type: 'string',
-                                    description: 'Roblox class name (e.g., "Part", "Script", "Folder")'
-                                },
-                                parent: {
-                                    type: 'string',
-                                    description: 'Path to the parent instance (e.g., "game.Workspace")'
-                                },
-                                name: {
-                                    type: 'string',
-                                    description: 'Optional name for the new object'
-                                }
-                            },
-                            required: ['className', 'parent']
-                        }
-                    },
-                    {
-                        name: 'create_object_with_properties',
-                        description: 'Create a new Roblox object instance with initial properties',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                className: {
-                                    type: 'string',
-                                    description: 'Roblox class name (e.g., "Part", "Script", "Folder")'
-                                },
-                                parent: {
-                                    type: 'string',
-                                    description: 'Path to the parent instance (e.g., "game.Workspace")'
-                                },
-                                name: {
-                                    type: 'string',
-                                    description: 'Optional name for the new object'
-                                },
-                                properties: {
-                                    type: 'object',
-                                    description: 'Properties to set on creation'
-                                }
-                            },
-                            required: ['className', 'parent']
-                        }
-                    },
-                    {
-                        name: 'mass_create_objects',
-                        description: 'Create multiple objects at once (basic, without properties)',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                objects: {
-                                    type: 'array',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            className: {
-                                                type: 'string',
-                                                description: 'Roblox class name'
-                                            },
-                                            parent: {
-                                                type: 'string',
-                                                description: 'Path to the parent instance'
-                                            },
-                                            name: {
-                                                type: 'string',
-                                                description: 'Optional name for the object'
-                                            }
-                                        },
-                                        required: ['className', 'parent']
-                                    },
-                                    description: 'Array of objects to create'
-                                }
-                            },
-                            required: ['objects']
-                        }
-                    },
-                    {
-                        name: 'mass_create_objects_with_properties',
-                        description: 'Create multiple objects at once with initial properties',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                objects: {
-                                    type: 'array',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            className: {
-                                                type: 'string',
-                                                description: 'Roblox class name'
-                                            },
-                                            parent: {
-                                                type: 'string',
-                                                description: 'Path to the parent instance'
-                                            },
-                                            name: {
-                                                type: 'string',
-                                                description: 'Optional name for the object'
-                                            },
-                                            properties: {
-                                                type: 'object',
-                                                description: 'Properties to set on creation'
-                                            }
-                                        },
-                                        required: ['className', 'parent']
-                                    },
-                                    description: 'Array of objects to create with properties'
-                                }
-                            },
-                            required: ['objects']
-                        }
-                    },
-                    {
-                        name: 'delete_object',
-                        description: 'Delete a Roblox object instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Path to the instance to delete'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'smart_duplicate',
-                        description: 'Smart duplication with automatic naming, positioning, and property variations',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Path to the instance to duplicate'
-                                },
-                                count: {
-                                    type: 'number',
-                                    description: 'Number of duplicates to create'
-                                },
-                                options: {
-                                    type: 'object',
-                                    properties: {
-                                        namePattern: {
-                                            type: 'string',
-                                            description: 'Name pattern with {n} placeholder (e.g., "Button{n}")'
-                                        },
-                                        positionOffset: {
-                                            type: 'array',
-                                            items: { type: 'number' },
-                                            minItems: 3,
-                                            maxItems: 3,
-                                            description: 'X, Y, Z offset per duplicate'
-                                        },
-                                        rotationOffset: {
-                                            type: 'array',
-                                            items: { type: 'number' },
-                                            minItems: 3,
-                                            maxItems: 3,
-                                            description: 'X, Y, Z rotation offset per duplicate'
-                                        },
-                                        scaleOffset: {
-                                            type: 'array',
-                                            items: { type: 'number' },
-                                            minItems: 3,
-                                            maxItems: 3,
-                                            description: 'X, Y, Z scale multiplier per duplicate'
-                                        },
-                                        propertyVariations: {
-                                            type: 'object',
-                                            description: 'Property name to array of values'
-                                        },
-                                        targetParents: {
-                                            type: 'array',
-                                            items: { type: 'string' },
-                                            description: 'Different parent for each duplicate'
-                                        }
-                                    }
-                                }
-                            },
-                            required: ['instancePath', 'count']
-                        }
-                    },
-                    {
-                        name: 'mass_duplicate',
-                        description: 'Perform multiple smart duplications at once',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                duplications: {
-                                    type: 'array',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            instancePath: {
-                                                type: 'string',
-                                                description: 'Path to the instance to duplicate'
-                                            },
-                                            count: {
-                                                type: 'number',
-                                                description: 'Number of duplicates to create'
-                                            },
-                                            options: {
-                                                type: 'object',
-                                                properties: {
-                                                    namePattern: {
-                                                        type: 'string',
-                                                        description: 'Name pattern with {n} placeholder'
-                                                    },
-                                                    positionOffset: {
-                                                        type: 'array',
-                                                        items: { type: 'number' },
-                                                        minItems: 3,
-                                                        maxItems: 3,
-                                                        description: 'X, Y, Z offset per duplicate'
-                                                    },
-                                                    rotationOffset: {
-                                                        type: 'array',
-                                                        items: { type: 'number' },
-                                                        minItems: 3,
-                                                        maxItems: 3,
-                                                        description: 'X, Y, Z rotation offset per duplicate'
-                                                    },
-                                                    scaleOffset: {
-                                                        type: 'array',
-                                                        items: { type: 'number' },
-                                                        minItems: 3,
-                                                        maxItems: 3,
-                                                        description: 'X, Y, Z scale multiplier per duplicate'
-                                                    },
-                                                    propertyVariations: {
-                                                        type: 'object',
-                                                        description: 'Property name to array of values'
-                                                    },
-                                                    targetParents: {
-                                                        type: 'array',
-                                                        items: { type: 'string' },
-                                                        description: 'Different parent for each duplicate'
-                                                    }
-                                                }
-                                            }
-                                        },
-                                        required: ['instancePath', 'count']
-                                    },
-                                    description: 'Array of duplication operations'
-                                }
-                            },
-                            required: ['duplications']
-                        }
-                    },
-                    {
-                        name: 'set_calculated_property',
-                        description: 'Set properties using mathematical formulas and variables',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                paths: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'Array of instance paths to modify'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to set'
-                                },
-                                formula: {
-                                    type: 'string',
-                                    description: 'Mathematical formula (e.g., "Position.magnitude * 2", "index * 50")'
-                                },
-                                variables: {
-                                    type: 'object',
-                                    description: 'Additional variables for the formula'
-                                }
-                            },
-                            required: ['paths', 'propertyName', 'formula']
-                        }
-                    },
-                    {
-                        name: 'set_relative_property',
-                        description: 'Modify properties relative to their current values',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                paths: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'Array of instance paths to modify'
-                                },
-                                propertyName: {
-                                    type: 'string',
-                                    description: 'Name of the property to modify'
-                                },
-                                operation: {
-                                    type: 'string',
-                                    enum: ['add', 'multiply', 'divide', 'subtract', 'power'],
-                                    description: 'Mathematical operation to perform'
-                                },
-                                value: {
-                                    description: 'Value to use in the operation'
-                                },
-                                component: {
-                                    type: 'string',
-                                    enum: ['X', 'Y', 'Z', 'XScale', 'XOffset', 'YScale', 'YOffset'],
-                                    description: 'For Vector3: X, Y, Z. For UDim2: XScale, XOffset, YScale, YOffset (value must be a number)'
-                                }
-                            },
-                            required: ['paths', 'propertyName', 'operation', 'value']
-                        }
-                    },
-                    {
-                        name: 'get_script_source',
-                        description: 'Get the source code of a Roblox script (LocalScript, Script, or ModuleScript). Returns both "source" (raw code) and "numberedSource" (with line numbers prefixed like "1: code"). Use numberedSource to accurately identify line numbers for editing. For large scripts (>1500 lines), use startLine/endLine to read specific sections.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to the script using dot notation (e.g., "game.ServerScriptService.MainScript", "game.StarterPlayer.StarterPlayerScripts.LocalScript")'
-                                },
-                                startLine: {
-                                    type: 'number',
-                                    description: 'Optional: Start line number (1-indexed). Use for reading specific sections of large scripts.'
-                                },
-                                endLine: {
-                                    type: 'number',
-                                    description: 'Optional: End line number (inclusive). Use for reading specific sections of large scripts.'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'set_script_source',
-                        description: 'Replace the entire source code of a Roblox script. Uses ScriptEditorService:UpdateSourceAsync (works with open editors). For partial edits, prefer edit_script_lines, insert_script_lines, or delete_script_lines.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to the script (e.g., "game.ServerScriptService.MainScript")'
-                                },
-                                source: {
-                                    type: 'string',
-                                    description: 'New source code for the script'
-                                }
-                            },
-                            required: ['instancePath', 'source']
-                        }
-                    },
-                    {
-                        name: 'edit_script_lines',
-                        description: 'Replace specific lines in a Roblox script without rewriting the entire source. IMPORTANT: Use the "numberedSource" field from get_script_source to identify the correct line numbers. Lines are 1-indexed and ranges are inclusive.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to the script (e.g., "game.ServerScriptService.MainScript")'
-                                },
-                                startLine: {
-                                    type: 'number',
-                                    description: 'First line to replace (1-indexed). Get this from the "numberedSource" field.'
-                                },
-                                endLine: {
-                                    type: 'number',
-                                    description: 'Last line to replace (inclusive). Get this from the "numberedSource" field.'
-                                },
-                                newContent: {
-                                    type: 'string',
-                                    description: 'New content to replace the specified lines (can be multiple lines separated by newlines)'
-                                }
-                            },
-                            required: ['instancePath', 'startLine', 'endLine', 'newContent']
-                        }
-                    },
-                    {
-                        name: 'insert_script_lines',
-                        description: 'Insert new lines into a Roblox script at a specific position. IMPORTANT: Use the "numberedSource" field from get_script_source to identify the correct line numbers.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to the script (e.g., "game.ServerScriptService.MainScript")'
-                                },
-                                afterLine: {
-                                    type: 'number',
-                                    description: 'Insert after this line number (0 = insert at very beginning, 1 = after first line). Get line numbers from "numberedSource".',
-                                    default: 0
-                                },
-                                newContent: {
-                                    type: 'string',
-                                    description: 'Content to insert (can be multiple lines separated by newlines)'
-                                }
-                            },
-                            required: ['instancePath', 'newContent']
-                        }
-                    },
-                    {
-                        name: 'delete_script_lines',
-                        description: 'Delete specific lines from a Roblox script. IMPORTANT: Use the "numberedSource" field from get_script_source to identify the correct line numbers.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path to the script (e.g., "game.ServerScriptService.MainScript")'
-                                },
-                                startLine: {
-                                    type: 'number',
-                                    description: 'First line to delete (1-indexed). Get this from the "numberedSource" field.'
-                                },
-                                endLine: {
-                                    type: 'number',
-                                    description: 'Last line to delete (inclusive). Get this from the "numberedSource" field.'
-                                }
-                            },
-                            required: ['instancePath', 'startLine', 'endLine']
-                        }
-                    },
-                    {
-                        name: 'get_attribute',
-                        description: 'Get a single attribute value from a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part", "game.ServerStorage.DataStore")'
-                                },
-                                attributeName: {
-                                    type: 'string',
-                                    description: 'Name of the attribute to get'
-                                }
-                            },
-                            required: ['instancePath', 'attributeName']
-                        }
-                    },
-                    {
-                        name: 'set_attribute',
-                        description: 'Set an attribute value on a Roblox instance. Supports string, number, boolean, Vector3, Color3, UDim2, and BrickColor.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                },
-                                attributeName: {
-                                    type: 'string',
-                                    description: 'Name of the attribute to set'
-                                },
-                                attributeValue: {
-                                    description: 'Value to set. For Vector3: {X, Y, Z}, Color3: {R, G, B}, UDim2: {X: {Scale, Offset}, Y: {Scale, Offset}}'
-                                },
-                                valueType: {
-                                    type: 'string',
-                                    description: 'Optional type hint: "Vector3", "Color3", "UDim2", "BrickColor"'
-                                }
-                            },
-                            required: ['instancePath', 'attributeName', 'attributeValue']
-                        }
-                    },
-                    {
-                        name: 'get_attributes',
-                        description: 'Get all attributes on a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'delete_attribute',
-                        description: 'Delete an attribute from a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                },
-                                attributeName: {
-                                    type: 'string',
-                                    description: 'Name of the attribute to delete'
-                                }
-                            },
-                            required: ['instancePath', 'attributeName']
-                        }
-                    },
-                    {
-                        name: 'get_tags',
-                        description: 'Get all CollectionService tags on a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                }
-                            },
-                            required: ['instancePath']
-                        }
-                    },
-                    {
-                        name: 'add_tag',
-                        description: 'Add a CollectionService tag to a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                },
-                                tagName: {
-                                    type: 'string',
-                                    description: 'Name of the tag to add'
-                                }
-                            },
-                            required: ['instancePath', 'tagName']
-                        }
-                    },
-                    {
-                        name: 'remove_tag',
-                        description: 'Remove a CollectionService tag from a Roblox instance',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                instancePath: {
-                                    type: 'string',
-                                    description: 'Roblox instance path using dot notation (e.g., "game.Workspace.Part")'
-                                },
-                                tagName: {
-                                    type: 'string',
-                                    description: 'Name of the tag to remove'
-                                }
-                            },
-                            required: ['instancePath', 'tagName']
-                        }
-                    },
-                    {
-                        name: 'get_tagged',
-                        description: 'Get all instances with a specific tag',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                tagName: {
-                                    type: 'string',
-                                    description: 'Name of the tag to search for'
-                                }
-                            },
-                            required: ['tagName']
-                        }
-                    },
-                    {
-                        name: 'get_selection',
-                        description: 'Get all currently selected objects',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    },
-                    {
-                        name: 'execute_luau',
-                        description: 'Execute arbitrary Luau code in Roblox Studio and return the result. The code runs in the plugin context with access to game, workspace, and all services. Use print() or warn() to produce output. The return value of the code (if any) is captured. Useful for querying game state, running one-off operations, or testing logic.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                code: {
-                                    type: 'string',
-                                    description: 'Luau code to execute. Can use print() for output. The return value is captured.'
-                                }
-                            },
-                            required: ['code']
-                        }
-                    },
-                    {
-                        name: 'start_playtest',
-                        description: 'Start a play test session in Roblox Studio. Captures all output (print/warn/error) from LogService. Use get_playtest_output to poll for logs while running, then stop_playtest to end. Typical workflow: add print/warn statements to code, start playtest, poll output to observe behavior, stop, analyze logs, fix issues with set_script_source, and repeat until correct.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                mode: {
-                                    type: 'string',
-                                    enum: ['play', 'run'],
-                                    description: '"play" for Play Solo mode, "run" for Run mode'
-                                }
-                            },
-                            required: ['mode']
-                        }
-                    },
-                    {
-                        name: 'stop_playtest',
-                        description: 'Stop the running play test session and return all captured output. Call this after observing enough output via get_playtest_output, or when you need to make code changes before the next run.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    },
-                    {
-                        name: 'get_playtest_output',
-                        description: 'Poll the output buffer without stopping the test. Returns isRunning, captured print/warn/error messages, and any test result. Call repeatedly to monitor a running session — useful for waiting on specific log output or checking if errors have occurred.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {}
-                        }
-                    }
-                ]
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'get_file_tree':
-                        return await this.tools.getFileTree(args?.path || '');
-                    case 'search_files':
-                        return await this.tools.searchFiles(args?.query, args?.searchType || 'name');
-                    case 'get_place_info':
-                        return await this.tools.getPlaceInfo();
-                    case 'get_services':
-                        return await this.tools.getServices(args?.serviceName);
-                    case 'search_objects':
-                        return await this.tools.searchObjects(args?.query, args?.searchType || 'name', args?.propertyName);
-                    case 'get_instance_properties':
-                        return await this.tools.getInstanceProperties(args?.instancePath);
-                    case 'get_instance_children':
-                        return await this.tools.getInstanceChildren(args?.instancePath);
-                    case 'search_by_property':
-                        return await this.tools.searchByProperty(args?.propertyName, args?.propertyValue);
-                    case 'get_class_info':
-                        return await this.tools.getClassInfo(args?.className);
-                    case 'get_project_structure':
-                        return await this.tools.getProjectStructure(args?.path, args?.maxDepth, args?.scriptsOnly);
-                    case 'set_property':
-                        return await this.tools.setProperty(args?.instancePath, args?.propertyName, args?.propertyValue);
-                    case 'mass_set_property':
-                        return await this.tools.massSetProperty(args?.paths, args?.propertyName, args?.propertyValue);
-                    case 'mass_get_property':
-                        return await this.tools.massGetProperty(args?.paths, args?.propertyName);
-                    case 'create_object':
-                        return await this.tools.createObject(args?.className, args?.parent, args?.name);
-                    case 'create_object_with_properties':
-                        return await this.tools.createObjectWithProperties(args?.className, args?.parent, args?.name, args?.properties);
-                    case 'mass_create_objects':
-                        return await this.tools.massCreateObjects(args?.objects);
-                    case 'mass_create_objects_with_properties':
-                        return await this.tools.massCreateObjectsWithProperties(args?.objects);
-                    case 'delete_object':
-                        return await this.tools.deleteObject(args?.instancePath);
-                    case 'smart_duplicate':
-                        return await this.tools.smartDuplicate(args?.instancePath, args?.count, args?.options);
-                    case 'mass_duplicate':
-                        return await this.tools.massDuplicate(args?.duplications);
-                    case 'set_calculated_property':
-                        return await this.tools.setCalculatedProperty(args?.paths, args?.propertyName, args?.formula, args?.variables);
-                    case 'set_relative_property':
-                        return await this.tools.setRelativeProperty(args?.paths, args?.propertyName, args?.operation, args?.value, args?.component);
-                    case 'get_script_source':
-                        return await this.tools.getScriptSource(args?.instancePath, args?.startLine, args?.endLine);
-                    case 'set_script_source':
-                        return await this.tools.setScriptSource(args?.instancePath, args?.source);
-                    case 'edit_script_lines':
-                        return await this.tools.editScriptLines(args?.instancePath, args?.startLine, args?.endLine, args?.newContent);
-                    case 'insert_script_lines':
-                        return await this.tools.insertScriptLines(args?.instancePath, args?.afterLine, args?.newContent);
-                    case 'delete_script_lines':
-                        return await this.tools.deleteScriptLines(args?.instancePath, args?.startLine, args?.endLine);
-                    case 'get_attribute':
-                        return await this.tools.getAttribute(args?.instancePath, args?.attributeName);
-                    case 'set_attribute':
-                        return await this.tools.setAttribute(args?.instancePath, args?.attributeName, args?.attributeValue, args?.valueType);
-                    case 'get_attributes':
-                        return await this.tools.getAttributes(args?.instancePath);
-                    case 'delete_attribute':
-                        return await this.tools.deleteAttribute(args?.instancePath, args?.attributeName);
-                    case 'get_tags':
-                        return await this.tools.getTags(args?.instancePath);
-                    case 'add_tag':
-                        return await this.tools.addTag(args?.instancePath, args?.tagName);
-                    case 'remove_tag':
-                        return await this.tools.removeTag(args?.instancePath, args?.tagName);
-                    case 'get_tagged':
-                        return await this.tools.getTagged(args?.tagName);
-                    case 'get_selection':
-                        return await this.tools.getSelection();
-                    case 'execute_luau':
-                        return await this.tools.executeLuau(args?.code);
-                    case 'start_playtest':
-                        return await this.tools.startPlaytest(args?.mode);
-                    case 'stop_playtest':
-                        return await this.tools.stopPlaytest();
-                    case 'get_playtest_output':
-                        return await this.tools.getPlaytestOutput();
-                    default:
-                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/http-server.js
+import express from "express";
+import cors from "cors";
+import http from "http";
+var TOOL_HANDLERS = {
+  get_file_tree: (tools, body) => tools.getFileTree(body.path),
+  search_files: (tools, body) => tools.searchFiles(body.query, body.searchType),
+  get_place_info: (tools) => tools.getPlaceInfo(),
+  get_services: (tools, body) => tools.getServices(body.serviceName),
+  search_objects: (tools, body) => tools.searchObjects(body.query, body.searchType, body.propertyName),
+  get_instance_properties: (tools, body) => tools.getInstanceProperties(body.instancePath, body.excludeSource),
+  get_instance_children: (tools, body) => tools.getInstanceChildren(body.instancePath),
+  search_by_property: (tools, body) => tools.searchByProperty(body.propertyName, body.propertyValue),
+  get_class_info: (tools, body) => tools.getClassInfo(body.className),
+  get_project_structure: (tools, body) => tools.getProjectStructure(body.path, body.maxDepth, body.scriptsOnly),
+  set_property: (tools, body) => tools.setProperty(body.instancePath, body.propertyName, body.propertyValue),
+  mass_set_property: (tools, body) => tools.massSetProperty(body.paths, body.propertyName, body.propertyValue),
+  mass_get_property: (tools, body) => tools.massGetProperty(body.paths, body.propertyName),
+  create_object: (tools, body) => tools.createObject(body.className, body.parent, body.name, body.properties),
+  create_object_with_properties: (tools, body) => tools.createObject(body.className, body.parent, body.name, body.properties),
+  mass_create_objects: (tools, body) => tools.massCreateObjects(body.objects),
+  mass_create_objects_with_properties: (tools, body) => tools.massCreateObjects(body.objects),
+  delete_object: (tools, body) => tools.deleteObject(body.instancePath),
+  smart_duplicate: (tools, body) => tools.smartDuplicate(body.instancePath, body.count, body.options),
+  mass_duplicate: (tools, body) => tools.massDuplicate(body.duplications),
+  set_calculated_property: (tools, body) => tools.setCalculatedProperty(body.paths, body.propertyName, body.formula, body.variables),
+  set_relative_property: (tools, body) => tools.setRelativeProperty(body.paths, body.propertyName, body.operation, body.value, body.component),
+  grep_scripts: (tools, body) => tools.grepScripts(body.pattern, {
+    caseSensitive: body.caseSensitive,
+    usePattern: body.usePattern,
+    contextLines: body.contextLines,
+    maxResults: body.maxResults,
+    maxResultsPerScript: body.maxResultsPerScript,
+    filesOnly: body.filesOnly,
+    path: body.path,
+    classFilter: body.classFilter
+  }),
+  get_script_source: (tools, body) => tools.getScriptSource(body.instancePath, body.startLine, body.endLine),
+  set_script_source: (tools, body) => tools.setScriptSource(body.instancePath, body.source),
+  edit_script_lines: (tools, body) => tools.editScriptLines(body.instancePath, body.startLine, body.endLine, body.newContent),
+  insert_script_lines: (tools, body) => tools.insertScriptLines(body.instancePath, body.afterLine, body.newContent),
+  delete_script_lines: (tools, body) => tools.deleteScriptLines(body.instancePath, body.startLine, body.endLine),
+  get_attribute: (tools, body) => tools.getAttribute(body.instancePath, body.attributeName),
+  set_attribute: (tools, body) => tools.setAttribute(body.instancePath, body.attributeName, body.attributeValue, body.valueType),
+  get_attributes: (tools, body) => tools.getAttributes(body.instancePath),
+  delete_attribute: (tools, body) => tools.deleteAttribute(body.instancePath, body.attributeName),
+  get_tags: (tools, body) => tools.getTags(body.instancePath),
+  add_tag: (tools, body) => tools.addTag(body.instancePath, body.tagName),
+  remove_tag: (tools, body) => tools.removeTag(body.instancePath, body.tagName),
+  get_tagged: (tools, body) => tools.getTagged(body.tagName),
+  get_selection: (tools) => tools.getSelection(),
+  execute_luau: (tools, body) => tools.executeLuau(body.code),
+  start_playtest: (tools, body) => tools.startPlaytest(body.mode),
+  stop_playtest: (tools) => tools.stopPlaytest(),
+  get_playtest_output: (tools) => tools.getPlaytestOutput(),
+  export_build: (tools, body) => tools.exportBuild(body.instancePath, body.outputId, body.style),
+  create_build: (tools, body) => tools.createBuild(body.id, body.style, body.palette, body.parts, body.bounds),
+  generate_build: (tools, body) => tools.generateBuild(body.id, body.style, body.palette, body.code, body.seed),
+  import_build: (tools, body) => tools.importBuild(body.buildData, body.targetPath, body.position),
+  list_library: (tools, body) => tools.listLibrary(body.style),
+  search_materials: (tools, body) => tools.searchMaterials(body.query, body.maxResults),
+  get_build: (tools, body) => tools.getBuild(body.id),
+  import_scene: (tools, body) => tools.importScene(body.sceneData, body.targetPath),
+  undo: (tools) => tools.undo(),
+  redo: (tools) => tools.redo(),
+  search_assets: (tools, body) => tools.searchAssets(body.assetType, body.query, body.maxResults, body.sortBy, body.verifiedCreatorsOnly),
+  get_asset_details: (tools, body) => tools.getAssetDetails(body.assetId),
+  get_asset_thumbnail: (tools, body) => tools.getAssetThumbnail(body.assetId, body.size),
+  insert_asset: (tools, body) => tools.insertAsset(body.assetId, body.parentPath, body.position),
+  preview_asset: (tools, body) => tools.previewAsset(body.assetId, body.includeProperties, body.maxDepth)
+};
+function createHttpServer(tools, bridge, allowedTools) {
+  const app = express();
+  let pluginConnected = false;
+  let mcpServerActive = false;
+  let lastMCPActivity = 0;
+  let mcpServerStartTime = 0;
+  let lastPluginActivity = 0;
+  const proxyInstances = /* @__PURE__ */ new Set();
+  const setMCPServerActive = (active) => {
+    mcpServerActive = active;
+    if (active) {
+      mcpServerStartTime = Date.now();
+      lastMCPActivity = Date.now();
+    } else {
+      mcpServerStartTime = 0;
+      lastMCPActivity = 0;
+    }
+  };
+  const trackMCPActivity = () => {
+    if (mcpServerActive) {
+      lastMCPActivity = Date.now();
+    }
+  };
+  const isMCPServerActive = () => {
+    if (!mcpServerActive)
+      return false;
+    return Date.now() - lastMCPActivity < 3e4;
+  };
+  const isPluginConnected = () => {
+    return pluginConnected && Date.now() - lastPluginActivity < 3e4;
+  };
+  app.use(cors());
+  app.use(express.json({ limit: "50mb" }));
+  app.use(express.urlencoded({ limit: "50mb", extended: true }));
+  app.get("/health", (req, res) => {
+    res.json({
+      status: "ok",
+      service: "robloxstudio-mcp",
+      pluginConnected,
+      mcpServerActive: isMCPServerActive(),
+      uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
+      proxyInstanceCount: proxyInstances.size
+    });
+  });
+  app.post("/ready", (req, res) => {
+    pluginConnected = true;
+    lastPluginActivity = Date.now();
+    res.json({ success: true });
+  });
+  app.post("/disconnect", (req, res) => {
+    pluginConnected = false;
+    bridge.clearAllPendingRequests();
+    res.json({ success: true });
+  });
+  app.get("/status", (req, res) => {
+    res.json({
+      pluginConnected: isPluginConnected(),
+      mcpServerActive: isMCPServerActive(),
+      lastMCPActivity,
+      uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0
+    });
+  });
+  app.get("/poll", (req, res) => {
+    if (!pluginConnected) {
+      pluginConnected = true;
+    }
+    lastPluginActivity = Date.now();
+    if (!isMCPServerActive()) {
+      res.status(503).json({
+        error: "MCP server not connected",
+        pluginConnected: true,
+        mcpConnected: false,
+        request: null
+      });
+      return;
+    }
+    const pendingRequest = bridge.getPendingRequest();
+    if (pendingRequest) {
+      res.json({
+        request: pendingRequest.request,
+        requestId: pendingRequest.requestId,
+        mcpConnected: true,
+        pluginConnected: true,
+        proxyInstanceCount: proxyInstances.size
+      });
+    } else {
+      res.json({
+        request: null,
+        mcpConnected: true,
+        pluginConnected: true,
+        proxyInstanceCount: proxyInstances.size
+      });
+    }
+  });
+  app.post("/response", (req, res) => {
+    const { requestId, response, error } = req.body;
+    if (error) {
+      bridge.rejectRequest(requestId, error);
+    } else {
+      bridge.resolveRequest(requestId, response);
+    }
+    res.json({ success: true });
+  });
+  app.post("/proxy", async (req, res) => {
+    const { endpoint, data, proxyInstanceId } = req.body;
+    if (!endpoint) {
+      res.status(400).json({ error: "endpoint is required" });
+      return;
+    }
+    if (proxyInstanceId) {
+      proxyInstances.add(proxyInstanceId);
+    }
+    try {
+      const response = await bridge.sendRequest(endpoint, data);
+      res.json({ response });
+    } catch (err) {
+      res.status(500).json({ error: err.message || "Proxy request failed" });
+    }
+  });
+  app.use("/mcp/*", (req, res, next) => {
+    trackMCPActivity();
+    next();
+  });
+  for (const [toolName, handler] of Object.entries(TOOL_HANDLERS)) {
+    if (allowedTools && !allowedTools.has(toolName))
+      continue;
+    app.post(`/mcp/${toolName}`, async (req, res) => {
+      try {
+        const result = await handler(tools, req.body);
+        res.json(result);
+      } catch (error) {
+        res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
+      }
+    });
+  }
+  app.isPluginConnected = isPluginConnected;
+  app.setMCPServerActive = setMCPServerActive;
+  app.isMCPServerActive = isMCPServerActive;
+  app.trackMCPActivity = trackMCPActivity;
+  return app;
+}
+function listenWithRetry(app, host, startPort, maxAttempts = 5) {
+  return new Promise(async (resolve, reject) => {
+    for (let i = 0; i < maxAttempts; i++) {
+      const port = startPort + i;
+      try {
+        const server2 = await bindPort(app, host, port);
+        resolve({ server: server2, port });
+        return;
+      } catch (err) {
+        if (err.code === "EADDRINUSE") {
+          console.error(`Port ${port} in use, trying next...`);
+          continue;
+        }
+        reject(err);
+        return;
+      }
+    }
+    reject(new Error(`All ports ${startPort}-${startPort + maxAttempts - 1} are in use. Stop some MCP server instances and retry.`));
+  });
+}
+function bindPort(app, host, port) {
+  return new Promise((resolve, reject) => {
+    const server2 = http.createServer(app);
+    const onError = (err) => {
+      server2.removeListener("error", onError);
+      reject(err);
+    };
+    server2.once("error", onError);
+    server2.listen(port, host, () => {
+      server2.removeListener("error", onError);
+      resolve(server2);
+    });
+  });
+}
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/tools/studio-client.js
+var StudioHttpClient = class {
+  bridge;
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+  async request(endpoint, data) {
+    try {
+      const response = await this.bridge.sendRequest(endpoint, data);
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.message === "Request timeout") {
+        throw new Error("Studio plugin connection timeout. Make sure the Roblox Studio plugin is running and activated.");
+      }
+      throw error;
+    }
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/tools/build-executor.js
+import * as vm from "vm";
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_MAX_PARTS = 1e4;
+var VALID_SHAPES = /* @__PURE__ */ new Set(["Block", "Wedge", "Cylinder", "Ball", "CornerWedge"]);
+function createSeededRng(seed) {
+  let s = seed;
+  return () => {
+    s = s * 1664525 + 1013904223 & 4294967295;
+    return (s >>> 0) / 4294967296;
+  };
+}
+function computeBoundsFromParts(parts) {
+  let maxX = 0, maxY = 0, maxZ = 0;
+  for (const p of parts) {
+    const px = Math.abs(p[0]) + p[3] / 2;
+    const py = Math.abs(p[1]) + p[4] / 2;
+    const pz = Math.abs(p[2]) + p[5] / 2;
+    maxX = Math.max(maxX, px);
+    maxY = Math.max(maxY, py);
+    maxZ = Math.max(maxZ, pz);
+  }
+  return [
+    Math.round(maxX * 2 * 10) / 10,
+    Math.round(maxY * 2 * 10) / 10,
+    Math.round(maxZ * 2 * 10) / 10
+  ];
+}
+function runBuildExecutor(code, palette, seed, options) {
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+  const maxParts = options?.maxParts ?? DEFAULT_MAX_PARTS;
+  const paletteKeys = new Set(Object.keys(palette));
+  const parts = [];
+  function checkLimit() {
+    if (parts.length >= maxParts) {
+      throw new Error(`Part limit exceeded: max ${maxParts} parts allowed`);
+    }
+  }
+  function validateKey(key, fnName) {
+    if (!paletteKeys.has(key)) {
+      throw new Error(`${fnName}: palette key "${key}" not found. Available keys: ${[...paletteKeys].join(", ")}`);
+    }
+  }
+  function validateNumber(val, name) {
+    if (typeof val !== "number" || !isFinite(val)) {
+      throw new Error(`${name} must be a finite number, got ${val}`);
+    }
+  }
+  function partFn(x, y, z, sx, sy, sz, key, shape, transparency) {
+    validateNumber(x, "part x");
+    validateNumber(y, "part y");
+    validateNumber(z, "part z");
+    validateNumber(sx, "part sx");
+    validateNumber(sy, "part sy");
+    validateNumber(sz, "part sz");
+    validateKey(key, "part");
+    if (shape !== void 0 && !VALID_SHAPES.has(shape)) {
+      throw new Error(`part: invalid shape "${shape}". Valid: ${[...VALID_SHAPES].join(", ")}`);
+    }
+    checkLimit();
+    const entry = [x, y, z, sx, sy, sz, 0, 0, 0, key];
+    if (shape !== void 0)
+      entry.push(shape);
+    if (transparency !== void 0)
+      entry.push(transparency);
+    parts.push(entry);
+  }
+  function rpartFn(x, y, z, sx, sy, sz, rx, ry, rz, key, shape, transparency) {
+    validateNumber(x, "rpart x");
+    validateNumber(y, "rpart y");
+    validateNumber(z, "rpart z");
+    validateNumber(sx, "rpart sx");
+    validateNumber(sy, "rpart sy");
+    validateNumber(sz, "rpart sz");
+    validateNumber(rx, "rpart rx");
+    validateNumber(ry, "rpart ry");
+    validateNumber(rz, "rpart rz");
+    validateKey(key, "rpart");
+    if (shape !== void 0 && !VALID_SHAPES.has(shape)) {
+      throw new Error(`rpart: invalid shape "${shape}". Valid: ${[...VALID_SHAPES].join(", ")}`);
+    }
+    checkLimit();
+    const entry = [x, y, z, sx, sy, sz, rx, ry, rz, key];
+    if (shape !== void 0)
+      entry.push(shape);
+    if (transparency !== void 0)
+      entry.push(transparency);
+    parts.push(entry);
+  }
+  function fillFn(x1, y1, z1, x2, y2, z2, key, unitSize) {
+    validateKey(key, "fill");
+    [x1, y1, z1, x2, y2, z2].forEach((v, i) => validateNumber(v, `fill arg${i}`));
+    if (!unitSize) {
+      const cx = (x1 + x2) / 2;
+      const cy = (y1 + y2) / 2;
+      const cz = (z1 + z2) / 2;
+      const sx = Math.abs(x2 - x1);
+      const sy = Math.abs(y2 - y1);
+      const sz = Math.abs(z2 - z1);
+      checkLimit();
+      parts.push([cx, cy, cz, sx, sy, sz, 0, 0, 0, key]);
+    } else {
+      const [ux, uy, uz] = unitSize;
+      validateNumber(ux, "fill unitSize[0]");
+      validateNumber(uy, "fill unitSize[1]");
+      validateNumber(uz, "fill unitSize[2]");
+      const minX = Math.min(x1, x2);
+      const minY = Math.min(y1, y2);
+      const minZ = Math.min(z1, z2);
+      const maxX = Math.max(x1, x2);
+      const maxY = Math.max(y1, y2);
+      const maxZ = Math.max(z1, z2);
+      for (let x = minX + ux / 2; x < maxX; x += ux) {
+        for (let y = minY + uy / 2; y < maxY; y += uy) {
+          for (let z = minZ + uz / 2; z < maxZ; z += uz) {
+            checkLimit();
+            parts.push([
+              Math.round(x * 1e3) / 1e3,
+              Math.round(y * 1e3) / 1e3,
+              Math.round(z * 1e3) / 1e3,
+              ux,
+              uy,
+              uz,
+              0,
+              0,
+              0,
+              key
+            ]);
+          }
+        }
+      }
+    }
+  }
+  function beamFn(x1, y1, z1, x2, y2, z2, thickness, key) {
+    validateKey(key, "beam");
+    [x1, y1, z1, x2, y2, z2, thickness].forEach((v, i) => validateNumber(v, `beam arg${i}`));
+    const cx = (x1 + x2) / 2;
+    const cy = (y1 + y2) / 2;
+    const cz = (z1 + z2) / 2;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const dz = z2 - z1;
+    const length = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    const ry = Math.atan2(dx, dz) * (180 / Math.PI);
+    const horizontalDist = Math.sqrt(dx * dx + dz * dz);
+    const rx = -Math.atan2(dy, horizontalDist) * (180 / Math.PI);
+    checkLimit();
+    parts.push([
+      Math.round(cx * 1e3) / 1e3,
+      Math.round(cy * 1e3) / 1e3,
+      Math.round(cz * 1e3) / 1e3,
+      thickness,
+      thickness,
+      Math.round(length * 1e3) / 1e3,
+      Math.round(rx * 100) / 100,
+      Math.round(ry * 100) / 100,
+      0,
+      key
+    ]);
+  }
+  function wallFn(x1, z1, x2, z2, height, thickness, key) {
+    validateKey(key, "wall");
+    [x1, z1, x2, z2, height, thickness].forEach((v, i) => validateNumber(v, `wall arg${i}`));
+    const cx = (x1 + x2) / 2;
+    const cz = (z1 + z2) / 2;
+    const cy = height / 2;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const wallLength = Math.sqrt(dx * dx + dz * dz);
+    const ry = Math.atan2(dx, dz) * (180 / Math.PI);
+    checkLimit();
+    parts.push([
+      Math.round(cx * 1e3) / 1e3,
+      Math.round(cy * 1e3) / 1e3,
+      Math.round(cz * 1e3) / 1e3,
+      thickness,
+      height,
+      Math.round(wallLength * 1e3) / 1e3,
+      0,
+      Math.round(ry * 100) / 100,
+      0,
+      key
+    ]);
+  }
+  function floorFn(x1, z1, x2, z2, y, thickness, key) {
+    validateKey(key, "floor");
+    [x1, z1, x2, z2, y, thickness].forEach((v, i) => validateNumber(v, `floor arg${i}`));
+    const cx = (x1 + x2) / 2;
+    const cz = (z1 + z2) / 2;
+    const sx = Math.abs(x2 - x1);
+    const sz = Math.abs(z2 - z1);
+    checkLimit();
+    parts.push([
+      Math.round(cx * 1e3) / 1e3,
+      y,
+      Math.round(cz * 1e3) / 1e3,
+      sx,
+      thickness,
+      sz,
+      0,
+      0,
+      0,
+      key
+    ]);
+  }
+  function rowFn(x, y, z, count, spacingX, spacingZ, partFnCb) {
+    validateNumber(x, "row x");
+    validateNumber(y, "row y");
+    validateNumber(z, "row z");
+    validateNumber(count, "row count");
+    validateNumber(spacingX, "row spacingX");
+    validateNumber(spacingZ, "row spacingZ");
+    if (typeof partFnCb !== "function") {
+      throw new Error("row: partFn must be a function");
+    }
+    for (let i = 0; i < count; i++) {
+      partFnCb(i, x + i * spacingX, y, z + i * spacingZ);
+    }
+  }
+  function gridFn(x, y, z, countX, countZ, spacingX, spacingZ, partFnCb) {
+    validateNumber(x, "grid x");
+    validateNumber(y, "grid y");
+    validateNumber(z, "grid z");
+    validateNumber(countX, "grid countX");
+    validateNumber(countZ, "grid countZ");
+    validateNumber(spacingX, "grid spacingX");
+    validateNumber(spacingZ, "grid spacingZ");
+    if (typeof partFnCb !== "function") {
+      throw new Error("grid: partFn must be a function");
+    }
+    for (let ix = 0; ix < countX; ix++) {
+      for (let iz = 0; iz < countZ; iz++) {
+        partFnCb(ix, iz, x + ix * spacingX, y, z + iz * spacingZ);
+      }
+    }
+  }
+  function roomFn(x, y, z, w, h, d, wallKey, floorKey, ceilKey, wallThickness) {
+    const t = wallThickness ?? 1;
+    const fk = floorKey ?? wallKey;
+    const ck = ceilKey ?? wallKey;
+    floorFn(x - w / 2, z - d / 2, x + w / 2, z + d / 2, y, t, fk);
+    floorFn(x - w / 2, z - d / 2, x + w / 2, z + d / 2, y + h, t, ck);
+    wallFn(x - w / 2, z - d / 2, x - w / 2, z + d / 2, h, t, wallKey);
+    wallFn(x + w / 2, z - d / 2, x + w / 2, z + d / 2, h, t, wallKey);
+    wallFn(x - w / 2, z - d / 2, x + w / 2, z - d / 2, h, t, wallKey);
+    wallFn(x - w / 2, z + d / 2, x + w / 2, z + d / 2, h, t, wallKey);
+  }
+  function roofFn(x, y, z, w, d, style, key, overhang) {
+    const oh = overhang ?? 1;
+    validateKey(key, "roof");
+    if (style === "flat") {
+      floorFn(x - w / 2 - oh, z - d / 2 - oh, x + w / 2 + oh, z + d / 2 + oh, y, 1, key);
+    } else if (style === "gable") {
+      const peakH = w / 2 * 0.6;
+      const slopeW = Math.sqrt((w / 2 + oh) * (w / 2 + oh) + peakH * peakH);
+      const angle = Math.atan2(peakH, w / 2 + oh) * (180 / Math.PI);
+      rpartFn(x - (w / 4 + oh / 2) * 0.5, y + peakH / 2, z, slopeW, 0.5, d + oh * 2, -angle, 0, 0, key);
+      rpartFn(x + (w / 4 + oh / 2) * 0.5, y + peakH / 2, z, slopeW, 0.5, d + oh * 2, angle, 0, 0, key);
+    } else if (style === "hip") {
+      const peakH = w / 3;
+      floorFn(x - w / 4, z - d / 4, x + w / 4, z + d / 4, y + peakH, 0.5, key);
+      const slopeW = Math.sqrt((w / 2 + oh) * (w / 2 + oh) + peakH * peakH);
+      const angle = Math.atan2(peakH, w / 2 + oh) * (180 / Math.PI);
+      rpartFn(x - w / 4, y + peakH / 2, z, slopeW * 0.6, 0.5, d + oh, -angle, 0, 0, key);
+      rpartFn(x + w / 4, y + peakH / 2, z, slopeW * 0.6, 0.5, d + oh, angle, 0, 0, key);
+    }
+  }
+  function stairsFn(x1, y1, z1, x2, y2, z2, w, key) {
+    validateKey(key, "stairs");
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const dz = z2 - z1;
+    const dist = Math.sqrt(dx * dx + dz * dz);
+    const stepCount = Math.max(2, Math.round(Math.abs(dy) / 0.5));
+    const stepH = dy / stepCount;
+    const stepDx = dx / stepCount;
+    const stepDz = dz / stepCount;
+    for (let i = 0; i < stepCount; i++) {
+      checkLimit();
+      const sx = x1 + stepDx * (i + 0.5);
+      const sy = y1 + stepH * (i + 0.5);
+      const sz = z1 + stepDz * (i + 0.5);
+      const stepDepth = dist / stepCount;
+      partFn(Math.round(sx * 100) / 100, Math.round(sy * 100) / 100, Math.round(sz * 100) / 100, w, Math.abs(stepH), stepDepth, key);
+    }
+  }
+  function archFn(x, y, z, w, h, thickness, key, segments) {
+    validateKey(key, "arch");
+    const segs = segments ?? 8;
+    const radius = w / 2;
+    const archH = h - radius;
+    if (archH > 0) {
+      partFn(x - w / 2, y + archH / 2, z, thickness, archH, thickness, key);
+      partFn(x + w / 2, y + archH / 2, z, thickness, archH, thickness, key);
+    }
+    for (let i = 0; i < segs; i++) {
+      const a1 = Math.PI / segs * i;
+      const a2 = Math.PI / segs * (i + 1);
+      const mx = x + radius * Math.cos((a1 + a2) / 2 + Math.PI / 2);
+      const my = y + archH + radius * Math.sin((a1 + a2) / 2 + Math.PI / 2) * (radius / (radius || 1));
+      checkLimit();
+      const segLen = 2 * radius * Math.sin((a2 - a1) / 2);
+      const angle = (a1 + a2) / 2 * (180 / Math.PI);
+      rpartFn(Math.round(mx * 100) / 100, Math.round(my * 100) / 100, z, segLen, thickness, thickness, 0, 0, Math.round(angle * 100) / 100, key);
+    }
+  }
+  function columnFn(x, y, z, height, radius, key, capKey) {
+    validateKey(key, "column");
+    rpartFn(x, y + height / 2, z, height, radius * 2, radius * 2, 0, 0, 90, key, "Cylinder");
+    const ck = capKey ?? key;
+    validateKey(ck, "column cap");
+    partFn(x, y + 0.25, z, radius * 2.5, 0.5, radius * 2.5, ck);
+    partFn(x, y + height - 0.25, z, radius * 2.5, 0.5, radius * 2.5, ck);
+  }
+  function pewFn(x, y, z, w, d, seatKey, legKey) {
+    validateKey(seatKey, "pew");
+    const lk = legKey ?? seatKey;
+    validateKey(lk, "pew legs");
+    partFn(x, y + 1.5, z, w, 0.3, d, seatKey);
+    partFn(x, y + 2.5, z - d / 2 + 0.15, w, 2, 0.3, seatKey);
+    partFn(x - w / 2 + 0.25, y + 0.75, z, 0.5, 1.5, d, lk);
+    partFn(x + w / 2 - 0.25, y + 0.75, z, 0.5, 1.5, d, lk);
+  }
+  function fenceFn(x1, z1, x2, z2, y, key, postSpacing) {
+    validateKey(key, "fence");
+    const spacing = postSpacing ?? 4;
+    const dx = x2 - x1;
+    const dz = z2 - z1;
+    const length = Math.sqrt(dx * dx + dz * dz);
+    const count = Math.max(2, Math.round(length / spacing) + 1);
+    for (let i = 0; i < count; i++) {
+      const t = i / (count - 1);
+      checkLimit();
+      partFn(x1 + dx * t, y + 1.5, z1 + dz * t, 0.5, 3, 0.5, key);
+    }
+    wallFn(x1, z1, x2, z2, 1, 0.3, key);
+    const cx = (x1 + x2) / 2;
+    const cz = (z1 + z2) / 2;
+    const ry = Math.atan2(dx, dz) * (180 / Math.PI);
+    checkLimit();
+    parts.push([
+      Math.round(cx * 1e3) / 1e3,
+      y + 2.5,
+      Math.round(cz * 1e3) / 1e3,
+      0.3,
+      0.3,
+      Math.round(length * 1e3) / 1e3,
+      0,
+      Math.round(ry * 100) / 100,
+      0,
+      key
+    ]);
+  }
+  const rng = createSeededRng(seed ?? 42);
+  const sandbox = {
+    part: partFn,
+    rpart: rpartFn,
+    fill: fillFn,
+    beam: beamFn,
+    wall: wallFn,
+    floor: floorFn,
+    row: rowFn,
+    grid: gridFn,
+    room: roomFn,
+    roof: roofFn,
+    stairs: stairsFn,
+    arch: archFn,
+    column: columnFn,
+    pew: pewFn,
+    fence: fenceFn,
+    Math,
+    GRID_SIZE: 1,
+    rng,
+    console: { log: () => {
+    }, warn: () => {
+    }, error: () => {
+    } }
+  };
+  const context = vm.createContext(sandbox, {
+    codeGeneration: { strings: false, wasm: false }
+  });
+  const script = new vm.Script(code, { filename: "build-generator.js" });
+  try {
+    script.runInContext(context, { timeout });
+  } catch (err) {
+    if (err.code === "ERR_SCRIPT_EXECUTION_TIMEOUT") {
+      throw new Error(`Build code execution timed out after ${timeout}ms`);
+    }
+    throw new Error(`Build code execution error: ${err.message}`);
+  }
+  if (parts.length === 0) {
+    throw new Error("Build code produced no parts. Make sure to call part(), wall(), floor(), etc.");
+  }
+  const bounds = computeBoundsFromParts(parts);
+  return { parts, bounds, partCount: parts.length };
+}
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/opencloud-client.js
+var OpenCloudClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey || process.env.ROBLOX_OPEN_CLOUD_API_KEY || "";
+    this.baseUrl = config.baseUrl || "https://apis.roblox.com";
+    this.timeout = config.timeout || 3e4;
+  }
+  hasApiKey() {
+    return !!this.apiKey;
+  }
+  async request(endpoint, options = {}) {
+    if (!this.apiKey) {
+      throw new Error("Open Cloud API key not configured. Set ROBLOX_OPEN_CLOUD_API_KEY environment variable.");
+    }
+    const { method = "GET", params, body } = options;
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers: {
+          "x-api-key": this.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorBody);
+          errorMessage = errorJson.detail || errorJson.message || errorBody;
+        } catch {
+          errorMessage = errorBody;
+        }
+        if (response.status === 401) {
+          throw new Error("Invalid or expired API key");
+        } else if (response.status === 403) {
+          throw new Error(`API key lacks required permissions: ${errorMessage}`);
+        } else if (response.status === 429) {
+          throw new Error("Rate limit exceeded. Please try again later.");
+        } else {
+          throw new Error(`Open Cloud API error (${response.status}): ${errorMessage}`);
+        }
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new Error("Request timed out");
+        }
+        throw error;
+      }
+      throw new Error(`Unknown error: ${String(error)}`);
+    }
+  }
+  async searchAssets(params) {
+    return this.request("/toolbox-service/v2/assets:search", {
+      params: {
+        searchCategoryType: params.searchCategoryType,
+        query: params.query,
+        pageToken: params.pageToken,
+        pageNumber: params.pageNumber,
+        maxPageSize: params.maxPageSize || 25,
+        sortDirection: params.sortDirection,
+        sortCategory: params.sortCategory,
+        includeOnlyVerifiedCreators: params.includeOnlyVerifiedCreators,
+        userId: params.userId,
+        groupId: params.groupId
+      }
+    });
+  }
+  async getAssetDetails(assetId) {
+    return this.request(`/toolbox-service/v2/assets/${assetId}`);
+  }
+  async getAssetThumbnail(assetId, size = "420x420") {
+    const url = `https://thumbnails.roblox.com/v1/assets?assetIds=${assetId}&size=${size}&format=Png`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok)
+        return null;
+      const data = await response.json();
+      const thumbnail = data.data[0];
+      if (!thumbnail || thumbnail.state !== "Completed" || !thumbnail.imageUrl) {
+        return null;
+      }
+      const imageResponse = await fetch(thumbnail.imageUrl);
+      if (!imageResponse.ok)
+        return null;
+      const arrayBuffer = await imageResponse.arrayBuffer();
+      const base64 = Buffer.from(arrayBuffer).toString("base64");
+      return { base64, mimeType: "image/png" };
+    } catch {
+      return null;
+    }
+  }
+  async getAssetThumbnails(assetIds, size = "420x420") {
+    const result = /* @__PURE__ */ new Map();
+    if (assetIds.length === 0)
+      return result;
+    const batches = [];
+    for (let i = 0; i < assetIds.length; i += 100) {
+      batches.push(assetIds.slice(i, i + 100));
+    }
+    for (const batch of batches) {
+      const url = `https://thumbnails.roblox.com/v1/assets?assetIds=${batch.join(",")}&size=${size}&format=Png`;
+      try {
+        const response = await fetch(url);
+        if (response.ok) {
+          const data = await response.json();
+          for (const thumbnail of data.data) {
+            if (thumbnail.state === "Completed" && thumbnail.imageUrl) {
+              result.set(thumbnail.targetId, thumbnail.imageUrl);
             }
-        });
-    }
-    async run() {
-        const basePort = process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741;
-        const maxPort = basePort + 4;
-        const host = process.env.ROBLOX_STUDIO_HOST || '0.0.0.0';
-        const httpServer = createHttpServer(this.tools, this.bridge);
-        let boundPort = 0;
-        for (let port = basePort; port <= maxPort; port++) {
-            try {
-                await new Promise((resolve, reject) => {
-                    const onError = (err) => {
-                        if (err.code === 'EADDRINUSE') {
-                            httpServer.removeListener('error', onError);
-                            reject(err);
-                        }
-                        else {
-                            reject(err);
-                        }
-                    };
-                    httpServer.once('error', onError);
-                    httpServer.listen(port, host, () => {
-                        httpServer.removeListener('error', onError);
-                        boundPort = port;
-                        console.error(`HTTP server listening on ${host}:${port} for Studio plugin`);
-                        resolve();
-                    });
-                });
-                break;
+          }
+        }
+      } catch {
+      }
+    }
+    return result;
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/tools/index.js
+import * as fs from "fs";
+import * as path from "path";
+var RobloxStudioTools = class _RobloxStudioTools {
+  client;
+  openCloudClient;
+  constructor(bridge) {
+    this.client = new StudioHttpClient(bridge);
+    this.openCloudClient = new OpenCloudClient();
+  }
+  async getFileTree(path2 = "") {
+    const response = await this.client.request("/api/file-tree", { path: path2 });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async searchFiles(query, searchType = "name") {
+    const response = await this.client.request("/api/search-files", { query, searchType });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getPlaceInfo() {
+    const response = await this.client.request("/api/place-info", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getServices(serviceName) {
+    const response = await this.client.request("/api/services", { serviceName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async searchObjects(query, searchType = "name", propertyName) {
+    const response = await this.client.request("/api/search-objects", {
+      query,
+      searchType,
+      propertyName
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getInstanceProperties(instancePath, excludeSource) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for get_instance_properties");
+    }
+    const response = await this.client.request("/api/instance-properties", { instancePath, excludeSource });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getInstanceChildren(instancePath) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for get_instance_children");
+    }
+    const response = await this.client.request("/api/instance-children", { instancePath });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async searchByProperty(propertyName, propertyValue) {
+    if (!propertyName || !propertyValue) {
+      throw new Error("Property name and value are required for search_by_property");
+    }
+    const response = await this.client.request("/api/search-by-property", {
+      propertyName,
+      propertyValue
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getClassInfo(className) {
+    if (!className) {
+      throw new Error("Class name is required for get_class_info");
+    }
+    const response = await this.client.request("/api/class-info", { className });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getProjectStructure(path2, maxDepth, scriptsOnly) {
+    const response = await this.client.request("/api/project-structure", {
+      path: path2,
+      maxDepth,
+      scriptsOnly
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async setProperty(instancePath, propertyName, propertyValue) {
+    if (!instancePath || !propertyName) {
+      throw new Error("Instance path and property name are required for set_property");
+    }
+    const response = await this.client.request("/api/set-property", {
+      instancePath,
+      propertyName,
+      propertyValue
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async massSetProperty(paths, propertyName, propertyValue) {
+    if (!paths || paths.length === 0 || !propertyName) {
+      throw new Error("Paths array and property name are required for mass_set_property");
+    }
+    const response = await this.client.request("/api/mass-set-property", {
+      paths,
+      propertyName,
+      propertyValue
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async massGetProperty(paths, propertyName) {
+    if (!paths || paths.length === 0 || !propertyName) {
+      throw new Error("Paths array and property name are required for mass_get_property");
+    }
+    const response = await this.client.request("/api/mass-get-property", {
+      paths,
+      propertyName
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async createObject(className, parent, name, properties) {
+    if (!className || !parent) {
+      throw new Error("Class name and parent are required for create_object");
+    }
+    const response = await this.client.request("/api/create-object", {
+      className,
+      parent,
+      name,
+      properties
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async massCreateObjects(objects) {
+    if (!objects || objects.length === 0) {
+      throw new Error("Objects array is required for mass_create_objects");
+    }
+    const hasProperties = objects.some((o) => o.properties && Object.keys(o.properties).length > 0);
+    const endpoint = hasProperties ? "/api/mass-create-objects-with-properties" : "/api/mass-create-objects";
+    const response = await this.client.request(endpoint, { objects });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async deleteObject(instancePath) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for delete_object");
+    }
+    const response = await this.client.request("/api/delete-object", { instancePath });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async smartDuplicate(instancePath, count, options) {
+    if (!instancePath || count < 1) {
+      throw new Error("Instance path and count > 0 are required for smart_duplicate");
+    }
+    const response = await this.client.request("/api/smart-duplicate", {
+      instancePath,
+      count,
+      options
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async massDuplicate(duplications) {
+    if (!duplications || duplications.length === 0) {
+      throw new Error("Duplications array is required for mass_duplicate");
+    }
+    const response = await this.client.request("/api/mass-duplicate", { duplications });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async setCalculatedProperty(paths, propertyName, formula, variables) {
+    if (!paths || paths.length === 0 || !propertyName || !formula) {
+      throw new Error("Paths, property name, and formula are required for set_calculated_property");
+    }
+    const response = await this.client.request("/api/set-calculated-property", {
+      paths,
+      propertyName,
+      formula,
+      variables
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async setRelativeProperty(paths, propertyName, operation, value, component) {
+    if (!paths || paths.length === 0 || !propertyName || !operation || value === void 0) {
+      throw new Error("Paths, property name, operation, and value are required for set_relative_property");
+    }
+    const response = await this.client.request("/api/set-relative-property", {
+      paths,
+      propertyName,
+      operation,
+      value,
+      component
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getScriptSource(instancePath, startLine, endLine) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for get_script_source");
+    }
+    const response = await this.client.request("/api/get-script-source", { instancePath, startLine, endLine });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async setScriptSource(instancePath, source) {
+    if (!instancePath || typeof source !== "string") {
+      throw new Error("Instance path and source code string are required for set_script_source");
+    }
+    const response = await this.client.request("/api/set-script-source", { instancePath, source });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async editScriptLines(instancePath, startLine, endLine, newContent) {
+    if (!instancePath || !startLine || !endLine || typeof newContent !== "string") {
+      throw new Error("Instance path, startLine, endLine, and newContent are required for edit_script_lines");
+    }
+    const response = await this.client.request("/api/edit-script-lines", { instancePath, startLine, endLine, newContent });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async insertScriptLines(instancePath, afterLine, newContent) {
+    if (!instancePath || typeof newContent !== "string") {
+      throw new Error("Instance path and newContent are required for insert_script_lines");
+    }
+    const response = await this.client.request("/api/insert-script-lines", { instancePath, afterLine: afterLine || 0, newContent });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async deleteScriptLines(instancePath, startLine, endLine) {
+    if (!instancePath || !startLine || !endLine) {
+      throw new Error("Instance path, startLine, and endLine are required for delete_script_lines");
+    }
+    const response = await this.client.request("/api/delete-script-lines", { instancePath, startLine, endLine });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async grepScripts(pattern, options) {
+    if (!pattern) {
+      throw new Error("Pattern is required for grep_scripts");
+    }
+    const response = await this.client.request("/api/grep-scripts", {
+      pattern,
+      ...options
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getAttribute(instancePath, attributeName) {
+    if (!instancePath || !attributeName) {
+      throw new Error("Instance path and attribute name are required for get_attribute");
+    }
+    const response = await this.client.request("/api/get-attribute", { instancePath, attributeName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async setAttribute(instancePath, attributeName, attributeValue, valueType) {
+    if (!instancePath || !attributeName) {
+      throw new Error("Instance path and attribute name are required for set_attribute");
+    }
+    const response = await this.client.request("/api/set-attribute", { instancePath, attributeName, attributeValue, valueType });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getAttributes(instancePath) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for get_attributes");
+    }
+    const response = await this.client.request("/api/get-attributes", { instancePath });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async deleteAttribute(instancePath, attributeName) {
+    if (!instancePath || !attributeName) {
+      throw new Error("Instance path and attribute name are required for delete_attribute");
+    }
+    const response = await this.client.request("/api/delete-attribute", { instancePath, attributeName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getTags(instancePath) {
+    if (!instancePath) {
+      throw new Error("Instance path is required for get_tags");
+    }
+    const response = await this.client.request("/api/get-tags", { instancePath });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async addTag(instancePath, tagName) {
+    if (!instancePath || !tagName) {
+      throw new Error("Instance path and tag name are required for add_tag");
+    }
+    const response = await this.client.request("/api/add-tag", { instancePath, tagName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async removeTag(instancePath, tagName) {
+    if (!instancePath || !tagName) {
+      throw new Error("Instance path and tag name are required for remove_tag");
+    }
+    const response = await this.client.request("/api/remove-tag", { instancePath, tagName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getTagged(tagName) {
+    if (!tagName) {
+      throw new Error("Tag name is required for get_tagged");
+    }
+    const response = await this.client.request("/api/get-tagged", { tagName });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getSelection() {
+    const response = await this.client.request("/api/get-selection", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async executeLuau(code) {
+    if (!code) {
+      throw new Error("Code is required for execute_luau");
+    }
+    const response = await this.client.request("/api/execute-luau", { code });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async startPlaytest(mode) {
+    if (mode !== "play" && mode !== "run") {
+      throw new Error('mode must be "play" or "run"');
+    }
+    const response = await this.client.request("/api/start-playtest", { mode });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async stopPlaytest() {
+    const response = await this.client.request("/api/stop-playtest", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getPlaytestOutput() {
+    const response = await this.client.request("/api/get-playtest-output", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async undo() {
+    const response = await this.client.request("/api/undo", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async redo() {
+    const response = await this.client.request("/api/redo", {});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  static findLibraryPath() {
+    let dir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
+    for (let i = 0; i < 6; i++) {
+      const candidate = path.join(dir, "build-library");
+      if (fs.existsSync(candidate))
+        return candidate;
+      dir = path.dirname(dir);
+    }
+    const fallback = path.join(dir, "build-library");
+    fs.mkdirSync(fallback, { recursive: true });
+    return fallback;
+  }
+  static LIBRARY_PATH = _RobloxStudioTools.findLibraryPath();
+  async exportBuild(instancePath, outputId, style = "misc") {
+    if (!instancePath) {
+      throw new Error("Instance path is required for export_build");
+    }
+    const response = await this.client.request("/api/export-build", {
+      instancePath,
+      outputId,
+      style
+    });
+    if (response && response.success && response.buildData) {
+      const buildData = response.buildData;
+      const buildId = buildData.id || `${style}/exported`;
+      const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${buildId}.json`);
+      const dirPath = path.dirname(filePath);
+      if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+      }
+      fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+      response.savedTo = filePath;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async createBuild(id, style, palette, parts, bounds) {
+    if (!id || !palette || !parts || parts.length === 0) {
+      throw new Error("id, palette, and parts are required for create_build");
+    }
+    for (let i = 0; i < parts.length; i++) {
+      if (!Array.isArray(parts[i]) || parts[i].length < 10) {
+        throw new Error(`Part ${i} must have at least 10 elements: [posX, posY, posZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey]`);
+      }
+    }
+    const computedBounds = bounds || this.computeBounds(parts);
+    const buildData = { id, style, bounds: computedBounds, palette, parts };
+    const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${id}.json`);
+    const dirPath = path.dirname(filePath);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            id,
+            style,
+            bounds: computedBounds,
+            partCount: parts.length,
+            paletteKeys: Object.keys(palette),
+            savedTo: filePath
+          })
+        }
+      ]
+    };
+  }
+  computeBounds(parts) {
+    let maxX = 0, maxY = 0, maxZ = 0;
+    for (const p of parts) {
+      const px = Math.abs(p[0]) + p[3] / 2;
+      const py = Math.abs(p[1]) + p[4] / 2;
+      const pz = Math.abs(p[2]) + p[5] / 2;
+      maxX = Math.max(maxX, px);
+      maxY = Math.max(maxY, py);
+      maxZ = Math.max(maxZ, pz);
+    }
+    return [
+      Math.round(maxX * 2 * 10) / 10,
+      Math.round(maxY * 2 * 10) / 10,
+      Math.round(maxZ * 2 * 10) / 10
+    ];
+  }
+  async generateBuild(id, style, palette, code, seed) {
+    if (!id || !palette || !code) {
+      throw new Error("id, palette, and code are required for generate_build");
+    }
+    for (const [key, value] of Object.entries(palette)) {
+      if (!Array.isArray(value) || value.length < 2 || value.length > 3) {
+        throw new Error(`Palette key "${key}" must map to [BrickColor, Material] or [BrickColor, Material, MaterialVariant]`);
+      }
+    }
+    const result = runBuildExecutor(code, palette, seed);
+    const buildData = {
+      id,
+      style,
+      bounds: result.bounds,
+      palette,
+      parts: result.parts,
+      generatorCode: code
+    };
+    if (seed !== void 0)
+      buildData.generatorSeed = seed;
+    const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${id}.json`);
+    const dirPath = path.dirname(filePath);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(buildData, null, 2));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            id,
+            style,
+            bounds: result.bounds,
+            partCount: result.partCount,
+            paletteKeys: Object.keys(palette),
+            savedTo: filePath
+          })
+        }
+      ]
+    };
+  }
+  async importBuild(buildData, targetPath, position) {
+    if (!buildData || !targetPath) {
+      throw new Error("buildData (or library ID string) and targetPath are required for import_build");
+    }
+    let resolved;
+    if (typeof buildData === "string") {
+      const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${buildData}.json`);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Build not found in library: ${buildData}`);
+      }
+      resolved = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } else if (buildData.id && !buildData.parts) {
+      const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${buildData.id}.json`);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Build not found in library: ${buildData.id}`);
+      }
+      resolved = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } else {
+      resolved = buildData;
+    }
+    const response = await this.client.request("/api/import-build", {
+      buildData: resolved,
+      targetPath,
+      position
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async listLibrary(style) {
+    const libraryPath = _RobloxStudioTools.LIBRARY_PATH;
+    const styles = style ? [style] : ["medieval", "modern", "nature", "scifi", "misc"];
+    const builds = [];
+    for (const s of styles) {
+      const dirPath = path.join(libraryPath, s);
+      if (!fs.existsSync(dirPath))
+        continue;
+      const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(dirPath, file), "utf-8");
+          const data = JSON.parse(content);
+          builds.push({
+            id: data.id || `${s}/${file.replace(".json", "")}`,
+            style: data.style || s,
+            bounds: data.bounds || [0, 0, 0],
+            partCount: Array.isArray(data.parts) ? data.parts.length : 0
+          });
+        } catch {
+        }
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ builds, total: builds.length })
+        }
+      ]
+    };
+  }
+  async searchMaterials(query, maxResults) {
+    const response = await this.client.request("/api/search-materials", {
+      query: query ?? "",
+      maxResults: maxResults ?? 50
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  async getBuild(id) {
+    if (!id) {
+      throw new Error("Build ID is required for get_build");
+    }
+    const filePath = path.join(_RobloxStudioTools.LIBRARY_PATH, `${id}.json`);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Build not found in library: ${id}`);
+    }
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const result = {
+      id: data.id,
+      style: data.style,
+      bounds: data.bounds,
+      partCount: Array.isArray(data.parts) ? data.parts.length : 0,
+      paletteKeys: data.palette ? Object.keys(data.palette) : [],
+      palette: data.palette
+    };
+    if (data.generatorCode) {
+      result.generatorCode = data.generatorCode;
+      result.generatorSeed = data.generatorSeed;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result)
+        }
+      ]
+    };
+  }
+  async importScene(sceneData, targetPath = "game.Workspace") {
+    if (!sceneData) {
+      throw new Error("sceneData is required for import_scene");
+    }
+    const libraryPath = _RobloxStudioTools.LIBRARY_PATH;
+    const expandedBuilds = [];
+    const modelMap = sceneData.models || {};
+    const placements = sceneData.place || [];
+    for (const placement of placements) {
+      const [modelKey, position, rotation] = placement;
+      const buildId = modelMap[modelKey];
+      if (!buildId)
+        continue;
+      const filePath = path.join(libraryPath, `${buildId}.json`);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Build not found in library: ${buildId}`);
+      }
+      const content = fs.readFileSync(filePath, "utf-8");
+      const buildData = JSON.parse(content);
+      const buildName = buildId.split("/").pop() || buildId;
+      expandedBuilds.push({
+        buildData,
+        position: position || [0, 0, 0],
+        rotation: rotation || [0, 0, 0],
+        name: buildName
+      });
+    }
+    const customs = sceneData.custom || [];
+    for (const custom of customs) {
+      expandedBuilds.push({
+        buildData: {
+          palette: custom.palette,
+          parts: custom.parts
+        },
+        position: custom.o || [0, 0, 0],
+        rotation: [0, 0, 0],
+        name: custom.n || "Custom"
+      });
+    }
+    if (expandedBuilds.length === 0) {
+      throw new Error("No builds to import \u2014 check model references and library");
+    }
+    const response = await this.client.request("/api/import-scene", {
+      expandedBuilds,
+      targetPath
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+  // === Asset Tools ===
+  async searchAssets(assetType, query, maxResults, sortBy, verifiedCreatorsOnly) {
+    if (!this.openCloudClient.hasApiKey()) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "ROBLOX_OPEN_CLOUD_API_KEY environment variable is not set. Set it to use Creator Store asset tools." })
+        }]
+      };
+    }
+    const response = await this.openCloudClient.searchAssets({
+      searchCategoryType: assetType,
+      query,
+      maxPageSize: maxResults,
+      sortCategory: sortBy,
+      includeOnlyVerifiedCreators: verifiedCreatorsOnly
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(response)
+      }]
+    };
+  }
+  async getAssetDetails(assetId) {
+    if (!assetId) {
+      throw new Error("Asset ID is required for get_asset_details");
+    }
+    if (!this.openCloudClient.hasApiKey()) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "ROBLOX_OPEN_CLOUD_API_KEY environment variable is not set. Set it to use Creator Store asset tools." })
+        }]
+      };
+    }
+    const response = await this.openCloudClient.getAssetDetails(assetId);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(response)
+      }]
+    };
+  }
+  async getAssetThumbnail(assetId, size) {
+    if (!assetId) {
+      throw new Error("Asset ID is required for get_asset_thumbnail");
+    }
+    if (!this.openCloudClient.hasApiKey()) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "ROBLOX_OPEN_CLOUD_API_KEY environment variable is not set. Set it to use Creator Store asset tools." })
+        }]
+      };
+    }
+    const result = await this.openCloudClient.getAssetThumbnail(assetId, size);
+    if (!result) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ error: "Thumbnail not available for this asset" })
+        }]
+      };
+    }
+    return {
+      content: [{
+        type: "image",
+        data: result.base64,
+        mimeType: result.mimeType
+      }]
+    };
+  }
+  async insertAsset(assetId, parentPath, position) {
+    if (!assetId) {
+      throw new Error("Asset ID is required for insert_asset");
+    }
+    const response = await this.client.request("/api/insert-asset", {
+      assetId,
+      parentPath: parentPath || "game.Workspace",
+      position
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(response)
+      }]
+    };
+  }
+  async previewAsset(assetId, includeProperties, maxDepth) {
+    if (!assetId) {
+      throw new Error("Asset ID is required for preview_asset");
+    }
+    const response = await this.client.request("/api/preview-asset", {
+      assetId,
+      includeProperties: includeProperties ?? true,
+      maxDepth: maxDepth ?? 10
+    });
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(response)
+      }]
+    };
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/bridge-service.js
+import { v4 as uuidv4 } from "uuid";
+var BridgeService = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestTimeout = 3e4;
+  async sendRequest(endpoint, data) {
+    const requestId = uuidv4();
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (this.pendingRequests.has(requestId)) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
+        }
+      }, this.requestTimeout);
+      const request = {
+        id: requestId,
+        endpoint,
+        data,
+        timestamp: Date.now(),
+        resolve,
+        reject,
+        timeoutId
+      };
+      this.pendingRequests.set(requestId, request);
+    });
+  }
+  getPendingRequest() {
+    let oldestRequest = null;
+    for (const request of this.pendingRequests.values()) {
+      if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
+        oldestRequest = request;
+      }
+    }
+    if (oldestRequest) {
+      return {
+        requestId: oldestRequest.id,
+        request: {
+          endpoint: oldestRequest.endpoint,
+          data: oldestRequest.data
+        }
+      };
+    }
+    return null;
+  }
+  resolveRequest(requestId, response) {
+    const request = this.pendingRequests.get(requestId);
+    if (request) {
+      clearTimeout(request.timeoutId);
+      this.pendingRequests.delete(requestId);
+      request.resolve(response);
+    }
+  }
+  rejectRequest(requestId, error) {
+    const request = this.pendingRequests.get(requestId);
+    if (request) {
+      clearTimeout(request.timeoutId);
+      this.pendingRequests.delete(requestId);
+      request.reject(error);
+    }
+  }
+  cleanupOldRequests() {
+    const now = Date.now();
+    for (const [id, request] of this.pendingRequests.entries()) {
+      if (now - request.timestamp > this.requestTimeout) {
+        clearTimeout(request.timeoutId);
+        this.pendingRequests.delete(id);
+        request.reject(new Error("Request timeout"));
+      }
+    }
+  }
+  clearAllPendingRequests() {
+    for (const [, request] of this.pendingRequests.entries()) {
+      clearTimeout(request.timeoutId);
+      request.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/proxy-bridge-service.js
+import { v4 as uuidv42 } from "uuid";
+var ProxyBridgeService = class extends BridgeService {
+  primaryBaseUrl;
+  proxyInstanceId;
+  proxyRequestTimeout = 3e4;
+  constructor(primaryBaseUrl) {
+    super();
+    this.primaryBaseUrl = primaryBaseUrl;
+    this.proxyInstanceId = uuidv42();
+  }
+  async sendRequest(endpoint, data) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.proxyRequestTimeout);
+    try {
+      const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ endpoint, data, proxyInstanceId: this.proxyInstanceId }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Proxy request failed (${response.status}): ${body}`);
+      }
+      const result = await response.json();
+      if (result.error) {
+        throw new Error(result.error);
+      }
+      return result.response;
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        throw new Error("Proxy request timeout");
+      }
+      throw err;
+    }
+  }
+  cleanupOldRequests() {
+  }
+  clearAllPendingRequests() {
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/server.js
+var RobloxStudioMCPServer = class {
+  server;
+  tools;
+  bridge;
+  allowedToolNames;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.allowedToolNames = new Set(config.tools.map((t) => t.name));
+    this.server = new Server({
+      name: config.name,
+      version: config.version
+    }, {
+      capabilities: {
+        tools: {}
+      }
+    });
+    this.bridge = new BridgeService();
+    this.tools = new RobloxStudioTools(this.bridge);
+    this.setupToolHandlers();
+  }
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: this.config.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      if (!this.allowedToolNames.has(name)) {
+        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+      try {
+        switch (name) {
+          case "get_file_tree":
+            return await this.tools.getFileTree(args?.path || "");
+          case "search_files":
+            return await this.tools.searchFiles(args?.query, args?.searchType || "name");
+          case "get_place_info":
+            return await this.tools.getPlaceInfo();
+          case "get_services":
+            return await this.tools.getServices(args?.serviceName);
+          case "search_objects":
+            return await this.tools.searchObjects(args?.query, args?.searchType || "name", args?.propertyName);
+          case "get_instance_properties":
+            return await this.tools.getInstanceProperties(args?.instancePath, args?.excludeSource);
+          case "get_instance_children":
+            return await this.tools.getInstanceChildren(args?.instancePath);
+          case "search_by_property":
+            return await this.tools.searchByProperty(args?.propertyName, args?.propertyValue);
+          case "get_class_info":
+            return await this.tools.getClassInfo(args?.className);
+          case "get_project_structure":
+            return await this.tools.getProjectStructure(args?.path, args?.maxDepth, args?.scriptsOnly);
+          case "set_property":
+            return await this.tools.setProperty(args?.instancePath, args?.propertyName, args?.propertyValue);
+          case "mass_set_property":
+            return await this.tools.massSetProperty(args?.paths, args?.propertyName, args?.propertyValue);
+          case "mass_get_property":
+            return await this.tools.massGetProperty(args?.paths, args?.propertyName);
+          case "create_object":
+          case "create_object_with_properties":
+            return await this.tools.createObject(args?.className, args?.parent, args?.name, args?.properties);
+          case "mass_create_objects":
+          case "mass_create_objects_with_properties":
+            return await this.tools.massCreateObjects(args?.objects);
+          case "delete_object":
+            return await this.tools.deleteObject(args?.instancePath);
+          case "smart_duplicate":
+            return await this.tools.smartDuplicate(args?.instancePath, args?.count, args?.options);
+          case "mass_duplicate":
+            return await this.tools.massDuplicate(args?.duplications);
+          case "set_calculated_property":
+            return await this.tools.setCalculatedProperty(args?.paths, args?.propertyName, args?.formula, args?.variables);
+          case "set_relative_property":
+            return await this.tools.setRelativeProperty(args?.paths, args?.propertyName, args?.operation, args?.value, args?.component);
+          case "grep_scripts":
+            return await this.tools.grepScripts(args?.pattern, {
+              caseSensitive: args?.caseSensitive,
+              usePattern: args?.usePattern,
+              contextLines: args?.contextLines,
+              maxResults: args?.maxResults,
+              maxResultsPerScript: args?.maxResultsPerScript,
+              filesOnly: args?.filesOnly,
+              path: args?.path,
+              classFilter: args?.classFilter
+            });
+          case "get_script_source":
+            return await this.tools.getScriptSource(args?.instancePath, args?.startLine, args?.endLine);
+          case "set_script_source":
+            return await this.tools.setScriptSource(args?.instancePath, args?.source);
+          case "edit_script_lines":
+            return await this.tools.editScriptLines(args?.instancePath, args?.startLine, args?.endLine, args?.newContent);
+          case "insert_script_lines":
+            return await this.tools.insertScriptLines(args?.instancePath, args?.afterLine, args?.newContent);
+          case "delete_script_lines":
+            return await this.tools.deleteScriptLines(args?.instancePath, args?.startLine, args?.endLine);
+          case "get_attribute":
+            return await this.tools.getAttribute(args?.instancePath, args?.attributeName);
+          case "set_attribute":
+            return await this.tools.setAttribute(args?.instancePath, args?.attributeName, args?.attributeValue, args?.valueType);
+          case "get_attributes":
+            return await this.tools.getAttributes(args?.instancePath);
+          case "delete_attribute":
+            return await this.tools.deleteAttribute(args?.instancePath, args?.attributeName);
+          case "get_tags":
+            return await this.tools.getTags(args?.instancePath);
+          case "add_tag":
+            return await this.tools.addTag(args?.instancePath, args?.tagName);
+          case "remove_tag":
+            return await this.tools.removeTag(args?.instancePath, args?.tagName);
+          case "get_tagged":
+            return await this.tools.getTagged(args?.tagName);
+          case "get_selection":
+            return await this.tools.getSelection();
+          case "execute_luau":
+            return await this.tools.executeLuau(args?.code);
+          case "start_playtest":
+            return await this.tools.startPlaytest(args?.mode);
+          case "stop_playtest":
+            return await this.tools.stopPlaytest();
+          case "get_playtest_output":
+            return await this.tools.getPlaytestOutput();
+          case "export_build":
+            return await this.tools.exportBuild(args?.instancePath, args?.outputId, args?.style);
+          case "create_build":
+            return await this.tools.createBuild(args?.id, args?.style, args?.palette, args?.parts, args?.bounds);
+          case "generate_build":
+            return await this.tools.generateBuild(args?.id, args?.style, args?.palette, args?.code, args?.seed);
+          case "import_build":
+            return await this.tools.importBuild(args?.buildData, args?.targetPath, args?.position);
+          case "list_library":
+            return await this.tools.listLibrary(args?.style);
+          case "search_materials":
+            return await this.tools.searchMaterials(args?.query, args?.maxResults);
+          case "get_build":
+            return await this.tools.getBuild(args?.id);
+          case "import_scene":
+            return await this.tools.importScene(args?.sceneData, args?.targetPath);
+          case "undo":
+            return await this.tools.undo();
+          case "redo":
+            return await this.tools.redo();
+          case "search_assets":
+            return await this.tools.searchAssets(args?.assetType, args?.query, args?.maxResults, args?.sortBy, args?.verifiedCreatorsOnly);
+          case "get_asset_details":
+            return await this.tools.getAssetDetails(args?.assetId);
+          case "get_asset_thumbnail":
+            return await this.tools.getAssetThumbnail(args?.assetId, args?.size);
+          case "insert_asset":
+            return await this.tools.insertAsset(args?.assetId, args?.parentPath, args?.position);
+          case "preview_asset":
+            return await this.tools.previewAsset(args?.assetId, args?.includeProperties, args?.maxDepth);
+          default:
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        if (error instanceof McpError)
+          throw error;
+        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+  }
+  async run() {
+    const basePort = process.env.ROBLOX_STUDIO_PORT ? parseInt(process.env.ROBLOX_STUDIO_PORT) : 58741;
+    const host = process.env.ROBLOX_STUDIO_HOST || "0.0.0.0";
+    let bridgeMode = "primary";
+    let httpHandle;
+    let primaryApp;
+    let boundPort = 0;
+    let promotionInterval;
+    try {
+      primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+      const result = await listenWithRetry(primaryApp, host, basePort, 5);
+      httpHandle = result.server;
+      boundPort = result.port;
+      console.error(`HTTP server listening on ${host}:${boundPort} for Studio plugin (primary mode)`);
+    } catch {
+      bridgeMode = "proxy";
+      primaryApp = void 0;
+      const proxyBridge = new ProxyBridgeService(`http://localhost:${basePort}`);
+      this.bridge = proxyBridge;
+      this.tools = new RobloxStudioTools(this.bridge);
+      console.error(`All ports ${basePort}-${basePort + 4} in use \u2014 entering proxy mode (forwarding to localhost:${basePort})`);
+      const promotionIntervalMs = parseInt(process.env.ROBLOX_STUDIO_PROXY_PROMOTION_INTERVAL_MS || "5000");
+      promotionInterval = setInterval(async () => {
+        try {
+          this.bridge = new BridgeService();
+          this.tools = new RobloxStudioTools(this.bridge);
+          primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+          const result = await listenWithRetry(primaryApp, host, basePort, 5);
+          httpHandle = result.server;
+          boundPort = result.port;
+          bridgeMode = "primary";
+          primaryApp.setMCPServerActive(true);
+          console.error(`Promoted from proxy to primary on port ${boundPort}`);
+          if (promotionInterval)
+            clearInterval(promotionInterval);
+        } catch {
+          this.bridge = new ProxyBridgeService(`http://localhost:${basePort}`);
+          this.tools = new RobloxStudioTools(this.bridge);
+          primaryApp = void 0;
+        }
+      }, promotionIntervalMs);
+    }
+    const LEGACY_PORT = 3002;
+    let legacyHandle;
+    let legacyApp;
+    if (boundPort !== LEGACY_PORT && bridgeMode === "primary") {
+      legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+      try {
+        const result = await listenWithRetry(legacyApp, host, LEGACY_PORT, 1);
+        legacyHandle = result.server;
+        console.error(`Legacy HTTP server also listening on ${host}:${LEGACY_PORT} for old plugins`);
+        legacyApp.setMCPServerActive(true);
+      } catch {
+        console.error(`Legacy port ${LEGACY_PORT} in use, skipping backward-compat listener`);
+      }
+    }
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error(`${this.config.name} v${this.config.version} running on stdio`);
+    if (primaryApp) {
+      primaryApp.setMCPServerActive(true);
+    }
+    console.error(bridgeMode === "primary" ? "MCP server marked as active (primary mode)" : "MCP server active in proxy mode \u2014 forwarding requests to primary");
+    console.error("Waiting for Studio plugin to connect...");
+    const activityInterval = setInterval(() => {
+      if (primaryApp)
+        primaryApp.trackMCPActivity();
+      if (legacyApp)
+        legacyApp.trackMCPActivity();
+      if (bridgeMode === "primary" && primaryApp) {
+        const pluginConnected = primaryApp.isPluginConnected();
+        const mcpActive = primaryApp.isMCPServerActive();
+        if (pluginConnected && mcpActive) {
+        } else if (pluginConnected && !mcpActive) {
+          console.error("Studio plugin connected, but MCP server inactive");
+        } else if (!pluginConnected && mcpActive) {
+          console.error("MCP server active, waiting for Studio plugin...");
+        } else {
+          console.error("Waiting for connections...");
+        }
+      }
+    }, 5e3);
+    const cleanupInterval = setInterval(() => {
+      this.bridge.cleanupOldRequests();
+    }, 5e3);
+    const shutdown = () => {
+      console.error("Shutting down MCP server...");
+      clearInterval(activityInterval);
+      clearInterval(cleanupInterval);
+      if (promotionInterval)
+        clearInterval(promotionInterval);
+      if (httpHandle)
+        httpHandle.close();
+      if (legacyHandle)
+        legacyHandle.close();
+      process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    process.on("SIGHUP", shutdown);
+    process.stdin.on("end", shutdown);
+    process.stdin.on("close", shutdown);
+  }
+};
+
+// ../../node_modules/@robloxstudio-mcp/core/dist/tools/definitions.js
+var TOOL_DEFINITIONS = [
+  // === File & Instance Browsing ===
+  {
+    name: "get_file_tree",
+    category: "read",
+    description: "Get instance hierarchy tree from Studio",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Root path (default: game root)",
+          default: ""
+        }
+      }
+    }
+  },
+  {
+    name: "search_files",
+    category: "read",
+    description: "Search instances by name, class, or script content",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Name, class, or code pattern"
+        },
+        searchType: {
+          type: "string",
+          enum: ["name", "type", "content"],
+          description: "Search mode",
+          default: "name"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  // === Place & Service Info ===
+  {
+    name: "get_place_info",
+    category: "read",
+    description: "Get place ID, name, and game settings",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "get_services",
+    category: "read",
+    description: "Get available services and their children",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serviceName: {
+          type: "string",
+          description: "Specific service name"
+        }
+      }
+    }
+  },
+  {
+    name: "search_objects",
+    category: "read",
+    description: "Find instances by name, class, or properties",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query"
+        },
+        searchType: {
+          type: "string",
+          enum: ["name", "class", "property"],
+          description: "Search mode",
+          default: "name"
+        },
+        propertyName: {
+          type: "string",
+          description: 'Property name when searchType is "property"'
+        }
+      },
+      required: ["query"]
+    }
+  },
+  // === Instance Inspection ===
+  {
+    name: "get_instance_properties",
+    category: "read",
+    description: "Get all properties of an instance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        excludeSource: {
+          type: "boolean",
+          description: "For scripts, return SourceLength/LineCount instead of full source (default: false)",
+          default: false
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "get_instance_children",
+    category: "read",
+    description: "Get children and their class types",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "search_by_property",
+    category: "read",
+    description: "Find objects with specific property values",
+    inputSchema: {
+      type: "object",
+      properties: {
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        },
+        propertyValue: {
+          type: "string",
+          description: "Value to match"
+        }
+      },
+      required: ["propertyName", "propertyValue"]
+    }
+  },
+  {
+    name: "get_class_info",
+    category: "read",
+    description: "Get properties/methods for a class",
+    inputSchema: {
+      type: "object",
+      properties: {
+        className: {
+          type: "string",
+          description: "Roblox class name"
+        }
+      },
+      required: ["className"]
+    }
+  },
+  // === Project Structure ===
+  {
+    name: "get_project_structure",
+    category: "read",
+    description: "Get full game hierarchy tree. Increase maxDepth (default 3) for deeper traversal.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Root path (default: workspace root)",
+          default: ""
+        },
+        maxDepth: {
+          type: "number",
+          description: "Max traversal depth (default: 3)",
+          default: 3
+        },
+        scriptsOnly: {
+          type: "boolean",
+          description: "Show only scripts",
+          default: false
+        }
+      }
+    }
+  },
+  // === Property Write ===
+  {
+    name: "set_property",
+    category: "write",
+    description: "Set a property on an instance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        },
+        propertyValue: {
+          description: "Value to set"
+        }
+      },
+      required: ["instancePath", "propertyName", "propertyValue"]
+    }
+  },
+  {
+    name: "mass_set_property",
+    category: "write",
+    description: "Set a property on multiple instances",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Instance paths"
+        },
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        },
+        propertyValue: {
+          description: "Value to set"
+        }
+      },
+      required: ["paths", "propertyName", "propertyValue"]
+    }
+  },
+  {
+    name: "mass_get_property",
+    category: "read",
+    description: "Get a property from multiple instances",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Instance paths"
+        },
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        }
+      },
+      required: ["paths", "propertyName"]
+    }
+  },
+  // === Object Creation/Deletion ===
+  {
+    name: "create_object",
+    category: "write",
+    description: "Create a new instance. Optionally set properties on creation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        className: {
+          type: "string",
+          description: "Roblox class name"
+        },
+        parent: {
+          type: "string",
+          description: "Parent instance path"
+        },
+        name: {
+          type: "string",
+          description: "Optional name"
+        },
+        properties: {
+          type: "object",
+          description: "Properties to set on creation"
+        }
+      },
+      required: ["className", "parent"]
+    }
+  },
+  {
+    name: "mass_create_objects",
+    category: "write",
+    description: "Create multiple instances. Each can have optional properties.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        objects: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              className: {
+                type: "string",
+                description: "Roblox class name"
+              },
+              parent: {
+                type: "string",
+                description: "Parent instance path"
+              },
+              name: {
+                type: "string",
+                description: "Optional name"
+              },
+              properties: {
+                type: "object",
+                description: "Properties to set on creation"
+              }
+            },
+            required: ["className", "parent"]
+          },
+          description: "Objects to create"
+        }
+      },
+      required: ["objects"]
+    }
+  },
+  {
+    name: "delete_object",
+    category: "write",
+    description: "Delete an instance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  // === Duplication ===
+  {
+    name: "smart_duplicate",
+    category: "write",
+    description: "Duplicate with naming, positioning, and property variations",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        count: {
+          type: "number",
+          description: "Number of duplicates"
+        },
+        options: {
+          type: "object",
+          properties: {
+            namePattern: {
+              type: "string",
+              description: "Name pattern ({n} placeholder)"
+            },
+            positionOffset: {
+              type: "array",
+              items: { type: "number" },
+              minItems: 3,
+              maxItems: 3,
+              description: "X, Y, Z offset per duplicate"
+            },
+            rotationOffset: {
+              type: "array",
+              items: { type: "number" },
+              minItems: 3,
+              maxItems: 3,
+              description: "X, Y, Z rotation offset"
+            },
+            scaleOffset: {
+              type: "array",
+              items: { type: "number" },
+              minItems: 3,
+              maxItems: 3,
+              description: "X, Y, Z scale multiplier"
+            },
+            propertyVariations: {
+              type: "object",
+              description: "Property name to array of values"
+            },
+            targetParents: {
+              type: "array",
+              items: { type: "string" },
+              description: "Different parent per duplicate"
             }
-            catch (err) {
-                if (err.code === 'EADDRINUSE') {
-                    console.error(`Port ${port} in use, trying next...`);
-                    if (port === maxPort) {
-                        throw new Error(`All ports ${basePort}-${maxPort} are in use. Stop some MCP server instances and retry.`);
-                    }
-                    continue;
+          }
+        }
+      },
+      required: ["instancePath", "count"]
+    }
+  },
+  {
+    name: "mass_duplicate",
+    category: "write",
+    description: "Batch smart_duplicate operations",
+    inputSchema: {
+      type: "object",
+      properties: {
+        duplications: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              instancePath: {
+                type: "string",
+                description: "Instance path (dot notation)"
+              },
+              count: {
+                type: "number",
+                description: "Number of duplicates"
+              },
+              options: {
+                type: "object",
+                properties: {
+                  namePattern: {
+                    type: "string",
+                    description: "Name pattern ({n} placeholder)"
+                  },
+                  positionOffset: {
+                    type: "array",
+                    items: { type: "number" },
+                    minItems: 3,
+                    maxItems: 3,
+                    description: "X, Y, Z offset per duplicate"
+                  },
+                  rotationOffset: {
+                    type: "array",
+                    items: { type: "number" },
+                    minItems: 3,
+                    maxItems: 3,
+                    description: "X, Y, Z rotation offset"
+                  },
+                  scaleOffset: {
+                    type: "array",
+                    items: { type: "number" },
+                    minItems: 3,
+                    maxItems: 3,
+                    description: "X, Y, Z scale multiplier"
+                  },
+                  propertyVariations: {
+                    type: "object",
+                    description: "Property name to array of values"
+                  },
+                  targetParents: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Different parent per duplicate"
+                  }
                 }
-                throw err;
-            }
+              }
+            },
+            required: ["instancePath", "count"]
+          },
+          description: "Duplication operations"
         }
-        const LEGACY_PORT = 3002;
-        let legacyServer;
-        if (boundPort !== LEGACY_PORT) {
-            const legacy = createHttpServer(this.tools, this.bridge);
-            legacyServer = legacy;
-            try {
-                await new Promise((resolve, reject) => {
-                    const onError = (err) => {
-                        if (err.code === 'EADDRINUSE') {
-                            legacy.removeListener('error', onError);
-                            reject(err);
-                        }
-                        else {
-                            reject(err);
-                        }
-                    };
-                    legacy.once('error', onError);
-                    legacy.listen(LEGACY_PORT, host, () => {
-                        legacy.removeListener('error', onError);
-                        console.error(`Legacy HTTP server also listening on ${host}:${LEGACY_PORT} for old plugins`);
-                        resolve();
-                    });
-                });
-                legacy.setMCPServerActive(true);
-            }
-            catch {
-                console.error(`Legacy port ${LEGACY_PORT} in use, skipping backward-compat listener`);
-            }
+      },
+      required: ["duplications"]
+    }
+  },
+  // === Calculated/Relative Properties ===
+  {
+    name: "set_calculated_property",
+    category: "write",
+    description: 'Set properties via formula (e.g. "index * 50")',
+    inputSchema: {
+      type: "object",
+      properties: {
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Instance paths"
+        },
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        },
+        formula: {
+          type: "string",
+          description: "Formula expression"
+        },
+        variables: {
+          type: "object",
+          description: "Additional formula variables"
         }
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error('Roblox Studio MCP server running on stdio');
-        httpServer.setMCPServerActive(true);
-        console.error('MCP server marked as active');
-        console.error('Waiting for Studio plugin to connect...');
-        setInterval(() => {
-            httpServer.trackMCPActivity();
-            if (legacyServer)
-                legacyServer.trackMCPActivity();
-            const pluginConnected = httpServer.isPluginConnected();
-            const mcpActive = httpServer.isMCPServerActive();
-            if (pluginConnected && mcpActive) {
-            }
-            else if (pluginConnected && !mcpActive) {
-                console.error('Studio plugin connected, but MCP server inactive');
-            }
-            else if (!pluginConnected && mcpActive) {
-                console.error('MCP server active, waiting for Studio plugin...');
-            }
-            else {
-                console.error('Waiting for connections...');
+      },
+      required: ["paths", "propertyName", "formula"]
+    }
+  },
+  {
+    name: "set_relative_property",
+    category: "write",
+    description: "Modify properties relative to current values",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Instance paths"
+        },
+        propertyName: {
+          type: "string",
+          description: "Property name"
+        },
+        operation: {
+          type: "string",
+          enum: ["add", "multiply", "divide", "subtract", "power"],
+          description: "Operation"
+        },
+        value: {
+          description: "Operand value"
+        },
+        component: {
+          type: "string",
+          enum: ["X", "Y", "Z", "XScale", "XOffset", "YScale", "YOffset"],
+          description: "Vector3/UDim2 component"
+        }
+      },
+      required: ["paths", "propertyName", "operation", "value"]
+    }
+  },
+  // === Script Read/Write ===
+  {
+    name: "get_script_source",
+    category: "read",
+    description: 'Get script source. Returns "source" and "numberedSource" (line-numbered). Use startLine/endLine for large scripts.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Script instance path"
+        },
+        startLine: {
+          type: "number",
+          description: "Start line (1-indexed)"
+        },
+        endLine: {
+          type: "number",
+          description: "End line (inclusive)"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "set_script_source",
+    category: "write",
+    description: "Replace entire script source. For partial edits use edit/insert/delete_script_lines.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Script instance path"
+        },
+        source: {
+          type: "string",
+          description: "New source code"
+        }
+      },
+      required: ["instancePath", "source"]
+    }
+  },
+  {
+    name: "edit_script_lines",
+    category: "write",
+    description: "Replace a range of lines. 1-indexed, inclusive. Use numberedSource for line numbers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Script instance path"
+        },
+        startLine: {
+          type: "number",
+          description: "Start line (1-indexed)"
+        },
+        endLine: {
+          type: "number",
+          description: "End line (inclusive)"
+        },
+        newContent: {
+          type: "string",
+          description: "Replacement content"
+        }
+      },
+      required: ["instancePath", "startLine", "endLine", "newContent"]
+    }
+  },
+  {
+    name: "insert_script_lines",
+    category: "write",
+    description: "Insert lines after a given line number (0 = beginning).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Script instance path"
+        },
+        afterLine: {
+          type: "number",
+          description: "Insert after this line (0 = beginning)",
+          default: 0
+        },
+        newContent: {
+          type: "string",
+          description: "Content to insert"
+        }
+      },
+      required: ["instancePath", "newContent"]
+    }
+  },
+  {
+    name: "delete_script_lines",
+    category: "write",
+    description: "Delete a range of lines. 1-indexed, inclusive.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Script instance path"
+        },
+        startLine: {
+          type: "number",
+          description: "Start line (1-indexed)"
+        },
+        endLine: {
+          type: "number",
+          description: "End line (inclusive)"
+        }
+      },
+      required: ["instancePath", "startLine", "endLine"]
+    }
+  },
+  // === Attributes ===
+  {
+    name: "get_attribute",
+    category: "read",
+    description: "Get an attribute value",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        attributeName: {
+          type: "string",
+          description: "Attribute name"
+        }
+      },
+      required: ["instancePath", "attributeName"]
+    }
+  },
+  {
+    name: "set_attribute",
+    category: "write",
+    description: "Set an attribute. Supports primitives, Vector3, Color3, UDim2, BrickColor.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        attributeName: {
+          type: "string",
+          description: "Attribute name"
+        },
+        attributeValue: {
+          description: "Value. Objects for Vector3/Color3/UDim2."
+        },
+        valueType: {
+          type: "string",
+          description: "Type hint if needed"
+        }
+      },
+      required: ["instancePath", "attributeName", "attributeValue"]
+    }
+  },
+  {
+    name: "get_attributes",
+    category: "read",
+    description: "Get all attributes on an instance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "delete_attribute",
+    category: "write",
+    description: "Delete an attribute",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        attributeName: {
+          type: "string",
+          description: "Attribute name"
+        }
+      },
+      required: ["instancePath", "attributeName"]
+    }
+  },
+  // === Tags ===
+  {
+    name: "get_tags",
+    category: "read",
+    description: "Get all tags on an instance",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "add_tag",
+    category: "write",
+    description: "Add a tag",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        tagName: {
+          type: "string",
+          description: "Tag name"
+        }
+      },
+      required: ["instancePath", "tagName"]
+    }
+  },
+  {
+    name: "remove_tag",
+    category: "write",
+    description: "Remove a tag",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Instance path (dot notation)"
+        },
+        tagName: {
+          type: "string",
+          description: "Tag name"
+        }
+      },
+      required: ["instancePath", "tagName"]
+    }
+  },
+  {
+    name: "get_tagged",
+    category: "read",
+    description: "Get all instances with a specific tag",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tagName: {
+          type: "string",
+          description: "Tag name"
+        }
+      },
+      required: ["tagName"]
+    }
+  },
+  // === Selection ===
+  {
+    name: "get_selection",
+    category: "read",
+    description: "Get all currently selected objects",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // === Luau Execution ===
+  {
+    name: "execute_luau",
+    category: "write",
+    description: "Execute Luau code in plugin context. Use print()/warn() for output. Return value is captured.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "Luau code to execute"
+        }
+      },
+      required: ["code"]
+    }
+  },
+  // === Script Search ===
+  {
+    name: "grep_scripts",
+    category: "read",
+    description: "Ripgrep-inspired search across all script sources. Supports literal and Lua pattern matching, context lines, early termination, and results grouped by script with line/column numbers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Search pattern (literal string or Lua pattern)"
+        },
+        caseSensitive: {
+          type: "boolean",
+          description: "Case-sensitive search (default: false)",
+          default: false
+        },
+        usePattern: {
+          type: "boolean",
+          description: "Use Lua pattern matching instead of literal (default: false)",
+          default: false
+        },
+        contextLines: {
+          type: "number",
+          description: "Number of context lines before/after each match (like rg -C)",
+          default: 0
+        },
+        maxResults: {
+          type: "number",
+          description: "Max total matches before stopping (default: 100)",
+          default: 100
+        },
+        maxResultsPerScript: {
+          type: "number",
+          description: "Max matches per script (like rg -m)"
+        },
+        filesOnly: {
+          type: "boolean",
+          description: "Only return matching script paths, not line details (like rg -l)",
+          default: false
+        },
+        path: {
+          type: "string",
+          description: 'Subtree to search (e.g. "game.ServerScriptService")'
+        },
+        classFilter: {
+          type: "string",
+          enum: ["Script", "LocalScript", "ModuleScript"],
+          description: "Only search scripts of this class type"
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  // === Playtest ===
+  {
+    name: "start_playtest",
+    category: "read",
+    description: "Start playtest. Captures print/warn/error via LogService. Poll with get_playtest_output, end with stop_playtest.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mode: {
+          type: "string",
+          enum: ["play", "run"],
+          description: "Play mode"
+        }
+      },
+      required: ["mode"]
+    }
+  },
+  {
+    name: "stop_playtest",
+    category: "read",
+    description: "Stop playtest and return all captured output.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "get_playtest_output",
+    category: "read",
+    description: "Poll output buffer without stopping. Returns isRunning and captured messages.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // === Undo/Redo ===
+  {
+    name: "undo",
+    category: "write",
+    description: "Undo the last change in Roblox Studio. Uses ChangeHistoryService to reverse the most recent operation.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "redo",
+    category: "write",
+    description: "Redo the last undone change in Roblox Studio. Uses ChangeHistoryService to reapply the most recently undone operation.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // === Build Library ===
+  {
+    name: "export_build",
+    category: "read",
+    description: "Export a Model/Folder into a compact, token-efficient build JSON format and auto-save it to the local build library. The output contains a palette (unique BrickColor+Material combos mapped to short keys) and compact part arrays with positions normalized relative to the bounding box center. The file is saved to build-library/{style}/{id}.json automatically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        instancePath: {
+          type: "string",
+          description: "Path to the Model or Folder to export (dot notation)"
+        },
+        outputId: {
+          type: "string",
+          description: 'Build ID for the output (e.g. "medieval/cottage_01"). Defaults to style/instance_name.'
+        },
+        style: {
+          type: "string",
+          enum: ["medieval", "modern", "nature", "scifi", "misc"],
+          description: "Style category for the build",
+          default: "misc"
+        }
+      },
+      required: ["instancePath"]
+    }
+  },
+  {
+    name: "create_build",
+    category: "write",
+    description: "Create a new build model from scratch and save it to the library. Define parts using compact arrays [posX, posY, posZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey, shape?, transparency?]. Palette maps short keys to [BrickColor, Material] pairs. The build is saved and can be referenced by import_build or import_scene.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'Build ID including style prefix (e.g. "medieval/torch_01", "nature/bush_small")'
+        },
+        style: {
+          type: "string",
+          enum: ["medieval", "modern", "nature", "scifi", "misc"],
+          description: "Style category"
+        },
+        palette: {
+          type: "object",
+          description: 'Map of short keys to [BrickColor, Material] or [BrickColor, Material, MaterialVariant] tuples. E.g. {"a": ["Dark stone grey", "Concrete"], "b": ["Brown", "Wood", "MyCustomWood"]}'
+        },
+        parts: {
+          type: "array",
+          description: "Array of part arrays. Each: [posX, posY, posZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey, shape?, transparency?]. Shapes: Block (default), Wedge, Cylinder, Ball, CornerWedge.",
+          items: {
+            type: "array",
+            minItems: 10
+          }
+        },
+        bounds: {
+          type: "array",
+          items: { type: "number" },
+          minItems: 3,
+          maxItems: 3,
+          description: "Optional bounding box [X, Y, Z]. Auto-computed if omitted."
+        }
+      },
+      required: ["id", "style", "palette", "parts"]
+    }
+  },
+  {
+    name: "generate_build",
+    category: "write",
+    description: `Procedurally generate a build via JS code. ALWAYS generate the entire scene in ONE call \u2014 never split into multiple small builds. PREFER high-level primitives over manual loops. No comments. No unnecessary variables. Maximize build detail per line.
+
+EDITING: When modifying an existing build, call get_build first to retrieve the original code. Then make ONLY the targeted changes the user requested \u2014 do not rewrite unchanged code. Pass the modified code to generate_build.
+
+HIGH-LEVEL (use these first \u2014 each replaces 5-20 lines):
+  room(x,y,z, w,h,d, wallKey, floorKey?, ceilKey?, wallThickness?) - Complete enclosed room (floor+ceiling+4 walls)
+  roof(x,y,z, w,d, style, key, overhang?) - style: "flat"|"gable"|"hip"
+  stairs(x1,y1,z1, x2,y2,z2, width, key) - Auto-generates steps between two points
+  column(x,y,z, height, radius, key, capKey?) - Cylinder with base+capital
+  pew(x,y,z, w,d, seatKey, legKey?) - Bench with seat+backrest+legs
+  arch(x,y,z, w,h, thickness, key, segments?) - Curved archway
+  fence(x1,z1, x2,z2, y, key, postSpacing?) - Fence with posts+rails
+
+BASIC:
+  part(x,y,z, sx,sy,sz, key, shape?, transparency?)
+  rpart(x,y,z, sx,sy,sz, rx,ry,rz, key, shape?, transparency?)
+  wall(x1,z1, x2,z2, height, thickness, key) \u2014 vertical plane from (x1,z1) to (x2,z2)
+  floor(x1,z1, x2,z2, y, thickness, key) \u2014 horizontal plane at height y, corners (x1,z1)-(x2,z2). NOT fill \u2014 only takes 2D corners+y, not 3D points
+  fill(x1,y1,z1, x2,y2,z2, key, [ux,uy,uz]?) \u2014 3D volume between two 3D points
+  beam(x1,y1,z1, x2,y2,z2, thickness, key)
+
+IMPORTANT: Palette keys must match exactly. Use only keys defined in your palette object, not color names.
+CUSTOM MATERIALS: Use search_materials to find MaterialVariant names, then reference them as the 3rd palette element: {"a": ["Color", "BaseMaterial", "VariantName"]}.
+
+REPETITION:
+  row(x,y,z, count, spacingX, spacingZ, fn(i,cx,cy,cz))
+  grid(x,y,z, countX, countZ, spacingX, spacingZ, fn(ix,iz,cx,cy,cz))
+
+Shapes: Block(default), Wedge, Cylinder, Ball, CornerWedge. Max 10000 parts. Math and rng() available.
+CYLINDER AXIS: Roblox cylinders extend along the X axis. For upright cylinders, use size (height, diameter, diameter) with rz=90. The column() primitive handles this automatically.
+
+EXAMPLE \u2014 compact cabin (17 lines):
+room(0,0,0,8,4,6,"a","b","a")
+roof(0,4,0,8,6,"gable","c")
+wall(-4,0,-2,4,0,-2,4,1,"a")
+part(0,2,3,3,3,0.3,"a","Block",0.4)
+row(-2,0,-1,3,0,2,(i,cx,cy,cz)=>{pew(cx,0,cz,3,2,"d")})
+column(-3,0,-2,4,0.5,"a","b")
+column(3,0,-2,4,0.5,"a","b")
+part(0,2,0,2,1,1,"b")`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'Build ID including style prefix (e.g. "medieval/church_01")'
+        },
+        style: {
+          type: "string",
+          enum: ["medieval", "modern", "nature", "scifi", "misc"],
+          description: "Style category"
+        },
+        palette: {
+          type: "object",
+          description: 'Map of short keys to [BrickColor, Material] or [BrickColor, Material, MaterialVariant] tuples. E.g. {"a": ["Dark stone grey", "Cobblestone"], "b": ["Brown", "WoodPlanks", "MyCustomWood"]}. MaterialVariant is optional \u2014 use it to reference custom materials from MaterialService.'
+        },
+        code: {
+          type: "string",
+          description: "JavaScript code using the primitives above to generate parts procedurally"
+        },
+        seed: {
+          type: "number",
+          description: "Optional seed for deterministic rng() output (default: 42)"
+        }
+      },
+      required: ["id", "style", "palette", "code"]
+    }
+  },
+  {
+    name: "import_build",
+    category: "write",
+    description: 'Import a build into Roblox Studio. Accepts either a full build data object OR a library ID string (e.g. "medieval/church_01") to load from the build library. When using generate_build or create_build, pass the build ID string instead of the full data.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        buildData: {
+          description: 'Either a build data object (with palette, parts, etc.) OR a library ID string (e.g. "medieval/church_01") to load from the build library'
+        },
+        targetPath: {
+          type: "string",
+          description: "Parent instance path where the model will be created"
+        },
+        position: {
+          type: "array",
+          items: { type: "number" },
+          minItems: 3,
+          maxItems: 3,
+          description: "World position offset [X, Y, Z]"
+        }
+      },
+      required: ["buildData", "targetPath"]
+    }
+  },
+  {
+    name: "list_library",
+    category: "read",
+    description: "List available builds in the local build library. Returns build IDs, styles, bounds, and part counts. Optionally filter by style.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        style: {
+          type: "string",
+          enum: ["medieval", "modern", "nature", "scifi", "misc"],
+          description: "Filter by style category"
+        }
+      }
+    }
+  },
+  {
+    name: "search_materials",
+    category: "read",
+    description: "Search for MaterialVariant instances in MaterialService by name. Use this to find custom materials before using them in generate_build or create_build palettes. Returns material names and their base material types.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query to match against material names (case-insensitive). Leave empty to list all."
+        },
+        maxResults: {
+          type: "number",
+          description: "Max results to return (default: 50)",
+          default: 50
+        }
+      }
+    }
+  },
+  {
+    name: "get_build",
+    category: "read",
+    description: "Get a build from the library by ID. Returns metadata, palette, and generator code (if the build was created with generate_build). IMPORTANT: When the user asks to modify an existing build, ALWAYS call get_build first to retrieve the original code, then make targeted edits to only the relevant lines, and call generate_build with the modified code. Never rewrite the entire code from scratch \u2014 only change what the user asked to change.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: 'Build ID (e.g. "medieval/church_01")'
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "import_scene",
+    category: "write",
+    description: "Import a full scene layout. Provide a scene with model references (resolved from library) and placement data. Each model is placed at the specified position/rotation. Can also include inline custom builds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sceneData: {
+          type: "object",
+          description: "Scene layout object with: models (map of key to library build ID), place (array of [key, position, rotation?]), and optional custom (array of inline build objects with name, position, palette, parts)",
+          properties: {
+            models: {
+              type: "object",
+              description: 'Map of short keys to library build IDs (e.g. {"A": "medieval/cottage_01"})'
+            },
+            place: {
+              type: "array",
+              description: "Array of placements: [modelKey, [x,y,z], [rotX?,rotY?,rotZ?]]",
+              items: { type: "array" }
+            },
+            custom: {
+              type: "array",
+              description: "Array of inline custom builds with {n: name, o: [x,y,z], palette: {...}, parts: [...]}",
+              items: { type: "object" }
             }
-        }, 5000);
-        setInterval(() => {
-            this.bridge.cleanupOldRequests();
-        }, 5000);
+          }
+        },
+        targetPath: {
+          type: "string",
+          description: "Parent instance path for the scene (default: game.Workspace)",
+          default: "game.Workspace"
+        }
+      },
+      required: ["sceneData"]
     }
-}
-const server = new RobloxStudioMCPServer();
+  },
+  // === Asset Tools ===
+  {
+    name: "search_assets",
+    category: "read",
+    description: "Search the Creator Store (Roblox marketplace) for assets by type and keywords. Requires ROBLOX_OPEN_CLOUD_API_KEY env var.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetType: {
+          type: "string",
+          enum: ["Audio", "Model", "Decal", "Plugin", "MeshPart", "Video", "FontFamily"],
+          description: "Type of asset to search for"
+        },
+        query: {
+          type: "string",
+          description: "Search keywords"
+        },
+        maxResults: {
+          type: "number",
+          description: "Max results to return (default: 25)",
+          default: 25
+        },
+        sortBy: {
+          type: "string",
+          enum: ["Relevance", "Trending", "Top", "AudioDuration", "CreateTime", "UpdatedTime", "Ratings"],
+          description: "Sort order (default: Relevance)",
+          default: "Relevance"
+        },
+        verifiedCreatorsOnly: {
+          type: "boolean",
+          description: "Only show assets from verified creators",
+          default: false
+        }
+      },
+      required: ["assetType"]
+    }
+  },
+  {
+    name: "get_asset_details",
+    category: "read",
+    description: "Get detailed marketplace metadata for a specific asset (creator info, votes, description, pricing). Requires ROBLOX_OPEN_CLOUD_API_KEY env var.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetId: {
+          type: "number",
+          description: "The Roblox asset ID"
+        }
+      },
+      required: ["assetId"]
+    }
+  },
+  {
+    name: "get_asset_thumbnail",
+    category: "read",
+    description: "Get the thumbnail image for an asset as base64 PNG, suitable for vision LLMs. Requires ROBLOX_OPEN_CLOUD_API_KEY env var.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetId: {
+          type: "number",
+          description: "The Roblox asset ID"
+        },
+        size: {
+          type: "string",
+          enum: ["150x150", "420x420", "768x432"],
+          description: "Thumbnail size (default: 420x420)",
+          default: "420x420"
+        }
+      },
+      required: ["assetId"]
+    }
+  },
+  {
+    name: "insert_asset",
+    category: "write",
+    description: "Insert a Roblox asset into Studio by loading it via AssetService and parenting it to a target location. Optionally set position.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetId: {
+          type: "number",
+          description: "The Roblox asset ID to insert"
+        },
+        parentPath: {
+          type: "string",
+          description: "Parent instance path (default: game.Workspace)",
+          default: "game.Workspace"
+        },
+        position: {
+          type: "object",
+          properties: {
+            x: { type: "number" },
+            y: { type: "number" },
+            z: { type: "number" }
+          },
+          description: "Optional world position to place the asset"
+        }
+      },
+      required: ["assetId"]
+    }
+  },
+  {
+    name: "preview_asset",
+    category: "read",
+    description: "Preview a Roblox asset without permanently inserting it. Loads the asset, builds a hierarchy tree with properties and summary stats, then destroys it. Useful for inspecting asset contents before insertion.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        assetId: {
+          type: "number",
+          description: "The Roblox asset ID to preview"
+        },
+        includeProperties: {
+          type: "boolean",
+          description: "Include detailed properties for each instance (default: true)",
+          default: true
+        },
+        maxDepth: {
+          type: "number",
+          description: "Max hierarchy traversal depth (default: 10)",
+          default: 10
+        }
+      },
+      required: ["assetId"]
+    }
+  }
+];
+var getAllTools = () => [...TOOL_DEFINITIONS];
+
+// src/index.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var { version: VERSION } = require2("../package.json");
+var server = new RobloxStudioMCPServer({
+  name: "robloxstudio-mcp",
+  version: VERSION,
+  tools: getAllTools()
+});
 server.run().catch((error) => {
-    console.error('Server failed to start:', error);
-    process.exit(1);
+  console.error("Server failed to start:", error);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map