snow-flow 10.0.198 → 10.0.199

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.198",
+  "version": "10.0.199",
   "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/catalog/snow_order_catalog_item.ts

@@ -1,25 +1,37 @@
 /**
  * snow_order_catalog_item - Order catalog item
  *
- * Orders a catalog item programmatically, creating a request (RITM) with specified variable values.
+ * Orders a catalog item programmatically, creating a request (RITM) with
+ * specified variable values.
+ *
+ * Operation order (avoids race condition with flows):
+ *   1. Fetch variable definitions (item_option_new)
+ *   2. Create sc_request
+ *   3. Pre-create sc_item_option records in parallel (no RITM needed yet)
+ *   4. Short delay to ensure DB commit
+ *   5. Create sc_req_item (RITM) — flow triggers here with variables ready
+ *   6. Create sc_item_option_mtom links in parallel
+ *   7. Two PATCHs to trigger Business Rules that associate the flow context
+ *
+ * Based on contribution by @frodoyoraul (PR #83).
  */
 
 import { MCPToolDefinition, ServiceNowContext, ToolResult } from "../../shared/types.js"
 import { getAuthenticatedClient } from "../../shared/auth.js"
 import { createSuccessResult, createErrorResult } from "../../shared/error-handler.js"
 
+// Delay between sc_item_option creation and RITM insert to ensure DB commit
+const VARIABLE_COMMIT_DELAY_MS = 1000
+
 export const toolDefinition: MCPToolDefinition = {
   name: "snow_order_catalog_item",
   description: "Orders a catalog item programmatically, creating a request (RITM) with specified variable values.",
-  // Metadata for tool discovery (not sent to LLM)
   category: "itsm",
   subcategory: "service-catalog",
   use_cases: ["ordering", "automation", "ritm"],
   complexity: "intermediate",
   frequency: "high",
 
-  // Permission enforcement
-  // Classification: WRITE - Write operation based on name pattern
   permission: "write",
   allowedRoles: ["developer", "admin"],
   inputSchema: {
@@ -36,46 +48,89 @@ export const toolDefinition: MCPToolDefinition = {
   },
 }
 
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+
 export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
   const { cat_item, requested_for, variables, quantity = 1, delivery_address, special_instructions } = args
 
   try {
     const client = await getAuthenticatedClient(context)
 
-    // Create service catalog request
+    // 1. Fetch variable definitions before creating the RITM
+    const varDefsResponse = await client.get("/api/now/table/item_option_new", {
+      params: {
+        sysparm_query: "cat_item=" + cat_item,
+        sysparm_fields: "sys_id,name",
+        sysparm_limit: 100,
+      },
+    })
+    const varDefs = varDefsResponse.data.result || []
+    const varMap = new Map<string, string>()
+    varDefs.forEach((def: any) => {
+      if (def.name) varMap.set(def.name, def.sys_id)
+    })
+
+    // 2. Create sc_request
     const requestData: any = {
       requested_for,
       opened_by: requested_for,
     }
-
     if (special_instructions) requestData.special_instructions = special_instructions
 
     const requestResponse = await client.post("/api/now/table/sc_request", requestData)
     const requestId = requestResponse.data.result.sys_id
 
-    // Create requested item (RITM)
+    // 3. Pre-create sc_item_option records in parallel (no RITM needed yet)
+    const varEntries = variables ? Object.entries(variables).filter(([name]) => varMap.has(name)) : []
+    const skippedVars = variables ? Object.keys(variables).filter((name) => !varMap.has(name)) : []
+
+    const optionSysIds: Array<{ optionSysId: string }> = await Promise.all(
+      varEntries.map(async ([varName, varValue]) => {
+        const defSysId = varMap.get(varName)!
+        const optResp = await client.post("/api/now/table/sc_item_option", {
+          item_option_new: defSysId,
+          value: varValue,
+        })
+        return { optionSysId: optResp.data.result.sys_id }
+      }),
+    )
+
+    // 4. Wait for sc_item_option records to be committed in DB
+    if (optionSysIds.length > 0) {
+      await sleep(VARIABLE_COMMIT_DELAY_MS)
+    }
+
+    // 5. Create sc_req_item (RITM) — flow triggers here with variables already ready
     const ritmData: any = {
       request: requestId,
       cat_item,
       requested_for,
       quantity,
     }
-
     if (delivery_address) ritmData.delivery_address = delivery_address
 
     const ritmResponse = await client.post("/api/now/table/sc_req_item", ritmData)
     const ritmId = ritmResponse.data.result.sys_id
     const ritmNumber = ritmResponse.data.result.number
 
-    // Set variable values if provided
-    if (variables) {
-      for (const [varName, varValue] of Object.entries(variables)) {
-        await client.post("/api/now/table/sc_item_option_mtom", {
+    // 6. Create sc_item_option_mtom links in parallel
+    await Promise.all(
+      optionSysIds.map(({ optionSysId }) =>
+        client.post("/api/now/table/sc_item_option_mtom", {
           request_item: ritmId,
-          name: varName,
-          value: varValue,
-        })
-      }
+          sc_item_option: optionSysId,
+        }),
+      ),
+    )
+
+    // 7. Two PATCHs to trigger Business Rules that associate the flow context.
+    //    sys_mod_count is auto-incremented by ServiceNow (the value we send is
+    //    ignored), but the PATCH itself is a real update that fires BR triggers.
+    //    Two updates are needed: the first associates the flow, the second
+    //    ensures the flow context is fully propagated.
+    if (optionSysIds.length > 0) {
+      await client.patch("/api/now/table/sc_req_item/" + ritmId, { sys_mod_count: "1" })
+      await client.patch("/api/now/table/sc_req_item/" + ritmId, { sys_mod_count: "1" })
     }
 
     return createSuccessResult(
@@ -85,6 +140,8 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         ritm_id: ritmId,
         ritm_number: ritmNumber,
         quantity,
+        variables_processed: varEntries.length,
+        variables_skipped: skippedVars.length > 0 ? skippedVars : undefined,
       },
       {
         operation: "order_catalog_item",
@@ -97,5 +154,5 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
   }
 }
 
-export const version = "1.0.0"
-export const author = "Snow-Flow SDK Migration"
+export const version = "2.0.0"
+export const author = "Snow-Flow"