@midscene/core 1.17.4 → 1.17.5-beta-20261102094111.0

package/dist/es/agent/planned-wait.mjs

@@ -0,0 +1,62 @@
+import { defineAction } from "../device/index.mjs";
+import { z } from "zod";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const plannedWaitContext = `Conditional waiting policy for all UI tasks:
+- PRIORITY: An explicit current business error, permission denial, read-only account or validation failure overrides generic text such as "the interface may take time to respond". Do not reinterpret such an error as loading. If no user-authorized action can resolve it, fail immediately with the visible reason; do NOT WaitFor that prohibition to disappear or a disabled control to enable. Only an explicit indication of a temporary/in-progress recovery justifies waiting despite an error.
+- If the latest screenshot already shows the next target visible and enabled, act immediately. Do NOT insert WaitFor or Sleep as a routine precaution before/after every action, or to recheck a condition that is already visibly satisfied.
+- Before choosing WaitFor, identify a specific unmet prerequisite or a pending result of an already performed action. Explain that evidence briefly in the planning thought. A validation error or missing required user action is not an asynchronous wait.
+- Before an interaction, inspect whether its target is currently visible and enabled. A disabled or loading control is not ready: use WaitFor for that prerequisite BEFORE attempting Tap. Do not test-click disabled controls.
+- Choose the nearest unmet condition that can become true WITHOUT another user action. After entering text, if the next control is disabled, wait for that control to become enabled; do not wait for the final submission result before submitting.
+- Preserve already entered text. Do not add/delete characters, clear/retype, refocus or press Enter just to force asynchronous UI state to update. Input content must only be changed when required by the user's task or an explicit validation error.
+- An action call returning only proves dispatch, not application acceptance. Do not assume a disabled control accepted a click. For a dispatched action with pending UI feedback, wait for its relevant next state instead of replaying it merely because the screen is unchanged.
+- WaitFor only observes. Once its prerequisite is satisfied, execute the pending action. Wait for an outcome only when the required triggering action has been performed on a ready control. Complete only when the user's requested end state is observed; do not expand the task scope.
+- Never use Sleep as a substitute when a concrete visual readiness condition is available. Report explicit errors rather than waiting for impossible success.`;
+class PlannedWaitError extends Error {
+    constructor(cause){
+        super(`Planned WaitFor failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause
+        }), _define_property(this, "code", 'PLANNED_WAIT_FAILED');
+        this.name = 'PlannedWaitError';
+    }
+}
+function isPlannedWaitError(error) {
+    const seen = new Set();
+    while(error && 'object' == typeof error && !seen.has(error)){
+        seen.add(error);
+        const value = error;
+        if ('PLANNED_WAIT_FAILED' === value.code) return true;
+        error = value.cause;
+    }
+    return false;
+}
+function definePlannedWait(wait) {
+    return defineAction({
+        name: 'WaitFor',
+        description: 'Wait for an unmet visible prerequisite or a pending result of an accepted action. Skip this if the current screenshot already satisfies the condition. Never wait for a result whose triggering action has not happened, or for an explicit business error to disappear. Only observes; does not click or edit. Times out after 30 seconds.',
+        paramSchema: z.object({
+            condition: z.string().trim().min(1).describe('The visible condition needed before continuing, which can become true without another user action.')
+        }),
+        delayBeforeRunner: 0,
+        delayAfterRunner: 0,
+        call: async ({ condition }, context)=>{
+            try {
+                await wait(condition, context?.signal);
+                if (context) context.task.planningFeedback = `WaitFor succeeded: ${condition}. Continue from the current screenshot; do not repeat this wait unless new evidence shows the condition became false again.`;
+            } catch (error) {
+                throw new PlannedWaitError(error);
+            }
+        }
+    });
+}
+export { PlannedWaitError, definePlannedWait, isPlannedWaitError, plannedWaitContext };
+
+//# sourceMappingURL=planned-wait.mjs.map

package/dist/es/agent/planned-wait.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent/planned-wait.mjs","sources":["../../../src/agent/planned-wait.ts"],"sourcesContent":["import { defineAction } from '@/device';\nimport { z } from 'zod';\n\n/** Planning guidance is only attached when conditional waiting is enabled. */\nexport const plannedWaitContext = `Conditional waiting policy for all UI tasks:\n- PRIORITY: An explicit current business error, permission denial, read-only account or validation failure overrides generic text such as \"the interface may take time to respond\". Do not reinterpret such an error as loading. If no user-authorized action can resolve it, fail immediately with the visible reason; do NOT WaitFor that prohibition to disappear or a disabled control to enable. Only an explicit indication of a temporary/in-progress recovery justifies waiting despite an error.\n- If the latest screenshot already shows the next target visible and enabled, act immediately. Do NOT insert WaitFor or Sleep as a routine precaution before/after every action, or to recheck a condition that is already visibly satisfied.\n- Before choosing WaitFor, identify a specific unmet prerequisite or a pending result of an already performed action. Explain that evidence briefly in the planning thought. A validation error or missing required user action is not an asynchronous wait.\n- Before an interaction, inspect whether its target is currently visible and enabled. A disabled or loading control is not ready: use WaitFor for that prerequisite BEFORE attempting Tap. Do not test-click disabled controls.\n- Choose the nearest unmet condition that can become true WITHOUT another user action. After entering text, if the next control is disabled, wait for that control to become enabled; do not wait for the final submission result before submitting.\n- Preserve already entered text. Do not add/delete characters, clear/retype, refocus or press Enter just to force asynchronous UI state to update. Input content must only be changed when required by the user's task or an explicit validation error.\n- An action call returning only proves dispatch, not application acceptance. Do not assume a disabled control accepted a click. For a dispatched action with pending UI feedback, wait for its relevant next state instead of replaying it merely because the screen is unchanged.\n- WaitFor only observes. Once its prerequisite is satisfied, execute the pending action. Wait for an outcome only when the required triggering action has been performed on a ready control. Complete only when the user's requested end state is observed; do not expand the task scope.\n- Never use Sleep as a substitute when a concrete visual readiness condition is available. Report explicit errors rather than waiting for impossible success.`;\n\nexport class PlannedWaitError extends Error {\n  readonly code = 'PLANNED_WAIT_FAILED';\n  constructor(cause: unknown) {\n    super(\n      `Planned WaitFor failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      { cause },\n    );\n    this.name = 'PlannedWaitError';\n  }\n}\n\nexport function isPlannedWaitError(error: unknown): boolean {\n  const seen = new Set<unknown>();\n  while (error && typeof error === 'object' && !seen.has(error)) {\n    seen.add(error);\n    const value = error as { code?: unknown; cause?: unknown };\n    if (value.code === 'PLANNED_WAIT_FAILED') return true;\n    error = value.cause;\n  }\n  return false;\n}\n\nexport function definePlannedWait(\n  wait: (condition: string, signal?: AbortSignal) => Promise<void>,\n) {\n  return defineAction({\n    name: 'WaitFor',\n    description:\n      'Wait for an unmet visible prerequisite or a pending result of an accepted action. Skip this if the current screenshot already satisfies the condition. Never wait for a result whose triggering action has not happened, or for an explicit business error to disappear. Only observes; does not click or edit. Times out after 30 seconds.',\n    paramSchema: z.object({\n      condition: z\n        .string()\n        .trim()\n        .min(1)\n        .describe(\n          'The visible condition needed before continuing, which can become true without another user action.',\n        ),\n    }),\n    delayBeforeRunner: 0,\n    delayAfterRunner: 0,\n    call: async ({ condition }, context) => {\n      try {\n        await wait(condition, context?.signal);\n        if (context) {\n          context.task.planningFeedback = `WaitFor succeeded: ${condition}. Continue from the current screenshot; do not repeat this wait unless new evidence shows the condition became false again.`;\n        }\n      } catch (error) {\n        throw new PlannedWaitError(error);\n      }\n    },\n  });\n}\n"],"names":["plannedWaitContext","PlannedWaitError","Error","cause","String","isPlannedWaitError","error","seen","Set","value","definePlannedWait","wait","defineAction","z","condition","context"],"mappings":";;;;;;;;;;;;AAIO,MAAMA,qBAAqB,CAAC;;;;;;;;;6JAS0H,CAAC;AAEvJ,MAAMC,yBAAyBC;IAEpC,YAAYC,KAAc,CAAE;QAC1B,KAAK,CACH,CAAC,wBAAwB,EAAEA,iBAAiBD,QAAQC,MAAM,OAAO,GAAGC,OAAOD,QAAQ,EACnF;YAAEA;QAAM,IAJZ,uBAAS,QAAO;QAMd,IAAI,CAAC,IAAI,GAAG;IACd;AACF;AAEO,SAASE,mBAAmBC,KAAc;IAC/C,MAAMC,OAAO,IAAIC;IACjB,MAAOF,SAAS,AAAiB,YAAjB,OAAOA,SAAsB,CAACC,KAAK,GAAG,CAACD,OAAQ;QAC7DC,KAAK,GAAG,CAACD;QACT,MAAMG,QAAQH;QACd,IAAIG,AAAe,0BAAfA,MAAM,IAAI,EAA4B,OAAO;QACjDH,QAAQG,MAAM,KAAK;IACrB;IACA,OAAO;AACT;AAEO,SAASC,kBACdC,IAAgE;IAEhE,OAAOC,aAAa;QAClB,MAAM;QACN,aACE;QACF,aAAaC,EAAE,MAAM,CAAC;YACpB,WAAWA,EAAAA,MACF,GACN,IAAI,GACJ,GAAG,CAAC,GACJ,QAAQ,CACP;QAEN;QACA,mBAAmB;QACnB,kBAAkB;QAClB,MAAM,OAAO,EAAEC,SAAS,EAAE,EAAEC;YAC1B,IAAI;gBACF,MAAMJ,KAAKG,WAAWC,SAAS;gBAC/B,IAAIA,SACFA,QAAQ,IAAI,CAAC,gBAAgB,GAAG,CAAC,mBAAmB,EAAED,UAAU,2HAA2H,CAAC;YAEhM,EAAE,OAAOR,OAAO;gBACd,MAAM,IAAIL,iBAAiBK;YAC7B;QACF;IACF;AACF"}

package/dist/es/agent/tasks.mjs

@@ -2,7 +2,7 @@ import { AIResponseParseError, ConversationHistory } from "../ai-model/index.mjs
 import { buildTypeQueryDemandValue } from "../ai-model/prompt/insight/index.mjs";
 import { prepareUserPrompt } from "../ai-model/shared/multimodal-prompt.mjs";
 import { standardPlan } from "../ai-model/workflows/planning/index.mjs";
-import { getReadableTimeString, userPromptToMultimodalPrompt, userPromptToString } from "../common.mjs";
+import { buildYamlFlowFromPlans, getReadableTimeString, userPromptToMultimodalPrompt, userPromptToString } from "../common.mjs";
 import { defineActionSleep } from "../device/index.mjs";
 import { TaskExecutionError } from "../task-runner.mjs";
 import { ServiceError, aiActProgressScope } from "../types.mjs";
@@ -12,6 +12,8 @@ import { resolveSystemOneEndpoint } from "../ai-model/service-caller/system-one/
 import { isActionReadinessError } from "./action-readiness.mjs";
 import { ExecutionSession } from "./execution-session.mjs";
 import { withFileChooser } from "./file-chooser.mjs";
+import { evaluatePlanFreshness } from "./plan-freshness.mjs";
+import { isPlannedWaitError } from "./planned-wait.mjs";
 import { createAiActActionReporter, errorMessageForAiAct } from "./progress/index.mjs";
 import { renderAIContext } from "./prompt-context.mjs";
 import { TaskBuilder, locatePlanForLocate } from "./task-builder.mjs";
@@ -185,9 +187,9 @@ class TaskExecutor {
             runner
         };
     }
-    async action(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort = 'balance', fileChooserAccept, deepLocate, abortSignal, reportOptions) {
+    async action(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort = 'balance', fileChooserAccept, deepLocate, abortSignal, reportOptions, checkScreenChanges = false) {
         abortSignal?.throwIfAborted();
-        return withFileChooser(this.interface, fileChooserAccept, async ()=>this.runAction(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort, deepLocate, abortSignal, reportOptions));
+        return withFileChooser(this.interface, fileChooserAccept, async ()=>this.runAction(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort, deepLocate, abortSignal, reportOptions, checkScreenChanges));
     }
     invalidateFailedCacheHitLocates(runner, fromIndex) {
         if (!this.taskCache) return;
@@ -199,7 +201,7 @@ class TaskExecutor {
             }
         }
     }
-    async runAction(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort = 'balance', deepLocate, abortSignal, reportOptions) {
+    async runAction(userPrompt, planningModel, locateModel, aiActContext, cacheable, replanningCycleLimitOverride, effort = 'balance', deepLocate, abortSignal, reportOptions, checkScreenChanges = false) {
         abortSignal ??= this.getAbortSignal?.();
         const conversationHistory = new ConversationHistory();
         const promptDisplay = reportOptions?.prompt || userPromptToString(userPrompt);
@@ -232,6 +234,8 @@ class TaskExecutor {
             noIndividualLocateModel
         });
         let replanCount = 0;
+        let consecutiveScreenChangeReplans = 0;
+        const screenChangeReplanLimit = 2;
         const yamlFlow = [];
         const replanningCycleLimit = replanningCycleLimitOverride ?? this.replanningCycleLimit;
         if (void 0 === replanningCycleLimit) throw new Error('replanningCycleLimit is required for TaskExecutor.action');
@@ -362,6 +366,14 @@ class TaskExecutor {
                     } finally{
                         setTimingFieldOnce(timing, 'callAiEnd');
                     }
+                    if (this.planningWaitFor && !planResult.delegation) {
+                        const waitIndex = planResult.actions?.findIndex((action)=>'WaitFor' === action.type) ?? -1;
+                        if (waitIndex >= 0) {
+                            planResult.actions = planResult.actions.slice(0, waitIndex + 1);
+                            planResult.yamlFlow = buildYamlFlowFromPlans(planResult.actions, actionSpace);
+                            planResult.shouldContinuePlanning = true;
+                        }
+                    }
                     debug('planResult', JSON.stringify(planResult, null, 2));
                     const { actions, thought, log, memory, error, usage, rawResponse, rawAssistantOutput, reasoning_content, finalizeSuccess, finalizeMessage, updateSubGoals, markFinishedIndexes } = planResult;
                     outputString = finalizeMessage;
@@ -424,7 +436,18 @@ class TaskExecutor {
             });
             const planResult = result?.output;
             latestPlanResult = planResult;
-            if (!planResult?.delegation) {
+            let freshness;
+            if (checkScreenChanges && !planResult?.delegation) try {
+                freshness = await evaluatePlanFreshness(runner.tasks[runner.tasks.length - 1], planResult?.actions || [], runner.id, planIndex);
+            } catch (error) {
+                return appendFailedPlan(`Failed to check screen freshness: ${error instanceof Error ? error.message : String(error)}`, planIndex);
+            }
+            if (freshness?.changed) {
+                if (consecutiveScreenChangeReplans >= screenChangeReplanLimit) return appendFailedPlan(`Task stopped: the screen kept changing during planning after ${screenChangeReplanLimit} consecutive screen-change replans. No action from the rejected plans was executed. Wait for the page to settle before trying again.`, planIndex);
+                ++consecutiveScreenChangeReplans;
+                this.setPendingFeedbackMessage(conversationHistory, await this.getTimeString(), 'The planned action was NOT executed: the screen changed while planning. Inspect the current screenshot and plan again; do not assume the previous action happened.');
+            }
+            if (!planResult?.delegation && !freshness?.changed) {
                 const plans = planResult?.actions || [];
                 yamlFlow.push(...planResult?.yamlFlow || []);
                 let executables;
@@ -444,9 +467,10 @@ class TaskExecutor {
                 activeActionReporter = createAiActActionReporter(planIndex, replanningCycleLimit, (phase, data)=>this.emitAiActProgress(phase, data));
                 try {
                     await session.appendAndRun(executables.tasks);
+                    if (executables.tasks.some((task)=>'Action Space' === task.type)) consecutiveScreenChangeReplans = 0;
                     this.setPendingFeedbackMessage(conversationHistory, initialTimeString, this.collectPlanningFeedback(runner.tasks.slice(taskCountBeforeRun)));
                 } catch (error) {
-                    if (isActionReadinessError(error)) throw error;
+                    if (isActionReadinessError(error) || isPlannedWaitError(error)) throw error;
                     errorCountInOnePlanningLoop++;
                     const timeString = await this.getTimeString();
                     this.setPendingFeedbackMessage(conversationHistory, timeString, `Error executing running tasks: ${error?.message || String(error)}`);
@@ -600,64 +624,84 @@ class TaskExecutor {
         };
     }
     async waitFor(assertion, opt, modelRuntime) {
-        const abortSignal = this.getAbortSignal?.();
-        const { textPrompt, multimodalPrompt } = parsePrompt(assertion);
-        const description = `waitFor: ${textPrompt}`;
-        const session = this.createExecutionSession(taskTitleStr('WaitFor', description), {
-            referenceImages: multimodalPrompt?.images,
-            abortSignal
-        });
-        const runner = session.getRunner();
-        const executionModelRuntime = {
-            ...modelRuntime,
-            executionId: runner.id
-        };
-        const { timeoutMs, checkIntervalMs, domIncluded, screenshotIncluded, ...restOpt } = opt;
-        const serviceExtractOpt = {
-            domIncluded,
-            screenshotIncluded,
-            ...restOpt
-        };
-        assert(assertion, 'No assertion for waitFor');
-        assert(timeoutMs, 'No timeoutMs for waitFor');
-        assert(checkIntervalMs, 'No checkIntervalMs for waitFor');
-        assert(checkIntervalMs <= timeoutMs, `wrong config for waitFor: checkIntervalMs must be less than timeoutMs, config: {checkIntervalMs: ${checkIntervalMs}, timeoutMs: ${timeoutMs}}`);
-        const overallStartTime = Date.now();
-        let lastCheckStart = overallStartTime;
-        let errorThought = '';
-        while(lastCheckStart - overallStartTime <= timeoutMs){
-            const currentCheckStart = Date.now();
-            lastCheckStart = currentCheckStart;
-            abortSignal?.throwIfAborted();
-            const queryTask = await this.createTypeQueryTask('WaitFor', textPrompt, executionModelRuntime, serviceExtractOpt, multimodalPrompt, {
+        const timeoutMs = opt.timeoutMs;
+        const checkIntervalMs = opt.checkIntervalMs;
+        assert('number' == typeof timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0 && timeoutMs <= 2147483647, 'waitFor timeoutMs must be a finite positive timer duration');
+        assert('number' == typeof checkIntervalMs && Number.isFinite(checkIntervalMs) && checkIntervalMs > 0 && checkIntervalMs <= timeoutMs, 'waitFor checkIntervalMs must be positive and no greater than timeoutMs');
+        const signals = [
+            opt.abortSignal,
+            this.getAbortSignal?.()
+        ].filter((signal)=>void 0 !== signal);
+        const callerSignal = signals.length ? AbortSignal.any(signals) : void 0;
+        callerSignal?.throwIfAborted();
+        const deadline = new AbortController();
+        const deadlineAt = Date.now() + timeoutMs;
+        const timer = setTimeout(()=>deadline.abort(new Error(`waitFor timeout after ${timeoutMs}ms`)), timeoutMs);
+        const abortSignal = callerSignal ? AbortSignal.any([
+            callerSignal,
+            deadline.signal
+        ]) : deadline.signal;
+        try {
+            const { textPrompt, multimodalPrompt } = parsePrompt(assertion);
+            const description = `waitFor: ${textPrompt}`;
+            const session = this.createExecutionSession(taskTitleStr('WaitFor', description), {
+                referenceImages: multimodalPrompt?.images,
                 abortSignal
             });
-            const result = await session.appendAndRun(queryTask);
-            if (result?.output) return {
-                output: void 0,
-                runner
+            const runner = session.getRunner();
+            const executionModelRuntime = {
+                ...modelRuntime,
+                executionId: runner.id
             };
-            errorThought = result?.thought || !result && `No result from assertion: ${textPrompt}` || `unknown error when waiting for assertion: ${textPrompt}`;
-            const now = Date.now();
-            if (now - currentCheckStart < checkIntervalMs) {
-                const elapsed = now - currentCheckStart;
-                const timeRemaining = checkIntervalMs - elapsed;
-                const thought = `Check interval is ${checkIntervalMs}ms, ${elapsed}ms elapsed since last check, sleeping for ${timeRemaining}ms`;
-                const { tasks: sleepTasks } = await this.convertPlanToExecutable([
-                    {
-                        type: 'Sleep',
-                        param: {
-                            timeMs: timeRemaining
-                        },
-                        thought
-                    }
-                ], modelRuntime, modelRuntime, {
+            const { timeoutMs: _timeoutMs, checkIntervalMs: _checkIntervalMs, abortSignal: _abortSignal, domIncluded, screenshotIncluded, ...restOpt } = opt;
+            const serviceExtractOpt = {
+                domIncluded,
+                screenshotIncluded,
+                ...restOpt
+            };
+            assert(assertion, 'No assertion for waitFor');
+            const overallStartTime = Date.now();
+            let errorThought = '';
+            while(Date.now() - overallStartTime < timeoutMs){
+                const currentCheckStart = Date.now();
+                abortSignal?.throwIfAborted();
+                const queryTask = await this.createTypeQueryTask('WaitFor', textPrompt, executionModelRuntime, serviceExtractOpt, multimodalPrompt, {
                     abortSignal
                 });
-                if (sleepTasks[0]) await session.appendAndRun(sleepTasks[0]);
+                const result = await session.appendAndRun(queryTask);
+                abortSignal.throwIfAborted();
+                if (Date.now() >= deadlineAt) {
+                    deadline.abort(new Error(`waitFor timeout after ${timeoutMs}ms`));
+                    abortSignal.throwIfAborted();
+                }
+                if (result?.output) return {
+                    output: void 0,
+                    runner
+                };
+                errorThought = result?.thought || !result && `No result from assertion: ${textPrompt}` || `unknown error when waiting for assertion: ${textPrompt}`;
+                const now = Date.now();
+                if (now - currentCheckStart < checkIntervalMs) {
+                    const elapsed = now - currentCheckStart;
+                    const timeRemaining = Math.max(0, Math.min(checkIntervalMs - elapsed, timeoutMs - (Date.now() - overallStartTime)));
+                    const thought = `Check interval is ${checkIntervalMs}ms, ${elapsed}ms elapsed since last check, sleeping for ${timeRemaining}ms`;
+                    const { tasks: sleepTasks } = await this.convertPlanToExecutable([
+                        {
+                            type: 'Sleep',
+                            param: {
+                                timeMs: timeRemaining
+                            },
+                            thought
+                        }
+                    ], modelRuntime, modelRuntime, {
+                        abortSignal
+                    });
+                    if (sleepTasks[0]) await session.appendAndRun(sleepTasks[0]);
+                }
             }
+            return session.appendErrorPlan(`waitFor timeout: ${errorThought}`);
+        } finally{
+            clearTimeout(timer);
         }
-        return session.appendErrorPlan(`waitFor timeout: ${errorThought}`);
     }
     constructor(interfaceInstance, service, opts){
         _define_property(this, "interface", void 0);
@@ -665,6 +709,7 @@ class TaskExecutor {
         _define_property(this, "taskCache", void 0);
         _define_property(this, "getDefaultModelRuntime", void 0);
         _define_property(this, "providedActionSpace", void 0);
+        _define_property(this, "planningWaitFor", void 0);
         _define_property(this, "taskBuilder", void 0);
         _define_property(this, "onTaskStartCallback", void 0);
         _define_property(this, "hooks", void 0);
@@ -678,6 +723,7 @@ class TaskExecutor {
         this.taskCache = opts.taskCache;
         this.onTaskStartCallback = opts?.onTaskStart;
         this.replanningCycleLimit = opts.replanningCycleLimit;
+        this.planningWaitFor = opts.planningWaitFor ?? false;
         this.waitAfterAction = opts.waitAfterAction;
         this.useDeviceTime = opts.useDeviceTime;
         this.hooks = opts.hooks;