unreal-engine-mcp-server 0.5.0 → 0.5.2

package/src/types/tool-interfaces.ts

@@ -8,8 +8,8 @@ export interface StandardActionResponse<T = any> {
     success: boolean;
     data?: T;
     warnings?: string[];
-    error?: {
-        code: string;
+    error?: string | {
+        code?: string;
         message: string;
         [key: string]: unknown;
     } | null;
@@ -53,48 +53,48 @@ export interface SourceControlState {
 }
 
 export interface IAssetTools {
-    importAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean; save?: boolean }): Promise<any>;
-    createFolder(path: string): Promise<any>;
-    duplicateAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean }): Promise<any>;
-    renameAsset(params: { sourcePath: string; destinationPath: string }): Promise<any>;
-    moveAsset(params: { sourcePath: string; destinationPath: string }): Promise<any>;
-    deleteAssets(params: { paths: string[]; fixupRedirectors?: boolean; timeoutMs?: number }): Promise<any>;
-    searchAssets(params: { classNames?: string[]; packagePaths?: string[]; recursivePaths?: boolean; recursiveClasses?: boolean; limit?: number }): Promise<any>;
-    saveAsset(assetPath: string): Promise<any>;
-    findByTag(params: { tag: string; value?: string }): Promise<any>;
-    getDependencies(params: { assetPath: string; recursive?: boolean }): Promise<any>;
-    getMetadata(params: { assetPath: string }): Promise<any>;
-    getSourceControlState(params: { assetPath: string }): Promise<SourceControlState | any>;
-    analyzeGraph(params: { assetPath: string; maxDepth?: number }): Promise<any>;
-    createThumbnail(params: { assetPath: string; width?: number; height?: number }): Promise<any>;
-    setTags(params: { assetPath: string; tags: string[] }): Promise<any>;
-    generateReport(params: { directory: string; reportType?: string; outputPath?: string }): Promise<any>;
-    validate(params: { assetPath: string }): Promise<any>;
-    generateLODs(params: { assetPath: string; lodCount: number; reductionSettings?: Record<string, unknown> }): Promise<any>;
+    importAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean; save?: boolean }): Promise<StandardActionResponse>;
+    createFolder(path: string): Promise<StandardActionResponse>;
+    duplicateAsset(params: { sourcePath: string; destinationPath: string; overwrite?: boolean }): Promise<StandardActionResponse>;
+    renameAsset(params: { sourcePath: string; destinationPath: string }): Promise<StandardActionResponse>;
+    moveAsset(params: { sourcePath: string; destinationPath: string }): Promise<StandardActionResponse>;
+    deleteAssets(params: { paths: string[]; fixupRedirectors?: boolean; timeoutMs?: number }): Promise<StandardActionResponse>;
+    searchAssets(params: { classNames?: string[]; packagePaths?: string[]; recursivePaths?: boolean; recursiveClasses?: boolean; limit?: number }): Promise<StandardActionResponse>;
+    saveAsset(assetPath: string): Promise<StandardActionResponse>;
+    findByTag(params: { tag: string; value?: string }): Promise<StandardActionResponse>;
+    getDependencies(params: { assetPath: string; recursive?: boolean }): Promise<StandardActionResponse>;
+    getMetadata(params: { assetPath: string }): Promise<StandardActionResponse>;
+    getSourceControlState(params: { assetPath: string }): Promise<SourceControlState | StandardActionResponse>;
+    analyzeGraph(params: { assetPath: string; maxDepth?: number }): Promise<StandardActionResponse>;
+    createThumbnail(params: { assetPath: string; width?: number; height?: number }): Promise<StandardActionResponse>;
+    setTags(params: { assetPath: string; tags: string[] }): Promise<StandardActionResponse>;
+    generateReport(params: { directory: string; reportType?: string; outputPath?: string }): Promise<StandardActionResponse>;
+    validate(params: { assetPath: string }): Promise<StandardActionResponse>;
+    generateLODs(params: { assetPath: string; lodCount: number; reductionSettings?: Record<string, unknown> }): Promise<StandardActionResponse>;
 }
 
 export interface ISequenceTools {
-    create(params: { name: string; path?: string; timeoutMs?: number }): Promise<any>;
-    open(params: { path: string }): Promise<any>;
-    addCamera(params: { spawnable?: boolean; path?: string }): Promise<any>;
-    addActor(params: { actorName: string; createBinding?: boolean; path?: string }): Promise<any>;
-    addActors(params: { actorNames: string[]; path?: string }): Promise<any>;
-    removeActors(params: { actorNames: string[]; path?: string }): Promise<any>;
-    getBindings(params: { path?: string }): Promise<any>;
-    addSpawnableFromClass(params: { className: string; path?: string }): Promise<any>;
-    play(params: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }): Promise<any>;
-    pause(params?: { path?: string }): Promise<any>;
-    stop(params?: { path?: string }): Promise<any>;
-    setSequenceProperties(params: { path?: string; frameRate?: number; lengthInFrames?: number; playbackStart?: number; playbackEnd?: number }): Promise<any>;
-    getSequenceProperties(params: { path?: string }): Promise<any>;
-    setPlaybackSpeed(params: { speed: number; path?: string }): Promise<any>;
-    list(params: { path?: string }): Promise<any>;
-    duplicate(params: { path: string; destinationPath: string }): Promise<any>;
-    rename(params: { path: string; newName: string }): Promise<any>;
-    deleteSequence(params: { path: string }): Promise<any>;
-    getMetadata(params: { path: string }): Promise<any>;
-    listTracks(params: { path: string }): Promise<any>;
-    setWorkRange(params: { path?: string; start: number; end: number }): Promise<any>;
+    create(params: { name: string; path?: string; timeoutMs?: number }): Promise<StandardActionResponse>;
+    open(params: { path: string }): Promise<StandardActionResponse>;
+    addCamera(params: { spawnable?: boolean; path?: string }): Promise<StandardActionResponse>;
+    addActor(params: { actorName: string; createBinding?: boolean; path?: string }): Promise<StandardActionResponse>;
+    addActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse>;
+    removeActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse>;
+    getBindings(params: { path?: string }): Promise<StandardActionResponse>;
+    addSpawnableFromClass(params: { className: string; path?: string }): Promise<StandardActionResponse>;
+    play(params: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }): Promise<StandardActionResponse>;
+    pause(params?: { path?: string }): Promise<StandardActionResponse>;
+    stop(params?: { path?: string }): Promise<StandardActionResponse>;
+    setSequenceProperties(params: { path?: string; frameRate?: number; lengthInFrames?: number; playbackStart?: number; playbackEnd?: number }): Promise<StandardActionResponse>;
+    getSequenceProperties(params: { path?: string }): Promise<StandardActionResponse>;
+    setPlaybackSpeed(params: { speed: number; path?: string }): Promise<StandardActionResponse>;
+    list(params: { path?: string }): Promise<StandardActionResponse>;
+    duplicate(params: { path: string; destinationPath: string }): Promise<StandardActionResponse>;
+    rename(params: { path: string; newName: string }): Promise<StandardActionResponse>;
+    deleteSequence(params: { path: string }): Promise<StandardActionResponse>;
+    getMetadata(params: { path: string }): Promise<StandardActionResponse>;
+    listTracks(params: { path: string }): Promise<StandardActionResponse>;
+    setWorkRange(params: { path?: string; start: number; end: number }): Promise<StandardActionResponse>;
 }
 
 export interface IAssetResources {
@@ -102,118 +102,118 @@ export interface IAssetResources {
 }
 
 export interface IBlueprintTools {
-    createBlueprint(params: { name: string; blueprintType?: string; savePath?: string; parentClass?: string; properties?: Record<string, unknown>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    modifyConstructionScript(params: { blueprintPath: string; operations: any[]; compile?: boolean; save?: boolean; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    addComponent(params: { blueprintName: string; componentType: string; componentName: string; attachTo?: string; transform?: Record<string, unknown>; properties?: Record<string, unknown>; compile?: boolean; save?: boolean; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    waitForBlueprint(blueprintRef: string | string[], timeoutMs?: number): Promise<any>;
-    getBlueprint(params: { blueprintName: string; timeoutMs?: number }): Promise<any>;
-    getBlueprintInfo(params: { blueprintPath: string; timeoutMs?: number }): Promise<any>;
-    probeSubobjectDataHandle(opts?: { componentClass?: string }): Promise<any>;
-    setBlueprintDefault(params: { blueprintName: string; propertyName: string; value: unknown }): Promise<any>;
-    addVariable(params: { blueprintName: string; variableName: string; variableType: string; defaultValue?: any; category?: string; isReplicated?: boolean; isPublic?: boolean; variablePinType?: Record<string, unknown>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    removeVariable(params: { blueprintName: string; variableName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    addEvent(params: { blueprintName: string; eventType: string; customEventName?: string; parameters?: Array<{ name: string; type: string }>; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    removeEvent(params: { blueprintName: string; eventName: string; customEventName?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    addFunction(params: { blueprintName: string; functionName: string; inputs?: Array<{ name: string; type: string }>; outputs?: Array<{ name: string; type: string }>; isPublic?: boolean; category?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    setVariableMetadata(params: { blueprintName: string; variableName: string; metadata: Record<string, unknown>; timeoutMs?: number }): Promise<any>;
-    renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    addConstructionScript(params: { blueprintName: string; scriptName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<any>;
-    compileBlueprint(params: { blueprintName: string; saveAfterCompile?: boolean }): Promise<any>;
-    getBlueprintSCS(params: { blueprintPath: string; timeoutMs?: number }): Promise<any>;
-    addSCSComponent(params: { blueprintPath: string; componentClass: string; componentName: string; parentComponent?: string; meshPath?: string; materialPath?: string; timeoutMs?: number }): Promise<any>;
-    removeSCSComponent(params: { blueprintPath: string; componentName: string; timeoutMs?: number }): Promise<any>;
-    reparentSCSComponent(params: { blueprintPath: string; componentName: string; newParent: string; timeoutMs?: number }): Promise<any>;
-    setSCSComponentTransform(params: { blueprintPath: string; componentName: string; location?: [number, number, number]; rotation?: [number, number, number]; scale?: [number, number, number]; timeoutMs?: number }): Promise<any>;
-    setSCSComponentProperty(params: { blueprintPath: string; componentName: string; propertyName: string; propertyValue: any; timeoutMs?: number }): Promise<any>;
-    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<any>;
-    connectPins(params: { blueprintName: string; sourceNodeGuid: string; targetNodeGuid: string; sourcePinName?: string; targetPinName?: string; timeoutMs?: number }): Promise<any>;
+    createBlueprint(params: { name: string; blueprintType?: string; savePath?: string; parentClass?: string; 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?: 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; 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; variableType: string; defaultValue?: any; category?: string; isReplicated?: boolean; isPublic?: boolean; 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; inputs?: Array<{ name: string; type: string }>; outputs?: Array<{ name: string; type: string }>; isPublic?: boolean; category?: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse>;
+    setVariableMetadata(params: { blueprintName: string; variableName: string; metadata: Record<string, unknown>; timeoutMs?: number }): Promise<StandardActionResponse>;
+    renameVariable(params: { blueprintName: string; oldName: string; newName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse>;
+    addConstructionScript(params: { blueprintName: string; scriptName: string; timeoutMs?: number; waitForCompletion?: boolean; waitForCompletionTimeoutMs?: number }): Promise<StandardActionResponse>;
+    compileBlueprint(params: { blueprintName: string; saveAfterCompile?: boolean }): 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>;
+    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>;
+    connectPins(params: { blueprintName: string; sourceNodeGuid: string; targetNodeGuid: string; sourcePinName?: string; targetPinName?: string; timeoutMs?: number }): Promise<StandardActionResponse>;
 }
 
 export interface ILevelTools {
-    listLevels(): Promise<any>;
-    getLevelSummary(levelPath?: string): Promise<any>;
+    listLevels(): Promise<StandardActionResponse>;
+    getLevelSummary(levelPath?: string): Promise<StandardActionResponse>;
     registerLight(levelPath: string | undefined, info: { name: string; type: string; details?: Record<string, unknown> }): void;
-    exportLevel(params: { levelPath?: string; exportPath: string; note?: string; timeoutMs?: number }): Promise<any>;
-    importLevel(params: { packagePath: string; destinationPath?: string; streaming?: boolean; timeoutMs?: number }): Promise<any>;
-    saveLevelAs(params: { sourcePath?: string; targetPath: string }): Promise<any>;
-    deleteLevels(params: { levelPaths: string[] }): Promise<any>;
-    loadLevel(params: { levelPath: string; streaming?: boolean; position?: [number, number, number] }): Promise<any>;
-    saveLevel(params: { levelName?: string; savePath?: string }): Promise<any>;
-    createLevel(params: { levelName: string; template?: 'Empty' | 'Default' | 'VR' | 'TimeOfDay'; savePath?: string }): Promise<any>;
-    addSubLevel(params: { parentLevel?: string; subLevelPath: string; streamingMethod?: 'Blueprint' | 'AlwaysLoaded' }): Promise<any>;
-    streamLevel(params: { levelPath?: string; levelName?: string; shouldBeLoaded: boolean; shouldBeVisible?: boolean; position?: [number, number, number] }): Promise<any>;
-    setupWorldComposition(params: { enableComposition: boolean; tileSize?: number; distanceStreaming?: boolean; streamingDistance?: number }): Promise<any>;
-    editLevelBlueprint(params: { eventType: 'BeginPlay' | 'EndPlay' | 'Tick' | 'Custom'; customEventName?: string; nodes?: Array<{ nodeType: string; position: [number, number]; connections?: string[] }> }): Promise<any>;
-    createSubLevel(params: { name: string; type: 'Persistent' | 'Streaming' | 'Lighting' | 'Gameplay'; parent?: string }): Promise<any>;
-    setWorldSettings(params: { gravity?: number; worldScale?: number; gameMode?: string; defaultPawn?: string; killZ?: number }): Promise<any>;
-    setLevelBounds(params: { min: [number, number, number]; max: [number, number, number] }): Promise<any>;
-    buildNavMesh(params: { rebuildAll?: boolean; selectedOnly?: boolean }): Promise<any>;
-    setLevelVisibility(params: { levelName: string; visible: boolean }): Promise<any>;
-    setWorldOrigin(params: { location: [number, number, number] }): Promise<any>;
-    createStreamingVolume(params: { levelName: string; position: [number, number, number]; size: [number, number, number]; streamingDistance?: number }): Promise<any>;
-    setLevelLOD(params: { levelName: string; lodLevel: number; distance: number }): Promise<any>;
+    exportLevel(params: { levelPath?: string; exportPath: string; note?: string; timeoutMs?: number }): Promise<StandardActionResponse>;
+    importLevel(params: { packagePath: string; destinationPath?: string; streaming?: boolean; timeoutMs?: number }): Promise<StandardActionResponse>;
+    saveLevelAs(params: { sourcePath?: string; targetPath: string }): Promise<StandardActionResponse>;
+    deleteLevels(params: { levelPaths: string[] }): Promise<StandardActionResponse>;
+    loadLevel(params: { levelPath: string; streaming?: boolean; position?: [number, number, number] }): Promise<StandardActionResponse>;
+    saveLevel(params: { levelName?: string; savePath?: string }): Promise<StandardActionResponse>;
+    createLevel(params: { levelName: string; template?: 'Empty' | 'Default' | 'VR' | 'TimeOfDay'; savePath?: string }): Promise<StandardActionResponse>;
+    addSubLevel(params: { parentLevel?: string; subLevelPath: string; streamingMethod?: 'Blueprint' | 'AlwaysLoaded' }): Promise<StandardActionResponse>;
+    streamLevel(params: { levelPath?: string; levelName?: string; shouldBeLoaded: boolean; shouldBeVisible?: boolean; position?: [number, number, number] }): Promise<StandardActionResponse>;
+    setupWorldComposition(params: { enableComposition: boolean; tileSize?: number; distanceStreaming?: boolean; streamingDistance?: number }): Promise<StandardActionResponse>;
+    editLevelBlueprint(params: { eventType: 'BeginPlay' | 'EndPlay' | 'Tick' | 'Custom'; customEventName?: string; nodes?: Array<{ nodeType: string; position: [number, number]; connections?: string[] }> }): Promise<StandardActionResponse>;
+    createSubLevel(params: { name: string; type: 'Persistent' | 'Streaming' | 'Lighting' | 'Gameplay'; parent?: string }): Promise<StandardActionResponse>;
+    setWorldSettings(params: { gravity?: number; worldScale?: number; gameMode?: string; defaultPawn?: string; killZ?: number }): Promise<StandardActionResponse>;
+    setLevelBounds(params: { min: [number, number, number]; max: [number, number, number] }): Promise<StandardActionResponse>;
+    buildNavMesh(params: { rebuildAll?: boolean; selectedOnly?: boolean }): Promise<StandardActionResponse>;
+    setLevelVisibility(params: { levelName: string; visible: boolean }): Promise<StandardActionResponse>;
+    setWorldOrigin(params: { location: [number, number, number] }): Promise<StandardActionResponse>;
+    createStreamingVolume(params: { levelName: string; position: [number, number, number]; size: [number, number, number]; streamingDistance?: number }): Promise<StandardActionResponse>;
+    setLevelLOD(params: { levelName: string; lodLevel: number; distance: number }): Promise<StandardActionResponse>;
 }
 
 export interface IEditorTools {
     isInPIE(): Promise<boolean>;
     ensureNotInPIE(): Promise<void>;
-    playInEditor(timeoutMs?: number): Promise<any>;
-    stopPlayInEditor(): Promise<any>;
-    pausePlayInEditor(): Promise<any>;
-    pauseInEditor(): Promise<any>;
-    buildLighting(): Promise<any>;
-    setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined): Promise<any>;
-    setCameraSpeed(speed: number): Promise<any>;
-    setFOV(fov: number): Promise<any>;
-    takeScreenshot(filename?: string, resolution?: string): Promise<any>;
-    resumePlayInEditor(): Promise<any>;
-    stepPIEFrame(steps?: number): Promise<any>;
-    startRecording(options?: { filename?: string; frameRate?: number; durationSeconds?: number; metadata?: Record<string, unknown> }): Promise<any>;
-    stopRecording(): Promise<any>;
-    createCameraBookmark(name: string): Promise<any>;
-    jumpToCameraBookmark(name: string): Promise<any>;
-    setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<any>;
-    setViewportResolution(width: number, height: number): Promise<any>;
-    executeConsoleCommand(command: string): Promise<any>;
+    playInEditor(timeoutMs?: number): Promise<StandardActionResponse>;
+    stopPlayInEditor(): Promise<StandardActionResponse>;
+    pausePlayInEditor(): Promise<StandardActionResponse>;
+    pauseInEditor(): Promise<StandardActionResponse>;
+    buildLighting(): Promise<StandardActionResponse>;
+    setViewportCamera(location?: { x: number; y: number; z: number } | [number, number, number] | null | undefined, rotation?: { pitch: number; yaw: number; roll: number } | [number, number, number] | null | undefined): Promise<StandardActionResponse>;
+    setCameraSpeed(speed: number): Promise<StandardActionResponse>;
+    setFOV(fov: number): Promise<StandardActionResponse>;
+    takeScreenshot(filename?: string, resolution?: string): Promise<StandardActionResponse>;
+    resumePlayInEditor(): Promise<StandardActionResponse>;
+    stepPIEFrame(steps?: number): Promise<StandardActionResponse>;
+    startRecording(options?: { filename?: string; frameRate?: number; durationSeconds?: number; metadata?: Record<string, unknown> }): Promise<StandardActionResponse>;
+    stopRecording(): Promise<StandardActionResponse>;
+    createCameraBookmark(name: string): Promise<StandardActionResponse>;
+    jumpToCameraBookmark(name: string): Promise<StandardActionResponse>;
+    setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<StandardActionResponse>;
+    setViewportResolution(width: number, height: number): Promise<StandardActionResponse>;
+    executeConsoleCommand(command: string): Promise<StandardActionResponse>;
 }
 
 export interface IEnvironmentTools {
-    setTimeOfDay(hour: unknown): Promise<any>;
-    setSunIntensity(intensity: unknown): Promise<any>;
-    setSkylightIntensity(intensity: unknown): Promise<any>;
-    exportSnapshot(params: { path?: unknown; filename?: unknown }): Promise<any>;
-    importSnapshot(params: { path?: unknown; filename?: unknown }): Promise<any>;
-    cleanup(params?: { names?: unknown }): Promise<any>;
+    setTimeOfDay(hour: unknown): Promise<StandardActionResponse>;
+    setSunIntensity(intensity: unknown): Promise<StandardActionResponse>;
+    setSkylightIntensity(intensity: unknown): Promise<StandardActionResponse>;
+    exportSnapshot(params: { path?: unknown; filename?: unknown }): Promise<StandardActionResponse>;
+    importSnapshot(params: { path?: unknown; filename?: unknown }): Promise<StandardActionResponse>;
+    cleanup(params?: { names?: unknown }): Promise<StandardActionResponse>;
 }
 
 export interface ILandscapeTools {
-    createLandscape(params: { name: string; location?: [number, number, number]; sizeX?: number; sizeY?: number; quadsPerSection?: number; sectionsPerComponent?: number; componentCount?: number; materialPath?: string; enableWorldPartition?: boolean; runtimeGrid?: string; isSpatiallyLoaded?: boolean; dataLayers?: string[] }): Promise<any>;
-    sculptLandscape(params: { landscapeName: string; tool: string; brushSize?: number; brushFalloff?: number; strength?: number; location?: [number, number, number]; radius?: number }): Promise<any>;
-    paintLandscape(params: { landscapeName: string; layerName: string; position: [number, number, number]; brushSize?: number; strength?: number; targetValue?: number; radius?: number; density?: number }): Promise<any>;
-    createProceduralTerrain(params: { name: string; location?: [number, number, number]; subdivisions?: number; heightFunction?: string; material?: string; settings?: Record<string, unknown> }): Promise<any>;
-    createLandscapeGrassType(params: { name: string; meshPath: string; density?: number; minScale?: number; maxScale?: number; path?: string; staticMesh?: string }): Promise<any>;
-    setLandscapeMaterial(params: { landscapeName: string; materialPath: string }): Promise<any>;
-    modifyHeightmap(params: { landscapeName: string; heightData: number[]; minX: number; minY: number; maxX: number; maxY: number; updateNormals?: boolean }): Promise<any>;
+    createLandscape(params: { name: string; location?: [number, number, number]; sizeX?: number; sizeY?: number; quadsPerSection?: number; sectionsPerComponent?: number; componentCount?: number; materialPath?: string; enableWorldPartition?: boolean; runtimeGrid?: string; isSpatiallyLoaded?: boolean; dataLayers?: string[] }): Promise<StandardActionResponse>;
+    sculptLandscape(params: { landscapeName: string; tool: string; brushSize?: number; brushFalloff?: number; strength?: number; location?: [number, number, number]; radius?: number }): Promise<StandardActionResponse>;
+    paintLandscape(params: { landscapeName: string; layerName: string; position: [number, number, number]; brushSize?: number; strength?: number; targetValue?: number; radius?: number; density?: number }): Promise<StandardActionResponse>;
+    createProceduralTerrain(params: { name: string; location?: [number, number, number]; subdivisions?: number; heightFunction?: string; material?: string; settings?: Record<string, unknown> }): Promise<StandardActionResponse>;
+    createLandscapeGrassType(params: { name: string; meshPath: string; density?: number; minScale?: number; maxScale?: number; path?: string; staticMesh?: string }): Promise<StandardActionResponse>;
+    setLandscapeMaterial(params: { landscapeName: string; materialPath: string }): Promise<StandardActionResponse>;
+    modifyHeightmap(params: { landscapeName: string; heightData: number[]; minX: number; minY: number; maxX: number; maxY: number; updateNormals?: boolean }): Promise<StandardActionResponse>;
 }
 
 export interface IFoliageTools {
-    addFoliageType(params: { name: string; meshPath: string; density?: number; radius?: number; minScale?: number; maxScale?: number; alignToNormal?: boolean; randomYaw?: boolean; groundSlope?: number }): Promise<any>;
-    addFoliage(params: { foliageType: string; locations: Array<{ x: number; y: number; z: number }> }): Promise<any>;
-    paintFoliage(params: { foliageType: string; position: [number, number, number]; brushSize?: number; paintDensity?: number; eraseMode?: boolean }): Promise<any>;
-    createProceduralFoliage(params: { name: string; bounds?: { location: { x: number; y: number; z: number }; size: { x: number; y: number; z: number } }; foliageTypes?: Array<{ meshPath: string; density: number; minScale?: number; maxScale?: number; alignToNormal?: boolean; randomYaw?: boolean }>; volumeName?: string; position?: [number, number, number]; size?: [number, number, number]; seed?: number; tileSize?: number }): Promise<any>;
-    addFoliageInstances(params: { foliageType: string; transforms: Array<{ location: [number, number, number]; rotation?: [number, number, number]; scale?: [number, number, number] }> }): Promise<any>;
-    getFoliageInstances(params: { foliageType?: string }): Promise<any>;
-    removeFoliage(params: { foliageType?: string; removeAll?: boolean }): Promise<any>;
-    createInstancedMesh(params: { name: string; meshPath: string; instances: Array<{ position: [number, number, number]; rotation?: [number, number, number]; scale?: [number, number, number] }>; enableCulling?: boolean; cullDistance?: number }): Promise<any>;
-    setFoliageLOD(params: { foliageType: string; lodDistances?: number[]; screenSize?: number[] }): Promise<any>;
-    setFoliageCollision(params: { foliageType: string; collisionEnabled?: boolean; collisionProfile?: string; generateOverlapEvents?: boolean }): Promise<any>;
-    createGrassSystem(params: { name: string; grassTypes: Array<{ meshPath: string; density: number; minScale?: number; maxScale?: number }>; windStrength?: number; windSpeed?: number }): Promise<any>;
-    removeFoliageInstances(params: { foliageType: string; position: [number, number, number]; radius: number }): Promise<any>;
-    selectFoliageInstances(params: { foliageType: string; position?: [number, number, number]; radius?: number; selectAll?: boolean }): Promise<any>;
-    updateFoliageInstances(params: { foliageType: string; updateTransforms?: boolean; updateMesh?: boolean; newMeshPath?: string }): Promise<any>;
-    createFoliageSpawner(params: { name: string; spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All'; excludeAreas?: Array<[number, number, number, number]> }): Promise<any>;
-    optimizeFoliage(params: { mergeInstances?: boolean; generateClusters?: boolean; clusterSize?: number; reduceDrawCalls?: boolean }): Promise<any>;
+    addFoliageType(params: { name: string; meshPath: string; density?: number; radius?: number; minScale?: number; maxScale?: number; alignToNormal?: boolean; randomYaw?: boolean; groundSlope?: number }): Promise<StandardActionResponse>;
+    addFoliage(params: { foliageType: string; locations: Array<{ x: number; y: number; z: number }> }): Promise<StandardActionResponse>;
+    paintFoliage(params: { foliageType: string; position: [number, number, number]; brushSize?: number; paintDensity?: number; eraseMode?: boolean }): Promise<StandardActionResponse>;
+    createProceduralFoliage(params: { name: string; bounds?: { location: { x: number; y: number; z: number }; size: { x: number; y: number; z: number } }; foliageTypes?: Array<{ meshPath: string; density: number; minScale?: number; maxScale?: number; alignToNormal?: boolean; randomYaw?: boolean }>; volumeName?: string; position?: [number, number, number]; size?: [number, number, number]; seed?: number; tileSize?: number }): Promise<StandardActionResponse>;
+    addFoliageInstances(params: { foliageType: string; transforms: Array<{ location: [number, number, number]; rotation?: [number, number, number]; scale?: [number, number, number] }> }): Promise<StandardActionResponse>;
+    getFoliageInstances(params: { foliageType?: string }): Promise<StandardActionResponse>;
+    removeFoliage(params: { foliageType?: string; removeAll?: boolean }): Promise<StandardActionResponse>;
+    createInstancedMesh(params: { name: string; meshPath: string; instances: Array<{ position: [number, number, number]; rotation?: [number, number, number]; scale?: [number, number, number] }>; enableCulling?: boolean; cullDistance?: number }): Promise<StandardActionResponse>;
+    setFoliageLOD(params: { foliageType: string; lodDistances?: number[]; screenSize?: number[] }): Promise<StandardActionResponse>;
+    setFoliageCollision(params: { foliageType: string; collisionEnabled?: boolean; collisionProfile?: string; generateOverlapEvents?: boolean }): Promise<StandardActionResponse>;
+    createGrassSystem(params: { name: string; grassTypes: Array<{ meshPath: string; density: number; minScale?: number; maxScale?: number }>; windStrength?: number; windSpeed?: number }): Promise<StandardActionResponse>;
+    removeFoliageInstances(params: { foliageType: string; position: [number, number, number]; radius: number }): Promise<StandardActionResponse>;
+    selectFoliageInstances(params: { foliageType: string; position?: [number, number, number]; radius?: number; selectAll?: boolean }): Promise<StandardActionResponse>;
+    updateFoliageInstances(params: { foliageType: string; updateTransforms?: boolean; updateMesh?: boolean; newMeshPath?: string }): Promise<StandardActionResponse>;
+    createFoliageSpawner(params: { name: string; spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All'; excludeAreas?: Array<[number, number, number, number]> }): Promise<StandardActionResponse>;
+    optimizeFoliage(params: { mergeInstances?: boolean; generateClusters?: boolean; clusterSize?: number; reduceDrawCalls?: boolean }): Promise<StandardActionResponse>;
 }
 
 export interface ITools {

package/src/types/tool-types.ts

@@ -9,6 +9,10 @@ export interface BaseToolResponse {
   message?: string;
   error?: string;
   warning?: string;
+  /** Whether this error is retriable (e.g., connection failures) */
+  retriable?: boolean;
+  /** Scope/context for the error (e.g., 'tool-call/manage_asset') */
+  scope?: string;
 }
 
 // Asset Management Types

package/src/unreal-bridge.ts

@@ -5,14 +5,59 @@ import { DEFAULT_AUTOMATION_HOST, DEFAULT_AUTOMATION_PORT } from './constants.js
 import { UnrealCommandQueue } from './utils/unreal-command-queue.js';
 import { CommandValidator } from './utils/command-validator.js';
 
+/** Connection event payload for automation bridge events */
+interface ConnectionEventInfo {
+  host?: string;
+  port?: number;
+  reason?: string;
+  error?: string;
+  [key: string]: unknown;
+}
+
+/** Result object from automation requests */
+interface AutomationResult {
+  value?: unknown;
+  propertyValue?: unknown;
+  message?: string;
+  warnings?: string[];
+  [key: string]: unknown;
+}
+
+/** Subsystems feature flags */
+interface SubsystemFlags {
+  unrealEditor?: boolean;
+  levelEditor?: boolean;
+  editorActor?: boolean;
+  [key: string]: unknown;
+}
+
+/** Engine version result */
+interface EngineVersionResult {
+  version?: string;
+  major?: number;
+  minor?: number;
+  patch?: number;
+  isUE56OrAbove?: boolean;
+  [key: string]: unknown;
+}
+
+/** Console command response */
+interface ConsoleCommandResponse {
+  success?: boolean;
+  message?: string;
+  error?: string;
+  transport?: string;
+  [key: string]: unknown;
+}
+
 export class UnrealBridge {
   private log = new Logger('UnrealBridge');
   private connected = false;
   private automationBridge?: AutomationBridge;
   private automationBridgeListeners?: {
-    connected: (info: any) => void;
-    disconnected: (info: any) => void;
-    handshakeFailed: (info: any) => void;
+    connected: (info: ConnectionEventInfo) => void;
+    disconnected: (info: ConnectionEventInfo) => void;
+    handshakeFailed: (info: ConnectionEventInfo) => void;
   };
 
   // Command queue for throttling
@@ -35,17 +80,17 @@ export class UnrealBridge {
       return;
     }
 
-    const onConnected = (info: any) => {
+    const onConnected = (info: ConnectionEventInfo) => {
       this.connected = true;
       this.log.debug('Automation bridge connected', info);
     };
 
-    const onDisconnected = (info: any) => {
+    const onDisconnected = (info: ConnectionEventInfo) => {
       this.connected = false;
       this.log.debug('Automation bridge disconnected', info);
     };
 
-    const onHandshakeFailed = (info: any) => {
+    const onHandshakeFailed = (info: ConnectionEventInfo) => {
       this.connected = false;
       this.log.warn('Automation bridge handshake failed', info);
     };
@@ -279,13 +324,13 @@ export class UnrealBridge {
       );
 
       const success = response.success !== false;
-      const rawResult =
+      const rawResult: AutomationResult | undefined =
         response.result && typeof response.result === 'object'
           ? { ...(response.result as Record<string, unknown>) }
-          : response.result;
+          : undefined;
       const value =
-        (rawResult as any)?.value ??
-        (rawResult as any)?.propertyValue ??
+        rawResult?.value ??
+        rawResult?.propertyValue ??
         (success ? rawResult : undefined);
 
       if (success) {
@@ -297,8 +342,8 @@ export class UnrealBridge {
           propertyValue: value,
           transport: 'automation_bridge',
           message: response.message,
-          warnings: Array.isArray((rawResult as any)?.warnings)
-            ? (rawResult as any).warnings
+          warnings: Array.isArray(rawResult?.warnings)
+            ? rawResult.warnings
             : undefined,
           raw: rawResult,
           bridge: {
@@ -389,10 +434,10 @@ export class UnrealBridge {
       );
 
       const success = response.success !== false;
-      const rawResult =
+      const rawResult: AutomationResult | undefined =
         response.result && typeof response.result === 'object'
           ? { ...(response.result as Record<string, unknown>) }
-          : response.result;
+          : undefined;
 
       if (success) {
         return {
@@ -401,7 +446,7 @@ export class UnrealBridge {
           propertyName,
           message:
             response.message ||
-            (typeof (rawResult as any)?.message === 'string' ? (rawResult as any).message : undefined),
+            (typeof rawResult?.message === 'string' ? rawResult.message : undefined),
           transport: 'automation_bridge',
           raw: rawResult,
           bridge: {
@@ -469,14 +514,14 @@ export class UnrealBridge {
         throw new Error('Automation bridge not connected');
       }
 
-      const pluginResp: any = await this.automationBridge.sendAutomationRequest(
+      const pluginResp: ConsoleCommandResponse = await this.automationBridge.sendAutomationRequest(
         'console_command',
         { command: cmdTrimmed },
         { timeoutMs: 30000 }
       );
 
       if (pluginResp && pluginResp.success) {
-        return { ...(pluginResp as any), transport: 'automation_bridge' };
+        return { ...pluginResp, transport: 'automation_bridge' };
       }
 
       const errMsg = pluginResp?.message || pluginResp?.error || 'Plugin execution failed';
@@ -553,14 +598,14 @@ export class UnrealBridge {
 
     const bridge = this.getAutomationBridge();
     try {
-      const resp: any = await bridge.sendAutomationRequest(
+      const resp = await bridge.sendAutomationRequest(
         'system_control',
         { action: 'get_engine_version' },
         { timeoutMs: 15000 }
       );
-      const raw = resp && typeof resp.result === 'object'
-        ? (resp.result as any)
-        : (resp?.result ?? resp ?? {});
+      const raw: EngineVersionResult = resp && typeof resp.result === 'object'
+        ? (resp.result as Record<string, unknown>)
+        : (resp?.result as Record<string, unknown>) ?? resp ?? {};
       const version = typeof raw.version === 'string' ? raw.version : 'unknown';
       const major = typeof raw.major === 'number' ? raw.major : 0;
       const minor = typeof raw.minor === 'number' ? raw.minor : 0;
@@ -596,16 +641,16 @@ export class UnrealBridge {
 
     const bridge = this.getAutomationBridge();
     try {
-      const resp: any = await bridge.sendAutomationRequest(
+      const resp = await bridge.sendAutomationRequest(
         'system_control',
         { action: 'get_feature_flags' },
         { timeoutMs: 15000 }
       );
       const raw = resp && typeof resp.result === 'object'
-        ? (resp.result as any)
-        : (resp?.result ?? resp ?? {});
-      const subs = raw && typeof raw.subsystems === 'object'
-        ? (raw.subsystems as any)
+        ? (resp.result as Record<string, unknown>)
+        : (resp?.result as Record<string, unknown>) ?? resp ?? {};
+      const subs: SubsystemFlags = raw && typeof raw.subsystems === 'object'
+        ? (raw.subsystems as SubsystemFlags)
         : {};
       return {
         subsystems: {

package/src/utils/command-validator.ts

@@ -1,27 +1,58 @@
+/**
+ * Validates console commands before execution to prevent dangerous operations.
+ * Blocks crash-inducing commands, shell injection, and Python execution.
+ */
 export class CommandValidator {
+    /**
+     * Commands that can crash the engine or cause severe instability.
+     * These are blocked unconditionally.
+     */
     private static readonly DANGEROUS_COMMANDS = [
-        'quit', 'exit', 'delete', 'destroy', 'kill', 'crash',
+        // Engine termination commands
+        'quit', 'exit', 'kill', 'crash',
+        // Crash-inducing commands
+        'r.gpucrash', 'r.crash', 'debug crash', 'forcecrash', 'debug break',
+        'assert false', 'check(false)',
+        // View buffer commands that can crash on some hardware
         'viewmode visualizebuffer basecolor',
         'viewmode visualizebuffer worldnormal',
-        'r.gpucrash',
-        'buildpaths', // Can cause access violation if nav system not initialized
-        'rebuildnavigation' // Can also crash without proper nav setup
+        // Heavy operations that can cause access violations if systems not initialized
+        'buildpaths', 'rebuildnavigation',
+        // Heavy debug commands that can stall or crash
+        'obj garbage', 'obj list', 'memreport',
+        // Potentially destructive without proper setup
+        'delete', 'destroy'
     ];
 
+    /**
+     * Tokens that indicate shell injection or external system access attempts.
+     * Any command containing these is blocked.
+     */
     private static readonly FORBIDDEN_TOKENS = [
+        // Shell commands (Windows/Unix)
         'rm ', 'rm-', 'del ', 'format ', 'shutdown', 'reboot',
         'rmdir', 'mklink', 'copy ', 'move ', 'start "', 'system(',
+        // Python injection attempts
         'import os', 'import subprocess', 'subprocess.', 'os.system',
         'exec(', 'eval(', '__import__', 'import sys', 'import importlib',
-        'with open', 'open('
+        'with open', 'open(', 'write(', 'read('
     ];
 
+    /**
+     * Patterns that indicate obviously invalid commands.
+     * Used to warn about likely typos or invalid input.
+     */
     private static readonly INVALID_PATTERNS = [
         /^\d+$/,  // Just numbers
         /^invalid_command/i,
         /^this_is_not_a_valid/i,
     ];
 
+    /**
+     * Validates a console command for safety before execution.
+     * @param command - The console command string to validate
+     * @throws Error if the command is dangerous, contains forbidden tokens, or is invalid
+     */
     static validate(command: string): void {
         if (!command || typeof command !== 'string') {
             throw new Error('Invalid command: must be a non-empty string');
@@ -55,11 +86,22 @@ export class CommandValidator {
         }
     }
 
+    /**
+     * Check if a command looks like an obviously invalid or mistyped command.
+     * @param command - The command to check
+     * @returns true if the command matches known invalid patterns
+     */
     static isLikelyInvalid(command: string): boolean {
         const cmdTrimmed = command.trim();
         return this.INVALID_PATTERNS.some(pattern => pattern.test(cmdTrimmed));
     }
 
+    /**
+     * Get the priority level of a command for throttling purposes.
+     * Lower numbers indicate heavier operations that need more throttling.
+     * @param command - The command to evaluate
+     * @returns Priority level (1=heavy, 5=medium, 7=default, 8-9=light)
+     */
     static getPriority(command: string): number {
         if (command.includes('BuildLighting') || command.includes('BuildPaths')) {
             return 1; // Heavy operation