snow-flow 10.0.1-dev.435 → 10.0.1-dev.439

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.435",
+  "version": "10.0.1-dev.439",
   "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

@@ -62,36 +62,63 @@ async function addTriggerViaGraphQL(
 ): Promise<{ success: boolean; triggerId?: string; steps?: any; error?: string }> {
   const steps: any = {};
 
-  const triggerMap: Record<string, { type: string; name: string; triggerType: string }> = {
-    'record_created': { type: 'record_create', name: 'Created', triggerType: 'Record' },
-    'record_updated': { type: 'record_update', name: 'Updated', triggerType: 'Record' },
-    'record_create_or_update': { type: 'record_create_or_update', name: 'Created or Updated', triggerType: 'Record' },
-    'scheduled': { type: 'scheduled', name: 'Scheduled', triggerType: 'Scheduled' },
+  // Dynamically look up trigger definition in sys_hub_trigger_definition
+  let trigDefId: string | null = null;
+  let trigName = '';
+  let trigType = triggerType;
+  let trigCategory = '';
+
+  // Build search variations: record_updated → also try record_update, and vice versa
+  const variations = [triggerType];
+  if (triggerType.endsWith('ed')) variations.push(triggerType.slice(0, -1), triggerType.slice(0, -2));
+  else if (triggerType.endsWith('e')) variations.push(triggerType + 'd');
+  else variations.push(triggerType + 'ed', triggerType + 'd');
+
+  const assignFound = (found: any, matched: string) => {
+    trigDefId = found.sys_id;
+    trigName = found.name || triggerType;
+    trigType = found.type || triggerType;
+    trigCategory = found.category || '';
+    steps.def_lookup = { id: found.sys_id, type: found.type, name: found.name, category: found.category, matched };
   };
 
-  const config = triggerMap[triggerType] || triggerMap['record_create_or_update'];
-
-  // Trigger definitions live in sys_hub_trigger_definition, keyed by `type` field
-  let trigDefId: string | null = null;
-  try {
-    const resp = await client.get('/api/now/table/sys_hub_trigger_definition', {
-      params: { sysparm_query: 'type=' + config.type, sysparm_fields: 'sys_id,type,name', sysparm_limit: 1 }
-    });
-    trigDefId = resp.data.result?.[0]?.sys_id || null;
-    steps.def_lookup_primary = resp.data.result?.[0] || null;
-  } catch (_) {}
-  // Fallback: search by name
+  // Try exact match on type and name for each variation
+  for (const variant of variations) {
+    if (trigDefId) break;
+    for (const field of ['type', 'name']) {
+      if (trigDefId) break;
+      try {
+        const resp = await client.get('/api/now/table/sys_hub_trigger_definition', {
+          params: {
+            sysparm_query: field + '=' + variant,
+            sysparm_fields: 'sys_id,type,name,category',
+            sysparm_display_value: 'true',
+            sysparm_limit: 1
+          }
+        });
+        const found = resp.data.result?.[0];
+        if (found?.sys_id) assignFound(found, field + '=' + variant);
+      } catch (_) {}
+    }
+  }
+  // Fallback: LIKE search using shortest variation (most likely to match)
   if (!trigDefId) {
+    const shortest = variations.reduce((a, b) => a.length <= b.length ? a : b);
     try {
       const resp = await client.get('/api/now/table/sys_hub_trigger_definition', {
-        params: { sysparm_query: 'name=' + config.name, sysparm_fields: 'sys_id,type,name', sysparm_limit: 1 }
+        params: {
+          sysparm_query: 'typeLIKE' + shortest + '^ORnameLIKE' + shortest,
+          sysparm_fields: 'sys_id,type,name,category',
+          sysparm_display_value: 'true',
+          sysparm_limit: 5
+        }
       });
-      trigDefId = resp.data.result?.[0]?.sys_id || null;
-      steps.def_lookup_fallback = resp.data.result?.[0] || null;
+      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, category: r.category }));
+      if (results[0]?.sys_id) assignFound(results[0], 'LIKE ' + shortest);
     } catch (_) {}
   }
   if (!trigDefId) return { success: false, error: 'Trigger definition not found for: ' + triggerType, steps };
-  steps.def_lookup = { id: trigDefId };
 
   const triggerResponseFields = 'triggerInstances { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
   try {
@@ -100,10 +127,10 @@ async function addTriggerViaGraphQL(
       triggerInstances: {
         insert: [{
           flowSysId: flowId,
-          name: config.name,
-          triggerType: config.triggerType,
+          name: trigName,
+          triggerType: trigCategory,
           triggerDefinitionId: trigDefId,
-          type: config.type,
+          type: trigType,
           hasDynamicOutputs: false,
           metadata: '{"predicates":[]}',
           inputs: [],
@@ -157,35 +184,26 @@ async function addActionViaGraphQL(
 ): Promise<{ success: boolean; actionId?: string; steps?: any; error?: string }> {
   const steps: any = {};
 
-  const actionTypeNames: Record<string, string[]> = {
-    'log': ['sn_fd.action.log', 'global.sn_fd.action.log', 'global.log'],
-    'create_record': ['sn_fd.action.create_record', 'global.sn_fd.action.create_record'],
-    'update_record': ['sn_fd.action.update_record', 'global.sn_fd.action.update_record'],
-    'notification': ['sn_fd.action.send_notification', 'global.sn_fd.action.send_notification'],
-    'script': ['sn_fd.action.script', 'global.sn_fd.action.script', 'global.script_action'],
-    'field_update': ['sn_fd.action.field_update', 'global.sn_fd.action.field_update'],
-    'wait': ['sn_fd.action.wait', 'global.sn_fd.action.wait'],
-    'approval': ['sn_fd.action.create_approval', 'global.sn_fd.action.create_approval'],
-  };
-
+  // Dynamically look up action definition in sys_hub_action_type_snapshot
   let actionDefId: string | null = null;
-  const candidates = actionTypeNames[actionType] || [];
-  for (const name of candidates) {
+  // Try exact match on internal_name first, then name
+  for (const field of ['internal_name', 'name']) {
+    if (actionDefId) break;
     try {
-      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
-        params: { sysparm_query: 'internal_name=' + name, sysparm_fields: 'sys_id,internal_name,name', sysparm_limit: 1 }
+      const resp = await client.get('/api/now/table/sys_hub_action_type_snapshot', {
+        params: { sysparm_query: field + '=' + actionType, sysparm_fields: 'sys_id,internal_name,name', sysparm_limit: 1 }
       });
       const found = resp.data.result?.[0];
       if (found?.sys_id) {
         actionDefId = found.sys_id;
-        steps.def_lookup = { id: found.sys_id, internal_name: found.internal_name, name: found.name, matched_query: name };
-        break;
+        steps.def_lookup = { id: found.sys_id, internal_name: found.internal_name, name: found.name, matched: field + '=' + actionType };
       }
     } catch (_) {}
   }
+  // Fallback: LIKE search on both fields
   if (!actionDefId) {
     try {
-      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+      const resp = await client.get('/api/now/table/sys_hub_action_type_snapshot', {
         params: {
           sysparm_query: 'internal_nameLIKE' + actionType + '^ORnameLIKE' + actionType,
           sysparm_fields: 'sys_id,internal_name,name', sysparm_limit: 5
@@ -193,8 +211,10 @@ async function addActionViaGraphQL(
       });
       const results = resp.data.result || [];
       steps.def_lookup_fallback_candidates = results.map((r: any) => ({ sys_id: r.sys_id, internal_name: r.internal_name, name: r.name }));
-      actionDefId = results[0]?.sys_id || null;
-      if (actionDefId) steps.def_lookup = { id: actionDefId, internal_name: results[0].internal_name, name: results[0].name, matched_query: 'LIKE ' + actionType };
+      if (results[0]?.sys_id) {
+        actionDefId = results[0].sys_id;
+        steps.def_lookup = { id: results[0].sys_id, internal_name: results[0].internal_name, name: results[0].name, matched: 'LIKE ' + actionType };
+      }
     } catch (_) {}
   }
   if (!actionDefId) return { success: false, error: 'Action definition not found for: ' + actionType, steps };