ff-automationv2 2.2.27 → 2.2.29

package/dist/ai/llmcalls/llmAction.d.ts

@@ -2,15 +2,20 @@ import { FireFlinkLLMResponse } from "../../core/types/llmResponseType.js";
 import { PromptArgsMap } from "../../core/interfaces/promptInterface.js";
 import { platform } from "../../core/types/scriptTypesType.js";
 export declare class llmAction {
-    private client;
-    private visionClient;
     private model;
     private visionApiKey;
-    constructor(apiKey: string, baseURL: string, model: string, visionApiKey: string);
-    getLLMResponse<K extends keyof PromptArgsMap>(platform: platform, type: K, args: PromptArgsMap[K], userInput: Record<string, any>): Promise<FireFlinkLLMResponse>;
+    private apiKey;
+    private provider;
+    private serviceProvider;
+    private visionProvider;
+    constructor(apiKey: string, provider: any, model: string, visionApiKey: string, accountType: string, enterpriseConfigFile: any, serviceProvider: string);
+    getLLMResponse<K extends keyof PromptArgsMap>(platform: platform, type: K, args: PromptArgsMap[K], userInput: Record<string, any>, isVision: boolean): Promise<FireFlinkLLMResponse>;
     private getLLMResponseText;
+    private getProviderToUse;
     private getLLMResponseWithVision;
     private isInvalidLLMOutput;
     private handleKnownErrors;
     private buildRetryFailure;
+    private extractValidatedJson;
+    private getProviderOptions;
 }

package/dist/ai/llmcalls/llmAction.js

@@ -1,65 +1,92 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.llmAction = void 0;
 const promptRegistry_js_1 = require("../llmprompts/promptRegistry.js");
-const openai_1 = __importDefault(require("openai"));
-const decodeApiKey_js_1 = require("./decodeApiKey.js");
 const userPrompt_js_1 = require("../../ai/llmprompts/userPrompts/userPrompt.js");
 const promptType_js_1 = require("../../core/types/promptType.js");
 const logData_js_1 = require("../../utils/logger/logData.js");
+const ai_1 = require("ai");
+const FireFlinkResponseSchema_js_1 = require("../../automation/actions/interface/FireFlinkResponseSchema.js");
+const llmConfiguration_js_1 = require("../../llmConfig/llmConfiguration.js");
 class llmAction {
-    constructor(apiKey, baseURL, model, visionApiKey) {
-        this.model = model;
+    constructor(apiKey, provider, model, visionApiKey, accountType, enterpriseConfigFile, serviceProvider) {
+        this.apiKey = apiKey;
+        this.provider = provider;
+        this.serviceProvider = serviceProvider;
+        if (model.startsWith("publishers/google/models/")) {
+            this.model = `${model.split("/").pop()}`;
+        }
+        else if (model.startsWith("publishers/meta/models/")) {
+            this.model = `${model.split("/").pop()}`;
+        }
+        else if (model.startsWith("models/")) {
+            this.model = model.split("/").pop();
+        }
+        else {
+            this.model = model;
+        }
         this.visionApiKey = visionApiKey;
-        this.client = new openai_1.default({
-            apiKey: (0, decodeApiKey_js_1.decodeApiKey)(apiKey),
-            baseURL: baseURL,
-        });
-        this.visionClient = new openai_1.default({
-            apiKey: (0, decodeApiKey_js_1.decodeApiKey)(this.visionApiKey ?? "c2stcHJvai1HVTVlZGt4UDJEQXVBa29IbzB0MXdsTWFrWjljNnlQQjEtdUdGLXloZmhIclhEYnZubHo0M0l4QUoyME5Pc0hGYUw2OUFkdG5kOVQzQmxia0ZKQzUxTFJZX09aQzNzRHBOYjN5XzM5SUY4UXpBZElSU2ZBQ21wZjRtZG1OUzBlWXRhUjhudGhWdUktb2djeVBSMW1PdVpEdU83UUE="),
-        });
     }
-    async getLLMResponse(platform, type, args, userInput) {
+    async getLLMResponse(platform, type, args, userInput, isVision) {
         const promptBuilder = promptRegistry_js_1.prompts[platform][type];
         const systemPrompt = await promptBuilder(args);
         const userPrompt = userPrompt_js_1.userInputFormatters[type](userInput);
         if (type === promptType_js_1.PromptType.VISION_PROMPT && Array.isArray(userPrompt)) {
-            return this.getLLMResponseWithVision(systemPrompt, userPrompt);
+            return this.getLLMResponseWithVision(systemPrompt, userPrompt, isVision);
         }
         if (typeof userPrompt !== "string") {
             throw new Error("Invalid non-vision user prompt format");
         }
-        return this.getLLMResponseText(systemPrompt, userPrompt);
+        return this.getLLMResponseText(platform, systemPrompt, userPrompt, type, args);
     }
-    async getLLMResponseText(system, user) {
+    async getLLMResponseText(platform, system, user, type, args) {
         let attempt = 0;
         const MAX_RETRIES = 5;
-        // const startTime = new Date().getTime()
+        const startTime = new Date().getTime();
+        const schemaToUse = (0, FireFlinkResponseSchema_js_1.getSchemaForPrompt)(type, platform, args);
         while (attempt < MAX_RETRIES) {
             attempt++;
             try {
-                const response = await this.client.chat.completions.create({
-                    model: this.model,
+                const response = await (0, ai_1.generateText)({
+                    model: this.provider(this.model),
                     messages: [
                         { role: "system", content: system },
                         { role: "user", content: user },
                     ],
-                    response_format: { type: "json_object" },
+                    output: ai_1.Output.object({
+                        schema: schemaToUse,
+                    }),
+                    providerOptions: this.getProviderOptions()
                 });
-                const content = response.choices?.[0]?.message?.content;
-                logData_js_1.logger.info(`LLM Attempt ${attempt} - Raw Response:`, content);
-                if (this.isInvalidLLMOutput(content)) {
+                const rawText = response.output;
+                const parsedContent = rawText;
+                logData_js_1.logger.info(`LLM Attempt ${attempt} - Raw Response:`, parsedContent);
+                if (this.isInvalidLLMOutput(parsedContent)) {
                     logData_js_1.logger.error(`Invalid LLM output. Retrying (${attempt})`);
                     continue;
                 }
-                // logger.info("Time taken to get LLM response (Text):", Date.now() - startTime, "ms");
-                return response;
+                await logData_js_1.logger.info("Time taken to get LLM response (Text):", Date.now() - startTime, "ms");
+                return {
+                    ...response,
+                    output: parsedContent
+                };
             }
             catch (error) {
                 logData_js_1.logger.error(`LLM Error Attempt ${attempt}:`, error);
+                logData_js_1.logger.error(`Cause is ${error.cause}`, error.cause);
+                if (ai_1.NoObjectGeneratedError.isInstance(error) && error.text) {
+                    try {
+                        const recovered = this.extractValidatedJson(error.text, schemaToUse);
+                        await logData_js_1.logger.info("Time taken to get LLM response (Text, recovered):", Date.now() - startTime, "ms");
+                        return {
+                            text: error.text,
+                            output: recovered
+                        };
+                    }
+                    catch (recoveryError) {
+                        logData_js_1.logger.error(`Regex recovery also failed on attempt ${attempt}:`, recoveryError);
+                    }
+                }
                 const structuredError = this.handleKnownErrors(error);
                 if (structuredError)
                     return structuredError;
@@ -67,32 +94,82 @@ class llmAction {
         }
         return this.buildRetryFailure();
     }
-    async getLLMResponseWithVision(system, userPrompt) {
+    async getProviderToUse(isVision) {
+        if (this.serviceProvider === "DefaultFireFlink" && isVision) {
+            if (!this.visionProvider) {
+                const configProvider = new llmConfiguration_js_1.ServiceProviderProviderConfiguration();
+                this.visionProvider = await configProvider.getProvider({
+                    serviceProvider: "OpenAi",
+                    apiKey: this.visionApiKey,
+                });
+            }
+            return this.visionProvider;
+        }
+        return this.provider;
+    }
+    async getLLMResponseWithVision(system, userPrompt, isVision = false) {
         let attempt = 0;
         const MAX_RETRIES = 5;
-        // const startTime = new Date().getTime()
+        let content;
+        const startTime = new Date().getTime();
+        const providerToUse = await this.getProviderToUse(isVision);
+        const modelToUse = (this.serviceProvider === "DefaultFireFlink" && isVision) ? "gpt-4.1" : this.model;
         while (attempt < MAX_RETRIES) {
             attempt++;
             try {
-                const response = await this.visionClient.chat.completions.create({
-                    model: "gpt-4.1",
+                const parts = userPrompt.map((item) => {
+                    if (item.type === "input_text") {
+                        return {
+                            type: "text",
+                            text: item.text,
+                        };
+                    }
+                    let imageValue = item.image_url;
+                    if (item.image_url.startsWith("http://") || item.image_url.startsWith("https://")) {
+                        imageValue = new URL(item.image_url);
+                    }
+                    return {
+                        type: "image",
+                        image: imageValue,
+                    };
+                });
+                const response = await (0, ai_1.generateText)({
+                    model: providerToUse(modelToUse),
                     messages: [
                         { role: "system", content: system },
-                        { role: "user", content: userPrompt },
+                        { role: "user", content: parts },
                     ],
-                    response_format: { type: "json_object" },
+                    output: ai_1.Output.object({
+                        schema: FireFlinkResponseSchema_js_1.VisionSchema,
+                    }),
+                    providerOptions: this.getProviderOptions()
                 });
-                const content = response.choices?.[0]?.message?.content;
-                logData_js_1.logger.info(`Vision LLM Attempt ${attempt} - Raw Response:`, content);
+                content = response.output;
+                const parsedContent = content;
+                logData_js_1.logger.info(`Vision LLM Attempt ${attempt} - Raw Response:`, parsedContent);
                 if (this.isInvalidLLMOutput(content)) {
                     logData_js_1.logger.error(`Invalid Vision output. Retrying (${attempt})`);
                     continue;
                 }
-                // logger.info("Time taken to get LLM response (vision):", Date.now() - startTime, "ms");
+                await logData_js_1.logger.info("Time taken to get LLM response (vision):", Date.now() - startTime, "ms");
                 return response;
             }
             catch (error) {
-                logData_js_1.logger.error(`Vision LLM Error Attempt ${attempt}:`);
+                logData_js_1.logger.error(`Vision LLM Error Attempt ${attempt}:`, error);
+                if (ai_1.NoObjectGeneratedError.isInstance(error) && error.text) {
+                    try {
+                        const recovered = this.extractValidatedJson(error.text, FireFlinkResponseSchema_js_1.VisionSchema);
+                        logData_js_1.logger.info(`Vision LLM Attempt ${attempt} - Recovered via regex fallback:`, recovered);
+                        await logData_js_1.logger.info("Time taken to get LLM response (vision, recovered):", Date.now() - startTime, "ms");
+                        return {
+                            text: error.text,
+                            output: recovered
+                        };
+                    }
+                    catch (recoveryError) {
+                        logData_js_1.logger.error(`Regex recovery also failed on attempt ${attempt}:`, recoveryError);
+                    }
+                }
                 const structuredError = this.handleKnownErrors(error);
                 if (structuredError)
                     return structuredError;
@@ -148,5 +225,64 @@ class llmAction {
             rawError: "Max retry limit reached",
         };
     }
+    extractValidatedJson(rawText, schemaToUse) {
+        const trimmed = rawText.trim();
+        const jsonMatch = trimmed.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error("No JSON object found in LLM response");
+        }
+        const parsedJson = JSON.parse(jsonMatch[0]);
+        return schemaToUse.parse(parsedJson);
+    }
+    getProviderOptions() {
+        switch (this.serviceProvider) {
+            case "OpenAI":
+                return {
+                    openai: {
+                        reasoningEffort: "low",
+                    },
+                };
+            case "Anthropic":
+                return {
+                    anthropic: {
+                        effort: "low",
+                    },
+                };
+            case "Gemini":
+                if (this.model.startsWith("gemini-2")) {
+                    return {
+                        google: {
+                            thinkingConfig: {
+                                thinkingBudget: 128,
+                            },
+                        },
+                    };
+                }
+                if (this.model.startsWith("gemini-3")) {
+                    return {
+                        google: {
+                            thinkingConfig: {
+                                thinkingLevel: "low",
+                            },
+                        },
+                    };
+                }
+                return {};
+            case "Groq":
+                return {
+                    groq: {
+                        reasoningEffort: "low",
+                    },
+                };
+            case "Azure_AI":
+                return {
+                    openai: {
+                        reasoningEffort: "low",
+                    },
+                };
+            default:
+                return {};
+        }
+    }
 }
 exports.llmAction = llmAction;

package/dist/ai/llmcalls/parseLlmOputput.js

@@ -19,25 +19,37 @@ class LLMResultParser {
             throw llmOutput;
         }
         try {
-            const content = llmOutput?.choices?.[0]?.message?.content;
+            let content;
+            if (llmOutput?.output) {
+                content = llmOutput?.output;
+            }
+            else if (llmOutput?.output_text) {
+                content = llmOutput?.output_text;
+            }
             if (!content) {
                 throw new Error("No content in LLM output");
             }
+            // if (typeof content === "string") {
+            //     content = content
+            //         .replace(/^[\s\S]*?(?=\{)|(?<=\})[\s\S]*$/g, "")
+            //         .trim();
+            // }
             let parsedContent;
             try {
                 parsedContent = JSON.parse(content);
             }
             catch {
-                const extracted = this.extractJsonObject(content);
-                if (!extracted) {
+                // const extracted = this.extractJsonObject(content);
+                if (!content) {
                     throw new Error("Could not extract valid JSON from LLM response");
                 }
-                parsedContent = extracted;
+                parsedContent = content;
             }
             const usage = llmOutput?.usage ?? {};
-            this.inputTokens += Number(usage.prompt_tokens ?? 0);
-            this.outputTokens += Number(usage.completion_tokens ?? 0);
+            this.inputTokens += Number(usage.input_tokens ?? 0);
+            this.outputTokens += Number(usage.output_tokens ?? 0);
             this.totalTokens += Number(usage.total_tokens ?? 0);
+            // logger.info(`tokens : ${usage.output_tokens} + ${usage.input_tokens} = ${usage.total_tokens}`);
             // logger.info(`Total tokens for this call is : ${usage.total_tokens}`);
             return { response: parsedContent };
         }

package/dist/ai/llmprompts/promptRegistry.js

@@ -39,5 +39,16 @@ exports.prompts = {
         getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
         combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
         waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
+    },
+    ios: {
+        userStoryToList: userStoryToListPrompt_js_1.androidbuildStepExtractionPrompt,
+        keywordExtractorPrompt: mobileKeywordExtractor_js_1.keywordExtractorMobile,
+        errorDescriptionPrompt: errorDescriptionPrompt_js_1.buildErrorDescriptionPrompt,
+        ffInspectorNumExtractor: fireflinkElementIndexExtractor_Mob_js_1.ffInspectorNumExtractorMob,
+        verifyActionExtractorPrompt: verifyActionExtractorPromptMob_js_1.verifyActionExtractorPromptMob,
+        visionPrompt: visionPromptMobile_js_1.visionPromptMobile,
+        getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
+        combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
+        waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
     }
 };

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

@@ -2,35 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.keywordExtractor = keywordExtractor;
 async function keywordExtractor({ priorAndNextSteps }) {
-    const allowedActions = ["enter", "wait", "verify", "scroll", "navigate", "navigateBack", "click", "maximize", "minimize", "get", "upload", "close", "open", "drag_and_drop", "switch", "cleartext"];
+    const allowedActions = ["enter", "wait", "verify", "scroll", "navigate", "navigateBack", "click", "maximize", "minimize", "get", "upload", "close", "open", "drag_and_drop", "switch", "cleartext", "notwebopenaction", "mouseAction"];
     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.
     Rules:
     - Only give response for the current step.
     - understand the step and context from the ${JSON.stringify(priorAndNextSteps)}.and keywords should be from step. it should not be related to other steps.
-    - 3 to 5 keywords maximum. dont give more than 5 keywords. and no need for casesensitive.And first keyword should be full keyword from step same as mentioned.like (click on search bar.in -> "search bar.in")
+    - Keywords must represent ONLY the element label or visible text, never add action or instruction words in keywords.
+    - If an element type is mentioned (e.g., icon, button, dropdown, text) in step.You should not add type is not mentioned in step , generate two keywords:
+       First keyword must be the pure element name
+        Second keyword should combine element name + type
+        Example: "click on x icon" → "x", "x icon" 
+    -  When a step contains two elements connected by a positional or relational phrase, keywords MUST contain at least one keyword from each element (reference and targe). Never omit the reference element. Example: "Click on x above y" → ["x", "y"].
+    - 3 to 5 keywords maximum. dont give more than 5 keywords. and no need for casesensitive.
+    - 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.
+    example: step open browser,x:\\x\\x\\x,default -> ["path:c:\\x\\x\\x","profile:default"] 
+    - 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.
+    - If icon is metioned in step than 'svg' should add in keywords and for Upload action first keyword should be 'file'.
+    - If step is about selecting, include keywords for both the source and the selected value (example: select 'x' in 'y' → "y", "x"), ensuring both are meaningful.
     - If the step is about entering text or Uploading file, Should NOT include input value from the step into keywords.
     - 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 and for Upload action first keyword should be 'file'.
-    - First keywords should be from step next Keywords must be distinct and based on the element's label meaning only.
-    - If a keyword contains exactly two words, you MUST always include both the spaced and concatenated (no-space) versions; omission of either is invalid.
+    - **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].**
     - 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 or combine them with relation words.
-    - Example: Click on Sign In above Create Account button → ["Sign In", "SignIn", "Create Account", "CreateAccount"] never break kewword like ["create", "account"]
+    - 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.
     - 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 like ["Sign In", "SignIn", "Add to Cart", "AddToCart"] and Never split them and also for keywords you generated, should not split them like ["sign", "in","add","to","cart"].
     - 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.
-    - 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.
+    - Set action to notwebopenaction only when the instruction is related to a desktop application, 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.
+    - 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:
     {
     "keywords": [key1,key2,key3,key4,key5],

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

@@ -12,23 +12,24 @@ Select the perfect matching NLP name from the list that best fits the step's int
 
 Return **only valid JSON** in the following format:
 {
-  "attribute_value": "Fire-Flink-x",
+  "attributeValue": "Fire-Flink-x",
   "nlpName": "x",
-  "input_text":"x",
+  "inputText":"x",
   "keyword": "x",
-  "element_type": "x",
+  "elementType": "x",
   "keycode": "x"
 }
 Rules:
 - nlpName must be exactly one from the provided list.
 - Use context from the steps : ${priorAndNextSteps}, keyword and json to search for FF-inspecter.
 - **Find the FF-inspecter attribute value of the element in the Simplified JSON whose text or attributes best match the step.**
-- If step has mutipul inputs add all in input_text and all matched attribute_value also.
-- Extract input_text from the step, if you can't find any input text in the step, return keyword as input_text.input can be number, app package, apk file path.dont include extra words.
+- If step has mutipul inputs add all in inputText and all matched attributeValue also.
+- Extract inputText from the step, if you can't find any input text in the step, return keyword as inputText.input can be number, app package, apk file path.dont include extra words.
 - Extract keyword from the step, if the step contains any keyword.
 - Extract keycode of keys if the step contains any key name like ENTER,SPACE,BACKSPACE etc and give keycode of the given key.
-- Use the closest semantic match for the step; return attribute_value as Fire-Flink-0, only if nothing is found.
+- Use the closest semantic match for the step; return attributeValue as Fire-Flink-0, only if nothing is found.
 - Based on step give most relevant type of element. use this list to choose 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 ONLY a valid JSON object; the response must start with '{' and end with '}', with no markdown, code fences, explanations, or extra text.
 - Respond with valid JSON only.
 `;
     return prompt;

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

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

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

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