@midscene/test 1.12.4-beta-20260903111111.0 → 1.12.4

package/dist/lib/midscene/index.js

@@ -1,5 +1,73 @@
 "use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./src/errors.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            h2: ()=>NodeExecutionError,
+            ww: ()=>NodeDefinitionError
+        });
+        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;
+        }
+        class WorkflowError extends Error {
+            toJSON() {
+                return {
+                    name: this.name,
+                    message: this.message,
+                    code: this.code,
+                    ...void 0 === this.details ? {} : {
+                        details: this.details
+                    }
+                };
+            }
+            constructor(message, options = {}){
+                super(message, {
+                    cause: options.cause
+                }), _define_property(this, "code", void 0), _define_property(this, "details", void 0);
+                this.name = new.target.name;
+                this.code = options.code ?? 'WORKFLOW_ERROR';
+                this.details = options.details;
+            }
+        }
+        class NodeDefinitionError extends WorkflowError {
+            constructor(message, details){
+                super(message, {
+                    code: 'NODE_DEFINITION_ERROR',
+                    details
+                });
+            }
+        }
+        class NodeExecutionError extends WorkflowError {
+            constructor(node, cause){
+                const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
+                super(`Node "${node}" failed: ${causeMessage}`, {
+                    code: 'NODE_EXECUTION_ERROR',
+                    details: {
+                        node
+                    },
+                    cause
+                }), _define_property(this, "node", void 0);
+                this.node = node;
+            }
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
 (()=>{
     __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -22,440 +90,224 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    aiAssertInputSchema: ()=>aiAssertInputSchema,
-    createMidsceneNodes: ()=>createMidsceneNodes,
-    recordToReportInputSchema: ()=>recordToReportInputSchema,
-    renderNodeHistory: ()=>renderNodeHistory,
-    agentInputSchema: ()=>agentInputSchema,
-    waitInputSchema: ()=>waitInputSchema,
-    aiActInputSchema: ()=>aiActInputSchema,
-    launchInputSchema: ()=>launchInputSchema
-});
-const v4_namespaceObject = require("zod/v4");
-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;
-}
-class WorkflowError extends Error {
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            code: this.code,
-            ...void 0 === this.details ? {} : {
-                details: this.details
-            }
-        };
-    }
-    constructor(message, options = {}){
-        super(message, {
-            cause: options.cause
-        }), _define_property(this, "code", void 0), _define_property(this, "details", void 0);
-        this.name = new.target.name;
-        this.code = options.code ?? 'WORKFLOW_ERROR';
-        this.details = options.details;
-    }
-}
-class NodeDefinitionError extends WorkflowError {
-    constructor(message, details){
-        super(message, {
-            code: 'NODE_DEFINITION_ERROR',
-            details
-        });
-    }
-}
-class NodeExecutionError extends WorkflowError {
-    constructor(node, cause){
-        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-        super(`Node "${node}" failed: ${causeMessage}`, {
-            code: 'NODE_EXECUTION_ERROR',
-            details: {
-                node
-            },
-            cause
-        }), _define_property(this, "node", void 0);
-        this.node = node;
-    }
-}
-const validateOptionalText = (value, field, node)=>{
-    if (void 0 !== value && ('string' != typeof value || 0 === value.trim().length)) throw new NodeDefinitionError(`Node "${node}" ${field} must be a non-empty string.`, {
-        node,
-        field
-    });
-};
-const validateInputSchema = (schema, node)=>{
-    if (void 0 === schema) return;
-    if (!(schema instanceof v4_namespaceObject.z.ZodObject)) throw new NodeDefinitionError(`Node "${node}" inputSchema must be a Zod object schema.`, {
-        node,
-        field: 'inputSchema'
-    });
-    if ('$' in schema.shape) throw new NodeDefinitionError(`Node "${node}" inputSchema must not declare "$" as an input property.`, {
-        node,
-        field: 'inputSchema.$'
-    });
-};
-const validateDefinition = (options)=>{
-    if (!options || 'object' != typeof options) throw new NodeDefinitionError('Node definition must be an object.');
-    if ('string' != typeof options.name || 0 === options.name.trim().length) throw new NodeDefinitionError('Node name must be a non-empty string.');
-    validateOptionalText(options.title, 'title', options.name);
-    validateOptionalText(options.description, "description", options.name);
-    validateInputSchema(options.inputSchema, options.name);
-    if ('function' != typeof options.execute) throw new NodeDefinitionError(`Node "${options.name}" must provide an execute function.`, {
-        node: options.name
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        createAgentTestRunnerNodes: ()=>createAgentTestRunnerNodes,
+        aiActOptionsInputSchema: ()=>test_runner_namespaceObject.aiActOptionsInputSchema,
+        aiTapInputSchema: ()=>test_runner_namespaceObject.aiTapInputSchema,
+        reportScreenshotInputSchema: ()=>test_runner_namespaceObject.reportScreenshotInputSchema,
+        insightInputSchema: ()=>test_runner_namespaceObject.insightInputSchema,
+        locateOptionsInputSchema: ()=>test_runner_namespaceObject.locateOptionsInputSchema,
+        structuredUserPromptInputSchema: ()=>test_runner_namespaceObject.structuredUserPromptInputSchema,
+        waitInputSchema: ()=>waitInputSchema,
+        promptImageInputSchema: ()=>test_runner_namespaceObject.promptImageInputSchema,
+        aiAssertInputSchema: ()=>test_runner_namespaceObject.aiAssertInputSchema,
+        createMidsceneNodes: ()=>createMidsceneNodes,
+        recordToReportInputSchema: ()=>test_runner_namespaceObject.recordToReportInputSchema,
+        recordToReportOptionsInputSchema: ()=>test_runner_namespaceObject.recordToReportOptionsInputSchema,
+        agentInputSchema: ()=>agentInputSchema,
+        userPromptInputSchema: ()=>test_runner_namespaceObject.userPromptInputSchema,
+        aiAssertOptionsInputSchema: ()=>test_runner_namespaceObject.aiAssertOptionsInputSchema,
+        aiActInputSchema: ()=>test_runner_namespaceObject.aiActInputSchema,
+        insightOptionsInputSchema: ()=>test_runner_namespaceObject.insightOptionsInputSchema
     });
-};
-function define_node_defineNode(options) {
-    validateDefinition(options);
-    return options;
-}
-const lifecycleInputSchema = (operation, description)=>v4_namespaceObject.z.strictObject({
-        prompt: v4_namespaceObject.z.string().regex(/\S/, 'prompt must contain a non-whitespace character').optional().describe(`String shorthand for the app to ${operation}.`),
-        uri: v4_namespaceObject.z.string().regex(/\S/, 'uri must contain a non-whitespace character').optional().describe(description)
-    }).superRefine((input, ctx)=>{
-        if (void 0 === input.prompt === (void 0 === input.uri)) ctx.addIssue({
-            code: 'custom',
-            message: 'exactly one of prompt and uri is required'
+    const test_runner_namespaceObject = require("@midscene/core/agent/test-runner");
+    const v4_namespaceObject = require("zod/v4");
+    var errors = __webpack_require__("./src/errors.ts");
+    const validateOptionalText = (value, field, node)=>{
+        if (void 0 !== value && ('string' != typeof value || 0 === value.trim().length)) throw new errors.ww(`Node "${node}" ${field} must be a non-empty string.`, {
+            node,
+            field
         });
-    });
-const launchInputSchema = lifecycleInputSchema('launch', 'The app, URL, URI, package name, or bundle identifier to launch.');
-lifecycleInputSchema('terminate', 'The package name, bundle identifier, or app name to terminate.');
-const requireLifecycleMethod = (agent, method, agentName)=>{
-    if ('object' != typeof agent || null === agent || 'function' != typeof agent[method]) throw new NodeExecutionError(method, new TypeError(`getAgent() must return ${agentName} with ${method}().`));
-    return agent[method];
-};
-const createLaunchNode = (getAgent, agentName = 'an Agent')=>define_node_defineNode({
-        name: 'launch',
-        description: 'Launch an app, URL, or URI through the current Midscene Agent. This Node does not install or manage applications.',
-        inputSchema: launchInputSchema,
-        async execute (ctx) {
-            const uri = ctx.input.uri ?? ctx.input.prompt;
-            const agent = await getAgent(ctx);
-            const launch = requireLifecycleMethod(agent, 'launch', agentName);
-            await launch.call(agent, uri);
-            return {
-                summary: `Launched ${uri}`
-            };
-        }
-    });
-const nonBlankPrompt = (description)=>v4_namespaceObject.z.string().regex(/\S/, 'prompt must contain a non-whitespace character').describe(description);
-const promptImagesInputSchema = v4_namespaceObject.z.array(v4_namespaceObject.z.strictObject({
-    name: nonBlankPrompt('The name used to identify this reference image.'),
-    url: nonBlankPrompt('The URL, data URL, or file path of this reference image.')
-})).min(1).optional();
-const promptImageConversionInputSchema = v4_namespaceObject.z.boolean().optional().describe('Whether HTTP reference images are converted to base64 first.');
-const aiActOptionsInputSchema = v4_namespaceObject.z.strictObject({
-    cacheable: v4_namespaceObject.z.boolean().optional().describe('Whether this action may use the Midscene cache.'),
-    fileChooserAccept: v4_namespaceObject.z.union([
-        v4_namespaceObject.z.string(),
-        v4_namespaceObject.z.array(v4_namespaceObject.z.string())
-    ]).optional().describe('Accepted file types for a file chooser.'),
-    deepThink: v4_namespaceObject.z.union([
-        v4_namespaceObject.z.literal('unset'),
-        v4_namespaceObject.z.boolean()
-    ]).optional().describe('Whether to enable deep thinking for this action.'),
-    deepLocate: v4_namespaceObject.z.boolean().optional().describe('Whether to use deep element location.'),
-    context: v4_namespaceObject.z.string().optional().describe('Additional context supplied to the UI Agent.')
-});
-const aiActInputSchema = v4_namespaceObject.z.strictObject({
-    prompt: nonBlankPrompt('The natural-language UI task to perform.'),
-    images: promptImagesInputSchema,
-    convertHttpImage2Base64: promptImageConversionInputSchema,
-    options: aiActOptionsInputSchema.optional()
-});
-const aiAssertOptionsInputSchema = v4_namespaceObject.z.strictObject({
-    domIncluded: v4_namespaceObject.z.union([
-        v4_namespaceObject.z.boolean(),
-        v4_namespaceObject.z.literal('visible-only')
-    ]).optional().describe('How DOM information is included in the assertion.'),
-    screenshotIncluded: v4_namespaceObject.z.boolean().optional().describe('Whether the assertion includes a screenshot.'),
-    context: v4_namespaceObject.z.string().optional().describe('Additional context supplied to the UI Agent.')
-});
-const aiAssertInputSchema = v4_namespaceObject.z.strictObject({
-    prompt: nonBlankPrompt('The natural-language condition that must be true.'),
-    images: promptImagesInputSchema,
-    convertHttpImage2Base64: promptImageConversionInputSchema,
-    message: v4_namespaceObject.z.string().optional().describe('The assertion failure message.'),
-    options: aiAssertOptionsInputSchema.optional()
-});
-const reportScreenshotInputSchema = v4_namespaceObject.z.strictObject({
-    base64: v4_namespaceObject.z.string().min(1).describe('A base64-encoded screenshot.'),
-    description: v4_namespaceObject.z.string().optional().describe('What the screenshot shows.')
-});
-const recordToReportInputSchema = v4_namespaceObject.z.strictObject({
-    prompt: v4_namespaceObject.z.string().optional().describe('String shorthand for the title.'),
-    title: v4_namespaceObject.z.string().optional().describe('The report section title.'),
-    content: v4_namespaceObject.z.string().optional().describe('The report text content.'),
-    screenshotBase64: v4_namespaceObject.z.string().optional().describe('One base64-encoded screenshot.'),
-    screenshots: v4_namespaceObject.z.array(reportScreenshotInputSchema).min(1).optional().describe('Screenshots attached to the report section.')
-}).superRefine((input, ctx)=>{
-    if (void 0 !== input.prompt && void 0 !== input.title) ctx.addIssue({
-        code: 'custom',
-        message: 'prompt and title are mutually exclusive'
-    });
-    if (void 0 !== input.screenshotBase64 && void 0 !== input.screenshots) ctx.addIssue({
-        code: 'custom',
-        message: 'screenshotBase64 and screenshots are mutually exclusive'
-    });
-});
-const waitInputSchema = v4_namespaceObject.z.strictObject({
-    duration: v4_namespaceObject.z.number().positive().describe('How long to wait.'),
-    unit: v4_namespaceObject.z["enum"]([
-        'ms',
-        's',
-        'min'
-    ]).default('ms').describe('Duration unit: milliseconds, seconds, or minutes.')
-});
-const agentInputSchema = v4_namespaceObject.z.strictObject({
-    prompt: nonBlankPrompt('A self-contained task, including allowed tools and success conditions.')
-});
-const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-const requireAgentMethod = (agent, method, node)=>{
-    if (!isRecord(agent) || 'function' != typeof agent[method]) throw new NodeExecutionError(node, new TypeError(`getAgent() must return an Agent with ${method}().`));
-    return agent[method];
-};
-const maxHistoryContextCharacters = 64000;
-const maxHistoryValuePreviewCharacters = 8000;
-const maxHistoryEntryCharacters = 24000;
-const historyOmissionNoticeReserve = 256;
-const compactHistoryContextValue = (value)=>{
-    const serialized = JSON.stringify(value);
-    if (void 0 === serialized || serialized.length <= maxHistoryValuePreviewCharacters) return value;
-    return {
-        omittedFromContext: true,
-        originalCharacters: serialized.length,
-        preview: 'string' == typeof value ? value.slice(0, maxHistoryValuePreviewCharacters) : serialized.slice(0, maxHistoryValuePreviewCharacters)
     };
-};
-const serializeHistoryEntryForContext = (entry, index)=>{
-    const compacted = Object.fromEntries(Object.entries({
-        index,
-        ...entry
-    }).map(([key, value])=>[
-            key,
-            compactHistoryContextValue(value)
-        ]));
-    const serialized = JSON.stringify(compacted);
-    if (serialized.length <= maxHistoryEntryCharacters) return serialized;
-    return JSON.stringify({
-        index,
-        scope: entry.scope,
-        phase: entry.phase,
-        stepIndex: entry.stepIndex,
-        node: entry.node,
-        status: entry.status,
-        ...void 0 === entry.summary ? {} : {
-            summary: compactHistoryContextValue(entry.summary)
-        },
-        omittedFromContext: true,
-        compactedCharacters: serialized.length
-    });
-};
-const renderNodeHistory = (history)=>{
-    if (0 === history.length) return;
-    const heading = 'Previous workflow results (read-only):';
-    const availableCharacters = maxHistoryContextCharacters - heading.length - historyOmissionNoticeReserve;
-    const renderedEntries = [];
-    let renderedCharacters = 0;
-    for(let index = history.length - 1; index >= 0; index -= 1){
-        const rendered = serializeHistoryEntryForContext(history[index], index + 1);
-        const separatorCharacters = 0 === renderedEntries.length ? 0 : 1;
-        if (renderedCharacters + separatorCharacters + rendered.length > availableCharacters) break;
-        renderedEntries.unshift(rendered);
-        renderedCharacters += separatorCharacters + rendered.length;
-    }
-    const omittedEntries = history.length - renderedEntries.length;
-    return [
-        heading,
-        ...0 === omittedEntries ? [] : [
-            `${omittedEntries} earlier history entr${1 === omittedEntries ? 'y was' : 'ies were'} omitted from Agent context to stay within the size limit. Complete results remain available in the Test Runner output.`
-        ],
-        ...renderedEntries
-    ].join('\n');
-};
-const mergeContext = (explicit, history)=>[
-        explicit,
-        renderNodeHistory(history)
-    ].filter(Boolean).join('\n\n') || void 0;
-const toAgentPrompt = (input)=>{
-    if (void 0 === input.images && void 0 === input.convertHttpImage2Base64) return input.prompt;
-    return {
-        prompt: input.prompt,
-        ...void 0 === input.images ? {} : {
-            images: input.images
-        },
-        ...void 0 === input.convertHttpImage2Base64 ? {} : {
-            convertHttpImage2Base64: input.convertHttpImage2Base64
-        }
+    const validateInputSchema = (schema, node)=>{
+        if (void 0 === schema) return;
+        if (!(schema instanceof v4_namespaceObject.z.ZodObject)) throw new errors.ww(`Node "${node}" inputSchema must be a Zod object schema.`, {
+            node,
+            field: 'inputSchema'
+        });
+        if ('$' in schema.shape) throw new errors.ww(`Node "${node}" inputSchema must not declare "$" as an input property.`, {
+            node,
+            field: 'inputSchema.$'
+        });
     };
-};
-const waitFor = async (durationMs, signal)=>{
-    if (signal.aborted) throw signal.reason ?? new Error('Wait aborted.');
-    await new Promise((resolve, reject)=>{
-        const timeout = setTimeout(()=>{
-            signal.removeEventListener('abort', abort);
-            resolve();
-        }, durationMs);
-        const abort = ()=>{
-            clearTimeout(timeout);
-            reject(signal.reason ?? new Error('Wait aborted.'));
-        };
-        signal.addEventListener('abort', abort, {
-            once: true
+    const validateDefinition = (options)=>{
+        if (!options || 'object' != typeof options) throw new errors.ww('Node definition must be an object.');
+        if ('string' != typeof options.name || 0 === options.name.trim().length) throw new errors.ww('Node name must be a non-empty string.');
+        validateOptionalText(options.title, 'title', options.name);
+        validateOptionalText(options.description, "description", options.name);
+        if (void 0 !== options.stringInputKey && false !== options.stringInputKey && ('string' != typeof options.stringInputKey || 0 === options.stringInputKey.trim().length)) throw new errors.ww(`Node "${options.name}" stringInputKey must be a non-empty string or false.`, {
+            node: options.name,
+            field: 'stringInputKey'
+        });
+        validateInputSchema(options.inputSchema, options.name);
+        if ('string' == typeof options.stringInputKey && options.inputSchema instanceof v4_namespaceObject.z.ZodObject && !(options.stringInputKey in options.inputSchema.shape)) throw new errors.ww(`Node "${options.name}" stringInputKey must reference a field in inputSchema.`, {
+            node: options.name,
+            field: 'stringInputKey'
         });
+        if ('function' != typeof options.execute) throw new errors.ww(`Node "${options.name}" must provide an execute function.`, {
+            node: options.name
+        });
+    };
+    function defineNode(options) {
+        validateDefinition(options);
+        return options;
+    }
+    const nonBlankPrompt = (description)=>v4_namespaceObject.z.string().regex(/\S/, 'prompt must contain a non-whitespace character').describe(description);
+    const waitInputSchema = v4_namespaceObject.z.strictObject({
+        duration: v4_namespaceObject.z.number().positive().describe('How long to wait.'),
+        unit: v4_namespaceObject.z["enum"]([
+            'ms',
+            's',
+            'min'
+        ]).default('ms').describe('Duration unit: milliseconds, seconds, or minutes.')
     });
-};
-function createMidsceneNodes(options) {
-    if (!options || 'object' != typeof options) throw new NodeDefinitionError('createMidsceneNodes() options must be an object.');
-    if ('function' != typeof options.agentProvider?.getAgent && 'function' != typeof options.getAgent) throw new NodeDefinitionError('createMidsceneNodes() requires getAgent or agentProvider.getAgent.');
-    const registeredAgentScopes = new Set();
-    const getExecutionId = (ctx)=>'case' === ctx.scope ? ctx.case.runId : ctx.document.documentRunId;
-    const getAgent = async (ctx)=>{
-        if (!options.agentProvider) return options.getAgent(ctx);
-        const runId = getExecutionId(ctx);
-        if (options.agentProvider.releaseAgent && !registeredAgentScopes.has(runId)) {
-            registeredAgentScopes.add(runId);
-            ctx.onTeardown(async ()=>{
-                try {
-                    const released = await options.agentProvider.releaseAgent(runId);
-                    return released?.reportPath ? {
-                        reportPaths: [
-                            released.reportPath
-                        ]
-                    } : void 0;
-                } finally{
-                    registeredAgentScopes.delete(runId);
-                }
+    const agentInputSchema = v4_namespaceObject.z.strictObject({
+        prompt: nonBlankPrompt('A self-contained task, including allowed tools and success conditions.')
+    });
+    const waitFor = async (durationMs, signal)=>{
+        if (signal.aborted) throw signal.reason ?? new Error('Wait aborted.');
+        await new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                signal.removeEventListener('abort', abort);
+                resolve();
+            }, durationMs);
+            const abort = ()=>{
+                clearTimeout(timeout);
+                reject(signal.reason ?? new Error('Wait aborted.'));
+            };
+            signal.addEventListener('abort', abort, {
+                once: true
             });
-        }
-        return options.agentProvider.getAgent(runId, ctx);
+        });
     };
-    return [
-        define_node_defineNode({
-            name: 'aiAct',
-            description: 'Perform a natural-language task with a Midscene UI Agent.',
-            inputSchema: aiActInputSchema,
-            async execute (ctx) {
-                const agent = await getAgent(ctx);
-                const aiAct = requireAgentMethod(agent, 'aiAct', 'aiAct');
-                const output = await aiAct.call(agent, toAgentPrompt(ctx.input), {
-                    ...ctx.input.options,
-                    context: mergeContext(ctx.input.options?.context, ctx.history),
-                    abortSignal: ctx.signal
-                });
-                return void 0 === output ? void 0 : {
-                    summary: output
-                };
-            }
-        }),
-        define_node_defineNode({
-            name: 'aiAssert',
-            description: 'Assert a natural-language condition with a Midscene UI Agent.',
-            inputSchema: aiAssertInputSchema,
-            async execute (ctx) {
-                const agent = await getAgent(ctx);
-                const aiAssert = requireAgentMethod(agent, 'aiAssert', 'aiAssert');
-                await aiAssert.call(agent, toAgentPrompt(ctx.input), ctx.input.message, {
-                    ...ctx.input.options,
-                    context: mergeContext(ctx.input.options?.context, ctx.history),
-                    abortSignal: ctx.signal
-                });
-                return {
-                    summary: `Assertion passed: ${ctx.input.prompt}`
-                };
-            }
-        }),
-        define_node_defineNode({
-            name: 'recordToReport',
-            description: 'Add text or screenshots to the current Midscene report.',
-            inputSchema: recordToReportInputSchema,
-            async execute (ctx) {
-                const title = ctx.input.title ?? ctx.input.prompt;
-                const reportOptions = {
-                    ...void 0 === ctx.input.content ? {} : {
-                        content: ctx.input.content
-                    },
-                    ...void 0 === ctx.input.screenshotBase64 ? {} : {
-                        screenshotBase64: ctx.input.screenshotBase64
-                    },
-                    ...void 0 === ctx.input.screenshots ? {} : {
-                        screenshots: ctx.input.screenshots
+    const createAgentTestRunnerNodes = (definitions, getAgent)=>definitions.map((definition)=>defineNode({
+                name: definition.name,
+                ...void 0 === definition.title ? {} : {
+                    title: definition.title
+                },
+                ...void 0 === definition.description ? {} : {
+                    description: definition.description
+                },
+                ...void 0 === definition.stringInputKey ? {} : {
+                    stringInputKey: definition.stringInputKey
+                },
+                inputSchema: definition.inputSchema,
+                async execute (ctx) {
+                    const agent = await getAgent(ctx);
+                    return definition.execute(agent, ctx.input, {
+                        signal: ctx.signal
+                    });
+                }
+            }));
+    function createMidsceneNodes(options) {
+        if (!options || 'object' != typeof options) throw new errors.ww('createMidsceneNodes() options must be an object.');
+        if ('function' != typeof options.agentProvider?.getAgent && 'function' != typeof options.getAgent) throw new errors.ww('createMidsceneNodes() requires getAgent or agentProvider.getAgent.');
+        if (!options.agentClass || 'function' != typeof options.agentClass.getTestRunnerNodeDefinitions) throw new errors.ww('createMidsceneNodes() requires agentClass.getTestRunnerNodeDefinitions().');
+        const registeredAgentScopes = new Set();
+        const getExecutionId = (ctx)=>'case' === ctx.scope ? ctx.case.runId : ctx.document.documentRunId;
+        const getAgent = async (ctx)=>{
+            if (!options.agentProvider) return options.getAgent(ctx);
+            const runId = getExecutionId(ctx);
+            if (options.agentProvider.releaseAgent && !registeredAgentScopes.has(runId)) {
+                registeredAgentScopes.add(runId);
+                ctx.onTeardown(async ()=>{
+                    try {
+                        const released = await options.agentProvider.releaseAgent(runId);
+                        return released?.reportPath ? {
+                            reportPaths: [
+                                released.reportPath
+                            ]
+                        } : void 0;
+                    } finally{
+                        registeredAgentScopes.delete(runId);
                     }
-                };
-                const agent = await getAgent(ctx);
-                const recordToReport = requireAgentMethod(agent, 'recordToReport', 'recordToReport');
-                await recordToReport.call(agent, title, reportOptions);
-                return {
-                    summary: `Recorded to report: ${title ?? 'untitled'}`
-                };
-            }
-        }),
-        ...false === options.includeLaunch ? [] : [
-            createLaunchNode(getAgent)
-        ],
-        define_node_defineNode({
-            name: 'wait',
-            description: 'Wait for a fixed duration while honoring cancellation.',
-            inputSchema: waitInputSchema,
-            async execute (ctx) {
-                const multiplier = 'min' === ctx.input.unit ? 60000 : 's' === ctx.input.unit ? 1000 : 1;
-                const durationMs = ctx.input.duration * multiplier;
-                await waitFor(durationMs, ctx.signal);
-                return {
-                    summary: `Waited ${durationMs}ms`
-                };
-            }
-        }),
-        define_node_defineNode({
-            name: 'agent',
-            description: 'Execute one self-contained natural-language task with an injected Agent executor.',
-            inputSchema: agentInputSchema,
-            async execute (ctx) {
-                if (!options.agentExecutor) throw new NodeExecutionError('agent', new TypeError('createMidsceneNodes() requires an agentExecutor.'));
-                const execution = 'case' === ctx.scope ? {
-                    scope: 'case',
-                    runId: ctx.case.runId
-                } : {
-                    scope: 'document',
-                    runId: ctx.document.documentRunId
-                };
-                const result = await options.agentExecutor.execute({
-                    prompt: ctx.input.prompt,
-                    history: ctx.history,
-                    context: ctx.context,
-                    signal: ctx.signal,
-                    execution
                 });
-                return result ?? {
-                    summary: 'Agent task completed.'
-                };
             }
-        })
-    ];
-}
+            return options.agentProvider.getAgent(runId, ctx);
+        };
+        const agentDefinitions = options.agentClass.getTestRunnerNodeDefinitions();
+        return [
+            ...createAgentTestRunnerNodes(agentDefinitions, getAgent),
+            defineNode({
+                name: 'wait',
+                description: 'Wait for a fixed duration while honoring cancellation.',
+                stringInputKey: false,
+                inputSchema: waitInputSchema,
+                async execute (ctx) {
+                    const multiplier = 'min' === ctx.input.unit ? 60000 : 's' === ctx.input.unit ? 1000 : 1;
+                    const durationMs = ctx.input.duration * multiplier;
+                    await waitFor(durationMs, ctx.signal);
+                    return {
+                        summary: `Waited ${durationMs}ms`
+                    };
+                }
+            }),
+            defineNode({
+                name: 'agent',
+                description: 'Execute one self-contained natural-language task with an injected Agent executor.',
+                stringInputKey: 'prompt',
+                inputSchema: agentInputSchema,
+                async execute (ctx) {
+                    if (!options.agentExecutor) throw new errors.h2('agent', new TypeError('createMidsceneNodes() requires an agentExecutor.'));
+                    const execution = 'case' === ctx.scope ? {
+                        scope: 'case',
+                        runId: ctx.case.runId
+                    } : {
+                        scope: 'document',
+                        runId: ctx.document.documentRunId
+                    };
+                    const result = await options.agentExecutor.execute({
+                        prompt: ctx.input.prompt,
+                        context: ctx.context,
+                        signal: ctx.signal,
+                        execution
+                    });
+                    return result ?? {
+                        summary: 'Agent task completed.'
+                    };
+                }
+            })
+        ];
+    }
+})();
 exports.agentInputSchema = __webpack_exports__.agentInputSchema;
 exports.aiActInputSchema = __webpack_exports__.aiActInputSchema;
+exports.aiActOptionsInputSchema = __webpack_exports__.aiActOptionsInputSchema;
 exports.aiAssertInputSchema = __webpack_exports__.aiAssertInputSchema;
+exports.aiAssertOptionsInputSchema = __webpack_exports__.aiAssertOptionsInputSchema;
+exports.aiTapInputSchema = __webpack_exports__.aiTapInputSchema;
+exports.createAgentTestRunnerNodes = __webpack_exports__.createAgentTestRunnerNodes;
 exports.createMidsceneNodes = __webpack_exports__.createMidsceneNodes;
-exports.launchInputSchema = __webpack_exports__.launchInputSchema;
+exports.insightInputSchema = __webpack_exports__.insightInputSchema;
+exports.insightOptionsInputSchema = __webpack_exports__.insightOptionsInputSchema;
+exports.locateOptionsInputSchema = __webpack_exports__.locateOptionsInputSchema;
+exports.promptImageInputSchema = __webpack_exports__.promptImageInputSchema;
 exports.recordToReportInputSchema = __webpack_exports__.recordToReportInputSchema;
-exports.renderNodeHistory = __webpack_exports__.renderNodeHistory;
+exports.recordToReportOptionsInputSchema = __webpack_exports__.recordToReportOptionsInputSchema;
+exports.reportScreenshotInputSchema = __webpack_exports__.reportScreenshotInputSchema;
+exports.structuredUserPromptInputSchema = __webpack_exports__.structuredUserPromptInputSchema;
+exports.userPromptInputSchema = __webpack_exports__.userPromptInputSchema;
 exports.waitInputSchema = __webpack_exports__.waitInputSchema;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "agentInputSchema",
     "aiActInputSchema",
+    "aiActOptionsInputSchema",
     "aiAssertInputSchema",
+    "aiAssertOptionsInputSchema",
+    "aiTapInputSchema",
+    "createAgentTestRunnerNodes",
     "createMidsceneNodes",
-    "launchInputSchema",
+    "insightInputSchema",
+    "insightOptionsInputSchema",
+    "locateOptionsInputSchema",
+    "promptImageInputSchema",
     "recordToReportInputSchema",
-    "renderNodeHistory",
+    "recordToReportOptionsInputSchema",
+    "reportScreenshotInputSchema",
+    "structuredUserPromptInputSchema",
+    "userPromptInputSchema",
     "waitInputSchema"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {