unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/debug.js

@@ -1,105 +1,46 @@
-import { bestEffortInterpretedText, coerceString, interpretStandardResult } from '../utils/result-helpers.js';
-import { parseStandardResult } from '../utils/python-output.js';
 export class DebugVisualizationTools {
     bridge;
+    automationBridge;
     constructor(bridge) {
         this.bridge = bridge;
     }
-    // Helper to draw via Python SystemLibrary with the editor world
-    async pyDraw(scriptBody, meta) {
-        const action = (meta?.action || 'debug_draw').replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-        const payloadObject = meta?.params ?? {};
-        const payloadJson = JSON.stringify(payloadObject).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-        const indentedBody = scriptBody
-            .split(/\r?\n/)
-            .map(line => `    ${line}`)
-            .join('\n');
-        const script = `
-import unreal
-import json
-
-payload = json.loads('${payloadJson}')
-ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-if not ues:
-    raise Exception('UnrealEditorSubsystem not available')
-world = ues.get_editor_world()
-if not world:
-    raise Exception('Editor world unavailable')
-try:
-${indentedBody}
-    print('DEBUG_DRAW:' + json.dumps({'action': '${action}', 'params': payload}))
-    print('RESULT:' + json.dumps({'success': True, 'action': '${action}', 'params': payload}))
-except Exception as e:
-    print('DEBUG_DRAW_ERROR:' + str(e))
-    print('RESULT:' + json.dumps({'success': False, 'action': '${action}', 'error': str(e)}))
-`.trim()
-            .replace(/\r?\n/g, '\n');
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
+    }
+    async useAutomationBridge(action, params) {
+        if (!this.automationBridge) {
+            return { success: false, error: 'AUTOMATION_BRIDGE_NOT_AVAILABLE', message: 'Automation Bridge not available for debug operations' };
+        }
         try {
-            const response = await this.bridge.executePython(script);
-            let interpreted = interpretStandardResult(response, {
-                successMessage: `${action} executed`,
-                failureMessage: `${action} failed`
+            const response = await this.automationBridge.sendAutomationRequest('create_effect', {
+                action: 'debug_shape',
+                shapeType: action,
+                ...params
             });
-            const parsed = parseStandardResult(response);
-            const parsedPayload = parsed.data ?? {};
-            const parsedSuccessValue = parsedPayload.success;
-            const normalizedSuccess = typeof parsedSuccessValue === 'string'
-                ? ['true', '1', 'yes'].includes(parsedSuccessValue.toLowerCase())
-                : parsedSuccessValue === true;
-            if (!interpreted.success && normalizedSuccess) {
-                interpreted = {
-                    ...interpreted,
-                    success: true,
-                    error: undefined,
-                    message: interpreted.message || `${action} executed`,
-                    payload: { ...parsedPayload }
-                };
-            }
-            const finalSuccess = interpreted.success || normalizedSuccess;
-            const resolvedAction = coerceString(interpreted.payload.action) ?? action;
-            const fallbackOutput = typeof parsed.text === 'string' ? parsed.text : '';
-            const rawOutput = bestEffortInterpretedText(interpreted) ?? (fallbackOutput ? fallbackOutput : undefined);
-            if (finalSuccess) {
-                return {
-                    ...interpreted.payload,
-                    success: true,
-                    action: resolvedAction,
-                    warnings: interpreted.warnings,
-                    details: interpreted.details,
-                    rawOutput,
-                    raw: parsed.raw ?? interpreted.raw
-                };
-            }
-            return {
-                success: false,
-                action: resolvedAction,
-                error: interpreted.error ?? `${resolvedAction} failed`,
-                warnings: interpreted.warnings,
-                details: interpreted.details,
-                rawOutput,
-                raw: parsed.raw ?? interpreted.raw
-            };
+            return response;
         }
-        catch (e) {
-            return { success: false, error: String(e), action: meta?.action || 'debug_draw' };
+        catch (error) {
+            return { success: false, error: 'AUTOMATION_BRIDGE_ERROR', message: String(error) };
         }
     }
-    // Draw debug line using Python SystemLibrary
     async drawDebugLine(params) {
         const color = params.color || [255, 0, 0, 255];
         const duration = params.duration ?? 5.0;
         const thickness = params.thickness ?? 1.0;
-        const [sr, sg, sb, sa] = color;
-        const [sx, sy, sz] = params.start;
-        const [ex, ey, ez] = params.end;
-        const script = `
-start = unreal.Vector(${sx}, ${sy}, ${sz})
-end = unreal.Vector(${ex}, ${ey}, ${ez})
-color = unreal.LinearColor(${sr}/255.0, ${sg}/255.0, ${sb}/255.0, ${sa}/255.0)
-unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${thickness})
-`;
-        return this.pyDraw(script, {
-            action: 'debug_line',
+        const result = await this.useAutomationBridge('line', {
+            start: params.start,
+            end: params.end,
+            color,
+            duration,
+            thickness
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug lines requires Automation Bridge debug_shape handler',
             params: {
                 start: params.start,
                 end: params.end,
@@ -107,27 +48,28 @@ unreal.SystemLibrary.draw_debug_line(world, start, end, color, ${duration}, ${th
                 duration,
                 thickness
             }
-        });
+        };
     }
-    // Draw debug box using Python SystemLibrary
     async drawDebugBox(params) {
         const color = params.color || [0, 255, 0, 255];
         const rotation = params.rotation || [0, 0, 0];
         const duration = params.duration ?? 5.0;
         const thickness = params.thickness ?? 1.0;
-        const [cr, cg, cb, ca] = color;
-        const [cx, cy, cz] = params.center;
-        const [ex, ey, ez] = params.extent;
-        const [rp, ry, rr] = rotation;
-        const script = `
-center = unreal.Vector(${cx}, ${cy}, ${cz})
-extent = unreal.Vector(${ex}, ${ey}, ${ez})
-rot = unreal.Rotator(${rp}, ${ry}, ${rr})
-color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
-unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duration}, ${thickness})
-`;
-        return this.pyDraw(script, {
-            action: 'debug_box',
+        const result = await this.useAutomationBridge('box', {
+            center: params.center,
+            extent: params.extent,
+            rotation,
+            color,
+            duration,
+            thickness
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug boxes requires Automation Bridge debug_shape handler',
             params: {
                 center: params.center,
                 extent: params.extent,
@@ -136,23 +78,28 @@ unreal.SystemLibrary.draw_debug_box(world, center, extent, color, rot, ${duratio
                 duration,
                 thickness
             }
-        });
+        };
     }
-    // Draw debug sphere using Python SystemLibrary
     async drawDebugSphere(params) {
         const segments = params.segments ?? 12;
         const color = params.color || [0, 0, 255, 255];
         const duration = params.duration ?? 5.0;
         const thickness = params.thickness ?? 1.0;
-        const [cr, cg, cb, ca] = color;
-        const [cx, cy, cz] = params.center;
-        const script = `
-center = unreal.Vector(${cx}, ${cy}, ${cz})
-color = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)
-unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segments}, color, ${duration}, ${thickness})
-`;
-        return this.pyDraw(script, {
-            action: 'debug_sphere',
+        const result = await this.useAutomationBridge('sphere', {
+            center: params.center,
+            radius: params.radius,
+            segments,
+            color,
+            duration,
+            thickness
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug spheres requires Automation Bridge debug_shape handler',
             params: {
                 center: params.center,
                 radius: params.radius,
@@ -161,19 +108,27 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 duration,
                 thickness
             }
-        });
+        };
     }
-    // The rest keep console-command fallbacks or editor helpers as before
     async drawDebugCapsule(params) {
         const rotation = params.rotation || [0, 0, 0];
         const color = params.color || [255, 255, 0, 255];
         const duration = params.duration || 5.0;
-        const [cx, cy, cz] = params.center;
-        const [rp, ry, rr] = rotation;
-        const [cr, cg, cb, ca] = color;
-        const script = `\ncenter = unreal.Vector(${cx}, ${cy}, ${cz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_capsule(world, center, ${params.halfHeight}, ${params.radius}, rot, color, ${duration}, 1.0)\n`;
-        return this.pyDraw(script, {
-            action: 'debug_capsule',
+        const result = await this.useAutomationBridge('capsule', {
+            center: params.center,
+            halfHeight: params.halfHeight,
+            radius: params.radius,
+            rotation,
+            color,
+            duration
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug capsules requires Automation Bridge debug_shape handler',
             params: {
                 center: params.center,
                 halfHeight: params.halfHeight,
@@ -182,17 +137,28 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 color,
                 duration
             }
-        });
+        };
     }
     async drawDebugCone(params) {
         const color = params.color || [255, 0, 255, 255];
         const duration = params.duration || 5.0;
-        const [ox, oy, oz] = params.origin;
-        const [dx, dy, dz] = params.direction;
-        const [cr, cg, cb, ca] = color;
-        const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\ndir = unreal.Vector(${dx}, ${dy}, ${dz})\ncolor = unreal.LinearColor(${cr}/255.0, ${cg}/255.0, ${cb}/255.0, ${ca}/255.0)\nunreal.SystemLibrary.draw_debug_cone(world, origin, dir, ${params.length}, ${params.angleWidth}, ${params.angleHeight}, ${params.numSides || 12}, color, ${duration}, 1.0)\n`;
-        return this.pyDraw(script, {
-            action: 'debug_cone',
+        const result = await this.useAutomationBridge('cone', {
+            origin: params.origin,
+            direction: params.direction,
+            length: params.length,
+            angleWidth: params.angleWidth,
+            angleHeight: params.angleHeight,
+            numSides: params.numSides || 12,
+            color,
+            duration
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug cones requires Automation Bridge debug_shape handler',
             params: {
                 origin: params.origin,
                 direction: params.direction,
@@ -203,16 +169,25 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 color,
                 duration
             }
-        });
+        };
     }
     async drawDebugString(params) {
         const color = params.color || [255, 255, 255, 255];
         const duration = params.duration || 5.0;
-        const [x, y, z] = params.location;
-        const [r, g, b, a] = color;
-        const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_string(world, loc, "${params.text.replace(/"/g, '\\"')}", None, color, ${duration})\n`;
-        return this.pyDraw(script, {
-            action: 'debug_string',
+        const result = await this.useAutomationBridge('string', {
+            location: params.location,
+            text: params.text,
+            color,
+            duration,
+            fontSize: params.fontSize
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug strings requires Automation Bridge debug_shape handler',
             params: {
                 location: params.location,
                 text: params.text,
@@ -220,18 +195,27 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 duration,
                 fontSize: params.fontSize
             }
-        });
+        };
     }
     async drawDebugArrow(params) {
         const color = params.color || [0, 255, 255, 255];
         const duration = params.duration || 5.0;
         const thickness = params.thickness || 2.0;
-        const [sx, sy, sz] = params.start;
-        const [ex, ey, ez] = params.end;
-        const [r, g, b, a] = color;
-        const script = `\nstart = unreal.Vector(${sx}, ${sy}, ${sz})\nend = unreal.Vector(${ex}, ${ey}, ${ez})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_arrow(world, start, end, ${params.arrowSize || 10.0}, color, ${duration}, ${thickness})\n`;
-        return this.pyDraw(script, {
-            action: 'debug_arrow',
+        const result = await this.useAutomationBridge('arrow', {
+            start: params.start,
+            end: params.end,
+            arrowSize: params.arrowSize || 10.0,
+            color,
+            duration,
+            thickness
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug arrows requires Automation Bridge debug_shape handler',
             params: {
                 start: params.start,
                 end: params.end,
@@ -240,32 +224,42 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 duration,
                 thickness
             }
-        });
+        };
     }
     async drawDebugPoint(params) {
         const size = params.size || 10.0;
         const color = params.color || [255, 255, 255, 255];
         const duration = params.duration || 5.0;
-        const [x, y, z] = params.location;
-        const [r, g, b, a] = color;
-        const script = `\nloc = unreal.Vector(${x}, ${y}, ${z})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_point(world, loc, ${size}, color, ${duration})\n`;
-        return this.pyDraw(script, {
-            action: 'debug_point',
+        const result = await this.useAutomationBridge('point', {
+            location: params.location,
+            size,
+            color,
+            duration
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug points requires Automation Bridge debug_shape handler',
             params: {
                 location: params.location,
                 size,
                 color,
                 duration
             }
-        });
+        };
     }
     async drawDebugCoordinateSystem(params) {
-        const rotation = params.rotation || [0, 0, 0];
-        const scale = params.scale || 100.0;
-        const duration = params.duration || 5.0;
-        const thickness = params.thickness || 2.0;
-        const command = `DrawDebugCoordinateSystem ${params.location.join(' ')} ${rotation.join(' ')} ${scale} ${duration} ${thickness}`;
-        return this.bridge.executeConsoleCommand(command);
+        const result = await this.useAutomationBridge('coordinate_system', {
+            location: params.location,
+            rotation: params.rotation || [0, 0, 0],
+            scale: params.scale || 1.0,
+            duration: params.duration || 5.0,
+            thickness: params.thickness || 1.0
+        });
+        return result;
     }
     async drawDebugFrustum(params) {
         const aspectRatio = params.aspectRatio || 1.77;
@@ -273,12 +267,23 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const farPlane = params.farPlane || 1000.0;
         const color = params.color || [128, 128, 255, 255];
         const duration = params.duration || 5.0;
-        const [ox, oy, oz] = params.origin;
-        const [rp, ry, rr] = params.rotation;
-        const [r, g, b, a] = color;
-        const script = `\norigin = unreal.Vector(${ox}, ${oy}, ${oz})\nrot = unreal.Rotator(${rp}, ${ry}, ${rr})\ncolor = unreal.LinearColor(${r}/255.0, ${g}/255.0, ${b}/255.0, ${a}/255.0)\nunreal.SystemLibrary.draw_debug_frustum(world, origin, rot, ${params.fov}, ${aspectRatio}, ${nearPlane}, ${farPlane}, color, ${duration})\n`;
-        return this.pyDraw(script, {
-            action: 'debug_frustum',
+        const result = await this.useAutomationBridge('frustum', {
+            origin: params.origin,
+            rotation: params.rotation,
+            fov: params.fov,
+            aspectRatio,
+            nearPlane,
+            farPlane,
+            color,
+            duration
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug frustums requires Automation Bridge debug_shape handler',
             params: {
                 origin: params.origin,
                 rotation: params.rotation,
@@ -289,9 +294,15 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
                 color,
                 duration
             }
-        });
+        };
     }
     async clearDebugDrawings() {
+        if (this.automationBridge) {
+            const response = await this.automationBridge.sendAutomationRequest('clear_debug_shapes', {});
+            if (response.success) {
+                return response;
+            }
+        }
         return this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
     }
     async showCollision(params) {
@@ -311,9 +322,7 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         return this.bridge.executeConsoleCommand(command);
     }
     async setViewMode(params) {
-        // Map non-viewmode requests to appropriate show flags for safety
         if (params.mode === 'CollisionPawn' || params.mode === 'CollisionVisibility') {
-            // Use collision visualization instead of viewmode (UE doesn't have these as view modes)
             await this.showCollision({ enabled: true, type: 'Both' });
             return { success: true, message: 'Collision visualization enabled (use show flags, not viewmode)' };
         }
@@ -321,7 +330,6 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
             'Lit', 'Unlit', 'Wireframe', 'DetailLighting', 'LightingOnly', 'LightComplexity', 'ShaderComplexity', 'LightmapDensity', 'StationaryLightOverlap', 'ReflectionOverride'
         ]);
         if (!VALID_VIEWMODES.has(params.mode)) {
-            // Fallback to Lit if unknown
             await this.bridge.executeConsoleCommand('viewmode Lit');
             return { success: false, warning: `Unknown or unsupported viewmode '${params.mode}'. Reverted to Lit.` };
         }
@@ -368,12 +376,26 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
         const color = params.color || [255, 128, 0, 255];
         const duration = params.duration || 5.0;
         const thickness = params.thickness || 2.0;
-        for (let i = 0; i < params.points.length - 1; i++) {
-            const start = params.points[i];
-            const end = params.points[i + 1];
-            await this.drawDebugLine({ start, end, color, duration, thickness });
+        const result = await this.useAutomationBridge('path', {
+            points: params.points,
+            color,
+            duration,
+            thickness
+        });
+        if (result.success) {
+            return result;
         }
-        return { success: true, message: `Debug path drawn with ${params.points.length} points` };
+        return {
+            success: false,
+            error: result.error || 'AUTOMATION_BRIDGE_REQUIRED',
+            message: result.message || 'Drawing debug paths requires Automation Bridge debug_shape handler',
+            params: {
+                points: params.points,
+                color,
+                duration,
+                thickness
+            }
+        };
     }
     async showNavigationMesh(params) {
         const command = params.enabled ? 'show Navigation' : 'show Navigation 0';
@@ -381,19 +403,51 @@ unreal.SystemLibrary.draw_debug_sphere(world, center, ${params.radius}, ${segmen
     }
     async enableOnScreenMessages(params) {
         if (params.enabled && params.message) {
-            const key = params.key || -1;
-            const duration = params.duration || 5.0;
-            const color = params.color || [255, 255, 255, 255];
-            const command = `ke * DisplayDebugMessage ${key} "${params.message}" ${duration} ${color.join(' ')}`;
-            return this.bridge.executeConsoleCommand(command);
-        }
-        else {
-            return this.bridge.executeConsoleCommand('DisableAllScreenMessages');
+            const result = await this.useAutomationBridge('message', {
+                message: params.message,
+                duration: params.duration || 5.0,
+                color: params.color || [255, 255, 255, 255]
+            });
+            if (result.success) {
+                return result;
+            }
+            return {
+                success: false,
+                error: 'AUTOMATION_BRIDGE_REQUIRED',
+                message: 'Showing on-screen messages requires Automation Bridge'
+            };
         }
+        const command = params.enabled ? 'EnableAllScreenMessages' : 'DisableAllScreenMessages';
+        return this.bridge.executeConsoleCommand(command);
     }
     async showSkeletalMeshBones(params) {
-        const command = params.enabled ? `ShowDebugSkelMesh ${params.actorName}` : `HideDebugSkelMesh ${params.actorName}`;
-        return this.bridge.executeConsoleCommand(command);
+        const result = await this.useAutomationBridge('skeletal_meshes', {
+            actorName: params.actorName,
+            enabled: params.enabled
+        });
+        if (result.success) {
+            return result;
+        }
+        return {
+            success: false,
+            error: 'AUTOMATION_BRIDGE_REQUIRED',
+            message: 'Showing skeletal mesh bones requires Automation Bridge'
+        };
+    }
+    async clearDebugShapes() {
+        if (this.automationBridge) {
+            const response = await this.automationBridge.sendAutomationRequest('clear_debug_shapes', {});
+            if (response.success) {
+                return response;
+            }
+        }
+        try {
+            await this.bridge.executeConsoleCommand('FlushPersistentDebugLines');
+            return { success: true, message: 'Debug shapes cleared' };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to clear debug shapes: ${err}` };
+        }
     }
 }
 //# sourceMappingURL=debug.js.map

package/dist/tools/dynamic-handler-registry.d.ts

@@ -0,0 +1,13 @@
+import { ITools } from '../types/tool-interfaces.js';
+type ToolHandler = (args: any, tools: ITools) => Promise<any>;
+export declare class DynamicHandlerRegistry {
+    private handlers;
+    register(toolName: string, handler: ToolHandler): void;
+    getHandler(toolName: string): ToolHandler | undefined;
+    hasHandler(toolName: string): boolean;
+    removeHandler(toolName: string): boolean;
+    getAllRegisteredTools(): string[];
+}
+export declare const toolRegistry: DynamicHandlerRegistry;
+export {};
+//# sourceMappingURL=dynamic-handler-registry.d.ts.map

package/dist/tools/dynamic-handler-registry.js

@@ -0,0 +1,23 @@
+export class DynamicHandlerRegistry {
+    handlers = new Map();
+    register(toolName, handler) {
+        if (this.handlers.has(toolName)) {
+            console.warn(`Handler for tool '${toolName}' is being overwritten.`);
+        }
+        this.handlers.set(toolName, handler);
+    }
+    getHandler(toolName) {
+        return this.handlers.get(toolName);
+    }
+    hasHandler(toolName) {
+        return this.handlers.has(toolName);
+    }
+    removeHandler(toolName) {
+        return this.handlers.delete(toolName);
+    }
+    getAllRegisteredTools() {
+        return Array.from(this.handlers.keys());
+    }
+}
+export const toolRegistry = new DynamicHandlerRegistry();
+//# sourceMappingURL=dynamic-handler-registry.js.map