@midscene/core 1.12.10-beta-20260920072249.0 → 1.13.0

package/dist/es/agent/agent.mjs

@@ -2,9 +2,14 @@ import { getModelRuntime } from "../ai-model/models/index.mjs";
 import { INTERNAL_CALL_ID_FIELD } from "../ai-model/service-caller/index.mjs";
 import { IS_REPORT_BUILD } from "../constants.mjs";
 import js_yaml from "js-yaml";
+import { generateTestRunReportScriptTag } from "../dump/html-utils.mjs";
 import { ScreenshotItem } from "../screenshot-item.mjs";
 import service from "../service/index.mjs";
+import { waitForResourceIdle } from "../test-runner/engine/resource-operations.mjs";
+import { buildAgentTestRunReportDump } from "../test-runner/reporting/agent-report.mjs";
+import { executionRecordsToReportInput } from "../test-runner/reporting/execution-record.mjs";
 import { ExecutionDump, ReportActionDump } from "../types.mjs";
+import { YamlExecutionOwnershipError, enterYamlAction, enterYamlExecution, runInYamlExecutionContext } from "../yaml/execution-session.mjs";
 import { ReportGenerator, assertReportGenerationOptions } from "../report-generator.mjs";
 import { getVersion, processCacheConfig, reportHTMLContent } from "../utils.mjs";
 import { ScriptPlayer, buildDetailedLocateParam, buildDetailedLocateParamAndRestParams, parseYamlScript } from "../yaml/index.mjs";
@@ -61,6 +66,60 @@ class Agent {
     static getTestRunnerNodeDefinitions() {
         return commonAgentTestRunnerNodeDefinitions;
     }
+    _prepareForTestRunner() {
+        this.reportGenerator.enableSourceSnapshots?.();
+    }
+    async _createReportSource(scopeId) {
+        return this.reportGenerator.createSourceSnapshot?.(scopeId);
+    }
+    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 executionRecordsToReportInput(scopedRecords, {
+            runId: this.yamlReportScopeId
+        });
+    }
     get onDumpUpdate() {
         return this.dumpUpdateListeners[0];
     }
@@ -247,7 +306,21 @@ class Agent {
     }
     reportHTMLString(opt) {
         if (IS_REPORT_BUILD) return '';
-        return reportHTMLContent(this.dumpDataString(opt));
+        const dumpString = this.dumpDataString(opt);
+        if (!this.yamlExecutionRecords.length) return reportHTMLContent(dumpString);
+        const reportId = this.yamlReportScopeId;
+        const runnerDump = buildAgentTestRunReportDump(this.buildYamlReportInput(), this.dump, {
+            reportId,
+            scopeId: this.yamlReportScopeId,
+            sourcePath: this.reportFile ?? '<inline-agent-report>'
+        });
+        return `${reportHTMLContent({
+            dumpString,
+            attributes: {
+                'data-group-id': reportId,
+                'data-report-id': reportId
+            }
+        })}\n${generateTestRunReportScriptTag(runnerDump)}`;
     }
     writeOutActionDumps(executionDump) {
         const exec = executionDump || this.lastExecutionDump;
@@ -257,6 +330,11 @@ class Agent {
         }
         this.reportFile = this.reportGenerator.getReportPath();
     }
+    async flushReport() {
+        this.writeOutActionDumps();
+        await this.reportGenerator.flush();
+        return this.lastExecutionDump ? this.reportFile ?? void 0 : void 0;
+    }
     getReportMeta() {
         return {
             groupName: this.dump.groupName,
@@ -276,9 +354,12 @@ class Agent {
     }
     async callActionInActionSpace(type, opt) {
         debug('callActionInActionSpace', type, ',', opt);
+        const clonedActionParam = opt && 'object' == typeof opt && !Array.isArray(opt) ? {
+            ...opt
+        } : opt || {};
         const actionPlan = {
             type: type,
-            param: opt || {},
+            param: clonedActionParam,
             thought: ''
         };
         debug('actionPlan', actionPlan);
@@ -441,9 +522,8 @@ class Agent {
             const aiActContext = this.resolveUserContext('aiAct', opt?.context);
             const cachePrompt = buildPromptWithContext(taskPrompt, aiActContext);
             const effort = (()=>{
-                const resolvedEffort = opt?.effort ?? (opt?.deepThink === 'auto' ? 'auto' : opt?.deepThink === true ? 'deepThink' : 'balance');
-                if (opt?.effort !== void 0) warn('The "effort" option is experimental and not yet open for public use. Do not use it. When both "effort" and "deepThink" are provided, "effort" takes precedence.');
-                if ('auto' === resolvedEffort && 'custom' === planningModel.adapter.planning.kind) throw new Error('deepThink: "auto" requires a standard planning adapter.');
+                const resolvedEffort = opt?.effort ?? (opt?.deepThink === true ? 'deepThink' : 'balance');
+                if (opt?.effort !== void 0 && void 0 !== opt.deepThink) warn('When both "effort" and "deepThink" are provided, "effort" takes precedence.');
                 if ('fast' === resolvedEffort && 'custom' === planningModel.adapter.planning.kind) throw new Error(`The "fast" aiAct effort is not supported with custom planning adapters (modelFamily: ${planningModel.config.modelFamily ?? 'unknown'}).`);
                 if ('deepThink' === resolvedEffort && 'custom' === planningModel.adapter.planning.kind) {
                     warn(`The "deepThink" aiAct effort is not supported with custom planning adapters (modelFamily: ${planningModel.config.modelFamily ?? 'unknown'}). It will be ignored.`);
@@ -466,9 +546,20 @@ class Agent {
                 try {
                     await this.taskExecutor.loadYamlFlowAsPlanning(taskPrompt, yaml, internalReportDisplay);
                     debug('matched cache, will call .runYaml to run the action');
-                    await this.runYaml(yaml);
+                    await runInYamlExecutionContext(async ()=>{
+                        const replay = enterYamlExecution(this);
+                        const leaveAction = abortSignal ? enterYamlAction(this, abortSignal) : void 0;
+                        try {
+                            await this.runYaml(yaml);
+                        } finally{
+                            leaveAction?.();
+                            replay.finish();
+                        }
+                    });
                     return;
                 } catch (error) {
+                    if (error instanceof YamlExecutionOwnershipError) throw error;
+                    abortSignal?.throwIfAborted();
                     cachedYamlFailed = true;
                     warn(`cached aiAct plan failed, will replan and disable the stale cache: ${error instanceof Error ? error.message : String(error)}`);
                 }
@@ -596,6 +687,7 @@ class Agent {
         return this.aiAct(...args);
     }
     async runYaml(yamlScriptContent) {
+        if (this.destroyed) throw new Error('Cannot run YAML using a destroyed Agent.');
         const script = parseYamlScript(yamlScriptContent, 'yaml');
         const player = new ScriptPlayer(script, async ()=>({
                 agent: this,
@@ -647,6 +739,7 @@ class Agent {
     async destroy() {
         if (this.destroyed) return;
         this.destroyed = true;
+        await waitForResourceIdle(this);
         for (const observer of this.ownedObservers)try {
             await observer.dispose();
         } catch (error) {
@@ -666,8 +759,9 @@ class Agent {
         this.resetDump();
         if (interfaceDestroyError) throw interfaceDestroyError;
     }
-    async sleep(ms) {
-        await this.taskExecutor.sleep(ms);
+    async sleep(ms, options) {
+        options?.abortSignal?.throwIfAborted();
+        await this.taskExecutor.sleep(ms, options?.abortSignal);
     }
     async recordToReport(title, opt) {
         const now = Date.now();
@@ -831,6 +925,8 @@ class Agent {
         _define_property(this, "dump", void 0);
         _define_property(this, "reportFile", void 0);
         _define_property(this, "reportFileName", void 0);
+        _define_property(this, "yamlReportScopeId", uuid());
+        _define_property(this, "yamlExecutionRecords", []);
         _define_property(this, "taskExecutor", void 0);
         _define_property(this, "opts", void 0);
         _define_property(this, "dryMode", false);