ff-automationv2 2.2.28 → 2.2.30

package/dist/core/main/runAutomationScript.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutomationRunner = void 0;
+require("../../utils/sslConfig/apiCallPatch.js");
+const platformContext_js_1 = require("../../utils/helpers/platformContext.js");
 const llmConfiguration_js_1 = require("../../llmConfig/llmConfiguration.js");
 const llmAction_js_1 = require("../../ai/llmcalls/llmAction.js");
-const executionContext_js_1 = require("./executionContext.js");
 const actionHandlerFactory_js_1 = require("../../core/main/actionHandlerFactory.js");
 const stepProcessor_js_1 = require("./stepProcessor.js");
 const fireflinkApi_service_js_1 = require("../../service/api/fireflinkApi.service.js");
@@ -26,6 +27,12 @@ const logData_js_1 = require("../../utils/logger/logData.js");
 const sameActionsHelper_js_1 = require("../../utils/helpers/sameActionsHelper.js");
 const node_console_1 = require("node:console");
 const annotatedScreenshotMobile_js_1 = require("../../imageAnalysisMobile/annotatedScreenshotMobile.js");
+const toon_1 = require("@toon-format/toon");
+const messageType_js_1 = require("../types/messageType.js");
+const platformSyntax_js_1 = require("../../utils/helpers/platformSyntax.js");
+const driverState_js_1 = require("../../automation/driverState.js");
+const SessionManager_js_1 = require("./SessionManager.js");
+const domSanitizer_js_1 = require("../../utils/helpers/domSanitizer.js");
 class AutomationRunner {
     constructor() {
         this.KafkaPayload = {};
@@ -36,38 +43,68 @@ class AutomationRunner {
     static updateSessionTerminationInfo(testCaseId) {
         AutomationRunner.sessionTerminationDetails[testCaseId] = true;
     }
-    async cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkService, request, platform, driver) {
+    static normalizeScriptType(scriptType) {
+        const rawValue = (scriptType ?? "Web").trim();
+        if (!rawValue) {
+            return "Web";
+        }
+        const value = rawValue.toLowerCase();
+        if (value.includes("web") && value.includes("android")) {
+            return "Web";
+        }
+        if (value.includes("android") && value.includes("ios")) {
+            return "Android";
+        }
+        if (value.includes("android")) {
+            return "Android";
+        }
+        if (value.includes("ios")) {
+            return "iOS";
+        }
+        if (value.includes("web")) {
+            return "Web";
+        }
+        return "Web";
+    }
+    async cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkService, request, platform) {
         try {
             logData_js_1.logger.info("Starting cleanup process...");
             domInfo = null;
             extractedRelevantDom = null;
-            if ((context?.session) || (context?.androidSession)) {
-                try {
-                    const platformHandlers = {
-                        android: async () => {
-                            if (driver?.sessionId) {
-                                await driver.deleteSession();
-                            }
-                            logData_js_1.logger.info("Android session deleted successfully");
-                        },
-                        web: async () => {
-                            if (request.isCloud) {
-                                if (driver?.sessionId) {
-                                    await driver.deleteSession();
-                                }
-                                logData_js_1.logger.info("Cloud session closed");
-                            }
-                            if (driver?.sessionId) {
-                                logData_js_1.logger.info("Still browser session is active, session id :", driver.sessionId);
-                            }
+            try {
+                if (context?.session) {
+                    const webDriver = await context.session.getCurrentDriver().catch(() => null);
+                    if (webDriver?.sessionId) {
+                        if (request.isCloud) {
+                            await webDriver.deleteSession();
+                            logData_js_1.logger.info("Cloud web session deleted successfully");
                         }
-                    };
-                    await (platformHandlers[platform] ?? platformHandlers.web)();
+                        else {
+                            logData_js_1.logger.info("Local web session kept alive.");
+                        }
+                    }
                 }
-                catch {
-                    logData_js_1.logger.error("Browser session is deactivated");
+            }
+            catch (err) {
+                logData_js_1.logger.error("Error closing Web session:", err);
+            }
+            try {
+                if (context?.mobileSession) {
+                    const mobileDriver = await context.mobileSession.getCurrentDriver().catch(() => null);
+                    if (mobileDriver?.sessionId) {
+                        if (platform === "ios") {
+                            logData_js_1.logger.info("iOS session is not deleted");
+                        }
+                        else {
+                            await mobileDriver.deleteSession();
+                            logData_js_1.logger.info("Mobile session deleted successfully");
+                        }
+                    }
                 }
             }
+            catch (err) {
+                logData_js_1.logger.error("Error closing Mobile session:", err);
+            }
             if (stepProcessor) {
                 stepProcessor.llm = null;
             }
@@ -85,35 +122,52 @@ class AutomationRunner {
     async run(request) {
         const usedElementNames = [];
         (0, logData_js_1.initLogger)(request.sessionPath);
+        request.type = request.platform;
+        request.platform = AutomationRunner.normalizeScriptType(request.platform);
         logData_js_1.logger.info("User Given Step", request.userStory);
+        const data = JSON.parse(request.scriptName);
+        const hasMoreSteps = data.hasMoreSteps;
+        request.scriptName = data.automationScriptName;
         if (request.isTerminate)
             return AutomationRunner.updateSessionTerminationInfo(request.testCaseId);
         AutomationRunner.sessionTerminationDetails[request.testCaseId] = request.isTerminate;
         const apiService = new fireflinkApi_service_js_1.FireFlinkApiService();
         const fireflinkServiceInstance = new fireflink_service_js_1.fireflinkService(apiService, request.broker, request.sslConfig);
-        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverHost);
+        const instanceDetails = await fireflinkServiceInstance.runGetInstancesDetails(request.projectId, request.token, request.serverHost, request.licenseId);
         const aiInfo = (0, getInstancesInfo_js_1.getAiInstanceInfo)(instanceDetails.responseObject);
-        const context = new executionContext_js_1.ExecutionContext(request);
-        const configProvider = new llmConfiguration_js_1.ServiceProviderBaseUrlProvider();
-        const baseUrl = configProvider.getBaseUrl(aiInfo);
+        let context = SessionManager_js_1.SessionManager.get(request);
+        if (!context) {
+            context = SessionManager_js_1.SessionManager.create(request);
+        }
+        const configProvider = new llmConfiguration_js_1.ServiceProviderProviderConfiguration();
+        const provider = await configProvider.getProvider(aiInfo);
         let domInfo = null;
         let extractedRelevantDom = null;
         let errorInfo = {};
-        const llm = new llmAction_js_1.llmAction(aiInfo.apiKey, baseUrl, aiInfo.model, aiInfo.visionApiKey);
+        const llm = new llmAction_js_1.llmAction(aiInfo.apiKey, provider, aiInfo.model, aiInfo.visionApiKey, aiInfo.accountType, aiInfo.enterpriseConfigFile, aiInfo.serviceProvider);
         let preCapturedDomInfo = null;
         const stepProcessor = new stepProcessor_js_1.StepProcessor(llm);
-        const platform = request.platform.toLocaleLowerCase();
+        let platform = context.activePlatform;
+        (0, platformContext_js_1.setPlatform)(platform);
         const actionHandlers = (0, actionHandlerFactory_js_1.createActionHandlers)(context);
         const domProcessor = new getRelaventElements_js_1.DomProcessingEngine();
         let stepCount = 1;
         const listOfSteps = request.userStory.map(step => String(step));
         let driver;
-        if (listOfSteps.length == 0) {
+        if (listOfSteps.length == 0 && request?.aiExecutionAction !== "stopExecution") {
             logData_js_1.logger.info(listOfSteps);
             throw new Error("No executable manual steps were returned by the LLM.");
         }
+        if (aiInfo.serviceProvider === "DefaultFireFlink") {
+            logData_js_1.logger.info('Service Provider --> DefaultFireFlink');
+        }
+        else {
+            logData_js_1.logger.info(`Service Provider --> ${aiInfo.serviceProvider} and Model --> ${aiInfo.model}`);
+        }
         const start_time = new Date().getTime();
-        for (const step of listOfSteps) {
+        for (const [index, step] of listOfSteps.entries()) {
+            platform = context.activePlatform;
+            (0, platformContext_js_1.setPlatform)(platform);
             let stepResult;
             let stepResultVision;
             let stepAction;
@@ -123,10 +177,70 @@ class AutomationRunner {
             let frameAction;
             let iframeDomHtml = null;
             let doc;
+            let pageDOM;
             let beforeHandles = null;
+            let baseStepActionBeforeFallback;
+            const topic = request.topic;
+            const produceLiveLog = async (message) => {
+                await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                    topic: topic, message: {
+                        topic: "",
+                        service: "",
+                        chatId: "",
+                        aiPromptPayload: {
+                            display: false,
+                            message: "",
+                            messageId: "",
+                            branchId: "",
+                            userId: request.userId,
+                            scriptId: "",
+                            scriptType: "",
+                            type: "logs",
+                            sessionId: "",
+                            licenseId: request.licenseId,
+                            projectId: request.projectId,
+                            liveLogs: {
+                                executionId: request.kafkaMessageKey,
+                                message,
+                                messageType: messageType_js_1.MessageType.LiveLog.retry,
+                            },
+                            attachment: [],
+                        },
+                    }
+                });
+            };
             try {
+                if (request?.aiExecutionAction === "stopExecution") {
+                    break;
+                }
                 if (AutomationRunner.getSessionTerminationInfo(request.testCaseId)) {
                     logData_js_1.logger.info(`Execution terminated successfully. Script: ${request.scriptName}, Test Case ID: ${request.testCaseId}`);
+                    await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                        topic: topic, message: {
+                            topic: "",
+                            service: "",
+                            chatId: "",
+                            aiPromptPayload: {
+                                display: false,
+                                message: "",
+                                messageId: "",
+                                branchId: "",
+                                userId: request.userId,
+                                scriptId: "",
+                                scriptType: "",
+                                type: "logs",
+                                sessionId: "",
+                                licenseId: request.licenseId,
+                                projectId: request.projectId,
+                                liveLogs: {
+                                    executionId: request.kafkaMessageKey,
+                                    message: "Execution terminated by the user",
+                                    messageType: messageType_js_1.MessageType.LiveLog.Termination,
+                                },
+                                attachment: [],
+                            },
+                        }
+                    });
                     break;
                 }
                 logData_js_1.logger.info(`Processing step ${stepCount}: ${step}`);
@@ -139,7 +253,139 @@ class AutomationRunner {
                     args: { priorAndNextSteps },
                     input: { currentStep: step }
                 });
+                if (platform === "android" || platform === "ios") {
+                    if (!driver) {
+                        await context.initializeMobileDriver(result.response.keywords);
+                    }
+                }
+                await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                    topic: topic, message: {
+                        topic: "",
+                        service: "",
+                        chatId: "",
+                        aiPromptPayload: {
+                            display: false,
+                            message: "",
+                            messageId: "",
+                            branchId: "",
+                            userId: request.userId,
+                            scriptId: "",
+                            scriptType: "",
+                            type: "logs",
+                            sessionId: "",
+                            licenseId: request.licenseId,
+                            projectId: request.projectId,
+                            liveLogs: {
+                                executionId: request.kafkaMessageKey,
+                                message: result.response.liveLog,
+                                messageType: messageType_js_1.MessageType.LiveLog.Ongoing,
+                            },
+                            attachment: [],
+                        },
+                    }
+                });
+                logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Ongoing })}`);
                 const action = result.response.action;
+                if (request.scenario && action === 'enter') {
+                    const currentUserStoryStep = request.userStory[index];
+                    if (currentUserStoryStep &&
+                        currentUserStoryStep.length > 1 &&
+                        typeof currentUserStoryStep[1] === 'string' &&
+                        currentUserStoryStep[1].trim() == '') {
+                        throw new Error(`Input is missing for the given step: ${currentUserStoryStep?.[0]}. Please provide the input.`);
+                    }
+                }
+                if (action === 'notwebopenaction') {
+                    throw new Error(`Selected platform is invalid for the step: ${step}`);
+                }
+                if (!allAction_js_1.allKeywordAction.includes(action)) {
+                    throw new Error(`Unsupported action at action or keyword exracter: ${action}`);
+                }
+                let handler = actionHandlers[action];
+                if (supportedActions_js_1.INPUTLESS_ACTIONS.includes(action)) {
+                    logData_js_1.logger.info(result.response.keywords);
+                    await handler({ keywords: result.response.keywords, step: step, driverSession: request.kafkaMessageKey });
+                    stepCount++;
+                    continue;
+                }
+                if (action === "getOtp") {
+                    stepResult = await stepProcessor.getLLMResponse({
+                        platform: platform,
+                        type: promptType_js_1.PromptType.FF_INSPECTOR,
+                        args: {
+                            stepAction: "getOtp",
+                            extractedDomJson: null,
+                            priorAndNextSteps,
+                            isAlert: false,
+                            isDrag: false
+                        },
+                        input: { currentStep: step }
+                    });
+                    const otpAction = platform === "android" || platform === "ios"
+                        ? sameActionsHelper_js_1.sameActionHelper[stepResult.response.nlpName] ||
+                            stepResult.response.nlpName
+                        : stepResult.response.nlpName;
+                    handler = actionHandlers[otpAction];
+                    await handler({
+                        selector: stepResult.response.inputText,
+                        timeFrom: stepResult.response.timeFrom,
+                        waitTime: stepResult.response.waitTime,
+                        activity: stepResult.response.activity,
+                        otpExtractor: async (smsBody) => {
+                            const llmRes = await stepProcessor.getLLMResponse({
+                                platform: platform,
+                                type: promptType_js_1.PromptType.OTP_EXTRACTOR,
+                                args: {},
+                                input: { smsBody }
+                            });
+                            if (llmRes.response?.otp) {
+                                context.extractedOtp = llmRes.response.otp;
+                            }
+                            return llmRes.response;
+                        }
+                    });
+                    stepCount++;
+                    continue;
+                }
+                if (action === "getOtp") {
+                    stepResult = await stepProcessor.getLLMResponse({
+                        platform: platform,
+                        type: promptType_js_1.PromptType.FF_INSPECTOR,
+                        args: {
+                            stepAction: "getOtp",
+                            extractedDomJson: null,
+                            priorAndNextSteps,
+                            isAlert: false,
+                            isDrag: false
+                        },
+                        input: { currentStep: step }
+                    });
+                    const otpAction = platform === "android" || platform === "ios"
+                        ? sameActionsHelper_js_1.sameActionHelper[stepResult.response.nlpName] ||
+                            stepResult.response.nlpName
+                        : stepResult.response.nlpName;
+                    handler = actionHandlers[otpAction];
+                    await handler({
+                        selector: stepResult.response.inputText,
+                        timeFrom: stepResult.response.timeFrom,
+                        waitTime: stepResult.response.waitTime,
+                        activity: stepResult.response.activity,
+                        otpExtractor: async (smsBody) => {
+                            const llmRes = await stepProcessor.getLLMResponse({
+                                platform: platform,
+                                type: promptType_js_1.PromptType.OTP_EXTRACTOR,
+                                args: {},
+                                input: { smsBody }
+                            });
+                            if (llmRes.response?.otp) {
+                                context.extractedOtp = llmRes.response.otp;
+                            }
+                            return llmRes.response;
+                        }
+                    });
+                    stepCount++;
+                    continue;
+                }
                 let elementName = result.response.elementName;
                 if (elementName) {
                     const baseName = elementName;
@@ -153,30 +399,30 @@ class AutomationRunner {
                     result.response.elementName = elementName;
                     usedElementNames.push(elementName);
                 }
-                if (!allAction_js_1.allKeywordAction.includes(action)) {
-                    throw new Error(`Unsupported action at action or keyword exracter: ${action}`);
-                }
-                let handler = actionHandlers[action];
-                if (supportedActions_js_1.INPUTLESS_ACTIONS.includes(action)) {
-                    logData_js_1.logger.info(result.response.keywords);
-                    await handler({ keywords: result.response.keywords, step: step });
-                    stepCount++;
-                    continue;
-                }
-                if (platform == "web") {
-                    driver = await context.session.getCurrentDriver();
+                try {
+                    if (platform == "web") {
+                        driver = await context.session.getCurrentDriver();
+                    }
+                    else {
+                        driver = await context.mobileSession.getCurrentDriver();
+                    }
                 }
-                else {
-                    driver = await context.androidSession.getCurrentDriver();
+                catch (error) {
+                    if (action == "verify") {
+                        driver = null;
+                    }
+                    else {
+                        throw error;
+                    }
                 }
-                if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) && action != "wait") {
+                if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) && !["wait", "verify"].includes(action)) {
                     logData_js_1.logger.info("Alert is present");
                     stepResult = await stepProcessor.getLLMResponse({
                         platform: platform,
                         type: promptType_js_1.PromptType.FF_INSPECTOR,
                         args: {
                             stepAction: action,
-                            extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                            extractedDomJson: null,
                             priorAndNextSteps,
                             isAlert: true,
                             isDrag: false
@@ -186,50 +432,90 @@ class AutomationRunner {
                     stepAction = stepResult.response.action;
                     handler = actionHandlers[stepAction];
                     await handler({
-                        value: stepResult.response.input_text
+                        value: stepResult.response.inputText
                     });
+                    stepCount++;
                     continue;
                 }
                 else {
-                    if (preCapturedDomInfo) {
+                    let toonDom;
+                    if (preCapturedDomInfo && platform === "web") {
                         logData_js_1.logger.info("Using pre-captured DOM from previous toaster detection");
                         domInfo = preCapturedDomInfo;
                         preCapturedDomInfo = null;
+                        const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domInfo.dom));
+                        doc = parser.window.document;
                     }
                     else {
+                        try {
+                            if (platform === "web") {
+                                domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-${stepCount}`);
+                                const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domInfo.dom));
+                                doc = parser.window.document;
+                            }
+                            else {
+                                domInfo = await (0, jsForAttributeInjection_js_2.getAnnotatedDOMForMobile)(driver);
+                                logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-Mob-${stepCount}`);
+                                const parser = new jsdom_1.JSDOM(domInfo.dom, {
+                                    contentType: "text/xml"
+                                });
+                                doc = parser.window.document;
+                            }
+                        }
+                        catch (error) {
+                            if (action == "verify") {
+                                extractedRelevantDom = null;
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                    }
+                    try {
                         if (platform === "web") {
-                            domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
-                            logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-${stepCount}`);
+                            extractedRelevantDom = await domProcessor.webProcess({
+                                keywords: result.response.keywords,
+                                rawDom: domInfo.dom,
+                                stepCount: stepCount,
+                                stepAction: action,
+                                step: step,
+                                platform: platform,
+                                driver: driver
+                            });
+                            toonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                            // logger.saveJSON(extractedRelevantDom, `relevant-dom-${stepCount}`);
+                            logData_js_1.logger.saveText(toonDom, `relevant-dom-toon-${stepCount}`);
                         }
                         else {
-                            domInfo = await (0, jsForAttributeInjection_js_2.getAnnotatedDOMForMobile)(driver);
-                            logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-Mob-${stepCount}`);
+                            extractedRelevantDom = await domProcessor.mobileProcess({
+                                keywords: result.response.keywords,
+                                rawDom: domInfo.dom,
+                                stepCount: stepCount,
+                                stepAction: action,
+                                step: step,
+                                platform: platform,
+                                driver: driver
+                            });
+                            toonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                            // logger.saveJSON(extractedRelevantDom, `relevant-dom-Mob-${stepCount}`);
+                            logData_js_1.logger.saveText(toonDom, `relevant-dom-toon-Mob-${stepCount}`);
                         }
                     }
-                    const parser = new jsdom_1.JSDOM(domInfo.dom);
-                    doc = parser.window.document;
-                    if (platform === "web") {
-                        extractedRelevantDom = domProcessor.webProcess({
-                            keywords: result.response.keywords,
-                            rawDom: domInfo.dom,
-                            stepCount: stepCount
-                        });
-                        logData_js_1.logger.saveJSON(extractedRelevantDom, `relevant-dom-${stepCount}`);
-                    }
-                    else {
-                        extractedRelevantDom = domProcessor.mobileProcess({
-                            keywords: result.response.keywords,
-                            rawDom: domInfo.dom,
-                            stepCount: stepCount
-                        });
-                        logData_js_1.logger.saveJSON(extractedRelevantDom, `relevant-dom-Mob-${stepCount}`);
+                    catch (error) {
+                        if (action == "verify") {
+                            extractedRelevantDom = null;
+                        }
+                        else {
+                            throw error;
+                        }
                     }
                     if (action == "verify") {
                         stepResult = await stepProcessor.getLLMResponse({
                             platform: platform,
                             type: promptType_js_1.PromptType.VERIFY_PROMPT,
                             args: {
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                             },
                             input: { currentStep: step }
@@ -241,7 +527,7 @@ class AutomationRunner {
                             platform: platform,
                             type: promptType_js_1.PromptType.GET_PROMPT,
                             args: {
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                             },
                             input: { currentStep: step }
@@ -253,7 +539,7 @@ class AutomationRunner {
                             platform: platform,
                             type: promptType_js_1.PromptType.WAIT_ACTION_EXTRACTOR_PROMPT,
                             args: {
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                             },
                             input: { currentStep: step }
@@ -265,7 +551,7 @@ class AutomationRunner {
                             platform: platform,
                             type: promptType_js_1.PromptType.COMBINED_ACTION_EXTRACTOR_PROMPT,
                             args: {
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                             },
                             input: { currentStep: step }
@@ -277,7 +563,7 @@ class AutomationRunner {
                             platform: platform,
                             type: promptType_js_1.PromptType.FF_INSPECTOR,
                             args: {
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                                 isDrag: true,
                                 isAlert: false
@@ -291,8 +577,8 @@ class AutomationRunner {
                             platform: platform,
                             type: promptType_js_1.PromptType.FF_INSPECTOR,
                             args: {
-                                stepAction: action,
-                                extractedDomJson: JSON.stringify(extractedRelevantDom, null, 2),
+                                stepAction: action === "enterOtp" ? "enter" : action,
+                                extractedDomJson: toonDom,
                                 priorAndNextSteps,
                                 isAlert: false,
                                 isDrag: false
@@ -305,11 +591,23 @@ class AutomationRunner {
                         else {
                             stepAction = stepResult.response.nlpName;
                         }
+                        if ((action === "enterOtp" || stepAction === "enterOtp") && context.extractedOtp) {
+                            stepResult.response.inputText = context.extractedOtp;
+                        }
                     }
                 }
-                if (platform === "android") {
+                if (platform === "android" || platform === "ios") {
                     stepAction = sameActionsHelper_js_1.sameActionHelper[stepAction] || stepAction;
-                    logData_js_1.logger.info(`step action: ${stepAction}`);
+                    // logger.info(`step action: ${stepAction}`);
+                }
+                if (supportedActions_js_1.SKIPPED_ACTIONS.includes(stepAction)) {
+                    handler = actionHandlers[stepAction];
+                    await handler();
+                    stepCount++;
+                    continue;
+                }
+                if (platform === "web") {
+                    beforeHandles = await driver.getWindowHandles();
                 }
                 if (supportedActions_js_1.ELEMENTLESS_ACTION.includes(stepAction)) {
                     let currentDriver = null;
@@ -319,218 +617,460 @@ class AutomationRunner {
                         beforeHandles = await currentDriver.getWindowHandles();
                     }
                     else {
-                        currentDriver = await context.androidSession.getCurrentDriver();
+                        currentDriver = await context.mobileSession.getCurrentDriver();
                     }
                     handler = actionHandlers[stepAction];
-                    await handler({ value: stepResult.response.input_text });
-                    if ((currentDriver) && (platform == "web")) {
-                        await (0, newTabTracker_js_1.newTabTracker)(currentDriver, action, beforeHandles, context.scriptAppender);
-                    }
-                    stepCount++;
-                    continue;
-                }
-                try {
-                    if (stepAction == "Builtin_DragAndDropToElement") {
-                        handler = actionHandlers[stepAction];
-                        const fireflinkIndex1 = stepResult.response.drag;
-                        const ele1 = doc.querySelector(`[ff-inspect="${fireflinkIndex1}"]`);
-                        const selector1 = ele1?.getAttribute("ff-xpath");
-                        const fireflinkIndex2 = stepResult.response.drop;
-                        const ele2 = doc.querySelector(`[ff-inspect="${fireflinkIndex2}"]`);
-                        const selector2 = ele2?.getAttribute("ff-xpath");
-                        if (!selector2 && !selector1) {
-                            throw new Error(`Unable to resolve xpath for ${fireflinkIndex2}`);
-                        }
-                        else if (fireflinkIndex2 == "Fire-Flink-0" && fireflinkIndex1 == "Fire-Flink-0") {
-                            throw new Error(`Unable to find element for ${step}`);
-                        }
+                    if (stepAction == "getOtp") {
                         await handler({
-                            selector1: selector1,
-                            selector2: selector2,
-                            fireflinkIndex1: fireflinkIndex1,
-                            fireflinkIndex2: fireflinkIndex2,
-                            pageDOM: domInfo.dom,
-                            elementName1: stepResult.response.drag_element_name,
-                            elementName2: stepResult.response.drop_element_name,
-                            elementType1: stepResult.response.drag_element_type,
-                            elementType2: stepResult.response.drop_element_type
+                            selector: stepResult.response.inputText,
+                            activity: stepResult.response.activity,
+                            otpExtractor: async (smsBody) => {
+                                const llmRes = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.OTP_EXTRACTOR,
+                                    args: {},
+                                    input: { smsBody }
+                                });
+                                if (llmRes.response?.otp) {
+                                    context.extractedOtp = llmRes.response.otp;
+                                }
+                                return llmRes.response;
+                            }
                         });
+                        stepCount++;
                         continue;
                     }
-                    fireflinkIndex = stepResult.response.attribute_value;
-                    if (fireflinkIndex == "Fire-Flink-0") {
-                        logData_js_1.logger.error(`element not found for step "${step}"`);
-                        throw new Error(`element not found for step "${step}"`, { cause: node_console_1.error });
-                    }
-                    if (platform === "web") {
-                        const ele = doc.querySelector(`[ff-inspect="${fireflinkIndex}"]`);
-                        selector = ele.getAttribute("ff-xpath");
-                    }
-                    else {
-                        const result = await (0, xpathcreation_js_1.getFFIndexAndXPath)(domInfo.dom, fireflinkIndex);
-                        selector = result.xpathPath;
-                    }
-                    if (!selector) {
-                        logData_js_1.logger.info(`Unable to resolve xpath for ${fireflinkIndex}`);
-                        throw new Error(`Unable to resolve xpath for ${fireflinkIndex}`, { cause: node_console_1.error });
-                    }
-                    if (platform === "web") {
-                        beforeHandles = await driver.getWindowHandles();
-                    }
-                    if (selector.includes("shadow")) {
-                        stepAction = stepAction + "_shadow";
-                        logData_js_1.logger.info(stepAction);
-                    }
-                    else if (selector.includes("iframe")) {
-                        frameAction = "switchToDefaultContent";
-                        handler = actionHandlers[frameAction];
-                        await handler({
-                            driver: driver,
-                        });
-                        const result_if = await driver.executeAsyncScript(jsFindElement_js_1.Find_element_by_ff_js_script, [fireflinkIndex]);
-                        if (!result_if?.success) {
-                            logData_js_1.logger.info("Not found");
-                            return;
-                        }
-                        const { xpath_if, frames, iframe_dom_html } = result_if;
-                        selector = xpath_if;
-                        iframeDomHtml = iframe_dom_html;
-                        frameAction = "switchToFrame";
-                        handler = actionHandlers[frameAction];
-                        await handler({
-                            selector: selector,
-                            fireflinkIndex,
-                            frames: frames,
-                            elementName: result.response.elementName,
-                            elementType: stepResult.response.elementType
-                        });
-                    }
-                    handler = actionHandlers[stepAction];
-                    if (iframeDomHtml != null) {
-                        domInfo = iframeDomHtml;
-                    }
-                    else {
-                        domInfo = domInfo.dom;
-                    }
                     await handler({
-                        selector: selector,
-                        value: stepResult.response.input_text,
-                        fireflinkIndex,
-                        pageDOM: domInfo,
+                        value: stepResult.response.inputText,
+                        selector: stepResult.response.attributeValue,
                         elementName: result.response.elementName,
-                        elementType: stepResult.response.elementType,
-                        num_of_scrolls: stepResult.response.num_of_scrolls,
-                        direction: stepResult.response.direction,
+                        elementType: stepResult.response.elementType
                     });
-                    if (platform === "web") {
-                        if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) != true) {
-                            if (action === "click") {
-                                await driver.executeScript(jsForToaster_js_1.TOAST_WATCHER_JS, []);
-                                await new Promise(resolve => setTimeout(resolve, 100));
-                                const postClickToastDetected = await driver.executeScript("return window.__toastDetected === true;", []);
-                                if (postClickToastDetected) {
-                                    logData_js_1.logger.info(`Toast detected after click`);
-                                    preCapturedDomInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
-                                    logData_js_1.logger.saveDOM(preCapturedDomInfo.dom, `toaster-dom-${stepCount}`);
-                                }
-                            }
-                        }
-                        await (0, newTabTracker_js_1.newTabTracker)(driver, action, beforeHandles, context.scriptAppender);
+                    if ((currentDriver) && (platform == "web")) {
+                        await (0, newTabTracker_js_1.newTabTracker)(currentDriver, action, beforeHandles, context.scriptAppender);
                     }
+                    stepCount++;
+                    continue;
                 }
-                catch (error) {
-                    logData_js_1.logger.error(`execution failed for step "${step}": ${error.message} and going for vision`);
+                baseStepActionBeforeFallback = stepAction;
+                for (let fallbackAttempt = 1; fallbackAttempt <= 2; fallbackAttempt++) {
                     try {
-                        let annotatedScreenshot;
-                        let bounds;
-                        if (platform === "web") {
-                            annotatedScreenshot = await (0, generateAnnotatedScreenshots_js_1.generateAnnotatedScreenshots)(driver);
+                        if (fallbackAttempt > 1) {
+                            logData_js_1.logger.info(`Waiting 5 seconds before retrying step "${step}". Attempt ${fallbackAttempt}`);
+                            await new Promise(resolve => setTimeout(resolve, 5000));
+                            logData_js_1.logger.info(`Retrying step "${step}" after vision fallback failure. Attempt ${fallbackAttempt}`);
+                            // if (result.response.liveLog) {
+                            //   await produceLiveLog(result.response.liveLog);
+                            // }
+                            stepAction = baseStepActionBeforeFallback;
+                            selector = "";
+                            xpath = "";
+                            iframeDomHtml = null;
+                            beforeHandles = null;
+                            if (platform === "web") {
+                                domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-retry-${stepCount}`);
+                                const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domInfo.dom));
+                                doc = parser.window.document;
+                            }
+                            else {
+                                domInfo = await (0, jsForAttributeInjection_js_2.getAnnotatedDOMForMobile)(driver);
+                                logData_js_1.logger.saveDOM(domInfo.dom, `annotated-dom-Mob-retry-${stepCount}`);
+                                const parser = new jsdom_1.JSDOM(domInfo.dom, {
+                                    contentType: "text/xml"
+                                });
+                                doc = parser.window.document;
+                            }
+                            let retryToonDom;
+                            if (platform === "web") {
+                                extractedRelevantDom = await domProcessor.webProcess({
+                                    keywords: result.response.keywords,
+                                    rawDom: domInfo.dom,
+                                    stepCount: stepCount,
+                                    stepAction: action,
+                                    step: step,
+                                    platform: platform,
+                                    driver: driver
+                                });
+                                retryToonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                                logData_js_1.logger.saveText(retryToonDom, `relevant-dom-toon-retry-${stepCount}`);
+                            }
+                            else {
+                                extractedRelevantDom = await domProcessor.mobileProcess({
+                                    keywords: result.response.keywords,
+                                    rawDom: domInfo.dom,
+                                    stepCount: stepCount,
+                                    stepAction: action,
+                                    step: step,
+                                    platform: platform,
+                                    driver: driver
+                                });
+                                retryToonDom = (0, toon_1.encode)(extractedRelevantDom || []);
+                                logData_js_1.logger.saveText(retryToonDom, `relevant-dom-toon-Mob-retry-${stepCount}`);
+                            }
+                            if (action == "verify") {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.VERIFY_PROMPT,
+                                    args: {
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = stepResult.response.nlpName;
+                            }
+                            else if (action == "get") {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.GET_PROMPT,
+                                    args: {
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = stepResult.response.nlpName;
+                            }
+                            else if (action == "wait") {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.WAIT_ACTION_EXTRACTOR_PROMPT,
+                                    args: {
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = stepResult.response.nlpName;
+                            }
+                            else if (action == "combined") {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.COMBINED_ACTION_EXTRACTOR_PROMPT,
+                                    args: {
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = stepResult.response.nlpName;
+                            }
+                            else if (action == "drag_and_drop") {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.FF_INSPECTOR,
+                                    args: {
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                        isDrag: true,
+                                        isAlert: false
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = stepResult.response.nlpName;
+                            }
+                            else {
+                                stepResult = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.FF_INSPECTOR,
+                                    args: {
+                                        stepAction: action,
+                                        extractedDomJson: retryToonDom,
+                                        priorAndNextSteps,
+                                        isAlert: false,
+                                        isDrag: false
+                                    },
+                                    input: { currentStep: step }
+                                });
+                                stepAction = platform == "web"
+                                    ? stepResult.response.action
+                                    : stepResult.response.nlpName;
+                            }
+                            if (platform === "android" || platform === "ios") {
+                                stepAction = sameActionsHelper_js_1.sameActionHelper[stepAction] || stepAction;
+                            }
                         }
-                        else {
-                            const VissionResult = await (0, annotatedScreenshotMobile_js_1.annotateScreenshot)(driver, domInfo.dom);
-                            annotatedScreenshot = VissionResult.boxedImageBuffer;
-                            bounds = VissionResult.boxes;
+                        if (stepAction == "Builtin_DragAndDropToElement") {
+                            handler = actionHandlers[stepAction];
+                            const fireflinkIndex1 = stepResult.response.drag;
+                            const ele1 = doc.querySelector(`[ff-inspect="${fireflinkIndex1}"]`);
+                            const selector1 = ele1?.getAttribute("ff-xpath");
+                            const fireflinkIndex2 = stepResult.response.drop;
+                            const ele2 = doc.querySelector(`[ff-inspect="${fireflinkIndex2}"]`);
+                            const selector2 = ele2?.getAttribute("ff-xpath");
+                            if (!selector2 && !selector1) {
+                                throw new Error(`Unable to resolve xpath for ${fireflinkIndex2}`);
+                            }
+                            else if (fireflinkIndex2 == "Fire-Flink-0" && fireflinkIndex1 == "Fire-Flink-0") {
+                                throw new Error(`Unable to find element for ${step}`);
+                            }
+                            await handler({
+                                selector1: selector1,
+                                selector2: selector2,
+                                fireflinkIndex1: fireflinkIndex1,
+                                fireflinkIndex2: fireflinkIndex2,
+                                pageDOM: domInfo.dom,
+                                elementName1: stepResult.response.drag_element_name,
+                                elementName2: stepResult.response.drop_element_name,
+                                elementType1: stepResult.response.drag_element_type,
+                                elementType2: stepResult.response.drop_element_type
+                            });
+                            continue;
                         }
-                        stepResultVision = await stepProcessor.getLLMResponse({
-                            platform: platform,
-                            type: promptType_js_1.PromptType.VISION_PROMPT,
-                            args: {
-                                priorAndNextSteps
-                            },
-                            input: { currentStep: step, annotatedScreenshot: annotatedScreenshot }
-                        });
-                        fireflinkIndex = stepResultVision.response.fireflinkIndex;
-                        logData_js_1.logger.info(`fireflinkIndex: ${fireflinkIndex}`);
+                        fireflinkIndex = stepResult.response.attributeValue;
                         if (fireflinkIndex == "Fire-Flink-0") {
-                            logData_js_1.logger.error(`vision unable to find element for step "${step}"`);
-                            context.scriptAppender.setErrorNLP(stepAction);
-                            throw new Error(`vision unable to find element for step "${step}"`, { cause: error });
-                        }
-                        if (platform == "android") {
-                            const index = Number(fireflinkIndex.split("-").pop());
-                            const box = bounds[index - 1];
-                            if (!box) {
-                                throw new Error(`No bounds found for index ${index}`, { cause: error });
-                            }
-                            const { x1, y1, x2, y2 } = box;
-                            const boundsStr = `[${x1},${y1}][${x2},${y2}]`;
-                            const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(domInfo.dom, boundsStr);
-                            xpath = result.xpathPath;
-                            fireflinkIndex = result.ffInspector ?? fireflinkIndex;
-                            logData_js_1.logger.info(`fireflinkIndex: ${fireflinkIndex}`);
-                            logData_js_1.logger.info(`xpath: ${xpath}`);
+                            logData_js_1.logger.error(`element not found for step "${step}"`);
+                            throw new Error(`element not found for step "${step}"`, { cause: node_console_1.error });
                         }
-                        else {
+                        if (platform === "web") {
+                            if (!doc) {
+                                logData_js_1.logger.info("doc is undefined. Rebuilding document from domInfo.");
+                                if (!domInfo || !domInfo.dom) {
+                                    domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                }
+                                const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domInfo.dom));
+                                doc = parser.window.document;
+                            }
                             const ele = doc.querySelector(`[ff-inspect="${fireflinkIndex}"]`);
-                            xpath = ele.getAttribute("ff-xpath");
-                            if (!xpath) {
-                                logData_js_1.logger.info(`Unable to resolve xpath for ${fireflinkIndex}`);
-                                context.scriptAppender.setErrorNLP(stepAction);
-                                throw new Error(`Unable to resolve xpath for ${fireflinkIndex}`, { cause: error });
+                            if (ele) {
+                                selector = ele.getAttribute("ff-xpath") || "";
+                            }
+                            else {
+                                const result = (0, xpathcreation_js_1.getWebXPathByFFIndex)(domInfo.dom, fireflinkIndex);
+                                selector = result.xpathPath;
                             }
-                        }
-                        if (iframeDomHtml != null) {
-                            domInfo = iframeDomHtml;
                         }
                         else {
-                            domInfo = domInfo.dom;
+                            const result = await (0, xpathcreation_js_1.getFFIndexAndXPath)(domInfo.dom, fireflinkIndex);
+                            selector = result.xpathPath;
+                        }
+                        if (!selector) {
+                            logData_js_1.logger.info(`Unable to resolve xpath for ${fireflinkIndex}`);
+                            throw new Error(`Unable to resolve xpath for ${fireflinkIndex}`, { cause: node_console_1.error });
+                        }
+                        if (selector.includes("shadow")) {
+                            stepAction = stepAction + "_shadow";
+                            logData_js_1.logger.info(stepAction);
+                        }
+                        else if (selector.includes("iframe")) {
+                            frameAction = "switchToDefaultContent";
+                            handler = actionHandlers[frameAction];
+                            await handler({
+                                driver: driver,
+                            });
+                            const result_if = await driver.executeAsyncScript(jsFindElement_js_1.Find_element_by_ff_js_script, [fireflinkIndex]);
+                            if (!result_if?.success) {
+                                logData_js_1.logger.info("Not found");
+                                return;
+                            }
+                            const { xpath_if, frames, iframe_dom_html } = result_if;
+                            selector = xpath_if;
+                            iframeDomHtml = iframe_dom_html;
+                            frameAction = "switchToFrame";
+                            handler = actionHandlers[frameAction];
+                            await handler({
+                                selector: selector,
+                                frames: frames,
+                                elementName: result.response.elementName,
+                                elementType: stepResult.response.elementType,
+                                pageDOM: domInfo.dom,
+                                fireflinkIndex
+                            });
+                        }
+                        if (selector.includes('svg')) {
+                            const match = /svg\[(\d+)\]/.exec(selector);
+                            const svgIndex = match ? match[1] : "1";
+                            selector = selector.replace(/svg\[\d+\]/, `*[name()='svg'][${svgIndex}]`);
                         }
-                        logData_js_1.logger.info(`elementType: ${stepResult.response.elementType}`);
+                        pageDOM = iframeDomHtml ?? domInfo.dom;
                         handler = actionHandlers[stepAction];
+                        // logger.info(`xpath ------>: ${selector}`)
                         await handler({
-                            selector: xpath,
-                            value: stepResult.response.input_text,
+                            nlpName: stepResult.response.nlpName,
+                            selector: selector,
+                            value: stepResult.response.inputText,
                             fireflinkIndex,
-                            pageDOM: domInfo,
+                            pageDOM: pageDOM,
                             elementName: result.response.elementName,
-                            elementType: stepResult.response.elementType
+                            elementType: stepResult.response.elementType,
+                            numOfScrolls: stepResult.response.numOfScrolls,
+                            direction: stepResult.response.direction,
+                            stepIndex: stepCount,
+                            filteredSteps: listOfSteps,
+                            attributeType: stepResult.response.attributeType,
                         });
-                        if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) != true) {
-                            if (action === "click") {
-                                await driver.executeScript(jsForToaster_js_1.TOAST_WATCHER_JS, []);
-                                await new Promise(resolve => setTimeout(resolve, 100));
-                                const postClickToastDetected = await driver.executeScript("return window.__toastDetected === true;", []);
-                                if (postClickToastDetected) {
-                                    logData_js_1.logger.info(`Toast detected after click`);
-                                    preCapturedDomInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
-                                    logData_js_1.logger.saveDOM(preCapturedDomInfo.dom, `toaster-dom-${stepCount}`);
+                        if (platform === "web") {
+                            if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) != true) {
+                                if (action === "click") {
+                                    await driver.executeScript(jsForToaster_js_1.TOAST_WATCHER_JS, []);
+                                    await new Promise(resolve => setTimeout(resolve, 100));
+                                    const postClickToastDetected = await driver.executeScript("return window.__toastDetected === true;", []);
+                                    if (postClickToastDetected) {
+                                        logData_js_1.logger.info(`Toast detected after click`);
+                                        preCapturedDomInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                        logData_js_1.logger.saveDOM(preCapturedDomInfo.dom, `toaster-dom-${stepCount}`);
+                                    }
                                 }
                             }
+                            if (beforeHandles?.length > 0) {
+                                await (0, newTabTracker_js_1.newTabTracker)(driver, action, beforeHandles, context.scriptAppender);
+                            }
                         }
+                        if (fallbackAttempt === 2) {
+                            await produceLiveLog("Retry successful. Moving on to the next step.");
+                        }
+                        break;
                     }
                     catch (error) {
-                        logData_js_1.logger.error(`vision execution failed for step "${step}": ${error}`);
-                        throw error;
+                        logData_js_1.logger.error(`execution failed for step "${step}": ${error} and going for vision`);
+                        try {
+                            let annotatedScreenshot;
+                            let bounds;
+                            if (action === "scroll") {
+                                throw new Error(`Scroll action failed element not found`, { cause: error });
+                            }
+                            if (platform === "web") {
+                                annotatedScreenshot = await (0, generateAnnotatedScreenshots_js_1.generateAnnotatedScreenshots)(driver);
+                            }
+                            else {
+                                domInfo = await (0, jsForAttributeInjection_js_2.getAnnotatedDOMForMobile)(driver);
+                                let VissionResult;
+                                if (platform === "android") {
+                                    VissionResult = await (0, annotatedScreenshotMobile_js_1.annotateScreenshot)(driver, domInfo.dom);
+                                }
+                                else {
+                                    VissionResult = await (0, annotatedScreenshotMobile_js_1.annotateIosScreenshot)(driver, domInfo.dom);
+                                }
+                                annotatedScreenshot = VissionResult.boxedImageBuffer;
+                                bounds = VissionResult.boxes;
+                            }
+                            if (platform == "web") {
+                                stepResultVision = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.VISION_PROMPT,
+                                    args: {
+                                        priorAndNextSteps
+                                    },
+                                    input: { currentStep: step, annotatedScreenshot: annotatedScreenshot.primary },
+                                    isVision: true
+                                });
+                                if (stepResultVision.response.fireflinkIndex == "Fire-Flink-0") {
+                                    stepResultVision = await stepProcessor.getLLMResponse({
+                                        platform: platform,
+                                        type: promptType_js_1.PromptType.VISION_PROMPT,
+                                        args: {
+                                            priorAndNextSteps
+                                        },
+                                        input: { currentStep: step, annotatedScreenshot: annotatedScreenshot.secondary },
+                                        isVision: true
+                                    });
+                                }
+                            }
+                            else {
+                                stepResultVision = await stepProcessor.getLLMResponse({
+                                    platform: platform,
+                                    type: promptType_js_1.PromptType.VISION_PROMPT,
+                                    args: {
+                                        priorAndNextSteps
+                                    },
+                                    input: { currentStep: step, annotatedScreenshot: annotatedScreenshot },
+                                    isVision: true
+                                });
+                            }
+                            fireflinkIndex = stepResultVision.response.fireflinkIndex;
+                            logData_js_1.logger.info(`fireflinkIndex: ${fireflinkIndex}`);
+                            if (fireflinkIndex == "Fire-Flink-0") {
+                                logData_js_1.logger.error(`vision unable to find element for step "${step}"`);
+                                if (platform === "web") {
+                                    context.scriptAppender.setErrorNLP(stepAction);
+                                }
+                                throw new Error(`vision unable to find element for step "${step}"`, { cause: error });
+                            }
+                            if (platform == "android" || platform == "ios") {
+                                const index = Number(fireflinkIndex.split("-").pop());
+                                const box = bounds[index - 1];
+                                if (!box) {
+                                    throw new Error(`No bounds found for index ${index}`, { cause: error });
+                                }
+                                const { x1, y1, x2, y2 } = box;
+                                const boundsStr = `[${x1},${y1}][${x2},${y2}]`;
+                                const result = (0, xpathcreation_js_1.getFFIndexAndXPath)(domInfo.dom, boundsStr, platform);
+                                xpath = result.xpathPath;
+                                fireflinkIndex = result.ffInspector ?? fireflinkIndex;
+                            }
+                            else {
+                                if (!domInfo || !domInfo.dom || !doc) {
+                                    logData_js_1.logger.info("Re-fetching annotated DOM for vision fallback");
+                                    domInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                    const parser = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(domInfo.dom));
+                                    doc = parser.window.document;
+                                }
+                                const ele = doc.querySelector(`[ff-inspect="${fireflinkIndex}"]`);
+                                if (ele) {
+                                    xpath = ele.getAttribute("ff-xpath") || "";
+                                }
+                                else {
+                                    const result = (0, xpathcreation_js_1.getWebXPathByFFIndex)(domInfo.dom, fireflinkIndex);
+                                    xpath = result.xpathPath;
+                                }
+                                if (!xpath) {
+                                    context.scriptAppender.setErrorNLP(stepAction);
+                                    throw new Error(`Unable to resolve xpath for ${fireflinkIndex}`, { cause: error });
+                                }
+                            }
+                            pageDOM = iframeDomHtml ?? domInfo.dom;
+                            handler = actionHandlers[stepAction];
+                            await handler({
+                                selector: xpath,
+                                value: stepResult.response.inputText,
+                                fireflinkIndex,
+                                pageDOM: pageDOM,
+                                elementName: result.response.elementName,
+                                elementType: stepResult.response.elementType,
+                                stepIndex: stepCount,
+                                filteredSteps: listOfSteps
+                            });
+                            if (platform === "web") {
+                                if (await (0, isAlertPresent_js_1.isAlertPresent)(driver) != true) {
+                                    if (action === "click") {
+                                        await driver.executeScript(jsForToaster_js_1.TOAST_WATCHER_JS, []);
+                                        await new Promise(resolve => setTimeout(resolve, 100));
+                                        const postClickToastDetected = await driver.executeScript("return window.__toastDetected === true;", []);
+                                        if (postClickToastDetected) {
+                                            logData_js_1.logger.info(`Toast detected after click`);
+                                            preCapturedDomInfo = await (0, jsForAttributeInjection_js_1.getAnnotatedDOM)(driver);
+                                            logData_js_1.logger.saveDOM(preCapturedDomInfo.dom, `toaster-dom-${stepCount}`);
+                                        }
+                                    }
+                                }
+                                if (beforeHandles?.length > 0) {
+                                    await (0, newTabTracker_js_1.newTabTracker)(driver, action, beforeHandles, context.scriptAppender);
+                                }
+                            }
+                            if (fallbackAttempt === 2) {
+                                await produceLiveLog("Retry successful. Moving on to the next step.");
+                            }
+                            break;
+                        }
+                        catch (error) {
+                            logData_js_1.logger.error(`vision execution failed for step "${step}": ${error}`);
+                            if (fallbackAttempt < 2) {
+                                await produceLiveLog("Step failed to execute. Waiting a few seconds before reattempting the same step.");
+                                continue;
+                            }
+                            throw error;
+                        }
                     }
                 }
+                baseStepActionBeforeFallback = stepAction;
                 domInfo = null;
                 extractedRelevantDom = null;
                 stepCount++;
             }
             catch (error) {
                 logData_js_1.logger.error(`Error executing step "${step}":`, error);
-                if (error.error === "Context Length Exceeded (400)" ||
-                    error.error === "Rate Limit Exceeded (429)") {
+                if (error?.error) {
                     errorInfo.error = error.error;
                     errorInfo.errorDescription = error.errorDescription;
                     if (context.scriptAppender.getErrorNLP()) {
@@ -551,45 +1091,232 @@ class AutomationRunner {
         }
         logData_js_1.logger.info('execution  time->', new Date().getTime() - start_time);
         const payload = {
-            scriptName: request.scriptName,
-            version: request.version,
+            scriptName: request.scriptName ?? "SCRIPT_NAME",
             type: request.type,
-            scriptType: request.scriptType,
+            scriptType: request.type,
             projectId: request.projectId,
             testCaseId: request.testCaseId,
-            promptId: request.promptId,
             pageDetails: request.pageDetails,
-            generatedBy: request.generatedBy,
-            webSocketId: request.webSocketId,
             licenseType: request.licenseType,
             licenseId: request.licenseId,
             userId: request.userId,
             projectType: request.projectType,
+            platform: (0, platformSyntax_js_1.getPlatformSyntax)(platform),
             tokensConsumed: (await stepProcessor.getResultTokenUsage()).totalTokens,
-            ...(errorInfo && Object.keys(errorInfo).length > 0
-                ? { error: errorInfo }
-                : {})
         };
+        this.KafkaPayload.topic = request.topic;
+        let keepSessionAlive = false;
         try {
-            await context.scriptAppender.waitForAllSteps();
-            logData_js_1.logger.info(context.scriptAppender.getData());
-            this.KafkaPayload.topic = `Topic-FIREFLINK-api-requests-${request.env}`;
-            this.KafkaPayload.message = {
-                ...payload,
-                stepData: context.scriptAppender.getData(),
-                serverHost: request.serverHost
-            };
-            delete payload.tokensConsumed;
-            logData_js_1.logger.info({ ...payload, topic: this.KafkaPayload.topic });
-            await fireflinkServiceInstance.produceMessageToKafka(this.KafkaPayload);
+            if ((errorInfo && Object.keys(errorInfo).length > 0)) {
+                await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                    topic: this.KafkaPayload.topic, message: {
+                        topic: "",
+                        service: "",
+                        chatId: "",
+                        aiPromptPayload: {
+                            display: false,
+                            message: "",
+                            messageId: "",
+                            branchId: "",
+                            userId: request.userId,
+                            scriptId: "",
+                            scriptType: "",
+                            type: "logs",
+                            sessionId: "",
+                            licenseId: request.licenseId,
+                            projectId: request.projectId,
+                            liveLogs: {
+                                executionId: request.kafkaMessageKey,
+                                message: errorInfo.errorDescription ?? "errorDescription unknown",
+                                messageType: messageType_js_1.MessageType.LiveLog.Error,
+                            },
+                            attachment: [],
+                        },
+                    }
+                });
+                logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Error })}`);
+                await context.scriptAppender.waitForAllSteps();
+                if (driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey]) {
+                    driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey].push(...context.scriptAppender.getData());
+                }
+                else {
+                    driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey] = context.scriptAppender.getData();
+                }
+                context.scriptAppender.reset();
+                return;
+            }
+            else {
+                if (request?.aiExecutionAction === "stopExecution") {
+                    await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                        topic: this.KafkaPayload.topic, message: {
+                            topic: "",
+                            service: "",
+                            chatId: "",
+                            aiPromptPayload: {
+                                display: false,
+                                message: "",
+                                messageId: "",
+                                branchId: "",
+                                userId: request.userId,
+                                scriptId: "",
+                                scriptType: "",
+                                type: "logs",
+                                sessionId: "",
+                                licenseId: request.licenseId,
+                                projectId: request.projectId,
+                                liveLogs: {
+                                    executionId: request.kafkaMessageKey,
+                                    message: "Execution stopped",
+                                    messageType: messageType_js_1.MessageType.LiveLog.ExecutionStopped,
+                                },
+                                attachment: [],
+                            },
+                        }
+                    });
+                    logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.ExecutionStopped })}`);
+                }
+                else if (hasMoreSteps) {
+                    keepSessionAlive = true;
+                    await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                        topic: this.KafkaPayload.topic, message: {
+                            topic: "",
+                            service: "",
+                            chatId: "",
+                            aiPromptPayload: {
+                                display: false,
+                                message: "",
+                                messageId: "",
+                                branchId: "",
+                                userId: request.userId,
+                                scriptId: "",
+                                scriptType: "",
+                                type: "logs",
+                                sessionId: "",
+                                licenseId: request.licenseId,
+                                projectId: request.projectId,
+                                liveLogs: {
+                                    executionId: request.kafkaMessageKey,
+                                    message: "Invoke the generate_script_from_scenario tool with the remaining test steps to continue the automation execution from where it left off.",
+                                    messageType: messageType_js_1.MessageType.nextBatch,
+                                },
+                                attachment: [],
+                            },
+                        }
+                    });
+                    logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.nextBatch })}`);
+                    await context.scriptAppender.waitForAllSteps();
+                    if (driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey]) {
+                        driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey].push(...context.scriptAppender.getData());
+                    }
+                    else {
+                        driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey] = context.scriptAppender.getData();
+                    }
+                    context.scriptAppender.reset();
+                }
+                else {
+                    await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                        topic: this.KafkaPayload.topic, message: {
+                            topic: "",
+                            service: "",
+                            chatId: "",
+                            aiPromptPayload: {
+                                display: false,
+                                message: "",
+                                messageId: "",
+                                branchId: "",
+                                userId: request.userId,
+                                scriptId: "",
+                                scriptType: "",
+                                type: "logs",
+                                sessionId: "",
+                                licenseId: request.licenseId,
+                                projectId: request.projectId,
+                                liveLogs: {
+                                    executionId: request.kafkaMessageKey,
+                                    message: "Execution completed",
+                                    messageType: messageType_js_1.MessageType.LiveLog.Completed,
+                                },
+                                attachment: [],
+                            },
+                        }
+                    });
+                    logData_js_1.logger.info(`Message produced to Kafka topic -  ${JSON.stringify({ messageType: messageType_js_1.MessageType.LiveLog.Completed })}`);
+                    await context.scriptAppender.waitForAllSteps();
+                    if (driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey]) {
+                        driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey].push(...context.scriptAppender.getData());
+                    }
+                    else {
+                        driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey] = context.scriptAppender.getData();
+                    }
+                    context.scriptAppender.reset();
+                }
+                // Intermediate batches must only emit nextBatch. Sending AutomationScriptMetaData
+                // here races the chat consumer and is treated as a finished execution.
+                if (!keepSessionAlive) {
+                    this.KafkaPayload.message = {
+                        ...payload,
+                        executionId: request.kafkaMessageKey,
+                        liveLogs: messageType_js_1.MessageType.AutomationScriptMetaData,
+                        stepData: driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey],
+                        serverHost: request.serverHost,
+                        messageType: messageType_js_1.MessageType.AutomationScriptMetaData
+                    };
+                    // logger.info(` ${JSON.stringify(context.scriptAppender.getData(), null, 2)}`);
+                    await fireflinkServiceInstance.produceMessageToKafka(request.kafkaMessageKey, {
+                        topic: this.KafkaPayload.topic, message: {
+                            topic: "",
+                            service: "",
+                            chatId: "",
+                            aiPromptPayload: {
+                                display: false,
+                                message: "",
+                                messageId: "",
+                                branchId: "",
+                                userId: request.userId,
+                                scriptId: "",
+                                scriptType: "",
+                                type: "logs",
+                                sessionId: "",
+                                licenseId: request.licenseId,
+                                projectId: request.projectId,
+                                liveLogs: {
+                                    executionId: request.kafkaMessageKey,
+                                    message: this.KafkaPayload,
+                                    messageType: messageType_js_1.MessageType.AutomationScriptMetaData,
+                                },
+                                attachment: [],
+                            },
+                        }
+                    });
+                    const stepDataArr = this.KafkaPayload.message.stepData;
+                    const lastStep = Array.isArray(stepDataArr) && stepDataArr.length > 0
+                        ? stepDataArr[stepDataArr.length - 1]
+                        : null;
+                    const closeStepNames = new Set([
+                        "CloseBrowser",
+                        "IOS_CloseApp",
+                        "MOB_CloseApp",
+                    ]);
+                    if (lastStep && closeStepNames.has(lastStep.nlpName)) {
+                        SessionManager_js_1.SessionManager.remove(request);
+                        delete driverState_js_1.UserSessionAutomationTestCase[request.kafkaMessageKey];
+                        logData_js_1.logger.info("Deletion happened.");
+                    }
+                    logData_js_1.logger.info(`Final Message produced to  Kafka topic ${JSON.stringify(this.KafkaPayload, null, 2)} successfully.`);
+                }
+                else {
+                    logData_js_1.logger.info("nextBatch produced; session kept alive for remaining steps.");
+                }
+            }
         }
         catch (error) {
             logData_js_1.logger.error("Failed to produce message :", logData_js_1.logger.getError(error));
             throw new Error("Failed to produce message :", { cause: error });
         }
         finally {
-            await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform, (await context.session.getCurrentDriver().catch(() => null)) ??
-                (await context.androidSession.getCurrentDriver().catch(() => null)));
+            if (!keepSessionAlive) {
+                await this.cleanup(context, domInfo, extractedRelevantDom, stepProcessor, fireflinkServiceInstance, request, platform);
+            }
         }
     }
 }