ff-automationv2 2.2.31 → 2.2.32-beta.0

package/dist/ai/llmprompts/llmPromptTypes/systemPromptTypes.d.ts

@@ -35,3 +35,6 @@ export type combinedActionArgs = {
     extractedDomJson: string;
     priorAndNextSteps: string[];
 };
+export type inputContextArgs = {
+    inputStepsContext: any[];
+};

package/dist/ai/llmprompts/promptRegistry.js

@@ -16,8 +16,10 @@ const mobileKeywordExtractor_js_1 = require("./systemPrompts/mobileKeywordExtrac
 const combinedActionExtractorPromptMob_js_1 = require("./systemPrompts/combinedActionExtractorPromptMob.js");
 const waitActionExtractorPromptMob_js_1 = require("./systemPrompts/waitActionExtractorPromptMob.js");
 const waitActionExtractorPrompt_js_1 = require("./systemPrompts/waitActionExtractorPrompt.js");
-const combinedActionExtractorPrompt_js_1 = require("./systemPrompts/combinedActionExtractorPrompt.js");
+const inputContextPrompt_js_1 = require("./systemPrompts/inputContextPrompt.js");
+// import { combinedActionExtractorPrompt } from "./systemPrompts/combinedActionExtractorPrompt.js";
 const otpExtractorPrompt_js_1 = require("./systemPrompts/otpExtractorPrompt.js");
+const fileVerifyActionExtractorPrompt_js_1 = require("./systemPrompts/fileVerifyActionExtractorPrompt.js");
 exports.prompts = {
     web: {
         userStoryToList: userStoryToListPrompt_js_1.buildStepExtractionPrompt,
@@ -27,9 +29,11 @@ exports.prompts = {
         verifyActionExtractorPrompt: verifyActionExtractorPrompt_js_1.verifyActionExtractorPrompt,
         visionPrompt: visionPrompt_js_1.visionPrompt,
         getActionExtractorPrompt: getActionExtractorPrompt_js_1.getActionExtractorPrompt,
-        combinedActionExtractorPrompt: combinedActionExtractorPrompt_js_1.combinedActionExtractorPrompt,
+        combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
         waitActionExtractorPrompt: waitActionExtractorPrompt_js_1.waitActionExtractorPrompt,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
         otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
     },
     android: {
         userStoryToList: userStoryToListPrompt_js_1.androidbuildStepExtractionPrompt,
@@ -41,7 +45,9 @@ exports.prompts = {
         getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
         combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
         waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
         otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
     },
     ios: {
         userStoryToList: userStoryToListPrompt_js_1.androidbuildStepExtractionPrompt,
@@ -53,6 +59,8 @@ exports.prompts = {
         getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
         combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
         waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
         otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
     }
 };

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.keywordExtractor = keywordExtractor;
 async function keywordExtractor({ priorAndNextSteps }) {
-    const allowedActions = ["enter", "refresh", "wait", "verify", "scroll", "navigate", "navigateBack", "click", "maximize", "minimize", "get", "upload", "close", "open", "drag_and_drop", "switch", "cleartext", "notwebopenaction", "mouseAction", "switchToAndroid", "getOtp", "enterOtp"];
+    const allowedActions = ["enter", "refresh", "wait", "verify", "scroll", "navigate", "navigateBack", "click", "maximize", "minimize", "get", "upload", "close", "open", "drag_and_drop", "switch", "cleartext", "notwebopenaction", "mouseAction", "switchToAndroid", "getOtp"];
     const prompt = `
 You are an expert in Web application testing.
     From the step, extract ONLY the meaningful keywords so that i can search for the element in the dom.
@@ -11,19 +11,20 @@ You are an expert in Web application testing.
     - understand the step and context from the ${JSON.stringify(priorAndNextSteps)}.and keywords should be from step. it should not be related to other steps.
     - Keywords must represent ONLY the element label or visible text, never add action or instruction words in keywords.
     - Element name + type keywords: strip action words, leaving the core element name and any
-  type word(s) attached to it (icon, button, dropdown, filter, tab, field, etc., in the order
-  they appear in the step). Build keywords as a growing chain starting from the core name and
-  adding one more type word each time: [name], [name+type1], [name+type1+type2], ...
-  The core name alone is ALWAYS keyword 1 — never drop it, no matter how many type words follow.
-  Treat "input field", "text field", "search box", "check box", "drop down" as ONE type word,
-  not two.
+    type word(s) attached to it (icon, button, dropdown, filter, tab, field, etc., in the order
+    they appear in the step). Build keywords as a growing chain starting from the core name and
+    adding one more type word each time: [name], [name+type1], [name+type1+type2], ...
+    The core name alone is ALWAYS keyword 1 — never drop it, no matter how many type words follow.
+      Treat "input field", "text field", "search box", "check box", "dropdown" as ONE type word,
+    not two.
   No type word in the step → only [name] as the keyword.
-  Example: "click X filter dropdown" → ["X", "X filter", "X filter dropdown"]
+    Example: "click X filter dropdown" → ["X", "X filter", "X filter dropdown"]
+  If more than 3 type words are attached to the element (chain would exceed 5 keywords), keep the core name plus only the 2-3 type words CLOSEST to the element name and drop the rest, so total keywords stay within the 3-5 max.
     - When a step contains two elements connected by a positional or relational phrase, keywords MUST contain at least one keyword from each element — TARGET element first, then the reference element. Never omit the reference element. Example: "Click on x above y" → x is the target, y is the reference → ["x", "y"].
-    - 3 to 5 keywords maximum. dont give more than 5 keywords. and no need for casesensitive.
+    - 3 to 5 keywords maximum. dont give more then 5 keywords. and no need for case sensitive.
     - General ordering rule: whenever a step involves both a target element and a reference/context element, the TARGET element's keyword(s) must always come FIRST, followed by the reference/context element's keyword(s). This applies to positional/relational steps, selection steps, and any other multi-element step.
     - For the open action if they are not provided anything like profile, capablities in the step in that case don't add them check whether the profile and the capablities are present in the step if not please don't add them.
-    - For the Open action, if a browser path and profile are provided, return keywords as ["path:<path_value>", "profile:<profile_value>"]. Should not remove backslach from path.
+    - For the Open action, if a browser path and profile are provided, return keywords as ["path:<path_value>", "profile:<profile_value>"]. Should not remove backslash from path.
     example: step open browser,x:\\x\\x\\x,default -> ["path:c:\\x\\x\\x","profile:default"] 
     - For the Open action, if the user requests specific browser capabilities/arguments, extract them into the keywords array using the "caps:" prefix followed by one of these exact allowed values: 
       - "headless" (for running in headless / no-gui mode)
@@ -44,37 +45,92 @@ You are an expert in Web application testing.
       - "passwordManager" (for disabling credentials and password manager prompts)
       Do NOT extract or generate any capability strings outside of this list.
     - Do NOT split the keyword into individual words or generate variations such as ["sign", "in"] or ["add", "to", "cart"] for ["Sign In","Add to Cart"]. Only include the original phrase should not add type for first keyword.
-    - If icon is metioned in step than 'svg' should add in keywords and for Upload action first keyword should be 'file'.
-    - If the step is about selecting, include keywords for both the target value and the source/reference, with the TARGET value FIRST and the source/reference SECOND (example: select 'x' in 'y' → "x", "y"), ensuring both are meaningful and action should set to 'click'.
+    - If the step is about selecting/choosing/picking a SINGLE element with no separate reference element present (e.g. "select the Agree checkbox", "select India"), treat it as ONE step: keywords = [target element] only, action = "click".
     - If the step is about entering text or Uploading file, Should NOT include input value from the step into keywords.
-    - If the step is about entering the OTP then give the action as the enterOtp, just only for the entering OTP only.
     - If the step has words like tag name audio, video, image,svg, checkbox etc, include them in the keywords.
-    - **If icon is metioned in step than 'svg' should add in keywords ex: click on x icon -> [x, x icon,svg] and for Upload action first keyword should be 'file'. ex: upload file in x  -> [file,x].**
+    - **If icon is mentioned in step then 'svg' should add in keywords ex: click on x icon -> [x, x icon,svg] and for Upload action first keyword should be 'file'. ex: upload file in x  -> [file,x].**
     - Do NOT split single-word keywords and do NOT include relation terms (above, below, next to, etc.) in keywords.
     - Treat each keyword independently never merge different keywords.
-    - Keywords can be string or number if the step contains a number ,add it also as keyword.
+    - Keywords can be string or number if the step contains a number as part of the ELEMENT's name/label (e.g. "click on Step 2 tab" -> "Step 2" is a keyword). This does NOT apply to numbers that are the value being entered/typed/uploaded — those stay excluded per the "entering text or Uploading file" rule below, even if numeric (e.g. "Enter 5 in Quantity field" -> "5" is NOT a keyword).
     - 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 the step is for the switching to android then provide the action as the switchToAndroid
-    - element_name: extract name of the element that mentioned in the the step.(eg:tap on x -> element_name:x) keep element_name as short as possible and make the first letter of first word of the element_name as capital. beacuse element_name is also used to find element in the dom. and if element_name is not mentioned in step than return action of the step as element_name.
+    - element_name: extract name of the element that mentioned in the the step.(eg:tap on x -> element_name:x) keep element_name as short as possible and make the first letter of first word of the element_name as capital. because element_name is also used to find element in the dom. and if element_name is not mentioned in step then return action of the step as element_name.
     - Set action to notwebopenaction only when the instruction is related to a mobile application, app, application, installed package, or bundle .
-    - action: click for taping, clicking or selecting, enter for entering input, wait for waiting or sleeping,scroll for scrolling and swiping, navigate for navigating to page using url, navigateBack for navigateing back to previous page, get for getting,fetching element,maximize for maximizing browser window, close for closing browser window,open for opening browser window, upload for uploading file using path, drag_and_drop for dragging and dropping element, switch is for switching to tab or window or frame,cleartext for clearing or removing text from element, mouseAction for the action related mouse actions even for mouse click , refresh is for .
+    - action: click for taping, clicking or selecting, enter for entering input, wait for waiting or sleeping,scroll for scrolling and swiping, navigate for navigating to page using url, navigateBack for navigateing back to previous page, get for getting,fetching element,maximize for maximizing browser window, close for closing browser window,open for opening browser window, upload for uploading file using path, drag_and_drop for dragging and dropping element, switch is for switching to tab or window or frame,cleartext for clearing or removing text from element, mouseAction for the action related mouse actions even for mouse click , refresh is for refreshing or reloading pages, getOtp for fetching/reading an OTP value.
     - If mouse action related step is there select mouseAction from the allowed actions list check for the step and provide it.
     - action must be one of from this list  ${JSON.stringify(allowedActions)}.if not one of them, return '0'. if step about set or find action return '0'
-    - For navigate action, keywords should contain only one keyword which is full url from the step and should not include any other text. and if step has another actions, including navigate action, don't return navigate action return another action witch is in the step. and element_name should be "URL".
-    Navigate action is allowed only when the step intent is purely navigation (e.g., "Navigate to URL").
-    If the step includes verification intent (verify/check/confirm/etc), you MUST return "verify" and MUST NOT return "navigate".
-    only give navigate action if step has only navigate action.
-    - 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:
+    - For navigate action, keywords should contain only one keyword which is full url from the step and should not include any other text. and if step has another actions, including navigate action, don't return navigate action return another action which is in the step. and element_name should be "URL".
+    - Navigate action rules:
+      - Use action "navigate" ONLY when the step gives an explicit instruction to go to a URL (e.g., "Navigate to https://x.com"). keywords must contain only the full URL, nothing else. elementName should be "URL".
+      - If the step ONLY checks/confirms the current or already-navigated URL, with NO "go to/navigate to" instruction present in that same step (e.g., "Verify navigated URL", "Get navigated URL"), return whichever action word the step itself uses (verify, get, check, confirm, etc. — never "navigate"), and do NOT split it — it is already a single atomic step. keywords should be ["URL"], elementName "URL".
+    CRITICAL RULES:
+    1.If the step contains multiple actions, you MUST split it into multiple objects in the "steps" array in the same sequence and generate the response object in the same flow.
+      - Each object must represent EXACTLY ONE action.
+      - Preserve the ORIGINAL ORDER of actions strictly.
+      Example 1: "Enter  username , Password as Username and Password and click on button", should be split into 3 steps: 1.Enter Username in Username, 2.Enter Password in Password, 3.Click on button. and elementName for first step should be Username, for second step should be Password and for third step should be click on button.
+    
+    2.If the step contains Select, choose, pick and also contains a connecting word to a reference element ("from", "in", "on", "under") then you must always split into exactly two steps, click on the reference element first and then click on the target value. elementName for the first step should be the reference element (mentioned after the connecting word), and for the second step it should be the target value (mentioned after select/choose/pick). if the step has more than one connecting word then consider only the first one for elementName and keyword extraction.
+      Example: "Select 'India' from Country" → 1.Click on Country, 2.Click on India. elementName for first step should be Country and for second step should be India.
+      Example: "select 'x' in 'y'" → 1.Click on y, 2.Click on x. elementName for first step should be y and for second step should be x.
+    3.If the step contains a compound action (e.g., "Enter text in field and click button"), you MUST split it into separate steps for each action, ensuring that each step is represented as a distinct object in the "steps" array with its own keywords and elementName.
+      Example: "Enter 'John' in Name field and click Submit" → 1.Enter 'John' in Name field, 2.Click on Submit. and elementName for first step should be Name field and for second step should be Submit.
+    4. ONLY IF the step text itself contains BOTH an explicit "go to/navigate to URL" instruction AND a separate URL-checking instruction (e.g., "Navigate to url and verify navigated url"), split into atomic steps with navigate FIRST, then the checking action SECOND, using whichever action word the step itself uses for the second part. Do not split a step that only checks the URL with no navigate instruction present — that stays a single step per the Navigate action rules above.
+    5.Keywords in the multiple steps should be extracted based on single step and it should not contain any keywords from other steps.
+    6. If the step performs the SAME action on TWO OR MORE DIFFERENT target elements joined by "and"/"," (with or without a value), split into separate steps — one per target element — each step keeping the same action (and same value, if any) with its own elementName and keywords. The "step" field for EACH split step must repeat the full action phrase from the original step, not just the element name — this is the one case where "step" is reconstructed rather than a literal substring, since the original sentence never repeated the action for each element.
+      Example (with value): "enter x in both a and b" -> 1. Enter x in a (elementName "a", keywords ["a"], step: "enter x in a"), 2. Enter x in b (elementName "b", keywords ["b"], step: "enter x in b").
+      Example (no value): "get text from a and b" -> 1. Get text from a (elementName "a", keywords ["a"], step: "get text from a"), 2. Get text from b (elementName "b", keywords ["b"], step: "get text from b").
+    
+    - fileType: If the verify action step mentions verifying or checking any file extension or document (e.g. "pdf" or any file extension), extract that file extension in lowercase (without dot, e.g. "pdf") and set it in fileType. For all non-file/UI verification steps, set fileType to null.
+
+    Respond ONLY with valid JSON in this EXACT format:
+
     {
-    "keywords": [key1,key2,key3,key4,key5],
-    "elementName": "x",
-    "action": "x",
-    "liveLog": "Should Generate a short, human-readable description of what the AI is about to do.",
+      "steps": [
+        {
+          "keywords": ["key1", "key2"],
+          "elementName": "element name",
+          "action": ${allowedActions.join("|")},
+          "isStepValueDependable": boolean (true ONLY if action is verify/enter AND the step contains an actual referential phrase pointing to an earlier step's data — see isStepValueDependable rule below for the full test and examples; false if the value is literal or no referential phrase is present. Never consider future steps.),
+          "liveLog": "Should Generate a short, human-readable description of what the AI is about to do.",
+          "fileType": "pdf" | other lowercase file extension | null,
+          "step": Return the original step exactly as-is if it contains a single action; if multiple actions exist, split into atomic steps without changing any wording, spelling, casing, spacing, or punctuation.(Rules: No rephrasing, no additions/removals—each output step must be an exact substring of the input.)
+        }
+      ]
     }
 
+
+    STEP RULES (VERY IMPORTANT):
+
+    - Each "step" MUST represent EXACTLY ONE action.
+    - isStepValueDependable (boolean):
+      • Test is REFERENTIAL vs LITERAL, not sentence completeness — e.g. "enter 2nd step input in name" is a complete sentence but still referential, since the value itself isn't written there.
+      • Set true ONLY when action is 'verify' or 'enter' AND the step contains an actual referential phrase pointing to data from an earlier step (by step number, "previous/prior/earlier/that/same" wording, or naming what was fetched/copied/retrieved there). Confirm the referenced step exists earlier in priorAndNextSteps, never a future step.
+      • Set false when the value is written literally, or no referential phrase is present, or the action isn't verify/enter.
+      • DO NOT infer true from an element/field name alone when that word appears only in the CURRENT step's own target/element — e.g. "get text from Password" is false because "Password" there is just this step's own target, not a value pointing elsewhere.
+      • EXCEPTION — reference-by-element-name: if the VALUE being entered matches (case-insensitively) the elementName or keyword of a 'get' or 'enter' action from an EARLIER step in priorAndNextSteps, treat this as referential (true) even with no explicit pointer wording like "previous"/"same" — this is a common shorthand for "reuse whatever was entered/fetched there". Example: step 2 is "enter santosh@123 in password" (elementName "Password"), step 3 is "enter password in confirm password" → true, because the value "password" matches step 2's elementName, meaning step 3 is reusing step 2's entered value, not typing the literal word "password".
+      • Examples (illustrative, not exhaustive): "enter 2nd step input in name" → true. "enter the OTP received earlier in name" → true. "enter 'John' in name" → false. "get text from Password" → false (no reference present). "enter password in confirm password" (given step 2 entered a value into a "Password" field) → true.
+    - Step MUST be rewritten as a CLEAN and COMPLETE instruction.
+    - Step MUST contain:
+      • action
+      • target element
+      • value (if applicable)
+    - DO NOT copy original sentence if it contains multiple actions.
+    - EXCEPTION: for steps split under Critical Rule 6 (same action repeated across multiple elements), the "step" field is reconstructed to repeat the action phrase per element (see Rule 6) — it will not be a literal substring of the original in this one case.
+    - DO NOT keep unnecessary words like:
+      "select", "choose", "pick", "credentials", "details", etc.
+
+    - ALWAYS normalize action wording:
+
+      Examples:
+      "Select X from Y"
+      "Click on Y"
+      "Click on X"
+
+    - Each step must be SELF-CONTAINED and EXECUTABLE.
+
+
     No other text.
 `;
     return prompt;

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileVerifyActionExtractorPrompt = fileVerifyActionExtractorPrompt;
+async function fileVerifyActionExtractorPrompt({ extractedDomJson, priorAndNextSteps, }) {
+    const nlpList = `VerifyPDF,CompareTwoPdf,VerifyPDFExist,CheckAccessibilityForPdfUsingPython,CheckIfPdfIsXfaFrom,VerifyElementIsDisplayed,VerifyElementIsNotDisplayed,VerifyElementIsEnabled,VerifyElementIsDisabled,VerifyElementIsClickable,VerifyNavigateURL,VerifyIfLinkIsWorking`;
+    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 file and element verification.
+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.
+
+- 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** in the following format:
+{
+  "attributeValue": "Fire-Flink-x",
+  "nlpName": "x",
+  "inputText": "x",
+  "elementType": "x"
+}
+
+Rules:
+- PDF steps: if step specifies checking/verifying text, content, or phrases inside a PDF → choose VerifyPDF and extract the expected text into inputText | if step only verifies the presence, creation, or download of the file without checking inner text → choose VerifyPDFExist with inputText: "".
+- nlpName must be exactly one from the provided list.
+- While matching nlpName with step (ignore spaces, case differences). If multiple NLPs are similar, choose the MOST SPECIFIC and EXACT match.
+- 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.**
+- If no matching element found for the step or if step is file/pdf verification, return attributeValue as 'Fire-Flink-0'.
+- Extract inputText from the step that is being verified (e.g. expected text to verify in PDF or element). If no input text in step, return keyword or empty string "" as inputText.
+- Based on step give most relevant type of element. Use this list to choose elementType: ${elementType}. If elementType 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/fireflinkElementIndexExtactors.js

@@ -15,6 +15,7 @@ async function ffInspectorNumExtractor({ stepAction, extractedDomJson, priorAndN
         "WaitTillAlertIsPresent",
         "VerifyTextPresentOnAlertPopup"
     ];
+    const OtpAction = ["getOtp"];
     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"];
@@ -181,6 +182,40 @@ You are an AI assistant. For the step, extract the element keyword from the step
 - 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 === "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",
+  "variableName": "validVariableName"
+}}
+
+Rules:
+- nlpName must be exactly one from the provided list from here ${OtpAction} and always pick the value as it is.
+- "variableName": Generate a valid, descriptive variable name for storing the fetched OTP value based on the step intent (e.g., valid camelCase identifier such as "otp", "extractedOtp", "smsOtp"). It must be a valid programming identifier (letters, numbers, underscores; cannot start with a number; no spaces or special characters).
+- 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.
+    - variableName: A valid camelCase variable name (e.g. "otp", "extractedOtp") for storing the extracted OTP.
+    - 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 === "click" || stepAction === "cleartext") {
         prompt = `

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

@@ -64,11 +64,13 @@ Return **only valid JSON** in the following format:
   "inputText": "x",
   "timeFrom": "x",
   "waitTime": "x",
-  "activity": "x"
+  "activity": "x",
+  "variableName": "validVariableName"
 }}
 
 Rules:
-- nlpName must be exactly one from the provided list.
+- nlpName must be exactly one from the provided list of ${OtpAction} don't generate any other nlpName.
+- "variableName": Generate a valid, descriptive variable name for storing the fetched OTP value based on the step intent (e.g., valid camelCase identifier such as "otp", "extractedOtp", "smsOtp"). It must be a valid programming identifier (letters, numbers, underscores; cannot start with a number; no spaces or special characters).
 - 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.
@@ -78,6 +80,7 @@ Rules:
     - 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.
+    - variableName: A valid camelCase variable name (e.g. "otp", "extractedOtp") for storing the extracted OTP.
     - 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.`;

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

@@ -27,12 +27,14 @@ Select the perfect matching NLP name from the list that best fits the step's int
   "attributeValue": "Fire-Flink-x",
   "nlpName": "x",
   "inputText":"x",
-  "elementType": "x"
+  "elementType": "x",
+  "variableName": "validVariableName"
 }
 Rules:
 - nlpName must be exactly one from the provided list.
+- "variableName": Generate a valid, descriptive variable name for storing the fetched value based on the step intent (e.g., valid camelCase identifier such as "pageTitle", "extractedText", "userEmail", "itemPrice", "orderId"). It must be a valid programming identifier (letters, numbers, underscores; cannot start with a number; no spaces or special characters).
 - 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.**
+- **Find the FF-inspecter attribute value of the element in the Simplified DOM  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 inputText. inputText 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 inputText in this order "https://app.talentscan.ai/login,https://app.talentscan.ai/sign up,c:jsonpath"

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

@@ -25,10 +25,12 @@ Return **only valid JSON** in the following format:
   "inputText":"x",
   "elementType": "x",
   "locator_type": "x",
-  "attributeType": "x"
+  "attributeType": "x",
+  "variableName": "validVariableName"
 }
 Rules:
 - nlpName must be exactly one from the provided list.
+- "variableName": Generate a valid, descriptive variable name for storing the fetched value based on the step intent (e.g., valid camelCase identifier such as "deviceDate", "extractedText", "batteryLevel", "currentOrientation"). It must be a valid programming identifier (letters, numbers, underscores; cannot start with a number; no spaces or special characters).
 - for screenshots, extract the inputText from the step. like what they what to name image.if not present then leave it empty.
 - Use context from the steps : ${priorAndNextSteps}, 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.**

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputContextPrompt = inputContextPrompt;
+async function inputContextPrompt({ inputStepsContext }) {
+    const prompt = `
+   You are an intelligent assistant that extracts input data for the current step.
+
+Previous steps data:
+${JSON.stringify(inputStepsContext, null, 2)}
+
+Instructions:
+
+1. Analyze the current step and previous steps carefully.
+
+2. Priority rules (strict order):
+   - If a step index or step reference is mentioned (e.g., "step 2", "2nd step", "3rd step", "3nd step", "step 1.1", "sub-step 1.1") → match to the corresponding stepindex (e.g., 2nd step -> stepindex 2, step 1.1 -> sub-step with stepindex "1.1"). If the matched step contains "subSteps", extract from the subStep matching the field name or sub-step index, and extract ONLY from that subStep.
+   - If a field name is mentioned (e.g., email, password, first name) → extract from the matching field step or subStep.
+   - If words like "above", "previous", "same" → extract from the most relevant previous step or subStep.
+
+3. If the step is normal (no reference):
+   - Extract input directly from the current step.
+   - Do NOT use previous steps.
+
+4. Conflict rule:
+   - If both source and destination fields exist (e.g., "enter first name in password"):
+     - Use the SOURCE field value ("first name").
+     - Ignore the destination field ("password").
+
+5. Extraction rules:
+   - Use ONLY given data (previous or current step).
+   - If input exists in the current step, then extract that input only, should not use input from previous steps.
+   - If step is about extracting two values from previous steps, extract both values and return them as an inputText as "input1input2".
+   - Do NOT create or merge values.
+   -If the step modifies an input value from the current or previous steps, return the updated value as "inputText".
+      Example: If the input is "abc" and the step says to add "@123" or and add @ and one number, return "inputText": "abc@123" || "abc@5".
+   - If step is saying to genarate a input using previous steps input values, genarate the input value and return it as "inputText". if that is is Password genarate a strong password.
+   - Always return a single value.
+
+6. Output rules:
+   - "inputText": Return ONLY the input value. inputText must NEVER be empty → fallback to most relevant previous value.
+   - "variableName": Do NOT generate a new variable name. Extract and return the "variableName" from the matching step or subStep in "Previous steps data" (inputStepsContext). If the matched previous step has a "variableName", return that exact variableName. If no variableName is present or no previous step is referenced, return "".
+
+7. Never generate new input. Always follow priority rules strictly.
+
+Respond ONLY with valid JSON:
+
+{
+  "inputText": "x",
+  "variableName": "variableNameFromPreviousStep"
+}
+
+`;
+    return prompt;
+}

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

@@ -34,16 +34,61 @@ Rules:
 - If step is press any key give action as tap.if step is clear or clearandenter give action as enter and if step is open chrome browser app por application and it doesnot have app package or bundle id give action as combined but if step has app package or bundle id give action as openApp.
 - action must be one of from this list ${allowedActions}.if not one of them, return action as 'combined'. if step about set or setting or find, install apk or ipa, uninstall apk or ipa,activate app with app package or bundle id, pinch in or pinch out or related turn wifi or airplane mode return action as 'combined'
 - if the step action is about finding or check app is installed or open chrome browser  or open notification bar or terminate app using app package or bumdle id or running app in the background for some seconds then provide action as combined.
-- 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:
+CRITICAL SPLITTING RULES:
+1. If the step contains multiple actions (two or more, in any combination), you MUST split it into multiple objects in the "steps" array in the same sequence and flow.
+   - Each object must represent EXACTLY ONE action.
+   - Preserve the ORIGINAL ORDER strictly.
+   Example: "Enter 'admin' in Username, '1234' in Password and tap Login" → split into 3 steps:
+   1. Enter 'admin' in Username (action: "enter", elementName: "Username")
+   2. Enter '1234' in Password (action: "enter", elementName: "Password")
+   3. Tap on Login (action: "tap", elementName: "Login")
+   Example: "Enter 'x' in a and tap b" → split into 2 steps:
+   1. Enter 'x' in a (action: "enter", elementName: "a")
+   2. Tap on b (action: "tap", elementName: "b")
+2. If the step contains "select", "choose", "pick" and also contains a connecting reference ("from", "in", "under"):
+   Split into two atomic steps: tap reference element first, then tap target option.
+   Example: "Select 'India' from Country" →
+   1. Tap on Country (action: "tap", elementName: "Country")
+   2. Tap on India (action: "tap", elementName: "India")
+3. If the step performs the SAME action with ONE VALUE into TWO OR MORE DIFFERENT elements:
+   Split into separate steps — one per target element:
+   Example: "Enter '1234' in PIN and Confirm PIN" →
+   1. Enter '1234' in PIN (elementName: "PIN", keywords: ["PIN"])
+   2. Enter '1234' in Confirm PIN (elementName: "Confirm PIN", keywords: ["Confirm PIN"])
+4. Keywords in multiple steps should be extracted based on each individual sub-step only.
+5. If the step performs the SAME action on TWO OR MORE DIFFERENT target elements joined by "and"/"," (with or without a value), split into separate steps — one per target element — each step keeping the same action (and same value, if any) with its own elementName and keywords.
+    Example (with value): "enter x in both a and b" -> 1. Enter x in a (elementName "a", keywords ["a"]), 2. Enter x in b (elementName "b", keywords ["b"]).
+    Example (no value): "get text from a and b" -> 1. Get text from a (elementName "a", keywords ["a"]), 2. Get text from b (elementName "b", keywords ["b"]).
+6. fileType: If the verify action step mentions verifying or checking any file extension or document (e.g. "pdf" or any file extension), extract that file extension in lowercase (without dot, e.g. "pdf") and set it in fileType. For all non-file/UI verification steps, set fileType to null.
+
+Respond ONLY with valid JSON in this EXACT format:
+{
+  "steps": [
     {
-    "keywords": [key1,key2,key3,key4,key5] if step is opening app then keywords should be like ["key1:value1","key2:value2"...],
-    "elementName": "x",
-    "action": "x",
-    "liveLog": "Should Generate a short, human-readable description of what the AI is about to do.for open app dont include whole step jsut give Opening app",
+      "keywords": [key1,key2,key3,key4,key5] if step is opening app then keywords should be like ["key1:value1","key2:value2"...],
+      "elementName": "x",
+      "action": ${allowedActions.join("|")},
+      "isStepValueDependable": boolean (true ONLY if action is verify/enter AND the step contains an actual referential phrase pointing to an earlier step's data — see isStepValueDependable rule below for the full test and examples; false if the value is literal or no referential phrase is present. Never consider future steps.),
+      "liveLog": "Should Generate a short, human-readable description of what the AI is about to do.",
+      "fileType": "pdf" | other lowercase file extension | null,
+      "step": "Clean, complete instruction of the step (or atomic sub-step if split)."
     }
-
-    No other text.
+  ]
+}
+STEP RULES (VERY IMPORTANT):
+- Each "step" MUST represent EXACTLY ONE action.
+- isStepValueDependable (boolean):
+    • Test is REFERENTIAL vs LITERAL, not sentence completeness — e.g. "enter 2nd step input in name" is a complete sentence but still referential, since the value itself isn't written there.
+    • Set true ONLY when action is 'verify' or 'enter' AND the step contains an actual referential phrase pointing to data from an earlier step (by step number, "previous/prior/earlier/that/same" wording, or naming what was fetched/copied/retrieved there). Confirm the referenced step exists earlier in priorAndNextSteps, never a future step.
+    • Set false when the value is written literally, or no referential phrase is present, or the action isn't verify/enter.
+    • DO NOT infer true from an element/field name alone when that word appears only in the CURRENT step's own target/element — e.g. "get text from Password" is false because "Password" there is just this step's own target, not a value pointing elsewhere.
+    • EXCEPTION — reference-by-element-name: if the VALUE being entered matches (case-insensitively) the elementName or keyword of a 'get' or 'enter' action from an EARLIER step in priorAndNextSteps, treat this as referential (true) even with no explicit pointer wording like "previous"/"same" — this is a common shorthand for "reuse whatever was entered/fetched there". Example: step 2 is "enter santosh@123 in password" (elementName "Password"), step 3 is "enter password in confirm password" → true, because the value "password" matches step 2's elementName, meaning step 3 is reusing step 2's entered value, not typing the literal word "password".
+    • Examples (illustrative, not exhaustive): "enter 2nd step input in name" → true. "enter the OTP received earlier in name" → true. "enter 'John' in name" → false. "get text from Password" → false (no reference present). "enter password in confirm password" (given step 2 entered a value into a "Password" field) → true.
+- Step MUST be rewritten as a CLEAN and COMPLETE instruction containing action, target element, and value (if applicable).
+- DO NOT copy original sentence if it contains multiple actions.
+- ALWAYS normalize mobile action wording (e.g., use "Tap on Y", not "Click on Y").
+- Each step must be SELF-CONTAINED and EXECUTABLE.
+No other text.
 `;
     return prompt;
 }

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

@@ -39,10 +39,11 @@ Given the step, the simplified DOM: ${extractedDomJson}, and the list of NLP nam
 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. and only select tags for these nlp's from the given tag list.
+for these nlp's VerifyIfSpecifiedOptionIsSelected,VerifyThatSpecifiedOptionIsNotSelected,VerifyIfOptionWithValueIsSelected,VerifyIfOptionWithValueIsDeselected,VerifyIfOptionWithVisibleTextIsSelected,VerifyIfOptionWithTextIsDeselected,use this precedence: if step mentions word "value" then only match with VerifyIfOptionWithValueIsSelected,VerifyIfOptionWithValueIsDeselected. if step mentions word "text" then only match with VerifyIfOptionWithVisibleTextIsSelected,VerifyIfOptionWithTextIsDeselected. Otherwise go with specified option nlp's (VerifyIfSpecifiedOptionIsSelected,VerifyThatSpecifiedOptionIsNotSelected). and only select tags for these nlp's from the given tag list.
 if step is verify option with index is deselected map to VerifyIfOptionWithIndexIsDeselectedInElement and if step is verify option with index is selected then map to VerifyIfOptionWithIndexIsSelectedInListBox.
 example: verify if email element is present
 nlp name should be VerifyElementIsDisplayed
+- Distinguish element-presence from text-presence: if the step says the ELEMENT/component itself is present/displayed/visible (e.g., "verify email element is present"), map to VerifyElementIsDisplayed. If the step says specific TEXT is present/displayed (e.g., "verify login text is present", "verify 'Login' text is displayed"), map to VerifyText instead (or VerifyPartialText if the step says "partial"/"contains"/"includes").
 - 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** in the following format:
 {
@@ -62,13 +63,13 @@ Rules:
 - For some steps you can see two inputs but you need to understand step and send the required inputText. inputText 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 inputText 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 inputText: "attribute_name,element_name" here attribute_name can be id,text,href etc not fire-flink-x. inputText should be in this format.if they mention css attribute value then inputText should be "css_property,expected_value" from the step only.
+- If step is about checking attribute value then map to attribute nlps and inputText: "attribute_name,expected_value" here attribute_name can be id,text,href etc not fire-flink-x, and expected_value is the value being checked against from the step. inputText should be in this format. if they mention css attribute value then inputText should be "css_property,expected_value" from the step only.
 and also If a step requires comparing two values, provide the input in the format inputText: "value1,value2".
 - if step is about tag name then inputText: "tag name". and if step is about verifying tag name and with count then inputText: "tag name,count". and if any step is about verifying number of elements with xpath then inputText should be "xpath,count"
-- if step is about verifying location then inputText: "coordinates".
+- if step is about verifying location then inputText should be the actual coordinate values from the step, formatted as "x,y" (e.g. "30,50") — never the literal word "coordinates".
 - If the step requires verifying text from an element, only select elements capable of containing text. Do not select image or image-related elements (e.g., img, svg, picture, source).
 - 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 inputText 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 inputText.**
+- **Extract inputText from the step — this is the specific value/text being verified in the step. If the step does not contain any explicit value being verified, return the element or subject name mentioned in the step as inputText instead.**
 if step is verifying value of element then extract value which is being verified only not any other words in the step. 
 - Only for VerifyIfStatusCodeOfAllLinksIsStatusCode extract all links given in step and give in inputText as '[link1,link2,link3...],statusCode'
 - For performance and accessibility score extraction from step, use the inputs from step: [url,device,score] should be in this order. if any input is missing send remining inputs from step itself.

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

@@ -24,7 +24,7 @@ Return **only valid JSON** in the following format:
   "nlpName": "x",
   "inputText":"x"
   "elementType": "x",
-  "locator_type":"x"
+  "locatorType":"x"
 }
 Rules:
 - nlpName must be exactly one from the provided list.

package/dist/ai/llmprompts/userPrompts/userPrompt.js

@@ -12,7 +12,9 @@ exports.userInputFormatters = {
     [promptType_js_1.PromptType.GET_PROMPT]: (userInput) => `Inspect the DOM for the following get context:\n\n${JSON.stringify(userInput.currentStep, null, 2)}`,
     [promptType_js_1.PromptType.COMBINED_ACTION_EXTRACTOR_PROMPT]: (userInput) => `Inspect the DOM for the following wait context:\n\n${JSON.stringify(userInput.currentStep, null, 2)}`,
     [promptType_js_1.PromptType.WAIT_ACTION_EXTRACTOR_PROMPT]: (userInput) => `Inspect the DOM for the following wait context:\n\n${JSON.stringify(userInput.currentStep, null, 2)}`,
+    [promptType_js_1.PromptType.INPUT_CONTEXT_PROMPT]: (userInput) => `Extract the input text from the following context:\n\n${JSON.stringify(userInput.currentStep, null, 2)}`,
     [promptType_js_1.PromptType.OTP_EXTRACTOR]: (userInput) => `Extract the OTP from this SMS body:\n\n${JSON.stringify(userInput.smsBody, null, 2)}`,
+    [promptType_js_1.PromptType.FILE_VERIFY_PROMPT]: (userInput) => `Extract the file verification action data for the following step:\n\n${JSON.stringify(userInput.currentStep, null, 2)}`,
     [promptType_js_1.PromptType.VISION_PROMPT]: (userInput) => {
         let imageBase64 = null;
         if (userInput.annotatedScreenshot) {