unreal-engine-mcp-server 0.5.21 → 0.5.30

package/dist/tools/handlers/material-authoring-handlers.js

@@ -1,4 +1,5 @@
-import { executeAutomationRequest } from './common-handlers.js';
+import { executeAutomationRequest, normalizePathFields } from './common-handlers.js';
+import { sanitizePath } from '../../utils/path-security.js';
 import { normalizeArgs, extractString, extractOptionalString, extractOptionalNumber, extractOptionalBoolean, extractOptionalObject, } from './argument-helper.js';
 function parseMaterialPath(fullPath) {
     if (!fullPath)
@@ -12,6 +13,11 @@ function parseMaterialPath(fullPath) {
 }
 import { ResponseFactory } from '../../utils/response-factory.js';
 import { TOOL_ACTIONS } from '../../utils/action-constants.js';
+import { MATERIAL_AUTHORING_ACTIONS } from '../consolidated-tool-definitions.js';
+function normalizeAssetPath(p) {
+    const normalized = normalizePathFields({ path: p }, ['path']).path;
+    return sanitizePath(normalized);
+}
 export async function handleMaterialAuthoringTools(action, args, tools) {
     try {
         switch (action) {
@@ -23,9 +29,9 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 let name;
                 let path;
                 if (materialPath) {
-                    const parsed = parseMaterialPath(materialPath);
-                    if (!parsed) {
-                        return ResponseFactory.error('Invalid materialPath format', 'INVALID_ARGUMENT');
+                    const parsed = parseMaterialPath(normalizeAssetPath(materialPath));
+                    if (!parsed || !parsed.name || !parsed.path) {
+                        return ResponseFactory.error('manage_material_authoring.create_material: invalid materialPath format', 'INVALID_ARGUMENT');
                     }
                     name = parsed.name;
                     path = parsed.path;
@@ -36,7 +42,7 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                         { key: 'path', aliases: ['directory'], default: '/Game/Materials' },
                     ]);
                     name = extractString(params, 'name');
-                    path = extractOptionalString(params, 'path') ?? '/Game/Materials';
+                    path = normalizeAssetPath(extractOptionalString(params, 'path') ?? '/Game/Materials');
                 }
                 const materialDomain = extractOptionalString(rawArgs, 'materialDomain') ??
                     extractOptionalString(rawArgs, 'domain') ?? 'Surface';
@@ -61,7 +67,7 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
             }
             case 'set_blend_mode': {
                 const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
+                    { key: 'assetPath', aliases: ['materialPath', 'instancePath'], required: true },
                     { key: 'blendMode', required: true },
                     { key: 'save', default: true },
                 ]);
@@ -81,7 +87,7 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
             }
             case 'set_shading_model': {
                 const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
+                    { key: 'assetPath', aliases: ['materialPath', 'instancePath'], required: true },
                     { key: 'shadingModel', required: true },
                     { key: 'save', default: true },
                 ]);
@@ -349,6 +355,8 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     { key: 'code', aliases: ['hlsl'], required: true },
                     { key: 'outputType', default: 'Float1' },
                     { key: 'description' },
+                    { key: 'inputs' },
+                    { key: 'additionalOutputs' },
                     { key: 'x', default: 0 },
                     { key: 'y', default: 0 },
                 ]);
@@ -356,9 +364,36 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 const code = extractString(params, 'code');
                 const outputType = extractOptionalString(params, 'outputType') ?? 'Float1';
                 const description = extractOptionalString(params, 'description');
+                const inputs = params.inputs;
+                const additionalOutputs = params.additionalOutputs;
+                if (inputs != null && !Array.isArray(inputs)) {
+                    return ResponseFactory.error('manage_material_authoring.add_custom_expression: inputs must be an array', 'INVALID_INPUTS');
+                }
+                if (inputs != null && Array.isArray(inputs)) {
+                    for (let i = 0; i < inputs.length; i++) {
+                        const item = inputs[i];
+                        if (!item || typeof item !== 'object' || typeof item.name !== 'string' || !item.name.trim()) {
+                            return ResponseFactory.error(`manage_material_authoring.add_custom_expression: inputs[${i}] must be an object with a non-empty string "name"`, 'INVALID_INPUTS');
+                        }
+                    }
+                }
+                if (additionalOutputs != null && !Array.isArray(additionalOutputs)) {
+                    return ResponseFactory.error('manage_material_authoring.add_custom_expression: additionalOutputs must be an array', 'INVALID_OUTPUTS');
+                }
+                if (additionalOutputs != null && Array.isArray(additionalOutputs)) {
+                    for (let i = 0; i < additionalOutputs.length; i++) {
+                        const item = additionalOutputs[i];
+                        if (!item || typeof item !== 'object' || typeof item.name !== 'string' || !item.name.trim()) {
+                            return ResponseFactory.error(`manage_material_authoring.add_custom_expression: additionalOutputs[${i}] must be an object with a non-empty string "name"`, 'INVALID_OUTPUTS');
+                        }
+                        if (item.type != null && typeof item.type !== 'string') {
+                            return ResponseFactory.error(`manage_material_authoring.add_custom_expression: additionalOutputs[${i}].type must be a string if provided`, 'INVALID_OUTPUTS');
+                        }
+                    }
+                }
                 const x = extractOptionalNumber(params, 'x') ?? 0;
                 const y = extractOptionalNumber(params, 'y') ?? 0;
-                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
+                const payload = {
                     subAction: 'add_custom_expression',
                     assetPath,
                     code,
@@ -366,11 +401,25 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     description,
                     x,
                     y,
-                }));
+                };
+                if (inputs != null) {
+                    payload.inputs = inputs;
+                }
+                if (additionalOutputs != null) {
+                    payload.additionalOutputs = additionalOutputs;
+                }
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
                 if (res.success === false) {
                     return ResponseFactory.error(res.error ?? 'Failed to add custom expression', res.errorCode);
                 }
-                return ResponseFactory.success(res, res.message ?? 'Custom HLSL expression added');
+                const response = ResponseFactory.success(res, res.message ?? 'Custom HLSL expression added');
+                const result = res.result;
+                if (result && typeof result === 'object' && !Array.isArray(result)) {
+                    const nodeId = result.nodeId;
+                    if (typeof nodeId === 'string')
+                        response.nodeId = nodeId;
+                }
+                return response;
             }
             case 'connect_nodes':
             case 'connect_material_pins': {
@@ -378,22 +427,28 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 const assetPath = extractOptionalString(rawArgs, 'assetPath') ??
                     extractOptionalString(rawArgs, 'materialPath') ?? '';
                 const sourceNodeId = extractOptionalString(rawArgs, 'sourceNodeId') ??
-                    extractOptionalString(rawArgs, 'fromNode') ?? '';
-                const targetNodeId = extractOptionalString(rawArgs, 'targetNodeId') ??
+                    extractOptionalString(rawArgs, 'fromNode') ??
+                    extractOptionalString(rawArgs, 'nodeId') ?? '';
+                let targetNodeId = extractOptionalString(rawArgs, 'targetNodeId') ??
                     extractOptionalString(rawArgs, 'toNode') ?? '';
                 const sourcePin = extractOptionalString(rawArgs, 'sourcePin') ??
                     extractOptionalString(rawArgs, 'fromPin') ?? '';
                 const targetPin = extractOptionalString(rawArgs, 'targetPin') ??
                     extractOptionalString(rawArgs, 'toPin') ??
                     extractOptionalString(rawArgs, 'inputName') ?? '';
+                if (!targetNodeId && targetPin) {
+                    targetNodeId = 'Main';
+                }
+                else if (targetNodeId.toLowerCase() === 'root') {
+                    targetNodeId = 'Main';
+                }
                 const effectiveSourceId = sourceNodeId || sourcePin;
-                const effectiveTargetId = targetNodeId || targetPin;
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'connect_nodes',
                     assetPath,
                     sourceNodeId: effectiveSourceId,
                     sourcePin,
-                    targetNodeId: effectiveTargetId,
+                    targetNodeId,
                     inputName: targetPin,
                 }));
                 if (res.success === false) {
@@ -410,10 +465,10 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     extractOptionalString(rawArgs, 'pinName') ?? '';
                 const pinName = extractOptionalString(rawArgs, 'pinName');
                 if (!assetPath) {
-                    return ResponseFactory.error('Missing required argument: assetPath or materialPath', 'MISSING_ASSET_PATH');
+                    return ResponseFactory.error('manage_material_authoring.disconnect_nodes: missing required argument assetPath', 'MISSING_ASSET_PATH');
                 }
                 if (!nodeId) {
-                    return ResponseFactory.error('Missing required argument: nodeId (or pinName)', 'MISSING_NODE_ID');
+                    return ResponseFactory.error('manage_material_authoring.disconnect_nodes: missing required argument nodeId (or pinName)', 'MISSING_NODE_ID');
                 }
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'disconnect_nodes',
@@ -461,7 +516,7 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     { key: 'x', default: 0 },
                     { key: 'y', default: 0 },
                 ]);
-                const assetPath = extractString(params, 'assetPath');
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
                 const inputName = extractString(params, 'inputName');
                 const inputType = extractOptionalString(params, 'inputType') ?? 'Float3';
                 const x = extractOptionalNumber(params, 'x') ?? 0;
@@ -486,8 +541,8 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     { key: 'x', default: 0 },
                     { key: 'y', default: 0 },
                 ]);
-                const assetPath = extractString(params, 'assetPath');
-                const functionPath = extractString(params, 'functionPath');
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const functionPath = normalizeAssetPath(extractString(params, 'functionPath'));
                 const x = extractOptionalNumber(params, 'x') ?? 0;
                 const y = extractOptionalNumber(params, 'y') ?? 0;
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
@@ -515,9 +570,9 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 let path;
                 let parentMaterial;
                 if (instancePath) {
-                    const parsed = parseMaterialPath(instancePath);
-                    if (!parsed) {
-                        return ResponseFactory.error('Invalid instancePath format', 'INVALID_ARGUMENT');
+                    const parsed = parseMaterialPath(normalizeAssetPath(instancePath));
+                    if (!parsed || !parsed.name || !parsed.path) {
+                        return ResponseFactory.error('manage_material_authoring.create_material_instance: invalid instancePath format', 'INVALID_ARGUMENT');
                     }
                     name = parsed.name;
                     path = parsed.path;
@@ -530,11 +585,11 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                         { key: 'parentMaterial', aliases: ['parent'], required: true },
                     ]);
                     name = extractString(params, 'name');
-                    path = extractOptionalString(params, 'path') ?? '/Game/Materials';
+                    path = normalizeAssetPath(extractOptionalString(params, 'path') ?? '/Game/Materials');
                     parentMaterial = extractString(params, 'parentMaterial');
                 }
                 if (!parentMaterial) {
-                    return ResponseFactory.error('parentMaterialPath or parent is required', 'MISSING_PARENT');
+                    return ResponseFactory.error('manage_material_authoring.create_material_instance: parentMaterialPath or parent is required', 'MISSING_PARENT');
                 }
                 const save = extractOptionalBoolean(rawArgs, 'save') ?? true;
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
@@ -697,31 +752,310 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
             }
             case 'get_material_info': {
                 const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'filter' },
                 ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const filter = extractOptionalString(params, 'filter');
+                const payload = {
                     subAction: 'get_material_info',
                     assetPath,
-                }));
+                };
+                if (filter)
+                    payload.filter = filter;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
                 if (res.success === false) {
                     return ResponseFactory.error(res.error ?? 'Failed to get material info', res.errorCode);
                 }
                 return ResponseFactory.success(res, res.message ?? 'Material info retrieved');
             }
+            case 'find_node': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'nodeType' },
+                    { key: 'name' },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const nodeType = extractOptionalString(params, 'nodeType');
+                const name = extractOptionalString(params, 'name');
+                if (!nodeType && !name) {
+                    return ResponseFactory.error('manage_material_authoring.find_node: requires at least one of nodeType or name', 'MISSING_SEARCH_CRITERIA');
+                }
+                const payload = {
+                    subAction: 'find_node',
+                    assetPath,
+                };
+                if (nodeType)
+                    payload.nodeType = nodeType;
+                if (name)
+                    payload.name = name;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to find node', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Node search complete');
+            }
+            case 'get_node_connections': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'nodeId', required: true },
+                    { key: 'direction' },
+                    { key: 'depth', default: 1 },
+                    { key: 'upstream' },
+                    { key: 'downstream' },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const nodeId = extractString(params, 'nodeId');
+                const payload = {
+                    subAction: 'get_node_connections',
+                    assetPath,
+                    nodeId,
+                };
+                const direction = extractOptionalString(params, 'direction');
+                const depth = extractOptionalNumber(params, 'depth');
+                const upstream = extractOptionalBoolean(params, 'upstream');
+                const downstream = extractOptionalBoolean(params, 'downstream');
+                if (direction)
+                    payload.direction = direction;
+                if (depth !== undefined && depth !== null)
+                    payload.depth = depth;
+                if (upstream !== undefined && upstream !== null)
+                    payload.upstream = upstream;
+                if (downstream !== undefined && downstream !== null)
+                    payload.downstream = downstream;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to get node connections', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Node connections retrieved');
+            }
+            case 'get_node_properties': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'nodeId', required: true },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const nodeId = extractString(params, 'nodeId');
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
+                    subAction: 'get_node_properties',
+                    assetPath,
+                    nodeId,
+                }));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to get node properties', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Node properties retrieved');
+            }
+            case 'set_static_switch_parameter_value': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'instancePath'], required: true },
+                    { key: 'parameterName', required: true },
+                    { key: 'value', required: true },
+                    { key: 'save', default: true },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const parameterName = extractString(params, 'parameterName');
+                const value = extractOptionalBoolean(params, 'value');
+                if (value === undefined) {
+                    return ResponseFactory.error('manage_material_authoring.set_static_switch_parameter_value: value must be a boolean', 'INVALID_VALUE');
+                }
+                const save = extractOptionalBoolean(params, 'save') ?? true;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
+                    subAction: 'set_static_switch_parameter_value',
+                    assetPath,
+                    parameterName,
+                    value,
+                    save,
+                }));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to set static switch parameter', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Static switch parameter set');
+            }
+            case 'delete_node': {
+                const rawArgs = args;
+                const assetPath = normalizeAssetPath(extractOptionalString(rawArgs, 'assetPath') ??
+                    extractOptionalString(rawArgs, 'materialPath') ??
+                    extractOptionalString(rawArgs, 'functionPath') ?? '');
+                if (!assetPath) {
+                    return ResponseFactory.error('manage_material_authoring.delete_node: missing required argument assetPath', 'MISSING_ASSET_PATH');
+                }
+                const nodeId = extractOptionalString(rawArgs, 'nodeId');
+                const nodeIdsRaw = Array.isArray(rawArgs.nodeIds) ? rawArgs.nodeIds : undefined;
+                const nodeIds = nodeIdsRaw?.filter((id) => typeof id === 'string' && id.trim().length > 0);
+                if (nodeIdsRaw && (!nodeIds || nodeIds.length !== nodeIdsRaw.length)) {
+                    return ResponseFactory.error('manage_material_authoring.delete_node: nodeIds must be an array of non-empty strings', 'INVALID_NODE_IDS');
+                }
+                if (!nodeId && (!nodeIds || nodeIds.length === 0)) {
+                    return ResponseFactory.error('manage_material_authoring.delete_node: provide nodeId or a non-empty nodeIds array', 'MISSING_NODE_ID');
+                }
+                const payload = {
+                    subAction: 'delete_node',
+                    assetPath,
+                };
+                if (nodeId)
+                    payload.nodeId = nodeId;
+                if (nodeIds && nodeIds.length > 0)
+                    payload.nodeIds = nodeIds;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to delete node(s)', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Node(s) deleted');
+            }
+            case 'update_custom_expression': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'nodeId', required: true },
+                    { key: 'code' },
+                    { key: 'description' },
+                    { key: 'outputType' },
+                    { key: 'inputs' },
+                    { key: 'additionalOutputs' },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const nodeId = extractString(params, 'nodeId');
+                const payload = {
+                    subAction: 'update_custom_expression',
+                    assetPath,
+                    nodeId,
+                };
+                const code = extractOptionalString(params, 'code');
+                const description = extractOptionalString(params, 'description');
+                const outputType = extractOptionalString(params, 'outputType');
+                const inputs = params.inputs;
+                const additionalOutputs = params.additionalOutputs;
+                if (inputs != null && !Array.isArray(inputs)) {
+                    return ResponseFactory.error('manage_material_authoring.update_custom_expression: inputs must be an array', 'INVALID_INPUTS');
+                }
+                if (inputs != null && Array.isArray(inputs)) {
+                    for (let i = 0; i < inputs.length; i++) {
+                        const item = inputs[i];
+                        if (!item || typeof item !== 'object' || typeof item.name !== 'string' || !item.name.trim()) {
+                            return ResponseFactory.error(`manage_material_authoring.update_custom_expression: inputs[${i}] must be an object with a non-empty string "name"`, 'INVALID_INPUTS');
+                        }
+                    }
+                }
+                if (additionalOutputs != null && !Array.isArray(additionalOutputs)) {
+                    return ResponseFactory.error('manage_material_authoring.update_custom_expression: additionalOutputs must be an array', 'INVALID_OUTPUTS');
+                }
+                if (additionalOutputs != null && Array.isArray(additionalOutputs)) {
+                    for (let i = 0; i < additionalOutputs.length; i++) {
+                        const item = additionalOutputs[i];
+                        if (!item || typeof item !== 'object' || typeof item.name !== 'string' || !item.name.trim()) {
+                            return ResponseFactory.error(`manage_material_authoring.update_custom_expression: additionalOutputs[${i}] must be an object with a non-empty string "name"`, 'INVALID_OUTPUTS');
+                        }
+                        if (item.type != null && typeof item.type !== 'string') {
+                            return ResponseFactory.error(`manage_material_authoring.update_custom_expression: additionalOutputs[${i}].type must be a string if provided`, 'INVALID_OUTPUTS');
+                        }
+                    }
+                }
+                const hasCode = code !== undefined && code !== null;
+                const hasDescription = description !== undefined && description !== null;
+                const hasOutputType = outputType !== undefined && outputType !== null;
+                const hasInputs = inputs !== undefined && inputs !== null;
+                const hasAdditionalOutputs = additionalOutputs !== undefined && additionalOutputs !== null;
+                if (!hasCode && !hasDescription && !hasOutputType && !hasInputs && !hasAdditionalOutputs) {
+                    return ResponseFactory.error('manage_material_authoring.update_custom_expression: provide at least one field to update', 'MISSING_UPDATE_FIELDS');
+                }
+                if (hasCode)
+                    payload.code = code;
+                if (hasDescription)
+                    payload.description = description;
+                if (hasOutputType)
+                    payload.outputType = outputType;
+                if (hasInputs)
+                    payload.inputs = inputs;
+                if (hasAdditionalOutputs)
+                    payload.additionalOutputs = additionalOutputs;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to update custom expression', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Custom expression updated');
+            }
+            case 'get_node_chain': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['materialPath', 'functionPath'], required: true },
+                    { key: 'startNodeId', required: true },
+                    { key: 'endNodeId' },
+                    { key: 'endPin' },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const startNodeId = extractString(params, 'startNodeId');
+                const endNodeId = extractOptionalString(params, 'endNodeId');
+                const endPin = extractOptionalString(params, 'endPin');
+                if (!endNodeId && !endPin) {
+                    return ResponseFactory.error('manage_material_authoring.get_node_chain: provide endNodeId or endPin', 'INVALID_ARGUMENT');
+                }
+                const payload = {
+                    subAction: 'get_node_chain',
+                    assetPath,
+                    startNodeId,
+                };
+                if (endNodeId)
+                    payload.endNodeId = endNodeId;
+                if (endPin)
+                    payload.endPin = endPin;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to trace node chain', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Node chain traced');
+            }
+            case 'get_connected_subgraph': {
+                const rawArgs = args;
+                const assetPath = normalizeAssetPath(extractOptionalString(rawArgs, 'assetPath') ??
+                    extractOptionalString(rawArgs, 'materialPath') ??
+                    extractOptionalString(rawArgs, 'functionPath') ?? '');
+                if (!assetPath) {
+                    return ResponseFactory.error('manage_material_authoring.get_connected_subgraph: missing required argument assetPath', 'MISSING_ASSET_PATH');
+                }
+                const nodeId = extractOptionalString(rawArgs, 'nodeId');
+                const orphansOnly = extractOptionalBoolean(rawArgs, 'orphansOnly') ?? false;
+                if (!nodeId && !orphansOnly) {
+                    return ResponseFactory.error('manage_material_authoring.get_connected_subgraph: provide nodeId or set orphansOnly=true', 'MISSING_NODE_ID');
+                }
+                const payload = {
+                    subAction: 'get_connected_subgraph',
+                    assetPath,
+                    orphansOnly,
+                };
+                if (nodeId)
+                    payload.nodeId = nodeId;
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, payload));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to get connected subgraph', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Connected subgraph retrieved');
+            }
+            case 'get_material_function_info': {
+                const params = normalizeArgs(args, [
+                    { key: 'assetPath', aliases: ['functionPath', 'materialFunctionPath'], required: true },
+                ]);
+                const assetPath = normalizeAssetPath(extractString(params, 'assetPath'));
+                const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
+                    subAction: 'get_material_function_info',
+                    assetPath,
+                }));
+                if (res.success === false) {
+                    return ResponseFactory.error(res.error ?? 'Failed to get material function info', res.errorCode);
+                }
+                return ResponseFactory.success(res, res.message ?? 'Material function info retrieved');
+            }
             case 'add_material_node': {
                 const rawArgs = args;
                 const assetPath = extractOptionalString(rawArgs, 'assetPath') ??
                     extractOptionalString(rawArgs, 'materialPath') ?? '';
                 const nodeType = extractOptionalString(rawArgs, 'nodeType') ??
                     extractOptionalString(rawArgs, 'type') ?? '';
-                const x = extractOptionalNumber(rawArgs, 'x') ?? 0;
-                const y = extractOptionalNumber(rawArgs, 'y') ?? 0;
+                const x = extractOptionalNumber(rawArgs, 'x') ?? extractOptionalNumber(rawArgs, 'posX') ?? 0;
+                const y = extractOptionalNumber(rawArgs, 'y') ?? extractOptionalNumber(rawArgs, 'posY') ?? 0;
                 if (!assetPath) {
-                    return ResponseFactory.error('Missing required argument: assetPath or materialPath', 'MISSING_ASSET_PATH');
+                    return ResponseFactory.error('manage_material_authoring.add_material_node: missing required argument assetPath', 'MISSING_ASSET_PATH');
                 }
                 if (!nodeType) {
-                    return ResponseFactory.error('Missing required argument: nodeType', 'MISSING_NODE_TYPE');
+                    return ResponseFactory.error('manage_material_authoring.add_material_node: missing required argument nodeType', 'MISSING_NODE_TYPE');
                 }
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'add_material_node',
@@ -733,7 +1067,14 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 if (res.success === false) {
                     return ResponseFactory.error(res.error ?? 'Failed to add material node', res.errorCode);
                 }
-                return ResponseFactory.success(res, res.message ?? `Material node '${nodeType}' added`);
+                const response = ResponseFactory.success(res, res.message ?? `Material node '${nodeType}' added`);
+                const result = res.result;
+                if (result && typeof result === 'object' && !Array.isArray(result)) {
+                    const nodeId = result.nodeId;
+                    if (typeof nodeId === 'string')
+                        response.nodeId = nodeId;
+                }
+                return response;
             }
             case 'rebuild_material':
                 return handleMaterialAuthoringTools('compile_material', args, tools);
@@ -747,13 +1088,13 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 const save = extractOptionalBoolean(rawArgs, 'save') ?? true;
                 const value = rawArgs.value;
                 if (!assetPath) {
-                    return ResponseFactory.error('Missing required argument: assetPath (or instancePath, materialPath)', 'MISSING_ASSET_PATH');
+                    return ResponseFactory.error('manage_material_authoring.set_material_parameter: missing required argument assetPath', 'MISSING_ASSET_PATH');
                 }
                 if (!parameterName) {
-                    return ResponseFactory.error('Missing required argument: parameterName', 'MISSING_PARAMETER_NAME');
+                    return ResponseFactory.error('manage_material_authoring.set_material_parameter: missing required argument parameterName', 'MISSING_PARAMETER_NAME');
                 }
                 if (value === undefined) {
-                    return ResponseFactory.error('Missing required argument: value', 'MISSING_VALUE');
+                    return ResponseFactory.error('manage_material_authoring.set_material_parameter: missing required argument value', 'MISSING_VALUE');
                 }
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'set_material_parameter',
@@ -774,10 +1115,10 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     extractOptionalString(rawArgs, 'materialPath') ?? '';
                 const nodeId = extractOptionalString(rawArgs, 'nodeId') ?? '';
                 if (!assetPath) {
-                    return ResponseFactory.error('Missing required argument: assetPath or materialPath', 'MISSING_ASSET_PATH');
+                    return ResponseFactory.error('manage_material_authoring.get_material_node_details: missing required argument assetPath', 'MISSING_ASSET_PATH');
                 }
                 if (!nodeId) {
-                    return ResponseFactory.error('Missing required argument: nodeId', 'MISSING_NODE_ID');
+                    return ResponseFactory.error('manage_material_authoring.get_material_node_details: missing required argument nodeId', 'MISSING_NODE_ID');
                 }
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'get_material_node_details',
@@ -795,10 +1136,10 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                     extractOptionalString(rawArgs, 'materialPath') ?? '';
                 const nodeId = extractOptionalString(rawArgs, 'nodeId') ?? '';
                 if (!assetPath) {
-                    return ResponseFactory.error('Missing required argument: assetPath or materialPath', 'MISSING_ASSET_PATH');
+                    return ResponseFactory.error('manage_material_authoring.remove_material_node: missing required argument assetPath', 'MISSING_ASSET_PATH');
                 }
                 if (!nodeId) {
-                    return ResponseFactory.error('Missing required argument: nodeId', 'MISSING_NODE_ID');
+                    return ResponseFactory.error('manage_material_authoring.remove_material_node: missing required argument nodeId', 'MISSING_NODE_ID');
                 }
                 const res = (await executeAutomationRequest(tools, TOOL_ACTIONS.MANAGE_MATERIAL_AUTHORING, {
                     subAction: 'remove_material_node',
@@ -851,7 +1192,7 @@ export async function handleMaterialAuthoringTools(action, args, tools) {
                 return ResponseFactory.success(res, res.message ?? `Cast shadows set to ${castShadows}`);
             }
             default:
-                return ResponseFactory.error(`Unknown material authoring action: ${action}. Available actions: create_material, set_blend_mode, set_shading_model, add_texture_sample, add_scalar_parameter, add_vector_parameter, add_math_node, connect_nodes, create_material_instance, set_scalar_parameter_value, set_vector_parameter_value, set_texture_parameter_value, compile_material, get_material_info`, 'UNKNOWN_ACTION');
+                return ResponseFactory.error(`Unknown material authoring action: ${action}. Available actions: ${MATERIAL_AUTHORING_ACTIONS.join(', ')}`, 'UNKNOWN_ACTION');
         }
     }
     catch (error) {