@tangle-network/browser-agent-driver 0.23.0 → 0.24.1

package/dist/runner/runner.js

@@ -282,6 +282,37 @@ export class BrowserAgent {
         this.runRegistry = options.runRegistry;
     }
     async run(scenario) {
+        // Gen 21: parallel tab execution for compound goals.
+        // Pre-flight: check if the goal should be decomposed into parallel sub-goals.
+        if (this.config.parallelTabs?.enabled && scenario.goal && scenario.startUrl) {
+            const context = this.driver.getPage?.()?.context();
+            if (context) {
+                const { decomposeGoal } = await import('./goal-decomposer.js');
+                const decomposition = await decomposeGoal(scenario.goal, scenario.startUrl, {
+                    provider: this.config.provider || 'openai',
+                    model: this.config.navModel || 'gpt-4.1-mini',
+                    apiKey: this.config.apiKey,
+                });
+                if (decomposition.type === 'compound' && decomposition.subGoals) {
+                    const { runParallel } = await import('./parallel-runner.js');
+                    const result = await runParallel({
+                        context,
+                        config: this.config,
+                        originalGoal: scenario.goal,
+                        subGoals: decomposition.subGoals,
+                        scenario,
+                        onTurn: this.onTurn ? (_label, turn) => this.onTurn(turn) : undefined,
+                        projectStore: this.projectStore,
+                    });
+                    return {
+                        success: result.success,
+                        reason: result.mergedResult,
+                        turns: [],
+                        totalMs: result.totalMs,
+                    };
+                }
+            }
+        }
         // Gen 14: vision mode gets more turns — each turn takes ~15s (screenshot
         // encode + image tokens) vs ~5s for DOM-first. Without the boost, vision
         // runs out of turns before completing multi-step tasks.
@@ -322,7 +353,7 @@ export class BrowserAgent {
                 phaseTimings,
                 wasteMetrics: deriveWasteMetrics(turns, runState.verificationRejectionCount, runState.firstSufficientEvidenceTurn),
             };
-            this.saveMemory(scenario, agentResult);
+            this.saveMemory(scenario, agentResult, turns);
             // Complete run manifest
             const lastTurn = agentResult.turns[agentResult.turns.length - 1];
             this.runRegistry?.completeRun(runId, {
@@ -395,6 +426,19 @@ export class BrowserAgent {
             await navPromise;
             phaseTimings.initialNavigateMs = Date.now() - navigateStartedAt;
             this.onPhaseTiming?.('navigate', phaseTimings.initialNavigateMs);
+            // Gen 24b: page warm-up — simulate human settling time after page load.
+            // DataDome and similar ML anti-bot systems measure time-to-first-interaction.
+            // Bots act within 100ms; humans take 1-3 seconds to orient on a new page.
+            // Also adds a small random scroll to generate natural mouse/scroll events.
+            const page = this.driver.getPage?.();
+            if (page) {
+                const settleMs = 1500 + Math.floor(Math.random() * 1500); // 1.5-3s
+                await page.waitForTimeout(settleMs);
+                // Small exploratory scroll — humans look around before acting
+                await page.mouse.move(300 + Math.random() * 400, 200 + Math.random() * 200);
+                await page.mouse.wheel(0, 100 + Math.random() * 200);
+                await page.waitForTimeout(300 + Math.floor(Math.random() * 500));
+            }
         }
         // Don't wait on warmup before entering the loop — it races against the
         // first observe and decode. Make sure any unhandled rejection is silenced.
@@ -410,8 +454,9 @@ export class BrowserAgent {
         });
         const supervisorConfig = {
             enabled: this.config.supervisor?.enabled ?? DEFAULT_SUPERVISOR.enabled,
-            model: this.config.supervisor?.model || this.config.model || 'gpt-5.4',
-            provider: this.config.supervisor?.provider || this.config.provider || 'openai',
+            // Gen 28: models.supervisor overrides supervisor.model, falls back to main
+            model: this.config.models?.supervisor?.model || this.config.supervisor?.model || this.config.model || 'gpt-5.4',
+            provider: (this.config.models?.supervisor?.provider || this.config.supervisor?.provider || this.config.provider || 'openai'),
             useVision: this.config.supervisor?.useVision ?? DEFAULT_SUPERVISOR.useVision,
             minTurnsBeforeInvoke: this.config.supervisor?.minTurnsBeforeInvoke ?? DEFAULT_SUPERVISOR.minTurnsBeforeInvoke,
             cooldownTurns: this.config.supervisor?.cooldownTurns ?? DEFAULT_SUPERVISOR.cooldownTurns,
@@ -1185,11 +1230,26 @@ export class BrowserAgent {
                     }
                 }
                 else {
+                    // Gen 24b: micro-movements during LLM "thinking" — anti-bot systems
+                    // flag frozen cursors. Run small random mouse drifts in parallel with
+                    // the LLM call. Stops when the decision arrives.
+                    let microMoving = true;
+                    const microMoveLoop = (async () => {
+                        const p = this.driver.getPage?.();
+                        if (!p)
+                            return;
+                        while (microMoving) {
+                            await p.mouse.move(300 + Math.random() * 600, 200 + Math.random() * 400, { steps: 3 }).catch(() => { });
+                            await p.waitForTimeout(800 + Math.floor(Math.random() * 1200)).catch(() => { });
+                        }
+                    })();
                     decision = await withRetry(() => this.brain.decide(scenario.goal, decisionState, finalExtraContext || undefined, { current: i, max: maxTurns }, { forceVision }), retries, retryDelayMs, (attempt, err) => {
                         if (this.config.debug) {
                             console.log(`[Runner] LLM retry ${attempt}: ${err.message}`);
                         }
                     }, scenario.signal);
+                    microMoving = false;
+                    void microMoveLoop; // ensure no unhandled rejection
                     if (cacheKey && this.decisionCache) {
                         // Store the fresh decision so a future identical turn replays it.
                         this.decisionCache.set(cacheKey, decision);
@@ -1547,8 +1607,22 @@ export class BrowserAgent {
                             runState.verificationRejectionCount++;
                             turn.verificationFailure = goalResult.missing.join('; ') || 'Goal verification failed';
                             runState.firstSufficientEvidenceTurn ??= i;
+                            // Gen 24b: checkpoint replay on 2nd rejection. Navigate back
+                            // to a previous page where the agent had correct data, instead
+                            // of continuing from the wrong-path state.
+                            let replayNote = '';
+                            if (runState.verificationRejectionCount === 2 && runState.checkpoints.length >= 2) {
+                                // Go back to the second-to-last checkpoint (before the wrong path)
+                                const target = runState.checkpoints[runState.checkpoints.length - 2];
+                                if (target) {
+                                    try {
+                                        await this.driver.execute({ action: 'navigate', url: target.url });
+                                        replayNote = ` ROLLED BACK to ${target.url} (checkpoint from turn ${target.turn}). You went down the wrong path — try a different approach from this known-good page.`;
+                                    }
+                                    catch { /* rollback failed, continue from current state */ }
+                                }
+                            }
                             // Gen 19: progressive strategy-shift escalation on rejection.
-                            // Each rejection level suggests a MORE different approach.
                             let escalation;
                             if (runState.verificationRejectionCount >= 3) {
                                 escalation = ' STRATEGY SHIFT REQUIRED: Your previous approaches have failed 3 times. Try a COMPLETELY different method: use navigate to go to a different search engine or URL, try extractWithIndex instead of runScript, or scroll to look for the data in a different part of the page. Do NOT repeat what you just tried.';
@@ -1559,7 +1633,7 @@ export class BrowserAgent {
                             else {
                                 escalation = ' Re-read the GOAL carefully — your result is missing specific data the goal asked for. Find and include it before completing.';
                             }
-                            this.brain.injectFeedback(`REJECTED (${goalResult.confidence.toFixed(2)}). Missing: ${goalResult.missing.join('; ')}.${escalation}`);
+                            this.brain.injectFeedback(`REJECTED (${goalResult.confidence.toFixed(2)}). Missing: ${goalResult.missing.join('; ')}.${escalation}${replayNote}`);
                             turn.durationMs = Date.now() - turnStart;
                             turns.push(turn);
                             this.onTurn?.(turn);
@@ -1740,6 +1814,16 @@ export class BrowserAgent {
                             console.log(`[Runner] Fill warning: ${warning}`);
                         }
                     }
+                    // Gen 24b: save checkpoint when URL changes after successful action.
+                    // These are rollback points for wrong-path recovery.
+                    const postUrl = this.driver.getPage?.()?.url() || '';
+                    const lastCheckpointUrl = runState.checkpoints[runState.checkpoints.length - 1]?.url;
+                    if (postUrl && postUrl !== 'about:blank' && postUrl !== lastCheckpointUrl) {
+                        runState.checkpoints.push({ url: postUrl, turn: i });
+                        // Keep max 5 checkpoints to avoid unbounded growth
+                        if (runState.checkpoints.length > 5)
+                            runState.checkpoints.shift();
+                    }
                     // Capture element bounding box for replay overlays
                     if (execResult.bounds) {
                         turn.actionBounds = execResult.bounds;
@@ -1931,10 +2015,29 @@ export class BrowserAgent {
         return selected;
     }
     /** Persist knowledge, selector cache, and session history to disk */
-    saveMemory(scenario, result) {
+    saveMemory(scenario, result, turns) {
         try {
             if (this.knowledge && scenario && result) {
                 this.knowledge.recordSession(buildSession(scenario, result));
+                // Gen 26b: extract reusable patterns from successful runs.
+                // Patterns gain confidence with repeated observation and auto-decay
+                // when contradicted. Low-confidence facts are pruned automatically.
+                if (result.success && turns && turns.length > 0) {
+                    const domain = safeHostname(scenario.startUrl || '') || '';
+                    if (domain) {
+                        // Dynamic import to keep the module tree clean
+                        import('./pattern-extractor.js').then(({ extractPatterns, recordPatterns }) => {
+                            const patterns = extractPatterns(turns, domain, result.success);
+                            if (patterns.length > 0) {
+                                recordPatterns(this.knowledge, patterns);
+                                this.knowledge.save();
+                                if (this.config.debug) {
+                                    console.log(`[Runner] Recorded ${patterns.length} patterns for ${domain}`);
+                                }
+                            }
+                        }).catch(() => { });
+                    }
+                }
             }
             this.knowledge?.save();
             this.selectorCache?.save();