@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-effect.test.mjs

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_effect Tool Integration Tests
- * Covers all 58 actions with real optional-parameter coverage.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/ManageEffect_${ts}`;
-const TEST_ACTOR = `TestActor_${ts}`;
-const EFFECT_ACTOR = `TestEffectActor_${ts}`;
-const SPAWNED_EFFECT_ACTOR = `TestSpawnedEffectActor_${ts}`;
-const SYSTEM_NAME = `Testniagara_system_${ts}`;
-const EMITTER_ASSET_NAME = `Testniagara_emitter_${ts}`;
-const SYSTEM_PATH = `${TEST_FOLDER}/${SYSTEM_NAME}.${SYSTEM_NAME}`;
-const EMITTER_PATH = `${TEST_FOLDER}/${EMITTER_ASSET_NAME}.${EMITTER_ASSET_NAME}`;
-const DEFAULT_EMITTER = '${captured:niagaraEmitterName}';
-const USER_PARAM = `MCPUserParam_${ts}`;
-const BOUND_PARAM = `MCPBoundParam_${ts}`;
-const EVENT_NAME = `MCPEvent_${ts}`;
-const STAGE_NAME = `MCPStage_${ts}`;
-const BASIC_MATERIAL = '/Engine/BasicShapes/BasicShapeMaterial.BasicShapeMaterial';
-const CUBE_MESH = '/Engine/BasicShapes/Cube.Cube';
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-  { scenario: 'Setup: spawn test actor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: TEST_ACTOR, location: { x: 0, y: 0, z: 100 } }, expected: 'success' },
-
-  // === CREATE ===
-  { scenario: 'CREATE: create_niagara_system', toolName: 'manage_effect', arguments: { action: 'create_niagara_system', name: SYSTEM_NAME, path: TEST_FOLDER, savePath: TEST_FOLDER }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_niagara_emitter', toolName: 'manage_effect', arguments: { action: 'create_niagara_emitter', name: EMITTER_ASSET_NAME, path: TEST_FOLDER, savePath: TEST_FOLDER, emitterName: EMITTER_ASSET_NAME }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_emitter_to_system', toolName: 'manage_effect', arguments: { action: 'add_emitter_to_system', systemPath: SYSTEM_PATH, emitterPath: EMITTER_PATH, save: false }, expected: 'success|already exists', captureResult: { key: 'niagaraEmitterName', fromField: 'result.emitterName' } },
-
-  // === ACTION ===
-  { scenario: 'ACTION: particle with preset and debug options', toolName: 'manage_effect', arguments: { action: 'particle', preset: 'Default', location: { x: 0, y: 0, z: 100 }, shapeType: 'sphere', radius: 30, color: [255, 64, 32, 255], duration: 0.1, timeoutMs: 30000 }, expected: 'success', assertions: [{ path: 'structuredContent.result.shapeType', equals: 'sphere', label: 'particle preset path drew requested debug shape' }] },
-  { scenario: 'ACTION: niagara with actor attachment', toolName: 'manage_effect', arguments: { action: 'niagara', systemPath: SYSTEM_PATH, actorName: EFFECT_ACTOR, attachToActor: TEST_ACTOR, location: { x: 0, y: 0, z: 120 } }, expected: 'success' },
-  { scenario: 'ACTION: debug_shape alias shape', toolName: 'manage_effect', arguments: { action: 'debug_shape', shape: 'box', location: { x: 20, y: 0, z: 100 }, radius: 25, color: [0, 128, 255, 255], duration: 0.1 }, expected: 'success', assertions: [{ path: 'structuredContent.result.shapeType', equals: 'box', label: 'shape alias reached native shapeType' }] },
-  { scenario: 'CREATE: spawn_niagara with system alias', toolName: 'manage_effect', arguments: { action: 'spawn_niagara', system: SYSTEM_PATH, actorName: SPAWNED_EFFECT_ACTOR, location: { x: 40, y: 0, z: 120 } }, expected: 'success' },
-  { scenario: 'CREATE: create_dynamic_light with light properties', toolName: 'manage_effect', arguments: { action: 'create_dynamic_light', name: `Testdynamic_light_${ts}`, location: { x: 80, y: 0, z: 250 }, lightType: 'Point', intensity: 750, color: [1, 0.8, 0.4, 1] }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_volumetric_fog with fog properties', toolName: 'manage_effect', arguments: { action: 'create_volumetric_fog', name: `Testvolumetric_fog_${ts}`, density: 0.02, scattering: 0.6, extinction: 0.4 }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_particle_trail', toolName: 'manage_effect', arguments: { action: 'create_particle_trail', name: `Testparticle_trail_${ts}`, systemPath: SYSTEM_PATH, location: { x: 120, y: 0, z: 120 } }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_environment_effect', toolName: 'manage_effect', arguments: { action: 'create_environment_effect', name: `Testenvironment_effect_${ts}`, systemPath: SYSTEM_PATH, location: { x: 160, y: 0, z: 120 } }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_impact_effect', toolName: 'manage_effect', arguments: { action: 'create_impact_effect', name: `Testimpact_effect_${ts}`, systemPath: SYSTEM_PATH, location: { x: 200, y: 0, z: 120 } }, expected: 'success|already exists' },
-  { scenario: 'CREATE: create_niagara_ribbon', toolName: 'manage_effect', arguments: { action: 'create_niagara_ribbon', name: `Testniagara_ribbon_${ts}`, systemPath: SYSTEM_PATH, location: { x: 240, y: 0, z: 120 } }, expected: 'success|already exists' },
-
-  // === PLAYBACK ===
-  { scenario: 'ACTION: activate', toolName: 'manage_effect', arguments: { action: 'activate', actorName: EFFECT_ACTOR, reset: false }, expected: 'success' },
-  { scenario: 'ACTION: activate_effect by systemName', toolName: 'manage_effect', arguments: { action: 'activate_effect', systemName: EFFECT_ACTOR }, expected: 'success' },
-  { scenario: 'ACTION: deactivate', toolName: 'manage_effect', arguments: { action: 'deactivate', actorName: EFFECT_ACTOR }, expected: 'success' },
-  { scenario: 'ACTION: reset', toolName: 'manage_effect', arguments: { action: 'reset', actorName: EFFECT_ACTOR, reset: true }, expected: 'success' },
-  { scenario: 'PLAYBACK: advance_simulation', toolName: 'manage_effect', arguments: { action: 'advance_simulation', actorName: EFFECT_ACTOR, deltaTime: 0.016, steps: 2 }, expected: 'success', assertions: [{ path: 'structuredContent.result.steps', equals: 2, label: 'native simulation step count applied' }] },
-
-  // === GRAPH ===
-  { scenario: 'ADD: add_niagara_module', toolName: 'manage_effect', arguments: { action: 'add_niagara_module', assetPath: SYSTEM_PATH, systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, modulePath: '/Niagara/Modules/Emitter/EmitterState.EmitterState', scriptType: 'Update', name: 'Testniagara_module' }, expected: 'success|already exists', captureResult: { key: 'niagaraModuleNodeId', fromField: 'result.nodeId' } },
-  { scenario: 'CONNECT: connect_niagara_pins', toolName: 'manage_effect', arguments: { action: 'connect_niagara_pins', assetPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, scriptType: 'Update', autoConnect: true }, expected: 'success', assertions: [{ path: 'structuredContent.result.connected', equals: true, label: 'real Niagara graph pins connected' }, { path: 'structuredContent.result.autoConnected', equals: true, label: 'native auto-connect path executed' }] },
-  { scenario: 'DELETE: remove_niagara_node', toolName: 'manage_effect', arguments: { action: 'remove_niagara_node', assetPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, scriptType: 'Update', nodeId: '${captured:niagaraModuleNodeId}' }, expected: 'success', assertions: [{ path: 'structuredContent.result.removed', equals: true, label: 'captured Niagara graph node removed' }] },
-
-  // === RUNTIME PARAMETER ===
-  { scenario: 'CONFIG: set_niagara_parameter', toolName: 'manage_effect', arguments: { action: 'set_niagara_parameter', actorName: EFFECT_ACTOR, parameterName: 'MCPParameter', parameterType: 'Float', value: 1.25 }, expected: 'success', assertions: [{ path: 'structuredContent.result.applied', equals: true, label: 'runtime Niagara parameter value applied' }] },
-  { scenario: 'DELETE: clear_debug_shapes', toolName: 'manage_effect', arguments: { action: 'clear_debug_shapes' }, expected: 'success|not found' },
-  { scenario: 'ACTION: cleanup with explicit filter', toolName: 'manage_effect', arguments: { action: 'cleanup', filter: `NoSuchManageEffectActor_${ts}` }, expected: 'success|not found' },
-  { scenario: 'INFO: list_debug_shapes', toolName: 'manage_effect', arguments: { action: 'list_debug_shapes' }, expected: 'success' },
-
-  // === NIAGARA AUTHORING ===
-  { scenario: 'CONFIG: set_emitter_properties', toolName: 'manage_effect', arguments: { action: 'set_emitter_properties', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, emitterProperties: { enabled: true }, save: false }, expected: 'success' },
-  { scenario: 'ADD: add_spawn_rate_module', toolName: 'manage_effect', arguments: { action: 'add_spawn_rate_module', systemPath: SYSTEM_PATH, emitter: DEFAULT_EMITTER, spawnRate: 123, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.spawnRate', equals: 123, label: 'spawnRate applied to native module' }] },
-  { scenario: 'ADD: add_spawn_burst_module', toolName: 'manage_effect', arguments: { action: 'add_spawn_burst_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, burstCount: 7, burstTime: 0.25, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.burstCount', equals: 7, label: 'burstCount reached native module' }, { path: 'structuredContent.result.burstTime', equals: 0.25, label: 'burstTime reached native module' }] },
-  { scenario: 'ADD: add_spawn_per_unit_module', toolName: 'manage_effect', arguments: { action: 'add_spawn_per_unit_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, spawnPerUnit: 2.5, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.spawnPerUnit', equals: 2.5, label: 'spawnPerUnit reached native module' }] },
-  { scenario: 'ADD: add_initialize_particle_module', toolName: 'manage_effect', arguments: { action: 'add_initialize_particle_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, lifetime: 3, mass: 1.5, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.lifetime', equals: 3, label: 'lifetime reached native module' }, { path: 'structuredContent.result.mass', equals: 1.5, label: 'mass reached native module' }] },
-  { scenario: 'ADD: add_particle_state_module', toolName: 'manage_effect', arguments: { action: 'add_particle_state_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, save: false }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_force_module', toolName: 'manage_effect', arguments: { action: 'add_force_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, forceType: 'Gravity', forceStrength: 456, forceVector: { x: 0, y: 0, z: -456 }, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.forceType', equals: 'Gravity', label: 'forceType reached native module' }, { path: 'structuredContent.result.forceStrength', equals: 456, label: 'forceStrength reached native module' }] },
-  { scenario: 'ADD: add_velocity_module', toolName: 'manage_effect', arguments: { action: 'add_velocity_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, velocity: { x: 1, y: 2, z: 3 }, velocityMode: 'Linear', save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.velocityMode', equals: 'Linear', label: 'velocityMode reached native module' }] },
-  { scenario: 'ADD: add_acceleration_module', toolName: 'manage_effect', arguments: { action: 'add_acceleration_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, acceleration: { x: 0, y: 0, z: -980 }, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.parameterAdded', equals: true, label: 'acceleration parameter added to Niagara system' }] },
-  { scenario: 'ADD: add_size_module', toolName: 'manage_effect', arguments: { action: 'add_size_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, sizeMode: 'Uniform', uniformSize: 12, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.parameterAdded', equals: true, label: 'size parameter added to Niagara system' }, { path: 'structuredContent.result.uniformSize', equals: 12, label: 'uniformSize reached native module' }] },
-  { scenario: 'ADD: add_color_module', toolName: 'manage_effect', arguments: { action: 'add_color_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, color: { r: 1, g: 0.5, b: 0.25, a: 1 }, colorMode: 'Direct', save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.parameterAdded', equals: true, label: 'color parameter added to Niagara system' }, { path: 'structuredContent.result.colorMode', equals: 'Direct', label: 'colorMode reached native module' }] },
-  { scenario: 'ADD: add_sprite_renderer_module', toolName: 'manage_effect', arguments: { action: 'add_sprite_renderer_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, materialPath: BASIC_MATERIAL, alignment: 'Unaligned', facingMode: 'FaceCamera', save: false }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_mesh_renderer_module', toolName: 'manage_effect', arguments: { action: 'add_mesh_renderer_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, meshPath: CUBE_MESH, save: false }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_ribbon_renderer_module', toolName: 'manage_effect', arguments: { action: 'add_ribbon_renderer_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, materialPath: BASIC_MATERIAL, save: false }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_light_renderer_module', toolName: 'manage_effect', arguments: { action: 'add_light_renderer_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, lightRadius: 200, save: false }, expected: 'success|already exists' },
-  { scenario: 'ADD: add_collision_module', toolName: 'manage_effect', arguments: { action: 'add_collision_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, collisionMode: 'SceneDepth', restitution: 0.4, friction: 0.1, dieOnCollision: true, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.moduleAdded', equals: true, label: 'collision module added to Niagara stack' }, { path: 'structuredContent.result.parameterAdded', equals: true, label: 'collision parameters added to Niagara system' }, { path: 'structuredContent.result.dieOnCollision', equals: true, label: 'dieOnCollision reached native module' }] },
-  { scenario: 'ADD: add_kill_particles_module', toolName: 'manage_effect', arguments: { action: 'add_kill_particles_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, killCondition: 'Age', save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.moduleAdded', equals: true, label: 'kill particles module added to Niagara stack' }, { path: 'structuredContent.result.killCondition', equals: 'Age', label: 'killCondition reached native module' }] },
-  { scenario: 'ADD: add_camera_offset_module', toolName: 'manage_effect', arguments: { action: 'add_camera_offset_module', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, cameraOffset: 4, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.moduleAdded', equals: true, label: 'camera offset module added to Niagara stack' }, { path: 'structuredContent.result.parameterAdded', equals: true, label: 'camera offset parameter added to Niagara system' }, { path: 'structuredContent.result.cameraOffset', equals: 4, label: 'cameraOffset reached native module' }] },
-  { scenario: 'ADD: add_user_parameter', toolName: 'manage_effect', arguments: { action: 'add_user_parameter', systemPath: SYSTEM_PATH, parameterName: USER_PARAM, parameterType: 'Float', save: false }, expected: 'success|already exists' },
-  { scenario: 'CONFIG: set_parameter_value', toolName: 'manage_effect', arguments: { action: 'set_parameter_value', systemPath: SYSTEM_PATH, parameterName: USER_PARAM, parameterValue: 2.5, save: false }, expected: 'success' },
-  { scenario: 'CONNECT: bind_parameter_to_source applies real assignment binding', toolName: 'manage_effect', arguments: { action: 'bind_parameter_to_source', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: BOUND_PARAM, parameterType: 'Float', sourceBinding: 'Emitter.Age', save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.bindingApplied', equals: true, label: 'real Niagara parameter binding applied' }, { path: 'structuredContent.result.assignmentModuleAdded', equals: true, label: 'assignment module added to Niagara stack' }, { path: 'structuredContent.result.niagaraDefaultSource', equals: 'Emitter Age', label: 'Emitter.Age normalized to Niagara engine constant' }] },
-  { scenario: 'ADD: add_skeletal_mesh_data_interface', toolName: 'manage_effect', arguments: { action: 'add_skeletal_mesh_data_interface', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: `MCPSkelDI_${ts}`, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.dataInterfaceAdded', equals: true, label: 'skeletal mesh data interface added to exposed parameters' }] },
-  { scenario: 'ADD: add_static_mesh_data_interface', toolName: 'manage_effect', arguments: { action: 'add_static_mesh_data_interface', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: `MCPStaticDI_${ts}`, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.dataInterfaceAdded', equals: true, label: 'static mesh data interface added to exposed parameters' }] },
-  { scenario: 'ADD: add_spline_data_interface', toolName: 'manage_effect', arguments: { action: 'add_spline_data_interface', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: `MCPSplineDI_${ts}`, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.dataInterfaceAdded', equals: true, label: 'spline data interface added to exposed parameters' }] },
-  { scenario: 'ADD: add_audio_spectrum_data_interface', toolName: 'manage_effect', arguments: { action: 'add_audio_spectrum_data_interface', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: `MCPAudioDI_${ts}`, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.dataInterfaceAdded', equals: true, label: 'audio spectrum data interface added to exposed parameters' }] },
-  { scenario: 'ADD: add_collision_query_data_interface', toolName: 'manage_effect', arguments: { action: 'add_collision_query_data_interface', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, parameterName: `MCPCollisionDI_${ts}`, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.dataInterfaceAdded', equals: true, label: 'collision query data interface added to exposed parameters' }] },
-  { scenario: 'ADD: add_event_generator', toolName: 'manage_effect', arguments: { action: 'add_event_generator', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, eventName: EVENT_NAME, eventType: 'Location', save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.eventGeneratorAdded', equals: true, label: 'event generator mutation recorded' }] },
-  { scenario: 'ADD: add_event_receiver', toolName: 'manage_effect', arguments: { action: 'add_event_receiver', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, eventName: EVENT_NAME, spawnOnEvent: true, eventSpawnCount: 2, save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.eventHandlerAdded', equals: true, label: 'event handler added to Niagara emitter' }, { path: 'structuredContent.result.eventGraphCreated', equals: true, label: 'event handler output graph created' }, { path: 'structuredContent.result.spawnOnEvent', equals: true, label: 'spawnOnEvent reached native event receiver' }] },
-  { scenario: 'CONFIG: configure_event_payload', toolName: 'manage_effect', arguments: { action: 'configure_event_payload', systemPath: SYSTEM_PATH, eventName: EVENT_NAME, eventPayload: [{ name: 'PayloadFloat', type: 'Float' }], save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.eventPayloadConfigured', equals: true, label: 'event payload parameters added' }, { path: 'structuredContent.result.payloadAttributeCount', equals: 1, label: 'eventPayload attributes reached native payload configuration' }] },
-  { scenario: 'TOGGLE: enable_gpu_simulation', toolName: 'manage_effect', arguments: { action: 'enable_gpu_simulation', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, fixedBoundsEnabled: true, deterministicEnabled: true, save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.fixedBoundsEnabled', equals: true, label: 'fixedBoundsEnabled reached native GPU configuration' }, { path: 'structuredContent.result.deterministicEnabled', equals: true, label: 'deterministicEnabled reached native GPU configuration' }] },
-  { scenario: 'ADD: add_simulation_stage', toolName: 'manage_effect', arguments: { action: 'add_simulation_stage', systemPath: SYSTEM_PATH, emitterName: DEFAULT_EMITTER, stageName: STAGE_NAME, stageIterationSource: 'Particles', save: false }, expected: 'success|already exists', assertions: [{ path: 'structuredContent.result.simulationStageAdded', equals: true, label: 'simulation stage added to Niagara emitter' }, { path: 'structuredContent.result.simulationStageGraphCreated', equals: true, label: 'simulation stage output graph created' }, { path: 'structuredContent.result.iterationSource', equals: 'Particles', label: 'stageIterationSource reached native stage configuration' }] },
-  { scenario: 'INFO: get_niagara_info', toolName: 'manage_effect', arguments: { action: 'get_niagara_info', assetPath: SYSTEM_PATH }, expected: 'success' },
-  { scenario: 'ACTION: validate_niagara_system', toolName: 'manage_effect', arguments: { action: 'validate_niagara_system', system: SYSTEM_PATH }, expected: 'success' },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete spawned Niagara actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: SPAWNED_EFFECT_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete primary Niagara actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: EFFECT_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: TEST_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-];
-
-runToolTests('manage-effect', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-gas.test.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_gas Tool Integration Tests
- * Covers all 27 actions with real captured asset paths.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayAssets/ManageGAS_${ts}`;
-const blueprintName = `BP_TestGAS_${ts}`;
-const attributeSetName = `BP_TestAttributes_${ts}`;
-const abilityName = `BP_TestAbility_${ts}`;
-const effectName = `BP_TestEffect_${ts}`;
-const cueName = `BP_TestCue_${ts}`;
-const attributeName = `Health_${ts}`;
-const abilityTag = `Ability.Test.${ts}`;
-const effectTag = `Effect.Test.${ts}`;
-const cueTag = `GameplayCue.Test.${ts}`;
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success' },
-  {
-    scenario: 'Setup: create test blueprint',
-    toolName: 'manage_blueprint',
-    arguments: { action: 'create', name: blueprintName, path: TEST_FOLDER, parentClass: 'Actor' },
-    expected: 'success',
-    captureResult: { key: 'blueprintPath', fromField: 'result.assetPath' }
-  },
-
-  // === COMPONENTS / ATTRIBUTES ===
-  { scenario: 'ADD: add_ability_system_component', toolName: 'manage_gas', arguments: { action: 'add_ability_system_component', blueprintPath: '${captured:blueprintPath}', componentName: 'AbilitySystemComponent' }, expected: 'success' },
-  { scenario: 'CONFIG: configure_asc', toolName: 'manage_gas', arguments: { action: 'configure_asc', blueprintPath: '${captured:blueprintPath}', componentName: 'AbilitySystemComponent', replicationMode: 'Mixed' }, expected: 'success' },
-  {
-    scenario: 'CREATE: create_attribute_set',
-    toolName: 'manage_gas',
-    arguments: { action: 'create_attribute_set', name: attributeSetName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'attributeSetPath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'ADD: add_attribute', toolName: 'manage_gas', arguments: { action: 'add_attribute', attributeSetPath: '${captured:attributeSetPath}', attributeName, attributeType: 'Custom', defaultValue: 100 }, expected: 'success' },
-  { scenario: 'CONFIG: set_attribute_base_value', toolName: 'manage_gas', arguments: { action: 'set_attribute_base_value', attributeSetPath: '${captured:attributeSetPath}', attributeName, baseValue: 125 }, expected: 'success' },
-  { scenario: 'CONFIG: set_attribute_clamping', toolName: 'manage_gas', arguments: { action: 'set_attribute_clamping', attributeSetPath: '${captured:attributeSetPath}', attributeName, minValue: 0, maxValue: 200, clampMode: 'MinMax' }, expected: 'success' },
-
-  // === GAMEPLAY ABILITY ===
-  {
-    scenario: 'CREATE: create_gameplay_ability',
-    toolName: 'manage_gas',
-    arguments: { action: 'create_gameplay_ability', name: abilityName, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'abilityPath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'CONFIG: set_ability_tags', toolName: 'manage_gas', arguments: { action: 'set_ability_tags', abilityPath: '${captured:abilityPath}', abilityTags: [abilityTag], cancelAbilitiesWithTag: [`Ability.Cancel.${ts}`], blockAbilitiesWithTag: [`Ability.Block.${ts}`], activationRequiredTags: [`Ability.Required.${ts}`], activationBlockedTags: [`Ability.Blocked.${ts}`] }, expected: 'success' },
-  { scenario: 'CONFIG: set_ability_targeting', toolName: 'manage_gas', arguments: { action: 'set_ability_targeting', abilityPath: '${captured:abilityPath}', targetingMode: 'AOE', targetRange: 1200, aoeRadius: 350 }, expected: 'success' },
-  { scenario: 'ADD: add_ability_task', toolName: 'manage_gas', arguments: { action: 'add_ability_task', abilityPath: '${captured:abilityPath}', taskType: 'WaitDelay' }, expected: 'success' },
-  { scenario: 'CONFIG: set_activation_policy', toolName: 'manage_gas', arguments: { action: 'set_activation_policy', abilityPath: '${captured:abilityPath}', activationPolicy: 'OnInputPressed' }, expected: 'success' },
-  { scenario: 'CONFIG: set_instancing_policy', toolName: 'manage_gas', arguments: { action: 'set_instancing_policy', abilityPath: '${captured:abilityPath}', instancingPolicy: 'InstancedPerExecution' }, expected: 'success' },
-
-  // === GAMEPLAY EFFECT ===
-  {
-    scenario: 'CREATE: create_gameplay_effect',
-    toolName: 'manage_gas',
-    arguments: { action: 'create_gameplay_effect', name: effectName, path: TEST_FOLDER, durationType: 'Instant' },
-    expected: 'success',
-    captureResult: { key: 'effectPath', fromField: 'result.assetPath' },
-    assertions: [{ path: 'structuredContent.result.durationType', equals: 'instant', label: 'effect duration type preserved at creation' }]
-  },
-  { scenario: 'CONFIG: set_ability_costs', toolName: 'manage_gas', arguments: { action: 'set_ability_costs', abilityPath: '${captured:abilityPath}', costEffectPath: '${captured:effectPath}' }, expected: 'success', assertions: [{ path: 'structuredContent.result.costEffectAssigned', equals: true, label: 'cost effect class assigned' }] },
-  { scenario: 'CONFIG: set_ability_cooldown', toolName: 'manage_gas', arguments: { action: 'set_ability_cooldown', abilityPath: '${captured:abilityPath}', cooldownEffectPath: '${captured:effectPath}' }, expected: 'success', assertions: [{ path: 'structuredContent.result.cooldownEffectAssigned', equals: true, label: 'cooldown effect class assigned' }] },
-  { scenario: 'CONFIG: set_effect_duration', toolName: 'manage_gas', arguments: { action: 'set_effect_duration', effectPath: '${captured:effectPath}', durationType: 'HasDuration', duration: 5, period: 1 }, expected: 'success' },
-  { scenario: 'ADD: add_effect_modifier', toolName: 'manage_gas', arguments: { action: 'add_effect_modifier', effectPath: '${captured:effectPath}', attributeName, modifierOperation: 'Add', modifierMagnitude: 25, targetAttribute: attributeName }, expected: 'success' },
-  { scenario: 'CONFIG: set_modifier_magnitude', toolName: 'manage_gas', arguments: { action: 'set_modifier_magnitude', effectPath: '${captured:effectPath}', modifierIndex: 0, magnitudeCalculationType: 'SetByCaller', modifierMagnitude: 50, setByCallerTag: `Data.Damage.${ts}` }, expected: 'success' },
-  { scenario: 'ADD: add_effect_execution_calculation', toolName: 'manage_gas', arguments: { action: 'add_effect_execution_calculation', effectPath: '${captured:effectPath}', calculationClass: '/Script/GameplayAbilities.GameplayEffectExecutionCalculation' }, expected: 'success' },
-  { scenario: 'ADD: add_effect_cue', toolName: 'manage_gas', arguments: { action: 'add_effect_cue', effectPath: '${captured:effectPath}', cueTag }, expected: 'success' },
-  { scenario: 'CONFIG: set_effect_stacking', toolName: 'manage_gas', arguments: { action: 'set_effect_stacking', effectPath: '${captured:effectPath}', stackingType: 'AggregateByTarget', stackLimitCount: 3, stackDurationRefreshPolicy: 'RefreshOnSuccessfulApplication', stackPeriodResetPolicy: 'ResetOnSuccessfulApplication', stackExpirationPolicy: 'RemoveSingleStackAndRefreshDuration' }, expected: 'success' },
-  { scenario: 'CONFIG: set_effect_tags', toolName: 'manage_gas', arguments: { action: 'set_effect_tags', effectPath: '${captured:effectPath}', grantedTags: [effectTag], applicationRequiredTags: [`Effect.Required.${ts}`], removalTags: [`Effect.Remove.${ts}`], immunityTags: [`Effect.Immune.${ts}`] }, expected: 'success' },
-
-  // === GAMEPLAY CUES / UTILITY ===
-  {
-    scenario: 'CREATE: create_gameplay_cue_notify',
-    toolName: 'manage_gas',
-    arguments: { action: 'create_gameplay_cue_notify', name: cueName, path: TEST_FOLDER, cueType: 'Static', cueTag },
-    expected: 'success',
-    captureResult: { key: 'cuePath', fromField: 'result.assetPath' }
-  },
-  { scenario: 'CONFIG: configure_cue_trigger', toolName: 'manage_gas', arguments: { action: 'configure_cue_trigger', cuePath: '${captured:cuePath}', triggerType: 'Executed' }, expected: 'success' },
-  { scenario: 'CONFIG: set_cue_effects', toolName: 'manage_gas', arguments: { action: 'set_cue_effects', cuePath: '${captured:cuePath}', particleSystemPath: '/Engine/EngineResources/DefaultTexture', soundPath: '/Engine/EngineSounds/Notifications/CompileSuccess_Cue', cameraShakePath: '/Script/Engine.CameraShakeBase', decalPath: '/Engine/EngineMaterials/DefaultMaterial.DefaultMaterial' }, expected: 'success', assertions: [{ path: 'structuredContent.result.decalPath', equals: '/Engine/EngineMaterials/DefaultMaterial.DefaultMaterial', label: 'decal path applied' }, { path: 'structuredContent.result.variableCount', equals: 12, label: 'decal variables added' }] },
-  { scenario: 'ADD: add_tag_to_asset', toolName: 'manage_gas', arguments: { action: 'add_tag_to_asset', assetPath: '${captured:abilityPath}', tagName: abilityTag }, expected: 'success' },
-  { scenario: 'INFO: get_gas_info', toolName: 'manage_gas', arguments: { action: 'get_gas_info', assetPath: '${captured:abilityPath}' }, expected: 'success' },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' }
-];
-
-runToolTests('manage-gas', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-interaction.test.mjs

@@ -1,122 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_interaction Tool Integration Tests
- * Covers all 22 actions with real Blueprint paths and spawned actor state.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayInteraction_${ts}`;
-const TEST_FOLDER_ALIAS = TEST_FOLDER.slice(1);
-const TEST_ACTOR = `TestInteractionActor_${ts}`;
-const BLUEPRINT_NAME = `BP_MCP_InteractionActor_${ts}`;
-const INTERFACE_NAME = `BPI_MCP_Interactable_${ts}`;
-const DOOR_NAME = `BP_MCP_Door_${ts}`;
-const SWITCH_NAME = `BP_MCP_Switch_${ts}`;
-const CHEST_NAME = `BP_MCP_Chest_${ts}`;
-const LEVER_NAME = `BP_MCP_Lever_${ts}`;
-const TRIGGER_NAME = `BP_MCP_Trigger_${ts}`;
-
-const EXPECTED_BLUEPRINT_PATH = `${TEST_FOLDER}/${BLUEPRINT_NAME}`;
-const EXPECTED_INTERFACE_PATH = `${TEST_FOLDER}/${INTERFACE_NAME}.${INTERFACE_NAME}`;
-const EXPECTED_DOOR_PATH = `${TEST_FOLDER}/${DOOR_NAME}`;
-const EXPECTED_SWITCH_PATH = `${TEST_FOLDER}/${SWITCH_NAME}.${SWITCH_NAME}`;
-const EXPECTED_CHEST_PATH = `${TEST_FOLDER}/${CHEST_NAME}.${CHEST_NAME}`;
-const EXPECTED_LEVER_PATH = `${TEST_FOLDER}/${LEVER_NAME}.${LEVER_NAME}`;
-const EXPECTED_TRIGGER_PATH = `${TEST_FOLDER}/${TRIGGER_NAME}.${TRIGGER_NAME}`;
-const TEST_WIDGET_CLASS = '/Script/UMG.UserWidget';
-const TEST_LOOT_TABLE_PATH = `${TEST_FOLDER}/LT_MCP_Test`;
-
-const blueprintPath = '${captured:blueprintPath}';
-const doorPath = '${captured:doorPath}';
-const switchPath = '${captured:switchPath}';
-const chestPath = '${captured:chestPath}';
-const triggerPath = '${captured:triggerPath}';
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-  { scenario: 'Setup: spawn destructible target actor', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: TEST_ACTOR, location: { x: 0, y: 0, z: 100 } }, expected: 'success', assertions: [{ path: 'structuredContent.result.actorName', equals: TEST_ACTOR, label: 'destructible target actor spawned' }] },
-  {
-    scenario: 'Setup: create interaction actor blueprint',
-    toolName: 'manage_blueprint',
-    arguments: { action: 'create', name: BLUEPRINT_NAME, path: TEST_FOLDER, parentClass: 'Actor' },
-    expected: 'success',
-    captureResult: { key: 'blueprintPath', fromField: 'result.assetPath' },
-    assertions: [{ path: 'structuredContent.result.assetPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'interaction target blueprint path returned' }]
-  },
-
-  // === INTERACTION COMPONENT ===
-  { scenario: 'CREATE: create_interaction_component', toolName: 'manage_interaction', arguments: { action: 'create_interaction_component', blueprintPath, componentName: 'InteractionComponent', traceDistance: 250 }, expected: 'success', assertions: [{ path: 'structuredContent.result.componentAdded', equals: true, label: 'interaction component added' }, { path: 'structuredContent.result.componentName', equals: 'InteractionComponent', label: 'interaction component name returned' }, { path: 'structuredContent.result.assetPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'interaction component target verified' }] },
-  { scenario: 'CONFIG: configure_interaction_trace', toolName: 'manage_interaction', arguments: { action: 'configure_interaction_trace', blueprintPath, traceType: 'sphere', traceDistance: 375, traceRadius: 80 }, expected: 'success', assertions: [{ path: 'structuredContent.result.traceType', equals: 'sphere', label: 'interaction trace type configured' }, { path: 'structuredContent.result.traceDistance', equals: 375, label: 'interaction trace distance configured' }, { path: 'structuredContent.result.traceRadius', equals: 80, label: 'interaction trace radius configured' }, { path: 'structuredContent.result.configured', equals: true, label: 'interaction trace configured flag returned' }] },
-  { scenario: 'CONFIG: configure_interaction_widget', toolName: 'manage_interaction', arguments: { action: 'configure_interaction_widget', blueprintPath, widgetClass: TEST_WIDGET_CLASS, showOnHover: true, showPromptText: false, promptTextFormat: 'Use {Key}' }, expected: 'success', assertions: [{ path: 'structuredContent.result.widgetClass', equals: TEST_WIDGET_CLASS, label: 'interaction widget class returned' }, { path: 'structuredContent.result.showOnHover', equals: true, label: 'interaction widget hover enabled' }, { path: 'structuredContent.result.showPromptText', equals: false, label: 'interaction widget prompt flag configured' }, { path: 'structuredContent.result.promptTextFormat', equals: 'Use {Key}', label: 'interaction widget prompt format configured' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'interaction widget target returned' }] },
-  { scenario: 'ADD: add_interaction_events', toolName: 'manage_interaction', arguments: { action: 'add_interaction_events', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.eventsAdded', length: 4, label: 'interaction event dispatchers added' }, { path: 'structuredContent.result.eventCount', equals: 4, label: 'interaction event count returned' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'interaction events target returned' }] },
-
-  // === INTERACTABLES ===
-  { scenario: 'CREATE: create_interactable_interface', toolName: 'manage_interaction', arguments: { action: 'create_interactable_interface', name: INTERFACE_NAME, folder: TEST_FOLDER_ALIAS }, expected: 'success', assertions: [{ path: 'structuredContent.result.interfacePath', equals: EXPECTED_INTERFACE_PATH, label: 'interactable interface path returned' }, { path: 'structuredContent.result.created', equals: true, label: 'interactable interface created' }, { path: 'structuredContent.result.functionsAdded', length: 3, label: 'interactable interface functions added' }] },
-  {
-    scenario: 'CREATE: create_door_actor',
-    toolName: 'manage_interaction',
-    arguments: { action: 'create_door_actor', name: DOOR_NAME, folder: TEST_FOLDER, openAngle: 110, openTime: 0.75, autoClose: true, autoCloseDelay: 2.5, requiresKey: true },
-    expected: 'success',
-    captureResult: { key: 'doorPath', fromField: 'result.assetPath' },
-    assertions: [{ path: 'structuredContent.result.openAngle', equals: 110, label: 'door open angle set at creation' }, { path: 'structuredContent.result.openTime', equals: 0.75, label: 'door open time set at creation' }, { path: 'structuredContent.result.autoClose', equals: true, label: 'door auto-close set at creation' }, { path: 'structuredContent.result.requiresKey', equals: true, label: 'door key requirement set at creation' }, { path: 'structuredContent.result.assetPath', equals: EXPECTED_DOOR_PATH, label: 'door asset path returned' }]
-  },
-  { scenario: 'CONFIG: configure_door_properties', toolName: 'manage_interaction', arguments: { action: 'configure_door_properties', doorPath, openAngle: 95, openTime: 1.25, locked: true }, expected: 'success', assertions: [{ path: 'structuredContent.result.doorPath', equals: EXPECTED_DOOR_PATH, label: 'door config target returned' }, { path: 'structuredContent.result.openAngle', equals: 95, label: 'door config open angle applied' }, { path: 'structuredContent.result.openTime', equals: 1.25, label: 'door config open time applied' }, { path: 'structuredContent.result.locked', equals: true, label: 'door locked flag applied' }] },
-  {
-    scenario: 'CREATE: create_switch_actor',
-    toolName: 'manage_interaction',
-    arguments: { action: 'create_switch_actor', name: SWITCH_NAME, folder: TEST_FOLDER, switchType: 'lever' },
-    expected: 'success',
-    captureResult: { key: 'switchPath', fromField: 'result.switchPath' },
-    assertions: [{ path: 'structuredContent.result.switchPath', equals: EXPECTED_SWITCH_PATH, label: 'switch path returned' }, { path: 'structuredContent.result.switchType', equals: 'lever', label: 'switch type set at creation' }]
-  },
-  { scenario: 'CONFIG: configure_switch_properties', toolName: 'manage_interaction', arguments: { action: 'configure_switch_properties', switchPath, switchType: 'pressure_plate', canToggle: false, resetTime: 3.5 }, expected: 'success', assertions: [{ path: 'structuredContent.result.switchPath', equals: EXPECTED_SWITCH_PATH, label: 'switch config target returned' }, { path: 'structuredContent.result.switchType', equals: 'pressure_plate', label: 'switch config type applied' }, { path: 'structuredContent.result.canToggle', equals: false, label: 'switch toggle flag applied' }, { path: 'structuredContent.result.resetTime', equals: 3.5, label: 'switch reset time applied' }] },
-  {
-    scenario: 'CREATE: create_chest_actor',
-    toolName: 'manage_interaction',
-    arguments: { action: 'create_chest_actor', name: CHEST_NAME, folder: TEST_FOLDER, locked: true },
-    expected: 'success',
-    captureResult: { key: 'chestPath', fromField: 'result.chestPath' },
-    assertions: [{ path: 'structuredContent.result.chestPath', equals: EXPECTED_CHEST_PATH, label: 'chest path returned' }, { path: 'structuredContent.result.locked', equals: true, label: 'chest locked at creation' }]
-  },
-  { scenario: 'CONFIG: configure_chest_properties', toolName: 'manage_interaction', arguments: { action: 'configure_chest_properties', chestPath, locked: false, openAngle: 75, openTime: 0.6, lootTablePath: TEST_LOOT_TABLE_PATH }, expected: 'success', assertions: [{ path: 'structuredContent.result.chestPath', equals: EXPECTED_CHEST_PATH, label: 'chest config target returned' }, { path: 'structuredContent.result.locked', equals: false, label: 'chest locked flag configured' }, { path: 'structuredContent.result.openAngle', equals: 75, label: 'chest open angle configured' }, { path: 'structuredContent.result.openTime', equals: 0.6, label: 'chest open time configured' }, { path: 'structuredContent.result.lootTablePath', equals: TEST_LOOT_TABLE_PATH, label: 'chest loot table path returned' }] },
-  {
-    scenario: 'CREATE: create_lever_actor',
-    toolName: 'manage_interaction',
-    arguments: { action: 'create_lever_actor', name: LEVER_NAME, folder: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'leverPath', fromField: 'result.leverPath' },
-    assertions: [{ path: 'structuredContent.result.leverPath', equals: EXPECTED_LEVER_PATH, label: 'lever path returned' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_LEVER_PATH, label: 'lever blueprint path returned' }]
-  },
-
-  // === DESTRUCTIBLES ===
-  { scenario: 'ACTION: setup_destructible_mesh', toolName: 'manage_interaction', arguments: { action: 'setup_destructible_mesh', actorName: TEST_ACTOR }, expected: 'success', assertions: [{ path: 'structuredContent.result.actorName', equals: TEST_ACTOR, label: 'destructible mesh actor target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'destructible mesh configured flag returned' }, { path: 'structuredContent.result.tagAdded', equals: 'MCP_DestructibleMeshConfigured', label: 'destructible mesh actor tag added' }] },
-  { scenario: 'CONFIG: configure_destruction_levels', toolName: 'manage_interaction', arguments: { action: 'configure_destruction_levels', actorName: TEST_ACTOR }, expected: 'success', assertions: [{ path: 'structuredContent.result.actorName', equals: TEST_ACTOR, label: 'destruction levels actor target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'destruction levels configured flag returned' }, { path: 'structuredContent.result.tagAdded', equals: 'MCP_DestructionLevelsConfigured', label: 'destruction levels actor tag added' }] },
-  { scenario: 'CONFIG: configure_destruction_effects', toolName: 'manage_interaction', arguments: { action: 'configure_destruction_effects', actorName: TEST_ACTOR }, expected: 'success', assertions: [{ path: 'structuredContent.result.actorName', equals: TEST_ACTOR, label: 'destruction effects actor target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'destruction effects configured flag returned' }, { path: 'structuredContent.result.tagAdded', equals: 'MCP_DestructionEffectsConfigured', label: 'destruction effects actor tag added' }] },
-  { scenario: 'CONFIG: configure_destruction_damage', toolName: 'manage_interaction', arguments: { action: 'configure_destruction_damage', actorName: TEST_ACTOR }, expected: 'success', assertions: [{ path: 'structuredContent.result.actorName', equals: TEST_ACTOR, label: 'destruction damage actor target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'destruction damage configured flag returned' }, { path: 'structuredContent.result.tagAdded', equals: 'MCP_DestructionDamageConfigured', label: 'destruction damage actor tag added' }] },
-  { scenario: 'ADD: add_destruction_component', toolName: 'manage_interaction', arguments: { action: 'add_destruction_component', blueprintPath, componentName: 'DestructionComponent' }, expected: 'success', assertions: [{ path: 'structuredContent.result.componentAdded', equals: true, label: 'destruction component added' }, { path: 'structuredContent.result.componentName', equals: 'DestructionComponent', label: 'destruction component name returned' }, { path: 'structuredContent.result.variablesAdded', length: 4, label: 'destruction variables added' }] },
-
-  // === TRIGGERS ===
-  {
-    scenario: 'CREATE: create_trigger_actor',
-    toolName: 'manage_interaction',
-    arguments: { action: 'create_trigger_actor', name: TRIGGER_NAME, folder: TEST_FOLDER, triggerShape: 'sphere' },
-    expected: 'success',
-    captureResult: { key: 'triggerPath', fromField: 'result.triggerPath' },
-    assertions: [{ path: 'structuredContent.result.triggerPath', equals: EXPECTED_TRIGGER_PATH, label: 'trigger path returned' }, { path: 'structuredContent.result.triggerShape', equals: 'sphere', label: 'trigger shape set at creation' }]
-  },
-  { scenario: 'CONFIG: configure_trigger_events', toolName: 'manage_interaction', arguments: { action: 'configure_trigger_events', triggerPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.configured', equals: true, label: 'trigger events configured flag returned' }, { path: 'structuredContent.result.eventCount', equals: 3, label: 'trigger event dispatchers added' }, { path: 'structuredContent.result.eventsAdded', length: 3, label: 'trigger event names returned' }] },
-  { scenario: 'CONFIG: configure_trigger_filter', toolName: 'manage_interaction', arguments: { action: 'configure_trigger_filter', triggerPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.triggerPath', equals: EXPECTED_TRIGGER_PATH, label: 'trigger filter target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'trigger filter configured flag returned' }, { path: 'structuredContent.result.variablesAdded', length: 2, label: 'trigger filter variables added' }] },
-  { scenario: 'CONFIG: configure_trigger_response', toolName: 'manage_interaction', arguments: { action: 'configure_trigger_response', triggerPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.triggerPath', equals: EXPECTED_TRIGGER_PATH, label: 'trigger response target returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'trigger response configured flag returned' }, { path: 'structuredContent.result.variablesAdded', length: 2, label: 'trigger response variables added' }] },
-
-  // === INFO ===
-  { scenario: 'INFO: get_interaction_info blueprint', toolName: 'manage_interaction', arguments: { action: 'get_interaction_info', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'Blueprint', label: 'interaction info reports blueprint asset type' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'interaction info returns blueprint path' }, { path: 'structuredContent.result.blueprintName', equals: BLUEPRINT_NAME, label: 'interaction info returns blueprint name' }] },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test actor', toolName: 'control_actor', arguments: { action: 'delete', actorName: TEST_ACTOR }, expected: 'success|not found' },
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-];
-
-runToolTests('manage-interaction', testCases);

package/mcps/unreal_mcp/tests/mcp-tools/gameplay/manage-inventory.test.mjs

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-/**
- * manage_inventory Tool Integration Tests
- * Covers all 33 actions with real asset paths captured from setup and creation.
- */
-
-import { runToolTests } from '../../test-runner.mjs';
-
-const ts = Date.now();
-const TEST_FOLDER = `/Game/MCPTest/GameplayInventory_${ts}`;
-const TEST_FOLDER_ALIAS = TEST_FOLDER.slice(1);
-const BLUEPRINT_NAME = `BP_MCP_InventoryActor_${ts}`;
-const ITEM_NAME = `DA_MCP_Item_${ts}`;
-const CATEGORY_NAME = `DA_MCP_Category_${ts}`;
-const PICKUP_NAME = `BP_MCP_Pickup_${ts}`;
-const LOOT_TABLE_NAME = `DA_MCP_LootTable_${ts}`;
-const RECIPE_NAME = `DA_MCP_Recipe_${ts}`;
-const STATION_NAME = `BP_MCP_CraftingStation_${ts}`;
-
-const EXPECTED_BLUEPRINT_PATH = `${TEST_FOLDER}/${BLUEPRINT_NAME}`;
-const EXPECTED_ITEM_PATH = `${TEST_FOLDER}/${ITEM_NAME}`;
-const EXPECTED_CATEGORY_PATH = `${TEST_FOLDER}/${CATEGORY_NAME}`;
-const EXPECTED_PICKUP_PATH = `${TEST_FOLDER}/${PICKUP_NAME}`;
-const EXPECTED_LOOT_TABLE_PATH = `${TEST_FOLDER}/${LOOT_TABLE_NAME}`;
-const EXPECTED_RECIPE_PATH = `${TEST_FOLDER}/${RECIPE_NAME}`;
-
-const blueprintPath = '${captured:blueprintPath}';
-const itemPath = '${captured:itemPath}';
-const categoryPath = '${captured:categoryPath}';
-const pickupPath = '${captured:pickupPath}';
-const lootTablePath = '${captured:lootTablePath}';
-const recipePath = '${captured:recipePath}';
-const stationPath = '${captured:stationPath}';
-
-const testCases = [
-  // === SETUP ===
-  { scenario: 'Setup: create test folder', toolName: 'manage_asset', arguments: { action: 'create_folder', path: TEST_FOLDER }, expected: 'success|already exists' },
-  {
-    scenario: 'Setup: create inventory actor blueprint',
-    toolName: 'manage_blueprint',
-    arguments: { action: 'create', name: BLUEPRINT_NAME, path: TEST_FOLDER, parentClass: 'Actor' },
-    expected: 'success',
-    captureResult: { key: 'blueprintPath', fromField: 'result.assetPath' },
-    assertions: [{ path: 'structuredContent.result.existsAfter', equals: true, label: 'inventory actor blueprint exists after creation' }]
-  },
-
-  // === ITEM DATA ===
-  {
-    scenario: 'CREATE: create_item_data_asset',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_item_data_asset', name: ITEM_NAME, path: TEST_FOLDER_ALIAS },
-    expected: 'success',
-    captureResult: { key: 'itemPath', fromField: 'result.assetPath' },
-    assertions: [{ path: 'structuredContent.result.assetClass', equals: 'McpGenericDataAsset', label: 'item data asset class reported' }]
-  },
-  { scenario: 'CONFIG: set_item_properties', toolName: 'manage_inventory', arguments: { action: 'set_item_properties', itemPath, properties: {}, save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.propertiesModified', equals: 0, label: 'generic item accepts properties payload without false modification' }, { path: 'structuredContent.result.assetPath', equals: EXPECTED_ITEM_PATH, label: 'item properties target verified' }] },
-  { scenario: 'CONFIG: configure_item_stacking', toolName: 'manage_inventory', arguments: { action: 'configure_item_stacking', itemPath, stackable: true, maxStackSize: 25, uniqueItems: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxStackSize', equals: 25, label: 'stack size request returned' }, { path: 'structuredContent.result.configured', equals: true, label: 'stacking persisted into asset data' }, { path: 'structuredContent.result.modifiedProperties', length: 3, label: 'stacking properties modified' }] },
-  { scenario: 'CONFIG: set_item_icon', toolName: 'manage_inventory', arguments: { action: 'set_item_icon', itemPath, iconPath: '/Game/MCPTest/FakeInventoryIcon' }, expected: 'success', assertions: [{ path: 'structuredContent.result.iconPath', equals: '/Game/MCPTest/FakeInventoryIcon', label: 'icon path request returned' }, { path: 'structuredContent.result.itemPath', equals: EXPECTED_ITEM_PATH, label: 'icon target item returned' }, { path: 'structuredContent.result.iconSet', equals: true, label: 'icon path persisted into asset data' }, { path: 'structuredContent.result.propertyModified', equals: 'Properties.IconPath', label: 'generic item icon storage reported' }] },
-
-  // === CATEGORY ===
-  {
-    scenario: 'CREATE: create_item_category',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_item_category', name: CATEGORY_NAME, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'categoryPath', fromField: 'result.categoryPath' },
-    assertions: [{ path: 'structuredContent.result.categoryPath', equals: EXPECTED_CATEGORY_PATH, label: 'category path returned' }]
-  },
-  { scenario: 'CONNECT: assign_item_category', toolName: 'manage_inventory', arguments: { action: 'assign_item_category', itemPath, categoryPath, save: false }, expected: 'success', assertions: [{ path: 'structuredContent.result.itemPath', equals: EXPECTED_ITEM_PATH, label: 'category assignment item target returned' }, { path: 'structuredContent.result.categoryPath', equals: EXPECTED_CATEGORY_PATH, label: 'category assignment category target returned' }] },
-
-  // === INVENTORY COMPONENT ===
-  { scenario: 'CREATE: create_inventory_component', toolName: 'manage_inventory', arguments: { action: 'create_inventory_component', blueprintPath, componentName: 'InventoryComponent', slotCount: 12 }, expected: 'success', assertions: [{ path: 'structuredContent.result.componentName', equals: 'InventoryComponent', label: 'inventory component name returned' }, { path: 'structuredContent.result.componentAdded', equals: true, label: 'inventory component added' }] },
-  { scenario: 'CONFIG: configure_inventory_slots', toolName: 'manage_inventory', arguments: { action: 'configure_inventory_slots', blueprintPath, slotCount: 16 }, expected: 'success', assertions: [{ path: 'structuredContent.result.slotCount', equals: 16, label: 'inventory slot count configured' }, { path: 'structuredContent.result.configured', equals: true, label: 'inventory slots configured flag returned' }] },
-  { scenario: 'ADD: add_inventory_functions', toolName: 'manage_inventory', arguments: { action: 'add_inventory_functions', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.functionsAdded', length: 8, label: 'inventory helper functions/events returned' }, { path: 'structuredContent.result.variablesAdded', length: 5, label: 'inventory helper variables added' }] },
-  { scenario: 'CONFIG: configure_inventory_events', toolName: 'manage_inventory', arguments: { action: 'configure_inventory_events', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.eventsAdded', length: 4, label: 'inventory events configured' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'inventory events target blueprint returned' }] },
-  { scenario: 'CONFIG: set_inventory_replication', toolName: 'manage_inventory', arguments: { action: 'set_inventory_replication', blueprintPath, replicated: true, replicationCondition: 'OwnerOnly' }, expected: 'success', assertions: [{ path: 'structuredContent.result.replicated', equals: true, label: 'inventory replication enabled' }, { path: 'structuredContent.result.replicationCondition', equals: 'OwnerOnly', label: 'inventory replication condition applied' }, { path: 'structuredContent.result.modifiedVariables', length: 4, label: 'inventory variables marked for replication' }] },
-  { scenario: 'CONFIG: configure_inventory_weight', toolName: 'manage_inventory', arguments: { action: 'configure_inventory_weight', blueprintPath, maxWeight: 125, enableWeight: true, encumberanceSystem: true, encumberanceThreshold: 0.8 }, expected: 'success', assertions: [{ path: 'structuredContent.result.maxWeight', equals: 125, label: 'max inventory weight configured' }, { path: 'structuredContent.result.encumberanceThreshold', equals: 0.8, label: 'encumberance threshold configured' }] },
-
-  // === PICKUPS ===
-  {
-    scenario: 'CREATE: create_pickup_actor',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_pickup_actor', name: PICKUP_NAME, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'pickupPath', fromField: 'result.pickupPath' },
-    assertions: [{ path: 'structuredContent.result.blueprintName', equals: PICKUP_NAME, label: 'pickup blueprint name returned' }]
-  },
-  { scenario: 'CONFIG: configure_pickup_interaction', toolName: 'manage_inventory', arguments: { action: 'configure_pickup_interaction', pickupPath, interactionType: 'Overlap', prompt: 'Collect item' }, expected: 'success', assertions: [{ path: 'structuredContent.result.interactionType', equals: 'Overlap', label: 'pickup interaction type configured' }, { path: 'structuredContent.result.configured', equals: true, label: 'pickup interaction configured flag returned' }] },
-  { scenario: 'CONFIG: configure_pickup_respawn', toolName: 'manage_inventory', arguments: { action: 'configure_pickup_respawn', pickupPath, respawnable: true, respawnTime: 45 }, expected: 'success', assertions: [{ path: 'structuredContent.result.respawnable', equals: true, label: 'pickup respawn enabled' }, { path: 'structuredContent.result.respawnTime', equals: 45, label: 'pickup respawn time configured' }] },
-  { scenario: 'CONFIG: configure_pickup_effects', toolName: 'manage_inventory', arguments: { action: 'configure_pickup_effects', pickupPath, bobbing: true, rotation: false, glowEffect: true }, expected: 'success', assertions: [{ path: 'structuredContent.result.bobbing', equals: true, label: 'pickup bobbing configured' }, { path: 'structuredContent.result.rotation', equals: false, label: 'pickup rotation configured' }, { path: 'structuredContent.result.glowEffect', equals: true, label: 'pickup glow configured' }] },
-
-  // === EQUIPMENT ===
-  { scenario: 'CREATE: create_equipment_component', toolName: 'manage_inventory', arguments: { action: 'create_equipment_component', blueprintPath, componentName: 'EquipmentComponent' }, expected: 'success', assertions: [{ path: 'structuredContent.result.componentName', equals: 'EquipmentComponent', label: 'equipment component name returned' }, { path: 'structuredContent.result.variablesAdded', length: 3, label: 'equipment state variables added' }] },
-  { scenario: 'ACTION: define_equipment_slots', toolName: 'manage_inventory', arguments: { action: 'define_equipment_slots', blueprintPath, slots: ['Head', 'Weapon', 'Ring'] }, expected: 'success', assertions: [{ path: 'structuredContent.result.slotCount', equals: 3, label: 'equipment slot count configured' }, { path: 'structuredContent.result.slotsConfigured', length: 3, label: 'equipment slots returned' }] },
-  { scenario: 'CONFIG: configure_equipment_effects', toolName: 'manage_inventory', arguments: { action: 'configure_equipment_effects', blueprintPath, statModifiers: true, abilityGrants: false, passiveEffects: true }, expected: 'success', assertions: [{ path: 'structuredContent.result.statModifiersConfigured', equals: true, label: 'equipment stat modifiers configured' }, { path: 'structuredContent.result.abilityGrantsConfigured', equals: false, label: 'equipment ability grants configured' }, { path: 'structuredContent.result.passiveEffectsConfigured', equals: true, label: 'equipment passive effects configured' }] },
-  { scenario: 'ADD: add_equipment_functions', toolName: 'manage_inventory', arguments: { action: 'add_equipment_functions', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.functionsAdded', length: 9, label: 'equipment helper functions/events returned' }, { path: 'structuredContent.result.variablesAdded', length: 6, label: 'equipment helper variables added' }] },
-  { scenario: 'CONFIG: configure_equipment_visuals', toolName: 'manage_inventory', arguments: { action: 'configure_equipment_visuals', blueprintPath, attachToSocket: true, defaultSocket: 'hand_r' }, expected: 'success', assertions: [{ path: 'structuredContent.result.attachToSocket', equals: true, label: 'equipment visual socket attach enabled' }, { path: 'structuredContent.result.defaultSocket', equals: 'hand_r', label: 'equipment default socket configured' }] },
-
-  // === LOOT ===
-  {
-    scenario: 'CREATE: create_loot_table',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_loot_table', name: LOOT_TABLE_NAME, path: TEST_FOLDER },
-    expected: 'success',
-    captureResult: { key: 'lootTablePath', fromField: 'result.lootTablePath' },
-    assertions: [{ path: 'structuredContent.result.lootTablePath', equals: EXPECTED_LOOT_TABLE_PATH, label: 'loot table path returned' }]
-  },
-  { scenario: 'ADD: add_loot_entry', toolName: 'manage_inventory', arguments: { action: 'add_loot_entry', lootTablePath, itemPath, lootWeight: 2.5, minQuantity: 1, maxQuantity: 3 }, expected: 'success', assertions: [{ path: 'structuredContent.result.lootTablePath', equals: EXPECTED_LOOT_TABLE_PATH, label: 'loot entry table target returned' }, { path: 'structuredContent.result.itemPath', equals: EXPECTED_ITEM_PATH, label: 'loot entry item target returned' }, { path: 'structuredContent.result.weight', equals: 2.5, label: 'loot entry weight returned' }, { path: 'structuredContent.result.added', equals: true, label: 'loot entry persisted into table data' }, { path: 'structuredContent.result.storage', equals: 'Properties', label: 'generic loot table storage reported' }] },
-  { scenario: 'CONFIG: configure_loot_drop', toolName: 'manage_inventory', arguments: { action: 'configure_loot_drop', actorPath: blueprintPath, lootTablePath, dropCount: 2, dropRadius: 250, dropOnDeath: true }, expected: 'success', assertions: [{ path: 'structuredContent.result.dropCount', equals: 2, label: 'loot drop count configured' }, { path: 'structuredContent.result.dropRadius', equals: 250, label: 'loot drop radius configured' }, { path: 'structuredContent.result.configured', equals: true, label: 'loot drop configured flag returned' }] },
-  { scenario: 'CONFIG: set_loot_quality_tiers', toolName: 'manage_inventory', arguments: { action: 'set_loot_quality_tiers', lootTablePath, tiers: [{ name: 'Common', dropWeight: 70 }, { name: 'Rare', dropWeight: 30 }] }, expected: 'success', assertions: [{ path: 'structuredContent.result.tierCount', equals: 2, label: 'loot quality tier count configured' }, { path: 'structuredContent.result.tiersConfigured', length: 2, label: 'loot quality tiers returned' }] },
-  { scenario: 'ACTION: remove_loot_entry', toolName: 'manage_inventory', arguments: { action: 'remove_loot_entry', lootTablePath, entryIndex: 0 }, expected: 'success', assertions: [{ path: 'structuredContent.result.lootTablePath', equals: EXPECTED_LOOT_TABLE_PATH, label: 'remove loot entry table target returned' }, { path: 'structuredContent.result.removed', equals: false, label: 'generic loot table reports no removable backing array' }] },
-
-  // === CRAFTING ===
-  {
-    scenario: 'CREATE: create_crafting_recipe',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_crafting_recipe', name: RECIPE_NAME, path: TEST_FOLDER, outputItemPath: itemPath, outputQuantity: 2, craftTime: 4.5 },
-    expected: 'success',
-    captureResult: { key: 'recipePath', fromField: 'result.recipePath' },
-    assertions: [{ path: 'structuredContent.result.outputItemPath', equals: EXPECTED_ITEM_PATH, label: 'crafting recipe output item configured' }, { path: 'structuredContent.result.outputQuantity', equals: 2, label: 'crafting output quantity configured' }]
-  },
-  { scenario: 'CONFIG: configure_recipe_requirements', toolName: 'manage_inventory', arguments: { action: 'configure_recipe_requirements', recipePath, requiredLevel: 5, requiredStation: 'Workbench' }, expected: 'success', assertions: [{ path: 'structuredContent.result.recipePath', equals: EXPECTED_RECIPE_PATH, label: 'recipe requirements target returned' }, { path: 'structuredContent.result.requiredLevel', equals: 5, label: 'recipe required level configured' }, { path: 'structuredContent.result.requiredStation', equals: 'Workbench', label: 'recipe required station configured' }, { path: 'structuredContent.result.configured', equals: true, label: 'recipe requirements persisted into asset data' }, { path: 'structuredContent.result.propertiesModified', equals: 2, label: 'recipe requirement properties modified' }] },
-  { scenario: 'ADD: add_recipe_ingredient', toolName: 'manage_inventory', arguments: { action: 'add_recipe_ingredient', recipePath, ingredientItemPath: itemPath, quantity: 3 }, expected: 'success', assertions: [{ path: 'structuredContent.result.recipePath', equals: EXPECTED_RECIPE_PATH, label: 'recipe ingredient target returned' }, { path: 'structuredContent.result.ingredientItemPath', equals: EXPECTED_ITEM_PATH, label: 'recipe ingredient item returned' }, { path: 'structuredContent.result.quantity', equals: 3, label: 'recipe ingredient quantity returned' }, { path: 'structuredContent.result.added', equals: true, label: 'recipe ingredient persisted into recipe data' }, { path: 'structuredContent.result.storage', equals: 'Properties', label: 'generic recipe ingredient storage reported' }] },
-  {
-    scenario: 'CREATE: create_crafting_station',
-    toolName: 'manage_inventory',
-    arguments: { action: 'create_crafting_station', name: STATION_NAME, path: TEST_FOLDER, stationType: 'Workbench' },
-    expected: 'success',
-    captureResult: { key: 'stationPath', fromField: 'result.stationPath' },
-    assertions: [{ path: 'structuredContent.result.stationType', equals: 'Workbench', label: 'crafting station type returned' }]
-  },
-  { scenario: 'ADD: add_crafting_component', toolName: 'manage_inventory', arguments: { action: 'add_crafting_component', blueprintPath, componentName: 'CraftingComponent' }, expected: 'success', assertions: [{ path: 'structuredContent.result.componentName', equals: 'CraftingComponent', label: 'crafting component name returned' }, { path: 'structuredContent.result.componentAdded', equals: true, label: 'crafting component added' }] },
-  { scenario: 'CONFIG: configure_station_recipes', toolName: 'manage_inventory', arguments: { action: 'configure_station_recipes', stationPath, recipePaths: [recipePath], stationType: 'Workbench', craftingSpeedMultiplier: 1.25 }, expected: 'success', assertions: [{ path: 'structuredContent.result.stationType', equals: 'Workbench', label: 'station recipe type configured' }, { path: 'structuredContent.result.recipeCount', equals: 1, label: 'station recipe count configured' }, { path: 'structuredContent.result.recipePaths', length: 1, label: 'station recipe path returned' }] },
-
-  // === INFO ===
-  { scenario: 'INFO: get_inventory_info blueprint', toolName: 'manage_inventory', arguments: { action: 'get_inventory_info', blueprintPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'Blueprint', label: 'inventory info reports blueprint asset type' }, { path: 'structuredContent.result.blueprintPath', equals: EXPECTED_BLUEPRINT_PATH, label: 'inventory info returns blueprint path' }, { path: 'structuredContent.result.components', length: 3, label: 'inventory info reports inventory, equipment, and crafting components' }] },
-  { scenario: 'INFO: get_inventory_info item', toolName: 'manage_inventory', arguments: { action: 'get_inventory_info', itemPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'Item', label: 'inventory info reports item asset type' }, { path: 'structuredContent.result.itemPath', equals: EXPECTED_ITEM_PATH, label: 'inventory info returns item path' }, { path: 'structuredContent.result.properties.bStackable', equals: 'true', label: 'item stacking flag read back from asset data' }, { path: 'structuredContent.result.properties.MaxStackSize', equals: '25', label: 'item stack size read back from asset data' }, { path: 'structuredContent.result.properties.IconPath', equals: '/Game/MCPTest/FakeInventoryIcon', label: 'item icon path read back from asset data' }] },
-  { scenario: 'INFO: get_inventory_info loot table', toolName: 'manage_inventory', arguments: { action: 'get_inventory_info', lootTablePath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'LootTable', label: 'inventory info reports loot table asset type' }, { path: 'structuredContent.result.lootTablePath', equals: EXPECTED_LOOT_TABLE_PATH, label: 'inventory info returns loot table path' }, { path: 'structuredContent.result.properties.LootEntry_0', equals: `ItemPath=${EXPECTED_ITEM_PATH};Weight=2.5;MinQuantity=1;MaxQuantity=3`, label: 'loot entry read back from table data' }] },
-  { scenario: 'INFO: get_inventory_info recipe', toolName: 'manage_inventory', arguments: { action: 'get_inventory_info', recipePath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'Recipe', label: 'inventory info reports recipe asset type' }, { path: 'structuredContent.result.recipePath', equals: EXPECTED_RECIPE_PATH, label: 'inventory info returns recipe path' }, { path: 'structuredContent.result.properties.RequiredLevel', equals: '5', label: 'recipe required level read back from asset data' }, { path: 'structuredContent.result.properties.RequiredStation', equals: 'Workbench', label: 'recipe station read back from asset data' }, { path: 'structuredContent.result.properties.Ingredient_2', equals: `ItemPath=${EXPECTED_ITEM_PATH};Quantity=3`, label: 'recipe ingredient read back from asset data' }] },
-  { scenario: 'INFO: get_inventory_info pickup', toolName: 'manage_inventory', arguments: { action: 'get_inventory_info', pickupPath }, expected: 'success', assertions: [{ path: 'structuredContent.result.assetType', equals: 'Pickup', label: 'inventory info reports pickup asset type' }, { path: 'structuredContent.result.pickupPath', equals: EXPECTED_PICKUP_PATH, label: 'inventory info returns pickup path' }] },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup: delete test folder', toolName: 'manage_asset', arguments: { action: 'delete', path: TEST_FOLDER, force: true }, expected: 'success|not found' },
-];
-
-runToolTests('manage-inventory', testCases);