@ddwang/magnitude-core 0.3.1-ddwang.1

package/dist/agent/index.js

@@ -0,0 +1,377 @@
+import logger from '@/logger';
+import EventEmitter from "eventemitter3";
+import z from "zod";
+import { Observation } from '@/memory/observation';
+import { AgentError } from "@/agent/errors";
+import { AgentMemory } from "@/memory";
+import { taskActions } from "@/actions/taskActions";
+import { traceAsync } from "@/ai/baml_client";
+import { telemetrifyAgent } from '@/telemetry/events';
+import { isClaude } from '@/ai/util';
+import { retryOnError } from '@/common';
+import { renderContentParts } from '@/memory/rendering';
+import { MultiModelHarness } from '@/ai/multiModelHarness';
+// Options for the startAgent helper function
+const DEFAULT_CONFIG = {
+    actions: [...taskActions], // Default to taskActions; other actions come from connectors
+    connectors: [],
+    llm: {
+        provider: 'google-ai',
+        options: {
+            model: 'gemini-2.5-pro-preview-05-06',
+            apiKey: process.env.GOOGLE_API_KEY || "YOUR_GOOGLE_API_KEY"
+        }
+    },
+    prompt: null,
+    telemetry: true,
+};
+export class Agent {
+    // maybe remove conns/actions from options since stored sep
+    options; //Omit<Required<AgentOptions>, 'actions'>;
+    connectors;
+    actions; // actions from connectors + any other additional ones configured
+    memoryOptions;
+    models;
+    //public readonly model: ModelHarness;
+    //public readonly micro: GroundingService;
+    //public readonly events: EventEmitter<AgentEvents>;
+    //protected readonly _emitter: EventEmitter<AgentEvents>;
+    events = new EventEmitter();
+    //public readonly memory: AgentMemory;
+    doneActing;
+    _paused = false;
+    _pauseResolve = null;
+    latestTaskMemory; // | null = null;
+    constructor(baseConfig = {}) {
+        this.options = {
+            ...DEFAULT_CONFIG,
+            ...baseConfig,
+            connectors: baseConfig.connectors ?? [],
+            actions: [...(baseConfig.actions || DEFAULT_CONFIG.actions)],
+        };
+        this.connectors = this.options.connectors;
+        // Aggregate actions from connectors
+        //const aggregatedActions = [...this.options.actions];
+        this.actions = [...this.options.actions];
+        for (const connector of this.connectors) {
+            this.actions.push(...(connector.getActionSpace ? connector.getActionSpace() : []));
+        }
+        // Deduplicate actions by name
+        // TODO: maybe error instead, or automatically differentiate them?
+        //this.options.actions = Array.from(new Map(aggregatedActions.map(actDef => [actDef.name, actDef])).values());
+        const llms = Array.isArray(this.options.llm) ? this.options.llm : [this.options.llm];
+        let doPromptCaching = false;
+        for (const client of llms) {
+            // If any LLM is prompt-caching compatible, turn on prompt caching overall for memory etc.
+            if (isClaude(client) && (client.provider === 'anthropic' || client.provider === 'claude-code')) {
+                // Prompt-caching compatible client
+                if ('promptCaching' in client.options && client.options.promptCaching !== undefined) {
+                    doPromptCaching = client.options.promptCaching;
+                }
+                else {
+                    // Default to true if not specified, and override on client config to true
+                    doPromptCaching = true;
+                    client.options.promptCaching = true;
+                }
+            }
+        }
+        //this.model = new ModelHarness({ llm: this.options.llm });
+        this.models = new MultiModelHarness(llms);
+        this.models.events.on('tokensUsed', (usage) => this.events.emit('tokensUsed', usage), this);
+        this.doneActing = false;
+        this._paused = false;
+        this._pauseResolve = null;
+        this.memoryOptions = {
+            // TODO: maybe do if Gemini or other prompt caching supported providers as well
+            // Claude supports prompt caching but only via Anthropic, not on Bedrock
+            promptCaching: doPromptCaching
+        };
+        // Empty memory will get replaced on first act(), but this prevents errors from having undefined memory
+        this.latestTaskMemory = new AgentMemory(this.memoryOptions);
+    }
+    getConnector(connectorClass) {
+        return this.connectors.find(c => c instanceof connectorClass);
+    }
+    require(connectorClass) {
+        const connector = this.getConnector(connectorClass);
+        if (!connector)
+            throw new Error(`Missing required connector ${connectorClass}`);
+        return connector;
+    }
+    async start() {
+        // Register telemetry if enabled - do on start instead of cons to prevent weird subclass event issues
+        if (this.options.telemetry)
+            telemetrifyAgent(this);
+        //console.log('setting up model')
+        await this.models.setup();
+        //console.log('done setting up model')
+        logger.info("Agent: Starting connectors...");
+        for (const connector of this.connectors) {
+            if (connector.onStart)
+                await connector.onStart();
+        }
+        this.events.emit('start');
+        logger.info("Agent: All connectors started.");
+        // logger.info("Making initial observations...");
+        // await this._recordConnectorObservations();
+        // logger.info("Initial observations recorded");
+        // Initial observations are handled by the first getObservations call in exec
+    }
+    identifyAction(action) {
+        // Get definition corresponding to an action
+        const actionDefinition = this.actions.find(def => def.name === action.variant);
+        if (!actionDefinition) {
+            // It's possible the action name was from a connector that is no longer active,
+            // or the action space was not correctly aggregated.
+            throw new AgentError(`Undefined action type '${action.variant}'. Ensure agent is configured with appropriate action definitions from connectors.`);
+        }
+        return actionDefinition;
+    }
+    async exec(action, memory) {
+        /**
+         * Execute an action that belongs to this Agent's action space.
+         * Provide memory to record the action taken, its results, and any connector observations to that memory.
+         */
+        let actionDefinition = this.identifyAction(action);
+        let input;
+        if (actionDefinition.schema instanceof z.ZodObject) {
+            let variant;
+            ({ variant, ...input } = action);
+        }
+        else {
+            input = action.input;
+        }
+        let parsed = actionDefinition.schema.safeParse(input);
+        if (!parsed.success) {
+            throw new AgentError(`Generated action '${action.variant}' violates input schema: ${parsed.error.message}`, { adaptable: true });
+        }
+        this.events.emit('actionStarted', action);
+        const data = await actionDefinition.resolver({ input: parsed.data, agent: this });
+        this.events.emit('actionDone', action);
+        if (memory) {
+            // Record action taken
+            memory.recordObservation(Observation.fromActionTaken(actionDefinition.name, JSON.stringify(action)));
+            // Record results of action
+            if (data) {
+                memory.recordObservation(Observation.fromActionResult(actionDefinition.name, data));
+            }
+            // Collect and record observations from connectors
+            await this._recordConnectorObservations(memory);
+        }
+    }
+    async _recordConnectorObservations(memory) {
+        for (const connector of this.connectors) {
+            // could do Promise.all if matters
+            const connObservations = connector.collectObservations ? await connector.collectObservations() : [];
+            //observations.push(...connObservations);
+            for (const obs of connObservations) {
+                memory.recordObservation(obs);
+            }
+        }
+    }
+    get memory() {
+        //if (!this.latestTaskMemory) throw new Error("No memory available");
+        return this.latestTaskMemory;
+    }
+    async act(taskOrSteps, options = {}) {
+        const instructions = [
+            ...(this.options.prompt ? [this.options.prompt] : []),
+            ...(options.prompt ? [options.prompt] : []),
+        ].join('\n');
+        const taskMemory = options.memory ?? new AgentMemory({ ...this.memoryOptions, instructions: instructions === '' ? undefined : instructions });
+        if (Array.isArray(taskOrSteps)) {
+            const steps = taskOrSteps;
+            //this.events.emit('actStarted', steps.join(', '));
+            // trace overall task
+            await (traceAsync('multistep', async (steps, options) => {
+                for (const step of steps) {
+                    this.events.emit('actStarted', step, options);
+                    await this._traceAct(step, taskMemory, options);
+                    this.events.emit('actDone', step, options);
+                }
+            })(steps, options));
+            //this.events.emit('actDone', steps.join(', '));
+        }
+        else {
+            const task = taskOrSteps;
+            this.events.emit('actStarted', task, options);
+            await this._traceAct(task, taskMemory, options);
+            this.events.emit('actDone', task, options);
+        }
+    }
+    async _traceAct(task, memory, options = {}) {
+        // memory not serializable to trace so bake it
+        await (traceAsync('act', async (task) => {
+            await this._act(task, memory, options);
+        })(task));
+    }
+    async _buildContext(memory) {
+        const messages = await memory.render();
+        const connectorInstructions = [];
+        for (const connector of this.connectors) {
+            if (connector.getInstructions) {
+                const instructions = await connector.getInstructions();
+                if (instructions) {
+                    connectorInstructions.push({
+                        connectorId: connector.id,
+                        instructions: instructions
+                    });
+                }
+            }
+        }
+        return {
+            instructions: memory.instructions,
+            observationContent: messages,
+            //observationContent: content,
+            connectorInstructions: connectorInstructions
+        };
+    }
+    async _act(description, memory, options = {}) {
+        this.doneActing = false;
+        logger.info(`Act: ${description}`);
+        // for now simply add data to task
+        let dataContentParts = [];
+        if (options.data) {
+            //description += "\nUse the following data where appropriate:\n";
+            // description += "\n<data>\n";
+            // // if (typeof options.data === 'string') {
+            // //     description += options.data;
+            // // } else {
+            // //     description += Object.entries(options.data).map(([k, v]) => `${k}: ${v}`).join("\n");
+            // // }
+            // const parts = renderParts(options.data);
+            // description += "\n</data>";
+            dataContentParts = await renderContentParts(options.data, { mode: 'json', indent: 2 });
+        }
+        //this.events.emit('stepStart', description);
+        //const testData = convertOptionsToTestData(options);
+        // Initialize task memory and record initial observations
+        // Combine any agent-level and task-level instructions
+        this.latestTaskMemory = memory;
+        // record initial observations
+        logger.info("Making initial observations...");
+        await this._recordConnectorObservations(memory);
+        logger.info("Initial observations recorded");
+        while (true) {
+            // Removed direct screenshot/tabState access here; it's part of memoryContext via connectors
+            logger.info(`Creating partial recipe`);
+            let reasoning = "";
+            let actions = [];
+            try {
+                const memoryContext = await this._buildContext(memory);
+                await retryOnError(async () => {
+                    ({ reasoning, actions } = await this.models.partialAct(memoryContext, description, dataContentParts, this.actions));
+                    if (actions.length === 0) {
+                        // Empty action list behavior - default wait else ... err? what if not in action space?
+                        //actions.push()
+                        throw new AgentError(`No actions generated`);
+                    }
+                }, 
+                // HTTP body is not JSON - comes from Anthropic sometimes, weird error
+                // Sometimes Anthropic will give 401 Unauthorized randomly even when authorized
+                {
+                    mode: 'retry_on_partial_message',
+                    errorSubstrings: ['HTTP body is not JSON', '401 Unauthorized', 'No actions generated'],
+                    retryLimit: 3,
+                    delayMs: 1000,
+                    showWarnOnRetry: true
+                });
+            }
+            catch (error) {
+                logger.error(`Error planning actions: ${error instanceof Error ? error.message : String(error)}`);
+                /**
+                 * (1) Failure to conform to JSON
+                 * (2) Misconfigured BAML client / bad API key
+                 * (3) Network error (past max retries)
+                 */
+                // this.fail({
+                //     variant: 'misalignment',
+                //     message: `Could not create partial recipe -> ${(error as Error).message}`
+                // });
+                throw new AgentError(`Error planning actions: ${error.message}`, { variant: 'misalignment' });
+            }
+            logger.info({ reasoning, actions }, `Partial recipe created`);
+            // Could be emitted in memory and bubbled up instead of recordThought was called in more places
+            this.events.emit('thought', reasoning);
+            memory.recordThought(reasoning);
+            // Execute partial recipe
+            for (const action of actions) {
+                await this._waitIfPaused();
+                if (this.doneActing)
+                    break;
+                await this.exec(action, memory);
+                // const postActionScreenshot = await this.screenshot();
+                // const actionDescriptor: ActionDescriptor = { ...action, screenshot: postActionScreenshot.image } as ActionDescriptor;
+                // this.events.emit('action', actionDescriptor);
+                logger.info({ action }, `Action taken`);
+            }
+            // If macro expects these actions should complete the step, break
+            // if (finished) {
+            //     break;
+            // }
+            await this._waitIfPaused();
+            if (this.doneActing) {
+                break;
+            }
+        }
+        logger.info(`Done with step`);
+        //this.events.emit('stepSuccess');
+        //this.currentTaskMemory = null;
+    }
+    async query(query, schema) {
+        // Record observations in case no act() was used beforehand
+        await this._recordConnectorObservations(this.latestTaskMemory);
+        const memoryContext = await this._buildContext(this.memory); //this.memory.buildContext(this.connectors);
+        return await this.models.query(memoryContext, query, schema);
+    }
+    async queueDone() {
+        this.doneActing = true;
+    }
+    async _waitIfPaused() {
+        if (!this._paused)
+            return;
+        this.events.emit('pause');
+        logger.info("Agent: Paused");
+        await new Promise((resolve) => {
+            this._pauseResolve = resolve;
+        });
+    }
+    pause() {
+        this._paused = true;
+    }
+    resume() {
+        this._paused = false;
+        if (this._pauseResolve) {
+            this._pauseResolve();
+            this._pauseResolve = null;
+        }
+        this.events.emit('resume');
+        logger.info("Agent: Resumed");
+    }
+    get paused() {
+        return this._paused;
+    }
+    async stop() {
+        /**
+         * Stop the agent and close the browser context.
+         * May be called asynchronously and interrupt an agent in the middle of a action sequence.
+         */
+        this.doneActing = true;
+        if (this._paused) {
+            this.resume(); // unblock so loop can see doneActing and exit
+        }
+        logger.info("Agent: Stopping connectors...");
+        for (const connector of this.connectors) {
+            try {
+                if (connector.onStop)
+                    await connector.onStop();
+            }
+            catch (error) {
+                logger.warn(`Agent: Error stopping connector ${connector.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.events.emit('stop');
+        logger.info("Agent: All connectors stopped.");
+        logger.info("Agent: Stopped successfully.");
+    }
+}

package/dist/agent/narrator.d.ts

@@ -0,0 +1,4 @@
+import { Agent } from '@/agent';
+import { BrowserAgent } from './browserAgent';
+export declare function narrateAgent(agent: Agent): void;
+export declare function narrateBrowserAgent(agent: BrowserAgent): void;

package/dist/agent/narrator.js

@@ -0,0 +1,63 @@
+import { blueBright, bold, cyanBright, gray } from 'ansis';
+export function narrateAgent(agent) {
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedWriteInputTokens = 0;
+    let totalCachedReadInputTokens = 0;
+    let totalInputTokenCost = 0.0;
+    let totalOutputTokenCost = 0.0;
+    agent.events.on('tokensUsed', (usage) => {
+        totalInputTokens += usage.inputTokens;
+        totalOutputTokens += usage.outputTokens;
+        totalCachedWriteInputTokens += usage.cacheWriteInputTokens ?? 0;
+        totalCachedReadInputTokens += usage.cacheReadInputTokens ?? 0;
+        totalInputTokenCost += usage.inputCost ?? 0.0;
+        totalOutputTokenCost += usage.outputCost ?? 0.0;
+    });
+    agent.events.on('start', () => {
+        console.log(bold(blueBright(`▶ [start] agent started with ${agent.models.describe()}`)));
+    });
+    agent.events.on('stop', () => {
+        console.log(bold(blueBright(`■ [stop] agent stopped`)));
+        console.log(`  Total usage: ` + bold `${totalInputTokens + totalCachedWriteInputTokens + totalCachedReadInputTokens}` + ` input tokens` + (totalCachedWriteInputTokens > 0 || totalCachedReadInputTokens > 0 ? ` (${totalCachedWriteInputTokens} cache write, ${totalCachedReadInputTokens} cache read)` : '') + ` / ` + bold `${totalOutputTokens}` + ` output tokens`);
+        if (totalInputTokenCost > 0 || totalOutputTokenCost > 0) {
+            if (agent.models.numUniqueModels === 1 && agent.models.describe().startsWith('claude-code')) {
+                console.log(`  Cost: ` + cyanBright `None - using Claude Pro or Max subscription`);
+            }
+            else {
+                console.log(`  Cost: $${(totalInputTokenCost + totalOutputTokenCost).toFixed(3)}`);
+            }
+        }
+        // Show token usage and cost if available
+        // if (totalInputTokenCost > 0 || totalOutputTokenCost > 0) {
+        //     console.log(`  Total usage: ` + bold`${totalInputTokens}` + ` input tokens (` + `$${totalInputTokenCost.toFixed(3)}` + `)` + ` / ` + bold`${totalOutputTokens}` + ` output tokens (` + `$${totalOutputTokenCost.toFixed(3)}` + `)`);
+        // } else {
+        //     console.log(`  Total usage: ` + bold`${totalInputTokens}` + ` input tokens` + ` / ` + bold`${totalOutputTokens}` + ` output tokens`);
+        // }
+    });
+    agent.events.on('thought', (thought) => {
+        console.log(gray `${thought}`);
+        //console.log(gray`⚙︎ ${thought}`);
+    });
+    agent.events.on('actStarted', (task, options) => {
+        console.log(bold(cyanBright(`◆ [act] ${task}`)));
+    });
+    agent.events.on('actionStarted', (action) => {
+        const actionDefinition = agent.identifyAction(action);
+        console.log(bold `  ${actionDefinition.render(action)}`);
+    });
+}
+export function narrateBrowserAgent(agent) {
+    narrateAgent(agent);
+    agent.browserAgentEvents.on('nav', (url) => {
+        console.log(bold(cyanBright `⛓︎ [nav] ${url}`));
+    });
+    agent.browserAgentEvents.on('extractStarted', (instructions, schema) => {
+        console.log(bold(cyanBright `⛏ [extract] ${instructions}`));
+    });
+    agent.browserAgentEvents.on('extractDone', (instructions, data) => {
+        // console.log has a decent default formatter for arbitrary data e.g. objects
+        console.log(data);
+        //console.log(blueBright`${JSON.stringify(data, null, 2)}`);
+    });
+}

package/dist/agent/pause.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/pause.test.js

@@ -0,0 +1,194 @@
+import { describe, expect, test } from 'bun:test';
+import EventEmitter from 'eventemitter3';
+// Minimal Agent-like class that isolates pause/resume logic for testing
+// without requiring LLM clients, connectors, or BAML dependencies
+class PauseableLoop {
+    events = new EventEmitter();
+    doneActing = false;
+    _paused = false;
+    _pauseResolve = null;
+    async _waitIfPaused() {
+        if (!this._paused)
+            return;
+        this.events.emit('pause');
+        await new Promise((resolve) => {
+            this._pauseResolve = resolve;
+        });
+    }
+    pause() {
+        this._paused = true;
+    }
+    resume() {
+        this._paused = false;
+        if (this._pauseResolve) {
+            this._pauseResolve();
+            this._pauseResolve = null;
+        }
+        this.events.emit('resume');
+    }
+    get paused() {
+        return this._paused;
+    }
+    queueDone() {
+        this.doneActing = true;
+    }
+    stop() {
+        this.doneActing = true;
+        if (this._paused) {
+            this.resume();
+        }
+    }
+    /**
+     * Simulates the Agent._act() loop structure.
+     * Each "batch" is an array of action labels. The loop processes batches
+     * until doneActing is set, mirroring the real while(true) loop.
+     */
+    async runLoop(batches, onAction) {
+        this.doneActing = false;
+        let batchIndex = 0;
+        while (true) {
+            const actions = batches[batchIndex % batches.length];
+            batchIndex++;
+            for (const action of actions) {
+                await this._waitIfPaused();
+                if (this.doneActing)
+                    return;
+                onAction(action);
+            }
+            await this._waitIfPaused();
+            if (this.doneActing)
+                return;
+        }
+    }
+}
+describe('Agent pause/resume', () => {
+    test('pause() sets paused flag', () => {
+        const loop = new PauseableLoop();
+        expect(loop.paused).toBe(false);
+        loop.pause();
+        expect(loop.paused).toBe(true);
+    });
+    test('resume() clears paused flag', () => {
+        const loop = new PauseableLoop();
+        loop.pause();
+        loop.resume();
+        expect(loop.paused).toBe(false);
+    });
+    test('resume() when not paused is a no-op (no error)', () => {
+        const loop = new PauseableLoop();
+        expect(() => loop.resume()).not.toThrow();
+        expect(loop.paused).toBe(false);
+    });
+    test('loop pauses before action and resumes on resume()', async () => {
+        const loop = new PauseableLoop();
+        const executed = [];
+        // Pause immediately so first action blocks
+        loop.pause();
+        const loopPromise = loop.runLoop([['a', 'b']], (label) => {
+            executed.push(label);
+            // After executing both actions, stop
+            if (executed.length === 2)
+                loop.queueDone();
+        });
+        // Give microtasks a chance to settle — loop should be blocked
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual([]);
+        // Resume — loop should execute actions then stop
+        loop.resume();
+        await loopPromise;
+        expect(executed).toEqual(['a', 'b']);
+    });
+    test('pause mid-batch stops before next action', async () => {
+        const loop = new PauseableLoop();
+        const executed = [];
+        const loopPromise = loop.runLoop([['a', 'b', 'c']], (label) => {
+            executed.push(label);
+            if (label === 'a')
+                loop.pause(); // pause after first action
+        });
+        // Wait for loop to pause after 'a'
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual(['a']);
+        // Resume and let it finish
+        loop.resume();
+        await new Promise(r => setTimeout(r, 20));
+        // 'b' should now execute, pause again since flag was cleared by resume
+        // Actually after resume, _paused is false, so b and c run
+        expect(executed).toContain('b');
+        expect(executed).toContain('c');
+        // Stop the loop
+        loop.stop();
+        await loopPromise;
+    });
+    test('pause emits pause event, resume emits resume event', async () => {
+        const loop = new PauseableLoop();
+        const events = [];
+        loop.events.on('pause', () => events.push('pause'));
+        loop.events.on('resume', () => events.push('resume'));
+        loop.pause();
+        const loopPromise = loop.runLoop([['a']], () => loop.queueDone());
+        // Wait for loop to hit _waitIfPaused and emit 'pause'
+        await new Promise(r => setTimeout(r, 20));
+        expect(events).toEqual(['pause']);
+        loop.resume();
+        await loopPromise;
+        expect(events).toEqual(['pause', 'resume']);
+    });
+    test('stop() while paused unblocks the loop', async () => {
+        const loop = new PauseableLoop();
+        const executed = [];
+        loop.pause();
+        const loopPromise = loop.runLoop([['a', 'b']], (label) => executed.push(label));
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual([]);
+        // stop() should set doneActing and resume so loop exits
+        loop.stop();
+        await loopPromise;
+        // No actions should have executed — loop exits immediately after unblocking
+        expect(executed).toEqual([]);
+    });
+    test('pause between batches blocks next iteration', async () => {
+        const loop = new PauseableLoop();
+        const executed = [];
+        let batchCount = 0;
+        const loopPromise = loop.runLoop([['a'], ['b']], (label) => {
+            executed.push(label);
+            batchCount++;
+            // After first batch completes, pause before second batch
+            if (batchCount === 1)
+                loop.pause();
+            if (batchCount === 2)
+                loop.queueDone();
+        });
+        // Let first batch run, then loop should pause at between-batch check
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual(['a']);
+        loop.resume();
+        await loopPromise;
+        expect(executed).toEqual(['a', 'b']);
+    });
+    test('multiple pause/resume cycles work correctly', async () => {
+        const loop = new PauseableLoop();
+        const executed = [];
+        let actionCount = 0;
+        const loopPromise = loop.runLoop([['x']], (label) => {
+            actionCount++;
+            executed.push(`${label}${actionCount}`);
+            if (actionCount < 3) {
+                loop.pause(); // pause after each action
+            }
+            else {
+                loop.queueDone(); // done after 3rd
+            }
+        });
+        // First action runs, then pauses
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual(['x1']);
+        loop.resume();
+        await new Promise(r => setTimeout(r, 20));
+        expect(executed).toEqual(['x1', 'x2']);
+        loop.resume();
+        await loopPromise;
+        expect(executed).toEqual(['x1', 'x2', 'x3']);
+    });
+});