snow-flow-test 10.0.1-test.159 → 10.0.1-test.161

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-test.159",
+  "version": "10.0.1-test.161",
   "name": "snow-flow-test",
   "description": "Snow-Flow Test - ServiceNow Multi-Agent Development Framework",
   "license": "Elastic-2.0",

package/src/servicenow/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.ts

@@ -413,6 +413,169 @@ async function addFlowLogicViaGraphQL(
   }
 }
 
+// ── SUBFLOW CALL (invoke a subflow as a step) ────────────────────────
+
+async function addSubflowCallViaGraphQL(
+  client: any,
+  flowId: string,
+  subflowId: string,
+  inputs?: Record<string, string>,
+  order?: number,
+  parentUiId?: string
+): Promise<{ success: boolean; callId?: string; steps?: any; error?: string }> {
+  const steps: any = {};
+
+  // Resolve subflow: look up by sys_id, name, or internal_name in sys_hub_flow
+  let subflowSysId = isSysId(subflowId) ? subflowId : null;
+  let subflowName = '';
+  if (!subflowSysId) {
+    for (const field of ['name', 'internal_name']) {
+      if (subflowSysId) break;
+      try {
+        const resp = await client.get('/api/now/table/sys_hub_flow', {
+          params: {
+            sysparm_query: field + '=' + subflowId + '^type=subflow',
+            sysparm_fields: 'sys_id,name,internal_name',
+            sysparm_limit: 1
+          }
+        });
+        const found = resp.data.result?.[0];
+        if (found?.sys_id) {
+          subflowSysId = found.sys_id;
+          subflowName = found.name || subflowId;
+          steps.subflow_lookup = { id: found.sys_id, name: found.name, internal_name: found.internal_name, matched: field + '=' + subflowId };
+        }
+      } catch (_) {}
+    }
+    // LIKE fallback
+    if (!subflowSysId) {
+      try {
+        const resp = await client.get('/api/now/table/sys_hub_flow', {
+          params: {
+            sysparm_query: 'nameLIKE' + subflowId + '^type=subflow',
+            sysparm_fields: 'sys_id,name,internal_name',
+            sysparm_limit: 5
+          }
+        });
+        const results = resp.data.result || [];
+        steps.subflow_lookup_candidates = results.map((r: any) => ({ sys_id: r.sys_id, name: r.name, internal_name: r.internal_name }));
+        if (results[0]?.sys_id) {
+          subflowSysId = results[0].sys_id;
+          subflowName = results[0].name || subflowId;
+          steps.subflow_lookup = { id: results[0].sys_id, name: results[0].name, matched: 'LIKE ' + subflowId };
+        }
+      } catch (_) {}
+    }
+  }
+  if (!subflowSysId) return { success: false, error: 'Subflow not found: ' + subflowId, steps };
+
+  if (!subflowName) subflowName = subflowId;
+
+  const uuid = generateUUID();
+  const subflowResponseFields = 'subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
+  try {
+    const result = await executeFlowPatchMutation(client, {
+      flowId: flowId,
+      subflows: {
+        insert: [{
+          metadata: '{"predicates":[]}',
+          flowSysId: flowId,
+          generationSource: '',
+          name: subflowName,
+          order: String(order || 1),
+          parent: parentUiId || '',
+          subflowSysId: subflowSysId,
+          uiUniqueIdentifier: uuid,
+          type: 'subflow',
+          parentUiId: parentUiId || '',
+          inputs: []
+        }]
+      }
+    }, subflowResponseFields);
+
+    const callId = result?.subflows?.inserts?.[0]?.sysId;
+    steps.insert = { success: !!callId, callId, uuid };
+    if (!callId) return { success: false, steps, error: 'GraphQL subflow INSERT returned no ID' };
+
+    // Update with input values if provided
+    if (inputs && Object.keys(inputs).length > 0) {
+      const updateInputs = Object.entries(inputs).map(([name, value]) => ({
+        name,
+        value: { schemaless: false, schemalessValue: '', value: String(value) }
+      }));
+      try {
+        await executeFlowPatchMutation(client, {
+          flowId: flowId,
+          subflows: { update: [{ uiUniqueIdentifier: uuid, type: 'subflow', inputs: updateInputs }] }
+        }, subflowResponseFields);
+        steps.value_update = { success: true, inputs: updateInputs.map(i => i.name) };
+      } catch (e: any) {
+        steps.value_update = { success: false, error: e.message };
+      }
+    }
+
+    return { success: true, callId, steps };
+  } catch (e: any) {
+    steps.insert = { success: false, error: e.message };
+    return { success: false, steps, error: 'GraphQL subflow INSERT failed: ' + e.message };
+  }
+}
+
+// ── GENERIC UPDATE/DELETE for any flow element ───────────────────────
+
+const elementGraphQLMap: Record<string, { key: string; type: string; responseFields: string }> = {
+  action:     { key: 'actions',           type: 'action',    responseFields: 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  trigger:    { key: 'triggerInstances',  type: 'trigger',   responseFields: 'triggerInstances { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  flowlogic:  { key: 'flowLogics',        type: 'flowlogic', responseFields: 'flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  subflow:    { key: 'subflows',          type: 'subflow',   responseFields: 'subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+};
+
+async function updateElementViaGraphQL(
+  client: any,
+  flowId: string,
+  elementType: string,
+  elementId: string,
+  inputs: Record<string, string>
+): Promise<{ success: boolean; steps?: any; error?: string }> {
+  const config = elementGraphQLMap[elementType];
+  if (!config) return { success: false, error: 'Unknown element type: ' + elementType };
+
+  const updateInputs = Object.entries(inputs).map(([name, value]) => ({
+    name,
+    value: { schemaless: false, schemalessValue: '', value: String(value) }
+  }));
+
+  try {
+    await executeFlowPatchMutation(client, {
+      flowId,
+      [config.key]: { update: [{ uiUniqueIdentifier: elementId, type: config.type, inputs: updateInputs }] }
+    }, config.responseFields);
+    return { success: true, steps: { element: elementId, type: elementType, inputs: updateInputs.map(i => i.name) } };
+  } catch (e: any) {
+    return { success: false, error: e.message, steps: { element: elementId, type: elementType } };
+  }
+}
+
+async function deleteElementViaGraphQL(
+  client: any,
+  flowId: string,
+  elementType: string,
+  elementIds: string[]
+): Promise<{ success: boolean; steps?: any; error?: string }> {
+  const config = elementGraphQLMap[elementType];
+  if (!config) return { success: false, error: 'Unknown element type: ' + elementType };
+
+  try {
+    await executeFlowPatchMutation(client, {
+      flowId,
+      [config.key]: { delete: elementIds }
+    }, config.responseFields);
+    return { success: true, steps: { deleted: elementIds, type: elementType } };
+  } catch (e: any) {
+    return { success: false, error: e.message, steps: { elementIds, type: elementType } };
+  }
+}
+
 async function createFlowViaProcessFlowAPI(
   client: any,
   params: {
@@ -521,8 +684,14 @@ export const toolDefinition: MCPToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish', 'add_trigger', 'update_trigger', 'add_action', 'add_flow_logic'],
-        description: 'Action to perform. Use add_trigger/add_action/add_flow_logic to add elements, update_trigger to change an existing trigger. Flow logic types: IF, FOR_EACH, DO_UNTIL, SWITCH.'
+        enum: [
+          'create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish',
+          'add_trigger', 'update_trigger', 'delete_trigger',
+          'add_action', 'update_action', 'delete_action',
+          'add_flow_logic', 'update_flow_logic', 'delete_flow_logic',
+          'add_subflow', 'update_subflow', 'delete_subflow'
+        ],
+        description: 'Action to perform. add_*/update_*/delete_* for triggers, actions, flow_logic, subflows. update_trigger replaces the trigger type. update_action/update_flow_logic/update_subflow change input values. delete_* removes elements by element_id.'
       },
 
       flow_id: {
@@ -618,7 +787,15 @@ export const toolDefinition: MCPToolDefinition = {
       },
       parent_ui_id: {
         type: 'string',
-        description: 'Parent UI unique identifier for nesting flow logic blocks (e.g. placing actions inside an If block)'
+        description: 'Parent UI unique identifier for nesting elements inside flow logic blocks (e.g. placing actions/subflows inside an If block)'
+      },
+      subflow_id: {
+        type: 'string',
+        description: 'Subflow sys_id or name to call as a step (for add_subflow action). Looked up in sys_hub_flow where type=subflow.'
+      },
+      element_id: {
+        type: 'string',
+        description: 'Element sys_id or uiUniqueIdentifier for update_*/delete_* actions. For delete_* this can also be a comma-separated list of IDs.'
       },
       type: {
         type: 'string',
@@ -1592,6 +1769,96 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           : createErrorResult(addLogicResult.error || 'Failed to add flow logic');
       }
 
+      // ────────────────────────────────────────────────────────────────
+      // ADD_SUBFLOW — call an existing subflow as a step in the flow
+      // ────────────────────────────────────────────────────────────────
+      case 'add_subflow': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for add_subflow');
+        }
+        if (!args.subflow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'subflow_id is required for add_subflow (sys_id or name of the subflow to call)');
+        }
+        var addSubFlowId = await resolveFlowId(client, args.flow_id);
+        var addSubSubflowId = args.subflow_id;
+        var addSubInputs = args.action_inputs || args.inputs || {};
+        var addSubOrder = args.order;
+        var addSubParentUiId = args.parent_ui_id || '';
+
+        var addSubResult = await addSubflowCallViaGraphQL(client, addSubFlowId, addSubSubflowId, addSubInputs, addSubOrder, addSubParentUiId);
+
+        var addSubSummary = summary();
+        if (addSubResult.success) {
+          addSubSummary
+            .success('Subflow call added via GraphQL')
+            .field('Flow', addSubFlowId)
+            .field('Subflow', addSubSubflowId)
+            .field('Call ID', addSubResult.callId || 'unknown');
+        } else {
+          addSubSummary.error('Failed to add subflow call: ' + (addSubResult.error || 'unknown'));
+        }
+
+        return addSubResult.success
+          ? createSuccessResult({ action: 'add_subflow', ...addSubResult }, {}, addSubSummary.build())
+          : createErrorResult(addSubResult.error || 'Failed to add subflow call');
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // UPDATE_ACTION / UPDATE_FLOW_LOGIC / UPDATE_SUBFLOW
+      // ────────────────────────────────────────────────────────────────
+      case 'update_action':
+      case 'update_flow_logic':
+      case 'update_subflow': {
+        if (!args.flow_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required');
+        if (!args.element_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'element_id is required (sys_id or uiUniqueIdentifier of the element)');
+        var updElemFlowId = await resolveFlowId(client, args.flow_id);
+        var updElemType = action === 'update_action' ? 'action' : action === 'update_flow_logic' ? 'flowlogic' : 'subflow';
+        var updElemInputs = args.action_inputs || args.logic_inputs || args.inputs || {};
+
+        var updElemResult = await updateElementViaGraphQL(client, updElemFlowId, updElemType, args.element_id, updElemInputs);
+
+        var updElemSummary = summary();
+        if (updElemResult.success) {
+          updElemSummary.success('Element updated').field('Type', updElemType).field('Element', args.element_id);
+        } else {
+          updElemSummary.error('Failed to update element: ' + (updElemResult.error || 'unknown'));
+        }
+        return updElemResult.success
+          ? createSuccessResult({ action, ...updElemResult }, {}, updElemSummary.build())
+          : createErrorResult(updElemResult.error || 'Failed to update element');
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // DELETE_ACTION / DELETE_FLOW_LOGIC / DELETE_SUBFLOW / DELETE_TRIGGER
+      // ────────────────────────────────────────────────────────────────
+      case 'delete_action':
+      case 'delete_flow_logic':
+      case 'delete_subflow':
+      case 'delete_trigger': {
+        if (!args.flow_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required');
+        if (!args.element_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'element_id is required (sys_id(s) to delete, comma-separated for multiple)');
+        var delElemFlowId = await resolveFlowId(client, args.flow_id);
+        var delElemType = action === 'delete_action' ? 'action'
+          : action === 'delete_flow_logic' ? 'flowlogic'
+          : action === 'delete_subflow' ? 'subflow'
+          : 'trigger';
+        var delElemIds = String(args.element_id).split(',').map((id: string) => id.trim());
+
+        // Map 'trigger' to the correct GraphQL key
+        var delGraphQLType = delElemType === 'trigger' ? 'trigger' : delElemType;
+        var delResult = await deleteElementViaGraphQL(client, delElemFlowId, delGraphQLType, delElemIds);
+
+        var delSummary = summary();
+        if (delResult.success) {
+          delSummary.success('Element(s) deleted').field('Type', delElemType).field('Deleted', delElemIds.join(', '));
+        } else {
+          delSummary.error('Failed to delete element: ' + (delResult.error || 'unknown'));
+        }
+        return delResult.success
+          ? createSuccessResult({ action, ...delResult }, {}, delSummary.build())
+          : createErrorResult(delResult.error || 'Failed to delete element');
+      }
+
       default:
         throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'Unknown action: ' + action);
     }