snow-flow-test 10.0.1-test.172 → 10.0.1-test.176

package/package.json

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

@@ -206,20 +206,39 @@ async function buildFlowLogicInputsForInsert(
   defId: string,
   defRecord: { name?: string; type?: string; description?: string; order?: string; attributes?: string; compilation_class?: string; quiescence?: string; visible?: string; category?: string; connected_to?: string },
   userValues?: Record<string, string>
-): Promise<{ inputs: any[]; flowLogicDefinition: any; resolvedInputs: Record<string, string> }> {
+): Promise<{ inputs: any[]; flowLogicDefinition: any; resolvedInputs: Record<string, string>; inputQueryError?: string; defParamsCount: number }> {
   // Query sys_hub_flow_logic_input for this definition's inputs (separate table from sys_hub_action_input)
+  // Field names verified from actual sys_hub_flow_logic_input XML schema
   var defParams: any[] = [];
+  var inputQueryError = '';
   try {
     var resp = await client.get('/api/now/table/sys_hub_flow_logic_input', {
       params: {
         sysparm_query: 'model=' + defId,
-        sysparm_fields: 'sys_id,element,label,internal_type,mandatory,default_value,order,max_length,hint,read_only,extended,data_structure,reference,reference_display,ref_qual,choice_option,table_name,column_name,use_dependent,dependent_on,show_ref_finder,local,attributes,sys_class_name',
+        sysparm_fields: 'sys_id,element,label,internal_type,mandatory,default_value,order,max_length,hint,read_only,attributes,sys_class_name,reference,choice,dependent,dependent_on_field,use_dependent_field,column_label',
         sysparm_display_value: 'false',
         sysparm_limit: 50
       }
     });
     defParams = resp.data.result || [];
-  } catch (_) {}
+  } catch (e: any) {
+    inputQueryError = e.message || 'unknown error';
+    // Fallback: try with minimal fields
+    try {
+      var resp2 = await client.get('/api/now/table/sys_hub_flow_logic_input', {
+        params: {
+          sysparm_query: 'model=' + defId,
+          sysparm_fields: 'sys_id,element,label,internal_type,mandatory,order,max_length,attributes',
+          sysparm_display_value: 'false',
+          sysparm_limit: 50
+        }
+      });
+      defParams = resp2.data.result || [];
+      inputQueryError = '';
+    } catch (e2: any) {
+      inputQueryError += '; fallback also failed: ' + (e2.message || '');
+    }
+  }
 
   // Fuzzy-match user-provided values to actual field names
   var resolvedInputs: Record<string, string> = {};
@@ -304,7 +323,7 @@ async function buildFlowLogicInputsForInsert(
     variables: '[]'
   };
 
-  return { inputs, flowLogicDefinition, resolvedInputs };
+  return { inputs, flowLogicDefinition, resolvedInputs, inputQueryError: inputQueryError || undefined, defParamsCount: defParams.length };
 }
 
 // Note: reordering of existing elements is NOT possible via Table API because
@@ -446,7 +465,8 @@ async function addTriggerViaGraphQL(
         },
         {
           name: 'condition',
-          displayValue: { schemaless: false, schemalessValue: '', value: condition || '^EQ' }
+          displayValue: { schemaless: false, schemalessValue: '', value: condition || '^EQ' },
+          value: { schemaless: false, schemalessValue: '', value: condition || '^EQ' }
         }
       ];
       try {
@@ -474,22 +494,53 @@ async function addActionViaGraphQL(
   actionName: string,
   inputs?: Record<string, string>,
   parentUiId?: string,
-  order?: number
+  order?: number,
+  spoke?: string
 ): Promise<{ success: boolean; actionId?: string; steps?: any; error?: string }> {
   const steps: any = {};
 
   // Dynamically look up action definition in sys_hub_action_type_snapshot
+  // Prefer global/core actions over spoke-specific ones (e.g. core "Update Record" vs spoke-specific "Update Record")
+  const snapshotFields = 'sys_id,internal_name,name,sys_scope,sys_package';
   let actionDefId: string | null = null;
+
+  // Helper: pick the best match from candidates — prefer spoke filter, then global scope
+  const pickBest = (candidates: any[]): any => {
+    if (!candidates || candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    // If spoke filter is specified, match against scope or package name
+    if (spoke) {
+      var spokeLC = spoke.toLowerCase();
+      var spokeMatch = candidates.find((c: any) =>
+        str(c.sys_scope).toLowerCase().includes(spokeLC) ||
+        str(c.sys_package).toLowerCase().includes(spokeLC) ||
+        str(c.internal_name).toLowerCase().includes(spokeLC)
+      );
+      if (spokeMatch) return spokeMatch;
+    }
+    // Prefer global scope
+    var global = candidates.find((c: any) => str(c.sys_scope) === 'global' || str(c.sys_scope) === 'rhino.global');
+    if (global) return global;
+    // Prefer records without "spoke" in the package name
+    var nonSpoke = candidates.find((c: any) => !str(c.sys_package).toLowerCase().includes('spoke'));
+    if (nonSpoke) return nonSpoke;
+    return candidates[0];
+  };
+
   for (const field of ['internal_name', 'name']) {
     if (actionDefId) break;
     try {
       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 }
+        params: { sysparm_query: field + '=' + actionType, sysparm_fields: snapshotFields, sysparm_limit: 10 }
       });
-      const found = resp.data.result?.[0];
+      const results = resp.data.result || [];
+      if (results.length > 1) {
+        steps.def_lookup_candidates = results.map((r: any) => ({ sys_id: r.sys_id, internal_name: str(r.internal_name), name: str(r.name), scope: str(r.sys_scope), package: str(r.sys_package) }));
+      }
+      const found = pickBest(results);
       if (found?.sys_id) {
         actionDefId = found.sys_id;
-        steps.def_lookup = { id: found.sys_id, internal_name: found.internal_name, name: found.name, matched: field + '=' + actionType };
+        steps.def_lookup = { id: found.sys_id, internal_name: str(found.internal_name), name: str(found.name), scope: str(found.sys_scope), package: str(found.sys_package), matched: field + '=' + actionType };
       }
     } catch (_) {}
   }
@@ -498,14 +549,15 @@ async function addActionViaGraphQL(
       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
+          sysparm_fields: snapshotFields, sysparm_limit: 10
         }
       });
       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 }));
-      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 };
+      steps.def_lookup_fallback_candidates = results.map((r: any) => ({ sys_id: r.sys_id, internal_name: str(r.internal_name), name: str(r.name), scope: str(r.sys_scope), package: str(r.sys_package) }));
+      const found = pickBest(results);
+      if (found?.sys_id) {
+        actionDefId = found.sys_id;
+        steps.def_lookup = { id: found.sys_id, internal_name: str(found.internal_name), name: str(found.name), scope: str(found.sys_scope), package: str(found.sys_package), matched: 'LIKE ' + actionType };
       }
     } catch (_) {}
   }
@@ -630,6 +682,7 @@ async function addFlowLogicViaGraphQL(
   const inputResult = await buildFlowLogicInputsForInsert(client, defId, defRecord, inputs);
   steps.available_inputs = inputResult.inputs.map((i: any) => ({ name: i.name, label: i.parameter?.label }));
   steps.resolved_inputs = inputResult.resolvedInputs;
+  steps.input_query_stats = { defParamsFound: inputResult.defParamsCount, inputsBuilt: inputResult.inputs.length, error: inputResult.inputQueryError };
 
   // Calculate insertion order
   const resolvedOrder = await calculateInsertOrder(client, flowId, parentUiId, order);
@@ -1106,6 +1159,10 @@ export const toolDefinition: MCPToolDefinition = {
         type: 'string',
         description: 'Display name for the action (for add_action)'
       },
+      spoke: {
+        type: 'string',
+        description: 'Spoke/scope filter for action lookup (for add_action). Use to disambiguate when multiple spokes have actions with the same name (e.g. "global" for core actions, "spoke-specific" for spoke-specific Spoke actions). Matched against sys_scope and sys_package fields.'
+      },
       action_inputs: {
         type: 'object',
         description: 'Key-value pairs for action inputs (e.g. {log_message: "test", log_level: "info"})'
@@ -1999,7 +2056,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         var addActName = args.action_name || args.name || addActType;
         var addActInputs = args.action_inputs || args.inputs || {};
 
-        var addActResult = await addActionViaGraphQL(client, addActFlowId, addActType, addActName, addActInputs, args.parent_ui_id, args.order);
+        var addActResult = await addActionViaGraphQL(client, addActFlowId, addActType, addActName, addActInputs, args.parent_ui_id, args.order, args.spoke);
 
         var addActSummary = summary();
         if (addActResult.success) {