unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/handlers/asset-handlers.js

@@ -0,0 +1,496 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { executeAutomationRequest } from './common-handlers.js';
+import { normalizeArgs } from './argument-helper.js';
+export async function handleAssetTools(action, args, tools) {
+    switch (action) {
+        case 'list': {
+            const params = normalizeArgs(args, [
+                { key: 'path', aliases: ['directory', 'assetPath'], default: '/Game' },
+                { key: 'limit', default: 50 },
+                { key: 'recursive', default: false },
+                { key: 'depth', default: undefined }
+            ]);
+            const recursive = params.recursive === true || (params.depth !== undefined && params.depth > 0);
+            const res = await executeAutomationRequest(tools, 'list', {
+                path: params.path,
+                recursive,
+                depth: params.depth
+            });
+            const response = res;
+            const assets = (Array.isArray(response.assets) ? response.assets :
+                (Array.isArray(response.result) ? response.result : (response.result?.assets || [])));
+            const folders = Array.isArray(response.folders) ? response.folders : (response.result?.folders || []);
+            const totalCount = assets.length;
+            const limitedAssets = assets.slice(0, params.limit);
+            const remaining = Math.max(0, totalCount - params.limit);
+            let message = `Found ${totalCount} assets`;
+            if (folders.length > 0) {
+                message += ` and ${folders.length} folders`;
+            }
+            message += `: ${limitedAssets.map((a) => a.path || a.package || a.name).join(', ')}`;
+            if (folders.length > 0 && limitedAssets.length < params.limit) {
+                const remainingLimit = params.limit - limitedAssets.length;
+                if (remainingLimit > 0) {
+                    const limitedFolders = folders.slice(0, remainingLimit);
+                    if (limitedAssets.length > 0)
+                        message += ', ';
+                    message += `Folders: [${limitedFolders.join(', ')}]`;
+                    if (folders.length > remainingLimit)
+                        message += '...';
+                }
+            }
+            if (remaining > 0) {
+                message += `... and ${remaining} others`;
+            }
+            return {
+                message: message,
+                assets: limitedAssets,
+                folders: folders,
+                totalCount: totalCount,
+                count: limitedAssets.length
+            };
+        }
+        case 'create_folder': {
+            const params = normalizeArgs(args, [
+                { key: 'path', aliases: ['directoryPath'], required: true }
+            ]);
+            const res = await tools.assetTools.createFolder(params.path);
+            return cleanObject(res);
+        }
+        case 'import': {
+            const params = normalizeArgs(args, [
+                { key: 'sourcePath', required: true },
+                { key: 'destinationPath', required: true },
+                { key: 'overwrite', default: false },
+                { key: 'save', default: true }
+            ]);
+            const res = await tools.assetTools.importAsset({
+                sourcePath: params.sourcePath,
+                destinationPath: params.destinationPath,
+                overwrite: params.overwrite,
+                save: params.save
+            });
+            return cleanObject(res);
+        }
+        case 'duplicate': {
+            const params = normalizeArgs(args, [
+                { key: 'sourcePath', aliases: ['assetPath'], required: true },
+                { key: 'destinationPath' },
+                { key: 'newName' }
+            ]);
+            let destinationPath = params.destinationPath;
+            if (params.newName) {
+                if (!destinationPath) {
+                    const lastSlash = params.sourcePath.lastIndexOf('/');
+                    const parentDir = lastSlash > 0 ? params.sourcePath.substring(0, lastSlash) : '/Game';
+                    destinationPath = `${parentDir}/${params.newName}`;
+                }
+                else if (!destinationPath.endsWith(params.newName)) {
+                    if (destinationPath.endsWith('/')) {
+                        destinationPath = `${destinationPath}${params.newName}`;
+                    }
+                }
+            }
+            if (!destinationPath) {
+                throw new Error('destinationPath or newName is required for duplicate action');
+            }
+            const res = await tools.assetTools.duplicateAsset({
+                sourcePath: params.sourcePath,
+                destinationPath
+            });
+            return cleanObject(res);
+        }
+        case 'rename': {
+            const params = normalizeArgs(args, [
+                { key: 'sourcePath', aliases: ['assetPath'], required: true },
+                { key: 'destinationPath' },
+                { key: 'newName' }
+            ]);
+            let destinationPath = params.destinationPath;
+            if (!destinationPath && params.newName) {
+                const lastSlash = params.sourcePath.lastIndexOf('/');
+                const parentDir = lastSlash > 0 ? params.sourcePath.substring(0, lastSlash) : '/Game';
+                destinationPath = `${parentDir}/${params.newName}`;
+            }
+            if (!destinationPath)
+                throw new Error('Missing destinationPath or newName');
+            const res = await tools.assetTools.renameAsset({
+                sourcePath: params.sourcePath,
+                destinationPath
+            });
+            if (res && res.success === false) {
+                const msg = (res.message || '').toLowerCase();
+                if (msg.includes('already exists') || msg.includes('exists')) {
+                    return cleanObject({
+                        success: false,
+                        error: 'ASSET_ALREADY_EXISTS',
+                        message: res.message || 'Asset already exists at destination',
+                        sourcePath: params.sourcePath,
+                        destinationPath
+                    });
+                }
+            }
+            return cleanObject(res);
+        }
+        case 'move': {
+            const params = normalizeArgs(args, [
+                { key: 'sourcePath', aliases: ['assetPath'], required: true },
+                { key: 'destinationPath' }
+            ]);
+            let destinationPath = params.destinationPath;
+            const assetName = params.sourcePath.split('/').pop();
+            if (assetName && destinationPath && !destinationPath.endsWith(assetName)) {
+                destinationPath = `${destinationPath.replace(/\/$/, '')}/${assetName}`;
+            }
+            const res = await tools.assetTools.moveAsset({
+                sourcePath: params.sourcePath,
+                destinationPath
+            });
+            return cleanObject(res);
+        }
+        case 'delete_assets':
+        case 'delete_asset':
+        case 'delete': {
+            let paths = [];
+            if (Array.isArray(args.paths)) {
+                paths = args.paths;
+            }
+            else if (Array.isArray(args.assetPaths)) {
+                paths = args.assetPaths;
+            }
+            else {
+                const single = args.assetPath || args.path;
+                if (typeof single === 'string' && single.trim()) {
+                    paths = [single.trim()];
+                }
+            }
+            if (paths.length === 0) {
+                throw new Error('No paths provided for delete action');
+            }
+            const res = await tools.assetTools.deleteAssets({ paths });
+            return cleanObject(res);
+        }
+        case 'generate_lods': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'lodCount', required: true }
+            ]);
+            return cleanObject(await tools.assetTools.generateLODs({
+                assetPath: params.assetPath,
+                lodCount: params.lodCount
+            }));
+        }
+        case 'create_thumbnail': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'width' },
+                { key: 'height' }
+            ]);
+            const res = await tools.assetTools.createThumbnail({
+                assetPath: params.assetPath,
+                width: params.width,
+                height: params.height
+            });
+            return cleanObject(res);
+        }
+        case 'set_tags': {
+            try {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', required: true },
+                    { key: 'tags', required: true }
+                ]);
+                const res = await tools.assetTools.setTags({ assetPath: params.assetPath, tags: params.tags });
+                return cleanObject(res);
+            }
+            catch (err) {
+                const message = String(err?.message || err || '').toLowerCase();
+                if (message.includes('not_implemented') ||
+                    message.includes('not implemented') ||
+                    message.includes('unknown action') ||
+                    message.includes('unknown subaction')) {
+                    return cleanObject({
+                        success: false,
+                        error: 'NOT_IMPLEMENTED',
+                        message: 'Asset tag writes are not implemented by the automation plugin.',
+                        action: 'set_tags',
+                        assetPath: args.assetPath,
+                        tags: args.tags
+                    });
+                }
+                throw err;
+            }
+        }
+        case 'get_metadata': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await tools.assetTools.getMetadata({ assetPath: params.assetPath });
+            const tags = res.tags || {};
+            const metadata = res.metadata || {};
+            const merged = { ...tags, ...metadata };
+            const tagCount = Object.keys(merged).length;
+            const cleanRes = cleanObject(res);
+            cleanRes.message = `Metadata retrieved (${tagCount} items)`;
+            cleanRes.tags = tags;
+            if (Object.keys(metadata).length > 0) {
+                cleanRes.metadata = metadata;
+            }
+            return cleanRes;
+        }
+        case 'set_metadata': {
+            const res = await executeAutomationRequest(tools, 'set_metadata', args);
+            return cleanObject(res);
+        }
+        case 'validate':
+        case 'validate_asset': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await tools.assetTools.validate({ assetPath: params.assetPath });
+            return cleanObject(res);
+        }
+        case 'generate_report': {
+            const params = normalizeArgs(args, [
+                { key: 'directory' },
+                { key: 'reportType' },
+                { key: 'outputPath' }
+            ]);
+            const res = await tools.assetTools.generateReport({
+                directory: params.directory,
+                reportType: params.reportType,
+                outputPath: params.outputPath
+            });
+            return cleanObject(res);
+        }
+        case 'create_material_instance': {
+            const res = await executeAutomationRequest(tools, 'create_material_instance', args, 'Automation bridge not available for create_material_instance');
+            const result = res?.result ?? res ?? {};
+            const errorCode = typeof result.error === 'string' ? result.error.toUpperCase() : '';
+            const message = typeof result.message === 'string' ? result.message : '';
+            if (errorCode === 'PARENT_NOT_FOUND' || message.toLowerCase().includes('parent material not found')) {
+                return cleanObject({
+                    success: false,
+                    error: 'PARENT_NOT_FOUND',
+                    message: message || 'Parent material not found',
+                    path: result.path,
+                    parentMaterial: args.parentMaterial
+                });
+            }
+            return cleanObject(res);
+        }
+        case 'search_assets': {
+            const params = normalizeArgs(args, [
+                { key: 'classNames' },
+                { key: 'packagePaths' },
+                { key: 'recursivePaths' },
+                { key: 'recursiveClasses' },
+                { key: 'limit' }
+            ]);
+            const res = await tools.assetTools.searchAssets({
+                classNames: params.classNames,
+                packagePaths: params.packagePaths,
+                recursivePaths: params.recursivePaths,
+                recursiveClasses: params.recursiveClasses,
+                limit: params.limit
+            });
+            return cleanObject(res);
+        }
+        case 'find_by_tag': {
+            const params = normalizeArgs(args, [
+                { key: 'tag', required: true },
+                { key: 'value' }
+            ]);
+            return tools.assetTools.findByTag({ tag: params.tag, value: params.value });
+        }
+        case 'get_dependencies': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'recursive' }
+            ]);
+            const res = await tools.assetTools.getDependencies({ assetPath: params.assetPath, recursive: params.recursive });
+            return cleanObject(res);
+        }
+        case 'get_source_control_state': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await tools.assetTools.getSourceControlState({ assetPath: params.assetPath });
+            return cleanObject(res);
+        }
+        case 'analyze_graph': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'maxDepth' }
+            ]);
+            const res = await executeAutomationRequest(tools, 'get_asset_graph', {
+                assetPath: params.assetPath,
+                maxDepth: params.maxDepth
+            });
+            return cleanObject(res);
+        }
+        case 'create_render_target': {
+            const params = normalizeArgs(args, [
+                { key: 'name', required: true },
+                { key: 'packagePath', aliases: ['path'], default: '/Game' },
+                { key: 'width' },
+                { key: 'height' },
+                { key: 'format' }
+            ]);
+            const res = await executeAutomationRequest(tools, 'manage_render', {
+                subAction: 'create_render_target',
+                name: params.name,
+                packagePath: params.packagePath,
+                width: params.width,
+                height: params.height,
+                format: params.format,
+                save: true
+            });
+            return cleanObject(res);
+        }
+        case 'nanite_rebuild_mesh': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', aliases: ['meshPath'], required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'manage_render', {
+                subAction: 'nanite_rebuild_mesh',
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'fixup_redirectors': {
+            const directoryRaw = typeof args.directory === 'string' && args.directory.trim().length > 0
+                ? args.directory.trim()
+                : (typeof args.directoryPath === 'string' && args.directoryPath.trim().length > 0
+                    ? args.directoryPath.trim()
+                    : '');
+            const payload = {};
+            if (directoryRaw) {
+                payload.directoryPath = directoryRaw;
+            }
+            if (typeof args.checkoutFiles === 'boolean') {
+                payload.checkoutFiles = args.checkoutFiles;
+            }
+            const res = await executeAutomationRequest(tools, 'fixup_redirectors', payload);
+            return cleanObject(res);
+        }
+        case 'add_material_parameter': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'parameterName', aliases: ['name'], required: true },
+                { key: 'parameterType', aliases: ['type'] },
+                { key: 'value', aliases: ['defaultValue'] }
+            ]);
+            const res = await executeAutomationRequest(tools, 'add_material_parameter', {
+                assetPath: params.assetPath,
+                name: params.parameterName,
+                type: params.parameterType,
+                value: params.value
+            });
+            return cleanObject(res);
+        }
+        case 'list_instances': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'list_instances', {
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'reset_instance_parameters': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'reset_instance_parameters', {
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'exists': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'exists', {
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'get_material_stats': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'get_material_stats', {
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'rebuild_material': {
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true }
+            ]);
+            const res = await executeAutomationRequest(tools, 'rebuild_material', {
+                assetPath: params.assetPath
+            });
+            return cleanObject(res);
+        }
+        case 'add_material_node': {
+            const materialNodeAliases = {
+                'Multiply': 'MaterialExpressionMultiply',
+                'Add': 'MaterialExpressionAdd',
+                'Subtract': 'MaterialExpressionSubtract',
+                'Divide': 'MaterialExpressionDivide',
+                'Power': 'MaterialExpressionPower',
+                'Clamp': 'MaterialExpressionClamp',
+                'Constant': 'MaterialExpressionConstant',
+                'Constant2Vector': 'MaterialExpressionConstant2Vector',
+                'Constant3Vector': 'MaterialExpressionConstant3Vector',
+                'Constant4Vector': 'MaterialExpressionConstant4Vector',
+                'TextureSample': 'MaterialExpressionTextureSample',
+                'TextureCoordinate': 'MaterialExpressionTextureCoordinate',
+                'Panner': 'MaterialExpressionPanner',
+                'Rotator': 'MaterialExpressionRotator',
+                'Lerp': 'MaterialExpressionLinearInterpolate',
+                'LinearInterpolate': 'MaterialExpressionLinearInterpolate',
+                'Sine': 'MaterialExpressionSine',
+                'Cosine': 'MaterialExpressionCosine',
+                'Append': 'MaterialExpressionAppendVector',
+                'AppendVector': 'MaterialExpressionAppendVector',
+                'ComponentMask': 'MaterialExpressionComponentMask',
+                'Fresnel': 'MaterialExpressionFresnel',
+                'Time': 'MaterialExpressionTime',
+                'ScalarParameter': 'MaterialExpressionScalarParameter',
+                'VectorParameter': 'MaterialExpressionVectorParameter',
+                'StaticSwitchParameter': 'MaterialExpressionStaticSwitchParameter'
+            };
+            const params = normalizeArgs(args, [
+                { key: 'assetPath', required: true },
+                { key: 'nodeType', aliases: ['type'], required: true, map: materialNodeAliases },
+                { key: 'posX' },
+                { key: 'posY' }
+            ]);
+            const res = await executeAutomationRequest(tools, 'add_material_node', {
+                assetPath: params.assetPath,
+                nodeType: params.nodeType,
+                posX: params.posX,
+                posY: params.posY
+            });
+            return cleanObject(res);
+        }
+        default:
+            const res = await executeAutomationRequest(tools, action || 'manage_asset', args);
+            const result = res?.result ?? res ?? {};
+            const errorCode = typeof result.error === 'string' ? result.error.toUpperCase() : '';
+            const message = typeof result.message === 'string' ? result.message : '';
+            if (errorCode === 'INVALID_SUBACTION' || message.toLowerCase().includes('unknown subaction')) {
+                return cleanObject({
+                    success: false,
+                    error: 'INVALID_SUBACTION',
+                    message: 'Asset action not recognized by the automation plugin.',
+                    action: action || 'manage_asset',
+                    assetPath: args.assetPath ?? args.path
+                });
+            }
+            return cleanObject(res);
+    }
+}
+//# sourceMappingURL=asset-handlers.js.map

package/dist/tools/handlers/audio-handlers.d.ts

@@ -0,0 +1,3 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleAudioTools(action: string, args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=audio-handlers.d.ts.map

package/dist/tools/handlers/audio-handlers.js

@@ -0,0 +1,166 @@
+import { cleanObject } from '../../utils/safe-json.js';
+import { requireNonEmptyString } from './common-handlers.js';
+function toVec3Array(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const x = Number(v.x);
+    const y = Number(v.y);
+    const z = Number(v.z);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        return undefined;
+    return [x, y, z];
+}
+function toRotArray(r) {
+    if (!r || typeof r !== 'object')
+        return undefined;
+    const pitch = Number(r.pitch);
+    const yaw = Number(r.yaw);
+    const roll = Number(r.roll);
+    if (!Number.isFinite(pitch) || !Number.isFinite(yaw) || !Number.isFinite(roll))
+        return undefined;
+    return [pitch, yaw, roll];
+}
+function getTimeoutMs() {
+    const envDefault = Number(process.env.MCP_AUTOMATION_REQUEST_TIMEOUT_MS ?? '120000');
+    return Number.isFinite(envDefault) && envDefault > 0 ? envDefault : 120000;
+}
+export async function handleAudioTools(action, args, tools) {
+    switch (action) {
+        case 'create_sound_cue':
+            requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
+            requireNonEmptyString(args?.wavePath ?? args?.soundPath, 'soundPath', 'Missing required parameter: soundPath (or wavePath)');
+            return cleanObject(await tools.audioTools.createSoundCue({
+                name: args.name,
+                wavePath: args.wavePath ?? args.soundPath,
+                savePath: args.savePath,
+                settings: args.settings
+            }));
+        case 'play_sound_at_location':
+            requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
+            return cleanObject(await tools.audioTools.playSoundAtLocation({
+                soundPath: args.soundPath,
+                location: toVec3Array(args.location) ?? [0, 0, 0],
+                rotation: toRotArray(args.rotation),
+                volume: args.volume,
+                pitch: args.pitch,
+                startTime: args.startTime,
+                attenuationPath: args.attenuationPath,
+                concurrencyPath: args.concurrencyPath
+            }));
+        case 'play_sound_2d':
+            requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
+            return cleanObject(await tools.audioTools.playSound2D({
+                soundPath: args.soundPath,
+                volume: args.volume,
+                pitch: args.pitch,
+                startTime: args.startTime
+            }));
+        case 'create_audio_component':
+            requireNonEmptyString(args?.actorName, 'actorName', 'Missing required parameter: actorName');
+            requireNonEmptyString(args?.componentName, 'componentName', 'Missing required parameter: componentName');
+            requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
+            return cleanObject(await tools.audioTools.createAudioComponent({
+                actorName: args.actorName,
+                componentName: args.componentName,
+                soundPath: args.soundPath,
+                autoPlay: args.autoPlay,
+                is3D: args.is3D
+            }));
+        case 'set_sound_attenuation':
+            requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
+            return cleanObject(await tools.audioTools.setSoundAttenuation({
+                name: args.name,
+                innerRadius: args.innerRadius,
+                falloffDistance: args.falloffDistance,
+                attenuationShape: args.attenuationShape,
+                falloffMode: args.falloffMode
+            }));
+        case 'create_sound_class':
+            requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
+            return cleanObject(await tools.audioTools.createSoundClass({
+                name: args.name,
+                parentClass: args.parentClass,
+                properties: args.properties
+            }));
+        case 'create_sound_mix':
+            requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
+            return cleanObject(await tools.audioTools.createSoundMix({
+                name: args.name,
+                classAdjusters: args.classAdjusters
+            }));
+        case 'push_sound_mix':
+            requireNonEmptyString(args?.mixName ?? args?.name, 'mixName', 'Missing required parameter: mixName (or name)');
+            return cleanObject(await tools.audioTools.pushSoundMix({
+                mixName: args.mixName ?? args.name
+            }));
+        case 'pop_sound_mix':
+            requireNonEmptyString(args?.mixName ?? args?.name, 'mixName', 'Missing required parameter: mixName (or name)');
+            return cleanObject(await tools.audioTools.popSoundMix({
+                mixName: args.mixName ?? args.name
+            }));
+        case 'create_ambient_sound':
+            requireNonEmptyString(args?.soundPath, 'soundPath', 'Missing required parameter: soundPath');
+            return cleanObject(await tools.audioTools.createAmbientSound({
+                soundPath: args.soundPath,
+                location: toVec3Array(args.location) ?? [0, 0, 0],
+                volume: args.volume,
+                pitch: args.pitch,
+                startTime: args.startTime,
+                attenuationPath: args.attenuationPath,
+                concurrencyPath: args.concurrencyPath
+            }));
+        case 'create_reverb_zone':
+            requireNonEmptyString(args?.name, 'name', 'Missing required parameter: name');
+            return cleanObject(await tools.audioTools.createReverbZone({
+                name: args.name,
+                location: toVec3Array(args.location) ?? [0, 0, 0],
+                size: toVec3Array(args.size) ?? [0, 0, 0],
+                reverbEffect: args.reverbEffect,
+                volume: args.volume,
+                fadeTime: args.fadeTime
+            }));
+        case 'enable_audio_analysis':
+            return cleanObject(await tools.audioTools.enableAudioAnalysis({
+                enabled: args.enabled,
+                fftSize: args.fftSize,
+                outputType: args.outputType
+            }));
+        case 'fade_sound':
+            requireNonEmptyString(args?.soundName, 'soundName', 'Missing required parameter: soundName');
+            return cleanObject(await tools.audioTools.fadeSound({
+                soundName: args.soundName,
+                targetVolume: args.targetVolume,
+                fadeTime: args.fadeTime,
+                fadeType: args.fadeType
+            }));
+        case 'set_doppler_effect':
+            return cleanObject(await tools.audioTools.setDopplerEffect({
+                enabled: args.enabled,
+                scale: args.scale
+            }));
+        case 'set_audio_occlusion':
+            return cleanObject(await tools.audioTools.setAudioOcclusion({
+                enabled: args.enabled,
+                lowPassFilterFrequency: args.lowPassFilterFrequency,
+                volumeAttenuation: args.volumeAttenuation
+            }));
+        case 'spawn_sound_at_location':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('spawn_sound_at_location', args, { timeoutMs: getTimeoutMs() }));
+        case 'play_sound_attached':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('play_sound_attached', args, { timeoutMs: getTimeoutMs() }));
+        case 'set_sound_mix_class_override':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('set_sound_mix_class_override', args, { timeoutMs: getTimeoutMs() }));
+        case 'clear_sound_mix_class_override':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('clear_sound_mix_class_override', args, { timeoutMs: getTimeoutMs() }));
+        case 'set_base_sound_mix':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('set_base_sound_mix', args, { timeoutMs: getTimeoutMs() }));
+        case 'prime_sound':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest('prime_sound', args, { timeoutMs: getTimeoutMs() }));
+        case 'fade_sound_in':
+        case 'fade_sound_out':
+            return cleanObject(await tools.automationBridge?.sendAutomationRequest(action, args, { timeoutMs: getTimeoutMs() }));
+        default:
+            return cleanObject({ success: false, error: 'UNKNOWN_ACTION', message: `Unknown audio action: ${action}` });
+    }
+}
+//# sourceMappingURL=audio-handlers.js.map

package/dist/tools/handlers/blueprint-handlers.d.ts

@@ -0,0 +1,4 @@
+import { ITools } from '../../types/tool-interfaces.js';
+export declare function handleBlueprintTools(action: string, args: any, tools: ITools): Promise<any>;
+export declare function handleBlueprintGet(args: any, tools: ITools): Promise<any>;
+//# sourceMappingURL=blueprint-handlers.d.ts.map