ff-automationv2 2.2.36-beta.0 → 2.2.36-beta.4

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

@@ -0,0 +1 @@
+export declare function decodeApiKey(apiKey: string): string;

package/dist/ai/llmcalls/decodeApiKey.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeApiKey = decodeApiKey;
+function decodeApiKey(apiKey) {
+    if (!apiKey) {
+        throw new Error("API key is required");
+    }
+    try {
+        return Buffer.from(apiKey, "base64").toString("utf-8");
+    }
+    catch (error) {
+        throw new Error("Failed to decode API key", { cause: error });
+    }
+}

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

@@ -0,0 +1,21 @@
+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 model;
+    private visionApiKey;
+    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

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmAction = void 0;
+const promptRegistry_js_1 = require("../llmprompts/promptRegistry.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, 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;
+    }
+    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 || type === promptType_js_1.PromptType.SWIPE_VISION_PROMPT) && Array.isArray(userPrompt)) {
+            const schemaToUse = (0, FireFlinkResponseSchema_js_1.getSchemaForPrompt)(type, platform, args);
+            return this.getLLMResponseWithVision(systemPrompt, userPrompt, isVision, schemaToUse);
+        }
+        if (typeof userPrompt !== "string") {
+            throw new Error("Invalid non-vision user prompt format");
+        }
+        return this.getLLMResponseText(platform, systemPrompt, userPrompt, type, args);
+    }
+    async getLLMResponseText(platform, system, user, type, args) {
+        let attempt = 0;
+        const MAX_RETRIES = 5;
+        const startTime = new Date().getTime();
+        const schemaToUse = (0, FireFlinkResponseSchema_js_1.getSchemaForPrompt)(type, platform, args);
+        let modelInstance;
+        if (this.serviceProvider === "Groq" || this.serviceProvider === "DefaultFireFlink") {
+            modelInstance = this.provider.responses(this.model);
+        }
+        else {
+            modelInstance = this.provider(this.model);
+        }
+        while (attempt < MAX_RETRIES) {
+            attempt++;
+            try {
+                const response = await (0, ai_1.generateText)({
+                    model: modelInstance,
+                    messages: [
+                        { role: "system", content: system },
+                        { role: "user", content: user },
+                    ],
+                    output: ai_1.Output.object({
+                        schema: schemaToUse,
+                    }),
+                    providerOptions: this.getProviderOptions()
+                });
+                const parsedContent = response.output;
+                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;
+                }
+                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);
+                if (attempt < MAX_RETRIES) {
+                    continue;
+                }
+                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;
+            }
+        }
+        return this.buildRetryFailure();
+    }
+    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, schemaToUse = FireFlinkResponseSchema_js_1.VisionSchema) {
+        let attempt = 0;
+        const MAX_RETRIES = 5;
+        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 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: parts },
+                    ],
+                    output: ai_1.Output.object({
+                        schema: schemaToUse,
+                    }),
+                    providerOptions: this.getProviderOptions()
+                });
+                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;
+                }
+                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}:`, error);
+                if (ai_1.NoObjectGeneratedError.isInstance(error) && error.text) {
+                    try {
+                        const recovered = this.extractValidatedJson(error.text, schemaToUse);
+                        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;
+            }
+        }
+        return this.buildRetryFailure();
+    }
+    isInvalidLLMOutput(content) {
+        if (!content)
+            return true;
+        if (typeof content === "string") {
+            const trimmed = content.trim();
+            if (!trimmed)
+                return true;
+            if (trimmed === "{}")
+                return true;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed === "object" &&
+                    parsed !== null &&
+                    Object.keys(parsed).length === 0) {
+                    return true;
+                }
+            }
+            catch {
+                return true;
+            }
+        }
+        return false;
+    }
+    handleKnownErrors(error) {
+        if (error?.lastError?.statusCode === 429) {
+            return {
+                error: "Rate Limit Exceeded (429)",
+                errorDescription: "Service has exceeded the API quota or rate limit for the selected AI model. \n This is common with free or low-tier API plans \n Please wait a moment before retrying or check your API usage limits.",
+                rawError: "Rate limit reached for model. HTTP 429 returned by model"
+            };
+        }
+        else if (error?.statusCode === 400 &&
+            error?.error?.message?.toLowerCase().includes("context")) {
+            return {
+                error: "Context Length Exceeded (400)",
+                errorDescription: "Service could not process the request because the input exceeds the maximum context length supported by the selected AI model.\nThis typically happens when the input is very long",
+                rawError: "This model's maximum context length has been exceeded. HTTP 400 returned by model"
+            };
+        }
+        else if (error?.statusCode === 401 &&
+            error?.error?.message?.toLowerCase().includes("Incorrect api key")) {
+            return {
+                error: "Invalid API key",
+                errorDescription: "Service could not process the request because the API key is invalid. Please check your API key and try again.",
+                rawError: "Invalid API key"
+            };
+        }
+        else if (error?.statusCode !== 200) {
+            return {
+                error: error.message,
+                errorDescription: "Service has can't process the request. Because of service Provider internal error",
+                rawError: error,
+            };
+        }
+        return null;
+    }
+    buildRetryFailure() {
+        return {
+            error: "LLM Empty Response After Retry",
+            errorDescription: "Service attempted multiple times but received empty or invalid responses.",
+            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":
+                if (this.model.startsWith("claude-haiku")) {
+                    return {
+                        anthropic: {
+                            thinking: {
+                                type: "enabled",
+                                budgetTokens: 1024
+                            }
+                        },
+                    };
+                }
+                else {
+                    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.d.ts

@@ -0,0 +1,15 @@
+import { FireFlinkLLMResponse } from "../../core/types/llmResponseType.js";
+export declare class LLMResultParser {
+    private inputTokens;
+    private outputTokens;
+    private totalTokens;
+    private extractJsonObject;
+    fetchResult(llmOutput: any): Promise<{
+        response: FireFlinkLLMResponse;
+    }>;
+    getTokenUsage(): {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+}

package/dist/ai/llmcalls/parseLlmOputput.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMResultParser = void 0;
+// import { logger } from "../../utils/logger/logData.js";
+class LLMResultParser {
+    constructor() {
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.totalTokens = 0;
+    }
+    async extractJsonObject(response) {
+        const match = response.match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        return JSON.parse(match[0]);
+    }
+    async fetchResult(llmOutput) {
+        if (llmOutput?.error) {
+            throw llmOutput;
+        }
+        try {
+            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 (!content) {
+                    throw new Error("Could not extract valid JSON from LLM response");
+                }
+                parsedContent = content;
+            }
+            const usage = llmOutput?.totalUsage ?? {};
+            this.inputTokens += Number(usage.inputTokens ?? 0);
+            this.outputTokens += Number(usage.outputTokens ?? 0);
+            this.totalTokens += Number(usage.totalTokens ?? 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 };
+        }
+        catch (error) {
+            throw new Error("Failed to parse LLM output", { cause: error });
+        }
+    }
+    getTokenUsage() {
+        return {
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+            totalTokens: this.totalTokens,
+        };
+    }
+}
+exports.LLMResultParser = LLMResultParser;

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

@@ -0,0 +1,48 @@
+export type keywordExtractor = {
+    priorAndNextSteps: string[];
+    allSteps?: string[];
+    previousPlatform?: string | null;
+};
+export type FFInspectorArgs = {
+    stepAction: string;
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+    isAlert?: boolean;
+    isDrag?: boolean;
+};
+export type FFInspectorArgsMob = {
+    stepAction: string;
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+};
+export type getActionArgs = {
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+};
+export type verifyActionArgs = {
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+};
+export type visionPrompt = {
+    priorAndNextSteps: string[];
+};
+export type visionPromptMobile = {
+    priorAndNextSteps: string[];
+};
+export type swipeVisionPrompt = {
+    priorAndNextSteps: string[];
+};
+export type waitActionArgs = {
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+};
+export type combinedActionArgs = {
+    extractedDomJson: string;
+    priorAndNextSteps: string[];
+};
+export type inputContextArgs = {
+    inputStepsContext: any[];
+};
+export type arithmeticArgs = {
+    inputStepsContext: any[];
+};

package/dist/ai/llmprompts/llmPromptTypes/systemPromptTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ai/llmprompts/promptRegistry.d.ts

@@ -0,0 +1,2 @@
+import { PromptMap } from "../../core/types/promptMap.js";
+export declare const prompts: PromptMap;

package/dist/ai/llmprompts/promptRegistry.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompts = void 0;
+const actionExtractorPrompt_js_1 = require("./systemPrompts/actionExtractorPrompt.js");
+const userStoryToListPrompt_js_1 = require("./systemPrompts/userStoryToListPrompt.js");
+const errorDescriptionPrompt_js_1 = require("./systemPrompts/errorDescriptionPrompt.js");
+const fireflinkElementIndexExtactors_js_1 = require("./systemPrompts/fireflinkElementIndexExtactors.js");
+const fireflinkElementIndexExtractor_Mob_js_1 = require("./systemPrompts/fireflinkElementIndexExtractor_Mob.js");
+const visionPrompt_js_1 = require("./systemPrompts/visionPrompt.js");
+const visionPromptMobile_js_1 = require("./systemPrompts/visionPromptMobile.js");
+const verifyActionExtractorPrompt_js_1 = require("./systemPrompts/verifyActionExtractorPrompt.js");
+const getActionExtractorPrompt_js_1 = require("./systemPrompts/getActionExtractorPrompt.js");
+const verifyActionExtractorPromptMob_js_1 = require("./systemPrompts/verifyActionExtractorPromptMob.js");
+const getActionExtractorPromptMob_js_1 = require("./systemPrompts/getActionExtractorPromptMob.js");
+const mobileKeywordExtractor_js_1 = require("./systemPrompts/mobileKeywordExtractor.js");
+const multichannelKeywordExtractor_js_1 = require("./systemPrompts/multichannelKeywordExtractor.js");
+const combinedActionExtractorPromptMob_js_1 = require("./systemPrompts/combinedActionExtractorPromptMob.js");
+const waitActionExtractorPromptMob_js_1 = require("./systemPrompts/waitActionExtractorPromptMob.js");
+const waitActionExtractorPrompt_js_1 = require("./systemPrompts/waitActionExtractorPrompt.js");
+const inputContextPrompt_js_1 = require("./systemPrompts/inputContextPrompt.js");
+// import { combinedActionExtractorPrompt } from "./systemPrompts/combinedActionExtractorPrompt.js";
+const otpExtractorPrompt_js_1 = require("./systemPrompts/otpExtractorPrompt.js");
+const fileVerifyActionExtractorPrompt_js_1 = require("./systemPrompts/fileVerifyActionExtractorPrompt.js");
+const arithmeticPrompt_js_1 = require("./systemPrompts/arithmeticPrompt.js");
+const sliderSwipeVisionPrompt_js_1 = require("./systemPrompts/sliderSwipeVisionPrompt.js");
+exports.prompts = {
+    web: {
+        userStoryToList: userStoryToListPrompt_js_1.buildStepExtractionPrompt,
+        keywordExtractorPrompt: actionExtractorPrompt_js_1.keywordExtractor,
+        multichannelKeywordExtractorPrompt: multichannelKeywordExtractor_js_1.keywordExtractorMultichannel,
+        errorDescriptionPrompt: errorDescriptionPrompt_js_1.buildErrorDescriptionPrompt,
+        ffInspectorNumExtractor: fireflinkElementIndexExtactors_js_1.ffInspectorNumExtractor,
+        verifyActionExtractorPrompt: verifyActionExtractorPrompt_js_1.verifyActionExtractorPrompt,
+        visionPrompt: visionPrompt_js_1.visionPrompt,
+        swipe_vision_prompt: sliderSwipeVisionPrompt_js_1.swipeVisionPrompt,
+        getActionExtractorPrompt: getActionExtractorPrompt_js_1.getActionExtractorPrompt,
+        combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
+        waitActionExtractorPrompt: waitActionExtractorPrompt_js_1.waitActionExtractorPrompt,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
+        otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
+        arithmeticPrompt: arithmeticPrompt_js_1.arithmeticPrompt,
+    },
+    android: {
+        userStoryToList: userStoryToListPrompt_js_1.androidbuildStepExtractionPrompt,
+        keywordExtractorPrompt: mobileKeywordExtractor_js_1.keywordExtractorMobile,
+        multichannelKeywordExtractorPrompt: multichannelKeywordExtractor_js_1.keywordExtractorMultichannel,
+        errorDescriptionPrompt: errorDescriptionPrompt_js_1.buildErrorDescriptionPrompt,
+        ffInspectorNumExtractor: fireflinkElementIndexExtractor_Mob_js_1.ffInspectorNumExtractorMob,
+        verifyActionExtractorPrompt: verifyActionExtractorPromptMob_js_1.verifyActionExtractorPromptMob,
+        visionPrompt: visionPromptMobile_js_1.visionPromptMobile,
+        swipe_vision_prompt: sliderSwipeVisionPrompt_js_1.swipeVisionPrompt,
+        getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
+        combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
+        waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
+        otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
+        arithmeticPrompt: arithmeticPrompt_js_1.arithmeticPrompt,
+    },
+    ios: {
+        userStoryToList: userStoryToListPrompt_js_1.androidbuildStepExtractionPrompt,
+        keywordExtractorPrompt: mobileKeywordExtractor_js_1.keywordExtractorMobile,
+        multichannelKeywordExtractorPrompt: multichannelKeywordExtractor_js_1.keywordExtractorMultichannel,
+        errorDescriptionPrompt: errorDescriptionPrompt_js_1.buildErrorDescriptionPrompt,
+        ffInspectorNumExtractor: fireflinkElementIndexExtractor_Mob_js_1.ffInspectorNumExtractorMob,
+        verifyActionExtractorPrompt: verifyActionExtractorPromptMob_js_1.verifyActionExtractorPromptMob,
+        visionPrompt: visionPromptMobile_js_1.visionPromptMobile,
+        swipe_vision_prompt: sliderSwipeVisionPrompt_js_1.swipeVisionPrompt,
+        getActionExtractorPrompt: getActionExtractorPromptMob_js_1.getActionExtractorPromptMob,
+        combinedActionExtractorPrompt: combinedActionExtractorPromptMob_js_1.combinedActionExtractorPromptMob,
+        waitActionExtractorPrompt: waitActionExtractorPromptMob_js_1.waitActionExtractorPromptMob,
+        inputContextPrompt: inputContextPrompt_js_1.inputContextPrompt,
+        otpExtractorPrompt: otpExtractorPrompt_js_1.otpExtractorPrompt,
+        fileVerifyActionExtractorPrompt: fileVerifyActionExtractorPrompt_js_1.fileVerifyActionExtractorPrompt,
+        arithmeticPrompt: arithmeticPrompt_js_1.arithmeticPrompt,
+    }
+};

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

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