unreal-engine-mcp-server 0.5.1 → 0.5.2

package/.github/workflows/publish-mcp.yml

@@ -61,17 +61,14 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Install MCP Publisher
-        if: ${{ success() }}
         run: |
-          curl -L "https://github.com/modelcontextprotocol/registry/releases/download/v1.1.0/mcp-publisher_1.1.0_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
+          curl -L "https://github.com/modelcontextprotocol/registry/releases/download/v1.4.0/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
           chmod +x mcp-publisher
 
       - name: Login to MCP Registry
-        if: ${{ success() }}
         run: ./mcp-publisher login github-oidc
 
       - name: Publish to MCP Registry
-        if: ${{ success() }}
         run: ./mcp-publisher publish
 
       - name: Verify publication

package/.github/workflows/release-drafter.yml

@@ -15,8 +15,9 @@ jobs:
       contents: write
       pull-requests: write
     runs-on: ubuntu-latest
+    timeout-minutes: 15
     steps:
-      - uses: release-drafter/release-drafter@v6.1.0 # v6.1.0
+      - uses: release-drafter/release-drafter@v6
         with:
           config-name: release-drafter-config.yml
         env:

package/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## 🏷️ [0.5.2] - 2025-12-18
+
+> [!IMPORTANT]
+> ### 🔄 Breaking Changes
+> - **Standardized Tools & Type Safety** - All tool handlers now use consistent interfaces with improved type safety. Some internal API signatures have changed. (`079e3c2`)
+
+### ✨ Added
+
+<details>
+<summary><b>🛠️ Blueprint Enhancements</b> (<code>e710751</code>)</summary>
+
+| Feature | Description |
+|---------|-------------|
+| **Dynamic Node Creation** | Support for creating nodes dynamically in Blueprint graphs |
+| **Struct Property Support** | Added ability to set and get struct properties on Blueprint components |
+
+</details>
+
+### 🔄 Changed
+
+<details>
+<summary><b>🎯 Standardized Tool Interfaces</b> (<a href="https://github.com/ChiR24/Unreal_mcp/pull/28">#28</a>)</summary>
+
+| Component | Change |
+|-----------|--------|
+| Tool Handlers | Optimized bridge communication and standardized response handling |
+| Type Safety | Hardened type definitions across all tool interfaces |
+| Bridge Optimization | Improved performance and reliability of automation bridge |
+
+</details>
+
+### 🔧 CI/CD
+
+- 🔗 **MCP Publisher** - Fixed download URL format in workflow steps (`0d452e7`)
+- 🧹 **Workflow Cleanup** - Removed unnecessary success conditions from MCP workflow steps (`82bd575`)
+
+---
+
 ## 🏷️ [0.5.1] - 2025-12-17
 
 > [!WARNING]

package/dist/automation/bridge.d.ts

@@ -24,9 +24,9 @@ export declare class AutomationBridge extends EventEmitter {
     private lastHandshakeFailure?;
     private lastDisconnect?;
     private lastError?;
-    private requestQueue;
     private queuedRequestItems;
     private connectionPromise?;
+    private connectionLock;
     constructor(options?: AutomationBridgeOptions);
     on<K extends keyof AutomationBridgeEvents>(event: K, listener: AutomationBridgeEvents[K]): this;
     once<K extends keyof AutomationBridgeEvents>(event: K, listener: AutomationBridgeEvents[K]): this;
@@ -44,7 +44,6 @@ export declare class AutomationBridge extends EventEmitter {
     private processRequestQueue;
     send(payload: AutomationBridgeMessage): boolean;
     private broadcast;
-    private flushQueue;
     private emitAutomation;
 }
 //# sourceMappingURL=bridge.d.ts.map

package/dist/automation/bridge.js

@@ -42,9 +42,9 @@ export class AutomationBridge extends EventEmitter {
     lastHandshakeFailure;
     lastDisconnect;
     lastError;
-    requestQueue = [];
     queuedRequestItems = [];
     connectionPromise;
+    connectionLock = false;
     constructor(options = {}) {
         super();
         this.host = options.host ?? process.env.MCP_AUTOMATION_WS_HOST ?? DEFAULT_AUTOMATION_HOST;
@@ -162,12 +162,12 @@ export class AutomationBridge extends EventEmitter {
                 this.lastHandshakeMetadata = metadata;
                 this.lastHandshakeFailure = undefined;
                 this.connectionManager.updateLastMessageTime();
-                const underlying = socket._socket || socket.socket;
+                const socketWithInternal = socket;
+                const underlying = socketWithInternal._socket || socketWithInternal.socket;
                 const remoteAddr = underlying?.remoteAddress ?? undefined;
                 const remotePort = underlying?.remotePort ?? undefined;
                 this.connectionManager.registerSocket(socket, this.clientPort, metadata, remoteAddr, remotePort);
                 this.connectionManager.startHeartbeat();
-                this.flushQueue();
                 this.emitAutomation('connected', {
                     socket,
                     metadata,
@@ -273,7 +273,7 @@ export class AutomationBridge extends EventEmitter {
                 ? { message: this.lastError.message, at: this.lastError.at.toISOString() }
                 : null,
             lastMessageAt: this.connectionManager.getLastMessageTime()?.toISOString() ?? null,
-            lastRequestSentAt: null,
+            lastRequestSentAt: this.requestTracker.getLastRequestSentAt()?.toISOString() ?? null,
             pendingRequests: this.requestTracker.getPendingCount(),
             pendingRequestDetails: this.requestTracker.getPendingDetails(),
             connections: connectionInfos,
@@ -282,15 +282,16 @@ export class AutomationBridge extends EventEmitter {
             serverName: this.serverName,
             serverVersion: this.serverVersion,
             maxConcurrentConnections: this.maxConcurrentConnections,
-            maxPendingRequests: 100,
-            heartbeatIntervalMs: 30000
+            maxPendingRequests: this.requestTracker.getMaxPendingRequests(),
+            heartbeatIntervalMs: this.connectionManager.getHeartbeatIntervalMs()
         };
     }
     async sendAutomationRequest(action, payload = {}, options = {}) {
         if (!this.isConnected()) {
             if (this.enabled) {
                 this.log.info('Automation bridge not connected, attempting lazy connection...');
-                if (!this.connectionPromise) {
+                if (!this.connectionPromise && !this.connectionLock) {
+                    this.connectionLock = true;
                     this.connectionPromise = new Promise((resolve, reject) => {
                         const onConnect = () => {
                             cleanup();
@@ -308,8 +309,8 @@ export class AutomationBridge extends EventEmitter {
                             this.off('connected', onConnect);
                             this.off('error', onError);
                             this.off('handshakeFailed', onHandshakeFail);
-                            if (this.connectionPromise)
-                                this.connectionPromise = undefined;
+                            this.connectionLock = false;
+                            this.connectionPromise = undefined;
                         };
                         this.once('connected', onConnect);
                         this.once('error', onError);
@@ -324,10 +325,17 @@ export class AutomationBridge extends EventEmitter {
                 }
                 try {
                     const connectTimeout = 5000;
-                    await Promise.race([
-                        this.connectionPromise,
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('Lazy connection timeout')), connectTimeout))
-                    ]);
+                    let timeoutId;
+                    const timeoutPromise = new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error('Lazy connection timeout')), connectTimeout);
+                    });
+                    try {
+                        await Promise.race([this.connectionPromise, timeoutPromise]);
+                    }
+                    finally {
+                        if (timeoutId)
+                            clearTimeout(timeoutId);
+                    }
                 }
                 catch (err) {
                     this.log.error('Lazy connection failed', err);
@@ -341,7 +349,7 @@ export class AutomationBridge extends EventEmitter {
         if (!this.isConnected()) {
             throw new Error('Automation bridge not connected');
         }
-        if (this.requestTracker.getPendingCount() >= this.requestTracker.maxPendingRequests) {
+        if (this.requestTracker.getPendingCount() >= this.requestTracker.getMaxPendingRequests()) {
             return new Promise((resolve, reject) => {
                 this.queuedRequestItems.push({
                     resolve,
@@ -378,6 +386,7 @@ export class AutomationBridge extends EventEmitter {
             this.processRequestQueue();
         }).catch(() => { });
         if (this.send(message)) {
+            this.requestTracker.updateLastRequestSentAt();
             return resultPromise;
         }
         else {
@@ -389,7 +398,7 @@ export class AutomationBridge extends EventEmitter {
         if (this.queuedRequestItems.length === 0)
             return;
         while (this.queuedRequestItems.length > 0 &&
-            this.requestTracker.getPendingCount() < this.requestTracker.maxPendingRequests) {
+            this.requestTracker.getPendingCount() < this.requestTracker.getMaxPendingRequests()) {
             const item = this.queuedRequestItems.shift();
             if (item) {
                 this.sendRequestInternal(item.action, item.payload, item.options)
@@ -437,14 +446,6 @@ export class AutomationBridge extends EventEmitter {
         }
         return sentCount > 0;
     }
-    flushQueue() {
-        if (this.requestQueue.length === 0)
-            return;
-        this.log.info(`Flushing ${this.requestQueue.length} queued automation requests`);
-        const queue = [...this.requestQueue];
-        this.requestQueue = [];
-        queue.forEach(fn => fn());
-    }
     emitAutomation(event, ...args) {
         this.emit(event, ...args);
     }

package/dist/automation/connection-manager.d.ts

@@ -9,6 +9,7 @@ export declare class ConnectionManager extends EventEmitter {
     private lastMessageAt?;
     private log;
     constructor(heartbeatIntervalMs: number);
+    getHeartbeatIntervalMs(): number;
     registerSocket(socket: WebSocket, port: number, metadata?: Record<string, unknown>, remoteAddress?: string, remotePort?: number): void;
     removeSocket(socket: WebSocket): SocketInfo | undefined;
     getActiveSockets(): Map<WebSocket, SocketInfo>;

package/dist/automation/connection-manager.js

@@ -13,6 +13,9 @@ export class ConnectionManager extends EventEmitter {
         super();
         this.heartbeatIntervalMs = heartbeatIntervalMs;
     }
+    getHeartbeatIntervalMs() {
+        return this.heartbeatIntervalMs;
+    }
     registerSocket(socket, port, metadata, remoteAddress, remotePort) {
         const connectionId = randomUUID();
         const sessionId = metadata && typeof metadata.sessionId === 'string' ? metadata.sessionId : undefined;
@@ -32,6 +35,13 @@ export class ConnectionManager extends EventEmitter {
         socket.on('pong', () => {
             this.lastMessageAt = new Date();
         });
+        socket.once('close', () => {
+            this.removeSocket(socket);
+        });
+        socket.once('error', (error) => {
+            this.log.error('Socket error in ConnectionManager', error);
+            this.removeSocket(socket);
+        });
     }
     removeSocket(socket) {
         const info = this.activeSockets.get(socket);

package/dist/automation/message-handler.js

@@ -92,7 +92,7 @@ export class MessageHandler {
                     const synthetic = {
                         type: 'automation_response',
                         requestId: reqId,
-                        success: evtSuccess !== undefined ? evtSuccess : (baseSuccess !== undefined ? baseSuccess : undefined),
+                        success: evtSuccess !== undefined ? evtSuccess : baseSuccess,
                         message: typeof evt.result?.message === 'string' ? evt.result.message : (typeof evt.message === 'string' ? evt.message : FStringSafe(evt.event)),
                         error: typeof evt.result?.error === 'string' ? evt.result.error : undefined,
                         result: evt.result ?? evt.payload ?? undefined
@@ -113,8 +113,9 @@ export class MessageHandler {
             const expected = (expectedAction || '').toString().toLowerCase();
             const echoed = (() => {
                 const r = response;
-                const candidate = (typeof r.action === 'string' && r.action) || (typeof r.result?.action === 'string' && r.result.action);
-                return candidate;
+                const resultObj = response.result;
+                const candidate = (typeof r.action === 'string' && r.action) || (typeof resultObj?.action === 'string' && resultObj.action);
+                return candidate || undefined;
             })();
             if (expected && echoed && typeof echoed === 'string') {
                 const got = echoed.toLowerCase();
@@ -141,7 +142,7 @@ export class MessageHandler {
             }
         }
         catch (e) {
-            this.log.debug('enforceActionMatch check skipped', e);
+            this.log.debug('enforceActionMatch check skipped', e instanceof Error ? e.message : String(e));
         }
         return response;
     }

package/dist/automation/request-tracker.d.ts

@@ -3,7 +3,11 @@ export declare class RequestTracker {
     private maxPendingRequests;
     private pendingRequests;
     private coalescedRequests;
+    private lastRequestSentAt?;
     constructor(maxPendingRequests: number);
+    getMaxPendingRequests(): number;
+    getLastRequestSentAt(): Date | undefined;
+    updateLastRequestSentAt(): void;
     createRequest(action: string, payload: Record<string, unknown>, timeoutMs: number): {
         requestId: string;
         promise: Promise<AutomationBridgeResponseMessage>;

package/dist/automation/request-tracker.js

@@ -1,18 +1,26 @@
 import { randomUUID, createHash } from 'node:crypto';
-const WAIT_FOR_EVENT_ACTIONS = new Set([]);
 export class RequestTracker {
     maxPendingRequests;
     pendingRequests = new Map();
     coalescedRequests = new Map();
+    lastRequestSentAt;
     constructor(maxPendingRequests) {
         this.maxPendingRequests = maxPendingRequests;
     }
+    getMaxPendingRequests() {
+        return this.maxPendingRequests;
+    }
+    getLastRequestSentAt() {
+        return this.lastRequestSentAt;
+    }
+    updateLastRequestSentAt() {
+        this.lastRequestSentAt = new Date();
+    }
     createRequest(action, payload, timeoutMs) {
         if (this.pendingRequests.size >= this.maxPendingRequests) {
             throw new Error(`Max pending requests limit reached (${this.maxPendingRequests})`);
         }
         const requestId = randomUUID();
-        const waitForEvent = WAIT_FOR_EVENT_ACTIONS.has(action);
         const promise = new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 if (this.pendingRequests.has(requestId)) {
@@ -27,7 +35,7 @@ export class RequestTracker {
                 action,
                 payload,
                 requestedAt: new Date(),
-                waitForEvent,
+                waitForEvent: false,
                 eventTimeoutMs: timeoutMs
             });
         });

package/dist/tools/actors.d.ts

@@ -64,7 +64,25 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             z: number;
         };
     }): Promise<StandardActionResponse<any>>;
-    getTransform(actorName: string): Promise<StandardActionResponse<any>>;
+    getTransform(actorName: string): Promise<{
+        success: boolean;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
+        message?: undefined;
+        location?: undefined;
+        rotation?: undefined;
+        scale?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        location: any;
+        rotation: any;
+        scale: any;
+        error?: undefined;
+    }>;
     setVisibility(params: {
         actorName: string;
         visible: boolean;

package/dist/tools/actors.js

@@ -40,7 +40,8 @@ export class ActorTools extends BaseTool {
             }, timeoutMs ? { timeoutMs } : undefined);
             if (!response || !response.success) {
                 const error = response?.error;
-                const errorMsg = typeof error === 'string' ? error : error?.message || response?.message || 'Failed to spawn actor';
+                const errorObj = typeof error === 'object' && error !== null ? error : null;
+                const errorMsg = typeof error === 'string' ? error : errorObj?.message || response?.message || 'Failed to spawn actor';
                 throw new Error(errorMsg);
             }
             const data = response.data || {};
@@ -226,10 +227,19 @@ export class ActorTools extends BaseTool {
         if (typeof actorName !== 'string' || actorName.trim().length === 0) {
             throw new Error('Invalid actorName');
         }
-        return this.sendRequest('get_transform', { actorName }, 'control_actor')
-            .then(response => {
-            return response;
-        });
+        const response = await this.sendRequest('get_transform', { actorName }, 'control_actor');
+        if (!response.success) {
+            return { success: false, error: response.error || `Failed to get transform for actor ${actorName}` };
+        }
+        const rawData = response.data ?? response.result ?? response;
+        const data = rawData?.data ?? rawData;
+        return {
+            success: true,
+            message: 'Transform retrieved',
+            location: data.location ?? data.Location,
+            rotation: data.rotation ?? data.Rotation,
+            scale: data.scale ?? data.Scale
+        };
     }
     async setVisibility(params) {
         const actorName = typeof params.actorName === 'string' ? params.actorName.trim() : '';

package/dist/tools/assets.js

@@ -222,7 +222,7 @@ export class AssetTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Analysis failed: ${e.message} ` };
+            return { success: false, error: `Analysis failed: ${e instanceof Error ? e.message : String(e)} ` };
         }
     }
     async createThumbnail(params) {

package/dist/tools/blueprint.d.ts

@@ -233,6 +233,18 @@ export declare class BlueprintTools extends BaseTool implements IBlueprintTools
         graphName?: string;
         timeoutMs?: number;
     }): Promise<StandardActionResponse>;
+    listNodeTypes(params?: {
+        blueprintPath?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    setPinDefaultValue(params: {
+        blueprintPath: string;
+        nodeId: string;
+        pinName: string;
+        value: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
     connectPins(params: {
         blueprintName: string;
         sourceNodeGuid: string;

package/dist/tools/blueprint.js

@@ -12,17 +12,20 @@ export class BlueprintTools extends BaseTool {
         try {
             const response = await this.sendAutomationRequest(action, payload, { timeoutMs: finalTimeout, waitForEvent: !!options?.waitForEvent, waitForEventTimeoutMs: options?.waitForEventTimeoutMs });
             const success = response && response.success !== false;
-            const result = response.result ?? response;
+            const result = (response.result ?? response);
             return { success, message: response.message ?? undefined, error: response.success === false ? (response.error ?? response.message) : undefined, result, requestId: response.requestId };
         }
         catch (err) {
-            return { success: false, error: String(err), message: String(err) };
+            const errMsg = err instanceof Error ? err.message : String(err);
+            return { success: false, error: errMsg, message: errMsg };
         }
     }
     isUnknownActionResponse(res) {
         if (!res)
             return false;
-        const txt = String((res.error ?? res.message ?? '')).toLowerCase();
+        const errStr = typeof res.error === 'string' ? res.error : '';
+        const msgStr = typeof res.message === 'string' ? res.message : '';
+        const txt = (errStr || msgStr).toLowerCase();
         return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
     }
     buildCandidates(rawName) {
@@ -114,7 +117,7 @@ export class BlueprintTools extends BaseTool {
         if (typeof params.save === 'boolean')
             payload.save = params.save;
         const res = await this.sendAction('blueprint_modify_scs', payload, { timeoutMs: params.timeoutMs, waitForEvent: !!params.waitForCompletion, waitForEventTimeoutMs: params.waitForCompletionTimeoutMs });
-        if (res && res.result && typeof res.result === 'object' && res.result.error === 'SCS_UNAVAILABLE') {
+        if (res && res.result && typeof res.result === 'object' && res.result?.error === 'SCS_UNAVAILABLE') {
             this.pluginBlueprintActionsAvailable = false;
             return { success: false, error: 'SCS_UNAVAILABLE', message: 'Plugin does not support construction script modification (blueprint_modify_scs)' };
         }
@@ -441,8 +444,8 @@ export class BlueprintTools extends BaseTool {
             }
             const pluginResp = await this.sendAction('add_scs_component', payload, { timeoutMs: params.timeoutMs });
             if (pluginResp && pluginResp.success === false) {
-                if (pluginResp.message) {
-                    this.log.warn?.(`addSCSComponent reported warning: ${pluginResp.message}`);
+                if (pluginResp?.message) {
+                    this.log.warn?.(`addSCSComponent reported warning: ${pluginResp?.message}`);
                 }
             }
             if (pluginResp && pluginResp.success)
@@ -468,8 +471,8 @@ export class BlueprintTools extends BaseTool {
         try {
             const pluginResp = await this.sendAction('remove_scs_component', { blueprint_path: blueprintPath, component_name: componentName }, { timeoutMs: params.timeoutMs });
             if (pluginResp && pluginResp.success === false) {
-                if (pluginResp.message) {
-                    this.log.warn?.(`removeSCSComponent reported warning: ${pluginResp.message}`);
+                if (pluginResp?.message) {
+                    this.log.warn?.(`removeSCSComponent reported warning: ${pluginResp?.message}`);
                 }
             }
             if (pluginResp && pluginResp.success)
@@ -499,8 +502,8 @@ export class BlueprintTools extends BaseTool {
                 new_parent: params.newParent || ''
             }, { timeoutMs: params.timeoutMs });
             if (pluginResp && pluginResp.success === false) {
-                if (pluginResp.message) {
-                    this.log.warn?.(`reparentSCSComponent reported warning: ${pluginResp.message}`);
+                if (pluginResp?.message) {
+                    this.log.warn?.(`reparentSCSComponent reported warning: ${pluginResp?.message}`);
                 }
             }
             if (pluginResp && pluginResp.success)
@@ -536,8 +539,8 @@ export class BlueprintTools extends BaseTool {
                 payload.scale = params.scale;
             const pluginResp = await this.sendAction('set_scs_component_transform', payload, { timeoutMs: params.timeoutMs });
             if (pluginResp && pluginResp.success === false) {
-                if (pluginResp.message) {
-                    this.log.warn?.(`setSCSComponentTransform reported warning: ${pluginResp.message}`);
+                if (pluginResp?.message) {
+                    this.log.warn?.(`setSCSComponentTransform reported warning: ${pluginResp?.message}`);
                 }
             }
             if (pluginResp && pluginResp.success)
@@ -573,8 +576,8 @@ export class BlueprintTools extends BaseTool {
                 property_value: propertyValueJson
             }, { timeoutMs: params.timeoutMs });
             if (pluginResp && pluginResp.success === false) {
-                if (pluginResp.message) {
-                    this.log.warn?.(`setSCSComponentProperty reported warning: ${pluginResp.message}`);
+                if (pluginResp?.message) {
+                    this.log.warn?.(`setSCSComponentProperty reported warning: ${pluginResp?.message}`);
                 }
             }
             if (pluginResp && pluginResp.success)
@@ -722,6 +725,32 @@ export class BlueprintTools extends BaseTool {
         }, { timeoutMs: params.timeoutMs });
         return res;
     }
+    async listNodeTypes(params = {}) {
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'list_node_types',
+            blueprintPath: params.blueprintPath || '/Game/Temp',
+            graphName: 'EventGraph'
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
+    async setPinDefaultValue(params) {
+        const blueprintPath = coerceString(params.blueprintPath);
+        if (!blueprintPath)
+            return { success: false, error: 'INVALID_BLUEPRINT_PATH', message: 'Blueprint path is required' };
+        if (!params.nodeId)
+            return { success: false, error: 'INVALID_NODE_ID', message: 'Node ID is required' };
+        if (!params.pinName)
+            return { success: false, error: 'INVALID_PIN_NAME', message: 'Pin name is required' };
+        const res = await this.sendAction('manage_blueprint_graph', {
+            subAction: 'set_pin_default_value',
+            blueprintPath: blueprintPath,
+            graphName: params.graphName || 'EventGraph',
+            nodeId: params.nodeId,
+            pinName: params.pinName,
+            value: params.value
+        }, { timeoutMs: params.timeoutMs });
+        return res;
+    }
     async connectPins(params) {
         const candidates = this.buildCandidates(params.blueprintName);
         const primary = candidates[0];

package/dist/tools/consolidated-tool-definitions.js

@@ -917,7 +917,8 @@ Supported actions: create_node, delete_node, connect_pins, break_pin_links, set_
                     type: 'string',
                     enum: [
                         'create_node', 'delete_node', 'connect_pins', 'break_pin_links', 'set_node_property',
-                        'create_reroute_node', 'get_node_details', 'get_graph_details', 'get_pin_details'
+                        'create_reroute_node', 'get_node_details', 'get_graph_details', 'get_pin_details',
+                        'list_node_types', 'set_pin_default_value'
                     ],
                     description: 'Action'
                 },

package/dist/tools/editor.js

@@ -34,8 +34,9 @@ export class EditorTools extends BaseTool {
                 return { success: false, error: response?.error || response?.message || 'Failed to start PIE' };
             }
             catch (err) {
-                if (err.message && /time.*out/i.test(err.message)) {
-                    return { success: false, error: `Timeout waiting for PIE to start: ${err.message}` };
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (errMsg && /time.*out/i.test(errMsg)) {
+                    return { success: false, error: `Timeout waiting for PIE to start: ${errMsg}` };
                 }
                 await this.bridge.executeConsoleCommand('t.MaxFPS 60');
                 await this.bridge.executeConsoleCommand('PlayInViewport');

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

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

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

@@ -1,6 +1,6 @@
-import { cleanObject } from '../../utils/safe-json.js';
 import { executeAutomationRequest } from './common-handlers.js';
 import { normalizeArgs } from './argument-helper.js';
+import { ResponseFactory } from '../../utils/response-factory.js';
 const handlers = {
     spawn: async (args, tools) => {
         const classAliases = {
@@ -28,11 +28,11 @@ const handlers = {
         ]);
         const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined;
         if (typeof timeoutMs === 'number' && timeoutMs > 0 && timeoutMs < 200) {
-            return cleanObject({
+            return {
                 success: false,
                 error: `Timeout too small for spawn operation: ${timeoutMs}ms`,
                 message: 'Timeout too small for spawn operation'
-            });
+            };
         }
         const originalClass = args.classPath || args.class || args.type || args.actorClass;
         const componentToAdd = (originalClass === 'SplineActor' || originalClass === 'Spline')
@@ -217,11 +217,17 @@ const handlers = {
     }
 };
 export async function handleActorTools(action, args, tools) {
-    const handler = handlers[action];
-    if (handler) {
-        const res = await handler(args, tools);
-        return cleanObject(res);
+    try {
+        const handler = handlers[action];
+        if (handler) {
+            const res = await handler(args, tools);
+            return ResponseFactory.success(res);
+        }
+        const res = await executeAutomationRequest(tools, 'control_actor', args);
+        return ResponseFactory.success(res);
+    }
+    catch (error) {
+        return ResponseFactory.error(error);
     }
-    return executeAutomationRequest(tools, 'control_actor', args);
 }
 //# sourceMappingURL=actor-handlers.js.map

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

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