unreal-engine-mcp-server 0.3.0 → 0.4.0

package/dist/tools/debug.js

@@ -20,13 +20,11 @@ export class DebugVisualizationTools {
     async pyDraw(scriptBody) {
         const script = `
 import unreal
-# Use modern UnrealEditorSubsystem instead of deprecated EditorLevelLibrary
+# Strict modern API: require UnrealEditorSubsystem (UE 5.1+)
 ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-if ues:
-    world = ues.get_editor_world()
-else:
-    # Fallback to deprecated API if subsystem not available
-    world = unreal.EditorLevelLibrary.get_editor_world()
+if not ues:
+    raise Exception('UnrealEditorSubsystem not available')
+world = ues.get_editor_world()
 ${scriptBody}
 `.trim()
             .replace(/\r?\n/g, '\n');

package/dist/tools/rc.js

@@ -142,7 +142,7 @@ except Exception as e:
     }
     // Expose an actor by label/name into a preset
     async exposeActor(params) {
-        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nactor_name = r"${params.actorName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    if not preset:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))\n    else:\n        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\n        target = None\n        for a in actor_sub.get_all_level_actors():\n            if not a: continue\n            try:\n                if a.get_actor_label() == actor_name or a.get_name() == actor_name:\n                    target = a; break\n            except Exception: pass\n        if not target:\n            print('RESULT:' + json.dumps({'success': False, 'error': 'Actor not found'}))\n        else:\n            try:\n                unreal.RemoteControlFunctionLibrary.expose_actor(preset, target, None)\n                unreal.EditorAssetLibrary.save_asset(preset_path)\n                print('RESULT:' + json.dumps({'success': True}))\n            except Exception as e:\n                print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
+        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nactor_name = r"${params.actorName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    if not preset:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))\n    else:\n        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)\n        target = None\n        for a in actor_sub.get_all_level_actors():\n            if not a: continue\n            try:\n                if a.get_actor_label() == actor_name or a.get_name() == actor_name:\n                    target = a; break\n            except Exception: pass\n        if not target:\n            print('RESULT:' + json.dumps({'success': False, 'error': 'Actor not found'}))\n        else:\n            try:\n                # Expose with a default-initialized optional args struct (cannot pass None)\n                args = unreal.RemoteControlOptionalExposeArgs()\n                unreal.RemoteControlFunctionLibrary.expose_actor(preset, target, args)\n                unreal.EditorAssetLibrary.save_asset(preset_path)\n                print('RESULT:' + json.dumps({'success': True}))\n            except Exception as e:\n                print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
         const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeActor');
         const result = this.parsePythonResult(resp, 'exposeActor');
         // Clear cache for this preset to force refresh
@@ -153,7 +153,7 @@ except Exception as e:
     }
     // Expose a property on an object into a preset
     async exposeProperty(params) {
-        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nobj_path = r"${params.objectPath}"\nprop_name = r"${params.propertyName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    obj = unreal.load_object(None, obj_path)\n    if not preset or not obj:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset or object not found'}))\n    else:\n        try:\n            unreal.RemoteControlFunctionLibrary.expose_property(preset, obj, prop_name, None)\n            unreal.EditorAssetLibrary.save_asset(preset_path)\n            print('RESULT:' + json.dumps({'success': True}))\n        except Exception as e:\n            print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
+        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nobj_path = r"${params.objectPath}"\nprop_name = r"${params.propertyName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    obj = unreal.load_object(None, obj_path)\n    if not preset or not obj:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset or object not found'}))\n    else:\n        try:\n            # Expose with default optional args struct (cannot pass None)\n            args = unreal.RemoteControlOptionalExposeArgs()\n            unreal.RemoteControlFunctionLibrary.expose_property(preset, obj, prop_name, args)\n            unreal.EditorAssetLibrary.save_asset(preset_path)\n            print('RESULT:' + json.dumps({'success': True}))\n        except Exception as e:\n            print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
         const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeProperty');
         const result = this.parsePythonResult(resp, 'exposeProperty');
         // Clear cache for this preset to force refresh

package/dist/tools/sequence.js

@@ -282,12 +282,31 @@ except Exception as e:
      * Play the current level sequence
      */
     async play(params) {
+        const loop = params?.loopMode || '';
         const py = `
 import unreal, json
+
+# Helper to resolve SequencerLoopMode from a friendly string
+def _resolve_loop_mode(mode_str):
+    try:
+        m = str(mode_str).lower()
+        slm = unreal.SequencerLoopMode
+        if m in ('once','noloop','no_loop'):
+            return getattr(slm, 'SLM_NoLoop', getattr(slm, 'NoLoop'))
+        if m in ('loop',):
+            return getattr(slm, 'SLM_Loop', getattr(slm, 'Loop'))
+        if m in ('pingpong','ping_pong'):
+            return getattr(slm, 'SLM_PingPong', getattr(slm, 'PingPong'))
+    except Exception:
+        pass
+    return None
+
 try:
     unreal.LevelSequenceEditorBlueprintLibrary.play()
-    ${params?.loopMode ? `unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode('${params.loopMode}')` : ''}
-    print('RESULT:' + json.dumps({'success': True, 'playing': True}))
+    loop_mode = _resolve_loop_mode('${loop}')
+    if loop_mode is not None:
+        unreal.LevelSequenceEditorBlueprintLibrary.set_loop_mode(loop_mode)
+    print('RESULT:' + json.dumps({'success': True, 'playing': True, 'loopMode': '${loop || 'default'}'}))
 except Exception as e:
     print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
 `.trim();

package/dist/unreal-bridge.d.ts

@@ -14,6 +14,7 @@ export declare class UnrealBridge {
     private reconnectAttempts;
     private readonly MAX_RECONNECT_ATTEMPTS;
     private readonly BASE_RECONNECT_DELAY;
+    private autoReconnectEnabled;
     private commandQueue;
     private isProcessing;
     private readonly MIN_COMMAND_DELAY;
@@ -32,6 +33,7 @@ export declare class UnrealBridge {
      * @param retryDelayMs Delay between retry attempts in milliseconds
      * @returns Promise that resolves when connected or rejects after all attempts fail
      */
+    private connectPromise?;
     tryConnect(maxAttempts?: number, timeoutMs?: number, retryDelayMs?: number): Promise<boolean>;
     connect(timeoutMs?: number): Promise<void>;
     httpCall<T = any>(path: string, method?: 'GET' | 'POST' | 'PUT', body?: any): Promise<T>;
@@ -39,6 +41,7 @@ export declare class UnrealBridge {
     getExposed(): Promise<any>;
     executeConsoleCommand(command: string): Promise<any>;
     executePython(command: string): Promise<any>;
+    setAutoReconnectEnabled(enabled: boolean): void;
     private scheduleReconnect;
     disconnect(): Promise<void>;
     /**
@@ -49,7 +52,7 @@ export declare class UnrealBridge {
     /**
      * Execute Python script and parse the result
      */
-    private executePythonWithResult;
+    executePythonWithResult(script: string): Promise<any>;
     /**
      * Get the Unreal Engine version via Python and parse major/minor/patch.
      */

package/dist/unreal-bridge.js

@@ -12,6 +12,7 @@ export class UnrealBridge {
     reconnectAttempts = 0;
     MAX_RECONNECT_ATTEMPTS = 5;
     BASE_RECONNECT_DELAY = 1000;
+    autoReconnectEnabled = false; // disabled by default to prevent looping retries
     // Command queue for throttling
     commandQueue = [];
     isProcessing = false;
@@ -151,53 +152,112 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
      * @param retryDelayMs Delay between retry attempts in milliseconds
      * @returns Promise that resolves when connected or rejects after all attempts fail
      */
+    connectPromise;
     async tryConnect(maxAttempts = 3, timeoutMs = 5000, retryDelayMs = 2000) {
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (this.connected)
+            return true;
+        if (this.connectPromise) {
             try {
-                this.log.info(`Connection attempt ${attempt}/${maxAttempts}`);
-                await this.connect(timeoutMs);
-                return true; // Successfully connected
+                await this.connectPromise;
             }
-            catch (err) {
-                this.log.warn(`Connection attempt ${attempt} failed:`, err);
-                if (attempt < maxAttempts) {
-                    this.log.info(`Retrying in ${retryDelayMs}ms...`);
-                    await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+            catch {
+                // swallow, we'll return connected flag
+            }
+            return this.connected;
+        }
+        this.connectPromise = (async () => {
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                // Early exit if another concurrent attempt already connected
+                if (this.connected) {
+                    this.log.debug('Already connected; skipping remaining retry attempts');
+                    return;
                 }
-                else {
-                    this.log.error(`All ${maxAttempts} connection attempts failed`);
-                    return false; // All attempts failed
+                try {
+                    this.log.debug(`Connection attempt ${attempt}/${maxAttempts}`);
+                    await this.connect(timeoutMs);
+                    return; // Successfully connected
+                }
+                catch (err) {
+                    const msg = (err?.message || String(err));
+                    this.log.debug(`Connection attempt ${attempt} failed: ${msg}`);
+                    if (attempt < maxAttempts) {
+                        this.log.debug(`Retrying in ${retryDelayMs}ms...`);
+                        // Sleep, but allow early break if we became connected during the wait
+                        const start = Date.now();
+                        while (Date.now() - start < retryDelayMs) {
+                            if (this.connected)
+                                return; // someone else connected
+                            await new Promise(r => setTimeout(r, 50));
+                        }
+                    }
+                    else {
+                        // Keep this at warn (not error) and avoid stack spam
+                        this.log.warn(`All ${maxAttempts} connection attempts failed`);
+                        return; // exit, connected remains false
+                    }
                 }
             }
+        })();
+        try {
+            await this.connectPromise;
         }
-        return false;
+        finally {
+            this.connectPromise = undefined;
+        }
+        return this.connected;
     }
     async connect(timeoutMs = 5000) {
+        // If already connected and socket is open, do nothing
+        if (this.connected && this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.log.debug('connect() called but already connected; skipping');
+            return;
+        }
         const wsUrl = `ws://${this.env.UE_HOST}:${this.env.UE_RC_WS_PORT}`;
         const httpBase = `http://${this.env.UE_HOST}:${this.env.UE_RC_HTTP_PORT}`;
         this.http = createHttpClient(httpBase);
-        this.log.info(`Connecting to UE Remote Control: ${wsUrl}`);
+        this.log.debug(`Connecting to UE Remote Control: ${wsUrl}`);
         this.ws = new WebSocket(wsUrl);
         await new Promise((resolve, reject) => {
             if (!this.ws)
                 return reject(new Error('WS not created'));
+            // Guard against double-resolution/rejection
+            let settled = false;
+            const safeResolve = () => { if (!settled) {
+                settled = true;
+                resolve();
+            } };
+            const safeReject = (err) => { if (!settled) {
+                settled = true;
+                reject(err);
+            } };
             // Setup timeout
             const timeout = setTimeout(() => {
                 this.log.warn(`Connection timeout after ${timeoutMs}ms`);
                 if (this.ws) {
-                    this.ws.removeAllListeners();
-                    // Only close if the websocket is in CONNECTING state
-                    if (this.ws.readyState === WebSocket.CONNECTING) {
-                        try {
-                            this.ws.terminate(); // Use terminate instead of close for immediate cleanup
+                    try {
+                        // Attach a temporary error handler to avoid unhandled 'error' events on abort
+                        this.ws.on('error', () => { });
+                        // Prefer graceful close; terminate as a fallback
+                        if (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN) {
+                            try {
+                                this.ws.close();
+                            }
+                            catch { }
+                            try {
+                                this.ws.terminate();
+                            }
+                            catch { }
                         }
-                        catch (_e) {
-                            // Ignore close errors
+                    }
+                    finally {
+                        try {
+                            this.ws.removeAllListeners();
                         }
+                        catch { }
+                        this.ws = undefined;
                     }
-                    this.ws = undefined;
                 }
-                reject(new Error('Connection timeout: Unreal Engine may not be running or Remote Control is not enabled'));
+                safeReject(new Error('Connection timeout: Unreal Engine may not be running or Remote Control is not enabled'));
             }, timeoutMs);
             // Success handler
             const onOpen = () => {
@@ -205,37 +265,52 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 this.connected = true;
                 this.log.info('Connected to Unreal Remote Control');
                 this.startCommandProcessor(); // Start command processor on connect
-                resolve();
+                safeResolve();
             };
             // Error handler
             const onError = (err) => {
                 clearTimeout(timeout);
-                this.log.error('WebSocket error', err);
+                // Keep error logs concise to avoid stack spam when UE is not running
+                this.log.debug(`WebSocket error during connect: ${(err && err.code) || ''} ${err.message}`);
                 if (this.ws) {
-                    this.ws.removeAllListeners();
                     try {
+                        // Attach a temporary error handler to avoid unhandled 'error' events while aborting
+                        this.ws.on('error', () => { });
                         if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-                            this.ws.terminate();
+                            try {
+                                this.ws.close();
+                            }
+                            catch { }
+                            try {
+                                this.ws.terminate();
+                            }
+                            catch { }
                         }
                     }
-                    catch (_e) {
-                        // Ignore close errors
+                    finally {
+                        try {
+                            this.ws.removeAllListeners();
+                        }
+                        catch { }
+                        this.ws = undefined;
                     }
-                    this.ws = undefined;
                 }
-                reject(new Error(`Failed to connect: ${err.message}`));
+                safeReject(new Error(`Failed to connect: ${err.message}`));
             };
             // Close handler (if closed before open)
             const onClose = () => {
                 if (!this.connected) {
                     clearTimeout(timeout);
-                    reject(new Error('Connection closed before establishing'));
+                    safeReject(new Error('Connection closed before establishing'));
                 }
                 else {
                     // Normal close after connection was established
                     this.connected = false;
+                    this.ws = undefined;
                     this.log.warn('WebSocket closed');
-                    this.scheduleReconnect();
+                    if (this.autoReconnectEnabled) {
+                        this.scheduleReconnect();
+                    }
                 }
             };
             // Message handler (currently best-effort logging)
@@ -244,8 +319,8 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                     const msg = JSON.parse(String(raw));
                     this.log.debug('WS message', msg);
                 }
-                catch (e) {
-                    this.log.error('Failed parsing WS message', e);
+                catch (_e) {
+                    // Noise reduction: keep at debug and do nothing on parse errors
                 }
             };
             // Attach listeners
@@ -256,6 +331,10 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         });
     }
     async httpCall(path, method = 'POST', body) {
+        // Guard: if not connected, do not attempt HTTP
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         const url = path.startsWith('/') ? path : `/${path}`;
         const started = Date.now();
         // Fix Content-Length header issue - ensure body is properly handled
@@ -329,14 +408,16 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 const delay = Math.min(1000 * Math.pow(2, attempt), 5000); // Exponential backoff with 5s max
                 // Log timeout errors specifically
                 if (error.message?.includes('timeout')) {
-                    this.log.warn(`HTTP request timed out (attempt ${attempt + 1}/3): ${url}`);
+                    this.log.debug(`HTTP request timed out (attempt ${attempt + 1}/3): ${url}`);
                 }
                 if (attempt < 2) {
-                    this.log.warn(`HTTP request failed (attempt ${attempt + 1}/3), retrying in ${delay}ms...`);
+                    this.log.debug(`HTTP request failed (attempt ${attempt + 1}/3), retrying in ${delay}ms...`);
                     await new Promise(resolve => setTimeout(resolve, delay));
                     // If connection error, try to reconnect
                     if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT' || error.message?.includes('timeout')) {
-                        this.scheduleReconnect();
+                        if (this.autoReconnectEnabled) {
+                            this.scheduleReconnect();
+                        }
                     }
                 }
             }
@@ -345,6 +426,8 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     }
     // Generic function call via Remote Control HTTP API
     async call(body) {
+        if (!this.connected)
+            throw new Error('Not connected to Unreal Engine');
         // Using HTTP endpoint /remote/object/call
         const result = await this.httpCall('/remote/object/call', 'PUT', {
             generateTransaction: false,
@@ -353,10 +436,15 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         return result;
     }
     async getExposed() {
+        if (!this.connected)
+            throw new Error('Not connected to Unreal Engine');
         return this.httpCall('/remote/preset', 'GET');
     }
     // Execute a console command safely with validation and throttling
     async executeConsoleCommand(command) {
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         // Validate command is not empty
         if (!command || typeof command !== 'string') {
             throw new Error('Invalid command: must be a non-empty string');
@@ -420,6 +508,9 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     }
     // Try to execute a Python command via the PythonScriptPlugin, fallback to `py` console command.
     async executePython(command) {
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         const isMultiLine = /[\r\n]/.test(command) || command.includes(';');
         try {
             // Use ExecutePythonCommandEx with appropriate mode based on content
@@ -511,8 +602,16 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
             }
         }
     }
+    // Allow callers to enable/disable auto-reconnect behavior
+    setAutoReconnectEnabled(enabled) {
+        this.autoReconnectEnabled = enabled;
+    }
     // Connection recovery
     scheduleReconnect() {
+        if (!this.autoReconnectEnabled) {
+            this.log.info('Auto-reconnect disabled; not scheduling reconnection');
+            return;
+        }
         if (this.reconnectTimer || this.connected) {
             return;
         }
@@ -523,7 +622,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         // Exponential backoff with jitter
         const delay = Math.min(this.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts) + Math.random() * 1000, 30000 // Max 30 seconds
         );
-        this.log.info(`Scheduling reconnection attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS} in ${Math.round(delay)}ms`);
+        this.log.debug(`Scheduling reconnection attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS} in ${Math.round(delay)}ms`);
         this.reconnectTimer = setTimeout(async () => {
             this.reconnectTimer = undefined;
             this.reconnectAttempts++;
@@ -533,7 +632,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 this.log.info('Successfully reconnected to Unreal Engine');
             }
             catch (err) {
-                this.log.error('Reconnection attempt failed:', err);
+                this.log.warn('Reconnection attempt failed:', err);
                 this.scheduleReconnect();
             }
         }, delay);
@@ -545,8 +644,25 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
             this.reconnectTimer = undefined;
         }
         if (this.ws) {
-            this.ws.close();
-            this.ws = undefined;
+            try {
+                // Avoid unhandled error during shutdown
+                this.ws.on('error', () => { });
+                try {
+                    this.ws.close();
+                }
+                catch { }
+                try {
+                    this.ws.terminate();
+                }
+                catch { }
+            }
+            finally {
+                try {
+                    this.ws.removeAllListeners();
+                }
+                catch { }
+                this.ws = undefined;
+            }
         }
         this.connected = false;
     }
@@ -581,6 +697,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     /**
      * Execute Python script and parse the result
      */
+    // Expose for internal consumers (resources) that want parsed RESULT blocks
     async executePythonWithResult(script) {
         try {
             // Wrap script to capture output so we can parse RESULT: lines reliably
@@ -606,7 +723,6 @@ finally:
                     out = response;
                 }
                 else if (response && typeof response === 'object') {
-                    // Common RC Python response contains LogOutput array entries with .Output strings
                     if (Array.isArray(response.LogOutput)) {
                         out = response.LogOutput.map((l) => l.Output || '').join('');
                     }
@@ -617,7 +733,6 @@ finally:
                         out = response.result;
                     }
                     else {
-                        // Fallback to stringifying object (may still include RESULT in nested fields)
                         out = JSON.stringify(response);
                     }
                 }
@@ -625,17 +740,58 @@ finally:
             catch {
                 out = String(response || '');
             }
-            // Find the last RESULT: JSON block in the output for robustness
-            const matches = Array.from(out.matchAll(/RESULT:({[\s\S]*?})/g));
+            // Robust RESULT parsing with bracket matching (handles nested objects)
+            const marker = 'RESULT:';
+            const idx = out.lastIndexOf(marker);
+            if (idx !== -1) {
+                // Find first '{' after the marker
+                let i = idx + marker.length;
+                while (i < out.length && out[i] !== '{')
+                    i++;
+                if (i < out.length && out[i] === '{') {
+                    let depth = 0;
+                    let inStr = false;
+                    let esc = false;
+                    let j = i;
+                    for (; j < out.length; j++) {
+                        const ch = out[j];
+                        if (esc) {
+                            esc = false;
+                            continue;
+                        }
+                        if (ch === '\\') {
+                            esc = true;
+                            continue;
+                        }
+                        if (ch === '"') {
+                            inStr = !inStr;
+                            continue;
+                        }
+                        if (!inStr) {
+                            if (ch === '{')
+                                depth++;
+                            else if (ch === '}') {
+                                depth--;
+                                if (depth === 0) {
+                                    j++;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    const jsonStr = out.slice(i, j);
+                    try {
+                        return JSON.parse(jsonStr);
+                    }
+                    catch { }
+                }
+            }
+            // Fallback to previous regex approach (best-effort)
+            const matches = Array.from(out.matchAll(/RESULT:({[\s\S]*})/g));
             if (matches.length > 0) {
                 const last = matches[matches.length - 1][1];
                 try {
-                    // Accept single quotes and True/False from Python repr if present
-                    const normalized = last
-                        .replace(/'/g, '"')
-                        .replace(/\bTrue\b/g, 'true')
-                        .replace(/\bFalse\b/g, 'false');
-                    return JSON.parse(normalized);
+                    return JSON.parse(last);
                 }
                 catch {
                     return { raw: last };
@@ -835,10 +991,12 @@ print('RESULT:' + json.dumps(flags))
             }
             catch (error) {
                 // Retry logic for transient failures
+                const msg = (error?.message || String(error)).toLowerCase();
+                const notConnected = msg.includes('not connected to unreal');
                 if (item.retryCount === undefined) {
                     item.retryCount = 0;
                 }
-                if (item.retryCount < 3) {
+                if (!notConnected && item.retryCount < 3) {
                     item.retryCount++;
                     this.log.warn(`Command failed, retrying (${item.retryCount}/3)`);
                     // Re-add to queue with increased priority

package/dist/utils/http.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
 import http from 'http';
 import https from 'https';
+import { Logger } from './logger.js';
 // Connection pooling configuration for better performance
 const httpAgent = new http.Agent({
     keepAlive: true,
@@ -16,6 +17,7 @@ const httpsAgent = new https.Agent({
     maxFreeSockets: 5,
     timeout: 30000
 });
+const log = new Logger('HTTP');
 const defaultRetryConfig = {
     maxRetries: 3,
     initialDelay: 1000,
@@ -75,7 +77,7 @@ export function createHttpClient(baseURL) {
     client.interceptors.response.use((response) => {
         const duration = Date.now() - (response.config.metadata?.startTime || 0);
         if (duration > 5000) {
-            console.warn(`[HTTP] Slow request: ${response.config.url} took ${duration}ms`);
+            log.warn(`[HTTP] Slow request: ${response.config.url} took ${duration}ms`);
         }
         return response;
     }, (error) => {
@@ -109,7 +111,7 @@ export async function requestWithRetry(client, config, retryConfig = {}) {
             }
             // Calculate delay and wait
             const delay = calculateBackoff(attempt, retry);
-            console.error(`[HTTP] Retry attempt ${attempt}/${retry.maxRetries} after ${Math.round(delay)}ms`);
+            log.debug(`[HTTP] Retry attempt ${attempt}/${retry.maxRetries} after ${Math.round(delay)}ms`);
             await new Promise(resolve => setTimeout(resolve, delay));
         }
     }

package/dist/utils/response-validator.d.ts

@@ -19,7 +19,12 @@ export declare class ResponseValidator {
         structuredContent?: any;
     };
     /**
-     * Wrap a tool response with validation
+     * Wrap a tool response with validation and MCP-compliant content shape.
+     *
+     * MCP tools/call responses must contain a `content` array. Many internal
+     * handlers return structured JSON objects (e.g., { success, message, ... }).
+     * This wrapper serializes such objects into a single text block while keeping
+     * existing `content` responses intact.
      */
     wrapResponse(toolName: string, response: any): any;
     /**