@midscene/core 1.16.0 → 1.16.2

package/dist/lib/agent/agent.js

@@ -38,20 +38,14 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const task_routing_js_namespaceObject = require("../ai-model/models/task-routing.js");
 const index_js_namespaceObject = require("../ai-model/service-caller/index.js");
-const external_constants_js_namespaceObject = require("../constants.js");
 const external_js_yaml_namespaceObject = require("js-yaml");
 var external_js_yaml_default = /*#__PURE__*/ __webpack_require__.n(external_js_yaml_namespaceObject);
-const html_utils_js_namespaceObject = require("../dump/html-utils.js");
 const external_screenshot_item_js_namespaceObject = require("../screenshot-item.js");
 const external_service_index_js_namespaceObject = require("../service/index.js");
 var external_service_index_js_default = /*#__PURE__*/ __webpack_require__.n(external_service_index_js_namespaceObject);
 const resource_operations_js_namespaceObject = require("../test-runner/engine/resource-operations.js");
-const agent_report_js_namespaceObject = require("../test-runner/reporting/agent-report.js");
-const execution_record_js_namespaceObject = require("../test-runner/reporting/execution-record.js");
 const external_types_js_namespaceObject = require("../types.js");
 const execution_session_js_namespaceObject = require("../yaml/execution-session.js");
-const external_report_generator_js_namespaceObject = require("../report-generator.js");
-const external_utils_js_namespaceObject = require("../utils.js");
 const external_yaml_index_js_namespaceObject = require("../yaml/index.js");
 const promises_namespaceObject = require("node:fs/promises");
 const external_node_path_namespaceObject = require("node:path");
@@ -63,6 +57,8 @@ const logger_namespaceObject = require("@midscene/shared/logger");
 const utils_namespaceObject = require("@midscene/shared/utils");
 const external_device_index_js_namespaceObject = require("../device/index.js");
 const external_action_readiness_js_namespaceObject = require("./action-readiness.js");
+const external_agent_options_js_namespaceObject = require("./agent-options.js");
+const external_agent_report_manager_js_namespaceObject = require("./agent-report-manager.js");
 const external_cache_config_js_namespaceObject = require("./cache-config.js");
 const external_file_chooser_js_namespaceObject = require("./file-chooser.js");
 const external_insight_js_namespaceObject = require("./insight.js");
@@ -77,7 +73,7 @@ const external_tasks_js_namespaceObject = require("./tasks.js");
 const external_test_runner_nodes_js_namespaceObject = require("./test-runner-nodes.js");
 const external_ui_observer_js_namespaceObject = require("./ui-observer.js");
 const external_ui_utils_js_namespaceObject = require("./ui-utils.js");
-const external_utils_js_namespaceObject_1 = require("./utils.js");
+const external_utils_js_namespaceObject = require("./utils.js");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -107,66 +103,38 @@ class Agent {
     static getTestRunnerNodeDefinitions() {
         return external_test_runner_nodes_js_namespaceObject.commonAgentTestRunnerNodeDefinitions;
     }
+    get dump() {
+        return this.reportManager.dump;
+    }
+    set dump(value) {
+        this.reportManager.dump = value;
+    }
+    get reportFile() {
+        return this.reportManager.reportFile;
+    }
+    set reportFile(value) {
+        this.reportManager.reportFile = value;
+    }
+    get reportFileName() {
+        return this.reportManager.reportFileName;
+    }
+    set reportFileName(value) {
+        this.reportManager.reportFileName = value;
+    }
     _prepareForTestRunner() {
-        this.reportGenerator.enableSourceSnapshots?.();
+        this.reportManager._prepareForTestRunner();
     }
     async _createReportSource(scopeId, executionIds) {
-        return this.reportGenerator.createSourceSnapshot?.(scopeId, executionIds);
+        return this.reportManager._createReportSource(scopeId, executionIds);
     }
     async _writeYamlExecutionReport(record) {
-        const existingIndex = this.yamlExecutionRecords.findIndex((entry)=>entry.runId === record.runId);
-        const recordIndex = existingIndex < 0 ? this.yamlExecutionRecords.length : existingIndex;
-        this.yamlExecutionRecords[recordIndex] = record;
-        try {
-            const path = await this.reportGenerator.writeRunnerReport?.(this.buildYamlReportInput(), this.yamlReportScopeId, this.getReportMeta());
-            this.reportFile = path ?? this.reportFile;
-            return path;
-        } catch (error) {
-            this.yamlExecutionRecords[recordIndex] = Object.freeze({
-                ...record,
-                status: 'failed',
-                reportError: error
-            });
-            throw error;
-        }
-    }
-    buildYamlReportInput() {
-        const scopedRecords = this.yamlExecutionRecords.map((entry)=>({
-                ...entry,
-                ...entry.execution ? {
-                    execution: {
-                        document: {
-                            ...entry.execution.document,
-                            reportScopeId: this.yamlReportScopeId
-                        },
-                        cases: entry.execution.cases.map((outcome)=>({
-                                ...outcome,
-                                ...outcome.run ? {
-                                    run: {
-                                        ...outcome.run,
-                                        reportScopeId: this.yamlReportScopeId
-                                    }
-                                } : {},
-                                ...outcome.attempts ? {
-                                    attempts: outcome.attempts.map((attempt)=>({
-                                            ...attempt,
-                                            reportScopeId: this.yamlReportScopeId
-                                        }))
-                                } : {}
-                            }))
-                    }
-                } : {}
-            }));
-        return (0, execution_record_js_namespaceObject.executionRecordsToReportInput)(scopedRecords, {
-            runId: this.yamlReportScopeId
-        });
+        return this.reportManager._writeYamlExecutionReport(record);
     }
     get onDumpUpdate() {
-        return this.dumpUpdateListeners[0];
+        return this.reportManager.onDumpUpdate;
     }
     set onDumpUpdate(callback) {
-        this.dumpUpdateListeners = [];
-        if (callback) this.dumpUpdateListeners.push(callback);
+        this.reportManager.onDumpUpdate = callback;
     }
     get aiContexts() {
         if (!this.opts.aiContexts) this.opts.aiContexts = {};
@@ -211,7 +179,9 @@ class Agent {
         };
     }
     createInsight(getUIContext) {
-        return new external_insight_js_namespaceObject.Insight(this.taskExecutor, (task)=>this.resolveModelRuntime('insight', task), (apiName, callContext)=>this.resolveUserContext(apiName, callContext), getUIContext);
+        return new external_insight_js_namespaceObject.Insight({
+            createTypeQueryExecution: (...args)=>this.withReportOperation(()=>this.taskExecutor.createTypeQueryExecution(...args))
+        }, (task)=>this.resolveModelRuntime('insight', task), (apiName, callContext)=>this.resolveUserContext(apiName, callContext), getUIContext);
     }
     async getActionSpace() {
         return this.fullActionSpace;
@@ -227,7 +197,7 @@ class Agent {
         }
         const maxRetries = Agent.CONTEXT_RETRY_MAX;
         for(let attempt = 0;; attempt++)try {
-            return await (0, external_utils_js_namespaceObject_1.commonContextParser)(this.interface, {
+            return await (0, external_utils_js_namespaceObject.commonContextParser)(this.interface, {
                 uploadServerUrl: this.modelConfigManager.getUploadTestServerUrl(),
                 screenshotShrinkFactor: this.opts.screenshotShrinkFactor
             });
@@ -244,6 +214,7 @@ class Agent {
         return await this.getUIContext('locate');
     }
     async startObserving(opt) {
+        this.assertReportWritable();
         (0, utils_namespaceObject.assert)(!this.frozenUIContext, 'startObserving() cannot be used while the UI context is frozen (call unfreezePageContext() first)');
         (0, utils_namespaceObject.assert)(!this.activeObserver, "An observation window is already active on this agent. Stop the existing observer first (await observer.stop()) before starting a new one.");
         const observer = new external_ui_observer_js_namespaceObject.UIObserverImpl({
@@ -291,31 +262,20 @@ class Agent {
             this.opts.aiActionContext = context;
         }
     }
-    resetDump() {
-        this.dump = new external_types_js_namespaceObject.ReportActionDump({
-            sdkVersion: (0, external_utils_js_namespaceObject.getVersion)(),
-            groupName: this.opts.groupName,
-            groupDescription: this.opts.groupDescription,
-            executions: [],
-            modelBriefs: [],
-            deviceType: this.interface.interfaceType
-        });
-        this.executionDumpIndexByRunner = new WeakMap();
-        return this.dump;
+    assertReportWritable() {
+        this.reportManager.assertReportWritable();
+    }
+    async withReportOperation(operation) {
+        return this.reportManager.withReportOperation(operation);
+    }
+    async resetDump() {
+        return this.reportManager.resetDump();
+    }
+    async finalizeReport() {
+        return this.reportManager.finalizeReport();
     }
     appendExecutionDump(execution, runner) {
-        const currentDump = this.dump;
-        if (runner) {
-            const existingIndex = this.executionDumpIndexByRunner.get(runner);
-            if (void 0 !== existingIndex) {
-                currentDump.executions[existingIndex] = execution;
-                return;
-            }
-            currentDump.executions.push(execution);
-            this.executionDumpIndexByRunner.set(runner, currentDump.executions.length - 1);
-            return;
-        }
-        currentDump.executions.push(execution);
+        this.reportManager.appendExecutionDump(execution, runner);
     }
     collectUsageMetrics(execution) {
         for (const task of execution.tasks){
@@ -340,50 +300,16 @@ class Agent {
         return this.metricsCollector.snapshot();
     }
     dumpDataString(opt) {
-        this.dump.groupName = this.opts.groupName;
-        this.dump.groupDescription = this.opts.groupDescription;
-        if (utils_namespaceObject.ifInBrowser || opt?.inlineScreenshots) return this.dump.serializeWithInlineScreenshots();
-        return this.dump.serialize();
+        return this.reportManager.dumpDataString(opt);
     }
     reportHTMLString(opt) {
-        if (external_constants_js_namespaceObject.IS_REPORT_BUILD) return '';
-        const dumpString = this.dumpDataString(opt);
-        if (!this.yamlExecutionRecords.length) return (0, external_utils_js_namespaceObject.reportHTMLContent)(dumpString);
-        const reportId = this.yamlReportScopeId;
-        const runnerDump = (0, agent_report_js_namespaceObject.buildAgentTestRunReportDump)(this.buildYamlReportInput(), this.dump, {
-            reportId,
-            scopeId: this.yamlReportScopeId,
-            sourcePath: this.reportFile ?? '<inline-agent-report>'
-        });
-        return `${(0, external_utils_js_namespaceObject.reportHTMLContent)({
-            dumpString,
-            attributes: {
-                'data-group-id': reportId,
-                'data-report-id': reportId
-            }
-        })}\n${(0, html_utils_js_namespaceObject.generateTestRunReportScriptTag)(runnerDump)}`;
+        return this.reportManager.reportHTMLString(()=>this.dumpDataString(opt));
     }
     writeOutActionDumps(executionDump) {
-        const exec = executionDump || this.lastExecutionDump;
-        if (exec) {
-            this.lastExecutionDump = exec;
-            this.reportGenerator.onExecutionUpdate(exec, this.getReportMeta(), this.opts.reportAttributes);
-        }
-        this.reportFile = this.reportGenerator.getReportPath();
+        this.reportManager.writeOutActionDumps(executionDump);
     }
     async flushReport() {
-        this.writeOutActionDumps();
-        await this.reportGenerator.flush();
-        return this.lastExecutionDump ? this.reportFile ?? void 0 : void 0;
-    }
-    getReportMeta() {
-        return {
-            groupName: this.dump.groupName,
-            groupDescription: this.dump.groupDescription,
-            sdkVersion: this.dump.sdkVersion,
-            modelBriefs: this.dump.modelBriefs,
-            deviceType: this.dump.deviceType
-        };
+        return this.reportManager.flushReport();
     }
     async callbackOnTaskStartTip(task) {
         const param = (0, external_ui_utils_js_namespaceObject.paramStr)(task);
@@ -394,6 +320,9 @@ class Agent {
         return async (param)=>await this.callActionInActionSpace(name, param);
     }
     async callActionInActionSpace(type, opt, abortSignal) {
+        return this.withReportOperation(()=>this.executeActionInActionSpace(type, opt, abortSignal));
+    }
+    async executeActionInActionSpace(type, opt, abortSignal) {
         debug('callActionInActionSpace', type, ',', opt);
         const clonedActionParam = opt && 'object' == typeof opt && !Array.isArray(opt) ? {
             ...opt
@@ -416,12 +345,14 @@ class Agent {
         return output;
     }
     async aiTap(locatePrompt, opt) {
-        (0, utils_namespaceObject.assert)(locatePrompt, 'missing locate prompt for tap');
-        const detailedLocateParam = (0, external_yaml_index_js_namespaceObject.buildDetailedLocateParam)(locatePrompt, this.withContext('aiTap', opt));
-        const fileChooserAccept = opt?.fileChooserAccept ? this.normalizeFileInput(opt.fileChooserAccept) : void 0;
-        await (0, external_tasks_js_namespaceObject.withFileChooser)(this.interface, fileChooserAccept, async ()=>{
-            await this.callActionInActionSpace('Tap', {
-                locate: detailedLocateParam
+        await this.withReportOperation(async ()=>{
+            (0, utils_namespaceObject.assert)(locatePrompt, 'missing locate prompt for tap');
+            const detailedLocateParam = (0, external_yaml_index_js_namespaceObject.buildDetailedLocateParam)(locatePrompt, this.withContext('aiTap', opt));
+            const fileChooserAccept = opt?.fileChooserAccept ? this.normalizeFileInput(opt.fileChooserAccept) : void 0;
+            await (0, external_tasks_js_namespaceObject.withFileChooser)(this.interface, fileChooserAccept, async ()=>{
+                await this.callActionInActionSpace('Tap', {
+                    locate: detailedLocateParam
+                });
             });
         });
     }
@@ -517,7 +448,7 @@ class Agent {
             };
         }
         if (opt) {
-            const normalizedScrollType = (0, external_utils_js_namespaceObject_1.normalizeScrollType)(opt.scrollType);
+            const normalizedScrollType = (0, external_utils_js_namespaceObject.normalizeScrollType)(opt.scrollType);
             if (normalizedScrollType !== opt.scrollType) opt = {
                 ...opt || {},
                 scrollType: normalizedScrollType
@@ -552,6 +483,9 @@ class Agent {
         });
     }
     async aiAct(taskPrompt, opt) {
+        return this.withReportOperation(()=>this.executeAiAct(taskPrompt, opt));
+    }
+    async executeAiAct(taskPrompt, opt) {
         const internalOptions = opt;
         const internalReportDisplay = internalOptions?._internalReportDisplay;
         const taskPromptText = 'string' == typeof taskPrompt ? taskPrompt : taskPrompt.prompt;
@@ -659,6 +593,9 @@ class Agent {
         return result;
     }
     async runMarkdown(markdownPath, opt) {
+        return this.withReportOperation(()=>this.executeMarkdown(markdownPath, opt));
+    }
+    async executeMarkdown(markdownPath, opt) {
         const markdown = await (0, promises_namespaceObject.readFile)(markdownPath, 'utf-8');
         const { prompt } = await (0, external_run_markdown_js_namespaceObject.markdownToAiActPrompt)(markdown, markdownPath);
         return this.aiAct(prompt, {
@@ -670,7 +607,7 @@ class Agent {
         });
     }
     async runGherkinScenario(scenarioText, opt) {
-        return (0, external_run_gherkin_scenario_js_namespaceObject.runGherkinScenario)(this, scenarioText, opt);
+        return this.withReportOperation(()=>(0, external_run_gherkin_scenario_js_namespaceObject.runGherkinScenario)(this, scenarioText, opt));
     }
     async aiAction(taskPrompt, opt) {
         return this.aiAct(taskPrompt, opt);
@@ -691,6 +628,9 @@ class Agent {
         return this.createInsight().aiAsk(prompt, opt);
     }
     async aiLocate(prompt, opt) {
+        return this.withReportOperation(()=>this.executeLocate(prompt, opt));
+    }
+    async executeLocate(prompt, opt) {
         const locateParam = (0, external_yaml_index_js_namespaceObject.buildDetailedLocateParam)(prompt, this.withContext('aiLocate', opt));
         (0, utils_namespaceObject.assert)(locateParam, 'cannot get locate param for aiLocate');
         const locatePlan = (0, external_tasks_js_namespaceObject.locatePlanForLocate)(locateParam);
@@ -720,16 +660,19 @@ class Agent {
     async aiWaitFor(assertion, opt) {
         const modelRuntime = this.resolveModelRuntime('insight', 'boolean');
         const options = this.withContext('aiWaitFor', opt);
-        await this.taskExecutor.waitFor(assertion, {
-            ...options,
-            timeoutMs: options?.timeoutMs || 15000,
-            checkIntervalMs: options?.checkIntervalMs || 3000
-        }, modelRuntime);
+        await this.withReportOperation(()=>this.taskExecutor.waitFor(assertion, {
+                ...options,
+                timeoutMs: options?.timeoutMs || 15000,
+                checkIntervalMs: options?.checkIntervalMs || 3000
+            }, modelRuntime));
     }
     async ai(...args) {
         return this.aiAct(...args);
     }
     async runYaml(yamlScriptContent, options) {
+        return this.withReportOperation(()=>this.executeYaml(yamlScriptContent, options));
+    }
+    async executeYaml(yamlScriptContent, options) {
         if (this.destroyed) throw new Error('Cannot run YAML using a destroyed Agent.');
         const script = (0, external_yaml_index_js_namespaceObject.parseYamlScript)(yamlScriptContent, 'yaml');
         const player = new external_yaml_index_js_namespaceObject.ScriptPlayer(script, async ()=>({
@@ -749,20 +692,16 @@ class Agent {
     }
     async evaluateJavaScript(script) {
         (0, utils_namespaceObject.assert)(this.interface.evaluateJavaScript, 'evaluateJavaScript is not supported in current agent');
-        return this.interface.evaluateJavaScript(script);
+        return this.withReportOperation(()=>this.interface.evaluateJavaScript(script));
     }
     addDumpUpdateListener(listener) {
-        this.dumpUpdateListeners.push(listener);
-        return ()=>{
-            this.removeDumpUpdateListener(listener);
-        };
+        return this.reportManager.addDumpUpdateListener(listener);
     }
     removeDumpUpdateListener(listener) {
-        const index = this.dumpUpdateListeners.indexOf(listener);
-        if (index > -1) this.dumpUpdateListeners.splice(index, 1);
+        this.reportManager.removeDumpUpdateListener(listener);
     }
     clearDumpUpdateListeners() {
-        this.dumpUpdateListeners = [];
+        this.reportManager.clearDumpUpdateListeners();
     }
     addProgressListener(listener) {
         return this.progressBus.subscribe(listener);
@@ -774,17 +713,13 @@ class Agent {
         this.progressBus.clear();
     }
     notifyDumpUpdateListeners(executionDump) {
-        const dumpString = this.dumpDataString();
-        for (const listener of this.dumpUpdateListeners)try {
-            listener(dumpString, executionDump);
-        } catch (error) {
-            console.error('Error in onDumpUpdate listener', error);
-        }
+        this.reportManager.notifyDumpUpdateListeners(executionDump);
     }
     async destroy() {
         if (this.destroyed) return;
         this.destroyed = true;
         await (0, resource_operations_js_namespaceObject.waitForResourceIdle)(this);
+        await this.reportManager.waitForOperations();
         for (const observer of this.ownedObservers)try {
             await observer.dispose();
         } catch (error) {
@@ -798,17 +733,18 @@ class Agent {
         } catch (error) {
             interfaceDestroyError = error;
         }
-        await this.reportGenerator.flush();
-        const finalPath = await this.reportGenerator.finalize();
-        this.reportFile = finalPath;
-        this.resetDump();
+        await this.reportManager.waitForReset();
+        if (!(0, execution_session_js_namespaceObject.hasActiveYamlExecution)(this)) await this.finalizeReport();
         if (interfaceDestroyError) throw interfaceDestroyError;
     }
     async sleep(ms, options) {
         options?.abortSignal?.throwIfAborted();
-        await this.taskExecutor.sleep(ms, options?.abortSignal);
+        await this.withReportOperation(()=>this.taskExecutor.sleep(ms, options?.abortSignal));
     }
     async recordToReport(title, opt) {
+        return this.withReportOperation(()=>this.writeRecordToReport(title, opt));
+    }
+    async writeRecordToReport(title, opt) {
         const now = Date.now();
         const screenshots = opt?.screenshots;
         const screenshotBase64 = opt?.screenshotBase64;
@@ -866,10 +802,13 @@ class Agent {
         });
         this.appendExecutionDump(executionDump);
         this.writeOutActionDumps(executionDump);
-        await this.reportGenerator.flush();
+        await this.reportManager.flushPendingWrites();
         this.notifyDumpUpdateListeners(executionDump);
     }
     async recordErrorToReport(title, opt) {
+        return this.withReportOperation(()=>this.writeErrorToReport(title, opt));
+    }
+    async writeErrorToReport(title, opt) {
         const now = Date.now();
         const error = (0, error_formatter_namespaceObject.serializeError)(opt.error);
         const recorder = [];
@@ -909,7 +848,7 @@ class Agent {
         });
         this.appendExecutionDump(executionDump);
         this.writeOutActionDumps(executionDump);
-        await this.reportGenerator.flush();
+        await this.reportManager.flushPendingWrites();
         this.notifyDumpUpdateListeners(executionDump);
     }
     async logScreenshot(title, opt) {
@@ -935,30 +874,11 @@ class Agent {
         this.frozenUIContext = void 0;
         debug('Page context unfrozen successfully');
     }
-    processCacheConfig(opts) {
-        (0, external_cache_config_js_namespaceObject.validateAgentCacheInput)(opts.cache);
-        const cacheConfig = (0, external_utils_js_namespaceObject.processCacheConfig)(opts.cache, opts.cacheId || 'default');
-        if (!cacheConfig) return null;
-        if ('object' == typeof cacheConfig && null !== cacheConfig) {
-            const id = cacheConfig.id;
-            const strategyValue = cacheConfig.strategy ?? 'read-write';
-            const isReadOnly = 'read-only' === strategyValue;
-            const isWriteOnly = 'write-only' === strategyValue;
-            return {
-                id,
-                enabled: !isWriteOnly,
-                readOnly: isReadOnly,
-                writeOnly: isWriteOnly,
-                cacheDir: cacheConfig.cacheDir?.trim()
-            };
-        }
-        return null;
-    }
     normalizeFileInput(files) {
         const filesArray = Array.isArray(files) ? files : [
             files
         ];
-        return (0, external_utils_js_namespaceObject_1.normalizeFilePaths)(filesArray);
+        return (0, external_utils_js_namespaceObject.normalizeFilePaths)(filesArray);
     }
     async flushCache(options) {
         if (!this.taskCache) throw new Error('Cache is not configured');
@@ -967,11 +887,7 @@ class Agent {
     constructor(interfaceInstance, opts){
         _define_property(this, "interface", void 0);
         _define_property(this, "service", void 0);
-        _define_property(this, "dump", void 0);
-        _define_property(this, "reportFile", void 0);
-        _define_property(this, "reportFileName", void 0);
-        _define_property(this, "yamlReportScopeId", (0, utils_namespaceObject.uuid)());
-        _define_property(this, "yamlExecutionRecords", []);
+        _define_property(this, "reportManager", void 0);
         _define_property(this, "taskExecutor", void 0);
         _define_property(this, "opts", void 0);
         _define_property(this, "dryMode", false);
@@ -980,7 +896,6 @@ class Agent {
         _define_property(this, "metricsCollector", new external_metrics_js_namespaceObject.MetricsCollector());
         _define_property(this, "usageCallCounter", 0);
         _define_property(this, "countedUsageKeys", new Set());
-        _define_property(this, "dumpUpdateListeners", []);
         _define_property(this, "progressBus", new external_progress_index_js_namespaceObject.AgentProgressBus());
         _define_property(this, "destroyed", false);
         _define_property(this, "actionReadiness", void 0);
@@ -988,44 +903,17 @@ class Agent {
         _define_property(this, "frozenUIContext", void 0);
         _define_property(this, "activeObserver", null);
         _define_property(this, "ownedObservers", new Set());
-        _define_property(this, "executionDumpIndexByRunner", new WeakMap());
         _define_property(this, "fullActionSpace", void 0);
         _define_property(this, "activeFileChooserAccepter", void 0);
         _define_property(this, "activeFileChooserAllowedDir", void 0);
-        _define_property(this, "reportGenerator", void 0);
-        _define_property(this, "lastExecutionDump", void 0);
         this.interface = interfaceInstance;
-        this.opts = Object.assign({
-            generateReport: true,
-            persistExecutionDump: false,
-            autoPrintReportMsg: true,
-            groupName: 'Midscene Report',
-            groupDescription: ''
-        }, opts || {});
-        (0, external_report_generator_js_namespaceObject.assertReportGenerationOptions)(this.opts);
+        this.opts = (0, external_agent_options_js_namespaceObject.withAgentDefaults)(opts);
         if (void 0 !== this.opts.waitForActionReady) this.actionReadiness = new external_action_readiness_js_namespaceObject.ActionReadiness(this.opts.waitForActionReady);
-        if (void 0 !== this.opts.aiContexts && ('object' != typeof this.opts.aiContexts || null === this.opts.aiContexts || Array.isArray(this.opts.aiContexts))) throw new TypeError('opts.aiContexts must be a plain object');
-        for (const [key, value] of Object.entries(this.opts.aiContexts ?? {})){
-            if (!(0, agent_context_namespaceObject.isAgentAIContextKey)(key)) throw new TypeError(`Unknown Agent context key: ${key}`);
-            if (void 0 !== value && 'string' != typeof value) throw new TypeError(`Agent context "${key}" must be a string`);
-        }
-        const deprecatedAiActContextOption = void 0 !== this.opts.aiActContext ? 'aiActContext' : void 0 !== this.opts.aiActionContext ? 'aiActionContext' : void 0;
-        if (deprecatedAiActContextOption) warn(`Agent option "${deprecatedAiActContextOption}" is deprecated; use "aiContexts.aiAct" instead. When both are provided, "aiContexts.aiAct" takes precedence.`);
-        const normalizedAIContexts = {
-            ...this.opts.aiContexts
-        };
-        const resolvedAiActContext = normalizedAIContexts.aiAct ?? this.opts.aiActContext ?? this.opts.aiActionContext;
-        if (void 0 !== resolvedAiActContext) {
-            normalizedAIContexts.aiAct = resolvedAiActContext;
-            this.opts.aiActContext = resolvedAiActContext;
-            this.opts.aiActionContext = resolvedAiActContext;
-        }
-        this.opts.aiContexts = normalizedAIContexts;
-        if (opts?.modelConfig && ('object' != typeof opts?.modelConfig || Array.isArray(opts.modelConfig))) throw new Error(`opts.modelConfig must be a plain object map of env keys to values, but got ${typeof opts?.modelConfig}`);
+        (0, external_agent_options_js_namespaceObject.normalizeAgentOptions)(this.opts, warn);
         this.modelConfigManager = opts?.modelConfig ? new env_namespaceObject.ModelConfigManager(opts.modelConfig, opts.createOpenAIClient) : opts?.createOpenAIClient ? new AgentScopedModelConfigManager(env_namespaceObject.globalModelConfigManager, opts.createOpenAIClient) : env_namespaceObject.globalModelConfigManager;
         this.onTaskStartTip = this.opts.onTaskStartTip;
         this.service = new (external_service_index_js_default())(async ()=>this.getUIContext());
-        const cacheConfigObj = this.processCacheConfig(opts || {});
+        const cacheConfigObj = (0, external_cache_config_js_namespaceObject.normalizeAgentCacheConfig)(opts || {});
         if (cacheConfigObj) this.taskCache = new external_task_cache_js_namespaceObject.TaskCache(cacheConfigObj.id, cacheConfigObj.enabled, void 0, {
             readOnly: cacheConfigObj.readOnly,
             writeOnly: cacheConfigObj.writeOnly,
@@ -1056,30 +944,26 @@ class Agent {
             operationResource: this,
             actionSpace: this.fullActionSpace,
             hooks: {
+                onExecutionCreated: (runner)=>{
+                    this.reportManager.bindRunner(runner);
+                },
                 onSnapshotChange: async (runner)=>{
+                    this.reportManager.assertRunnerCurrent(runner);
                     const executionDump = runner.dump();
                     this.appendExecutionDump(executionDump, runner);
                     this.collectUsageMetrics(executionDump);
                     this.writeOutActionDumps(executionDump);
-                    await this.reportGenerator.flush();
-                    const dumpString = this.dumpDataString();
-                    for (const listener of this.dumpUpdateListeners)try {
-                        listener(dumpString, executionDump);
-                    } catch (error) {
-                        console.error('Error in onDumpUpdate listener', error);
-                    }
+                    await this.reportManager.flushPendingWrites();
+                    this.reportManager.notifyDumpUpdateListeners(executionDump);
                 },
                 onProgress: this.progressBus.publish
             }
         });
-        this.dump = this.resetDump();
-        this.reportFileName = opts?.reportFileName ?? (0, external_utils_js_namespaceObject_1.getReportFileName)(opts?.testId || this.interface.interfaceType || 'web');
-        this.reportGenerator = external_report_generator_js_namespaceObject.ReportGenerator.create(this.reportFileName, {
-            generateReport: this.opts.generateReport,
-            persistExecutionDump: this.opts.persistExecutionDump,
-            outputFormat: this.opts.outputFormat,
-            autoPrintReportMsg: this.opts.autoPrintReportMsg,
-            reuseExistingReport: this.opts.reportAttributes?.['data-group-id'] === this.reportFileName
+        this.reportManager = new external_agent_report_manager_js_namespaceObject.AgentReportManager({
+            getOptions: ()=>this.opts,
+            getDeviceType: ()=>this.interface.interfaceType,
+            isDestroyed: ()=>this.destroyed,
+            isExternallyBusy: ()=>Boolean(this.activeObserver) || (0, execution_session_js_namespaceObject.hasActiveYamlExecution)(this) || (0, resource_operations_js_namespaceObject.hasPendingResourceOperation)(this)
         });
         Object.defineProperty(this, observation_artifact_namespaceObject.observationArtifactAdapterSymbol, {
             value: {