@midscene/web 0.1.4 → 0.2.0

package/dist/lib/index.js

@@ -53,17 +53,76 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/playwright/index.ts
-var import_crypto = require("crypto");
+var import_node_crypto = require("crypto");
 
-// src/playwright/cache.ts
-var import_path2 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
+// src/common/agent.ts
+var import_utils4 = require("@midscene/core/utils");
+
+// src/common/tasks.ts
+var import_node_assert2 = __toESM(require("assert"));
+var import_core = __toESM(require("@midscene/core"));
+var import_image2 = require("@midscene/core/image");
 var import_utils2 = require("@midscene/core/utils");
 
+// src/common/task-cache.ts
+var TaskCache = class {
+  constructor(opts) {
+    this.cache = opts == null ? void 0 : opts.cache;
+    this.newCache = {
+      aiTasks: []
+    };
+  }
+  readCache(pageContext, type, userPrompt) {
+    var _a;
+    if (this.cache) {
+      const { aiTasks } = this.cache;
+      const index = aiTasks.findIndex((item) => item.prompt === userPrompt);
+      if (index === -1) {
+        return false;
+      }
+      const taskRes = aiTasks.splice(index, 1)[0];
+      if ((taskRes == null ? void 0 : taskRes.type) === "locate" && !((_a = taskRes.response) == null ? void 0 : _a.elements.every((element) => {
+        const findIndex = pageContext.content.findIndex(
+          (contentElement) => contentElement.id === element.id
+        );
+        if (findIndex === -1) {
+          return false;
+        }
+        return true;
+      }))) {
+        return false;
+      }
+      if (taskRes && taskRes.type === type && taskRes.prompt === userPrompt && this.pageContextEqual(taskRes.pageContext, pageContext)) {
+        return taskRes.response;
+      }
+    }
+    return false;
+  }
+  saveCache(cache) {
+    var _a;
+    if (cache) {
+      (_a = this.newCache) == null ? void 0 : _a.aiTasks.push(cache);
+    }
+  }
+  pageContextEqual(taskPageContext, pageContext) {
+    return taskPageContext.size.width === pageContext.size.width && taskPageContext.size.height === pageContext.size.height;
+  }
+  /**
+   * Generate task cache data.
+   * This method is mainly used to create or obtain some cached data for tasks, and it returns a new cache object.
+   * In the cache object, it may contain task-related information, states, or other necessary data.
+   * It is assumed that the `newCache` property already exists in the current class or object and is a data structure used to store task cache.
+   * @returns {Object} Returns a new cache object, which may include task cache data.
+   */
+  generateTaskCache() {
+    return this.newCache;
+  }
+};
+
 // src/common/utils.ts
-var import_fs = __toESM(require("fs"));
-var import_assert = __toESM(require("assert"));
-var import_path = __toESM(require("path"));
+var import_node_assert = __toESM(require("assert"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
 var import_image = require("@midscene/core/image");
 var import_utils = require("@midscene/core/utils");
 
@@ -79,7 +138,10 @@ var WebElementInfo = class {
   }) {
     this.content = content;
     this.rect = rect;
-    this.center = [Math.floor(rect.left + rect.width / 2), Math.floor(rect.top + rect.height / 2)];
+    this.center = [
+      Math.floor(rect.left + rect.width / 2),
+      Math.floor(rect.top + rect.height / 2)
+    ];
     this.page = page;
     this.locator = locator;
     this.id = id;
@@ -89,14 +151,18 @@ var WebElementInfo = class {
 
 // src/common/utils.ts
 async function parseContextFromWebPage(page, _opt) {
-  (0, import_assert.default)(page, "page is required");
+  (0, import_node_assert.default)(page, "page is required");
   const url = page.url();
   const file = (0, import_utils.getTmpFile)("jpeg");
   await page.screenshot({ path: file, type: "jpeg", quality: 75 });
-  const screenshotBuffer = (0, import_fs.readFileSync)(file);
+  const screenshotBuffer = (0, import_node_fs.readFileSync)(file);
   const screenshotBase64 = (0, import_image.base64Encoded)(file);
   const captureElementSnapshot = await getElementInfosFromPage(page);
-  const elementsInfo = await alignElements(screenshotBuffer, captureElementSnapshot, page);
+  const elementsInfo = await alignElements(
+    screenshotBuffer,
+    captureElementSnapshot,
+    page
+  );
   const size = await (0, import_image.imageInfoOfBase64)(screenshotBase64);
   return {
     content: elementsInfo,
@@ -107,9 +173,9 @@ async function parseContextFromWebPage(page, _opt) {
 }
 async function getElementInfosFromPage(page) {
   const pathDir = findNearestPackageJson(__dirname);
-  (0, import_assert.default)(pathDir, `can't find pathDir, with ${__dirname}`);
-  const scriptPath = import_path.default.join(pathDir, "./dist/script/htmlElement.js");
-  const elementInfosScriptContent = (0, import_fs.readFileSync)(scriptPath, "utf-8");
+  (0, import_node_assert.default)(pathDir, `can't find pathDir, with ${__dirname}`);
+  const scriptPath = import_node_path.default.join(pathDir, "./dist/script/htmlElement.js");
+  const elementInfosScriptContent = (0, import_node_fs.readFileSync)(scriptPath, "utf-8");
   const extraReturnLogic = `${elementInfosScriptContent}midscene_element_inspector.extractTextWithPositionDFS()`;
   const captureElementSnapshot = await page.evaluate(extraReturnLogic);
   return captureElementSnapshot;
@@ -133,135 +199,17 @@ async function alignElements(screenshotBuffer, elements, page) {
   return textsAligned;
 }
 function findNearestPackageJson(dir) {
-  const packageJsonPath = import_path.default.join(dir, "package.json");
-  if (import_fs.default.existsSync(packageJsonPath)) {
+  const packageJsonPath = import_node_path.default.join(dir, "package.json");
+  if (import_node_fs.default.existsSync(packageJsonPath)) {
     return dir;
   }
-  const parentDir = import_path.default.dirname(dir);
+  const parentDir = import_node_path.default.dirname(dir);
   if (parentDir === dir) {
     return null;
   }
   return findNearestPackageJson(parentDir);
 }
 
-// src/playwright/cache.ts
-function writeTestCache(taskFile, taskTitle, taskCacheJson) {
-  const packageJson = getPkgInfo();
-  (0, import_utils2.writeDumpFile)({
-    fileName: `${taskFile}(${taskTitle})`,
-    fileExt: "json",
-    fileContent: JSON.stringify(
-      __spreadValues({
-        pkgName: packageJson.name,
-        pkgVersion: packageJson.version,
-        taskFile,
-        taskTitle
-      }, taskCacheJson),
-      null,
-      2
-    ),
-    type: "cache"
-  });
-}
-function readTestCache(taskFile, taskTitle) {
-  const cacheFile = (0, import_path2.join)((0, import_utils2.getDumpDirPath)("cache"), `${taskFile}(${taskTitle}).json`);
-  const pkgInfo = getPkgInfo();
-  if (process.env.MIDSCENE_CACHE === "true" && import_fs2.default.existsSync(cacheFile)) {
-    try {
-      const data = import_fs2.default.readFileSync(cacheFile, "utf8");
-      const jsonData = JSON.parse(data);
-      if (jsonData.pkgName !== pkgInfo.name || jsonData.pkgVersion !== pkgInfo.version) {
-        return void 0;
-      }
-      return jsonData;
-    } catch (err) {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function getPkgInfo() {
-  const packageJsonDir = findNearestPackageJson(__dirname);
-  if (!packageJsonDir) {
-    console.error("Cannot find package.json directory: ", __dirname);
-    return {
-      name: "@midscene/web",
-      version: "0.0.0"
-    };
-  }
-  const packageJsonPath = import_path2.default.join(packageJsonDir, "package.json");
-  const data = import_fs2.default.readFileSync(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(data);
-  return {
-    name: packageJson.name,
-    version: packageJson.version
-  };
-}
-
-// src/common/agent.ts
-var import_utils6 = require("@midscene/core/utils");
-
-// src/common/tasks.ts
-var import_assert2 = __toESM(require("assert"));
-var import_core = __toESM(require("@midscene/core"));
-var import_utils4 = require("@midscene/core/utils");
-var import_image2 = require("@midscene/core/image");
-
-// src/common/task-cache.ts
-var TaskCache = class {
-  constructor(opts) {
-    this.cache = opts == null ? void 0 : opts.cache;
-    this.newCache = {
-      aiTasks: []
-    };
-  }
-  readCache(pageContext, type, userPrompt) {
-    var _a;
-    if (this.cache) {
-      const { aiTasks } = this.cache;
-      const index = aiTasks.findIndex((item) => item.prompt === userPrompt);
-      if (index === -1) {
-        return false;
-      }
-      const taskRes = aiTasks.splice(index, 1)[0];
-      if ((taskRes == null ? void 0 : taskRes.type) === "locate" && !((_a = taskRes.response) == null ? void 0 : _a.elements.every((element) => {
-        const findIndex = pageContext.content.findIndex(
-          (contentElement) => contentElement.id === element.id
-        );
-        if (findIndex === -1) {
-          return false;
-        }
-        return true;
-      }))) {
-        return false;
-      }
-      if (taskRes && taskRes.type === type && taskRes.prompt === userPrompt && this.pageContextEqual(taskRes.pageContext, pageContext)) {
-        return taskRes.response;
-      }
-    }
-    return false;
-  }
-  saveCache(cache) {
-    var _a;
-    if (cache) {
-      (_a = this.newCache) == null ? void 0 : _a.aiTasks.push(cache);
-    }
-  }
-  pageContextEqual(taskPageContext, pageContext) {
-    return taskPageContext.size.width === pageContext.size.width && taskPageContext.size.height === pageContext.size.height;
-  }
-  /**
-   * Generate task cache data.
-   * This method is mainly used to create or obtain some cached data for tasks, and it returns a new cache object.
-   * In the cache object, it may contain task-related information, states, or other necessary data.
-   * It is assumed that the `newCache` property already exists in the current class or object and is a data structure used to store task cache.
-   * @returns {Object} Returns a new cache object, which may include task cache data.
-   */
-  generateTaskCache() {
-    return this.newCache;
-  }
-};
-
 // src/common/tasks.ts
 var PageTaskExecutor = class {
   constructor(page, opts) {
@@ -272,8 +220,8 @@ var PageTaskExecutor = class {
     this.taskCache = new TaskCache(opts);
   }
   async recordScreenshot(timing) {
-    const file = (0, import_utils4.getTmpFile)("jpeg");
-    await this.page.screenshot(__spreadProps(__spreadValues({}, import_utils4.commonScreenshotParam), {
+    const file = (0, import_utils2.getTmpFile)("jpeg");
+    await this.page.screenshot(__spreadProps(__spreadValues({}, import_utils2.commonScreenshotParam), {
       path: file
     }));
     const item = {
@@ -294,7 +242,7 @@ var PageTaskExecutor = class {
         recorder.push(shot);
         const result = await taskApply.executor(param, context, ...args);
         if (taskApply.type === "Action") {
-          await (0, import_utils4.sleep)(1e3);
+          await (0, import_utils2.sleep)(1e3);
           const shot2 = await this.recordScreenshot("after Action");
           recorder.push(shot2);
         }
@@ -317,7 +265,11 @@ var PageTaskExecutor = class {
             };
             this.insight.onceDumpUpdatedFn = dumpCollector;
             const pageContext = await this.insight.contextRetrieverFn();
-            const locateCache = this.taskCache.readCache(pageContext, "locate", param.prompt);
+            const locateCache = this.taskCache.readCache(
+              pageContext,
+              "locate",
+              param.prompt
+            );
             let locateResult;
             const callAI = this.insight.aiVendorFn;
             const element = await this.insight.locate(param.prompt, {
@@ -330,7 +282,7 @@ var PageTaskExecutor = class {
                 return locateResult;
               }
             });
-            (0, import_assert2.default)(element, `Element not found: ${param.prompt}`);
+            (0, import_node_assert2.default)(element, `Element not found: ${param.prompt}`);
             if (locateResult) {
               this.taskCache.saveCache({
                 type: "locate",
@@ -356,59 +308,100 @@ var PageTaskExecutor = class {
           }
         };
         return taskFind;
-      } else if (plan2.type === "Input") {
+      }
+      if (plan2.type === "Assert") {
+        const assertPlan = plan2;
+        const taskAssert = {
+          type: "Insight",
+          subType: "Assert",
+          param: assertPlan.param,
+          executor: async () => {
+            let insightDump;
+            const dumpCollector = (dump) => {
+              insightDump = dump;
+            };
+            this.insight.onceDumpUpdatedFn = dumpCollector;
+            const assertion = await this.insight.assert(
+              assertPlan.param.assertion
+            );
+            return {
+              output: assertion,
+              log: {
+                dump: insightDump
+              }
+            };
+          }
+        };
+        return taskAssert;
+      }
+      if (plan2.type === "Input") {
         const taskActionInput = {
           type: "Action",
           subType: "Input",
           param: plan2.param,
           executor: async (taskParam, { element }) => {
             if (element) {
-              await this.page.mouse.click(element.center[0], element.center[1]);
+              await this.page.mouse.click(
+                element.center[0],
+                element.center[1]
+              );
             }
-            (0, import_assert2.default)(taskParam.value, "No value to input");
+            (0, import_node_assert2.default)(taskParam.value, "No value to input");
             await this.page.keyboard.type(taskParam.value);
           }
         };
         return taskActionInput;
-      } else if (plan2.type === "KeyboardPress") {
+      }
+      if (plan2.type === "KeyboardPress") {
         const taskActionKeyboardPress = {
           type: "Action",
           subType: "KeyboardPress",
           param: plan2.param,
           executor: async (taskParam) => {
-            (0, import_assert2.default)(taskParam.value, "No key to press");
+            (0, import_node_assert2.default)(taskParam.value, "No key to press");
             await this.page.keyboard.press(taskParam.value);
           }
         };
         return taskActionKeyboardPress;
-      } else if (plan2.type === "Tap") {
+      }
+      if (plan2.type === "Tap") {
         const taskActionTap = {
           type: "Action",
           subType: "Tap",
           executor: async (param, { element }) => {
-            (0, import_assert2.default)(element, "Element not found, cannot tap");
-            await this.page.mouse.click(element.center[0], element.center[1]);
+            (0, import_node_assert2.default)(element, "Element not found, cannot tap");
+            await this.page.mouse.click(
+              element.center[0],
+              element.center[1]
+            );
           }
         };
         return taskActionTap;
-      } else if (plan2.type === "Hover") {
+      }
+      if (plan2.type === "Hover") {
         const taskActionHover = {
           type: "Action",
           subType: "Hover",
           executor: async (param, { element }) => {
-            (0, import_assert2.default)(element, "Element not found, cannot hover");
-            await this.page.mouse.move(element.center[0], element.center[1]);
+            (0, import_node_assert2.default)(element, "Element not found, cannot hover");
+            await this.page.mouse.move(
+              element.center[0],
+              element.center[1]
+            );
           }
         };
         return taskActionHover;
-      } else if (plan2.type === "Scroll") {
+      }
+      if (plan2.type === "Scroll") {
         const taskActionScroll = {
           type: "Action",
           subType: "Scroll",
           param: plan2.param,
           executor: async (taskParam) => {
             const scrollToEventName = taskParam.scrollType;
-            const innerHeight = await this.page.evaluate(() => window.innerHeight);
+            const innerHeight = await this.page.evaluate(
+              () => window.innerHeight
+            );
             switch (scrollToEventName) {
               case "ScrollUntilTop":
                 await this.page.mouse.wheel(0, -9999999);
@@ -423,16 +416,19 @@ var PageTaskExecutor = class {
                 await this.page.mouse.wheel(0, innerHeight);
                 break;
               default:
-                console.error("Unknown scroll event type:", scrollToEventName);
+                console.error(
+                  "Unknown scroll event type:",
+                  scrollToEventName
+                );
             }
           }
         };
         return taskActionScroll;
-      } else if (plan2.type === "Error") {
+      }
+      if (plan2.type === "Error") {
         throw new Error(`Got a task plan with type Error: ${plan2.thought}`);
-      } else {
-        throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
       }
+      throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
     }).map((task) => {
       return this.wrapExecutorWithScreenshot(task);
     });
@@ -450,7 +446,11 @@ var PageTaskExecutor = class {
       executor: async (param) => {
         const pageContext = await this.insight.contextRetrieverFn();
         let planResult;
-        const planCache = this.taskCache.readCache(pageContext, "plan", userPrompt);
+        const planCache = this.taskCache.readCache(
+          pageContext,
+          "plan",
+          userPrompt
+        );
         if (planCache) {
           planResult = planCache;
         } else {
@@ -458,7 +458,7 @@ var PageTaskExecutor = class {
             context: pageContext
           });
         }
-        (0, import_assert2.default)(planResult.plans.length > 0, "No plans found");
+        (0, import_node_assert2.default)(planResult.plans.length > 0, "No plans found");
         plans = planResult.plans;
         this.taskCache.saveCache({
           type: "plan",
@@ -472,7 +472,7 @@ var PageTaskExecutor = class {
         return {
           output: planResult,
           cache: {
-            hint: Boolean(planCache)
+            hit: Boolean(planCache)
           }
         };
       }
@@ -485,7 +485,7 @@ var PageTaskExecutor = class {
       await taskExecutor.append(executables);
       await taskExecutor.flush();
       this.executionDump = taskExecutor.dump();
-      (0, import_assert2.default)(
+      (0, import_node_assert2.default)(
         taskExecutor.status !== "error",
         `failed to execute tasks: ${taskExecutor.status}, msg: ${taskExecutor.errorMsg || ""}`
       );
@@ -530,6 +530,22 @@ var PageTaskExecutor = class {
     }
     return data;
   }
+  async assert(assertion) {
+    const description = assertion;
+    const taskExecutor = new import_core.Executor(description);
+    taskExecutor.description = description;
+    const assertionPlan = {
+      type: "Assert",
+      param: {
+        assertion
+      }
+    };
+    const assertTask = await this.convertPlanToExecutable([assertionPlan]);
+    await taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+    const assertionResult = await taskExecutor.flush();
+    this.executionDump = taskExecutor.dump();
+    return assertionResult;
+  }
 };
 
 // src/common/agent.ts
@@ -543,7 +559,7 @@ var PageAgent = class {
       }
     ];
     this.testId = (opts == null ? void 0 : opts.testId) || String(process.pid);
-    this.actionAgent = new PageTaskExecutor(this.page, {
+    this.taskExecutor = new PageTaskExecutor(this.page, {
       cache: (opts == null ? void 0 : opts.cache) || { aiTasks: [] }
     });
   }
@@ -552,21 +568,21 @@ var PageAgent = class {
     currentDump.executions.push(execution);
   }
   writeOutActionDumps() {
-    this.dumpFile = (0, import_utils6.writeDumpFile)({
+    this.dumpFile = (0, import_utils4.writeDumpFile)({
       fileName: `playwright-${this.testId}`,
-      fileExt: import_utils6.groupedActionDumpFileExt,
+      fileExt: import_utils4.groupedActionDumpFileExt,
       fileContent: JSON.stringify(this.dumps)
     });
   }
   async aiAction(taskPrompt) {
     let error;
     try {
-      await this.actionAgent.action(taskPrompt);
+      await this.taskExecutor.action(taskPrompt);
     } catch (e) {
       error = e;
     }
-    if (this.actionAgent.executionDump) {
-      this.appendDump(this.actionAgent.executionDump);
+    if (this.taskExecutor.executionDump) {
+      this.appendDump(this.taskExecutor.executionDump);
       this.writeOutActionDumps();
     }
     if (error) {
@@ -578,12 +594,12 @@ var PageAgent = class {
     let error;
     let result;
     try {
-      result = await this.actionAgent.query(demand);
+      result = await this.taskExecutor.query(demand);
     } catch (e) {
       error = e;
     }
-    if (this.actionAgent.executionDump) {
-      this.appendDump(this.actionAgent.executionDump);
+    if (this.taskExecutor.executionDump) {
+      this.appendDump(this.taskExecutor.executionDump);
       this.writeOutActionDumps();
     }
     if (error) {
@@ -592,23 +608,102 @@ var PageAgent = class {
     }
     return result;
   }
+  async aiAssert(assertion, msg) {
+    const assertionResult = await this.taskExecutor.assert(assertion);
+    if (this.taskExecutor.executionDump) {
+      this.appendDump(this.taskExecutor.executionDump);
+      this.writeOutActionDumps();
+    }
+    if (!assertionResult.pass) {
+      const errMsg = msg || `Assertion failed: ${assertion}`;
+      const reasonMsg = `Reason: ${assertionResult.thought}`;
+      throw new Error(`${errMsg}
+${reasonMsg}`);
+    }
+  }
   async ai(taskPrompt, type = "action") {
     if (type === "action") {
       return this.aiAction(taskPrompt);
-    } else if (type === "query") {
+    }
+    if (type === "query") {
       return this.aiQuery(taskPrompt);
     }
-    throw new Error(`Unknown or Unsupported task type: ${type}, only support 'action' or 'query'`);
+    if (type === "assert") {
+      return this.aiAssert(taskPrompt);
+    }
+    throw new Error(
+      `Unknown type: ${type}, only support 'action', 'query', 'assert'`
+    );
   }
 };
 
+// src/playwright/cache.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_utils6 = require("@midscene/core/utils");
+function writeTestCache(taskFile, taskTitle, taskCacheJson) {
+  const packageJson = getPkgInfo();
+  (0, import_utils6.writeDumpFile)({
+    fileName: `${taskFile}(${taskTitle})`,
+    fileExt: "json",
+    fileContent: JSON.stringify(
+      __spreadValues({
+        pkgName: packageJson.name,
+        pkgVersion: packageJson.version,
+        taskFile,
+        taskTitle
+      }, taskCacheJson),
+      null,
+      2
+    ),
+    type: "cache"
+  });
+}
+function readTestCache(taskFile, taskTitle) {
+  const cacheFile = (0, import_node_path2.join)(
+    (0, import_utils6.getDumpDirPath)("cache"),
+    `${taskFile}(${taskTitle}).json`
+  );
+  const pkgInfo = getPkgInfo();
+  if (process.env.MIDSCENE_CACHE === "true" && import_node_fs2.default.existsSync(cacheFile)) {
+    try {
+      const data = import_node_fs2.default.readFileSync(cacheFile, "utf8");
+      const jsonData = JSON.parse(data);
+      if (jsonData.pkgName !== pkgInfo.name || jsonData.pkgVersion !== pkgInfo.version) {
+        return void 0;
+      }
+      return jsonData;
+    } catch (err) {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function getPkgInfo() {
+  const packageJsonDir = findNearestPackageJson(__dirname);
+  if (!packageJsonDir) {
+    console.error("Cannot find package.json directory: ", __dirname);
+    return {
+      name: "@midscene/web",
+      version: "0.0.0"
+    };
+  }
+  const packageJsonPath = import_node_path2.default.join(packageJsonDir, "package.json");
+  const data = import_node_fs2.default.readFileSync(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(data);
+  return {
+    name: packageJson.name,
+    version: packageJson.version
+  };
+}
+
 // src/playwright/index.ts
 var groupAndCaseForTest = (testInfo) => {
   let taskFile;
   let taskTitle;
   const titlePath = [...testInfo.titlePath];
   if (titlePath.length > 1) {
-    taskTitle = titlePath.pop();
+    taskTitle = titlePath.pop() || "unnamed";
     taskFile = `${titlePath.join(" > ")}:${testInfo.line}`;
   } else if (titlePath.length === 1) {
     taskTitle = titlePath[0];
@@ -619,15 +714,17 @@ var groupAndCaseForTest = (testInfo) => {
   }
   return { taskFile, taskTitle };
 };
-var midSceneAgentKeyId = "_midSceneAgentId";
+var midsceneAgentKeyId = "_midsceneAgentId";
 var PlaywrightAiFixture = () => {
   const pageAgentMap = {};
   const agentForPage = (page, opts) => {
-    let idForPage = page[midSceneAgentKeyId];
+    let idForPage = page[midsceneAgentKeyId];
     if (!idForPage) {
-      idForPage = (0, import_crypto.randomUUID)();
-      page[midSceneAgentKeyId] = idForPage;
-      const testCase = readTestCache(opts.taskFile, opts.taskTitle) || { aiTasks: [] };
+      idForPage = (0, import_node_crypto.randomUUID)();
+      page[midsceneAgentKeyId] = idForPage;
+      const testCase = readTestCache(opts.taskFile, opts.taskTitle) || {
+        aiTasks: []
+      };
       pageAgentMap[idForPage] = new PageAgent(page, {
         testId: `${opts.testId}-${idForPage}`,
         taskFile: opts.taskFile,
@@ -639,14 +736,20 @@ var PlaywrightAiFixture = () => {
   return {
     ai: async ({ page }, use, testInfo) => {
       const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
-      const agent = agentForPage(page, { testId: testInfo.testId, taskFile, taskTitle });
-      await use(async (taskPrompt, opts) => {
-        await page.waitForLoadState("networkidle");
-        const actionType = (opts == null ? void 0 : opts.type) || "action";
-        const result = await agent.ai(taskPrompt, actionType);
-        return result;
+      const agent = agentForPage(page, {
+        testId: testInfo.testId,
+        taskFile,
+        taskTitle
       });
-      const taskCacheJson = agent.actionAgent.taskCache.generateTaskCache();
+      await use(
+        async (taskPrompt, opts) => {
+          await page.waitForLoadState("networkidle");
+          const actionType = (opts == null ? void 0 : opts.type) || "action";
+          const result = await agent.ai(taskPrompt, actionType);
+          return result;
+        }
+      );
+      const taskCacheJson = agent.taskExecutor.taskCache.generateTaskCache();
       writeTestCache(taskFile, taskTitle, taskCacheJson);
       if (agent.dumpFile) {
         testInfo.annotations.push({
@@ -660,7 +763,11 @@ var PlaywrightAiFixture = () => {
     },
     aiAction: async ({ page }, use, testInfo) => {
       const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
-      const agent = agentForPage(page, { testId: testInfo.testId, taskFile, taskTitle });
+      const agent = agentForPage(page, {
+        testId: testInfo.testId,
+        taskFile,
+        taskTitle
+      });
       await use(async (taskPrompt) => {
         await page.waitForLoadState("networkidle");
         await agent.aiAction(taskPrompt);
@@ -677,8 +784,12 @@ var PlaywrightAiFixture = () => {
     },
     aiQuery: async ({ page }, use, testInfo) => {
       const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
-      const agent = agentForPage(page, { testId: testInfo.testId, taskFile, taskTitle });
-      await use(async function(demand) {
+      const agent = agentForPage(page, {
+        testId: testInfo.testId,
+        taskFile,
+        taskTitle
+      });
+      await use(async (demand) => {
         await page.waitForLoadState("networkidle");
         const result = await agent.aiQuery(demand);
         return result;
@@ -692,6 +803,27 @@ var PlaywrightAiFixture = () => {
           })
         });
       }
+    },
+    aiAssert: async ({ page }, use, testInfo) => {
+      const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
+      const agent = agentForPage(page, {
+        testId: testInfo.testId,
+        taskFile,
+        taskTitle
+      });
+      await use(async (assertion, errorMsg) => {
+        await page.waitForLoadState("networkidle");
+        await agent.aiAssert(assertion, errorMsg);
+      });
+      if (agent.dumpFile) {
+        testInfo.annotations.push({
+          type: "MIDSCENE_AI_ACTION",
+          description: JSON.stringify({
+            testId: testInfo.testId,
+            dumpPath: agent.dumpFile
+          })
+        });
+      }
     }
   };
 };