unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/base-tool.d.ts

@@ -0,0 +1,17 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
+import { IBaseTool } from '../types/tool-interfaces.js';
+export declare abstract class BaseTool implements IBaseTool {
+    protected bridge: UnrealBridge;
+    constructor(bridge: UnrealBridge);
+    getAutomationBridge(): AutomationBridge;
+    protected sendRequest<T = unknown>(action: string, params: Record<string, unknown>, toolName?: string, options?: {
+        timeoutMs?: number;
+    }): Promise<T>;
+    protected sendAutomationRequest<T = unknown>(action: string, params?: Record<string, unknown>, options?: {
+        timeoutMs?: number;
+        waitForEvent?: boolean;
+        waitForEventTimeoutMs?: number;
+    }): Promise<T>;
+}
+//# sourceMappingURL=base-tool.d.ts.map

package/dist/tools/base-tool.js

@@ -0,0 +1,46 @@
+export class BaseTool {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getAutomationBridge() {
+        return this.bridge.getAutomationBridge();
+    }
+    async sendRequest(action, params, toolName = 'unknown_tool', options) {
+        const automation = this.getAutomationBridge();
+        if (!automation.isConnected()) {
+            throw new Error(`Automation bridge not connected for ${toolName}`);
+        }
+        const response = await automation.sendAutomationRequest(toolName, {
+            action,
+            ...params
+        }, options);
+        if (!response || response.success === false) {
+            let errorMessage = `Failed to execute ${action} in ${toolName}`;
+            if (response?.error) {
+                if (typeof response.error === 'string') {
+                    errorMessage = response.error;
+                }
+                else if (typeof response.error === 'object') {
+                    const errObj = response.error;
+                    if (errObj.message) {
+                        errorMessage = `${errObj.message} (Code: ${errObj.code || 'UNKNOWN'})`;
+                    }
+                }
+            }
+            else if (response?.message) {
+                errorMessage = response.message;
+            }
+            throw new Error(errorMessage);
+        }
+        return (response.result ?? response);
+    }
+    async sendAutomationRequest(action, params = {}, options) {
+        const automation = this.getAutomationBridge();
+        if (!automation.isConnected()) {
+            throw new Error('Automation bridge not connected');
+        }
+        return automation.sendAutomationRequest(action, params, options);
+    }
+}
+//# sourceMappingURL=base-tool.js.map

package/dist/tools/behavior-tree.d.ts

@@ -0,0 +1,94 @@
+import { BaseTool } from './base-tool.js';
+export declare class BehaviorTreeTools extends BaseTool {
+    private sendAction;
+    addNode(params: {
+        assetPath: string;
+        nodeType: string;
+        x: number;
+        y: number;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    connectNodes(params: {
+        assetPath: string;
+        parentNodeId: string;
+        childNodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    removeNode(params: {
+        assetPath: string;
+        nodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    breakConnections(params: {
+        assetPath: string;
+        nodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    setNodeProperties(params: {
+        assetPath: string;
+        nodeId: string;
+        comment?: string;
+        properties?: Record<string, unknown>;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    create(params: {
+        name: string;
+        savePath?: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+}
+//# sourceMappingURL=behavior-tree.d.ts.map

package/dist/tools/behavior-tree.js

@@ -0,0 +1,39 @@
+import { BaseTool } from './base-tool.js';
+export class BehaviorTreeTools extends BaseTool {
+    async sendAction(subAction, payload = {}) {
+        try {
+            const response = await this.sendAutomationRequest('manage_behavior_tree', {
+                subAction,
+                ...payload
+            });
+            return {
+                success: response?.success ?? false,
+                message: response?.message,
+                error: response?.error,
+                result: response?.result
+            };
+        }
+        catch (e) {
+            return { success: false, error: String(e) };
+        }
+    }
+    async addNode(params) {
+        return this.sendAction('add_node', params);
+    }
+    async connectNodes(params) {
+        return this.sendAction('connect_nodes', params);
+    }
+    async removeNode(params) {
+        return this.sendAction('remove_node', params);
+    }
+    async breakConnections(params) {
+        return this.sendAction('break_connections', params);
+    }
+    async setNodeProperties(params) {
+        return this.sendAction('set_node_properties', params);
+    }
+    async create(params) {
+        return this.sendAction('create', params);
+    }
+}
+//# sourceMappingURL=behavior-tree.js.map

package/dist/tools/blueprint.d.ts

@@ -1,87 +1,60 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-export declare class BlueprintTools {
-    private bridge;
-    constructor(bridge: UnrealBridge);
-    private validateParentClassReference;
-    /**
-     * Create Blueprint
-     */
+import { BaseTool } from './base-tool.js';
+import { IBlueprintTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class BlueprintTools extends BaseTool implements IBlueprintTools {
+    private log;
+    private pluginBlueprintActionsAvailable;
+    private sendAction;
+    private isUnknownActionResponse;
+    private buildCandidates;
     createBlueprint(params: {
         name: string;
-        blueprintType: 'Actor' | 'Pawn' | 'Character' | 'GameMode' | 'PlayerController' | 'HUD' | 'ActorComponent';
+        blueprintType?: string;
         savePath?: string;
         parentClass?: string;
-    }): Promise<{
-        success: true;
-        message: string;
-        path: string;
-        exists?: boolean;
-        parent?: string;
-        verifyError?: string;
-        warnings?: string[];
-        details?: string[];
-    } | {
-        success: boolean;
-        message: string;
-        error: string;
-        path: string;
-    } | {
-        success: boolean;
-        message: string;
-        path: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        error: string | undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    private parseBlueprintCreationOutput;
-    /**
-     * Add Component to Blueprint
-     */
+        properties?: Record<string, unknown>;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    modifyConstructionScript(params: {
+        blueprintPath: string;
+        operations: any[];
+        compile?: boolean;
+        save?: boolean;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
     addComponent(params: {
         blueprintName: string;
         componentType: string;
         componentName: string;
         attachTo?: string;
-        transform?: {
-            location?: [number, number, number];
-            rotation?: [number, number, number];
-            scale?: [number, number, number];
-        };
-    }): Promise<{
-        success: true;
-        message: string;
-        blueprintPath: string;
-        component: string;
-        componentType: string;
-        warnings?: string[];
-        details?: string[];
-    } | {
-        success: false;
-        message: string;
-        error: string;
+        transform?: Record<string, unknown>;
+        properties?: Record<string, unknown>;
+        compile?: boolean;
+        save?: boolean;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    waitForBlueprint(blueprintRef: string | string[], timeoutMs?: number): Promise<StandardActionResponse>;
+    getBlueprint(params: {
+        blueprintName: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    getBlueprintInfo(params: {
         blueprintPath: string;
-        component: string;
-        componentType: string;
-        warnings?: string[];
-        details?: string[];
-    } | {
-        success: boolean;
-        message: string;
-        error: string;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    /**
-     * Add Variable to Blueprint
-     */
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    probeSubobjectDataHandle(opts?: {
+        componentClass?: string;
+    }): Promise<StandardActionResponse>;
+    setBlueprintDefault(params: {
+        blueprintName: string;
+        propertyName: string;
+        value: unknown;
+    }): Promise<StandardActionResponse>;
     addVariable(params: {
         blueprintName: string;
         variableName: string;
@@ -90,18 +63,46 @@ export declare class BlueprintTools {
         category?: string;
         isReplicated?: boolean;
         isPublic?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    /**
-     * Add Function to Blueprint
-     */
+        variablePinType?: Record<string, unknown>;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    removeVariable(params: {
+        blueprintName: string;
+        variableName: string;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    renameVariable(params: {
+        blueprintName: string;
+        oldName: string;
+        newName: string;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    addEvent(params: {
+        blueprintName: string;
+        eventType: string;
+        customEventName?: string;
+        parameters?: Array<{
+            name: string;
+            type: string;
+        }>;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    removeEvent(params: {
+        blueprintName: string;
+        eventName: string;
+        customEventName?: string;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
     addFunction(params: {
         blueprintName: string;
         functionName: string;
@@ -115,49 +116,130 @@ export declare class BlueprintTools {
         }>;
         isPublic?: boolean;
         category?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    /**
-     * Add Event to Blueprint
-     */
-    addEvent(params: {
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    setVariableMetadata(params: {
         blueprintName: string;
-        eventType: 'BeginPlay' | 'Tick' | 'EndPlay' | 'BeginOverlap' | 'EndOverlap' | 'Hit' | 'Custom';
-        customEventName?: string;
-        parameters?: Array<{
-            name: string;
-            type: string;
-        }>;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
-    /**
-     * Compile Blueprint
-     */
+        variableName: string;
+        metadata: Record<string, unknown>;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    addConstructionScript(params: {
+        blueprintName: string;
+        scriptName: string;
+        timeoutMs?: number;
+        waitForCompletion?: boolean;
+        waitForCompletionTimeoutMs?: number;
+    }): Promise<StandardActionResponse>;
     compileBlueprint(params: {
         blueprintName: string;
         saveAfterCompile?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
+    getBlueprintSCS(params: {
+        blueprintPath: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    addSCSComponent(params: {
+        blueprintPath: string;
+        componentClass: string;
+        componentName: string;
+        parentComponent?: string;
+        meshPath?: string;
+        materialPath?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    removeSCSComponent(params: {
+        blueprintPath: string;
+        componentName: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    reparentSCSComponent(params: {
+        blueprintPath: string;
+        componentName: string;
+        newParent: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    setSCSComponentTransform(params: {
+        blueprintPath: string;
+        componentName: string;
+        location?: [number, number, number];
+        rotation?: [number, number, number];
+        scale?: [number, number, number];
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    setSCSComponentProperty(params: {
+        blueprintPath: string;
+        componentName: string;
+        propertyName: string;
+        propertyValue: any;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    getNodes(params: {
+        blueprintPath: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    addNode(params: {
+        blueprintName: string;
+        nodeType: string;
+        graphName?: string;
+        functionName?: string;
+        variableName?: string;
+        nodeName?: string;
+        eventName?: string;
+        memberClass?: string;
+        posX?: number;
+        posY?: number;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    deleteNode(params: {
+        blueprintPath: string;
+        nodeId: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    createRerouteNode(params: {
+        blueprintPath: string;
+        graphName?: string;
+        x: number;
+        y: number;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    setNodeProperty(params: {
+        blueprintPath: string;
+        nodeId: string;
+        propertyName: string;
+        value: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    getNodeDetails(params: {
+        blueprintPath: string;
+        nodeId: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    getGraphDetails(params: {
+        blueprintPath: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    getPinDetails(params: {
+        blueprintPath: string;
+        nodeId: string;
+        pinName?: string;
+        graphName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
+    connectPins(params: {
+        blueprintName: string;
+        sourceNodeGuid: string;
+        targetNodeGuid: string;
+        sourcePinName?: string;
+        targetPinName?: string;
+        timeoutMs?: number;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=blueprint.d.ts.map