ff-automationv2 2.2.28 → 2.2.30

package/dist/ai/llmprompts/systemPrompts/combinedActionExtractorPromptMob.js

@@ -6,43 +6,44 @@ async function combinedActionExtractorPromptMob({ extractedDomJson, priorAndNext
 "MOB_IsAppInstalled","MOB_SetEmulatorPowerPercentage","MOB_ReceiveMessageOnEmulator","MOB_UninstallAPK",
 "MOB_InstallAPK","MOB_SetClipBoardText","MOB_PressAnyKeyNTimes",
 "MOB_SetContext","MOB_TerminateAppUsingAppPackage","MOB_OpenAppWithApkFilePath","MOB_ActivateAppUsingAppPackage",
-"MOB_ExecuteJavaScript","MOB_LongPress","MOB_Clear","MOB_EnterInputIntoElementFromClipBoard",
-"MOB_FindElement","FindElements","MOB_OpenNotification","MOB_PressEnterKey","MOB_ResetApp","MOB_HideKeyboard",
+"MOB_ExecuteJavaScript","MOB_LongPress","MOB_EnterInputIntoElementFromClipBoard",
+"MOB_OpenNotification","MOB_PressEnterKey","MOB_ResetApp","MOB_HideKeyboard",
 "MOB_SetEmulatorPowerStateOff","MOB_OpenChromeBrowser","MOB_SetDeviceOrientationAsPortrait","MOB_SetDeviceOrientationAsLandscape",
 "MOB_SetEmulatorPowerStateOn","MOB_AirplaneModeSwitchOn","MOB_LockDevice","MOB_WifiSwitchOff",
 "Continue","MOB_GpsSwitchOn","MOB_GpsSwitchOff","MOB_RestartCurrentDevice","MOB_AirplaneModeSwitchOff","Break","MOB_WifiSwitchOn",
-"MOB_PinchInByPercent","MOB_PinchOutByPercent","MOB_Click",
+"MOB_PinchInByPercent","MOB_PinchOutByPercent","MOB_Click","MOB_FindElement","MOB_FindElements",
 "MOB_CreateCapabilitiesInstance","MOB_PressAnyKey","MOB_PressBackSpaceKey","MOB_PressSpaceKey","MOB_RunAppInBackground",
 "MOB_SetAppiumDriverSettings","MOB_SetDriverInstance","MOB_SetImplicitTimeOut",
 "MOB_TakeScreenShotAndCompareWithImage","MOB_TakeScreenshotAndCompareSectionWithImage","MOB_TakeScreenshotAndCompareWithImageIgnoringSpecifiedSection"`;
     const elementType = ["link", "textfield", "icon", "button", "radiobutton", "checkbox", "tab", "action overflow button", "hamburger menu", "toggle button", "steppers", "sliders"];
     const prompt = `
     You are an intelligent assistant that extracts structured UI action data.
-Given the step, the simplified DOM: ${extractedDomJson}, and the list of NLP names: ${nlpList}.
+Given the step, the simplified DOM: ${extractedDomJson}, and the nlpList: ${nlpList}.
 
-Select the perfect matching NLP name from the list that best fits the step's intent.
+**Select the perfect matching NLP name from the nlpList that best fits and matches the user given step.**
 if step has only word continue or break then return nlpName as continue or break only if they dont have any action in step.
 
 Return **only valid JSON** in the following format:
 {
-  "attribute_value": "Fire-Flink-x",
+  "attributeValue": "Fire-Flink-x",
   "nlpName": "x",
-  "input_text":"x",
+  "inputText":"x",
   "keyword": "x",
   "elementType": "x",
-  "keycode": "x"
+  "keyCode": "x"
 }
 Rules:
 - nlpName must be exactly one from the provided list.
 - Use context from the steps : ${priorAndNextSteps}, keyword and json to search for FF-inspecter.
 - **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the step.**
-- If step has mutipul inputs add all in input_text and all matched attribute_value also.
-- Extract input_text from the step, if you can't find any input text in the step, return keyword as input_text.input can be number, app package, apk file path.dont include extra words.
+- If step has mutipul inputs add all in inputText and all matched attributeValue also.
+- **Extract inputText from the step, if you can't find any input text in the ste,input can be number or app package or bundle id or apk file path and if anything mentioned in string consider it as input text.dont include extra words.**
 - Extract keyword from the step, if the step contains any keyword.
 - Extract keycode of keys if the step contains any key name like ENTER,SPACE,BACKSPACE etc and give keycode of the given key.
-- Use the closest semantic match for the step; return attribute_value as Fire-Flink-0, only if nothing is found.
-- Based on step give most relevant type of element. use this list to choose element_type: ${elementType} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
-- If the steps is to find elements then provide nlpName as findElements and if the step is to find element then provide nlpName as MOB_FindElement.
+- Use the closest semantic match for the step; return attributeValue as Fire-Flink-0, only if nothing is found.
+- Based on step give most relevant type of element. use this list to choose elementType: ${elementType} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
+- If the steps is to find elements then provide nlpName as MOB_FindElements and if the step is to find element then provide nlpName as MOB_FindElement.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 - Respond with valid json only.
 `;
     return prompt;

package/dist/ai/llmprompts/systemPrompts/errorDescriptionPrompt.js

@@ -9,6 +9,8 @@ SYSTEM CONTEXT:
 - The underlying automation framework must NEVER be mentioned.
 - The tone must be professional, clear, and user-friendly.
 - Do NOT expose internal technical details.
+- IF error message contains a custom error message, error and errorDescription should be based on that custom error message.
+- If error is based on llm response error or llm related error than error and errorDescription should be based on that context.
 
 ERROR NORMALIZATION:
 - Convert the failure into the closest equivalent Selenium-style exception class name.
@@ -30,7 +32,7 @@ STRICT OUTPUT RULES:
 Return a JSON object with EXACTLY these keys:
 
 1. "error":
-   - A concise, single-line, selenium exception name or appium exception name (error).__name__ (e.g., "InvalidSessionIdException", "NoSuchElementException", "WebDriverException","ElementNotInteractableException" etc) expamle: if error is element not found, return "NoSuchElementException" 
+   - A concise, single-line, selenium exception name or appium exception name (error).__name__ (e.g., "InvalidSessionIdException", "NoSuchElementException", "WebDriverException","ElementNotInteractableException" etc) expamle: if error is element not found, return "NoSuchElementException"  and for device not found or error relatd to appium server connection or related to app package or incorrect adb path return "WebDriverException".
    - Must contain ONLY a single Selenium-style exception class name.
    - Do NOT include additional words.
 
@@ -40,9 +42,9 @@ Return a JSON object with EXACTLY these keys:
    - Avoid words like "system", "framework", or "process".
    - Describe the issue as a general situation, not from a system perspective.
    - Provide realistic possible causes based on the exception type.
-   - Keep it concise and non-repetitive.
-
-Required JSON format:
+   - Keep it concise and non-repetitive. and should be exactly 40 words no more or no less.
+   - Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
+     Required JSON format:
 
 {
   "error": "",

package/dist/ai/llmprompts/systemPrompts/fireflinkElementIndexExtactors.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ffInspectorNumExtractor = ffInspectorNumExtractor;
 async function ffInspectorNumExtractor({ stepAction, extractedDomJson, priorAndNextSteps, isAlert = false, isDrag = false, }) {
     const switchActions = ["SwitchToNewTabBasedOnTitle", "SwitchToNewTabBasedOnUrl", "SwitchToNewWindowBasedOnTitle", "SwitchToNewWindowBasedOnURL", "SwitchToParentWindow", "SwitchToWindowIfTitleContainsString", "SwitchToNewWindowIfUrlContainsString"];
+    const mouseAction = ["MouseClickOnCurrentCursorPoint", "MouseDoubleClickAtCursorPoint", "ReleaseLeftMouseButton", "PressAndHoldLeftMouseButton", "MouseHover", "MouseClickOnCurrentCursorPointNTimes"];
     const clickActions = ["Click", "DoubleClick", "RightClick", "WaitAndClick", "ClickNTimes", "ClickUsingJS"];
     const alertActions = [
         "ClickOkOnAlertPopup",
@@ -14,7 +15,7 @@ async function ffInspectorNumExtractor({ stepAction, extractedDomJson, priorAndN
         "WaitTillAlertIsPresent",
         "VerifyTextPresentOnAlertPopup"
     ];
-    const scrollActions = ["ScrollToElement", "ScrollVerticallyTillElementIsVisible", "ScrollHorizontallyTillElementIsVisible"];
+    const scrollActions = ["ScrollToElement", "ScrollVerticallyTillElementIsVisible", "ScrollHorizontallyTillElementIsVisible", "ScrollPageToSpecificLocation"];
     const elementType = ['link', 'textfield', 'icon', 'button', 'radioButton', 'text', 'textarea', 'image', 'dropdown', 'checkbox', 'tab', 'action overflow button', 'hamburger icon', 'toggle button', 'suggestion', 'time picker', 'date picker', 'toaster message', 'card', 'tooltip', 'option', 'calender', 'sliders', 'visual testing'];
     const enterActions = ["SendKeys", "ClearThenEnterInput", "WaitAndSendKeys", "EnterInputUsingJS", "EnterDataAndPressKey"];
     let prompt;
@@ -24,16 +25,18 @@ async function ffInspectorNumExtractor({ stepAction, extractedDomJson, priorAndN
 You are given a manual test step that requires interaction with a browser alert popup.
 Based on the step, return the required alert element with input in the following JSON format only:
 Rules:
-- if the alert requires entering text inpt alert or for verification if we need compare text than extract that text and give as input_text.
-- If no input is needed, set "input_text" to "None".
-- if step is about verify text present than map to VerifyTextPresentOnAlertPopup.and if step is about verify text contains than map to VerifyAlertPopUpMessageContainsString.
+- if the alert requires entering text inpt alert or for verification if we need compare text then extract that text and give as inputText.
+- if step about VerifyAlertPopupIsDisplayed and if step consists of time in step then extract time and give as inputText ex : "Verify Alert popup is displayed within 5 sec" -> inputText: "5" no need to extract any element just return the inputText.
+- If no input is needed, set "inputText" to "None".
+- if step is about verify text present then map to VerifyTextPresentOnAlertPopup.and if step is about verify text contains than map to VerifyAlertPopUpMessageContainsString.
 - Do not add explanations, comments, or extra text.
 - send one action from this list only ${alertActions} witch is related to step.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 - Output must be valid JSON.
 Respond only with JSON using this format:
 {
-  "action": x,
-  "input_text": "text to enter" | "None"
+  "action": ${alertActions.join("|")},
+  "inputText": "text to enter" | "time" | "None"
 }
 
 `;
@@ -56,10 +59,10 @@ Rules:
 - If not found, return Fire-Flink-0 for both.
 - Extract element names from step if possible.
 - Respond with JSON only.
-- The element type should be from this list ${elementType}, check for both drag and drop element type.
+- The element type should be from this list ${elementType.join("|")}, check for both drag and drop element type.
 Simplified JSON:
 ${extractedDomJson}
-
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 Respond only with JSON using this format:
 {
   "drag": "Fire-Flink-x",
@@ -81,27 +84,28 @@ You are an intelligent assistant that extracts structured UI action data.
 
 Rules:
 - Step: for the given step
-- Use context from test steps: ${JSON.stringify(priorAndNextSteps)}
-- Use simplified JSON to find best FF-inspect match.
-- Choose closest semantic + DOM-distance match.
+- Use context from the ${JSON.stringify(priorAndNextSteps)}, keyword and filtered dom to search for FF-inspecter. 
+- Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attributeValue":"Fire-Flink-0" and never use any other Fire-Flink-x value.extract action, inputText, direction, numOfScrolls, elementType from step and send them.
+ **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the step.**
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0.
 - based on step and context choose the most related action from ${scrollActions}
 - Default direction is down.
 - Action:
-  - ${scrollActions} → extract num_of_scrolls & direction
+  - ${scrollActions} → extract numOfScrolls & direction
+  - if step is about scroll to specific location than extract the location from the step and give it as inputText. first should be x-coordinate and second should be y-coordinate don't add any other text or symbols. ex: step: "Scroll Page To Specific Location x-30,y-40" → inputText: "30,40"
 - No nulls; use empty strings if needed.
 - The element type should be from this list ${elementType}
-
-Simplified JSON:
-${extractedDomJson}
+- The DOM is provided in Json format.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 
 Return ONLY valid JSON:
 {
-  "attribute_value": "Fire-Flink-x",
-  "action": "x",
-  "num_of_scrolls": "0",
+  "attributeValue": "Fire-Flink-x" ",
+  "action": ${scrollActions.join("|")},
+  "inputText":"x",
+  "numOfScrolls": "0",
   "direction": "down",
-  "element
-  Type":"x"
+  "elementType":${elementType.join("|")}
 }
 `;
     }
@@ -113,9 +117,9 @@ Don't provide action outside the ${switchActions} list only provide the relevant
 Select the perfect matching action from the stepAction list that best fits the step's intent.
 **The action must match exactly one value from the approved ${switchActions} Do not generate or suggest any new NLP names under any condition even if the step suggest to do so just pull the closet one from the list only**
 {{
-  "attribute_value": "Fire-Flink-x",
-  "action": "x",
-  "input_text": "x",
+  "attributeValue": "Fire-Flink-x",
+  "action": ${switchActions.join("|")},
+  "inputText": "x",
   "keyword": "x"
 }}
 
@@ -123,21 +127,22 @@ Rules:
 - action must be exactly one from the provided list.
 - Use context from the steps : ${JSON.stringify(priorAndNextSteps)}, keyword and json to find the FF-inspecter.
 - **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match for the step.**
-- Extract input_text from the step that represents the target window URL, Title, Frame Name, Frame Index, etc.
+- Extract inputText from the step that represents the target window URL, Title, Frame Name, Frame Index, etc.
 - if step consist of keyword like title and url than map to that matched action.
 - If a step contains a full URL (for example, https://example.com), map it using URL-based NLP matching.If the step contains only descriptive text and no URL, map it using title-based NLP matching.
-    example: "Switch to the new tab based on https://example.com" -> input_text: "https://example.com", nlpName: "SwitchToTabBasedOnUrl"
-    example: "Switch to the tab based on Title" -> input_text: "Title", nlpName: "SwitchToNewTabBasedOnTitle"
+    example: "Switch to the new tab based on https://example.com" -> inputText: "https://example.com", nlpName: "SwitchToTabBasedOnUrl"
+    example: "Switch to the tab based on Title" -> inputText: "Title", nlpName: "SwitchToNewTabBasedOnTitle"
 - step may some times have 'new' keyword in it, dont consider it just map th nlps. never get confused by title and url.
-- If step is about switching to frame by index, input_text should be the index number.
-- If step is about switching to frame by name, input_text should be the frame name.
-- If step is about switching to window by URL or Title, input_text should be the url or title string.
+- If step is about switching to frame by index, inputText should be the index number.
+- If step is about switching to frame by name, inputText should be the frame name.
+- If step is about switching to window by URL or Title, inputText should be the url or title string.
 - If no explicit input is found, attempt to infer it or leave empty if the NLP implies a specific action without input (e.g. SwitchToParentWindow).
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 - **Respond with valid JSON only. don't return any other text or don't return response in list format**
 `;
     }
     // ---------------- DEFAULT (CLICK / cleartext etc.) ----------------
-    else if (stepAction === "click" || stepAction === "cleartext") {
+    else if (stepAction === "mouseAction") {
         prompt = `
 
 -You are an intelligent assistant that extracts structured UI action data.
@@ -147,17 +152,58 @@ Rules:
     
 Return **only valid JSON** in the following format:
 {
-"attribute_value": "Fire-Flink-x",
-"action": "x",
-"input_text": "x",
-"elementType": "x"
+"attributeValue": "Fire-Flink-x",
+"action": ${mouseAction.join("|")},
+"inputText": "x",
+"elementType": ${elementType.join("|")}
 }
 
 Rules:
 You are an AI assistant. For the step, extract the element keyword from the step (the field name like 'Leaving from', 'Going To').
 - Use context from the ${JSON.stringify(priorAndNextSteps)}, keyword and filtered dom to search for FF-inspecter. 
-- Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attribute_value":"Fire-Flink-0" and never use any other Fire-Flink-x value.
+- Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attributeValue":"Fire-Flink-0" and never use any other Fire-Flink-x value.extract action, inputText, keyword, elementType from step and send them.
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0
 - **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the atep.**
+- If multiple matches exist, use the reference element and choose the closest match by ff-inspect distance.
+
+  **important example: step: "mouce click on login below user login" 
+            simplified json: 
+                        login - ff-inspect-300
+                        user login - ff-inspect-790
+                        login - ff-inspect-803
+                        then should return login - ff-inspect-803 witch is near to user reference element user login - ff-inspect-790**
+- Do not return elements far away from the reference.
+- These are actions: ${mouseAction}. action should be exactly one from the provided list.
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0.
+- example: step: "mouse click on login below user login" -> should return the attributeValue of the login element.
+- for mouse click on current cursor point n times in that case provide input text as number of clicks only.
+- Based on step give most relevant type of element. use this list to choose elementType: ${elementType.join("|")} and Never change syntax of elementType, follow the syntax of elementType in list.if elementType is not there in list return 'link'.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
+- Respond with valid JSON only.Don
+`;
+    }
+    else if (stepAction === "click" || stepAction === "cleartext") {
+        prompt = `
+
+-You are an intelligent assistant that extracts structured UI action data.
+    -Given a structured UI JSON representation with uniquely identified elements (ff-inspect values like Fire-Flink-0, Fire-Flink-1, Fire-Flink-2, Fire-Flink-3... in DOM order), 
+    -locate the most appropriate element for an automation step by performing keyword-based matching using exact, partial, and fuzzy strategies, and 
+    return the identifier of the best match.
+    
+Return **only valid JSON** in the following format:
+{
+"attributeValue": "Fire-Flink-x",
+"action": ${clickActions.join("|")},
+"inputText": "x",
+"elementType": ${elementType.join("|")}
+}
+
+Rules:
+You are an AI assistant. For the step, extract the element keyword from the step (the field name like 'Leaving from', 'Going To').
+- Use context from the ${JSON.stringify(priorAndNextSteps)}, keyword and filtered dom to search for FF-inspecter. 
+- **Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attributeValue":"Fire-Flink-0" and never use any other Fire-Flink-x value.extract action, inputText, elementType from step and send them.**
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0
+- **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the step.**
 - If multiple matches exist, use the reference element and choose the closest match by ff-inspect distance.
   **important example: step: "click on login below user login" 
             simplified json: 
@@ -166,16 +212,20 @@ You are an AI assistant. For the step, extract the element keyword from the step
                         login - ff-inspect-803
                         then should return login - ff-inspect-803 witch is near to user reference element user login - ff-inspect-790**
 - Do not return elements far away from the reference.
-- These are actions: ${clickActions}.
-- For wait and click step check in the step the time of wait in seconds will be mentioned take provide it has the input_text in the output and action as  waitandclick as mention in the clickactionlist similarly for the click n times n will the input_text in the output and action as clickntimes as mention in the clickactionlist.
+- These are actions: ${clickActions}. action should be exactly one from the provided list.
+- For wait and click step check in the step the time of wait in seconds will be mentioned take provide it has the inputText in the output and action as  waitandclick as mention in the clickactionlist similarly for the click n times n will the inputText in the output and action as clickntimes as mention in the clickactionlist.
 - If it is like wait and click in the step then send the wait time as the value  as provided in the step and then for click n times provide the n as the value in the output.
-- Select the closest semantic match to step and return only its attribute_value, else Fire-Flink-0.
-- For WaitAndClick take action as WaitAndClick and input_text as the wait time as provided in the step.
-- For ClickNTimes take action as ClickNTimes and input_text as the n as provided in the step.
-- For ClickUsingJS take action as ClickUsingJS and input_text as the empty string and select this click action only if the step is about clicking an element using javascript.
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0.
+- If a step involves a select action, you MUST first check for a matching option tag (exact or fuzzy) and return its attributeValue; ONLY if no option exists, return the related select element. example: step: "select state India" -> should return the attributeValue of the option tag with text 'India'.
+- If a matching option is found, returning the select element is strictly invalid unless the step explicitly says to click the select dropdown itself.
+- For WaitAndClick take action as WaitAndClick and inputText as the wait time as provided in the step.
+- For ClickNTimes take action as ClickNTimes and inputText as the n as provided in the step.
+- For ClickUsingJS take action as ClickUsingJS and inputText as the empty string and select this click action only if the step is about clicking an element using javascript.
 - Action: ${clickActions} for clicking or selecting,'Clear' for clearing text based on the step.
-- For Click action, if only step involving 'clicking on icon' then try to return related svg tags attribute_value, if they are available in simplified json.
-- Based on step give most relevant type of element. use this list to choose element_type: ${elementType} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
+- For Click action, if only step involving 'clicking on icon' then try to return related svg tags attributeValue, if they are available in simplified json.
+- Based on step give most relevant type of element. use this list to choose elementType: ${elementType.join("|")} and Never change syntax of elementType, follow the syntax of elementType in list.if elementType is not there in list return 'link'.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
+- **Respond with valid JSON only. don't return any other text or don't return response in list format**
 
 `;
     }
@@ -190,44 +240,52 @@ return the identifier of the best match.
 
 Return **only valid JSON** in the following format:
 {
-"attribute_value": "Fire-Flink-x",
-"action": "x",
-"input_text": "x",
-"elementType": "x"
+"attributeValue": "Fire-Flink-x",
+"action": ${enterActions.join("|")},
+"inputText": "x",
+"elementType": ${elementType.join("|")}
 }
 
 Rules:
 You are an AI assistant. For the step, extract the element keyword from the step (the field name like 'Leaving from', 'Going To').
 - Use context from the ${JSON.stringify(priorAndNextSteps)}, keyword and filtered dom to search for FF-inspecter.
-- Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attribute_value":"Fire-Flink-0" and never use any other Fire-Flink-x value.
-- Select the closest semantic match to step and return only its attribute_value, else Fire-Flink-0.
+- **Simplified JSON: ${extractedDomJson} — if it is empty, null, or has no valid data, return strictly "attributeValue":"Fire-Flink-0" and never use any other Fire-Flink-x value.extract action, inputText, elementType from step and send them.**
+- If no input tag is present in the simplified JSON, select the element most relevant to the step (regardless of tag type), i will use that to enter the data.
+- Select the closest semantic match to step and return only its attributeValue, else Fire-Flink-0.
 - **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the atep.**
-- If multiple matches exist, use the reference element and choose the closest match by ff-inspect distance.
-important example: step: "click on login below user login"
-simplified json:
-login - ff-inspect-300
-user login - ff-inspect-790
-login - ff-inspect-803
-then should return login - ff-inspect-803 witch is near to user reference element user login - ff-inspect-790
+- If multiple matches exist, identify the reference element from the step and select the matching element with the smallest ff-inspect distance relative to that reference (i.e., the closest in position).
+      Example:
+      Step: "Enter input in Username below Confirm", "harry"
+      Simplified JSON:
+      Username - ff-inspect-300
+      Confirm - ff-inspect-790
+      Username - ff-inspect-811
+      Reference element: Confirm - ff-inspect-790
+      Closest match: Username - ff-inspect-811 (nearest to 790)
+      Final selection: Username - ff-inspect-811
 - Respect direction (up/down), default is down.
 - Do not return elements far away from the reference.
-- Select the closest semantic match to step and return only its attribute_value
-- Action:SendKeys for entering text, EnterDataAndPressKey for entering data and pressing the key, clearThenEnterInput for clear and Entering Input, 'upload' for uploading file.
+- Select the closest semantic match to step and return only its attributeValue
+- **Never directly select a input tag if should be realted to step; if u can't find input tag related to step then prefer the closest label/span/div/b/i/tr/td etc, it can be any tag related to the step. i will use that to enter the data.**
+- Action:SendKeys for entering text, EnterDataAndPressKey for entering data and pressing the key, 'upload' for uploading file.
+- Use ClearThenEnterInput only when the step explicitly involves clearing existing text before entering new input.
 - Action:EnterDataAndPressKey if step is about entering data and pressing a key, then select this action.
 - Action:EnterInputUsingJS if step is about entering input using js,WaitAndSendKeys for waiting for some time and then entring.
-- If action is waitAndSendkeys then in the input_text provide output with the input and then the wait time in seconds as "input_text = " input, waittime" input is input for that step and waittime is time in seconds mentioned in steps only for wiat and enter step and also the attribute_value should be the attribute_value of the element in the simplified json.
-- For click action, if only step involving 'clicking on icon' then try to return related svg tags attribute_value, if they are available in simplified json.
+- Action:WaitAndSendKeys for waiting for some time and then entring input.if wait is present in step.
+- If action is waitAndSendkeys then in the inputText provide output with the input and then the wait time in seconds as "inputText = " input, waittime" input is input for that step and waittime is time in seconds mentioned in steps only for wiat and enter step and also the attributeValue should be the attributeValue of the element in the simplified json.
+- For click action, if only step involving 'clicking on icon' then try to return related svg tags attributeValue, if they are available in simplified json.
 - For Action ${enterActions} extract input text from step.
 - **For ${enterActions} actions, never directly select a input tag if should be realted to step; if u can't find input tag related to step then prefer the closest label/span/div/b/i etc, it can be any tag related to the step.**
-- **For ${enterActions} step if you can't find perfect matching element return attribute_value as Fire-Flink-0 for the step. it should be exact match for the step.**
-- For ${enterActions} step, If the step implies autogenerated data or random data(email, phone, credentials, identifiers, etc.), generate a valid dummy input_text suitable for the field.
+- **For ${enterActions} step if you can't find perfect matching element return attributeValue as Fire-Flink-0 for the step. it should be exact match for the step.**
+- For ${enterActions} step, If the step implies autogenerated data or random data(email, phone, credentials, identifiers, etc.), generate a valid dummy inputText suitable for the field.
 example: step: "Enter sss.@gmail.com in email field" and step :
-you should check only for email in Simplified JSON and input_text should be "sss.@gmail.com" dont add any extra text.
+you should check only for email in Simplified JSON and inputText should be "sss.@gmail.com" dont add any extra text.
 - For Action "upload" extract file path from step. and add extra //// for path.like "C:////Users/////User/////Downloads/////fireflinkElementIndexExtactors.ts"
-- For Action "EnterDataAndPressKey" extract input text from step. and also extract the key to be pressed from the step. and return the key to be pressed as the input_text in the form of input_text, key_to_be_pressed.ex(input_text = "input","key_to_be_pressed" )
-- if u cant find any input_text or any other dont give null just return them "" empty.
-- Based on step give most relevant type of element. use this list to choose element_type: ${elementType} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
-
+- For Action "EnterDataAndPressKey" extract input text from step. and also extract the key to be pressed from the step. and return the key to be pressed as the inputText in the form of inputText, key_to_be_pressed.ex(inputText = "input","key_to_be_pressed" )
+- if u cant find any inputText or any other dont give null just return them "" empty.
+- Based on step give most relevant type of element. use this list to choose element_type: ${elementType.join("|")} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
+- Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
+- **Respond with valid JSON only. don't return any other text or don't return response in list format**
 
 `;
     }

package/dist/ai/llmprompts/systemPrompts/fireflinkElementIndexExtractor_Mob.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ffInspectorNumExtractorMob = ffInspectorNumExtractorMob;
 async function ffInspectorNumExtractorMob({ stepAction, extractedDomJson, priorAndNextSteps, }) {
-    const SwipeActions = ["MOB_SwipeToElement", "MOB_SwipeUpToElement", "MOB_SwipeDownToElement", "MOB_SwipeLeftToElement", "MOB_SwipeRightToElement", "MOB_SwipeNTimes", "MOB_Builtin_Swipe", "MOB_SwipeDirectionNTimes", "MOB_SwipeToElementForMWeb", "MOB_SwipeUsingReferenceElement"];
+    const SwipeActions = ["MOB_SwipeToElement", "MOB_SwipeUpToElement", "MOB_SwipeDownToElement", "MOB_SwipeLeftToElement", "MOB_SwipeRightToElement", "MOB_SwipeNTimes", "MOB_Builtin_Swipe", "MOB_SwipeDirectionNTimes", "MOB_SwipeToElementForMWeb", "MOB_SwipeUsingReferenceElement", "SwipeUp", "SwipeDown", "SwipeLeft", "SwipeRight", "Swipe"];
     const Actions = ["MOB_Tap", "MOB_TapNTimes", "MOB_DoubleTap", "MOB_DoubleTapAtSpecifiedLocation", "MOB_TapOnSpecifiedLocation",
-        "MOB_Enter", "MOB_EnterDataAndPressKey", "MOB_EnterInputIntoElementFromClipBoard", "MOB_EnterUrl", "MOB_ClearThenEnterInput",
+        "MOB_Enter", "MOB_EnterDataAndPressKey", "MOB_EnterInputIntoElementFromClipBoard", "MOB_EnterUrl", "MOB_Clear", "MOB_ClearThenEnterInput",
         "MOB_LongPress", "MOB_PressEnterKey", "MOB_PressSpaceKey", "MOB_PressBackSpaceKey", "MOB_PressAnyKey", "MOB_PressAnyKeyNTimes", "MOB_EnterDataAndPressKey", "MOB_PressHomeKey", "MOB_PressBackKey"];
     const elementType = ["link", "textfield", "icon", "button", "radiobutton", "checkbox", "tab", "action overflow button", "hamburger menu", "toggle button", "steppers", "sliders"];
+    const OtpAction = ["getOtp"];
     let prompt = "";
     if (stepAction === "tap" || stepAction === "enter") {
         prompt = `
@@ -14,8 +15,8 @@ You are an intelligent assistant that extracts structured UI action data.\n
 Return **only valid JSON** in the following format:\n
 **Dont give any extra explanation or text**
 {
-  "attribute_value": "Fire-Flink-x",
-  "input_text": "x",
+  "attributeValue": "Fire-Flink-x",
+  "inputText": "x",
   "keyword": "x",
   "elementType": "x",
   "nlpName": "x"
@@ -25,30 +26,61 @@ Rules:\n
 You are an AI assistant. For the step, extract the element keyword from the step (the field name like 'Leaving from', 'Going To').
 - Use context from all steps: ${JSON.stringify(priorAndNextSteps)}, keyword and filtered dom to search for FF-inspecter. 
 **nlpName: MOB_PressBackKey or MOB_PressHomeKey for mobile navigation respective buttons like back and home**
-- **If step is tap on element of referenece element,if multiple elements are there ,choose element which is related to reference element.The element can be reference element's before or after sibling nodes in filtered dom json.**
+- **For step if you can't find perfect matching element or no attribute in filtered dom JSON is related to step return attributeValue as Fire-Flink-0.**
 - If step is enter input into element try to find ff inspector attribute value of element not input text.
-- **For step if you can't find perfect matching element or no attribute in filtered dom JSON is related to step return attribute_value as Fire-Flink-0.**
 - Don't think if type of element is found it is exact element, check with keyword and step.If it is not matched return Fire-Flink-0.
+- If step is tap on element of referenece element,if multiple elements are there ,choose element which is related to reference element.The element can be reference element's before or after sibling nodes in filtered dom json,if siblings also same return element which ff-inspect value is close to reference element.
  **important example: step: "click on login below user login" 
-            simplified json: login - ff-inspect-300
-                        user login - ff-inspect-790
-                        login - ff-inspect-803
-                        then should return login - ff-inspect-803 witch is near to user reference element user login - ff-inspect-790**
-- **Find the FF-inspecter attribute value of the element in the filtered dom JSON whose text or content-desc or other attributes best or perfect match for the step.**
+            simplified json: login - ff-inspect-320
+                        user login - ff-inspect-330
+                        login - ff-inspect-350
+                        then should return login - ff-inspect-320 witch is near to user reference element user login - ff-inspect-330**
+- **Find the FF-inspecter attribute value of the element in the filtered dom JSON whose text or content-desc or name or label or other attributes best or perfect match for the step.**
 - nlpName: Extract nlpName from the list of nlps: ${Actions} based on the step.If step is enter url, nlpName should be MOB_EnterUrl.
-- For taping action dont take attribute_value of the node contining edittext in class, resource-id.
-- For some steps you can see two inputs but you need to uderstand step and send the requred input_text. 
+- For taping action dont take attributeValue of the node contining edittext in class, resource-id.
+- For some steps you can see two inputs but you need to uderstand step and send the requred inputText. 
         ex:Double tap on the 30,50
         here  here input:30,50
-- and for this MOB_TapNTimes nlps send number of times to tap as input_text.
-- If step is press any key and if the step contains any key name like ENTER,SPACE,BACKSPACE etc and give keyname of the given key as input_text if they mention key and how many times to press key 'keyname,number of times' or enter input and press key keep it as 'input,keyname'.
-- nlpName: wait for wait action, and in input_text give time to wait. like sleep for 30 seconds, here nlpName is wait and input_text is 30.
+- and for this MOB_TapNTimes nlps send number of times to tap as inputText.
+- If step is press any key and if the step contains any key name like ENTER,SPACE,BACKSPACE etc and give keyname of the given key as inputText if they mention key and how many times to press key 'keyname,number of times' or if step is enter input and press key keep it as 'input,keyname'.
+- nlpName: wait for wait action, and in inputText give time to wait. like sleep for 30 seconds, here nlpName is wait and inputText is 30.
 - Extract input text from step for all actions,if input is not there give empty string "". 
 - Based on step give most relevant type of element. use this list to choose elementType: ${elementType} and Never change syntax of elementType, follow the syntax of elementType in list.if elementType is not there in list return 'link'.
 - Respond with valid JSON only.
 
 filtered dom JSON: ${extractedDomJson}
 `;
+    }
+    else if (stepAction === "getOtp") {
+        prompt = `
+  You are an intelligent assistant that extracts structured mobile getOTP action data.
+  Given the step: ${JSON.stringify(priorAndNextSteps)},and the list of NLP names: ${OtpAction}.
+
+Select the perfect matching NLP name from the list that best fits the step's intent.
+
+Return **only valid JSON** in the following format:
+{{ 
+  "nlpName": "x",
+  "inputText": "x",
+  "timeFrom": "x",
+  "waitTime": "x",
+  "activity": "x"
+}}
+
+Rules:
+- nlpName must be exactly one from the provided list.
+- If the steps are provided with the message header and the messaging app provide the message header in the inputText and messaging app in the bundleID in the activity field.
+- If the step does not provides the messaging app don't provide example provide "activity":"" empty.
+- If the step does not provides the time range don't provide example provide "timeFrom":"" and "waitTime":"" empty.
+
+- **Extraction**:
+    - inputText: The header of the message mentioned in the step.
+    - activity: The messaging app from which the OTP is to be extracted.
+    - timeFrom: The time range for which the OTP is to be extracted just give number like "60" for 60 seconds like that don't add any extra words with that.
+    - waitTime: The time to wait for the OTP to be extracted just give number like "60" for 60 seconds like that don't add any extra words with that.
+    - Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
+
+- response:valid json only.`;
     }
     else if (stepAction === "swipe" || stepAction === "scroll") {
         prompt = `
@@ -59,34 +91,39 @@ Select the perfect matching NLP name from the list that best fits the step's int
 
 Return **only valid JSON** in the following format:
 {{
-  "attribute_value": "Fire-Flink-x", 
+  "attributeValue": "Fire-Flink-x", 
   "nlpName": "x",
-  "input_text": "x",
+  "inputText": "x",
   "keyword": "x",
   "type": "x",
-  "num_of_scrolls": "x",
+  "numOfScrolls": "x",
   "direction": "x"
 }}
 
 Rules:
 - nlpName must be exactly one from the provided list.
+- If the step is provided with the coordinates like (x1,y1,x2,y2) and direction is not mentioned but coordinates are there means then map to swipe of direction is given then it must match to swipe up, swipe down,swipe left, swipe right don't go with the MOB_ one's
+- **If the step is saying 'swipe up, down, left, right' with the coordinates specified in the step, then give coordintates in inputText like (x1,y1,x2,y2) and map to nlp's like swipe up, swipe down,swipe left, swipe right if direction is not mentioned but coordinates are there means then map to swipe.**
 - Use cont2ext from the steps : ${JSON.stringify(priorAndNextSteps)}, keyword and json to search for FF-inspecter.
-- If direction is not specified, then match to "MOB_SwipeToElement".
+- If direction is not specified and also coordinates are not specified, then match to "MOB_SwipeToElement".
 - If direction is Not specified and element is not specified, then match to "MOB_SwipeNTimes".
-- If direction is specified and element is not specified, then match to "MOB_SwipeDirectionNTimes".
-- If step has a reference element, then match to "MOB_SwipeUsingReferenceElement". and give input_text: "reference element -> <next element>"
+- If direction is specified and direction word is there and no of times is given, then match to "MOB_SwipeDirectionNTimes" ex: swipe up direction 2 times.
+- If step has a reference element, then match to "MOB_SwipeUsingReferenceElement". and give inputText: "reference element -> <next element>"
 example: swipe up to "Contact Us" using "Settings" as reference.
-        input_text: "Settings -> Contact Us"
+        inputText: "Settings -> Contact Us"
 - If the step is saying 'up to' or 'till' element, then return the number of scrolls as 0. and also don't take 'up' as direction in this case, give direction as "none" ".
+- **If the step is saying 'swipe up, down, left, right' with the coordinates specified in the step, then give coordintates in inputText like (x1,y1,x2,y2) and map to nlp's like swipe up, swipe down,swipe left, swipe right if direction is not mentioned but coordinates are there means then map to swipe.**
+
 - **Extraction**:
-    - input_text: The target element in the step.e.g., "swipe to submit text",then input text must be "submit",Dont include its type in input_text like text,button,icon etc...Leave empty if just swiping N times.**
+    - inputText: The target element in the step.e.g., "swipe to submit text",then input text must be "submit",Dont include its type in inputText like text,button,icon etc...Leave empty if just swiping N times, if coordinates are specified then give coordinates in inputText like (x1,y1,x2,y2) where x1,y1 is starting coordinate and x2,y2 is ending coordinate.**
     - keyword: Crucial keyword from step (e.g., "Settings").
-    - num_of_scrolls: Extract count if specified (e.g., "scroll 3 times"). Default to 0 if not specified but action implies generic scroll.
+    - nomOfScrolls: Extract count if specified (e.g., "scroll 3 times"). Default to 0 if not specified but action implies generic scroll.
     - direction: "up", "down", "left", "right". Infer from step (e.g., "Scroll down" -> "down"). If direction is not specified, default direction to "none".
-    - attribute_value: If an element is visible and matches the target, provide its FF-inspecter. Otherwise "Fire-Flink-2".
-    - type: Based on step give most relevant type of element. use this list to choose element_type: ${elementType} and Never change syntax of element_type, follow the syntax of element_type in list.if element_type is not there in list return 'link'.
+    - attributeValue: If an element is visible and matches the target, provide its FF-inspecter. Otherwise "Fire-Flink-2".
+    - type: Based on step give most relevant type of element. use this list to choose elementType: ${elementType} and Never change syntax of elementType, follow the syntax of elementType in list.if elementType is not there in list return 'link'.
+    - Return ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 
-- Respond with valid JSON only.`;
+- response:valid json only.`;
     }
     return prompt;
 }