snow-flow 10.0.1-dev.467 → 10.0.1-dev.469

package/package.json

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

@@ -1009,12 +1009,30 @@ async function addActionViaGraphQL(
     inputResult.actionParams, uuid
   );
   steps.record_action = recordActionResult.steps;
+  var hasRecordPills = recordActionResult.labelCacheEntries.length > 0;
+
+  // For record actions: clear data pill values from INSERT — they'll be set via separate UPDATE
+  // (Flow Designer's GraphQL API ignores labelCache during INSERT, it only works with UPDATE)
+  var insertInputs = recordActionResult.inputs;
+  if (hasRecordPills) {
+    // Clone inputs and clear data pill values for INSERT
+    insertInputs = recordActionResult.inputs.map(function (inp: any) {
+      if (inp.name === 'record' && inp.value?.value?.startsWith('{{')) {
+        return { ...inp, value: { schemaless: false, schemalessValue: '', value: '' } };
+      }
+      if (inp.name === 'values' && inp.value?.value?.includes('{{')) {
+        return { ...inp, value: { schemaless: false, schemalessValue: '', value: '' } };
+      }
+      return inp;
+    });
+    steps.record_action_strategy = 'two_step';
+  }
 
   const actionResponseFields = 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' +
     ' subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
 
-  // Build mutation payload — single INSERT with full inputs (matching UI behavior)
+  // Build mutation payload — INSERT with inputs (data pill values cleared for record actions)
   const flowPatch: any = {
     flowId: flowId,
     actions: {
@@ -1028,25 +1046,62 @@ async function addActionViaGraphQL(
         uiUniqueIdentifier: uuid,
         type: 'action',
         parentUiId: parentUiId || '',
-        inputs: recordActionResult.inputs
+        inputs: insertInputs
       }]
     }
   };
 
-  // Add labelCache entries for data pill references in record actions
-  if (recordActionResult.labelCacheEntries.length > 0) {
-    flowPatch.labelCache = { insert: recordActionResult.labelCacheEntries };
-  }
-
   // Add parent flow logic update signal (tells GraphQL the parent was modified)
   if (parentUiId) {
     flowPatch.flowLogics = { update: [{ uiUniqueIdentifier: parentUiId, type: 'flowlogic' }] };
   }
 
   try {
+    // Step 1: INSERT the action element
     const result = await executeFlowPatchMutation(client, flowPatch, actionResponseFields);
     const actionId = result?.actions?.inserts?.[0]?.sysId;
     steps.insert = { success: !!actionId, actionId, uuid };
+    if (!actionId) return { success: false, steps, error: 'GraphQL action INSERT returned no ID' };
+
+    // Step 2: UPDATE with data pill values + labelCache (separate mutation, matching UI behavior)
+    // The Flow Designer UI always sets data pill references via a separate UPDATE.
+    if (hasRecordPills) {
+      var updateInputs: any[] = [];
+      // Collect all inputs that have data pill values
+      for (var ri = 0; ri < recordActionResult.inputs.length; ri++) {
+        var inp = recordActionResult.inputs[ri];
+        var val = inp.value?.value || '';
+        if (inp.name === 'record' && val.startsWith('{{')) {
+          updateInputs.push({ name: 'record', value: { schemaless: false, schemalessValue: '', value: val } });
+        } else if (inp.name === 'table_name') {
+          updateInputs.push({ name: 'table_name', displayValue: inp.displayValue || { value: '' }, value: inp.value || { value: '' } });
+        } else if (inp.name === 'values' && val) {
+          updateInputs.push({ name: 'values', value: { schemaless: false, schemalessValue: '', value: val } });
+        }
+      }
+
+      if (updateInputs.length > 0) {
+        try {
+          var updatePatch: any = {
+            flowId: flowId,
+            labelCache: { insert: recordActionResult.labelCacheEntries },
+            actions: {
+              update: [{
+                uiUniqueIdentifier: uuid,
+                type: 'action',
+                inputs: updateInputs
+              }]
+            }
+          };
+          await executeFlowPatchMutation(client, updatePatch, actionResponseFields);
+          steps.record_update = { success: true, inputCount: updateInputs.length };
+        } catch (ue: any) {
+          steps.record_update = { success: false, error: ue.message };
+          // Action was created — update failure is non-fatal
+        }
+      }
+    }
+
     return { success: true, actionId: actionId || undefined, steps };
   } catch (e: any) {
     steps.insert = { success: false, error: e.message };
@@ -1268,58 +1323,81 @@ function transformConditionToDataPills(conditionValue: string, dataPillBase: str
  * Build labelCache entries for field-level data pills used in flow logic conditions.
  *
  * Each field referenced in the condition needs a labelCache entry so the Flow Designer UI
- * can display the data pill correctly. Also registers the record-level parent pill.
+ * can display the data pill correctly. Queries sys_dictionary for actual field types/labels.
+ *
+ * The UI only sends field-level pills (NOT a record-level parent pill).
+ * Each entry includes parent_table_name and column_name for the UI to resolve the field.
  *
- * Example for "category=software":
- * - Record pill: { name: "Created or Updated_1.current", type: "reference", reference: "incident" }
- * - Field pill: { name: "Created or Updated_1.current.category", type: "string" }
+ * Example for "category=inquiry" on incident table:
+ * - { name: "Created or Updated_1.current.category", type: "choice", parent_table_name: "incident", column_name: "category" }
  */
-function buildConditionLabelCache(
+async function buildConditionLabelCache(
+  client: any,
   conditionValue: string,
   dataPillBase: string,
   triggerName: string,
   table: string,
   tableLabel: string,
   logicUiId: string
-): any[] {
+): Promise<any[]> {
   if (!dataPillBase) return [];
 
   var clauses = parseEncodedQuery(conditionValue);
-  var entries: any[] = [];
-  var seen: Record<string, boolean> = {};
-
-  // Register the record-level parent pill (always needed as context)
-  entries.push({
-    name: dataPillBase,
-    label: 'Trigger - Record ' + triggerName + '\u27a1' + tableLabel + ' Record',
-    reference: table,
-    reference_display: tableLabel,
-    type: 'reference',
-    base_type: 'reference',
-    attributes: '',
-    usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }],
-    choices: {}
-  });
-  seen[dataPillBase] = true;
+  if (clauses.length === 0) return [];
 
-  // Register each field-level pill
+  // Collect unique field names
+  var uniqueFields: string[] = [];
+  var seen: Record<string, boolean> = {};
   for (var i = 0; i < clauses.length; i++) {
     var field = clauses[i].field;
-    if (!field) continue;
-    var pillName = dataPillBase + '.' + field;
-    if (seen[pillName]) continue;
-    seen[pillName] = true;
+    if (field && !seen[field]) {
+      seen[field] = true;
+      uniqueFields.push(field);
+    }
+  }
+  if (uniqueFields.length === 0) return [];
 
-    var fieldLabel = field.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); });
+  // Batch-query sys_dictionary for field metadata (type, label)
+  var fieldMeta: Record<string, { type: string; label: string }> = {};
+  try {
+    var dictResp = await client.get('/api/now/table/sys_dictionary', {
+      params: {
+        sysparm_query: 'name=' + table + '^elementIN' + uniqueFields.join(','),
+        sysparm_fields: 'element,column_label,internal_type',
+        sysparm_display_value: 'false',
+        sysparm_limit: uniqueFields.length + 5
+      }
+    });
+    var dictResults = dictResp.data.result || [];
+    for (var d = 0; d < dictResults.length; d++) {
+      var rec = dictResults[d];
+      var elName = str(rec.element);
+      var intType = str(rec.internal_type?.value || rec.internal_type || 'string');
+      var colLabel = str(rec.column_label);
+      if (elName) fieldMeta[elName] = { type: intType, label: colLabel };
+    }
+  } catch (_) {
+    // Fallback: use "string" type and generated labels if dictionary lookup fails
+  }
+
+  // Build field-level labelCache entries (no record-level parent — UI doesn't send one)
+  var entries: any[] = [];
+  for (var j = 0; j < uniqueFields.length; j++) {
+    var f = uniqueFields[j];
+    var meta = fieldMeta[f];
+    var fType = meta ? meta.type : 'string';
+    var fLabel = meta ? meta.label : f.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); });
+    var pillName = dataPillBase + '.' + f;
 
     entries.push({
       name: pillName,
-      label: 'Trigger - Record ' + triggerName + '\u27a1' + tableLabel + ' Record\u27a1' + fieldLabel,
+      label: 'Trigger - Record ' + triggerName + '\u27a1' + tableLabel + ' Record\u27a1' + fLabel,
       reference: '',
-      reference_display: '',
-      type: 'string',
-      base_type: 'string',
-      attributes: '',
+      reference_display: fLabel,
+      type: fType,
+      base_type: fType,
+      parent_table_name: table,
+      column_name: f,
       usedInstances: [{ uiUniqueIdentifier: logicUiId, inputName: 'condition' }],
       choices: {}
     });
@@ -1655,8 +1733,8 @@ async function addFlowLogicViaGraphQL(
     if (needsConditionUpdate && conditionTriggerInfo) {
       var dataPillBase = conditionTriggerInfo.dataPillBase;
       var transformedCondition = transformConditionToDataPills(rawCondition, dataPillBase);
-      var labelCacheEntries = buildConditionLabelCache(
-        rawCondition, dataPillBase, conditionTriggerInfo.triggerName,
+      var labelCacheEntries = await buildConditionLabelCache(
+        client, rawCondition, dataPillBase, conditionTriggerInfo.triggerName,
         conditionTriggerInfo.tableRef, conditionTriggerInfo.tableLabel, returnedUuid
       );
 
@@ -1673,8 +1751,13 @@ async function addFlowLogicViaGraphQL(
               type: 'flowlogic',
               inputs: [{
                 name: 'condition',
+                displayValue: { value: '' },
                 value: { schemaless: false, schemalessValue: '', value: transformedCondition }
-              }]
+              }],
+              flowLogicDefinition: {
+                inputs: [{ name: 'condition_name', attributes: 'use_basic_input=true,' }],
+                variables: 'undefined'
+              }
             }]
           }
         };