@positronic/core 0.0.77 → 0.0.78

package/dist/src/dsl/execution/event-stream.js

@@ -166,6 +166,35 @@ function AsyncFromSyncIterator(s) {
         }
     }, new AsyncFromSyncIterator(s);
 }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function _await_async_generator(value) {
     return new _overload_yield(value, 0);
 }
@@ -201,6 +230,13 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
@@ -437,12 +473,15 @@ import { v4 as uuidv4 } from 'uuid';
 import { STATUS, BRAIN_EVENTS } from '../constants.js';
 import { createPatch, applyPatches } from '../json-patch.js';
 import { IterateResult } from '../iterate-result.js';
-import { generateUI } from '../../ui/generate-ui.js';
+import { generatePage } from '../../ui/generate-page.js';
 import { generatePageHtml } from '../../ui/generate-page-html.js';
-import { createScopedMemory } from '../../memory/scoped-memory.js';
+import { guessMimeType } from '../../files/mime.js';
+import { EventChannel } from './event-channel.js';
+import { wrapFilesWithEvents } from '../../files/event-wrapper.js';
 import { Step } from '../builder/step.js';
-import { DEFAULT_ENV, DEFAULT_AGENT_SYSTEM_PROMPT } from './constants.js';
-import { defaultDoneSchema } from '../../tools/index.js';
+import { DEFAULT_ENV } from './constants.js';
+import { resolveTemplate, buildTemplateContext } from '../../template/render.js';
+import { renderHtml, wrapHtmlDocument } from '../../template/render-html.js';
 var clone = function(value) {
     return structuredClone(value);
 };
@@ -458,54 +497,56 @@ export var BrainEventStream = /*#__PURE__*/ function() {
         _define_property(this, "description", void 0);
         _define_property(this, "client", void 0);
         _define_property(this, "options", void 0);
-        _define_property(this, "services", void 0);
         _define_property(this, "resources", void 0);
         _define_property(this, "pages", void 0);
         _define_property(this, "env", void 0);
         _define_property(this, "currentResponse", undefined);
         _define_property(this, "currentPage", undefined);
-        _define_property(this, "resumeContext", void 0);
+        _define_property(this, "resume", void 0);
         _define_property(this, "components", void 0);
-        _define_property(this, "defaultTools", void 0);
-        _define_property(this, "extraTools", void 0);
         _define_property(this, "signalProvider", void 0);
-        _define_property(this, "memoryProvider", void 0);
-        _define_property(this, "scopedMemory", void 0);
         _define_property(this, "store", void 0);
+        _define_property(this, "files", void 0);
+        _define_property(this, "storeProvider", void 0);
+        _define_property(this, "pluginInjections", void 0);
+        _define_property(this, "pluginAdapters", void 0);
+        _define_property(this, "pluginConfigs", void 0);
+        _define_property(this, "templateContext", void 0);
         _define_property(this, "governor", void 0);
         _define_property(this, "currentUser", void 0);
         _define_property(this, "guards", new Map());
         _define_property(this, "waits", new Map());
         _define_property(this, "stopped", false);
         _define_property(this, "optionsSchema", void 0);
-        var blocks = params.blocks, title = params.title, description = params.description, providedBrainRunId = params.brainRunId, _params_options = params.options, options = _params_options === void 0 ? {} : _params_options, client = params.client, services = params.services, _params_resources = params.resources, resources = _params_resources === void 0 ? {} : _params_resources, pages = params.pages, env = params.env, components = params.components, defaultTools = params.defaultTools, extraTools = params.extraTools, signalProvider = params.signalProvider, memoryProvider = params.memoryProvider, store = params.store, currentUser = params.currentUser;
+        var blocks = params.blocks, title = params.title, description = params.description, providedBrainRunId = params.brainRunId, _params_options = params.options, options = _params_options === void 0 ? {} : _params_options, client = params.client, _params_resources = params.resources, resources = _params_resources === void 0 ? {} : _params_resources, pages = params.pages, env = params.env, components = params.components, signalProvider = params.signalProvider, store = params.store, files = params.files, currentUser = params.currentUser;
         // Store governor for per-step client resolution
         this.governor = params.governor;
         this.currentUser = currentUser;
         // Check if this is a resume run or fresh start
         var resumeParams = params;
         var initialParams = params;
-        var resumeContext = resumeParams.resumeContext;
+        var resume = resumeParams.resume;
         this.title = title;
         this.description = description;
         this.client = client;
         this.options = options;
-        this.services = services;
         this.resources = resources;
         this.pages = pages;
         this.env = env !== null && env !== void 0 ? env : DEFAULT_ENV;
-        this.resumeContext = resumeContext;
+        this.resume = resume;
         this.components = components;
-        this.defaultTools = defaultTools;
-        this.extraTools = extraTools;
         this.signalProvider = signalProvider;
-        this.memoryProvider = memoryProvider;
         this.store = store;
+        this.files = files;
+        this.storeProvider = params.storeProvider;
+        var _params_pluginInjections;
+        this.pluginInjections = (_params_pluginInjections = params.pluginInjections) !== null && _params_pluginInjections !== void 0 ? _params_pluginInjections : {};
+        var _params_pluginAdapters;
+        this.pluginAdapters = (_params_pluginAdapters = params.pluginAdapters) !== null && _params_pluginAdapters !== void 0 ? _params_pluginAdapters : [];
+        var _params_pluginConfigs;
+        this.pluginConfigs = (_params_pluginConfigs = params.pluginConfigs) !== null && _params_pluginConfigs !== void 0 ? _params_pluginConfigs : [];
+        this.templateContext = buildTemplateContext(this.files, this.resources);
         this.optionsSchema = params.optionsSchema;
-        // Create scoped memory if provider is configured
-        if (memoryProvider) {
-            this.scopedMemory = createScopedMemory(memoryProvider, title, this.currentUser.name);
-        }
         // Initialize steps - track guard and wait blocks by index
         this.steps = [];
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
@@ -535,27 +576,42 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                 }
             }
         }
-        if (resumeContext) {
-            // Resume: use state and stepIndex directly from resumeContext
-            this.currentState = clone(resumeContext.state);
-            this.currentStepIndex = resumeContext.stepIndex;
+        if (resume) {
+            // Resume: use state and stepIndex from resume params
+            this.currentState = clone(resume.state);
+            this.currentStepIndex = resume.stepIndex;
             // Mark steps before stepIndex as complete (they won't be re-executed)
-            for(var i = 0; i < resumeContext.stepIndex; i++){
+            for(var i = 0; i < resume.stepIndex; i++){
                 this.steps[i].withStatus(STATUS.COMPLETE);
             }
-            // For inner brains (no signalProvider), check resumeContext for webhookResponse
+            // Re-wrap IterateResult instances that were serialized to plain arrays.
+            // During suspension, JSON patches call toJSON() on IterateResult, turning
+            // them into plain [item, result][] arrays. Re-wrap so downstream steps
+            // can use IterateResult methods (.map, .filter, etc.)
+            for(var i1 = 0; i1 < resume.stepIndex; i1++){
+                var block1 = this.steps[i1].block;
+                if (block1.type === 'map') {
+                    var mapBlock = block1;
+                    var value = this.currentState[mapBlock.stateKey];
+                    if (value != null && Array.isArray(value) && !_instanceof(value, IterateResult)) {
+                        this.currentState[mapBlock.stateKey] = new IterateResult(value);
+                    }
+                }
+            }
+            // For inner brains (no signalProvider), check for webhookResponse
             // The outer brain will have set this from the signal
-            if (!signalProvider && resumeContext.webhookResponse && !resumeContext.agentContext) {
-                this.currentResponse = resumeContext.webhookResponse;
+            if (!signalProvider && resume.webhookResponse) {
+                this.currentResponse = resume.webhookResponse;
             }
-            // Agent webhook response is handled via agentContext (checked in executeAgent)
             // Restore page context if available (from a preceding UI step)
-            if (resumeContext.currentPage) {
-                this.currentPage = {
-                    url: resumeContext.currentPage.url,
-                    webhook: _object_spread_props(_object_spread({}, resumeContext.currentPage.webhook), {
+            if (resume.currentPage) {
+                this.currentPage = resume.currentPage.webhook ? {
+                    url: resume.currentPage.url,
+                    webhook: _object_spread_props(_object_spread({}, resume.currentPage.webhook), {
                         schema: z.record(z.unknown())
                     })
+                } : {
+                    url: resume.currentPage.url
                 };
             }
         } else {
@@ -569,20 +625,167 @@ export var BrainEventStream = /*#__PURE__*/ function() {
     }
     _create_class(BrainEventStream, [
         {
-            key: "findWebhookResponseInResumeContext",
-            value: /**
-   * Find webhookResponse anywhere in the resumeContext tree (for nested brain resumes)
-   */ function findWebhookResponseInResumeContext(context) {
-                if (!context) return undefined;
-                if (context.webhookResponse) return context.webhookResponse;
-                return this.findWebhookResponseInResumeContext(context.innerResumeContext);
+            key: "next",
+            value: function next() {
+                return _wrap_async_generator(function() {
+                    var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, _iteratorNormalCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, adapter, err, err1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _iteratorAbruptCompletion = false, _didIteratorError = false;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    15,
+                                    16,
+                                    21
+                                ]);
+                                _iterator = _async_iterator(this.generate());
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator.next())
+                                ];
+                            case 3:
+                                if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                                    3,
+                                    14
+                                ];
+                                _value = _step.value;
+                                event = _value;
+                                _iteratorNormalCompletion = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                _state.label = 4;
+                            case 4:
+                                _state.trys.push([
+                                    4,
+                                    9,
+                                    10,
+                                    11
+                                ]);
+                                _iterator1 = this.pluginAdapters[Symbol.iterator]();
+                                _state.label = 5;
+                            case 5:
+                                if (!!(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done)) return [
+                                    3,
+                                    8
+                                ];
+                                adapter = _step1.value;
+                                return [
+                                    4,
+                                    _await_async_generator(adapter.dispatch(event))
+                                ];
+                            case 6:
+                                _state.sent();
+                                _state.label = 7;
+                            case 7:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 8:
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 9:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 10:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 11:
+                                return [
+                                    4,
+                                    event
+                                ];
+                            case 12:
+                                _state.sent();
+                                _state.label = 13;
+                            case 13:
+                                _iteratorAbruptCompletion = false;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 14:
+                                return [
+                                    3,
+                                    21
+                                ];
+                            case 15:
+                                err1 = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err1;
+                                return [
+                                    3,
+                                    21
+                                ];
+                            case 16:
+                                _state.trys.push([
+                                    16,
+                                    ,
+                                    19,
+                                    20
+                                ]);
+                                if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                                    3,
+                                    18
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator.return())
+                                ];
+                            case 17:
+                                _state.sent();
+                                _state.label = 18;
+                            case 18:
+                                return [
+                                    3,
+                                    20
+                                ];
+                            case 19:
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                                return [
+                                    7
+                                ];
+                            case 20:
+                                return [
+                                    7
+                                ];
+                            case 21:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
             }
         },
         {
-            key: "next",
-            value: function next() {
+            key: "generate",
+            value: function generate() {
                 return _wrap_async_generator(function() {
-                    var _this, steps, brainTitle, brainDescription, currentState, options, brainRunId, webhookResponse, signals, webhookSignal, deepest, signals1, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, err, step, guard, waitBlock, err1, error, currentStep;
+                    var _this, steps, brainTitle, brainDescription, currentState, options, brainRunId, webhookResponse, signals, webhookSignal, _this_resume, signals1, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, err, step, guard, waitBlock, err1, error, currentStep;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -595,7 +798,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     ,
                                     36
                                 ]);
-                                if (!!this.resumeContext) return [
+                                if (!!this.resume) return [
                                     3,
                                     4
                                 ];
@@ -617,17 +820,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 // Emit initial step status after brain starts
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(step) {
-                                            var _step_serialized = step.serialized, patch = _step_serialized.patch, rest = _object_without_properties(_step_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 3:
                                 _state.sent();
@@ -635,7 +828,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 if (this.optionsSchema) {
                                     this.options = this.optionsSchema.parse(this.options);
                                 } else if (this.options && Object.keys(this.options).length > 0) {
-                                    throw new Error("Brain '".concat(brainTitle, "' received options but no schema was defined. Use withOptionsSchema() to define a schema for options."));
+                                    throw new Error("Brain '".concat(brainTitle, "' received options but no schema was defined. Use withOptions() to define a schema for options."));
                                 }
                                 return [
                                     3,
@@ -657,18 +850,13 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 });
                                 if (webhookSignal && webhookSignal.type === 'WEBHOOK_RESPONSE') {
                                     webhookResponse = webhookSignal.response;
-                                    // Set currentResponse for step consumption (non-agent webhooks)
+                                    // Set currentResponse for step consumption
                                     this.currentResponse = webhookResponse;
-                                    // Set webhookResponse at the deepest level of the resumeContext tree
-                                    // This is needed for:
-                                    // 1. Agent webhook resumes (via resumeContext.webhookResponse)
-                                    // 2. Nested brain resumes (inner brain accesses via innerResumeContext)
-                                    if (this.resumeContext) {
-                                        deepest = this.resumeContext;
-                                        while(deepest.innerResumeContext){
-                                            deepest = deepest.innerResumeContext;
-                                        }
-                                        deepest.webhookResponse = webhookResponse;
+                                    // Store for propagation to inner brains
+                                    if (this.resume) {
+                                        this.resume = _object_spread_props(_object_spread({}, this.resume), {
+                                            webhookResponse: webhookResponse
+                                        });
                                     }
                                 }
                                 return [
@@ -676,9 +864,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     7
                                 ];
                             case 6:
-                                // Inner brain (no signalProvider): check resumeContext for webhookResponse
-                                // The outer brain will have set this from the signal
-                                webhookResponse = this.findWebhookResponseInResumeContext(this.resumeContext);
+                                // Inner brain (no signalProvider): check for webhookResponse passed from outer brain
+                                webhookResponse = (_this_resume = this.resume) === null || _this_resume === void 0 ? void 0 : _this_resume.webhookResponse;
                                 _state.label = 7;
                             case 7:
                                 if (!webhookResponse) return [
@@ -886,17 +1073,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 // Step Status Event to indicate that the step is running
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(step) {
-                                            var _step_serialized = step.serialized, patch = _step_serialized.patch, rest = _object_without_properties(_step_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 28:
                                 _state.sent();
@@ -917,17 +1094,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 // Step Status Event
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(step) {
-                                            var _step_serialized = step.serialized, patch = _step_serialized.patch, rest = _object_without_properties(_step_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 30:
                                 _state.sent();
@@ -980,17 +1147,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 // Step Status Event
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(step) {
-                                            var _step_serialized = step.serialized, patch = _step_serialized.patch, rest = _object_without_properties(_step_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 35:
                                 _state.sent();
@@ -1004,6 +1161,39 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "stepStatusEvent",
+            value: function stepStatusEvent() {
+                return {
+                    type: BRAIN_EVENTS.STEP_STATUS,
+                    steps: this.steps.map(function(s) {
+                        var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
+                            "patch"
+                        ]);
+                        return rest;
+                    }),
+                    options: this.options,
+                    brainRunId: this.brainRunId
+                };
+            }
+        },
+        {
+            key: "innerBrainParams",
+            get: /** Params forwarded to inner brain runs (nested .brain() and .map() steps). */ function get() {
+                return {
+                    resources: this.resources,
+                    client: this.client,
+                    currentUser: this.currentUser,
+                    env: this.env,
+                    brainRunId: this.brainRunId,
+                    governor: this.governor,
+                    files: this.files,
+                    pages: this.pages,
+                    storeProvider: this.storeProvider,
+                    pluginConfigs: this.pluginConfigs
+                };
+            }
+        },
         {
             key: "buildStepContext",
             value: function buildStepContext(step) {
@@ -1017,35 +1207,36 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                     page: this.currentPage,
                     pages: this.pages,
                     env: this.env,
-                    memory: this.scopedMemory,
+                    components: this.components,
                     store: this.store,
+                    files: this.files,
                     currentUser: this.currentUser,
                     brainRunId: this.brainRunId,
                     stepId: step.id
-                }, this.services);
+                }, this.pluginInjections);
             }
         },
         {
             key: "executeStep",
             value: function executeStep(step) {
                 return _wrap_async_generator(function() {
-                    var block, stepBlock, _this_resumeContext, brainBlock, initialState, innerResumeContext, patches, innerBrainPaused, _this_options, _this_options1, innerRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err, _innerResumeContext_state, baseState, innerState, prevState, _, agentBlock, prevState1, prevState2, stepBlock1, stepClient, _this_options2, result;
+                    var block, stepBlock, _this_resume, brainBlock, initialState, innerOptions, innerStack, hasInnerResume, innerEntry, remainingStack, patches, innerBrainPaused, innerRun, innerDepth, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err1, _innerEntry_state, baseState, innerState, prevState, prevState1, stepBlock1, stepClient, channel, context, _this_options, wrappedFiles, stepDone, stepResult, stepError, stepPromise, _iteratorNormalCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, event1, err, _iteratorNormalCompletion1, _didIteratorError2, _iteratorError2, _iterator2, _step2, event2, err, result;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 block = step.block;
                                 if (!(block.type === 'step')) return [
                                     3,
-                                    4
+                                    2
                                 ];
                                 stepBlock = block;
-                                if (!stepBlock.isUIStep) return [
+                                if (!stepBlock.isPageStep) return [
                                     3,
                                     2
                                 ];
                                 return [
                                     5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeUIStep(step, stepBlock))))
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executePageStep(step, stepBlock))))
                                 ];
                             case 1:
                                 _state.sent();
@@ -1053,13 +1244,13 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     2
                                 ];
                             case 2:
-                                if (!stepBlock.iterateConfig) return [
+                                if (!(block.type === 'prompt')) return [
                                     3,
                                     4
                                 ];
                                 return [
                                     5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeIteratePrompt(step))))
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executePrompt(step))))
                                 ];
                             case 3:
                                 _state.sent();
@@ -1067,18 +1258,13 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     2
                                 ];
                             case 4:
-                                if (!(block.type === 'brain')) return [
-                                    3,
-                                    22
-                                ];
-                                brainBlock = block;
-                                if (!brainBlock.iterateConfig) return [
+                                if (!(block.type === 'map')) return [
                                     3,
                                     6
                                 ];
                                 return [
                                     5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeIterateBrain(step))))
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeMap(step))))
                                 ];
                             case 5:
                                 _state.sent();
@@ -1086,34 +1272,43 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     2
                                 ];
                             case 6:
-                                initialState = typeof brainBlock.initialState === 'function' ? brainBlock.initialState(this.currentState) : brainBlock.initialState;
-                                // Check if we're resuming and if there's an inner resume context
-                                innerResumeContext = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.innerResumeContext;
+                                if (!(block.type === 'brain')) return [
+                                    3,
+                                    21
+                                ];
+                                brainBlock = block;
+                                initialState = brainBlock.initialState ? typeof brainBlock.initialState === 'function' ? brainBlock.initialState(this.buildStepContext(step)) : brainBlock.initialState : {};
+                                innerOptions = brainBlock.options ? typeof brainBlock.options === 'function' ? brainBlock.options(this.buildStepContext(step)) : brainBlock.options : {};
+                                // Check if we're resuming an inner brain
+                                innerStack = (_this_resume = this.resume) === null || _this_resume === void 0 ? void 0 : _this_resume.innerStack;
+                                hasInnerResume = innerStack && innerStack.length > 0;
+                                innerEntry = hasInnerResume ? innerStack[0] : undefined;
+                                remainingStack = hasInnerResume ? innerStack.slice(1) : undefined;
                                 // Run inner brain and yield all its events
                                 // Pass brainRunId so inner brain shares outer brain's run ID
                                 patches = [];
                                 innerBrainPaused = false;
-                                innerRun = innerResumeContext ? brainBlock.innerBrain.run({
-                                    resources: this.resources,
-                                    client: this.client,
-                                    currentUser: this.currentUser,
-                                    resumeContext: innerResumeContext,
-                                    options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                    pages: this.pages,
-                                    env: this.env,
-                                    brainRunId: this.brainRunId,
-                                    governor: this.governor
-                                }) : brainBlock.innerBrain.run({
-                                    resources: this.resources,
-                                    client: this.client,
-                                    currentUser: this.currentUser,
+                                innerRun = hasInnerResume ? brainBlock.innerBrain.run(_object_spread_props(_object_spread({}, this.innerBrainParams), {
+                                    resume: _object_spread_props(_object_spread({}, this.resume), {
+                                        state: innerEntry.state,
+                                        stepIndex: innerEntry.stepIndex,
+                                        innerStack: (remainingStack === null || remainingStack === void 0 ? void 0 : remainingStack.length) ? remainingStack : undefined
+                                    }),
+                                    options: innerOptions
+                                })) : brainBlock.innerBrain.run(_object_spread_props(_object_spread({}, this.innerBrainParams), {
                                     initialState: initialState,
-                                    options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
-                                    pages: this.pages,
-                                    env: this.env,
-                                    brainRunId: this.brainRunId,
-                                    governor: this.governor
-                                });
+                                    options: innerOptions
+                                }));
+                                // Context has been forwarded to the inner brain — clear so outer
+                                // brain's later steps don't consume them.
+                                if (hasInnerResume) {
+                                    this.resume = undefined;
+                                }
+                                // Track nesting depth so we only collect patches from the direct
+                                // child brain (depth 1) and ignore patches from deeper nested brains
+                                // (e.g. inner brains run by .map() or nested .brain() steps).
+                                // Resumed brains skip their START event, so start at depth 1.
+                                innerDepth = hasInnerResume ? 1 : 0;
                                 _iteratorAbruptCompletion = false, _didIteratorError = false;
                                 _state.label = 7;
                             case 7:
@@ -1143,19 +1338,29 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 ];
                             case 10:
                                 _state.sent(); // Forward all inner brain events
-                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
+                                if (event.type === BRAIN_EVENTS.START) {
+                                    innerDepth++;
+                                }
+                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE && innerDepth === 1) {
                                     patches.push(event.patch);
                                 }
                                 // If inner brain yielded a WEBHOOK event, it's pausing
                                 if (event.type === BRAIN_EVENTS.WEBHOOK) {
                                     innerBrainPaused = true;
                                 }
-                                // If inner brain completed, break immediately to prevent hanging
                                 if (event.type === BRAIN_EVENTS.COMPLETE) {
-                                    return [
-                                        3,
-                                        12
-                                    ];
+                                    innerDepth--;
+                                    if (innerDepth === 0) {
+                                        return [
+                                            3,
+                                            12
+                                        ];
+                                    }
+                                }
+                                // Errored brains emit ERROR instead of COMPLETE, so decrement depth
+                                // to keep tracking accurate when errors are caught (e.g. by .map() error handlers)
+                                if (event.type === BRAIN_EVENTS.ERROR) {
+                                    innerDepth--;
                                 }
                                 _state.label = 11;
                             case 11:
@@ -1170,9 +1375,9 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     19
                                 ];
                             case 13:
-                                err = _state.sent();
+                                err1 = _state.sent();
                                 _didIteratorError = true;
-                                _iteratorError = err;
+                                _iteratorError = err1;
                                 return [
                                     3,
                                     19
@@ -1221,90 +1426,187 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 // Apply collected patches to get final inner state
                                 // When resuming, use the resumed state as base; otherwise use initialState
-                                baseState = (_innerResumeContext_state = innerResumeContext === null || innerResumeContext === void 0 ? void 0 : innerResumeContext.state) !== null && _innerResumeContext_state !== void 0 ? _innerResumeContext_state : initialState;
+                                baseState = (_innerEntry_state = innerEntry === null || innerEntry === void 0 ? void 0 : innerEntry.state) !== null && _innerEntry_state !== void 0 ? _innerEntry_state : initialState;
                                 innerState = applyPatches(baseState, patches);
                                 // Get previous state before action
                                 prevState = this.currentState;
-                                // Update state with inner brain results
-                                _ = this;
-                                return [
-                                    4,
-                                    _await_async_generator(brainBlock.action(this.currentState, innerState, this.services))
-                                ];
-                            case 20:
-                                _.currentState = _state.sent();
+                                // Spread inner brain's final state onto outer state
+                                this.currentState = _object_spread({}, this.currentState, innerState);
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
-                            case 21:
+                            case 20:
                                 _state.sent();
                                 return [
                                     3,
-                                    30
+                                    42
                                 ];
+                            case 21:
+                                // Get previous state before action
+                                prevState1 = this.currentState;
+                                stepBlock1 = block;
+                                // Resolve per-step client: if the step has an override, apply governor to it;
+                                // otherwise use the default (already-governed) client
+                                stepClient = stepBlock1.client ? this.governor ? this.governor(stepBlock1.client) : stepBlock1.client : this.client;
+                                // Event channel lets file operations (and potentially other services)
+                                // emit events mid-step. The race loop yields them as they arrive.
+                                // If no events are pushed, the loop resolves immediately with the step.
+                                channel = new EventChannel();
+                                context = this.buildStepContext(step);
+                                wrappedFiles = this.files ? wrapFilesWithEvents(this.files, channel, {
+                                    options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
+                                    brainRunId: this.brainRunId,
+                                    stepTitle: stepBlock1.title
+                                }) : undefined;
+                                stepDone = false;
+                                stepPromise = Promise.resolve(stepBlock1.action(_object_spread(_object_spread_props(_object_spread({}, context), {
+                                    client: stepClient
+                                }), wrappedFiles && {
+                                    files: wrappedFiles
+                                }))).then(function(r) {
+                                    stepDone = true;
+                                    stepResult = r;
+                                }, function(e) {
+                                    stepDone = true;
+                                    stepError = e;
+                                });
+                                _state.label = 22;
                             case 22:
-                                if (!(block.type === 'agent')) return [
-                                    3,
-                                    27
-                                ];
-                                agentBlock = block;
-                                if (!agentBlock.iterateConfig) return [
+                                if (!!stepDone) return [
                                     3,
-                                    24
+                                    32
                                 ];
                                 return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeIterateAgent(step))))
+                                    4,
+                                    _await_async_generator(Promise.race([
+                                        stepPromise,
+                                        channel.wait()
+                                    ]))
                                 ];
                             case 23:
                                 _state.sent();
-                                return [
-                                    2
-                                ];
+                                _iteratorNormalCompletion = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                _state.label = 24;
                             case 24:
-                                prevState1 = this.currentState;
+                                _state.trys.push([
+                                    24,
+                                    29,
+                                    30,
+                                    31
+                                ]);
+                                _iterator1 = channel.drain()[Symbol.iterator]();
+                                _state.label = 25;
+                            case 25:
+                                if (!!(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done)) return [
+                                    3,
+                                    28
+                                ];
+                                event1 = _step1.value;
                                 return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeAgent(step))))
+                                    4,
+                                    event1
                                 ];
-                            case 25:
+                            case 26:
                                 _state.sent();
-                                return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
+                                _state.label = 27;
+                            case 27:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    25
                                 ];
-                            case 26:
-                                _state.sent();
+                            case 28:
                                 return [
                                     3,
-                                    30
+                                    31
                                 ];
-                            case 27:
-                                // Get previous state before action
-                                prevState2 = this.currentState;
-                                stepBlock1 = block;
-                                // Resolve per-step client: if the step has an override, apply governor to it;
-                                // otherwise use the default (already-governed) client
-                                stepClient = stepBlock1.client ? this.governor ? this.governor(stepBlock1.client) : stepBlock1.client : this.client;
+                            case 29:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                                return [
+                                    3,
+                                    31
+                                ];
+                            case 30:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 31:
+                                return [
+                                    3,
+                                    22
+                                ];
+                            case 32:
+                                _iteratorNormalCompletion1 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                _state.label = 33;
+                            case 33:
+                                _state.trys.push([
+                                    33,
+                                    38,
+                                    39,
+                                    40
+                                ]);
+                                _iterator2 = channel.drain()[Symbol.iterator]();
+                                _state.label = 34;
+                            case 34:
+                                if (!!(_iteratorNormalCompletion1 = (_step2 = _iterator2.next()).done)) return [
+                                    3,
+                                    37
+                                ];
+                                event2 = _step2.value;
                                 return [
                                     4,
-                                    _await_async_generator(Promise.resolve(stepBlock1.action(_object_spread({
-                                        state: this.currentState,
-                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
-                                        client: stepClient,
-                                        resources: this.resources,
-                                        response: this.currentResponse,
-                                        page: this.currentPage,
-                                        pages: this.pages,
-                                        env: this.env,
-                                        memory: this.scopedMemory,
-                                        store: this.store,
-                                        currentUser: this.currentUser
-                                    }, this.services))))
+                                    event2
                                 ];
-                            case 28:
-                                result = _state.sent();
+                            case 35:
+                                _state.sent();
+                                _state.label = 36;
+                            case 36:
+                                _iteratorNormalCompletion1 = true;
+                                return [
+                                    3,
+                                    34
+                                ];
+                            case 37:
+                                return [
+                                    3,
+                                    40
+                                ];
+                            case 38:
+                                err = _state.sent();
+                                _didIteratorError2 = true;
+                                _iteratorError2 = err;
+                                return [
+                                    3,
+                                    40
+                                ];
+                            case 39:
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator2.return != null) {
+                                        _iterator2.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError2) {
+                                        throw _iteratorError2;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 40:
+                                if (stepError) throw stepError;
+                                result = stepResult;
                                 // Extract state from result (handles promptResponse case)
                                 if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
                                     this.currentState = result.state;
@@ -1313,9 +1615,9 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 return [
                                     5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState2))))
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
                                 ];
-                            case 29:
+                            case 41:
                                 _state.sent();
                                 // Handle promptResponse - set currentResponse for next step
                                 if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
@@ -1323,8 +1625,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 // Reset currentPage after step consumes it (page is ephemeral)
                                 this.currentPage = undefined;
-                                _state.label = 30;
-                            case 30:
+                                _state.label = 42;
+                            case 42:
                                 return [
                                     2
                                 ];
@@ -1334,1059 +1636,934 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "executeAgent",
-            value: function executeAgent(step) {
+            key: "executePrompt",
+            value: /**
+   * Execute a prompt step. Either single-shot (generateObject) or
+   * iterative tool-calling loop (generateText) when `loop` is present.
+   */ function executePrompt(step) {
                 return _wrap_async_generator(function() {
-                    var _this_resumeContext, _this_resumeContext1, block, prevState, _this_defaultTools, _this_extraTools, allTools, _this_components, components, _this_options, config, _config_tools, mergedTools, _config_outputSchema, schema, name, responseMessages, initialMessages, agentContext, webhookResponse, _agentContext_stepId, effectiveStepId, _this_options1, _this_options2, userMessage, toolResultMessage, _this_options3, userMessage1, _config_prompt, prompt, _this_options4, totalTokens, iteration, _config_maxIterations, maxIterations, _response_responseMessages, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, userMessage2, _this_options5, err, _this_options6, toolsForClient, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value, name1, toolDef, tool, description, componentList, systemPrompt, response, newAssistantMessage, _this_options7, tokensThisIteration, _this_options8, _this_options9, _this_options10, pendingWebhook, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, toolCall, _this_options11, tool1, _this_options12, parsed, _this_options13, toolContext, toolResult, waitForResult, webhooks, _this_options14, placeholderMessage, _this_options15, toolResultMessage1, _this_options16, err, _this_options17, _this_options18;
+                    var block, prevState, config, client, prompt, system, _tmp, attachments, _tmp1, result, loopGen, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 block = step.block;
-                                prevState = this.currentState;
-                                // Combine default tools and extra tools for injection into configFn
-                                allTools = _object_spread({}, (_this_defaultTools = this.defaultTools) !== null && _this_defaultTools !== void 0 ? _this_defaultTools : {}, (_this_extraTools = this.extraTools) !== null && _this_extraTools !== void 0 ? _this_extraTools : {});
-                                components = (_this_components = this.components) !== null && _this_components !== void 0 ? _this_components : {};
+                                prevState = clone(this.currentState);
                                 return [
                                     4,
-                                    _await_async_generator(block.configFn(_object_spread({
-                                        state: this.currentState,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                        tools: allTools,
-                                        components: components,
-                                        client: this.client,
-                                        resources: this.resources,
-                                        response: this.currentResponse,
-                                        page: this.currentPage,
-                                        pages: this.pages,
-                                        env: this.env,
-                                        memory: this.scopedMemory,
-                                        store: this.store,
-                                        currentUser: this.currentUser
-                                    }, this.services)))
+                                    _await_async_generator(block.configFn(this.buildStepContext(step)))
                                 ];
                             case 1:
                                 config = _state.sent();
-                                // Reset currentPage after configFn consumes it (page is ephemeral)
-                                this.currentPage = undefined;
-                                // Merge tools: step tools override defaults + extras
-                                mergedTools = _object_spread({}, allTools, (_config_tools = config.tools) !== null && _config_tools !== void 0 ? _config_tools : {});
-                                // Always generate a 'done' terminal tool for every agent
-                                // If outputSchema is provided, use that schema; otherwise use defaultDoneSchema
-                                if (config.outputSchema) {
-                                    _config_outputSchema = config.outputSchema, schema = _config_outputSchema.schema, name = _config_outputSchema.name;
-                                    mergedTools['done'] = {
-                                        description: "Signal that the task is complete and provide the final ".concat(name, " result.\n\nPURPOSE: End agent execution and return structured output to the calling system.\n\nBEHAVIOR:\n- This is a TERMINAL tool - calling it immediately ends the agent\n- No further tools will execute after this\n- No further iterations will occur\n- The input you provide becomes the agent's final output\n\nWHEN TO CALL:\n- When you have completed the assigned task\n- When you have gathered all required information\n- When you have the final answer or result ready\n\nDO NOT CALL IF:\n- You still need to gather more information\n- You are waiting for user input (use waitForWebhook instead)\n- The task is not yet complete\n\nThe schema for this result is: ").concat(name),
-                                        inputSchema: schema,
-                                        terminal: true
-                                    };
-                                } else {
-                                    mergedTools['done'] = {
-                                        description: "Signal that the task is complete and provide a summary of what was accomplished.\n\nPURPOSE: End agent execution and return a result string to the calling system.\n\nBEHAVIOR:\n- This is a TERMINAL tool - calling it immediately ends the agent\n- No further tools will execute after this\n- No further iterations will occur\n- The result string you provide becomes the agent's final output\n\nWHEN TO CALL:\n- When you have completed the assigned task\n- When you have gathered all required information\n- When you have the final answer ready to report\n\nDO NOT CALL IF:\n- You still need to gather more information\n- You are waiting for user input (use waitForWebhook instead)\n- The task is not yet complete\n\nProvide a clear, concise summary of the outcome in the 'result' field.",
-                                        inputSchema: defaultDoneSchema,
-                                        terminal: true
-                                    };
-                                }
-                                // Check if we're resuming from a previous agent execution
-                                agentContext = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.agentContext;
-                                webhookResponse = (_this_resumeContext1 = this.resumeContext) === null || _this_resumeContext1 === void 0 ? void 0 : _this_resumeContext1.webhookResponse;
-                                // Use preserved stepId from agentContext when resuming, or step.id for fresh start
-                                // This ensures all events for the same agent use the same stepId across resumes
-                                effectiveStepId = (_agentContext_stepId = agentContext === null || agentContext === void 0 ? void 0 : agentContext.stepId) !== null && _agentContext_stepId !== void 0 ? _agentContext_stepId : step.id;
-                                if (!agentContext) return [
-                                    3,
-                                    9
-                                ];
-                                if (!(webhookResponse && agentContext.pendingToolCallId && agentContext.pendingToolName)) return [
-                                    3,
-                                    7
-                                ];
-                                // WEBHOOK RESUME: Agent was waiting for a webhook response
-                                // Emit WEBHOOK_RESPONSE event to record the response
+                                client = config.client ? this.governor ? this.governor(config.client) : config.client : this.client;
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.WEBHOOK_RESPONSE,
-                                        response: webhookResponse,
-                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
-                                        brainRunId: this.brainRunId
-                                    }
+                                    _await_async_generator(resolveTemplate(config.message, this.templateContext))
                                 ];
                             case 2:
-                                _state.sent();
-                                // Emit AGENT_TOOL_RESULT for the pending tool (webhook response injected as tool result)
+                                prompt = _state.sent();
+                                if (!config.system) return [
+                                    3,
+                                    4
+                                ];
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_TOOL_RESULT,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        toolCallId: agentContext.pendingToolCallId,
-                                        toolName: agentContext.pendingToolName,
-                                        result: webhookResponse,
-                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
-                                        brainRunId: this.brainRunId
-                                    }
+                                    _await_async_generator(resolveTemplate(config.system, this.templateContext))
                                 ];
                             case 3:
-                                _state.sent();
-                                // Use restored responseMessages from the agent context (preserves providerOptions)
-                                // Prepend the user message and append the webhook response
-                                // Note: reconstructed messages don't include the placeholder (we don't emit events for it),
-                                // so we just append the real webhook response here.
-                                userMessage = {
-                                    role: 'user',
-                                    content: agentContext.prompt
-                                };
-                                if (!this.client.createToolResultMessage) return [
+                                _tmp = _state.sent();
+                                return [
                                     3,
                                     5
                                 ];
-                                toolResultMessage = this.client.createToolResultMessage(agentContext.pendingToolCallId, agentContext.pendingToolName, webhookResponse);
-                                responseMessages = [
-                                    userMessage
-                                ].concat(_to_consumable_array(agentContext.responseMessages), [
-                                    toolResultMessage
-                                ]);
-                                // Emit event for this tool result message (for reconstruction if there's another pause)
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        iteration: 0,
-                                        message: toolResultMessage,
-                                        options: (_this_options3 = this.options) !== null && _this_options3 !== void 0 ? _this_options3 : {},
-                                        brainRunId: this.brainRunId
-                                    }
-                                ];
                             case 4:
-                                _state.sent();
-                                return [
+                                _tmp = undefined;
+                                _state.label = 5;
+                            case 5:
+                                system = _tmp;
+                                if (!!config.loop) return [
                                     3,
-                                    6
+                                    11
+                                ];
+                                if (!config.attachments) return [
+                                    3,
+                                    7
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(Promise.all(config.attachments.map(function(handle) {
+                                        return _async_to_generator(function() {
+                                            var _tmp;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        _tmp = {
+                                                            name: handle.name,
+                                                            mimeType: guessMimeType(handle.name)
+                                                        };
+                                                        return [
+                                                            4,
+                                                            handle.readBytes()
+                                                        ];
+                                                    case 1:
+                                                        return [
+                                                            2,
+                                                            (_tmp.data = _state.sent(), _tmp)
+                                                        ];
+                                                }
+                                            });
+                                        })();
+                                    })))
                                 ];
-                            case 5:
-                                // Fallback if client doesn't support createToolResultMessage
-                                responseMessages = [
-                                    userMessage
-                                ].concat(_to_consumable_array(agentContext.responseMessages));
-                                _state.label = 6;
                             case 6:
-                                // Set empty initial messages since user message is in responseMessages
-                                initialMessages = [];
+                                _tmp1 = _state.sent();
                                 return [
                                     3,
                                     8
                                 ];
                             case 7:
-                                // PAUSE RESUME: Agent was paused mid-execution (no pending webhook)
-                                // Restore conversation history and continue from where we left off
-                                userMessage1 = {
-                                    role: 'user',
-                                    content: agentContext.prompt
-                                };
-                                responseMessages = [
-                                    userMessage1
-                                ].concat(_to_consumable_array(agentContext.responseMessages));
-                                initialMessages = [];
+                                _tmp1 = undefined;
                                 _state.label = 8;
                             case 8:
-                                // Clear the resume context so it's only used once
-                                this.resumeContext = undefined;
+                                attachments = _tmp1;
                                 return [
-                                    3,
-                                    11
+                                    4,
+                                    _await_async_generator(client.generateObject({
+                                        schema: config.outputSchema,
+                                        prompt: prompt,
+                                        system: system,
+                                        attachments: attachments
+                                    }))
                                 ];
                             case 9:
-                                // Use "Begin." as default prompt if not provided
-                                prompt = (_config_prompt = config.prompt) !== null && _config_prompt !== void 0 ? _config_prompt : 'Begin.';
-                                // Emit agent start event (only for fresh starts)
+                                result = _state.sent();
+                                this.currentState = _object_spread({}, this.currentState, result.object);
                                 return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_START,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        prompt: prompt,
-                                        system: config.system,
-                                        tools: Object.keys(mergedTools),
-                                        options: (_this_options4 = this.options) !== null && _this_options4 !== void 0 ? _this_options4 : {},
-                                        brainRunId: this.brainRunId
-                                    }
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
                             case 10:
                                 _state.sent();
-                                // Initialize messages for fresh start
-                                initialMessages = [
-                                    {
-                                        role: 'user',
-                                        content: prompt
-                                    }
+                                return [
+                                    2
                                 ];
-                                _state.label = 11;
                             case 11:
-                                // Initialize token tracking
-                                totalTokens = 0;
-                                iteration = 0;
-                                maxIterations = (_config_maxIterations = config.maxIterations) !== null && _config_maxIterations !== void 0 ? _config_maxIterations : 100;
+                                // Loop path: tool-calling iteration
+                                loopGen = this.runPromptLoop({
+                                    step: step,
+                                    prompt: prompt,
+                                    system: system,
+                                    client: client,
+                                    outputSchema: config.outputSchema,
+                                    loopConfig: config.loop,
+                                    allowWebhookSuspension: true,
+                                    resume: this.resume
+                                });
+                                _iteratorAbruptCompletion = false, _didIteratorError = false;
                                 _state.label = 12;
                             case 12:
-                                if (!true) return [
-                                    3,
-                                    55
-                                ];
-                                iteration++;
-                                if (!this.signalProvider) return [
-                                    3,
-                                    26
-                                ];
+                                _state.trys.push([
+                                    12,
+                                    18,
+                                    19,
+                                    24
+                                ]);
+                                _iterator = _async_iterator(loopGen);
+                                _state.label = 13;
+                            case 13:
                                 return [
                                     4,
-                                    _await_async_generator(this.signalProvider.getSignals('ALL'))
+                                    _await_async_generator(_iterator.next())
                                 ];
-                            case 13:
-                                signals = _state.sent();
-                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                _state.label = 14;
                             case 14:
-                                _state.trys.push([
-                                    14,
-                                    24,
-                                    25,
-                                    26
-                                ]);
-                                _iterator = signals[Symbol.iterator]();
-                                _state.label = 15;
-                            case 15:
-                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
-                                    3,
-                                    23
-                                ];
-                                signal = _step.value;
-                                if (!(signal.type === 'KILL')) return [
+                                if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
                                     3,
                                     17
                                 ];
+                                _value = _step.value;
+                                event = _value;
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.CANCELLED,
-                                        status: STATUS.CANCELLED,
-                                        brainTitle: this.title,
-                                        brainDescription: this.description,
-                                        brainRunId: this.brainRunId,
-                                        options: this.options
-                                    }
+                                    event
                                 ];
-                            case 16:
+                            case 15:
                                 _state.sent();
-                                return [
+                                // If the loop caused a pause/cancel/webhook, stop
+                                if (this.stopped) return [
                                     2
                                 ];
-                            case 17:
-                                if (!(signal.type === 'PAUSE')) return [
+                                if (event.type === BRAIN_EVENTS.WEBHOOK) return [
+                                    2
+                                ];
+                                _state.label = 16;
+                            case 16:
+                                _iteratorAbruptCompletion = false;
+                                return [
                                     3,
-                                    19
+                                    13
                                 ];
+                            case 17:
                                 return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.PAUSED,
-                                        status: STATUS.PAUSED,
-                                        brainTitle: this.title,
-                                        brainDescription: this.description,
-                                        brainRunId: this.brainRunId,
-                                        options: this.options
-                                    }
+                                    3,
+                                    24
                                 ];
                             case 18:
-                                _state.sent();
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
                                 return [
-                                    2
+                                    3,
+                                    24
                                 ];
                             case 19:
-                                if (!(signal.type === 'USER_MESSAGE')) return [
+                                _state.trys.push([
+                                    19,
+                                    ,
+                                    22,
+                                    23
+                                ]);
+                                if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
                                     3,
-                                    22
+                                    21
                                 ];
-                                // Emit event for user message injection
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_USER_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        content: signal.content,
-                                        options: this.options,
-                                        brainRunId: this.brainRunId
-                                    }
+                                    _await_async_generator(_iterator.return())
                                 ];
                             case 20:
                                 _state.sent();
-                                // Inject as user message into conversation
-                                userMessage2 = {
-                                    role: 'user',
-                                    content: signal.content
-                                };
-                                if (responseMessages) {
-                                    responseMessages = _to_consumable_array(responseMessages).concat([
-                                        userMessage2
-                                    ]);
-                                } else {
-                                    initialMessages = _to_consumable_array(initialMessages).concat([
-                                        {
-                                            role: 'user',
-                                            content: signal.content
-                                        }
-                                    ]);
-                                }
-                                // Emit raw response message event so it shows up in agent chat view
+                                _state.label = 21;
+                            case 21:
                                 return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        iteration: iteration,
-                                        message: userMessage2,
-                                        options: (_this_options5 = this.options) !== null && _this_options5 !== void 0 ? _this_options5 : {},
-                                        brainRunId: this.brainRunId
-                                    }
+                                    3,
+                                    23
                                 ];
-                            case 21:
-                                _state.sent();
-                                _state.label = 22;
                             case 22:
-                                _iteratorNormalCompletion = true;
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
                                 return [
-                                    3,
-                                    15
+                                    7
                                 ];
                             case 23:
                                 return [
-                                    3,
-                                    26
+                                    7
                                 ];
                             case 24:
-                                err = _state.sent();
-                                _didIteratorError = true;
-                                _iteratorError = err;
                                 return [
-                                    3,
-                                    26
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
                             case 25:
-                                try {
-                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                        _iterator.return();
-                                    }
-                                } finally{
-                                    if (_didIteratorError) {
-                                        throw _iteratorError;
-                                    }
-                                }
-                                return [
-                                    7
-                                ];
-                            case 26:
-                                if (!(iteration > maxIterations)) return [
-                                    3,
-                                    28
-                                ];
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_ITERATION_LIMIT,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        iteration: iteration - 1,
-                                        maxIterations: maxIterations,
-                                        totalTokens: totalTokens,
-                                        options: (_this_options6 = this.options) !== null && _this_options6 !== void 0 ? _this_options6 : {},
-                                        brainRunId: this.brainRunId
-                                    }
-                                ];
-                            case 27:
                                 _state.sent();
-                                if (config.outputSchema) {
-                                    throw new Error("Agent hit iteration limit (".concat(maxIterations, ") without producing required '").concat(config.outputSchema.name, "' output"));
-                                }
                                 return [
                                     2
                                 ];
-                            case 28:
-                                // Check if client supports generateText
-                                if (!this.client.generateText) {
-                                    throw new Error('Client does not support generateText. Use a client that implements generateText for agent steps.');
-                                }
-                                // Build tools object for the client (description and inputSchema only)
-                                toolsForClient = {};
-                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "runPromptLoop",
+            value: /**
+   * Shared prompt loop generator. Contains the core iteration logic:
+   * resume handling, signal checks, LLM calls, tool processing, and event emission.
+   *
+   * Yields all PROMPT_* events. When the done tool or a terminal tool fires,
+   * updates this.currentState, yields PROMPT_COMPLETE, and returns.
+   * The caller is responsible for calling completeStep().
+   *
+   * When a webhook suspension occurs and allowWebhookSuspension is true,
+   * yields PROMPT_WEBHOOK + WEBHOOK events and returns. If false, throws.
+   */ function runPromptLoop(params) {
+                return _wrap_async_generator(function() {
+                    var step, prompt, system, client, outputSchema, loopConfig, allowWebhookSuspension, resume, userTools, _loopConfig_maxIterations, maxIterations, maxTokens, _loopConfig_toolChoice, toolChoice, toolDefs, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, tool, componentList, resumeCtx, _resumeCtx_stepId, stepId, stepTitle, initialMessages, responseMessages, totalTokens, iteration, webhookResponse, toolResultMsg, _this_options, _this_options1, _this_options2, signals, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, signal, _this_options3, _this_options4, err, llmResult, tokensThisIteration, _this_options5, _this_options6, _this_options7, _this_options8, pendingWebhook, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, toolCall, toolCallId, toolName, args, _this_options9, parsed, errorMsg, toolResultMsg1, _this_options10, _this_options11, _this_options12, tool1, _this_options13, _this_options14, toolResult, _this_options15, placeholderMsg, toolResultMsg2, _this_options16, err, toolWaitFor, webhooks, serializedWaitFor, _this_options17, _this_options18;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                step = params.step, prompt = params.prompt, system = params.system, client = params.client, outputSchema = params.outputSchema, loopConfig = params.loopConfig, allowWebhookSuspension = params.allowWebhookSuspension, resume = params.resume;
+                                userTools = loopConfig.tools, _loopConfig_maxIterations = loopConfig.maxIterations, maxIterations = _loopConfig_maxIterations === void 0 ? 100 : _loopConfig_maxIterations, maxTokens = loopConfig.maxTokens, _loopConfig_toolChoice = loopConfig.toolChoice, toolChoice = _loopConfig_toolChoice === void 0 ? 'required' : _loopConfig_toolChoice;
+                                // Build tool definitions for the LLM (description + inputSchema only)
+                                toolDefs = {};
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 try {
-                                    for(_iterator1 = Object.entries(mergedTools)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                                        _step_value = _sliced_to_array(_step1.value, 2), name1 = _step_value[0], toolDef = _step_value[1];
-                                        tool = toolDef;
-                                        description = tool.description;
-                                        // Enrich generateUI description with available component information
-                                        if (name1 === 'generateUI' && components && Object.keys(components).length > 0) {
-                                            componentList = Object.entries(components).map(function(param) {
-                                                var _param = _sliced_to_array(param, 2), compName = _param[0], comp = _param[1];
-                                                var desc = comp.description.split('\n')[0]; // First line only
-                                                return "- ".concat(compName, ": ").concat(desc);
-                                            }).join('\n');
-                                            description = "Generate a web page for displaying rich content or collecting user input.\n\nSometimes you need more than simple notifications to communicate with users. This tool creates web pages that can display formatted content, dashboards, or forms to collect information.\n\nAVAILABLE COMPONENTS:\n".concat(componentList, "\n\nRETURNS: { url: string, webhook: { slug: string, identifier: string, token: string } | null }\n- url: The page URL\n- webhook: For forms (hasForm=true), contains slug, identifier, and token that must all be passed to waitForWebhook to pause execution until the user submits the form\n\nIMPORTANT: Users have no way to discover the page URL on their own. After generating a page, you must tell them the URL using whatever communication tools are available.");
-                                        }
-                                        toolsForClient[name1] = {
-                                            description: description,
+                                    for(_iterator = Object.entries(userTools)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], tool = _step_value[1];
+                                        toolDefs[name] = {
+                                            description: tool.description,
                                             inputSchema: tool.inputSchema
                                         };
                                     }
                                 } catch (err) {
-                                    _didIteratorError1 = true;
-                                    _iteratorError1 = err;
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
                                 } finally{
                                     try {
-                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                            _iterator1.return();
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
                                         }
                                     } finally{
-                                        if (_didIteratorError1) {
-                                            throw _iteratorError1;
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
                                         }
                                     }
                                 }
-                                // Prepend default system prompt to user's system prompt
-                                systemPrompt = config.system ? "".concat(DEFAULT_AGENT_SYSTEM_PROMPT, "\n\n").concat(config.system) : DEFAULT_AGENT_SYSTEM_PROMPT;
-                                return [
-                                    4,
-                                    _await_async_generator(this.client.generateText({
-                                        system: systemPrompt,
-                                        messages: initialMessages,
-                                        responseMessages: responseMessages,
-                                        tools: toolsForClient,
-                                        toolChoice: config.toolChoice
-                                    }))
+                                // Enrich generatePage description with available components so the outer
+                                // LLM (which reads tool descriptions to decide how to call them) knows what
+                                // UI components exist. This only matters in the prompt loop — it's the only
+                                // path where an LLM reads tool descriptions. Direct tool.execute() calls
+                                // (e.g., from a regular step) don't need this because they don't go through
+                                // LLM tool selection.
+                                if (toolDefs['generatePage'] && this.components) {
+                                    componentList = Object.entries(this.components).map(function(param) {
+                                        var _param = _sliced_to_array(param, 2), name = _param[0], comp = _param[1];
+                                        return "- ".concat(name, ": ").concat(comp.description.split('\n')[0]);
+                                    }).join('\n');
+                                    toolDefs['generatePage'] = _object_spread_props(_object_spread({}, toolDefs['generatePage']), {
+                                        description: toolDefs['generatePage'].description + "\n\nAvailable UI Components:\n".concat(componentList) + "\n\nIMPORTANT: When generating a page with a form (hasForm=true), the page generator" + " automatically creates a Form component. You do NOT need to include Form in your prompt." + " Just describe the form fields you need and the page generator handles the rest."
+                                    });
+                                }
+                                // Auto-generate 'done' tool from outputSchema
+                                toolDefs['done'] = {
+                                    description: "Signal that the task is complete and provide the final result.\n\nThis is a TERMINAL tool - calling it immediately ends execution.\nNo further tools will execute after this. No further iterations will occur.\nThe input you provide becomes the final output.\n\nCall this when you have completed the assigned task and have the final answer ready.\nDo NOT call if you still need to gather more information.\n\nThe output must conform to the provided schema.",
+                                    inputSchema: outputSchema
+                                };
+                                if (!client.generateText) {
+                                    throw new Error('Client does not support generateText, required for prompt loop in step "'.concat(step.block.title, '"'));
+                                }
+                                if (!client.createToolResultMessage) {
+                                    throw new Error('Client does not support createToolResultMessage, required for prompt loop in step "'.concat(step.block.title, '"'));
+                                }
+                                resumeCtx = resume === null || resume === void 0 ? void 0 : resume.promptLoopContext;
+                                // Preserve stepId across resumes so all events correlate
+                                stepId = (_resumeCtx_stepId = resumeCtx === null || resumeCtx === void 0 ? void 0 : resumeCtx.stepId) !== null && _resumeCtx_stepId !== void 0 ? _resumeCtx_stepId : step.id;
+                                stepTitle = step.block.title;
+                                // Conversation state — restored from resume context or fresh
+                                initialMessages = [
+                                    {
+                                        role: 'user',
+                                        content: prompt
+                                    }
                                 ];
-                            case 29:
-                                response = _state.sent();
-                                // Update responseMessages for next iteration (preserves providerOptions)
-                                responseMessages = response.responseMessages;
-                                // Get the new assistant message (the last one added by generateText)
-                                newAssistantMessage = (_response_responseMessages = response.responseMessages) === null || _response_responseMessages === void 0 ? void 0 : _response_responseMessages.at(-1);
-                                if (!newAssistantMessage) return [
+                                totalTokens = 0;
+                                iteration = 0;
+                                if (!resumeCtx) return [
                                     3,
-                                    31
+                                    3
+                                ];
+                                // Resuming a paused/waiting prompt loop
+                                iteration = resumeCtx.iteration;
+                                totalTokens = resumeCtx.totalTokens;
+                                responseMessages = resumeCtx.responseMessages;
+                                // If resuming from webhook, inject the response as a tool result
+                                webhookResponse = resume === null || resume === void 0 ? void 0 : resume.webhookResponse;
+                                if (!(webhookResponse && resumeCtx.pendingToolCallId && resumeCtx.pendingToolName)) return [
+                                    3,
+                                    2
                                 ];
+                                toolResultMsg = client.createToolResultMessage(resumeCtx.pendingToolCallId, resumeCtx.pendingToolName, webhookResponse);
+                                responseMessages = _to_consumable_array(responseMessages).concat([
+                                    toolResultMsg
+                                ]);
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: resumeCtx.pendingToolName,
+                                        toolCallId: resumeCtx.pendingToolCallId,
+                                        result: webhookResponse,
                                         iteration: iteration,
-                                        message: newAssistantMessage,
-                                        options: (_this_options7 = this.options) !== null && _this_options7 !== void 0 ? _this_options7 : {},
+                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 30:
+                            case 1:
                                 _state.sent();
-                                _state.label = 31;
-                            case 31:
-                                // Track tokens
-                                tokensThisIteration = response.usage.totalTokens;
-                                totalTokens += tokensThisIteration;
-                                // Emit iteration event (after LLM call so we have token info)
+                                _state.label = 2;
+                            case 2:
+                                // Safe to clear: only the block that caused the pause reads this.resume,
+                                // and the main loop already processed webhookResponse/resumed before here
+                                this.resume = undefined;
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                // Fresh start — emit PROMPT_START
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_ITERATION,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        iteration: iteration,
-                                        tokensThisIteration: tokensThisIteration,
-                                        totalTokens: totalTokens,
-                                        options: (_this_options8 = this.options) !== null && _this_options8 !== void 0 ? _this_options8 : {},
+                                        type: BRAIN_EVENTS.PROMPT_START,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        prompt: prompt,
+                                        system: system,
+                                        tools: Object.keys(toolDefs),
+                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 32:
+                            case 4:
                                 _state.sent();
-                                if (!(config.maxTokens && totalTokens > config.maxTokens)) return [
+                                _state.label = 5;
+                            case 5:
+                                if (!true) return [
                                     3,
-                                    34
+                                    51
+                                ];
+                                iteration++;
+                                if (!(iteration > maxIterations)) return [
+                                    3,
+                                    7
                                 ];
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_TOKEN_LIMIT,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        totalTokens: totalTokens,
-                                        maxTokens: config.maxTokens,
-                                        options: (_this_options9 = this.options) !== null && _this_options9 !== void 0 ? _this_options9 : {},
+                                        type: BRAIN_EVENTS.PROMPT_ITERATION_LIMIT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        totalIterations: iteration - 1,
+                                        maxIterations: maxIterations,
+                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 33:
+                            case 6:
                                 _state.sent();
-                                if (config.outputSchema) {
-                                    throw new Error("Agent hit token limit (".concat(config.maxTokens, ") without producing required '").concat(config.outputSchema.name, "' output"));
-                                }
-                                return [
-                                    2
-                                ];
-                            case 34:
-                                if (!response.text) return [
+                                throw new Error("Iteration limit (".concat(maxIterations, ') reached in prompt loop "').concat(stepTitle, '"'));
+                            case 7:
+                                if (!this.signalProvider) return [
                                     3,
-                                    36
+                                    18
                                 ];
-                                // Log assistant messages to console as fallback (users shouldn't rely on this)
-                                console.log("[Assistant] ".concat(response.text));
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        content: response.text,
-                                        options: (_this_options10 = this.options) !== null && _this_options10 !== void 0 ? _this_options10 : {},
-                                        brainRunId: this.brainRunId
-                                    }
+                                    _await_async_generator(this.signalProvider.getSignals('CONTROL'))
                                 ];
-                            case 35:
-                                _state.sent();
-                                _state.label = 36;
-                            case 36:
-                                // If no tool calls, agent is done
-                                if (!response.toolCalls || response.toolCalls.length === 0) {
-                                    return [
-                                        2
-                                    ];
-                                }
-                                // Track pending webhook if any tool returns waitFor
-                                // We process ALL tool calls first, then pause for webhook at the end
-                                pendingWebhook = null;
-                                _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
-                                _state.label = 37;
-                            case 37:
+                            case 8:
+                                signals = _state.sent();
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                _state.label = 9;
+                            case 9:
                                 _state.trys.push([
-                                    37,
-                                    49,
-                                    50,
-                                    51
+                                    9,
+                                    16,
+                                    17,
+                                    18
                                 ]);
-                                _iterator2 = response.toolCalls[Symbol.iterator]();
-                                _state.label = 38;
-                            case 38:
-                                if (!!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) return [
+                                _iterator1 = signals[Symbol.iterator]();
+                                _state.label = 10;
+                            case 10:
+                                if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
                                     3,
-                                    48
+                                    15
                                 ];
-                                toolCall = _step2.value;
+                                signal = _step1.value;
+                                if (!(signal.type === 'KILL')) return [
+                                    3,
+                                    12
+                                ];
+                                this.stopped = true;
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_TOOL_CALL,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        toolName: toolCall.toolName,
-                                        toolCallId: toolCall.toolCallId,
-                                        input: toolCall.args,
-                                        options: (_this_options11 = this.options) !== null && _this_options11 !== void 0 ? _this_options11 : {},
-                                        brainRunId: this.brainRunId
+                                        type: BRAIN_EVENTS.CANCELLED,
+                                        status: STATUS.CANCELLED,
+                                        brainTitle: this.title,
+                                        brainDescription: this.description,
+                                        brainRunId: this.brainRunId,
+                                        options: (_this_options3 = this.options) !== null && _this_options3 !== void 0 ? _this_options3 : {}
                                     }
                                 ];
-                            case 39:
+                            case 11:
                                 _state.sent();
-                                tool1 = mergedTools[toolCall.toolName];
-                                if (!tool1) {
-                                    throw new Error("Unknown tool: ".concat(toolCall.toolName));
-                                }
-                                if (!tool1.terminal) return [
+                                return [
+                                    2
+                                ];
+                            case 12:
+                                if (!(signal.type === 'PAUSE')) return [
                                     3,
-                                    41
+                                    14
                                 ];
+                                this.stopped = true;
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_COMPLETE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        terminalToolName: toolCall.toolName,
-                                        result: toolCall.args,
-                                        totalIterations: iteration,
-                                        totalTokens: totalTokens,
-                                        options: (_this_options12 = this.options) !== null && _this_options12 !== void 0 ? _this_options12 : {},
-                                        brainRunId: this.brainRunId
+                                        type: BRAIN_EVENTS.PAUSED,
+                                        status: STATUS.PAUSED,
+                                        brainTitle: this.title,
+                                        brainDescription: this.description,
+                                        brainRunId: this.brainRunId,
+                                        options: (_this_options4 = this.options) !== null && _this_options4 !== void 0 ? _this_options4 : {}
                                     }
                                 ];
-                            case 40:
+                            case 13:
                                 _state.sent();
-                                // Merge terminal result into state
-                                // Only namespace under outputSchema.name when 'done' tool is called with outputSchema
-                                if (config.outputSchema && toolCall.toolName === 'done') {
-                                    parsed = config.outputSchema.schema.safeParse(toolCall.args);
-                                    if (!parsed.success) {
-                                        throw new Error("Agent output does not match outputSchema '".concat(config.outputSchema.name, "': ").concat(parsed.error.message));
-                                    }
-                                    // Namespace result under outputSchema.name
-                                    this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, config.outputSchema.name, parsed.data));
-                                } else {
-                                    // Default behavior: spread into state root (for other terminal tools)
-                                    this.currentState = _object_spread({}, this.currentState, toolCall.args);
-                                }
                                 return [
                                     2
                                 ];
-                            case 41:
-                                if (!tool1.execute) return [
+                            case 14:
+                                _iteratorNormalCompletion1 = true;
+                                return [
                                     3,
-                                    47
+                                    10
                                 ];
-                                toolContext = {
-                                    state: this.currentState,
-                                    options: (_this_options13 = this.options) !== null && _this_options13 !== void 0 ? _this_options13 : {},
-                                    client: this.client,
-                                    resources: this.resources,
-                                    response: this.currentResponse,
-                                    page: this.currentPage,
-                                    pages: this.pages,
-                                    env: this.env,
-                                    components: this.components,
-                                    brainRunId: this.brainRunId,
-                                    stepId: effectiveStepId,
-                                    memory: this.scopedMemory,
-                                    store: this.store,
-                                    currentUser: this.currentUser
-                                };
+                            case 15:
                                 return [
-                                    4,
-                                    _await_async_generator(tool1.execute(toolCall.args, toolContext))
-                                ];
-                            case 42:
-                                toolResult = _state.sent();
-                                if (!(toolResult && (typeof toolResult === "undefined" ? "undefined" : _type_of(toolResult)) === 'object' && 'waitFor' in toolResult)) return [
                                     3,
-                                    44
-                                ];
-                                waitForResult = toolResult;
-                                // Normalize waitFor to array (supports single or multiple webhooks)
-                                webhooks = Array.isArray(waitForResult.waitFor) ? waitForResult.waitFor : [
-                                    waitForResult.waitFor
+                                    18
                                 ];
-                                // Store webhook info - we'll emit the events after processing all tool calls
-                                // This ensures all other tool results are processed before pausing
-                                pendingWebhook = {
-                                    toolCallId: toolCall.toolCallId,
-                                    toolName: toolCall.toolName,
-                                    input: toolCall.args,
-                                    webhooks: webhooks.map(function(w) {
-                                        return {
-                                            slug: w.slug,
-                                            identifier: w.identifier,
-                                            token: w.token
-                                        };
-                                    }),
-                                    timeout: waitForResult.timeout
-                                };
-                                // Emit tool result event for debugging/visibility (with pending status)
+                            case 16:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
                                 return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.AGENT_TOOL_RESULT,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        toolName: toolCall.toolName,
-                                        toolCallId: toolCall.toolCallId,
-                                        result: {
-                                            status: 'waiting_for_webhook',
-                                            webhooks: pendingWebhook.webhooks
-                                        },
-                                        options: (_this_options14 = this.options) !== null && _this_options14 !== void 0 ? _this_options14 : {},
+                                    3,
+                                    18
+                                ];
+                            case 17:
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 18:
+                                return [
+                                    4,
+                                    _await_async_generator(client.generateText({
+                                        system: system,
+                                        messages: iteration === 1 ? initialMessages : [],
+                                        responseMessages: responseMessages,
+                                        tools: toolDefs,
+                                        toolChoice: toolChoice
+                                    }))
+                                ];
+                            case 19:
+                                llmResult = _state.sent();
+                                tokensThisIteration = llmResult.usage.totalTokens;
+                                totalTokens += tokensThisIteration;
+                                responseMessages = llmResult.responseMessages;
+                                // Emit raw response message for replay
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_RAW_RESPONSE_MESSAGE,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        iteration: iteration,
+                                        message: llmResult.responseMessages,
+                                        options: (_this_options5 = this.options) !== null && _this_options5 !== void 0 ? _this_options5 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 43:
+                            case 20:
                                 _state.sent();
-                                // Add placeholder to responseMessages locally so the conversation stays valid
-                                // for any subsequent generateText calls in this execution.
-                                // We DON'T emit an event for it - on resume, we reconstruct from events
-                                // and append the real webhook response.
-                                if (this.client.createToolResultMessage && responseMessages) {
-                                    placeholderMessage = this.client.createToolResultMessage(toolCall.toolCallId, toolCall.toolName, {
-                                        status: 'waiting_for_webhook',
-                                        webhooks: pendingWebhook.webhooks
-                                    });
-                                    responseMessages = _to_consumable_array(responseMessages).concat([
-                                        placeholderMessage
-                                    ]);
-                                }
-                                // Continue processing other tool calls - don't return yet
+                                // Emit iteration event
                                 return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_ITERATION,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        iteration: iteration,
+                                        tokensThisIteration: tokensThisIteration,
+                                        totalTokens: totalTokens,
+                                        options: (_this_options6 = this.options) !== null && _this_options6 !== void 0 ? _this_options6 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 21:
+                                _state.sent();
+                                if (!(maxTokens && totalTokens >= maxTokens)) return [
                                     3,
-                                    47
+                                    23
                                 ];
-                            case 44:
-                                // Emit tool result event for debugging/visibility
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_TOOL_RESULT,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        toolName: toolCall.toolName,
-                                        toolCallId: toolCall.toolCallId,
-                                        result: toolResult,
-                                        options: (_this_options15 = this.options) !== null && _this_options15 !== void 0 ? _this_options15 : {},
+                                        type: BRAIN_EVENTS.PROMPT_TOKEN_LIMIT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        totalTokens: totalTokens,
+                                        maxTokens: maxTokens,
+                                        options: (_this_options7 = this.options) !== null && _this_options7 !== void 0 ? _this_options7 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 45:
+                            case 22:
                                 _state.sent();
-                                if (!(this.client.createToolResultMessage && responseMessages)) return [
+                                throw new Error("Token limit (".concat(maxTokens, ') reached in prompt loop "').concat(stepTitle, '"'));
+                            case 23:
+                                if (!llmResult.text) return [
                                     3,
-                                    47
+                                    25
                                 ];
-                                toolResultMessage1 = this.client.createToolResultMessage(toolCall.toolCallId, toolCall.toolName, toolResult);
-                                responseMessages = _to_consumable_array(responseMessages).concat([
-                                    toolResultMessage1
-                                ]);
-                                // Emit event for this tool result message
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
+                                        type: BRAIN_EVENTS.PROMPT_ASSISTANT_MESSAGE,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        text: llmResult.text,
                                         iteration: iteration,
-                                        message: toolResultMessage1,
-                                        options: (_this_options16 = this.options) !== null && _this_options16 !== void 0 ? _this_options16 : {},
+                                        options: (_this_options8 = this.options) !== null && _this_options8 !== void 0 ? _this_options8 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 46:
+                            case 24:
                                 _state.sent();
-                                _state.label = 47;
-                            case 47:
-                                _iteratorNormalCompletion2 = true;
-                                return [
+                                _state.label = 25;
+                            case 25:
+                                // Check tool calls
+                                if (!llmResult.toolCalls || llmResult.toolCalls.length === 0) {
+                                    if (toolChoice === 'required') {
+                                        throw new Error("LLM did not call any tools with toolChoice 'required' in step \"".concat(stepTitle, '"'));
+                                    }
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                }
+                                // Process tool calls sequentially
+                                pendingWebhook = null;
+                                _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                _state.label = 26;
+                            case 26:
+                                _state.trys.push([
+                                    26,
+                                    45,
+                                    46,
+                                    47
+                                ]);
+                                _iterator2 = llmResult.toolCalls[Symbol.iterator]();
+                                _state.label = 27;
+                            case 27:
+                                if (!!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) return [
                                     3,
-                                    38
+                                    44
                                 ];
-                            case 48:
+                                toolCall = _step2.value;
+                                toolCallId = toolCall.toolCallId, toolName = toolCall.toolName, args = toolCall.args;
+                                // Emit tool call event
                                 return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_CALL,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: toolName,
+                                        toolCallId: toolCallId,
+                                        input: args,
+                                        iteration: iteration,
+                                        options: (_this_options9 = this.options) !== null && _this_options9 !== void 0 ? _this_options9 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 28:
+                                _state.sent();
+                                if (!(toolName === 'done')) return [
                                     3,
-                                    51
+                                    33
                                 ];
-                            case 49:
-                                err = _state.sent();
-                                _didIteratorError2 = true;
-                                _iteratorError2 = err;
-                                return [
+                                parsed = outputSchema.safeParse(args);
+                                if (!!parsed.success) return [
                                     3,
-                                    51
+                                    30
                                 ];
-                            case 50:
-                                try {
-                                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                                        _iterator2.return();
-                                    }
-                                } finally{
-                                    if (_didIteratorError2) {
-                                        throw _iteratorError2;
-                                    }
-                                }
+                                // Feed validation error back to LLM so it can retry
+                                errorMsg = "Invalid output: ".concat(parsed.error.message, ". Please fix and try again.");
+                                toolResultMsg1 = client.createToolResultMessage(toolCallId, 'done', errorMsg);
+                                responseMessages = _to_consumable_array(responseMessages !== null && responseMessages !== void 0 ? responseMessages : []).concat([
+                                    toolResultMsg1
+                                ]);
                                 return [
-                                    7
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: 'done',
+                                        toolCallId: toolCallId,
+                                        result: errorMsg,
+                                        iteration: iteration,
+                                        options: (_this_options10 = this.options) !== null && _this_options10 !== void 0 ? _this_options10 : {},
+                                        brainRunId: this.brainRunId
+                                    }
                                 ];
-                            case 51:
-                                if (!pendingWebhook) return [
+                            case 29:
+                                _state.sent();
+                                return [
                                     3,
-                                    54
-                                ];
-                                // Emit AGENT_WEBHOOK event
+                                    44
+                                ]; // Break to next iteration so LLM can retry
+                            case 30:
+                                // Valid output — merge onto state and complete
+                                this.currentState = _object_spread({}, this.currentState, parsed.data);
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.AGENT_WEBHOOK,
-                                        stepTitle: step.block.title,
-                                        stepId: effectiveStepId,
-                                        toolCallId: pendingWebhook.toolCallId,
-                                        toolName: pendingWebhook.toolName,
-                                        input: pendingWebhook.input,
-                                        options: (_this_options17 = this.options) !== null && _this_options17 !== void 0 ? _this_options17 : {},
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: 'done',
+                                        toolCallId: toolCallId,
+                                        result: parsed.data,
+                                        iteration: iteration,
+                                        options: (_this_options11 = this.options) !== null && _this_options11 !== void 0 ? _this_options11 : {},
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 52:
+                            case 31:
                                 _state.sent();
-                                // Emit WEBHOOK event with all webhooks (first response wins)
                                 return [
                                     4,
-                                    _object_spread_props(_object_spread({
-                                        type: BRAIN_EVENTS.WEBHOOK,
-                                        waitFor: pendingWebhook.webhooks
-                                    }, pendingWebhook.timeout !== undefined && {
-                                        timeout: pendingWebhook.timeout
-                                    }), {
-                                        options: (_this_options18 = this.options) !== null && _this_options18 !== void 0 ? _this_options18 : {},
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_COMPLETE,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        result: parsed.data,
+                                        terminalTool: 'done',
+                                        totalIterations: iteration,
+                                        totalTokens: totalTokens,
+                                        options: (_this_options12 = this.options) !== null && _this_options12 !== void 0 ? _this_options12 : {},
                                         brainRunId: this.brainRunId
-                                    })
+                                    }
                                 ];
-                            case 53:
+                            case 32:
                                 _state.sent();
                                 return [
                                     2
                                 ];
-                            case 54:
-                                return [
+                            case 33:
+                                // Handle user-defined tools
+                                tool1 = userTools[toolName];
+                                if (!tool1) {
+                                    throw new Error('Unknown tool "'.concat(toolName, '" called in step "').concat(stepTitle, '"'));
+                                }
+                                if (!tool1.terminal) return [
                                     3,
-                                    12
+                                    36
                                 ];
-                            case 55:
+                                this.currentState = _object_spread({}, this.currentState, args);
                                 return [
-                                    2
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: toolName,
+                                        toolCallId: toolCallId,
+                                        result: args,
+                                        iteration: iteration,
+                                        options: (_this_options13 = this.options) !== null && _this_options13 !== void 0 ? _this_options13 : {},
+                                        brainRunId: this.brainRunId
+                                    }
                                 ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "executeIteratePrompt",
-            value: /**
-   * Execute an iterate prompt step, yielding one ITERATE_ITEM_COMPLETE
-   * event per item. Between items, checks for PAUSE/KILL signals so
-   * Cloudflare backends can restart the DO to reclaim memory.
-   */ function executeIteratePrompt(step) {
-                return _wrap_async_generator(function() {
-                    var _this_resumeContext, block, iterateConfig, prevState, rawClient, client, items, totalItems, iterateProgress, _iterateProgress_processedCount, startIndex, resultsMap, k, r, i, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, item, result, _this_options1, promptText, response, error, fallback, _this_options2, finalResults;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                block = step.block;
-                                iterateConfig = block.iterateConfig;
-                                prevState = this.currentState;
-                                rawClient = iterateConfig.client;
-                                client = rawClient ? this.governor ? this.governor(rawClient) : rawClient : this.client;
+                            case 34:
+                                _state.sent();
                                 return [
                                     4,
-                                    _await_async_generator(iterateConfig.over(this.buildStepContext(step)))
-                                ];
-                            case 1:
-                                items = _state.sent();
-                                totalItems = items.length;
-                                // Resume support: pick up from where we left off
-                                iterateProgress = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.iterateProgress;
-                                startIndex = (_iterateProgress_processedCount = iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.processedCount) !== null && _iterateProgress_processedCount !== void 0 ? _iterateProgress_processedCount : 0;
-                                // Use a Map for results accumulation during iteration.
-                                resultsMap = new Map();
-                                if (iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.accumulatedResults) {
-                                    for(k = 0; k < iterateProgress.accumulatedResults.length; k++){
-                                        r = iterateProgress.accumulatedResults[k];
-                                        if (r != null) resultsMap.set(k, r);
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_COMPLETE,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        result: args,
+                                        terminalTool: toolName,
+                                        totalIterations: iteration,
+                                        totalTokens: totalTokens,
+                                        options: (_this_options14 = this.options) !== null && _this_options14 !== void 0 ? _this_options14 : {},
+                                        brainRunId: this.brainRunId
                                     }
-                                }
-                                // Clear resumeContext after consuming iterateProgress
-                                if (iterateProgress) {
-                                    this.resumeContext = undefined;
-                                }
-                                i = startIndex;
-                                _state.label = 2;
-                            case 2:
-                                if (!(i < totalItems)) return [
-                                    3,
-                                    20
                                 ];
-                                if (!this.signalProvider) return [
+                            case 35:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 36:
+                                // Execute non-terminal tool
+                                toolResult = void 0;
+                                if (!tool1.execute) return [
                                     3,
-                                    12
+                                    40
                                 ];
                                 return [
                                     4,
-                                    _await_async_generator(this.signalProvider.getSignals('CONTROL'))
-                                ];
-                            case 3:
-                                signals = _state.sent();
-                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                _state.label = 4;
-                            case 4:
-                                _state.trys.push([
-                                    4,
-                                    10,
-                                    11,
-                                    12
-                                ]);
-                                _iterator = signals[Symbol.iterator]();
-                                _state.label = 5;
-                            case 5:
-                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
-                                    3,
-                                    9
+                                    _await_async_generator(tool1.execute(args, this.buildStepContext(step)))
                                 ];
-                                signal = _step.value;
-                                if (!(signal.type === 'KILL')) return [
+                            case 37:
+                                toolResult = _state.sent();
+                                if (!(toolResult && (typeof toolResult === "undefined" ? "undefined" : _type_of(toolResult)) === 'object' && 'waitFor' in toolResult)) return [
                                     3,
-                                    7
+                                    39
                                 ];
-                                this.stopped = true;
+                                if (!allowWebhookSuspension) {
+                                    throw new Error("Webhook/wait inside .map() prompt loop is not supported. " + 'Step "'.concat(step.block.title, '" tool "').concat(toolName, '" triggered a webhook. ') + "Remove webhook-returning tools from the map prompt loop.");
+                                }
+                                pendingWebhook = {
+                                    toolCallId: toolCallId,
+                                    toolName: toolName,
+                                    input: args,
+                                    waitFor: toolResult
+                                };
+                                // Emit tool result with waiting status
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.CANCELLED,
-                                        status: STATUS.CANCELLED,
-                                        brainTitle: this.title,
-                                        brainDescription: this.description,
-                                        brainRunId: this.brainRunId,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {}
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: toolName,
+                                        toolCallId: toolCallId,
+                                        result: 'Waiting for webhook response...',
+                                        iteration: iteration,
+                                        status: 'waiting_for_webhook',
+                                        options: (_this_options15 = this.options) !== null && _this_options15 !== void 0 ? _this_options15 : {},
+                                        brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 6:
+                            case 38:
                                 _state.sent();
-                                return [
-                                    2
-                                ];
-                            case 7:
-                                if (signal.type === 'PAUSE') {
-                                    // Don't yield PAUSED - pausing between iterate items is a backend
-                                    // implementation detail (e.g. Cloudflare DO restart for memory).
-                                    // Just stop execution silently; the backend handles resume.
-                                    this.stopped = true;
-                                    return [
-                                        2
-                                    ];
-                                }
-                                _state.label = 8;
-                            case 8:
-                                _iteratorNormalCompletion = true;
-                                return [
-                                    3,
-                                    5
-                                ];
-                            case 9:
+                                // Add placeholder to conversation
+                                placeholderMsg = client.createToolResultMessage(toolCallId, toolName, 'Waiting for webhook response...');
+                                responseMessages = _to_consumable_array(responseMessages !== null && responseMessages !== void 0 ? responseMessages : []).concat([
+                                    placeholderMsg
+                                ]);
+                                // Continue processing remaining tool calls in this iteration
                                 return [
                                     3,
-                                    12
+                                    43
                                 ];
-                            case 10:
-                                err = _state.sent();
-                                _didIteratorError = true;
-                                _iteratorError = err;
+                            case 39:
                                 return [
                                     3,
-                                    12
-                                ];
-                            case 11:
-                                try {
-                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                        _iterator.return();
-                                    }
-                                } finally{
-                                    if (_didIteratorError) {
-                                        throw _iteratorError;
-                                    }
-                                }
-                                return [
-                                    7
+                                    41
                                 ];
-                            case 12:
-                                item = items[i];
-                                result = void 0;
-                                _state.label = 13;
-                            case 13:
-                                _state.trys.push([
-                                    13,
-                                    16,
-                                    ,
-                                    17
+                            case 40:
+                                toolResult = {
+                                    success: true
+                                };
+                                _state.label = 41;
+                            case 41:
+                                // Feed tool result back to LLM
+                                toolResultMsg2 = client.createToolResultMessage(toolCallId, toolName, toolResult);
+                                responseMessages = _to_consumable_array(responseMessages !== null && responseMessages !== void 0 ? responseMessages : []).concat([
+                                    toolResultMsg2
                                 ]);
                                 return [
                                     4,
-                                    _await_async_generator(iterateConfig.template({
-                                        item: item,
-                                        state: this.currentState,
-                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
-                                        resources: this.resources
-                                    }))
+                                    {
+                                        type: BRAIN_EVENTS.PROMPT_TOOL_RESULT,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolName: toolName,
+                                        toolCallId: toolCallId,
+                                        result: toolResult,
+                                        iteration: iteration,
+                                        options: (_this_options16 = this.options) !== null && _this_options16 !== void 0 ? _this_options16 : {},
+                                        brainRunId: this.brainRunId
+                                    }
                                 ];
-                            case 14:
-                                promptText = _state.sent();
+                            case 42:
+                                _state.sent();
+                                _state.label = 43;
+                            case 43:
+                                _iteratorNormalCompletion2 = true;
                                 return [
-                                    4,
-                                    _await_async_generator(client.generateObject({
-                                        schema: iterateConfig.schema,
-                                        schemaName: iterateConfig.schemaName,
-                                        prompt: promptText
-                                    }))
-                                ];
-                            case 15:
-                                response = _state.sent();
-                                result = [
-                                    item,
-                                    response.object
+                                    3,
+                                    27
                                 ];
+                            case 44:
                                 return [
                                     3,
-                                    17
+                                    47
                                 ];
-                            case 16:
-                                error = _state.sent();
-                                if (iterateConfig.error) {
-                                    fallback = iterateConfig.error(item, error);
-                                    result = fallback !== null ? [
-                                        item,
-                                        fallback
-                                    ] : undefined;
-                                } else {
-                                    throw error;
-                                }
+                            case 45:
+                                err = _state.sent();
+                                _didIteratorError2 = true;
+                                _iteratorError2 = err;
                                 return [
                                     3,
-                                    17
+                                    47
                                 ];
-                            case 17:
-                                if (result != null) {
-                                    resultsMap.set(i, result);
+                            case 46:
+                                try {
+                                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                        _iterator2.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError2) {
+                                        throw _iteratorError2;
+                                    }
                                 }
-                                // Yield one event per item
+                                return [
+                                    7
+                                ];
+                            case 47:
+                                if (!pendingWebhook) return [
+                                    3,
+                                    50
+                                ];
+                                toolWaitFor = pendingWebhook.waitFor;
+                                webhooks = Array.isArray(toolWaitFor.waitFor) ? toolWaitFor.waitFor : [
+                                    toolWaitFor.waitFor
+                                ];
+                                serializedWaitFor = webhooks.map(function(registration) {
+                                    return {
+                                        slug: registration.slug,
+                                        identifier: registration.identifier,
+                                        token: registration.token
+                                    };
+                                });
+                                // Emit prompt-level webhook event
                                 return [
                                     4,
                                     {
-                                        type: BRAIN_EVENTS.ITERATE_ITEM_COMPLETE,
-                                        stepTitle: step.block.title,
-                                        stepId: step.id,
-                                        itemIndex: i,
-                                        item: item,
-                                        result: result ? result[1] : undefined,
-                                        processedCount: i + 1,
-                                        totalItems: totalItems,
-                                        schemaName: iterateConfig.schemaName,
-                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
-                                        brainRunId: this.brainRunId,
-                                        canRelease: !!this.signalProvider
+                                        type: BRAIN_EVENTS.PROMPT_WEBHOOK,
+                                        stepTitle: stepTitle,
+                                        stepId: stepId,
+                                        toolCallId: pendingWebhook.toolCallId,
+                                        toolName: pendingWebhook.toolName,
+                                        input: pendingWebhook.input,
+                                        options: (_this_options17 = this.options) !== null && _this_options17 !== void 0 ? _this_options17 : {},
+                                        brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 18:
+                            case 48:
+                                _state.sent();
+                                // Emit brain-level webhook event (triggers state machine transition to waiting)
+                                return [
+                                    4,
+                                    _object_spread_props(_object_spread({
+                                        type: BRAIN_EVENTS.WEBHOOK,
+                                        waitFor: serializedWaitFor
+                                    }, toolWaitFor.timeout !== undefined && {
+                                        timeout: toolWaitFor.timeout
+                                    }), {
+                                        options: (_this_options18 = this.options) !== null && _this_options18 !== void 0 ? _this_options18 : {},
+                                        brainRunId: this.brainRunId
+                                    })
+                                ];
+                            case 49:
                                 _state.sent();
-                                _state.label = 19;
-                            case 19:
-                                i++;
                                 return [
-                                    3,
                                     2
                                 ];
-                            case 20:
-                                // All items done - update state and complete step
-                                finalResults = new IterateResult(_to_consumable_array(resultsMap.values()));
-                                this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, iterateConfig.schemaName, finalResults));
+                            case 50:
                                 return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                    3,
+                                    5
                                 ];
-                            case 21:
-                                _state.sent();
+                            case 51:
                                 return [
                                     2
                                 ];
@@ -2396,30 +2573,34 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "executeIterateBrain",
+            key: "executeMap",
             value: /**
-   * Execute a nested brain iterate step. Runs the inner brain once per item
+   * Execute a map step. Runs the inner brain once per item
    * from the `over` list, collects [item, innerState] tuples under `outputKey`.
-   */ function executeIterateBrain(step) {
+   */ function executeMap(step) {
                 return _wrap_async_generator(function() {
-                    var _this_resumeContext, block, iterateConfig, prevState, items, totalItems, iterateProgress, _iterateProgress_processedCount, startIndex, resultsMap, k, r, i, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, item, result, initialState, _this_options1, innerRun, patches, _iteratorAbruptCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value, event, err1, innerState, error, fallback, _this_options2, finalResults, outputResults;
+                    var _this_resume, block, prevState, config, items, totalItems, iterateProgress, _iterateProgress_processedCount, startIndex, resultsMap, k, r, i, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, item, result, prompt, itemSystem, _tmp, _tmp1, client, loopResult, response, initialState, _config_options, mapInnerOptions, innerRun, patches, _iteratorAbruptCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value, event, err1, innerState, error, fallback, _this_options1, finalResults;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 block = step.block;
-                                iterateConfig = block.iterateConfig;
                                 prevState = this.currentState;
                                 return [
                                     4,
-                                    _await_async_generator(iterateConfig.over(this.buildStepContext(step)))
+                                    _await_async_generator(block.configFn(this.buildStepContext(step)))
                                 ];
                             case 1:
+                                config = _state.sent();
+                                return [
+                                    4,
+                                    _await_async_generator(config.over)
+                                ];
+                            case 2:
                                 items = _state.sent();
                                 totalItems = items.length;
                                 // Resume support
-                                iterateProgress = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.iterateProgress;
+                                iterateProgress = (_this_resume = this.resume) === null || _this_resume === void 0 ? void 0 : _this_resume.iterateProgress;
                                 startIndex = (_iterateProgress_processedCount = iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.processedCount) !== null && _iterateProgress_processedCount !== void 0 ? _iterateProgress_processedCount : 0;
-                                // Use a Map for results accumulation during iteration.
                                 resultsMap = new Map();
                                 if (iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.accumulatedResults) {
                                     for(k = 0; k < iterateProgress.accumulatedResults.length; k++){
@@ -2428,45 +2609,45 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     }
                                 }
                                 if (iterateProgress) {
-                                    this.resumeContext = undefined;
+                                    this.resume = undefined;
                                 }
                                 i = startIndex;
-                                _state.label = 2;
-                            case 2:
+                                _state.label = 3;
+                            case 3:
                                 if (!(i < totalItems)) return [
                                     3,
-                                    31
+                                    45
                                 ];
                                 if (!this.signalProvider) return [
                                     3,
-                                    12
+                                    13
                                 ];
                                 return [
                                     4,
                                     _await_async_generator(this.signalProvider.getSignals('CONTROL'))
                                 ];
-                            case 3:
+                            case 4:
                                 signals = _state.sent();
                                 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                _state.label = 4;
-                            case 4:
+                                _state.label = 5;
+                            case 5:
                                 _state.trys.push([
-                                    4,
-                                    10,
+                                    5,
                                     11,
-                                    12
+                                    12,
+                                    13
                                 ]);
                                 _iterator = signals[Symbol.iterator]();
-                                _state.label = 5;
-                            case 5:
+                                _state.label = 6;
+                            case 6:
                                 if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                                     3,
-                                    9
+                                    10
                                 ];
                                 signal = _step.value;
                                 if (!(signal.type === 'KILL')) return [
                                     3,
-                                    7
+                                    8
                                 ];
                                 this.stopped = true;
                                 return [
@@ -2480,39 +2661,39 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {}
                                     }
                                 ];
-                            case 6:
+                            case 7:
                                 _state.sent();
                                 return [
                                     2
                                 ];
-                            case 7:
+                            case 8:
                                 if (signal.type === 'PAUSE') {
                                     this.stopped = true;
                                     return [
                                         2
                                     ];
                                 }
-                                _state.label = 8;
-                            case 8:
+                                _state.label = 9;
+                            case 9:
                                 _iteratorNormalCompletion = true;
                                 return [
                                     3,
-                                    5
+                                    6
                                 ];
-                            case 9:
+                            case 10:
                                 return [
                                     3,
-                                    12
+                                    13
                                 ];
-                            case 10:
+                            case 11:
                                 err = _state.sent();
                                 _didIteratorError = true;
                                 _iteratorError = err;
                                 return [
                                     3,
-                                    12
+                                    13
                                 ];
-                            case 11:
+                            case 12:
                                 try {
                                     if (!_iteratorNormalCompletion && _iterator.return != null) {
                                         _iterator.return();
@@ -2525,62 +2706,145 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 return [
                                     7
                                 ];
-                            case 12:
+                            case 13:
                                 item = items[i];
                                 result = void 0;
-                                _state.label = 13;
-                            case 13:
+                                _state.label = 14;
+                            case 14:
                                 _state.trys.push([
-                                    13,
-                                    27,
+                                    14,
+                                    41,
                                     ,
-                                    28
+                                    42
                                 ]);
-                                initialState = iterateConfig.initialState(item, this.currentState);
-                                innerRun = block.innerBrain.run({
-                                    resources: this.resources,
-                                    client: this.client,
-                                    currentUser: this.currentUser,
+                                if (!config.prompt) return [
+                                    3,
+                                    26
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(resolveTemplate(config.prompt.message(item), this.templateContext))
+                                ];
+                            case 15:
+                                prompt = _state.sent();
+                                if (!config.prompt.system) return [
+                                    3,
+                                    20
+                                ];
+                                if (!(typeof config.prompt.system === 'function')) return [
+                                    3,
+                                    17
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(resolveTemplate(config.prompt.system(item), this.templateContext))
+                                ];
+                            case 16:
+                                _tmp1 = _state.sent();
+                                return [
+                                    3,
+                                    19
+                                ];
+                            case 17:
+                                return [
+                                    4,
+                                    _await_async_generator(resolveTemplate(config.prompt.system, this.templateContext))
+                                ];
+                            case 18:
+                                _tmp1 = _state.sent();
+                                _state.label = 19;
+                            case 19:
+                                _tmp = _tmp1;
+                                return [
+                                    3,
+                                    21
+                                ];
+                            case 20:
+                                _tmp = undefined;
+                                _state.label = 21;
+                            case 21:
+                                itemSystem = _tmp;
+                                client = config.client ? this.governor ? this.governor(config.client) : config.client : this.client;
+                                if (!config.prompt.loop) return [
+                                    3,
+                                    23
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(this.runMapPromptLoop(step, prompt, itemSystem, client, config.prompt.outputSchema, config.prompt.loop))
+                                ];
+                            case 22:
+                                loopResult = _state.sent();
+                                result = [
+                                    item,
+                                    loopResult
+                                ];
+                                return [
+                                    3,
+                                    25
+                                ];
+                            case 23:
+                                return [
+                                    4,
+                                    _await_async_generator(client.generateObject({
+                                        schema: config.prompt.outputSchema,
+                                        prompt: prompt,
+                                        system: itemSystem
+                                    }))
+                                ];
+                            case 24:
+                                response = _state.sent();
+                                result = [
+                                    item,
+                                    response.object
+                                ];
+                                _state.label = 25;
+                            case 25:
+                                return [
+                                    3,
+                                    40
+                                ];
+                            case 26:
+                                // Brain mode: run inner brain per item
+                                initialState = config.initialState(item);
+                                mapInnerOptions = (_config_options = config.options) !== null && _config_options !== void 0 ? _config_options : {};
+                                innerRun = config.run.run(_object_spread_props(_object_spread({}, this.innerBrainParams), {
                                     initialState: initialState,
-                                    options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
-                                    pages: this.pages,
-                                    env: this.env,
-                                    brainRunId: this.brainRunId,
-                                    governor: this.governor
-                                });
+                                    options: mapInnerOptions
+                                }));
                                 patches = [];
                                 _iteratorAbruptCompletion = false, _didIteratorError1 = false;
-                                _state.label = 14;
-                            case 14:
+                                _state.label = 27;
+                            case 27:
                                 _state.trys.push([
-                                    14,
-                                    20,
-                                    21,
-                                    26
+                                    27,
+                                    33,
+                                    34,
+                                    39
                                 ]);
                                 _iterator1 = _async_iterator(innerRun);
-                                _state.label = 15;
-                            case 15:
+                                _state.label = 28;
+                            case 28:
                                 return [
                                     4,
                                     _await_async_generator(_iterator1.next())
                                 ];
-                            case 16:
+                            case 29:
                                 if (!(_iteratorAbruptCompletion = !(_step1 = _state.sent()).done)) return [
                                     3,
-                                    19
+                                    32
                                 ];
                                 _value = _step1.value;
                                 event = _value;
-                                // Throw on WEBHOOK — not supported in iterate (Phase 2)
+                                // Throw on WEBHOOK — not supported in map
                                 if (event.type === BRAIN_EVENTS.WEBHOOK) {
-                                    throw new Error("Webhook/wait inside brain iterate is not supported. " + 'Step "'.concat(block.title, '" item ').concat(i, " triggered a webhook. ") + "Remove .wait() from the inner brain or process items outside of iterate.");
+                                    throw new Error("Webhook/wait inside .map() is not supported. " + 'Step "'.concat(block.title, '" item ').concat(i, " triggered a webhook. ") + "Remove .wait() from the inner brain or process items outside of .map().");
                                 }
                                 return [
                                     4,
                                     event
                                 ];
-                            case 17:
+                            case 30:
                                 _state.sent(); // Forward all inner events
                                 if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
                                     patches.push(event.patch);
@@ -2588,77 +2852,79 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 if (event.type === BRAIN_EVENTS.COMPLETE) {
                                     return [
                                         3,
-                                        19
+                                        32
                                     ];
                                 }
-                                _state.label = 18;
-                            case 18:
+                                _state.label = 31;
+                            case 31:
                                 _iteratorAbruptCompletion = false;
                                 return [
                                     3,
-                                    15
+                                    28
                                 ];
-                            case 19:
+                            case 32:
                                 return [
                                     3,
-                                    26
+                                    39
                                 ];
-                            case 20:
+                            case 33:
                                 err1 = _state.sent();
                                 _didIteratorError1 = true;
                                 _iteratorError1 = err1;
                                 return [
                                     3,
-                                    26
+                                    39
                                 ];
-                            case 21:
+                            case 34:
                                 _state.trys.push([
-                                    21,
+                                    34,
                                     ,
-                                    24,
-                                    25
+                                    37,
+                                    38
                                 ]);
                                 if (!(_iteratorAbruptCompletion && _iterator1.return != null)) return [
                                     3,
-                                    23
+                                    36
                                 ];
                                 return [
                                     4,
                                     _await_async_generator(_iterator1.return())
                                 ];
-                            case 22:
+                            case 35:
                                 _state.sent();
-                                _state.label = 23;
-                            case 23:
+                                _state.label = 36;
+                            case 36:
                                 return [
                                     3,
-                                    25
+                                    38
                                 ];
-                            case 24:
+                            case 37:
                                 if (_didIteratorError1) {
                                     throw _iteratorError1;
                                 }
                                 return [
                                     7
                                 ];
-                            case 25:
+                            case 38:
                                 return [
                                     7
                                 ];
-                            case 26:
+                            case 39:
                                 innerState = applyPatches(initialState, patches);
                                 result = [
                                     item,
                                     innerState
                                 ];
+                                _state.label = 40;
+                            case 40:
                                 return [
                                     3,
-                                    28
+                                    42
                                 ];
-                            case 27:
+                            case 41:
                                 error = _state.sent();
-                                if (iterateConfig.error) {
-                                    fallback = iterateConfig.error(item, error);
+                                if (config.error) {
+                                    fallback = config.error(item, error);
                                     result = fallback !== null ? [
                                         item,
                                         fallback
@@ -2668,9 +2934,9 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 return [
                                     3,
-                                    28
+                                    42
                                 ];
-                            case 28:
+                            case 42:
                                 if (result != null) {
                                     resultsMap.set(i, result);
                                 }
@@ -2685,30 +2951,29 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         result: result ? result[1] : undefined,
                                         processedCount: i + 1,
                                         totalItems: totalItems,
-                                        schemaName: iterateConfig.outputKey,
-                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
+                                        stateKey: block.stateKey,
+                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
                                         brainRunId: this.brainRunId,
                                         canRelease: !!this.signalProvider
                                     }
                                 ];
-                            case 29:
+                            case 43:
                                 _state.sent();
-                                _state.label = 30;
-                            case 30:
+                                _state.label = 44;
+                            case 44:
                                 i++;
                                 return [
                                     3,
-                                    2
+                                    3
                                 ];
-                            case 31:
-                                finalResults = _to_consumable_array(resultsMap.values());
-                                outputResults = new IterateResult(finalResults);
-                                this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, iterateConfig.outputKey, outputResults));
+                            case 45:
+                                finalResults = new IterateResult(_to_consumable_array(resultsMap.values()));
+                                this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, block.stateKey, finalResults));
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
-                            case 32:
+                            case 46:
                                 _state.sent();
                                 return [
                                     2
@@ -2719,310 +2984,101 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "executeIterateAgent",
-            value: /**
-   * Execute an agent config iterate step. Runs the agent once per item
-   * from the `over` list, collects [item, agentResult] tuples under `outputKey`.
-   */ function executeIterateAgent(step) {
+            key: "buildFormAction",
+            value: function buildFormAction(step, formSchema) {
+                var webhookIdentifier = "".concat(this.brainRunId, "-").concat(step.id);
+                var formToken = crypto.randomUUID();
+                var formAction = "".concat(this.env.origin, "/webhooks/system/page-form?identifier=").concat(encodeURIComponent(webhookIdentifier), "&token=").concat(encodeURIComponent(formToken));
+                return {
+                    formAction: formAction,
+                    webhookIdentifier: webhookIdentifier,
+                    formToken: formToken,
+                    formSchema: formSchema
+                };
+            }
+        },
+        {
+            key: "executePageStep",
+            value: function executePageStep(step, stepBlock) {
                 return _wrap_async_generator(function() {
-                    var _this, _loop, _this_resumeContext, block, iterateConfig, prevState, items, totalItems, iterateProgress, _iterateProgress_processedCount, startIndex, resultsMap, k, r, i, _ret, finalResults;
+                    var prevState, pageConfigFn, pageConfig, html, formInfo, body, prompt, _pageConfig_props, data, uiResult, placementCount, placementInfo, _uiResult_text, _pageConfig_persist, pageCreateOptions, page, webhook;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                _loop = function(i) {
-                                    var signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, item, result, savedState, itemConfigFn, tempBlock, tempStep, agentResult, error, fallback, _this_options1;
-                                    return _ts_generator(this, function(_state) {
-                                        switch(_state.label){
-                                            case 0:
-                                                if (!_this.signalProvider) return [
-                                                    3,
-                                                    10
-                                                ];
-                                                return [
-                                                    4,
-                                                    _await_async_generator(_this.signalProvider.getSignals('CONTROL'))
-                                                ];
-                                            case 1:
-                                                signals = _state.sent();
-                                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                                _state.label = 2;
-                                            case 2:
-                                                _state.trys.push([
-                                                    2,
-                                                    8,
-                                                    9,
-                                                    10
-                                                ]);
-                                                _iterator = signals[Symbol.iterator]();
-                                                _state.label = 3;
-                                            case 3:
-                                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
-                                                    3,
-                                                    7
-                                                ];
-                                                signal = _step.value;
-                                                if (!(signal.type === 'KILL')) return [
-                                                    3,
-                                                    5
-                                                ];
-                                                _this.stopped = true;
-                                                return [
-                                                    4,
-                                                    {
-                                                        type: BRAIN_EVENTS.CANCELLED,
-                                                        status: STATUS.CANCELLED,
-                                                        brainTitle: _this.title,
-                                                        brainDescription: _this.description,
-                                                        brainRunId: _this.brainRunId,
-                                                        options: (_this_options = _this.options) !== null && _this_options !== void 0 ? _this_options : {}
-                                                    }
-                                                ];
-                                            case 4:
-                                                _state.sent();
-                                                return [
-                                                    2,
-                                                    {
-                                                        v: void void 0
-                                                    }
-                                                ];
-                                            case 5:
-                                                if (signal.type === 'PAUSE') {
-                                                    _this.stopped = true;
-                                                    return [
-                                                        2,
-                                                        {
-                                                            v: void void 0
-                                                        }
-                                                    ];
-                                                }
-                                                _state.label = 6;
-                                            case 6:
-                                                _iteratorNormalCompletion = true;
-                                                return [
-                                                    3,
-                                                    3
-                                                ];
-                                            case 7:
-                                                return [
-                                                    3,
-                                                    10
-                                                ];
-                                            case 8:
-                                                err = _state.sent();
-                                                _didIteratorError = true;
-                                                _iteratorError = err;
-                                                return [
-                                                    3,
-                                                    10
-                                                ];
-                                            case 9:
-                                                try {
-                                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                                        _iterator.return();
-                                                    }
-                                                } finally{
-                                                    if (_didIteratorError) {
-                                                        throw _iteratorError;
-                                                    }
-                                                }
-                                                return [
-                                                    7
-                                                ];
-                                            case 10:
-                                                item = items[i];
-                                                result = void 0;
-                                                _state.label = 11;
-                                            case 11:
-                                                _state.trys.push([
-                                                    11,
-                                                    13,
-                                                    ,
-                                                    14
-                                                ]);
-                                                // Save outer state; agent will modify this.currentState
-                                                savedState = _this.currentState;
-                                                // Create a wrapper configFn that injects the item as the first argument
-                                                itemConfigFn = function(params) {
-                                                    return block.configFn(item, params);
-                                                };
-                                                // Create a temporary agent block with the per-item configFn
-                                                tempBlock = {
-                                                    type: 'agent',
-                                                    title: block.title,
-                                                    configFn: itemConfigFn
-                                                };
-                                                tempStep = new Step(tempBlock);
-                                                return [
-                                                    5,
-                                                    _ts_values(_async_generator_delegate(_async_iterator(_this.executeAgent(tempStep))))
-                                                ];
-                                            case 12:
-                                                _state.sent();
-                                                // Capture agent result from this.currentState, then restore outer state
-                                                agentResult = _this.currentState;
-                                                _this.currentState = savedState;
-                                                result = [
-                                                    item,
-                                                    agentResult
-                                                ];
-                                                return [
-                                                    3,
-                                                    14
-                                                ];
-                                            case 13:
-                                                error = _state.sent();
-                                                if (iterateConfig.error) {
-                                                    fallback = iterateConfig.error(item, error);
-                                                    result = fallback !== null ? [
-                                                        item,
-                                                        fallback
-                                                    ] : undefined;
-                                                } else {
-                                                    throw error;
-                                                }
-                                                return [
-                                                    3,
-                                                    14
-                                                ];
-                                            case 14:
-                                                if (result != null) {
-                                                    resultsMap.set(i, result);
-                                                }
-                                                return [
-                                                    4,
-                                                    {
-                                                        type: BRAIN_EVENTS.ITERATE_ITEM_COMPLETE,
-                                                        stepTitle: step.block.title,
-                                                        stepId: step.id,
-                                                        itemIndex: i,
-                                                        item: item,
-                                                        result: result ? result[1] : undefined,
-                                                        processedCount: i + 1,
-                                                        totalItems: totalItems,
-                                                        schemaName: iterateConfig.outputKey,
-                                                        options: (_this_options1 = _this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
-                                                        brainRunId: _this.brainRunId,
-                                                        canRelease: !!_this.signalProvider
-                                                    }
-                                                ];
-                                            case 15:
-                                                _state.sent();
-                                                return [
-                                                    2
-                                                ];
-                                        }
-                                    });
-                                };
-                                block = step.block;
-                                iterateConfig = block.iterateConfig;
                                 prevState = this.currentState;
+                                pageConfigFn = stepBlock.pageConfigFn;
                                 return [
                                     4,
-                                    _await_async_generator(iterateConfig.over(this.buildStepContext(step)))
+                                    _await_async_generator(pageConfigFn(this.buildStepContext(step)))
                                 ];
                             case 1:
-                                items = _state.sent();
-                                totalItems = items.length;
-                                // Resume support
-                                iterateProgress = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.iterateProgress;
-                                startIndex = (_iterateProgress_processedCount = iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.processedCount) !== null && _iterateProgress_processedCount !== void 0 ? _iterateProgress_processedCount : 0;
-                                // Use a Map for results accumulation during iteration.
-                                resultsMap = new Map();
-                                if (iterateProgress === null || iterateProgress === void 0 ? void 0 : iterateProgress.accumulatedResults) {
-                                    for(k = 0; k < iterateProgress.accumulatedResults.length; k++){
-                                        r = iterateProgress.accumulatedResults[k];
-                                        if (r != null) resultsMap.set(k, r);
-                                    }
-                                }
-                                if (iterateProgress) {
-                                    this.resumeContext = undefined;
-                                }
-                                i = startIndex;
-                                _state.label = 2;
-                            case 2:
-                                if (!(i < totalItems)) return [
-                                    3,
-                                    5
-                                ];
-                                _this = this;
-                                return [
-                                    5,
-                                    _ts_values(_loop(i))
-                                ];
-                            case 3:
-                                _ret = _state.sent();
-                                if (_type_of(_ret) === "object") return [
-                                    2,
-                                    _ret.v
-                                ];
-                                _state.label = 4;
-                            case 4:
-                                i++;
-                                return [
+                                pageConfig = _state.sent();
+                                if (!(this.currentResponse && pageConfig.formSchema)) return [
                                     3,
-                                    2
+                                    3
                                 ];
-                            case 5:
-                                finalResults = new IterateResult(_to_consumable_array(resultsMap.values()));
-                                this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, iterateConfig.outputKey, finalResults));
+                                this.currentState = _object_spread({}, this.currentState, this.currentResponse);
+                                this.currentResponse = undefined;
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
-                            case 6:
+                            case 2:
                                 _state.sent();
                                 return [
                                     2
                                 ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "executeUIStep",
-            value: /**
-   * Execute a UI generation step.
-   * Generates UI components, renders to HTML, creates page, and sets up webhook.
-   */ function executeUIStep(step, stepBlock) {
-                return _wrap_async_generator(function() {
-                    var prevState, uiConfig, _this_options, prompt, uiResult, placementCount, placementInfo, _uiResult_text, webhookIdentifier, formToken, formAction, html, page, _uiConfig_responseSchema, webhook;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                prevState = this.currentState;
-                                // Validate required configuration
-                                if (!this.components) {
-                                    throw new Error('UI step "'.concat(stepBlock.title, '" requires components to be configured via brain.withComponents()'));
+                            case 3:
+                                // Validate: exactly one of prompt or html must be present
+                                if (!pageConfig.prompt && !pageConfig.html) {
+                                    throw new Error('Page step "'.concat(stepBlock.title, "\" requires either 'prompt' or 'html'"));
+                                }
+                                if (pageConfig.prompt && pageConfig.html) {
+                                    throw new Error('Page step "'.concat(stepBlock.title, "\" cannot have both 'prompt' and 'html'"));
                                 }
                                 if (!this.pages) {
-                                    throw new Error('UI step "'.concat(stepBlock.title, '" requires pages service to be configured'));
+                                    throw new Error('Page step "'.concat(stepBlock.title, '" requires pages service to be configured'));
+                                }
+                                formInfo = pageConfig.formSchema ? this.buildFormAction(step, pageConfig.formSchema) : undefined;
+                                if (!pageConfig.html) return [
+                                    3,
+                                    4
+                                ];
+                                body = renderHtml(pageConfig.html, formInfo ? {
+                                    formAction: formInfo.formAction
+                                } : {});
+                                html = wrapHtmlDocument(body, {
+                                    title: stepBlock.title
+                                });
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 4:
+                                // LLM-generated page
+                                if (!this.components) {
+                                    throw new Error('Page step "'.concat(stepBlock.title, '" requires components to be configured via brain.withComponents()'));
                                 }
-                                uiConfig = stepBlock.uiConfig;
                                 return [
                                     4,
-                                    _await_async_generator(uiConfig.template({
-                                        state: this.currentState,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                        resources: this.resources
-                                    }))
+                                    _await_async_generator(resolveTemplate(pageConfig.prompt, this.templateContext))
                                 ];
-                            case 1:
+                            case 5:
                                 prompt = _state.sent();
+                                data = (_pageConfig_props = pageConfig.props) !== null && _pageConfig_props !== void 0 ? _pageConfig_props : {};
                                 return [
                                     4,
-                                    _await_async_generator(generateUI({
+                                    _await_async_generator(generatePage({
                                         client: this.client,
                                         prompt: prompt,
                                         components: this.components,
-                                        schema: uiConfig.responseSchema,
-                                        data: this.currentState
+                                        schema: pageConfig.formSchema,
+                                        data: data
                                     }))
                                 ];
-                            case 2:
+                            case 6:
                                 uiResult = _state.sent();
                                 if (!uiResult.rootId) {
-                                    // Provide detailed debug information
                                     placementCount = uiResult.placements.length;
                                     placementInfo = uiResult.placements.map(function(p) {
                                         var _p_parentId;
@@ -3030,60 +3086,104 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     }).join(', ');
                                     if (placementCount === 0) {
                                         ;
-                                        throw new Error('UI generation failed for step "'.concat(stepBlock.title, '" - no components were placed. ') + "The LLM may not have called any component tools. " + "LLM response text: ".concat((_uiResult_text = uiResult.text) !== null && _uiResult_text !== void 0 ? _uiResult_text : '(none)'));
+                                        throw new Error('Page generation failed for step "'.concat(stepBlock.title, '" - no components were placed. ') + "The LLM may not have called any component tools. " + "LLM response text: ".concat((_uiResult_text = uiResult.text) !== null && _uiResult_text !== void 0 ? _uiResult_text : '(none)'));
                                     } else {
-                                        throw new Error('UI generation failed for step "'.concat(stepBlock.title, '" - no root component found. ') + "".concat(placementCount, " component(s) were placed but all have a parentId: [").concat(placementInfo, "]. ") + "The first component should be placed without a parentId to serve as the root.");
+                                        throw new Error('Page generation failed for step "'.concat(stepBlock.title, '" - no root component found. ') + "".concat(placementCount, " component(s) were placed but all have a parentId: [").concat(placementInfo, "]. ") + "The first component should be placed without a parentId to serve as the root.");
                                     }
                                 }
-                                // Create unique identifier for this form submission webhook
-                                webhookIdentifier = "".concat(this.brainRunId, "-").concat(step.id);
-                                // Generate CSRF token for form submission validation
-                                formToken = crypto.randomUUID();
-                                // Construct form action URL for the webhook
-                                formAction = "".concat(this.env.origin, "/webhooks/system/ui-form?identifier=").concat(encodeURIComponent(webhookIdentifier));
-                                // Generate HTML page
                                 html = generatePageHtml({
                                     placements: uiResult.placements,
                                     rootId: uiResult.rootId,
-                                    data: this.currentState,
+                                    data: data,
                                     title: stepBlock.title,
-                                    formAction: formAction,
-                                    formToken: formToken
+                                    formAction: formInfo === null || formInfo === void 0 ? void 0 : formInfo.formAction
                                 });
+                                _state.label = 7;
+                            case 7:
+                                // Step 2: Create page and handle form/read-only branching (shared by both paths)
+                                pageCreateOptions = {
+                                    persist: (_pageConfig_persist = pageConfig.persist) !== null && _pageConfig_persist !== void 0 ? _pageConfig_persist : pageConfig.ttl ? true : false,
+                                    ttl: pageConfig.ttl
+                                };
                                 return [
                                     4,
-                                    _await_async_generator(this.pages.create(html))
+                                    _await_async_generator(this.pages.create(html, pageCreateOptions))
                                 ];
-                            case 3:
+                            case 8:
                                 page = _state.sent();
-                                // Create webhook registration for form submissions
-                                // Uses a built-in 'ui-form' webhook slug that the backend knows how to handle
+                                if (!formInfo) return [
+                                    3,
+                                    12
+                                ];
                                 webhook = {
-                                    slug: 'ui-form',
-                                    identifier: webhookIdentifier,
-                                    schema: (_uiConfig_responseSchema = uiConfig.responseSchema) !== null && _uiConfig_responseSchema !== void 0 ? _uiConfig_responseSchema : z.record(z.unknown()),
-                                    token: formToken
+                                    slug: 'page-form',
+                                    identifier: formInfo.webhookIdentifier,
+                                    schema: formInfo.formSchema,
+                                    token: formInfo.formToken
                                 };
-                                // Set currentPage for the next step to access
                                 this.currentPage = {
                                     url: page.url,
                                     webhook: webhook
                                 };
-                                // State doesn't change from UI step - it just sets up the page
-                                // The next step will receive the page object and can use waitFor
+                                if (!pageConfig.onCreated) return [
+                                    3,
+                                    10
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(pageConfig.onCreated(this.currentPage))
+                                ];
+                            case 9:
+                                _state.sent();
+                                _state.label = 10;
+                            case 10:
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.WEBHOOK,
+                                        waitFor: [
+                                            {
+                                                slug: webhook.slug,
+                                                identifier: webhook.identifier,
+                                                token: webhook.token
+                                            }
+                                        ],
+                                        options: this.options,
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 11:
+                                _state.sent();
+                                this.currentPage = undefined;
+                                return [
+                                    3,
+                                    16
+                                ];
+                            case 12:
+                                if (!pageConfig.onCreated) return [
+                                    3,
+                                    14
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(pageConfig.onCreated({
+                                        url: page.url
+                                    }))
+                                ];
+                            case 13:
+                                _state.sent();
+                                _state.label = 14;
+                            case 14:
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState, {
-                                        url: page.url,
-                                        webhook: {
-                                            slug: webhook.slug,
-                                            identifier: webhook.identifier,
-                                            token: webhook.token
-                                        }
+                                        url: page.url
                                     }))))
                                 ];
-                            case 4:
+                            case 15:
                                 _state.sent();
+                                _state.label = 16;
+                            case 16:
                                 return [
                                     2
                                 ];
@@ -3096,7 +3196,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             key: "executeWait",
             value: function executeWait(step, waitBlock) {
                 return _wrap_async_generator(function() {
-                    var _this, steps, options, brainRunId, _this_options, result, webhooks, serializedWaitFor;
+                    var _this, steps, options, brainRunId, result, webhooks, serializedWaitFor;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -3119,33 +3219,13 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 step.withStatus(STATUS.RUNNING);
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(s) {
-                                            var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 2:
                                 _state.sent();
                                 return [
                                     4,
-                                    _await_async_generator(waitBlock.action(_object_spread({
-                                        state: this.currentState,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                        client: this.client,
-                                        resources: this.resources,
-                                        page: this.currentPage,
-                                        pages: this.pages,
-                                        env: this.env,
-                                        store: this.store,
-                                        currentUser: this.currentUser
-                                    }, this.services)))
+                                    _await_async_generator(waitBlock.action(this.buildStepContext(step)))
                                 ];
                             case 3:
                                 result = _state.sent();
@@ -3158,17 +3238,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 _state.sent();
                                 return [
                                     4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_STATUS,
-                                        steps: steps.map(function(s) {
-                                            var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
-                                                "patch"
-                                            ]);
-                                            return rest;
-                                        }),
-                                        options: options,
-                                        brainRunId: brainRunId
-                                    }
+                                    this.stepStatusEvent()
                                 ];
                             case 5:
                                 _state.sent();
@@ -3217,10 +3287,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                     switch(_state.label){
                         case 0:
                             _this = this, steps = _this.steps, options = _this.options, brainRunId = _this.brainRunId;
-                            predicateResult = guard.predicate({
-                                state: this.currentState,
-                                options: this.options
-                            });
+                            predicateResult = guard.predicate(this.buildStepContext(step));
                             // Emit STEP_START for the guard
                             return [
                                 4,
@@ -3239,17 +3306,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                             step.withStatus(STATUS.RUNNING);
                             return [
                                 4,
-                                {
-                                    type: BRAIN_EVENTS.STEP_STATUS,
-                                    steps: steps.map(function(s) {
-                                        var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
-                                            "patch"
-                                        ]);
-                                        return rest;
-                                    }),
-                                    options: options,
-                                    brainRunId: brainRunId
-                                }
+                                this.stepStatusEvent()
                             ];
                         case 2:
                             _state.sent();
@@ -3262,17 +3319,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                             _state.sent();
                             return [
                                 4,
-                                {
-                                    type: BRAIN_EVENTS.STEP_STATUS,
-                                    steps: steps.map(function(s) {
-                                        var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
-                                            "patch"
-                                        ]);
-                                        return rest;
-                                    }),
-                                    options: options,
-                                    brainRunId: brainRunId
-                                }
+                                this.stepStatusEvent()
                             ];
                         case 4:
                             _state.sent();
@@ -3312,17 +3359,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                         case 7:
                             return [
                                 4,
-                                {
-                                    type: BRAIN_EVENTS.STEP_STATUS,
-                                    steps: steps.map(function(s) {
-                                        var _s_serialized = s.serialized, patch = _s_serialized.patch, rest = _object_without_properties(_s_serialized, [
-                                            "patch"
-                                        ]);
-                                        return rest;
-                                    }),
-                                    options: options,
-                                    brainRunId: brainRunId
-                                }
+                                this.stepStatusEvent()
                             ];
                         case 8:
                             _state.sent();
@@ -3335,6 +3372,120 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                 });
             }
         },
+        {
+            key: "runMapPromptLoop",
+            value: /**
+   * Run a prompt loop for a single map item. Delegates to the shared
+   * runPromptLoop generator, drains events (map doesn't forward prompt events),
+   * and extracts the result from the PROMPT_COMPLETE event.
+   */ function runMapPromptLoop(step, prompt, system, client, outputSchema, loopConfig) {
+                return _async_to_generator(function() {
+                    var loopGen, result, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                loopGen = this.runPromptLoop({
+                                    step: step,
+                                    prompt: prompt,
+                                    system: system,
+                                    client: client,
+                                    outputSchema: outputSchema,
+                                    loopConfig: loopConfig,
+                                    allowWebhookSuspension: false
+                                });
+                                _iteratorAbruptCompletion = false, _didIteratorError = false;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    12
+                                ]);
+                                _iterator = _async_iterator(loopGen);
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    4,
+                                    _iterator.next()
+                                ];
+                            case 3:
+                                if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                _value = _step.value;
+                                event = _value;
+                                if (event.type === BRAIN_EVENTS.PROMPT_COMPLETE) {
+                                    result = event.result;
+                                }
+                                _state.label = 4;
+                            case 4:
+                                _iteratorAbruptCompletion = false;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 7:
+                                _state.trys.push([
+                                    7,
+                                    ,
+                                    10,
+                                    11
+                                ]);
+                                if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                                    3,
+                                    9
+                                ];
+                                return [
+                                    4,
+                                    _iterator.return()
+                                ];
+                            case 8:
+                                _state.sent();
+                                _state.label = 9;
+                            case 9:
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 10:
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                                return [
+                                    7
+                                ];
+                            case 11:
+                                return [
+                                    7
+                                ];
+                            case 12:
+                                if (!result) {
+                                    throw new Error('Prompt loop in map step "'.concat(step.block.title, '" did not produce a result'));
+                                }
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "completeStep",
             value: function completeStep(step, prevState, pageContext) {