misoai-web 1.0.6 → 1.5.6

package/dist/lib/chrome-extension.js

@@ -193,10 +193,11 @@ var ScriptPlayer = class {
     this.unnamedResultIndex = 0;
     this.pageAgent = null;
     this.result = {};
+    const target = script.target || script.web || script.android;
     if (import_utils3.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`);
     }
@@ -270,12 +271,13 @@ var ScriptPlayer = class {
       } else if ("aiAssert" in flowItem) {
         const assertTask = flowItem;
         const prompt = assertTask.aiAssert;
+        const msg = assertTask.errorMessage;
         (0, import_utils3.assert)(prompt, "missing prompt for aiAssert");
         (0, import_utils3.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;
@@ -1725,7 +1727,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.5.6";
 
 // src/common/task-cache.ts
 var debug3 = (0, import_logger3.getDebug)("cache");
@@ -1753,70 +1755,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");
@@ -1892,16 +1868,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) => {
@@ -1909,11 +1880,6 @@ cache file: ${cacheFile}`
         });
       }
     } else {
-      if (newRecord.type === "plan" && contextData) {
-        const planRecord = newRecord;
-        planRecord.contextHash = this.generateContextHash(contextData);
-        planRecord.contextData = { ...contextData };
-      }
       this.appendCache(newRecord);
     }
   }
@@ -1943,13 +1909,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;
@@ -1976,69 +1939,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, {
@@ -2274,35 +2174,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,
@@ -2312,28 +2186,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
@@ -2358,114 +2210,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,
@@ -2575,48 +2330,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 {
@@ -2624,13 +2337,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) {
@@ -2844,79 +2551,6 @@ ${errors}`);
   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}`
-      };
-    }
-    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}`;
-    }
-  }
 };
 
 // src/chrome-extension/agent.ts
@@ -3134,7 +2768,7 @@ function sleep2(ms) {
 var ChromeExtensionProxyPage = class {
   constructor(forceSameTabNavigation) {
     this.pageType = "chrome-extension-proxy";
-    this.version = "1.0.5";
+    this.version = "1.5.6";
     this.activeTabId = null;
     this.tabIdOfDebuggerAttached = null;
     this.attachingDebugger = null;