misoai-web 1.0.6 → 1.5.7

package/dist/lib/playwright.js

@@ -56,10 +56,11 @@ var ScriptPlayer = class {
     this.unnamedResultIndex = 0;
     this.pageAgent = null;
     this.result = {};
+    const target = script.target || script.web || script.android;
     if (import_utils.ifInBrowser) {
       this.output = void 0;
-    } else if (script.target?.output) {
-      this.output = (0, import_node_path.resolve)(process.cwd(), script.target.output);
+    } else if (target?.output) {
+      this.output = (0, import_node_path.resolve)(process.cwd(), target.output);
     } else {
       this.output = (0, import_node_path.join)((0, import_common.getMidsceneRunSubDir)("output"), `${process.pid}.json`);
     }
@@ -133,15 +134,20 @@ var ScriptPlayer = class {
       } else if ("aiAssert" in flowItem) {
         const assertTask = flowItem;
         const prompt = assertTask.aiAssert;
+        const msg = assertTask.errorMessage;
         (0, import_utils.assert)(prompt, "missing prompt for aiAssert");
         (0, import_utils.assert)(
           typeof prompt === "string",
           "prompt for aiAssert must be a string"
         );
-        await agent.aiAssert(prompt);
+        await agent.aiAssert(prompt, msg);
       } else if ("aiQuery" in flowItem) {
         const queryTask = flowItem;
         const prompt = queryTask.aiQuery;
+        const options = {
+          domIncluded: queryTask.domIncluded,
+          screenshotIncluded: queryTask.screenshotIncluded
+        };
         (0, import_utils.assert)(prompt, "missing prompt for aiQuery");
         (0, import_utils.assert)(
           typeof prompt === "string",
@@ -152,6 +158,10 @@ var ScriptPlayer = class {
       } else if ("aiNumber" in flowItem) {
         const numberTask = flowItem;
         const prompt = numberTask.aiNumber;
+        const options = {
+          domIncluded: numberTask.domIncluded,
+          screenshotIncluded: numberTask.screenshotIncluded
+        };
         (0, import_utils.assert)(prompt, "missing prompt for number");
         (0, import_utils.assert)(
           typeof prompt === "string",
@@ -162,6 +172,10 @@ var ScriptPlayer = class {
       } else if ("aiString" in flowItem) {
         const stringTask = flowItem;
         const prompt = stringTask.aiString;
+        const options = {
+          domIncluded: stringTask.domIncluded,
+          screenshotIncluded: stringTask.screenshotIncluded
+        };
         (0, import_utils.assert)(prompt, "missing prompt for string");
         (0, import_utils.assert)(
           typeof prompt === "string",
@@ -172,6 +186,10 @@ var ScriptPlayer = class {
       } else if ("aiBoolean" in flowItem) {
         const booleanTask = flowItem;
         const prompt = booleanTask.aiBoolean;
+        const options = {
+          domIncluded: booleanTask.domIncluded,
+          screenshotIncluded: booleanTask.screenshotIncluded
+        };
         (0, import_utils.assert)(prompt, "missing prompt for boolean");
         (0, import_utils.assert)(
           typeof prompt === "string",
@@ -214,6 +232,9 @@ var ScriptPlayer = class {
       } else if ("aiTap" in flowItem) {
         const tapTask = flowItem;
         await agent.aiTap(tapTask.aiTap, tapTask);
+      } else if ("aiRightClick" in flowItem) {
+        const rightClickTask = flowItem;
+        await agent.aiRightClick(rightClickTask.aiRightClick, rightClickTask);
       } else if ("aiHover" in flowItem) {
         const hoverTask = flowItem;
         await agent.aiHover(hoverTask.aiHover, hoverTask);
@@ -236,6 +257,11 @@ var ScriptPlayer = class {
           evaluateJavaScriptTask.javascript
         );
         this.setResult(evaluateJavaScriptTask.name, result);
+      } else if ("logScreenshot" in flowItem) {
+        const logScreenshotTask = flowItem;
+        await agent.logScreenshot(logScreenshotTask.logScreenshot, {
+          content: logScreenshotTask.content || ""
+        });
       } else {
         throw new Error(`unknown flowItem: ${JSON.stringify(flowItem)}`);
       }
@@ -484,7 +510,8 @@ var WebElementInfo = class {
     id,
     attributes,
     indexId,
-    xpaths
+    xpaths,
+    isVisible
   }) {
     this.content = content;
     this.rect = rect;
@@ -497,6 +524,7 @@ var WebElementInfo = class {
     this.attributes = attributes;
     this.indexId = indexId;
     this.xpaths = xpaths;
+    this.isVisible = isVisible;
   }
 };
 
@@ -519,14 +547,15 @@ async function parseContextFromWebPage(page, _opt) {
     })
   ]);
   const webTree = (0, import_extractor.traverseTree)(tree, (elementInfo) => {
-    const { rect, id, content, attributes, locator, indexId } = elementInfo;
+    const { rect, id, content, attributes, locator, indexId, isVisible } = elementInfo;
     return new WebElementInfo({
       rect,
       locator,
       id,
       content,
       attributes,
-      indexId
+      indexId,
+      isVisible
     });
   });
   (0, import_utils4.assert)(screenshotBase64, "screenshotBase64 is required");
@@ -556,7 +585,7 @@ function printReportMsg(filepath) {
   (0, import_utils4.logMsg)(`Midscene - report file updated: ${filepath}`);
 }
 function replaceIllegalPathCharsAndSpace(str) {
-  return str.replace(/[/\\:*?"<>| ]/g, "-");
+  return str.replace(/[:*?"<>| ]/g, "-");
 }
 function forceClosePopup(page, debug6) {
   page.on("popup", async (popup) => {
@@ -870,10 +899,10 @@ var PageTaskExecutor = class {
               if (!taskParam || !taskParam.value) {
                 return;
               }
-              await this.page.keyboard.type(taskParam.value);
-            } else {
-              await this.page.keyboard.type(taskParam.value);
             }
+            await this.page.keyboard.type(taskParam.value, {
+              autoDismissKeyboard: taskParam.autoDismissKeyboard
+            });
           }
         };
         tasks.push(taskActionInput);
@@ -902,6 +931,22 @@ var PageTaskExecutor = class {
           }
         };
         tasks.push(taskActionTap);
+      } else if (plan2.type === "RightClick") {
+        const taskActionRightClick = {
+          type: "Action",
+          subType: "RightClick",
+          thought: plan2.thought,
+          locate: plan2.locate,
+          executor: async (param, { element }) => {
+            (0, import_utils6.assert)(element, "Element not found, cannot right click");
+            await this.page.mouse.click(
+              element.center[0],
+              element.center[1],
+              { button: "right" }
+            );
+          }
+        };
+        tasks.push(taskActionRightClick);
       } else if (plan2.type === "Drag") {
         const taskActionDrag = {
           type: "Action",
@@ -1430,7 +1475,7 @@ var PageTaskExecutor = class {
       executor: taskExecutor
     };
   }
-  async createTypeQueryTask(type, demand) {
+  async createTypeQueryTask(type, demand, opt) {
     const taskExecutor = new import_misoai_core.Executor(
       taskTitleStr(
         type,
@@ -1461,7 +1506,10 @@ var PageTaskExecutor = class {
             result: `${type}, ${demand}`
           };
         }
-        const { data, usage } = await this.insight.extract(demandInput);
+        const { data, usage } = await this.insight.extract(
+          demandInput,
+          opt
+        );
         let outputResult = data;
         if (ifTypeRestricted) {
           (0, import_utils6.assert)(data?.result !== void 0, "No result in query data");
@@ -1481,17 +1529,17 @@ var PageTaskExecutor = class {
       executor: taskExecutor
     };
   }
-  async query(demand) {
-    return this.createTypeQueryTask("Query", demand);
+  async query(demand, opt) {
+    return this.createTypeQueryTask("Query", demand, opt);
   }
-  async boolean(prompt) {
-    return this.createTypeQueryTask("Boolean", prompt);
+  async boolean(prompt, opt) {
+    return this.createTypeQueryTask("Boolean", prompt, opt);
   }
-  async number(prompt) {
-    return this.createTypeQueryTask("Number", prompt);
+  async number(prompt, opt) {
+    return this.createTypeQueryTask("Number", prompt, opt);
   }
-  async string(prompt) {
-    return this.createTypeQueryTask("String", prompt);
+  async string(prompt, opt) {
+    return this.createTypeQueryTask("String", prompt, opt);
   }
   async assert(assertion) {
     const description = `assert: ${assertion}`;
@@ -1627,7 +1675,7 @@ function buildPlans(type, locateParam, param) {
     param: locateParam,
     thought: ""
   } : null;
-  if (type === "Tap" || type === "Hover") {
+  if (type === "Tap" || type === "Hover" || type === "RightClick") {
     (0, import_utils8.assert)(locateParam, `missing locate info for action "${type}"`);
     (0, import_utils8.assert)(locatePlan, `missing locate info for action "${type}"`);
     const tapPlan = {
@@ -1707,7 +1755,7 @@ var import_js_yaml3 = __toESM(require("js-yaml"));
 var import_semver = __toESM(require("semver"));
 
 // package.json
-var version = "1.0.5";
+var version = "1.0.3";
 
 // src/common/task-cache.ts
 var debug3 = (0, import_logger3.getDebug)("cache");
@@ -1735,70 +1783,44 @@ var TaskCache = class {
     this.cache = cacheContent;
     this.cacheOriginalLength = this.cache.caches.length;
   }
-  matchCache(prompt, type, contextData) {
-    const contextHash = contextData ? this.generateContextHash(contextData) : void 0;
+  matchCache(prompt, type) {
     for (let i = 0; i < this.cacheOriginalLength; i++) {
       const item = this.cache.caches[i];
       const key = `${type}:${prompt}:${i}`;
-      if (item.type !== type || item.prompt !== prompt || this.matchedCacheIndices.has(key)) {
-        continue;
-      }
-      if (type === "plan" && item.type === "plan") {
-        const planItem = item;
-        if (contextHash && planItem.contextHash) {
-          if (contextHash !== planItem.contextHash) {
-            debug3("cache context mismatch, type: %s, prompt: %s, index: %d", type, prompt, i);
-            continue;
+      if (item.type === type && item.prompt === prompt && !this.matchedCacheIndices.has(key)) {
+        this.matchedCacheIndices.add(key);
+        debug3(
+          "cache found and marked as used, type: %s, prompt: %s, index: %d",
+          type,
+          prompt,
+          i
+        );
+        return {
+          cacheContent: item,
+          updateFn: (cb) => {
+            debug3(
+              "will call updateFn to update cache, type: %s, prompt: %s, index: %d",
+              type,
+              prompt,
+              i
+            );
+            cb(item);
+            debug3(
+              "cache updated, will flush to file, type: %s, prompt: %s, index: %d",
+              type,
+              prompt,
+              i
+            );
+            this.flushCacheToFile();
           }
-        } else if (contextHash || planItem.contextHash) {
-          debug3("cache context availability mismatch, type: %s, prompt: %s, index: %d", type, prompt, i);
-          continue;
-        }
+        };
       }
-      this.matchedCacheIndices.add(key);
-      debug3(
-        "cache found and marked as used, type: %s, prompt: %s, index: %d, contextMatch: %s",
-        type,
-        prompt,
-        i,
-        contextHash ? "yes" : "no-context"
-      );
-      return {
-        cacheContent: item,
-        updateFn: (cb) => {
-          debug3(
-            "will call updateFn to update cache, type: %s, prompt: %s, index: %d",
-            type,
-            prompt,
-            i
-          );
-          cb(item);
-          debug3(
-            "cache updated, will flush to file, type: %s, prompt: %s, index: %d",
-            type,
-            prompt,
-            i
-          );
-          this.flushCacheToFile();
-        }
-      };
     }
-    debug3("no unused cache found, type: %s, prompt: %s, contextHash: %s", type, prompt, contextHash);
+    debug3("no unused cache found, type: %s, prompt: %s", type, prompt);
     return void 0;
   }
-  generateContextHash(contextData) {
-    const sortedKeys = Object.keys(contextData).sort();
-    const stableString = sortedKeys.map((key) => `${key}:${JSON.stringify(contextData[key])}`).join("|");
-    let hash = 0;
-    for (let i = 0; i < stableString.length; i++) {
-      const char = stableString.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return hash.toString(36);
-  }
-  matchPlanCache(prompt, contextData) {
-    return this.matchCache(prompt, "plan", contextData);
+  matchPlanCache(prompt) {
+    return this.matchCache(prompt, "plan");
   }
   matchLocateCache(prompt) {
     return this.matchCache(prompt, "locate");
@@ -1864,8 +1886,14 @@ cache file: ${cacheFile}`
       return;
     }
     try {
+      const dir = (0, import_node_path2.dirname)(this.cacheFilePath);
+      if (!(0, import_node_fs2.existsSync)(dir)) {
+        (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+        debug3("created cache directory: %s", dir);
+      }
       const yamlData = import_js_yaml3.default.dump(this.cache);
       (0, import_node_fs2.writeFileSync)(this.cacheFilePath, yamlData);
+      debug3("cache flushed to file: %s", this.cacheFilePath);
     } catch (err) {
       debug3(
         "write cache to file failed, path: %s, error: %s",
@@ -1874,16 +1902,11 @@ cache file: ${cacheFile}`
       );
     }
   }
-  updateOrAppendCacheRecord(newRecord, cachedRecord, contextData) {
+  updateOrAppendCacheRecord(newRecord, cachedRecord) {
     if (cachedRecord) {
       if (newRecord.type === "plan") {
         cachedRecord.updateFn((cache) => {
-          const planCache = cache;
-          planCache.yamlWorkflow = newRecord.yamlWorkflow;
-          if (contextData) {
-            planCache.contextHash = this.generateContextHash(contextData);
-            planCache.contextData = { ...contextData };
-          }
+          cache.yamlWorkflow = newRecord.yamlWorkflow;
         });
       } else {
         cachedRecord.updateFn((cache) => {
@@ -1891,11 +1914,6 @@ cache file: ${cacheFile}`
         });
       }
     } else {
-      if (newRecord.type === "plan" && contextData) {
-        const planRecord = newRecord;
-        planRecord.contextHash = this.generateContextHash(contextData);
-        planRecord.contextData = { ...contextData };
-      }
       this.appendCache(newRecord);
     }
   }
@@ -1925,13 +1943,10 @@ var PageAgent = class {
         generateReport: true,
         autoPrintReportMsg: true,
         groupName: "Midscene Report",
-        groupDescription: "",
-        enableCumulativeContext: true,
-        autoClearContext: false
+        groupDescription: ""
       },
       opts || {}
     );
-    this.initializeContextStore();
     if (this.page.pageType === "puppeteer" || this.page.pageType === "playwright") {
       this.page.waitForNavigationTimeout = this.opts.waitForNavigationTimeout || import_constants2.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT;
       this.page.waitForNetworkIdleTimeout = this.opts.waitForNetworkIdleTimeout || import_constants2.DEFAULT_WAIT_FOR_NETWORK_IDLE_TIMEOUT;
@@ -1958,69 +1973,6 @@ var PageAgent = class {
       opts?.testId || this.page.pageType || "web"
     );
   }
-  /**
-   * Initialize context store for cumulative context functionality
-   */
-  async initializeContextStore() {
-    if (!this.opts.enableCumulativeContext) {
-      debug4("Cumulative context disabled via options");
-      return;
-    }
-    try {
-      const aiModel = await import("misoai-core/ai-model");
-      this.contextStore = aiModel.getContextStore();
-      debug4("Context store initialized successfully", {
-        autoClearContext: this.opts.autoClearContext,
-        testId: this.opts.testId
-      });
-      if (this.opts.autoClearContext) {
-        this.contextStore.clear();
-        debug4("Context store cleared due to autoClearContext option");
-      } else {
-        const existingData = this.contextStore.getAllData();
-        const existingSteps = this.contextStore.getRecentSteps(100).length;
-        debug4("Context store preserving existing data", {
-          existingDataKeys: Object.keys(existingData),
-          existingStepsCount: existingSteps
-        });
-      }
-    } catch (error) {
-      debug4("Failed to initialize context store:", error);
-      console.warn("⚠️ Could not initialize context store:", error);
-    }
-  }
-  /**
-   * Get the context store instance
-   */
-  getContextStore() {
-    return this.contextStore;
-  }
-  /**
-   * Clear the context store
-   */
-  clearContext() {
-    if (this.contextStore) {
-      this.contextStore.clear();
-    }
-  }
-  /**
-   * Get all stored data from context store
-   */
-  getStoredData() {
-    if (this.contextStore) {
-      return this.contextStore.getAllData();
-    }
-    return {};
-  }
-  /**
-   * Get step summary from context store
-   */
-  getStepSummary() {
-    if (this.contextStore) {
-      return this.contextStore.getStepSummary();
-    }
-    return "";
-  }
   async getUIContext(action) {
     if (action && (action === "extract" || action === "assert" || action === "captcha")) {
       return await parseContextFromWebPage(this.page, {
@@ -2199,6 +2151,23 @@ var PageAgent = class {
       metadata
     };
   }
+  async aiRightClick(locatePrompt, opt) {
+    const detailedLocateParam = this.buildDetailedLocateParam(
+      locatePrompt,
+      opt
+    );
+    const plans = buildPlans("RightClick", detailedLocateParam);
+    const { executor, output } = await this.taskExecutor.runPlans(
+      taskTitleStr("RightClick", locateParamStr(detailedLocateParam)),
+      plans,
+      { cacheable: opt?.cacheable }
+    );
+    const metadata = this.afterTaskRunning(executor);
+    return {
+      result: output,
+      metadata
+    };
+  }
   async aiInput(value, locatePrompt, opt) {
     (0, import_utils12.assert)(
       typeof value === "string",
@@ -2256,35 +2225,9 @@ var PageAgent = class {
     };
   }
   async aiAction(taskPrompt, opt) {
-    const originalPrompt = taskPrompt;
-    let processedPrompt = taskPrompt;
-    if (this.opts.enableCumulativeContext && this.contextStore) {
-      try {
-        const storedData = this.contextStore.getAllData();
-        if (Object.keys(storedData).length > 0) {
-          debug4("Available data for aiAction:", {
-            prompt: taskPrompt,
-            availableData: storedData
-          });
-        }
-      } catch (error) {
-        debug4("Context store operation failed:", error);
-      }
-    }
     const cacheable = opt?.cacheable;
     const isVlmUiTars = (0, import_env2.vlLocateMode)() === "vlm-ui-tars";
-    let contextData;
-    if (this.opts.enableCumulativeContext && this.contextStore) {
-      try {
-        contextData = this.contextStore.getAllData();
-        if (contextData && Object.keys(contextData).length === 0) {
-          contextData = void 0;
-        }
-      } catch (error) {
-        debug4("Failed to get context data for cache:", error);
-      }
-    }
-    const matchedCache = isVlmUiTars || cacheable === false ? void 0 : this.taskCache?.matchPlanCache(taskPrompt, contextData);
+    const matchedCache = isVlmUiTars || cacheable === false ? void 0 : this.taskCache?.matchPlanCache(taskPrompt);
     if (matchedCache && this.taskCache?.isCacheResultUsed) {
       const { executor: executor2 } = await this.taskExecutor.loadYamlFlowAsPlanning(
         taskPrompt,
@@ -2294,28 +2237,6 @@ var PageAgent = class {
       debug4("matched cache, will call .runYaml to run the action");
       const yaml5 = matchedCache.cacheContent?.yamlWorkflow;
       const result = await this.runYaml(yaml5);
-      if (this.opts.enableCumulativeContext && this.contextStore) {
-        try {
-          const executionResult = {
-            success: true,
-            actionType: "cached",
-            description: `Executed cached action: ${processedPrompt}`,
-            timing: result.metadata?.totalTime
-          };
-          this.contextStore.addStep({
-            type: "action",
-            summary: `Action: ${processedPrompt} (cached)`,
-            prompt: processedPrompt,
-            executionResult
-          });
-          debug4("Added cached action step to context store:", {
-            stepNumber: this.contextStore.getRecentSteps(1)[0]?.stepNumber,
-            totalSteps: this.contextStore.getRecentSteps(100).length
-          });
-        } catch (error) {
-          debug4("Failed to add cached action step:", error);
-        }
-      }
       return {
         result: result.result,
         metadata: metadata2
@@ -2340,114 +2261,17 @@ var PageAgent = class {
           prompt: taskPrompt,
           yamlWorkflow: yamlFlowStr
         },
-        matchedCache,
-        contextData
-        // Pass context data for cache creation
+        matchedCache
       );
     }
     const metadata = this.afterTaskRunning(executor);
-    if (this.opts.enableCumulativeContext && this.contextStore) {
-      try {
-        const executionResult = this.analyzeExecutionResults(executor, originalPrompt);
-        this.contextStore.addStep({
-          type: "action",
-          summary: `Action: ${processedPrompt}`,
-          prompt: processedPrompt,
-          executionResult
-        });
-        debug4("Added action step with execution result to context store:", {
-          stepNumber: this.contextStore.getRecentSteps(1)[0]?.stepNumber,
-          totalSteps: this.contextStore.getRecentSteps(100).length,
-          executionResult
-        });
-      } catch (error) {
-        debug4("Failed to analyze execution results, adding step without execution result:", error);
-        try {
-          this.contextStore.addStep({
-            type: "action",
-            summary: `Action: ${processedPrompt}`,
-            prompt: processedPrompt
-          });
-        } catch (stepError) {
-          debug4("Failed to add action step:", stepError);
-        }
-      }
-    }
     return {
       result: output,
       metadata
     };
   }
   async aiQuery(demand) {
-    let processedDemand = demand;
-    let storageKey;
-    try {
-      const aiModel = await import("misoai-core/ai-model");
-      const contextStore = aiModel.getContextStore();
-      if (typeof demand === "string") {
-        const storageInstruction = contextStore.parseStorageInstruction(demand);
-        if (storageInstruction) {
-          storageKey = storageInstruction.key;
-          processedDemand = storageInstruction.cleanText;
-          contextStore._pendingAliases = storageInstruction.aliases;
-        } else {
-          const storageMatch = demand.match(/store\s+(?:as\s+)?(\w+)/i);
-          if (storageMatch) {
-            storageKey = storageMatch[1];
-            processedDemand = demand.replace(/,?\s*store\s+(?:as\s+)?\w+/i, "").trim();
-          }
-        }
-      }
-    } catch (error) {
-      debug4("Context store not available:", error);
-    }
-    const { output, executor } = await this.taskExecutor.query(processedDemand);
-    if (this.opts.enableCumulativeContext && this.contextStore) {
-      if (storageKey && output) {
-        try {
-          const pendingAliases = this.contextStore._pendingAliases;
-          if (pendingAliases) {
-            this.contextStore.storeDataWithAliases(storageKey, output, pendingAliases, typeof processedDemand === "string" ? processedDemand : JSON.stringify(processedDemand));
-            delete this.contextStore._pendingAliases;
-            debug4("Stored query result with aliases:", {
-              key: storageKey,
-              value: output,
-              aliases: pendingAliases
-            });
-          } else {
-            this.contextStore.storeData(storageKey, output);
-            debug4("Stored query result:", {
-              key: storageKey,
-              value: output
-            });
-          }
-          this.contextStore.addStep({
-            type: "query",
-            summary: `Query: ${typeof processedDemand === "string" ? processedDemand : JSON.stringify(processedDemand)} (stored as ${storageKey})`,
-            data: output,
-            prompt: typeof processedDemand === "string" ? processedDemand : JSON.stringify(processedDemand)
-          });
-          debug4("Added query step to context store:", {
-            storageKey,
-            totalStoredItems: Object.keys(this.contextStore.getAllData()).length,
-            totalSteps: this.contextStore.getRecentSteps(100).length
-          });
-        } catch (error) {
-          debug4("Failed to store query result:", error);
-        }
-      } else {
-        try {
-          this.contextStore.addStep({
-            type: "query",
-            summary: `Query: ${typeof processedDemand === "string" ? processedDemand : JSON.stringify(processedDemand)}`,
-            data: output,
-            prompt: typeof processedDemand === "string" ? processedDemand : JSON.stringify(processedDemand)
-          });
-        } catch (error) {
-          debug4("Failed to add query step:", error);
-        }
-      }
-    }
+    const { output, executor } = await this.taskExecutor.query(demand);
     const metadata = this.afterTaskRunning(executor);
     return {
       result: output,
@@ -2557,48 +2381,6 @@ var PageAgent = class {
     };
   }
   async aiAssert(assertion, msg, opt) {
-    let executionContext = "";
-    if (this.opts.enableCumulativeContext && this.contextStore) {
-      try {
-        const recentSteps = this.contextStore.getRecentSteps(3);
-        const stepsWithExecutionResults = recentSteps.filter((step) => step.executionResult);
-        const storedData = this.contextStore.getAllData();
-        if (stepsWithExecutionResults.length > 0) {
-          const recentActions = stepsWithExecutionResults.map((step) => {
-            const result = step.executionResult;
-            return `- ${result.description}${result.success ? "" : " (FAILED)"}`;
-          }).join("\n");
-          executionContext = `
-
-Recent actions performed:
-${recentActions}
-
-This context may help verify the assertion.`;
-        }
-        if (storedData && Object.keys(storedData).length > 0) {
-          executionContext += `
-
-Available data for reference:
-${JSON.stringify(storedData, null, 2)}
-
-Note: If the assertion references any data keys or natural language equivalents, consider the stored values when verifying.`;
-          debug4("Available data for aiAssert:", {
-            assertion,
-            availableData: storedData
-          });
-        }
-        this.contextStore.addStep({
-          type: "assertion",
-          summary: `Assertion: ${assertion}`,
-          prompt: assertion
-        });
-        debug4("Added assertion step to context store:", {
-          totalSteps: this.contextStore.getRecentSteps(100).length
-        });
-      } catch (error) {
-        debug4("Context store operation failed:", error);
-      }
-    }
     let currentUrl = "";
     if (this.page.url) {
       try {
@@ -2606,13 +2388,7 @@ Note: If the assertion references any data keys or natural language equivalents,
       } catch (e) {
       }
     }
-    let assertionWithContext = assertion;
-    if (currentUrl) {
-      assertionWithContext = `For the page at URL "${currentUrl}", ${assertion}`;
-    }
-    if (executionContext) {
-      assertionWithContext += executionContext;
-    }
+    const assertionWithContext = currentUrl ? `For the page at URL "${currentUrl}", ${assertion}` : assertion;
     const { output, executor } = await this.taskExecutor.assert(assertionWithContext);
     const metadata = this.afterTaskRunning(executor, true);
     if (output && opt?.keepRawResponse) {
@@ -2823,81 +2599,42 @@ ${errors}`);
     }
     throw new Error("evaluateJavaScript is not supported in current agent");
   }
-  async destroy() {
-    await this.page.destroy();
-  }
-  /**
-   * Analyze execution results from executor to generate meaningful descriptions
-   */
-  analyzeExecutionResults(executor, originalPrompt) {
-    const tasks = executor.tasks;
-    const success = !executor.isInErrorState();
-    if (!success) {
-      const errorTask = executor.latestErrorTask();
-      return {
-        success: false,
-        actionType: "error",
-        description: `Failed to execute: ${originalPrompt}`,
-        error: errorTask?.error
-      };
-    }
-    const actionTasks = tasks.filter((t) => t.type === "Action" && t.status === "finished");
-    const locateTasks = tasks.filter((t) => t.type === "Insight" && t.subType === "Locate");
-    const lastAction = actionTasks[actionTasks.length - 1];
-    const lastLocate = locateTasks[locateTasks.length - 1];
-    if (!lastAction) {
-      return {
-        success: true,
-        actionType: "unknown",
-        description: `Completed: ${originalPrompt}`
+  async logScreenshot(title, options) {
+    const screenshotTitle = title || "untitled";
+    const content = options?.content || "";
+    const screenshot = await this.page.screenshotBase64?.();
+    if (screenshot) {
+      const executionDump = {
+        name: screenshotTitle,
+        description: content,
+        tasks: [{
+          type: "Screenshot",
+          subType: "log",
+          status: "finished",
+          executor: null,
+          param: {
+            title: screenshotTitle,
+            content
+          },
+          output: {
+            screenshot
+          },
+          thought: `Logged screenshot: ${screenshotTitle}`,
+          timing: {
+            start: Date.now(),
+            end: Date.now(),
+            cost: 0
+          }
+        }],
+        sdkVersion: "1.0.0",
+        logTime: Date.now(),
+        model_name: "screenshot"
       };
+      this.appendExecutionDump(executionDump);
     }
-    const actionType = lastAction.subType || "unknown";
-    const elementInfo = this.extractElementInfo(lastLocate, lastAction);
-    const description = this.generateActionDescription(actionType, lastAction.param, elementInfo);
-    return {
-      success: true,
-      actionType,
-      description,
-      elementInfo,
-      timing: lastAction.timing?.cost
-    };
   }
-  /**
-   * Extract element information from locate task
-   */
-  extractElementInfo(locateTask, _actionTask) {
-    if (!locateTask?.output?.element)
-      return void 0;
-    const element = locateTask.output.element;
-    return {
-      type: element.attributes?.nodeType || "unknown",
-      text: element.content || element.attributes?.placeholder || element.attributes?.title || "",
-      location: `(${element.center[0]}, ${element.center[1]})`
-    };
-  }
-  /**
-   * Generate natural language description for actions
-   */
-  generateActionDescription(actionType, param, elementInfo) {
-    const elementDesc = elementInfo ? `'${elementInfo.text || elementInfo.type}' element` : "element";
-    switch (actionType) {
-      case "Tap":
-        return `Clicked on ${elementDesc}`;
-      case "Input":
-        const inputValue = param?.value || "";
-        return `Entered "${inputValue}" into ${elementDesc}`;
-      case "KeyboardPress":
-        return `Pressed ${param?.value || "key"}`;
-      case "Scroll":
-        return `Scrolled ${param?.direction || "on page"}`;
-      case "Hover":
-        return `Hovered over ${elementDesc}`;
-      case "Drag":
-        return `Dragged ${elementDesc}`;
-      default:
-        return `Performed ${actionType} action on ${elementDesc}`;
-    }
+  async destroy() {
+    await this.page.destroy();
   }
 };
 
@@ -2914,7 +2651,7 @@ var Page = class {
     this.everMoved = false;
     this.underlyingPage = underlyingPage;
     this.pageType = pageType;
-    this.waitForNavigationTimeout = opts?.waitForNavigationTimeout || import_constants3.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT;
+    this.waitForNavigationTimeout = opts?.waitForNavigationTimeout ?? import_constants3.DEFAULT_WAIT_FOR_NAVIGATION_TIMEOUT;
   }
   async evaluate(pageFunction, arg) {
     let result;
@@ -3319,6 +3056,14 @@ var PlaywrightAiFixture = (options) => {
         aiActionType: "aiTap"
       });
     },
+    aiRightClick: async ({ page }, use, testInfo) => {
+      await generateAiFunction({
+        page,
+        testInfo,
+        use,
+        aiActionType: "aiRightClick"
+      });
+    },
     aiHover: async ({ page }, use, testInfo) => {
       await generateAiFunction({
         page,
@@ -3406,6 +3151,14 @@ var PlaywrightAiFixture = (options) => {
         use,
         aiActionType: "aiBoolean"
       });
+    },
+    logScreenshot: async ({ page }, use, testInfo) => {
+      await generateAiFunction({
+        page,
+        testInfo,
+        use,
+        aiActionType: "logScreenshot"
+      });
     }
   };
 };