snow-flow-test 10.0.1-test.183 → 10.0.1-test.185

package/package.json

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

@@ -1323,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.
  *
- * 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" }
+ * 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=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> = {};
+  if (clauses.length === 0) return [];
 
-  // 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;
-
-  // 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 [];
+
+  // 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
+  }
 
-    var fieldLabel = field.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); });
+  // 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: {}
     });
@@ -1537,22 +1560,79 @@ async function transformActionInputsForRecordAction(
   // ── 4. Build labelCache entries for data pills ────────────────────
   if (dataPillBase && usedInstances.length > 0) {
     var tableRef = triggerInfo.tableRef || triggerInfo.table || '';
-    var tableLabel = triggerInfo.tableLabel || '';
+    var tblLabel = triggerInfo.tableLabel || '';
 
-    // Record-level data pill entry
+    // Record-level data pill entry (for the `record` input — selecting the whole record)
     labelCacheEntries.push({
       name: dataPillBase,
-      label: 'Trigger - Record ' + triggerInfo.triggerName + '\u27a1' + tableLabel + ' Record',
+      label: 'Trigger - Record ' + triggerInfo.triggerName + '\u27a1' + tblLabel + ' Record',
       reference: tableRef,
-      reference_display: tableLabel,
+      reference_display: tblLabel,
       type: 'reference',
       base_type: 'reference',
-      attributes: '',
+      parent_table_name: tableRef,
+      column_name: '',
       usedInstances: usedInstances,
       choices: {}
     });
 
-    steps.label_cache = { count: labelCacheEntries.length, pills: [dataPillBase], usedInstances: usedInstances.length };
+    // Field-level data pill entries for any field references in the `values` string
+    var valuesStr = '';
+    var valuesInp = actionInputs.find(function (inp: any) { return inp.name === 'values'; });
+    if (valuesInp) valuesStr = valuesInp.value?.value || '';
+
+    if (valuesStr && valuesStr.includes('{{')) {
+      // Extract field-level pills from values like "assigned_to={{dataPillBase.assigned_to}}"
+      var pillRegex = /\{\{([^}]+)\}\}/g;
+      var pillMatch;
+      var seenPills: Record<string, boolean> = {};
+      seenPills[dataPillBase] = true;
+
+      while ((pillMatch = pillRegex.exec(valuesStr)) !== null) {
+        var fullPillName = pillMatch[1];
+        if (seenPills[fullPillName]) continue;
+        seenPills[fullPillName] = true;
+
+        // Extract field name from pill (e.g. "Created or Updated_1.current.assigned_to" → "assigned_to")
+        var dotParts = fullPillName.split('.');
+        var fieldCol = dotParts.length > 2 ? dotParts[dotParts.length - 1] : '';
+
+        if (fieldCol) {
+          // Look up field metadata from sys_dictionary
+          var fMeta: { type: string; label: string } = { type: 'string', label: fieldCol.replace(/_/g, ' ').replace(/\b\w/g, function (c: string) { return c.toUpperCase(); }) };
+          try {
+            var dictResp = await client.get('/api/now/table/sys_dictionary', {
+              params: {
+                sysparm_query: 'name=' + tableRef + '^element=' + fieldCol,
+                sysparm_fields: 'element,column_label,internal_type',
+                sysparm_display_value: 'false',
+                sysparm_limit: 1
+              }
+            });
+            var dictRec = dictResp.data.result?.[0];
+            if (dictRec) {
+              fMeta.type = str(dictRec.internal_type?.value || dictRec.internal_type || 'string');
+              fMeta.label = str(dictRec.column_label) || fMeta.label;
+            }
+          } catch (_) {}
+
+          labelCacheEntries.push({
+            name: fullPillName,
+            label: 'Trigger - Record ' + triggerInfo.triggerName + '\u27a1' + tblLabel + ' Record\u27a1' + fMeta.label,
+            reference: '',
+            reference_display: fMeta.label,
+            type: fMeta.type,
+            base_type: fMeta.type,
+            parent_table_name: tableRef,
+            column_name: fieldCol,
+            usedInstances: [{ uiUniqueIdentifier: uuid, inputName: fieldCol }],
+            choices: {}
+          });
+        }
+      }
+    }
+
+    steps.label_cache = { count: labelCacheEntries.length, pills: labelCacheEntries.map(function (e: any) { return e.name; }), usedInstances: usedInstances.length };
   }
 
   return { inputs: actionInputs, labelCacheEntries, steps };
@@ -1710,8 +1790,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
       );
 
@@ -1728,8 +1808,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'
+              }
             }]
           }
         };