blueprint-extractor-mcp 8.1.0 → 8.1.1

package/dist/helpers/formatting.js

@@ -104,7 +104,7 @@ export function extractExtraContent(result) {
     if (!isPlainObject(result) || !Array.isArray(result.content)) {
         return [];
     }
-    return result.content.filter((candidate) => (isContentBlock(candidate) && candidate.type !== 'text'));
+    return result.content.filter((candidate) => (isContentBlock(candidate)));
 }
 export function maybeBoolean(...values) {
     for (const value of values) {

package/dist/helpers/tool-results.js

@@ -1,5 +1,17 @@
 import { isPlainObject } from './formatting.js';
 export function createToolResultNormalizers({ taskAwareTools, classifyRecoverableToolFailure, }) {
+    function serializeSuccessEnvelope(envelope) {
+        try {
+            return JSON.stringify(envelope);
+        }
+        catch {
+            return JSON.stringify({
+                success: true,
+                operation: typeof envelope.operation === 'string' ? envelope.operation : 'unknown_operation',
+                message: 'Unable to serialize tool result payload.',
+            });
+        }
+    }
     function extractNonTextContent(existingResult) {
         if (!existingResult || !Array.isArray(existingResult.content)) {
             return [];
@@ -132,7 +144,10 @@ export function createToolResultNormalizers({ taskAwareTools, classifyRecoverabl
             ...(taskAwareTools.has(toolName) ? { execution: inferExecutionMetadata(toolName, basePayload) } : {}),
         };
         return {
-            content: extraContent,
+            content: [
+                { type: 'text', text: serializeSuccessEnvelope(envelope) },
+                ...extraContent,
+            ],
             structuredContent: envelope,
         };
     }

package/dist/tools/project-control.js

@@ -47,6 +47,9 @@ export function registerProjectControlTools({ server, client, projectController,
         engineRoot: previousEditor?.engineRoot ?? fallback.engineRoot,
         target: previousEditor?.editorTarget ?? fallback.target,
     });
+    const matchesResolvedEditor = (entry, resolved) => (filesystemPathsEqual(entry.projectFilePath, resolved.projectPath)
+        && (!resolved.engineRoot || !entry.engineRoot || filesystemPathsEqual(entry.engineRoot, resolved.engineRoot))
+        && (!resolved.target || !entry.editorTarget || entry.editorTarget === resolved.target));
     const recoverEditorViaHostRelaunch = async (request) => {
         const recovery = {
             strategy: 'host_relaunch_after_failed_graceful_restart',
@@ -452,18 +455,51 @@ export function registerProjectControlTools({ server, client, projectController,
             if (!resolved.engineRoot || !resolved.projectPath) {
                 throw explainProjectResolutionFailure('launch_editor requires engine_root and project_path', resolved);
             }
+            const resolvedProjectPath = resolved.projectPath;
+            const resolvedEngineRoot = resolved.engineRoot;
+            const resolvedTarget = resolved.target;
+            if (activeEditorSession) {
+                const matchingEditors = (await activeEditorSession.listRunningEditors()).filter((entry) => matchesResolvedEditor(entry, {
+                    projectPath: resolvedProjectPath,
+                    engineRoot: resolvedEngineRoot,
+                    target: resolvedTarget,
+                }));
+                if (matchingEditors.length > 1) {
+                    throw new Error(`Multiple running editors already match "${resolvedProjectPath}". `
+                        + 'Call list_running_editors and select_editor instead of launch_editor.');
+                }
+                if (matchingEditors.length === 1) {
+                    try {
+                        const bound = await activeEditorSession.selectEditor({ instanceId: matchingEditors[0].instanceId });
+                        clearProjectAutomationContext();
+                        const activeEditor = toLabeledActiveEditor(bound);
+                        return jsonToolSuccess({
+                            success: true,
+                            operation: 'launch_editor',
+                            launched: false,
+                            reusedExistingEditor: true,
+                            message: 'Bound the existing matching editor instead of launching a new process.',
+                            inputResolution: buildInputResolution(resolved),
+                            activeEditor,
+                        });
+                    }
+                    catch {
+                        // Fall through to a real launch when the registry entry is stale or not yet responsive.
+                    }
+                }
+            }
             const launched = await projectController.launchEditor({
-                engineRoot: resolved.engineRoot,
-                projectPath: resolved.projectPath,
+                engineRoot: resolvedEngineRoot,
+                projectPath: resolvedProjectPath,
             });
             clearProjectAutomationContext();
             let activeEditor;
             if (activeEditorSession) {
                 const bound = await activeEditorSession.bindLaunchedEditor({
                     processId: launched.processId,
-                    projectPath: resolved.projectPath,
-                    engineRoot: resolved.engineRoot,
-                    target: resolved.target,
+                    projectPath: resolvedProjectPath,
+                    engineRoot: resolvedEngineRoot,
+                    target: resolvedTarget,
                     timeoutMs: reconnect_timeout_seconds * 1000,
                 });
                 activeEditor = toLabeledActiveEditor(bound);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blueprint-extractor-mcp",
-  "version": "8.1.0",
+  "version": "8.1.1",
   "description": "MCP server for the Unreal Engine BlueprintExtractor plugin over Remote Control",
   "type": "module",
   "main": "dist/index.js",