unreal-engine-mcp-server 0.5.1 → 0.5.2

package/dist/utils/response-validator.js

@@ -21,91 +21,106 @@ function buildSummaryText(toolName, payload) {
         return `${toolName} responded`;
     }
     const effectivePayload = { ...payload };
-    if (isRecord(effectivePayload.data)) {
-        Object.assign(effectivePayload, effectivePayload.data);
-    }
-    if (isRecord(effectivePayload.result)) {
-        Object.assign(effectivePayload, effectivePayload.result);
-    }
-    const parts = [];
-    const listKeys = ['actors', 'levels', 'assets', 'folders', 'blueprints', 'components', 'pawnClasses', 'foliageTypes', 'nodes', 'tracks', 'bindings', 'keys'];
-    for (const key of listKeys) {
-        if (Array.isArray(effectivePayload[key])) {
-            const arr = effectivePayload[key];
-            const names = arr.map(i => isRecord(i) ? (i.name || i.path || i.id || i.assetName || i.objectPath || i.packageName || i.nodeName || '<?>') : String(i));
-            const count = arr.length;
-            const preview = names.slice(0, 100).join(', ');
-            const suffix = count > 100 ? `, ... (+${count - 100} more)` : '';
-            parts.push(`${key}: ${preview}${suffix} (Total: ${count})`);
+    const flattenWrappers = (obj, depth = 0) => {
+        if (depth > 5)
+            return;
+        if (isRecord(obj.data)) {
+            Object.assign(obj, obj.data);
+            delete obj.data;
+            flattenWrappers(obj, depth + 1);
         }
-    }
-    if (typeof effectivePayload.actor === 'string' || isRecord(effectivePayload.actor)) {
-        const a = effectivePayload.actor;
-        const name = isRecord(a) ? (a.name || a.path) : a;
-        const loc = isRecord(effectivePayload.location) ? ` at [${effectivePayload.location.x},${effectivePayload.location.y},${effectivePayload.location.z}]` : '';
-        parts.push(`Actor: ${name}${loc}`);
-    }
-    if (typeof effectivePayload.asset === 'string' || isRecord(effectivePayload.asset)) {
-        const a = effectivePayload.asset;
-        const path = isRecord(a) ? (a.path || a.name) : a;
-        parts.push(`Asset: ${path}`);
-    }
-    if (typeof effectivePayload.blueprint === 'string' || isRecord(effectivePayload.blueprint)) {
-        const bp = effectivePayload.blueprint;
-        const name = isRecord(bp) ? (bp.name || bp.path || effectivePayload.blueprintPath) : bp;
-        parts.push(`Blueprint: ${name}`);
-    }
-    if (typeof effectivePayload.sequence === 'string' || isRecord(effectivePayload.sequence)) {
-        const seq = effectivePayload.sequence;
-        const name = isRecord(seq) ? (seq.name || seq.path) : seq;
-        parts.push(`Sequence: ${name}`);
-    }
-    const usefulKeys = [
-        'success', 'error', 'message', 'assets', 'folders', 'count', 'totalCount',
-        'saved', 'valid', 'issues', 'class', 'skeleton', 'parent',
-        'package', 'dependencies', 'graph', 'tags', 'metadata', 'properties'
-    ];
-    for (const key of usefulKeys) {
-        if (effectivePayload[key] !== undefined && effectivePayload[key] !== null) {
-            const val = effectivePayload[key];
-            if (typeof val === 'object') {
-                if (key === 'metadata' || key === 'properties' || key === 'tags') {
-                    const entries = Object.entries(val);
-                    const formatted = entries.map(([k, v]) => `${k}=${v}`);
-                    const limit = 50;
-                    parts.push(`${key}: { ${formatted.slice(0, limit).join(', ')}${formatted.length > limit ? '...' : ''} }`);
-                    continue;
+        if (isRecord(obj.result)) {
+            Object.assign(obj, obj.result);
+            delete obj.result;
+            flattenWrappers(obj, depth + 1);
+        }
+    };
+    flattenWrappers(effectivePayload);
+    const parts = [];
+    const addedKeys = new Set();
+    const skipKeys = new Set(['requestId', 'type', 'data', 'result', 'warnings']);
+    const formatValue = (val) => {
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'string')
+            return val.length > 150 ? val.slice(0, 150) + '...' : val;
+        if (typeof val === 'number' || typeof val === 'boolean')
+            return String(val);
+        if (Array.isArray(val)) {
+            if (val.length === 0)
+                return '[] (0)';
+            const items = val.slice(0, 30).map(v => {
+                if (isRecord(v)) {
+                    return v.name || v.path || v.id || v.nodeId || v.nodeName || v.className ||
+                        v.displayName || v.type || v.assetPath || v.objectPath ||
+                        JSON.stringify(v).slice(0, 50);
                 }
-                continue;
+                return String(v);
+            });
+            const suffix = val.length > 30 ? `, ... (+${val.length - 30} more)` : '';
+            return `[${items.join(', ')}${suffix}] (${val.length})`;
+        }
+        if (isRecord(val)) {
+            const keys = Object.keys(val);
+            if (keys.some(k => ['x', 'y', 'z', 'pitch', 'yaw', 'roll'].includes(k))) {
+                const x = val.x ?? val.pitch ?? 0;
+                const y = val.y ?? val.yaw ?? 0;
+                const z = val.z ?? val.roll ?? 0;
+                return `[${x}, ${y}, ${z}]`;
             }
-            const strVal = String(val);
-            if (strVal.length > 100)
-                continue;
-            if (!parts.some(p => p.includes(strVal))) {
-                parts.push(`${key}: ${strVal}`);
+            const entries = Object.entries(val).slice(0, 8);
+            const formatted = entries.map(([k, v]) => {
+                const vStr = typeof v === 'object' ? JSON.stringify(v).slice(0, 40) : String(v);
+                return `${k}=${vStr}`;
+            });
+            return `{ ${formatted.join(', ')}${keys.length > 8 ? ' ...' : ''} }`;
+        }
+        return String(val);
+    };
+    for (const key of ['success', 'error']) {
+        if (effectivePayload[key] !== undefined && !addedKeys.has(key)) {
+            const formatted = formatValue(effectivePayload[key]);
+            if (formatted) {
+                parts.push(`${key}: ${formatted}`);
+                addedKeys.add(key);
             }
         }
     }
-    const success = typeof payload.success === 'boolean' ? payload.success : undefined;
-    const message = typeof payload.message === 'string' ? normalizeText(payload.message) : '';
-    const error = typeof payload.error === 'string' ? normalizeText(payload.error) : '';
-    if (parts.length > 0) {
-        if (message && message.toLowerCase() !== 'success') {
-            parts.push(message);
+    let hasArrays = false;
+    for (const [key, val] of Object.entries(effectivePayload)) {
+        if (addedKeys.has(key))
+            continue;
+        if (skipKeys.has(key))
+            continue;
+        if (val === undefined || val === null)
+            continue;
+        if (typeof val === 'string' && val.trim() === '')
+            continue;
+        if (key === 'message')
+            continue;
+        if (Array.isArray(val) && val.length > 0)
+            hasArrays = true;
+        if ((key === 'count' || key === 'totalCount') && hasArrays)
+            continue;
+        const formatted = formatValue(val);
+        if (formatted) {
+            parts.push(`${key}: ${formatted}`);
+            addedKeys.add(key);
         }
     }
-    else {
-        if (message)
+    const message = typeof effectivePayload.message === 'string' ? normalizeText(effectivePayload.message) : '';
+    if (message && message.toLowerCase() !== 'success') {
+        const isDuplicateInfo = /^(found|listed|retrieved|got|loaded|created|deleted|saved|spawned)\s+\d+/i.test(message) ||
+            /Folders:\s*\[/.test(message) ||
+            /\d+\s+(assets?|folders?|items?|actors?|components?)\s+(and|in|at)/i.test(message);
+        const messageInParts = parts.some(p => p.toLowerCase().includes(message.toLowerCase().slice(0, 30)));
+        if (!isDuplicateInfo && !messageInParts) {
             parts.push(message);
-        if (error)
-            parts.push(`Error: ${error}`);
-        if (parts.length === 0 && success !== undefined) {
-            parts.push(success ? 'Success' : 'Failed');
         }
     }
-    const warnings = Array.isArray(payload.warnings) ? payload.warnings : [];
+    const warnings = Array.isArray(effectivePayload.warnings) ? effectivePayload.warnings : [];
     if (warnings.length > 0) {
-        parts.push(`Warnings: ${warnings.length}`);
+        parts.push(`Warnings: ${warnings.map((w) => typeof w === 'string' ? w : JSON.stringify(w)).join('; ')}`);
     }
     return parts.length > 0 ? parts.join(' | ') : `${toolName} responded`;
 }

package/dist/utils/unreal-command-queue.d.ts

@@ -11,6 +11,7 @@ export declare class UnrealCommandQueue {
     private isProcessing;
     private lastCommandTime;
     private lastStatCommandTime;
+    private processorInterval?;
     private readonly MIN_COMMAND_DELAY;
     private readonly MAX_COMMAND_DELAY;
     private readonly STAT_COMMAND_DELAY;
@@ -19,6 +20,7 @@ export declare class UnrealCommandQueue {
     private processQueue;
     private calculateDelay;
     private startProcessor;
+    stopProcessor(): void;
     private delay;
 }
 //# sourceMappingURL=unreal-command-queue.d.ts.map

package/dist/utils/unreal-command-queue.js

@@ -5,6 +5,7 @@ export class UnrealCommandQueue {
     isProcessing = false;
     lastCommandTime = 0;
     lastStatCommandTime = 0;
+    processorInterval;
     MIN_COMMAND_DELAY = 100;
     MAX_COMMAND_DELAY = 500;
     STAT_COMMAND_DELAY = 300;
@@ -107,12 +108,18 @@ export class UnrealCommandQueue {
         }
     }
     startProcessor() {
-        setInterval(() => {
+        this.processorInterval = setInterval(() => {
             if (!this.isProcessing && this.queue.length > 0) {
                 this.processQueue();
             }
         }, 1000);
     }
+    stopProcessor() {
+        if (this.processorInterval) {
+            clearInterval(this.processorInterval);
+            this.processorInterval = undefined;
+        }
+    }
     delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }

package/docs/handler-mapping.md

@@ -235,8 +235,10 @@ This document maps the TypeScript tool definitions to their corresponding C++ ha
 
 | Action | C++ Handler File | C++ Function | Notes |
 | :--- | :--- | :--- | :--- |
-| `create_node` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
+| `create_node` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | Dynamic node class resolution |
 | `delete_node` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
 | `connect_pins` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
 | `break_pin_links` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
-| `set_node_property` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
+| `set_node_property` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | |
+| `list_node_types` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | Lists all UK2Node subclasses |
+| `set_pin_default_value` | `McpAutomationBridge_BlueprintGraphHandlers.cpp` | `HandleBlueprintGraphAction` | Sets default value on input pins |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unreal-engine-mcp-server",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "mcpName": "io.github.ChiR24/unreal-engine-mcp",
   "description": "A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine via native automation bridge. Built with TypeScript and designed for game development automation.",
   "type": "module",