ff-automationv2 2.2.0 → 2.2.2

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

@@ -0,0 +1,232 @@
+export async function ffInspectorNumExtractor({ stepAction, extractedDomJson, priorAndNextSteps, isAlert = false, isDrag = false, }) {
+    const switchActions = ["SwitchToNewTabBasedOnTitle", "SwitchToNewTabBasedOnUrl", "SwitchToNewWindowBasedOnTitle", "SwitchToNewWindowBasedOnURL", "SwitchToParentWindow", "SwitchToWindowIfTitleContainsString", "SwitchToNewWindowIfUrlContainsString"];
+    const clickActions = ["Click", "DoubleClick", "RightClick", "WaitAndClick", "ClickNTimes", "ClickUsingJS"];
+    const alertActions = [
+        "ClickOkOnAlertPopup",
+        "ClickCancelOnAlertPopup",
+        "EnterDataToAlert",
+        "GetTextPresentOnAlertPopup",
+        "VerifyAlertPopupIsDisplayed",
+        "VerifyAlertPopUpMessageContainsString",
+        "WaitTillAlertIsPresent",
+        "VerifyTextPresentOnAlertPopup"
+    ];
+    const scrollActions = ["ScrollToElement", "ScrollVerticallyTillElementIsVisible", "ScrollHorizontallyTillElementIsVisible"];
+    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;
+    // ---------------- ALERT ----------------
+    if (isAlert) {
+        prompt = `
+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.
+- Do not add explanations, comments, or extra text.
+- send one action from this list only ${alertActions} witch is related to step.
+- Output must be valid JSON.
+Respond only with JSON using this format:
+{
+  "action": x,
+  "input_text": "text to enter" | "None"
+}
+
+`;
+    }
+    // ---------------- DRAG & DROP ----------------
+    else if (isDrag) {
+        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-1, Fire-Flink-2... in DOM order),
+locate the most appropriate elements for a drag-and-drop action.
+
+
+
+Rules:
+- Step: for the given step
+- Use the simplified JSON to find elements.
+- Identify source (drag) and destination (drop).
+- 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.
+Simplified JSON:
+${extractedDomJson}
+
+Respond only with JSON using this format:
+{
+  "drag": "Fire-Flink-x",
+  "drop": "Fire-Flink-x",
+  "action": "Builtin_DragAndDropToElement",
+  "drag_element_name": "x",
+  "drop_element_name": "x"
+  "drag_element_type": "x",
+  "drop_element_type": "x"
+}
+`;
+    }
+    // ---------------- SCROLL ----------------
+    else if (stepAction === "scroll") {
+        prompt = `
+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.
+- based on step and context choose the most related action from ${scrollActions}
+- Default direction is down.
+- Action:
+  - ${scrollActions} → extract num_of_scrolls & direction
+- No nulls; use empty strings if needed.
+- The element type should be from this list ${elementType}
+
+Simplified JSON:
+${extractedDomJson}
+
+Return ONLY valid JSON:
+{
+  "attribute_value": "Fire-Flink-x",
+  "action": "x",
+  "num_of_scrolls": "0",
+  "direction": "down",
+  "element
+  Type":"x"
+}
+`;
+    }
+    else if (stepAction === "switch") {
+        prompt = `
+You are an intelligent assistant that extracts structured UI action data.
+Given the stepActions: ${switchActions}, the simplified DOM: ${extractedDomJson}.
+Don't provide action outside the ${switchActions} list only provide the relevant action from inside the list itself.
+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",
+  "keyword": "x"
+}}
+
+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.
+- 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"
+- 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 no explicit input is found, attempt to infer it or leave empty if the NLP implies a specific action without input (e.g. SwitchToParentWindow).
+- **Respond with valid JSON only. don't return any other text or don't return response in list format**
+`;
+    }
+    // ---------------- DEFAULT (CLICK / ENTER / UPLOAD etc.) ----------------
+    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-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:
+{
+"attribute_value": "Fire-Flink-x",
+"action": "x",
+"input_text": "x",
+"elementType": "x"
+}
+
+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 this simplified json is empty return Fire-Flink-0 never return Fire-Flink-1 as attribute_value.
+- **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**
+- 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.
+- 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.
+- 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'.
+
+`;
+    }
+    // ---------------- DEFAULT (CLICK / ENTER / UPLOAD etc.) ----------------
+    else {
+        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-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:
+{
+"attribute_value": "Fire-Flink-x",
+"action": "x",
+"input_text": "x",
+"elementType": "x"
+}
+
+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 this simplified json is empty return Fire-Flink-0 never return Fire-Flink-1 as attribute_value.
+- Select the closest semantic match to step and return only its attribute_value, 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
+- 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_valu
+- Action:SendKeys for entering text, EnterDataAndPressKey for entering data and pressing the key, clearThenEnterInput for clear and Entering Input, 'upload' for uploading file.
+- 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.
+- 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.
+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.
+- 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'.
+
+
+`;
+    }
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/fireflinkElementIndexExtractor_Mob.d.ts

@@ -0,0 +1,2 @@
+import { FFInspectorArgsMob } from "../llmPromptTypes/systemPromptTypes";
+export declare function ffInspectorNumExtractorMob({ stepAction, extractedDomJson, priorAndNextSteps, }: FFInspectorArgsMob): Promise<string>;

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

@@ -0,0 +1,43 @@
+export async function ffInspectorNumExtractorMob({ stepAction, extractedDomJson, priorAndNextSteps, }) {
+    const Actions = ["MOB_Tap", "MOB_TapNTimes", "MOB_DoubleTap", "MOB_DoubleTapAtSpecifiedLocation", "MOB_TapOnSpecifiedLocation",
+        "MOB_Enter", "MOB_EnterDataAndPressKey", "MOB_EnterInputIntoElementFromClipBoard", "MOB_EnterUrl", "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"];
+    let prompt = "";
+    if (stepAction === "tap" || stepAction === "enter") {
+        prompt = `
+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",
+  "keyword": "x",
+  "element_type": "x",
+  "nlpName": "x"
+}
+
+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 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.
+- **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.**
+- nlpName: Extract nlpName from the list of nlps: ${Actions} based on the step. 
+- 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. 
+        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.
+- 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.
+- 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 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'.
+- Respond with valid JSON only.
+
+filtered dom JSON: ${extractedDomJson}
+`;
+    }
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/getActionExtractorPrompt.d.ts

@@ -0,0 +1,2 @@
+import { getActionArgs } from "../llmPromptTypes/systemPromptTypes";
+export declare function getActionExtractorPrompt({ extractedDomJson, priorAndNextSteps, }: getActionArgs): Promise<string>;

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

@@ -0,0 +1,53 @@
+export async function getActionExtractorPrompt({ extractedDomJson, priorAndNextSteps, }) {
+    const nlpList = `"GetAllTheOptionsFromListBoxAsTextInSortedOrder", "GetScreenshot", "GetAllTheOptionsFromListBoxAsText", "GetTheFirstSelectedOptionFromListBoxAsText", "GetAllTheSelectedOptionsFromListBoxAsText", "GetAttribute", "GetTagName", "GetListBoxSize",
+ "GetWrappedOptionFromListBoxAsText", "GetTextFromListOfWebElements", "GetCssValue", "GetScreenshotAs", "GetFirstSelectedOption", "GetText", "GetOptions", "GetAllSelectedOptions", "GetSize", "GetWrappedElement", "GetRect", "GetLocation", 
+ "GetXLocationOfWebElement", "GetYLocationOfWebElement", "GetVideoMediaSource", "GetListOfElementsFromLocatorTypeLocatorValue",  "GetVideoCurrentSeekTime", "GetVideoMediaLength", "GetVideoDefaultPlaybackRate", "GetVideoHeight", "GetAudioCurrentPlaybackRate", 
+ "GetAudioDecodedByte", "GetVideoCurrentPlaybackRate", "GetVideoCurrentVolume", "GetVideoDimension", "GetAudioDefaultPlaybackRate", "GetVideoWidth", "GetSingleApiStatusCode", "GetSingleApiResponseTime", "GetAudioCurrentVolume", "GetSingleApiResponse", 
+ "GetCollectiveApiStatusCode", "GetVideoDecodedByte", "GetDataFromApiResponseForJsonPath", "GetAudioMediaSource", "GetCollectiveApiResponseTime", "GetStatusCodeOfALink", "GetValueFromLocalStorage", "GetHeightOfWebElement", "GetTunnelIdentifier", 
+ "GetWidthOfWebElement", "GetValueByCookieName", "GetAudioHeight", "GetHexCodeForGivenXYCoordinatesOfImage", "GetAudioCurrentSeekTime", "GetAudioWidth", "GetAudioMediaLength", "GetAudioDimension", "ScrollPageToSpecificLocation", "GetDateWithGivenFormat", 
+
+ "GetBestPracticesScore", "GetPwaScore", "GetDataFromApiRequestHeaderForJsonPath", "GetSeoScore", "GetValueOfSystemVariable", "GetStringDataFromLocalFile", "GetAccessibilityScore", "GetPerformanceScore", "GetSystemProperty", "GetValueFromXmlPath", 
+ "RobotGetXLocationOfWebElement", "RobotGetYLocationOfWebElement", "GetSingleApiRequestPayload","GetAllBrokenLinks", "GetHeightOfBrowserWindow", "GetXLocationOfBrowserWindow", "GetAllBrokenLinkCount", "GetWidthOfBrowser", "GetCurrentWindowHandle", 
+ "GetAllWindowHandles", "GetURLPresentInAddressBar", "GetHTMLCodeOfPage", "GetPageTitle", "GetBrowserCount", "GetBrowserVersion", "GetImplicitTimeOut", "GetCapabilityNames", "GetYLocationOfBrowserWindow", "GetCurrentSystemDate", 
+ "GetCurrentDayOfTheWeek", "GetCurrentSystemTime", "GetCurrentSecondsFromCurrentSystemTime", "GetCurrentSystemYear", "GetHourFromCurrentSystemTime", "GetMinuteFromCurrentSystemTime", "GetNumberOfLinksPresentInCurrentPage", "GetAllConsoleWarnings", 
+ "GetAllConsoleInformation", "GetAllConsoleErrors", "GetAllCookieValues", "GetSizeOfBrowserWindow", "GetCurrentSystemMonth", "GetCurrentSystemDay", "GetAllConsoleLogs", "GetTotalNumberOfCookies", "GetAllBrokenImages", "GetAllCookieNames", 
+ "GetNumberOfWorkingLinksFromCurrentPage", "GetNumberOfBrokenImages", "GetWorkingLinksFromCurrentPage", "BrowserWindowGetPosition", "GetClipBoardText", "GetDriverInstance", "GetFullPaintTime", "GetFirstContentfulPaint", "GetLargestContentfulPaint", 
+ "GetNetworkRouteTime", "GetPerformanceMetrics", "GetUserHomeDirectory"`;
+    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 prompt = `You are an intelligent assistant that extracts structured UI action data for fetching (GET) information.
+Given the step, the simplified DOM: ${JSON.stringify(extractedDomJson)}, and the list of NLP names: ${nlpList}.
+
+Select the perfect matching NLP name from the list that best fits the step's intent.
+**The NLP name must match exactly one value from the approved NLP list. Do not generate or suggest any new NLP names under any condition.**
+
+{
+  "attribute_value": "Fire-Flink-x",
+  "nlpName": "x",
+  "input_text":"x"
+  "element_type": "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.**
+- **CRITICAL: For media actions (GetVideo..., GetAudio...), ALWAYS prioritize the actual <video> or <audio> element. DO NOT select container <div>, <span> or code block elements that merely contain the media tag as text. If you see a code block and a real media element, choose the real media element.**
+- For some steps you can see two inputs but you need to understand step and send the required input_text. input_text can be string, number, url or xpath.
+        ex: get the flights matches the flight, Get Single Api Response of url- 'https://app.talentscan.ai/login' and request url-'https://app.talentscan.ai/sign up', if they give x-30,y-50 just send 30,50 and for this nlps GetDataFromApiRequestHeaderForJsonPath and Get Data From Api Response of url- 'https://app.talentscan.ai/login' and request url-'https://app.talentscan.ai/sign up' For JsonPath - c:jsonpath format than fill input_text in this order "https://app.talentscan.ai/login,https://app.talentscan.ai/sign up,c:jsonpath"
+        here keyword : "flights" , input : "flight", here input:"https://app.talentscan.ai/login,https://app.talentscan.ai/sign up" first input is url and second input is request url 
+- If step is about getting text from list of web elements from locator type locator value then always follow this format first type next value input_text: "locator_type, locator_value". if they didn't give locator type then based on locator value find locator type.
+and also If a step is about getting value from element or some kind of locator type then provide the input in the format input_text: "locator_type, locator_value".
+- If step is about getting attribute value then map to attribute nlps and input_text: "attribute_name".
+- if step is about tag name then input_text: "tag name". and if step is about getting tag name and with count then input_text: "tag name,count".
+- if step is about getting screenshot of element then than map to GetScreenshotAs.
+- If step is mapted to GetTunnelIdentifier nlp than input_text must have 4 values separated by comma.first will be datacenter second will be username third will be access key and fourth will be tunnel id. they must follow this order. if they miss any value than return all values except that value.
+- If a step refers to location, use X-location or Y-location NLP only when X or Y is explicitly mentioned; otherwise, use the general location NLP.
+- if step is about getting options than map to option nlps.
+- for nlp GetBestPracticesScore,GetPwaScore and GetSeoScore input_text must have 2 values separated by comma.first will be url second will be device type. they must follow this order. if they miss any value than return all values except that value.
+- If no explicit option is mentioned in the step, map it to the most relevant non-option getting NLP based on the intent of the step.
+- Extract input_text from the step that is which is being getting in the step, if you can't find any input text in the step, return keyword as input_text.
+- Use the closest semantic match for the step; return attribute_value as Fire-Flink-0, only if nothing is found.and never return Fire-Flink-x.
+- 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'.
+- **Respond with valid JSON only. don't return any other text* or or don't return response in list format*.
+`;
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/getActionExtractorPromptMob.d.ts

@@ -0,0 +1,2 @@
+import { getActionArgs } from "../llmPromptTypes/systemPromptTypes";
+export declare function getActionExtractorPromptMob({ extractedDomJson, priorAndNextSteps, }: getActionArgs): Promise<string>;

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

@@ -0,0 +1,45 @@
+export async function getActionExtractorPromptMob({ extractedDomJson, priorAndNextSteps, }) {
+    const nlpList = `"MOB_GetDeviceLocation","MOB_GetBatteryPercentage","MOB_GetLongitude","MOB_GetAltitude","MOB_GetLatitude",
+"MOB_GetCurrentDeviceDate","MOB_GetMinuteFromCurrentDeviceTime","MOB_GetCurrentAppPackage","MOB_GetAllContexts",
+"MOB_GetHourFromCurrentDeviceTime","MOB_GetSecondFromCurrentDeviceTime","MOB_GetSupportedPerformanceDataTypes",
+"MOB_GetCurrentOrientation","MOB_GetCurrentDeviceTime","MOB_GetCurrentContext","MOB_GetCurrentDeviceSettings","GetCurrentSystemDay",
+"MOB_GetClipBoardText","GetCurrentSystemMonth","MOB_GetCurrentDeviceStatus","MOB_GetSizeOfScreen","MOB_GetAllWindowHandles","MOB_GetWidthOfScreen",
+"MOB_GetBatteryStatus","MOB_GetCurrentActivity","MOB_GetDeviceOsVersion","MOB_GetDeviceUdid","MOB_GetDeviceName","MOB_GetImplicitTimeOut",
+"MOB_GetDriverInstance","MOB_GetCurrentWindowHandle","MOB_GetCurrentSessionId","MOB_GetHeightOfScreen","MOB_GetCurrentDeviceSystemBars",
+"MOB_GetAttributeValueFromListOfWebElements","MOB_GetTagName","MOB_GetListOfElementsFromLocatorTypeLocatorValue","MOB_GetScreenshot","MOB_GetTextFromElementAndSetToClipBoard",
+"MOB_GetHeightOfElement","MOB_GetTextFromListOfWebElements","MOB_GetHexCodeForGivenXYCoordinatesOfImage","MOB_GetADBLogsForGivenAppPackage","MOB_GetScreenshotAs","MOB_GetWidthOfElement",
+"MOB_GetX", "MOB_GetLocation","MOB_GetY","MOB_GetPerformanceData","MOB_GetRect","MOB_GetText","MOB_GetSize","MOB_GetAttribute"`;
+    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: step, the simplified DOM: ${extractedDomJson} and the list of NLP names: ${nlpList}.
+
+Select the perfect matching NLP name from the list that best fits the step's intent.
+
+Return **only valid JSON** in the following format:
+{
+  "FF_inspector_value": "Fire-Flink-x",
+  "nlpName": "x",
+  "input_text":"x"
+  "keyword": "x",
+  "element_type": "x",
+  "locator_type": "x",
+  "attribute_type": "x"
+}
+Rules:
+- nlpName must be exactly one from the provided list.
+- for screenshots, extract the input_text from the step. like what they what to name image.if not present then leave it empty.
+- 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.**
+- Extract input_text from the step, if you can't find any input text in the step, return keyword as input_text.
+    ex:Fetch the ADB logs for the abhibus 
+    here input: abhibus
+- Extract keyword from the step, if the step contains any keyword.
+- Use the closest semantic match for the step; return attribute_value as Fire-Flink-0, only if nothing is found.
+- if step is get location of device or get device location then map to MOB_GetDeviceLocation nlp.
+- 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'.
+- Extract locator_type if mentioned in the step, like(text,resource-id,content-desc,xpath) 
+- Extract attribute_type if mentioned in the step, like (text,resource-id,content-desc,className).
+- Respond with valid JSON only.
+`;
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/mobileKeywordExtractor.d.ts

@@ -0,0 +1,2 @@
+import { keywordExtractor } from "../llmPromptTypes/systemPromptTypes";
+export declare function keywordExtractorMobile({ priorAndNextSteps }: keywordExtractor): Promise<string>;

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

@@ -0,0 +1,32 @@
+export async function keywordExtractorMobile({ priorAndNextSteps }) {
+    const allowedActions = ["openApp", "tap", "enter", "wait", "verify", "scroll", "get", "close"];
+    const prompt = `
+You are an expert in mobile app testing.
+From the step, extract ONLY the meaningful keywords so that i can search for the element in the dom.
+Rules:
+- understand the step and context from the ${priorAndNextSteps}.and only extract keywords from current step and dont extract from all steps.
+- 3 to 5 keywords maximum.
+- If the step is about luanching an app or opening app, like (action, param1, param2) or(action,'param1,param2') then wrap them into array and give them as keywords like ['com.app.android', 'com.app.activity']
+and also give them in the format (launch app, 'com.app.android', 'com.app.activity') like first package name and second activity name. if any separator exists (- / | :), split on it.
+If they mention package:com.app.android and activity:com.app.activity remove variable name and then convert them into ['com.app.android, 'com.app.activity']
+- If the step is about entering text, Do NOT include entered input values from the step.
+- First keywords should be from step next Keywords must be distinct and based on the element's label meaning only.
+- **Keywords can be string or number if the step contains a number it can be any number,must include that number in keywords.**
+- Do Not include any other unrelated keywords for step.
+- Do NOT include generic UI words (button, field, etc) and action words (tap, click, press, etc).
+- Do NOT include status/technical words (displayed, enabled, authenticate, visible).
+- If an element label contains multiple words (e.g., "Sign In", "Add to Cart"), keep them together as ONE keyword and do not split them and also for keywords you generated, do not split them.
+-** element_name: extract name of the element that mentioned in the step  not from keywords or other steps.(eg:tap on x -> element_name:x). always try to retuen short and meaning full element name from step**
+- action: openApp for opening or launching of app, tap for taping or selecting or clicking or pressing, enter for entering input, wait for waiting or sleeping, verify for verifying or checking,scroll for scrolling and swiping, get for getting,fetching element, closeApp for closing the app.
+- action must be one of from this list ${allowedActions}.if not one of them, return '0'. if step about set or find or press enter key action return '0'
+Respond only with JSON using this format:
+    {
+    "keywords": [key1,key2,key3,key4,key5] if step is opening app then keywords should be like [app package,app activity],
+    "elementName": "x",
+    "action": "x"
+    }
+
+    No other text.
+`;
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/userStoryToListPrompt.d.ts

@@ -0,0 +1,2 @@
+export declare function buildStepExtractionPrompt(): Promise<string>;
+export declare function androidbuildStepExtractionPrompt(): Promise<string>;

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

@@ -0,0 +1,56 @@
+export async function buildStepExtractionPrompt() {
+    const prompt = `
+You are a precise assistant.
+Extract Steps from the following user story for web automation.
+
+Rules:
+1. Each step must be a string — not a tuple.
+2. Keep the wording the same except:
+   - Do not add new steps, only rewrite existing ones.
+   - Do not remove any steps.
+   - Do not remove quotes from the step. if these quotes are present in the step, keep them as it is.
+3. Output only a **valid TypeScript array of strings**. No explanations, markdown, or code fences..
+4. Please paste the “below example array” here, so I can make it dynamic and generic strictly in the same format.
+**Dont include any other text in the array. and also dont include example array in the response.**
+Output Format
+
+Respond strictly in valid JSON using the following structure:
+{
+"manualSteps": ["step 1", "step 2", "step 3"]
+}
+`;
+    return prompt;
+}
+export async function androidbuildStepExtractionPrompt() {
+    const prompt = `
+You are a precise assistant.  
+Extract **step data** from the following mobile {user_story_raw}.
+
+Rules:
+Dont take text from one step and use it in another step.
+1. If the step is about luanching an app, like (action, param1, param2) or(action,'param1,param2') then wrap them into a tuple.
+and also give them in the format (launch app, 'com.app.android', 'com.app.activity') like first package name and second activity name. if any separator exists (- / | :), split on it.
+If they mention package:com.app.android and activity:com.app.activity remove variable name and then convert them into (launch app, 'com.app.android, 'com.app.activity')
+2.Dont remove parameters from the step. and never combine or merge steps and dont create any extra steps.
+step may be any formate for enter if input is give seperatly with comma use this
+ example:'enter username in text field','testuser' → ('enter username in text field','testuser').
+if not given seperatly with comma use and mention in step it self than this
+ example:'enter testuser in text field' → ('enter testuser in text field','testuser').
+3. If it's just a single string value, keep it as a string.
+4. Always output a **Always output a valid list of strings.** containing strings or tuples only. 
+ - Do not add explanations, reasoning, or extra text outside the list.
+ - Do not make any assumption if step inputs are missing in user_story_raw
+ - **Dont change the order of steps from user story**
+5. If the step is tuple keep it as tuple like this (step). if not just keep it as a string like this 'step'.
+**strictly follow the output format**
+[
+    ('Launch  Mobile App','com.app.android','com.app.activity'),
+    'Tap on cancel button',
+    'Tap on signin with email',
+    ('enter username in text field','testuser'),
+    ('enter testuser in text field','testuser'),
+    'verify element is displayed'
+]
+`;
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/verifyActionExtractorPrompt.d.ts

@@ -0,0 +1,2 @@
+import { verifyActionArgs } from "../llmPromptTypes/systemPromptTypes";
+export declare function verifyActionExtractorPrompt({ extractedDomJson, priorAndNextSteps, }: verifyActionArgs): Promise<string>;

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

@@ -0,0 +1,71 @@
+export async function verifyActionExtractorPrompt({ extractedDomJson, priorAndNextSteps, }) {
+    const nlpList = `VerifyElementIsDisabled,VerifyElementIsEnabled,VerifyElementIsSelected,VerifyIfOptionWithIndexIsSelectedInListBox,VerifyWidthOfElement,VerifyBrowserWindowXLocation,
+    VerifyIfCookieNameIsDeleted,VerifyBrowserWindowWidth,VerifyValueOfElementIsCleared,
+    VerifyTagName,VerifyIfCookieNameIsAdded,VerifyLinkNavigatesToTitle,VerifyXLocationOfElement,
+    VerifyAllOptionsAreDeselected,VerifyBrowserHtmlCodeContainsString,VerifyBrowserWindowYLocation,
+    VerifyNumberOfElementsByTagName,VerifyListBoxOptionsAreSorted,VerifyNavigateURL,
+    VerifyHeightOfWebElement,VerifyValueOfElementContainsString,VerifyBrowserWindowHeight,VerifyIfLinksAreBroken,
+    VerifyIfLinkIsBroken,VerifyValueOfElementIsString,VerifyYLocationOfElement,
+    VerifyNumberOfElementsByXpath,VerifyIfOptionWithIndexIsDeselectedInElement,VerifyAttributeValue,
+    VerifyElementIsDisplayed,VerifyAllOptionsAreSelected,VerifyIfOptionWithValueIsDeselected,
+    VerifyBrowserWindowTitleContainsString,VerifyBrowserWindowTitleIsString,
+    VerifyTitleOfCurrentPage,VerifyPartialTitleOfCurrentPage,VerifyElementIsNotDisplayed,
+    VerifyCssAttributeValue,VerifyPartialAttributeValue,VerifyIfSpecifiedOptionIsSelected,
+    VerifyTitleInAllPage,VerifyIfOptionWithValueIsSelected,VerifyIfVideoIsPlaying,
+    VerifyIfGivenOptionIsDuplicate,VerifyRadioButtonIsSelected,VerifyRadioButtonIsNotSelected,
+    VerifyThatSpecifiedOptionIsNotSelected,
+    VerifyText,VerifyPartialText,VerifyElementNotContainsText,VerifyElementIsClickable,
+    VerifyCheckBoxIsSelected,VerifyCheckBoxIsNotSelected,
+    VerifyUrlContainsExpectedUrl,VerifyUrlIsString,
+    VerifyIfBrowserWindowIsClosed,VerifyAllBrowserWindowsClosed,
+    VerifyIfAllCookiesAreDeleted,VerifyIfCookieObjectIsPresent,
+    VerifyIfXAndYCoordinateOfElement,VerifyIfVideoIsMuted,VerifyIfVideoIsPaused,
+    VerifyIfVideoEnded,VerifyIfVideoPlayingInMute,VerifyIfVideoPlayingInUnmute,
+    VerifyIfAudioIsPlaying,VerifyIfAudioIsPaused,VerifyIfAudioIsMuted,VerifyIfAudioEnded,
+    VerifyIfLinkIsWorking,VerifyIfLinksAreWorking,
+    VerifyIfImageIsBroken,VerifyAllBrokenImages,VerifyIfStatusCodeOfALinkIsStatusCode,
+    VerifyIfStatusCodesOfLinks,VerifyIfOptionWithVisibleTextIsSelected,VerifyBrowserWindowUrlIsString,
+    VerifyIfOptionWithTextIsDeselected,VerifyPerformanceScore,VerifyAccessibilityScore,VerifyBrowserWindowUrlContainsExpectedUrl,
+    VerifyBestPracticesScore,VerifySeoScore,VerifyPwaScore,VerifyHexCodeForGivenXYCoordinates`;
+    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 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} don't provide the other nlp names which are not present in the list in any manner.
+
+
+Select the perfect matching NLP name from the list that best fits the step's intent.
+**The NLP name must match exactly one value from the approved NLP list. Do not generate or suggest any new NLP names under any condition.**
+step may give any way,you need to get most matching and most related nlp name from the list that relates to step.
+for these nlp's VerifyIfSpecifiedOptionIsSelected,VerifyThatSpecifiedOptionIsNotSelected,VerifyIfOptionWithValueIsSelected,VerifyIfOptionWithValueIsDeselected,in step if they mention word value then only match with these VerifyIfOptionWithValueIsSelected,VerifyIfOptionWithValueIsDeselected.Otherwise go with specified option nlp's.
+example: verify if email element is present
+nlp name should be VerifyElementIsDisplayed
+
+
+{
+  "attribute_value": "Fire-Flink-x",
+  "nlpName": "x",
+  "input_text":"x"
+  "elementType": "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 any other attributes best match the step in the simplified DOM.**
+- For some steps you can see two inputs but you need to understand step and send the required input_text. input_text can be string, number, url or xpath.
+        ex: Verify the flights matches the flight, Verify the home has 30 and 50 coordinates if they give x-30,y-50 just send 30,50 and verify hex code '#FFFFFF' for given (34,11) coordinates or they will give x-34,y-11 hexcode-#FFFFFF format than fill input_text in this order "#FFFFFF,34,11"
+        here keyword : "flights" , input : "flight", here input:"30,50"  , here input:"#FFFFFF,34,11" 
+- If step is about checking attribute value then map to attribute nlps and input_text: "attribute_name,element_name" here attribute_name can be id,text,href etc not fire-flink-x. input_text should be in this format.if they mention css attribute value then input_text should be "css_property,expected_value".
+and also If a step requires comparing two values, provide the input in the format input_text: "value1,value2".
+- if step is about tag name then input_text: "tag name". and if step is about verifying tag name and with count then input_text: "tag name,count". and if any step is about verifying number of elements with xpath then input_text should be "xpath,count"
+- if step is about verifying location then input_text: "coordinates".
+- If a step involves a URL, map navigation/action keywords (navigate) to VerifyNavigateURL, partial match keywords (contains, includes) to VerifyUrlContainsExpectedUrl or VerifyBrowserWindowUrlContainsExpectedUrl exact match keywords (equals, is, exactly) to VerifyUrlIsString or VerifyBrowserWindowUrlIsString based on step  if they mention navigate to title match with (VerifyLinkNavigatesToTitle) default to exact match if unclear, and prioritize navigation if both intents exist.
+- If no explicit option is mentioned in the step, map it to the most relevant non-option verification NLP based on the intent of the step.
+- **Extract input_text from the step that is which is being verified in the step, if you can't find any input text in the step, return keyword as input_text.**
+if step is verifying value of element then extract value which is being verified only not any other words in the step. 
+- Extract keyword from the step, if the step contains any keyword.
+- if no matching element found for the step return attribute_value as only 'Fire-Flink-0' dont give Fire-Flink-x or any string .
+- 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'.
+- **Respond with valid JSON only. don't return any other text or don't return response in list format**
+`;
+    return prompt;
+}

package/dist/ai/llmprompts/systemPrompts/verifyActionExtractorPromptMob.d.ts

@@ -0,0 +1,2 @@
+import { verifyActionArgs } from "../llmPromptTypes/systemPromptTypes";
+export declare function verifyActionExtractorPromptMob({ extractedDomJson, priorAndNextSteps, }: verifyActionArgs): Promise<string>;