snow-flow 10.0.1-dev.443 → 10.0.1-dev.445

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.443",
+  "version": "10.0.1-dev.445",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

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

@@ -311,6 +311,216 @@ async function addActionViaGraphQL(
   }
 }
 
+// ── FLOW LOGIC (If/Else, For Each, etc.) ─────────────────────────────
+
+async function addFlowLogicViaGraphQL(
+  client: any,
+  flowId: string,
+  logicType: string,
+  inputs?: Record<string, string>,
+  order?: number,
+  parentUiId?: string
+): Promise<{ success: boolean; logicId?: string; steps?: any; error?: string }> {
+  const steps: any = {};
+
+  // Dynamically look up flow logic definition in sys_hub_flow_logic_definition
+  let defId: string | null = null;
+  let defName = '';
+  let defType = logicType;
+  // Try exact match on type (IF, FOR_EACH, DO_UNTIL, SWITCH), then name
+  for (const field of ['type', 'name']) {
+    if (defId) break;
+    try {
+      const resp = await client.get('/api/now/table/sys_hub_flow_logic_definition', {
+        params: { sysparm_query: field + '=' + logicType, sysparm_fields: 'sys_id,type,name,description', sysparm_limit: 1 }
+      });
+      const found = resp.data.result?.[0];
+      if (found?.sys_id) {
+        defId = found.sys_id;
+        defName = found.name || logicType;
+        defType = found.type || logicType;
+        steps.def_lookup = { id: found.sys_id, type: found.type, name: found.name, matched: field + '=' + logicType };
+      }
+    } catch (_) {}
+  }
+  // Fallback: LIKE search
+  if (!defId) {
+    try {
+      const resp = await client.get('/api/now/table/sys_hub_flow_logic_definition', {
+        params: {
+          sysparm_query: 'typeLIKE' + logicType + '^ORnameLIKE' + logicType,
+          sysparm_fields: 'sys_id,type,name,description', sysparm_limit: 5
+        }
+      });
+      const results = resp.data.result || [];
+      steps.def_lookup_fallback_candidates = results.map((r: any) => ({ sys_id: r.sys_id, type: r.type, name: r.name }));
+      if (results[0]?.sys_id) {
+        defId = results[0].sys_id;
+        defName = results[0].name || logicType;
+        defType = results[0].type || logicType;
+        steps.def_lookup = { id: results[0].sys_id, type: results[0].type, name: results[0].name, matched: 'LIKE ' + logicType };
+      }
+    } catch (_) {}
+  }
+  if (!defId) return { success: false, error: 'Flow logic definition not found for: ' + logicType, steps };
+
+  const uuid = generateUUID();
+  const logicResponseFields = 'flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
+  try {
+    const result = await executeFlowPatchMutation(client, {
+      flowId: flowId,
+      flowLogics: {
+        insert: [{
+          order: String(order || 1),
+          uiUniqueIdentifier: uuid,
+          parent: '',
+          metadata: '{"predicates":[]}',
+          flowSysId: flowId,
+          generationSource: '',
+          definitionId: defId,
+          type: 'flowlogic',
+          parentUiId: parentUiId || '',
+          inputs: []
+        }]
+      }
+    }, logicResponseFields);
+
+    const logicId = result?.flowLogics?.inserts?.[0]?.sysId;
+    steps.insert = { success: !!logicId, logicId, uuid };
+    if (!logicId) return { success: false, steps, error: 'GraphQL flow logic 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,
+          flowLogics: { update: [{ uiUniqueIdentifier: uuid, type: 'flowlogic', inputs: updateInputs }] }
+        }, logicResponseFields);
+        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, logicId, steps };
+  } catch (e: any) {
+    steps.insert = { success: false, error: e.message };
+    return { success: false, steps, error: 'GraphQL flow logic INSERT failed: ' + e.message };
+  }
+}
+
+// ── 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 };
+  }
+}
+
 async function createFlowViaProcessFlowAPI(
   client: any,
   params: {
@@ -419,8 +629,8 @@ 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'],
-        description: 'Action to perform. Use add_trigger/add_action to add new elements, update_trigger to change an existing trigger type/table/condition.'
+        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish', 'add_trigger', 'update_trigger', 'add_action', 'add_flow_logic', 'add_subflow'],
+        description: 'Action to perform. Use add_trigger/add_action/add_flow_logic/add_subflow to add elements, update_trigger to change an existing trigger. Flow logic types: IF, FOR_EACH, DO_UNTIL, SWITCH. add_subflow calls an existing subflow as a step.'
       },
 
       flow_id: {
@@ -506,6 +716,22 @@ export const toolDefinition: MCPToolDefinition = {
         description: 'Activate flow after creation (default: true)',
         default: true
       },
+      logic_type: {
+        type: 'string',
+        description: 'Flow logic type for add_flow_logic. Looked up dynamically in sys_hub_flow_logic_definition. Common values: IF, FOR_EACH, DO_UNTIL, SWITCH'
+      },
+      logic_inputs: {
+        type: 'object',
+        description: 'Input values for the flow logic block (e.g. {condition: "expression", condition_name: "My Condition"})'
+      },
+      parent_ui_id: {
+        type: 'string',
+        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.'
+      },
       type: {
         type: 'string',
         enum: ['flow', 'subflow', 'all'],
@@ -1444,6 +1670,74 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           : createErrorResult(addActResult.error || 'Failed to add action');
       }
 
+      // ────────────────────────────────────────────────────────────────
+      // ADD_FLOW_LOGIC — add If/Else, For Each, Do Until, Switch blocks
+      // ────────────────────────────────────────────────────────────────
+      case 'add_flow_logic': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for add_flow_logic');
+        }
+        if (!args.logic_type) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'logic_type is required for add_flow_logic (e.g. IF, FOR_EACH, DO_UNTIL, SWITCH)');
+        }
+        var addLogicFlowId = await resolveFlowId(client, args.flow_id);
+        var addLogicType = args.logic_type;
+        var addLogicInputs = args.logic_inputs || {};
+        var addLogicOrder = args.order;
+        var addLogicParentUiId = args.parent_ui_id || '';
+
+        var addLogicResult = await addFlowLogicViaGraphQL(client, addLogicFlowId, addLogicType, addLogicInputs, addLogicOrder, addLogicParentUiId);
+
+        var addLogicSummary = summary();
+        if (addLogicResult.success) {
+          addLogicSummary
+            .success('Flow logic added via GraphQL')
+            .field('Flow', addLogicFlowId)
+            .field('Type', addLogicType)
+            .field('Logic ID', addLogicResult.logicId || 'unknown');
+        } else {
+          addLogicSummary.error('Failed to add flow logic: ' + (addLogicResult.error || 'unknown'));
+        }
+
+        return addLogicResult.success
+          ? createSuccessResult({ action: 'add_flow_logic', ...addLogicResult }, {}, addLogicSummary.build())
+          : 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');
+      }
+
       default:
         throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'Unknown action: ' + action);
     }