@positronic/core 0.0.61 → 0.0.63

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);
 }
@@ -469,6 +498,9 @@ export var BrainEventStream = /*#__PURE__*/ function() {
         _define_property(this, "signalProvider", void 0);
         _define_property(this, "memoryProvider", void 0);
         _define_property(this, "scopedMemory", void 0);
+        _define_property(this, "guards", new Map());
+        _define_property(this, "waits", new Map());
+        _define_property(this, "stopped", false);
         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, signalProvider = params.signalProvider, memoryProvider = params.memoryProvider;
         // Check if this is a resume run or fresh start
         var resumeParams = params;
@@ -491,10 +523,35 @@ export var BrainEventStream = /*#__PURE__*/ function() {
         if (memoryProvider) {
             this.scopedMemory = createScopedMemory(memoryProvider, title);
         }
-        // Initialize steps - all start as pending (fresh UUIDs)
-        this.steps = blocks.map(function(block) {
-            return new Step(block);
-        });
+        // Initialize steps - track guard and wait blocks by index
+        this.steps = [];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = blocks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var block = _step.value;
+                if (block.type === 'guard') {
+                    var guardBlock = block;
+                    this.guards.set(this.steps.length, guardBlock);
+                } else if (block.type === 'wait') {
+                    var waitBlock = block;
+                    this.waits.set(this.steps.length, waitBlock);
+                }
+                this.steps.push(new Step(block));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
         if (resumeContext) {
             // Resume: use state and stepIndex directly from resumeContext
             this.currentState = clone(resumeContext.state);
@@ -533,7 +590,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             key: "next",
             value: function next() {
                 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, err1, error, currentStep;
+                    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;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -542,9 +599,9 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                             case 1:
                                 _state.trys.push([
                                     1,
-                                    29,
+                                    33,
                                     ,
-                                    32
+                                    36
                                 ]);
                                 if (!!this.resumeContext) return [
                                     3,
@@ -664,7 +721,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                             case 11:
                                 if (!(this.currentStepIndex < steps.length)) return [
                                     3,
-                                    27
+                                    31
                                 ];
                                 if (!this.signalProvider) return [
                                     3,
@@ -768,14 +825,49 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 ];
                             case 22:
                                 step = steps[this.currentStepIndex];
-                                // Skip completed steps
-                                if (step.serialized.status === STATUS.COMPLETE) {
+                                // Skip completed or skipped steps
+                                if (step.serialized.status === STATUS.COMPLETE || step.serialized.status === STATUS.HALTED) {
                                     this.currentStepIndex++;
                                     return [
                                         3,
                                         11
                                     ];
                                 }
+                                // Handle guard blocks
+                                guard = this.guards.get(this.currentStepIndex);
+                                if (!guard) return [
+                                    3,
+                                    24
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeGuard(step, guard))))
+                                ];
+                            case 23:
+                                _state.sent();
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 24:
+                                // Handle wait blocks
+                                waitBlock = this.waits.get(this.currentStepIndex);
+                                if (!waitBlock) return [
+                                    3,
+                                    26
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeWait(step, waitBlock))))
+                                ];
+                            case 25:
+                                _state.sent();
+                                this.currentStepIndex++;
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 26:
                                 // Step start event
                                 return [
                                     4,
@@ -789,7 +881,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         brainRunId: brainRunId
                                     }
                                 ];
-                            case 23:
+                            case 27:
                                 _state.sent();
                                 step.withStatus(STATUS.RUNNING);
                                 // Step Status Event to indicate that the step is running
@@ -807,7 +899,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         brainRunId: brainRunId
                                     }
                                 ];
-                            case 24:
+                            case 28:
                                 _state.sent();
                                 // Execute step and yield the STEP_COMPLETE event and
                                 // all events from inner brains if any
@@ -815,8 +907,14 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.executeStep(step))))
                                 ];
-                            case 25:
+                            case 29:
                                 _state.sent();
+                                // Backend requested a stop (e.g. batch chunk pause for DO restart)
+                                if (this.stopped) {
+                                    return [
+                                        2
+                                    ];
+                                }
                                 // Step Status Event
                                 return [
                                     4,
@@ -832,14 +930,14 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         brainRunId: brainRunId
                                     }
                                 ];
-                            case 26:
+                            case 30:
                                 _state.sent();
                                 this.currentStepIndex++;
                                 return [
                                     3,
                                     11
                                 ];
-                            case 27:
+                            case 31:
                                 return [
                                     4,
                                     {
@@ -851,13 +949,13 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         options: options
                                     }
                                 ];
-                            case 28:
+                            case 32:
                                 _state.sent();
                                 return [
                                     3,
-                                    32
+                                    36
                                 ];
-                            case 29:
+                            case 33:
                                 err1 = _state.sent();
                                 error = err1;
                                 currentStep = steps[this.currentStepIndex];
@@ -878,7 +976,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         options: options
                                     }
                                 ];
-                            case 30:
+                            case 34:
                                 _state.sent();
                                 // Step Status Event
                                 return [
@@ -895,10 +993,10 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         brainRunId: brainRunId
                                     }
                                 ];
-                            case 31:
+                            case 35:
                                 _state.sent();
                                 throw error;
-                            case 32:
+                            case 36:
                                 return [
                                     2
                                 ];
@@ -911,14 +1009,14 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             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, _, prevState1, stepBlock1, retries, result, _this_options2, actionPromise, error, _this_options3, serializedWaitFor;
+                    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, _, prevState1, stepBlock1, retries, result, _this_options2, actionPromise, error, _this_options3;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 block = step.block;
                                 if (!(block.type === 'step')) return [
                                     3,
-                                    2
+                                    4
                                 ];
                                 stepBlock = block;
                                 if (!stepBlock.isUIStep) return [
@@ -935,9 +1033,23 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     2
                                 ];
                             case 2:
+                                if (!stepBlock.batchConfig) return [
+                                    3,
+                                    4
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeBatchPrompt(step))))
+                                ];
+                            case 3:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 4:
                                 if (!(block.type === 'brain')) return [
                                     3,
-                                    18
+                                    20
                                 ];
                                 brainBlock = block;
                                 initialState = typeof brainBlock.initialState === 'function' ? brainBlock.initialState(this.currentState) : brainBlock.initialState;
@@ -965,25 +1077,25 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     brainRunId: this.brainRunId
                                 });
                                 _iteratorAbruptCompletion = false, _didIteratorError = false;
-                                _state.label = 3;
-                            case 3:
+                                _state.label = 5;
+                            case 5:
                                 _state.trys.push([
-                                    3,
-                                    9,
-                                    10,
-                                    15
+                                    5,
+                                    11,
+                                    12,
+                                    17
                                 ]);
                                 _iterator = _async_iterator(innerRun);
-                                _state.label = 4;
-                            case 4:
+                                _state.label = 6;
+                            case 6:
                                 return [
                                     4,
                                     _await_async_generator(_iterator.next())
                                 ];
-                            case 5:
+                            case 7:
                                 if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
                                     3,
-                                    8
+                                    10
                                 ];
                                 _value = _step.value;
                                 event = _value;
@@ -991,7 +1103,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     4,
                                     event
                                 ];
-                            case 6:
+                            case 8:
                                 _state.sent(); // Forward all inner brain events
                                 if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
                                     patches.push(event.patch);
@@ -1004,64 +1116,64 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 if (event.type === BRAIN_EVENTS.COMPLETE) {
                                     return [
                                         3,
-                                        8
+                                        10
                                     ];
                                 }
-                                _state.label = 7;
-                            case 7:
+                                _state.label = 9;
+                            case 9:
                                 _iteratorAbruptCompletion = false;
                                 return [
                                     3,
-                                    4
+                                    6
                                 ];
-                            case 8:
+                            case 10:
                                 return [
                                     3,
-                                    15
+                                    17
                                 ];
-                            case 9:
+                            case 11:
                                 err = _state.sent();
                                 _didIteratorError = true;
                                 _iteratorError = err;
                                 return [
                                     3,
-                                    15
+                                    17
                                 ];
-                            case 10:
+                            case 12:
                                 _state.trys.push([
-                                    10,
+                                    12,
                                     ,
-                                    13,
-                                    14
+                                    15,
+                                    16
                                 ]);
                                 if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
                                     3,
-                                    12
+                                    14
                                 ];
                                 return [
                                     4,
                                     _await_async_generator(_iterator.return())
                                 ];
-                            case 11:
+                            case 13:
                                 _state.sent();
-                                _state.label = 12;
-                            case 12:
+                                _state.label = 14;
+                            case 14:
                                 return [
                                     3,
-                                    14
+                                    16
                                 ];
-                            case 13:
+                            case 15:
                                 if (_didIteratorError) {
                                     throw _iteratorError;
                                 }
                                 return [
                                     7
                                 ];
-                            case 14:
+                            case 16:
                                 return [
                                     7
                                 ];
-                            case 15:
+                            case 17:
                                 // If inner brain paused for webhook, don't complete the outer brain step
                                 // The outer brain should also pause
                                 if (innerBrainPaused) {
@@ -1081,52 +1193,52 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     4,
                                     _await_async_generator(brainBlock.action(this.currentState, innerState, this.services))
                                 ];
-                            case 16:
+                            case 18:
                                 _.currentState = _state.sent();
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
                                 ];
-                            case 17:
+                            case 19:
                                 _state.sent();
                                 return [
                                     3,
                                     33
                                 ];
-                            case 18:
+                            case 20:
                                 if (!(block.type === 'agent')) return [
                                     3,
-                                    20
+                                    22
                                 ];
                                 return [
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.executeAgent(step))))
                                 ];
-                            case 19:
+                            case 21:
                                 _state.sent();
                                 return [
                                     3,
                                     33
                                 ];
-                            case 20:
+                            case 22:
                                 // Get previous state before action
                                 prevState1 = this.currentState;
                                 stepBlock1 = block;
                                 // Execute step with automatic retry on failure
                                 retries = 0;
-                                _state.label = 21;
-                            case 21:
+                                _state.label = 23;
+                            case 23:
                                 if (!true) return [
                                     3,
-                                    29
+                                    31
                                 ];
-                                _state.label = 22;
-                            case 22:
+                                _state.label = 24;
+                            case 24:
                                 _state.trys.push([
-                                    22,
                                     24,
+                                    26,
                                     ,
-                                    28
+                                    30
                                 ]);
                                 actionPromise = Promise.resolve(stepBlock1.action(_object_spread({
                                     state: this.currentState,
@@ -1143,17 +1255,17 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     4,
                                     _await_async_generator(actionPromise)
                                 ];
-                            case 23:
+                            case 25:
                                 result = _state.sent();
                                 return [
                                     3,
-                                    29
+                                    31
                                 ]; // Success
-                            case 24:
+                            case 26:
                                 error = _state.sent();
                                 if (!(retries < MAX_RETRIES)) return [
                                     3,
-                                    26
+                                    28
                                 ];
                                 retries++;
                                 return [
@@ -1172,27 +1284,27 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         brainRunId: this.brainRunId
                                     }
                                 ];
-                            case 25:
+                            case 27:
                                 _state.sent();
                                 return [
                                     3,
-                                    27
+                                    29
                                 ];
-                            case 26:
+                            case 28:
                                 throw error;
-                            case 27:
+                            case 29:
                                 return [
                                     3,
-                                    28
+                                    30
                                 ];
-                            case 28:
+                            case 30:
                                 return [
                                     3,
-                                    21
+                                    23
                                 ];
-                            case 29:
-                                // Extract state from result (handles waitFor and promptResponse cases)
-                                if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && ('waitFor' in result || 'promptResponse' in result)) {
+                            case 31:
+                                // Extract state from result (handles promptResponse case)
+                                if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
                                     this.currentState = result.state;
                                 } else {
                                     this.currentState = result;
@@ -1201,32 +1313,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
                                 ];
-                            case 30:
-                                _state.sent();
-                                if (!(result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'waitFor' in result)) return [
-                                    3,
-                                    32
-                                ];
-                                // Serialize webhook registrations (remove Zod schemas for event serializability)
-                                serializedWaitFor = result.waitFor.map(function(registration) {
-                                    return {
-                                        slug: registration.slug,
-                                        identifier: registration.identifier
-                                    };
-                                });
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.WEBHOOK,
-                                        waitFor: serializedWaitFor,
-                                        options: this.options,
-                                        brainRunId: this.brainRunId
-                                    }
-                                ];
-                            case 31:
-                                _state.sent();
-                                _state.label = 32;
                             case 32:
+                                _state.sent();
                                 // Handle promptResponse - set currentResponse for next step
                                 if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
                                     this.currentResponse = result.promptResponse;
@@ -1675,7 +1763,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                         system: systemPrompt,
                                         messages: initialMessages,
                                         responseMessages: responseMessages,
-                                        tools: toolsForClient
+                                        tools: toolsForClient,
+                                        toolChoice: config.toolChoice
                                     }))
                                 ];
                             case 30:
@@ -2070,6 +2159,246 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "executeBatchPrompt",
+            value: /**
+   * Execute a batch prompt step in chunks, yielding one BATCH_CHUNK_COMPLETE
+   * event per chunk. Between chunks, checks for PAUSE/KILL signals so
+   * Cloudflare backends can restart the DO to reclaim memory.
+   */ function executeBatchPrompt(step) {
+                return _wrap_async_generator(function() {
+                    var _this, _this_resumeContext, block, batchConfig, prevState, _batchConfig_client, client, items, totalItems, _batchConfig_chunkSize, chunkSize, batchProgress, _batchProgress_processedCount, startIndex, results, chunkStart, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, chunkEnd, chunk, chunkResults, i, _this_options1, finalResults;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                block = step.block;
+                                batchConfig = block.batchConfig;
+                                prevState = this.currentState;
+                                client = (_batchConfig_client = batchConfig.client) !== null && _batchConfig_client !== void 0 ? _batchConfig_client : this.client;
+                                items = batchConfig.over(this.currentState);
+                                totalItems = items.length;
+                                chunkSize = (_batchConfig_chunkSize = batchConfig.chunkSize) !== null && _batchConfig_chunkSize !== void 0 ? _batchConfig_chunkSize : 10;
+                                // Resume support: pick up from where we left off
+                                batchProgress = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.batchProgress;
+                                startIndex = (_batchProgress_processedCount = batchProgress === null || batchProgress === void 0 ? void 0 : batchProgress.processedCount) !== null && _batchProgress_processedCount !== void 0 ? _batchProgress_processedCount : 0;
+                                results = (batchProgress === null || batchProgress === void 0 ? void 0 : batchProgress.accumulatedResults) ? _to_consumable_array(batchProgress.accumulatedResults) : new Array(totalItems);
+                                // Clear resumeContext after consuming batchProgress
+                                if (batchProgress) {
+                                    this.resumeContext = undefined;
+                                }
+                                chunkStart = startIndex;
+                                _state.label = 1;
+                            case 1:
+                                if (!(chunkStart < totalItems)) return [
+                                    3,
+                                    15
+                                ];
+                                if (!this.signalProvider) return [
+                                    3,
+                                    11
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(this.signalProvider.getSignals('CONTROL'))
+                                ];
+                            case 2:
+                                signals = _state.sent();
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    9,
+                                    10,
+                                    11
+                                ]);
+                                _iterator = signals[Symbol.iterator]();
+                                _state.label = 4;
+                            case 4:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    8
+                                ];
+                                signal = _step.value;
+                                if (!(signal.type === 'KILL')) return [
+                                    3,
+                                    6
+                                ];
+                                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 5:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 6:
+                                if (signal.type === 'PAUSE') {
+                                    // Don't yield PAUSED - pausing between batch chunks 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 = 7;
+                            case 7:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 8:
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 9:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 10:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 11:
+                                chunkEnd = Math.min(chunkStart + chunkSize, totalItems);
+                                chunk = items.slice(chunkStart, chunkEnd);
+                                return [
+                                    4,
+                                    _await_async_generator(Promise.all(chunk.map(function(item) {
+                                        return _async_to_generator(function() {
+                                            var promptText, output, error, fallback;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        _state.trys.push([
+                                                            0,
+                                                            3,
+                                                            ,
+                                                            4
+                                                        ]);
+                                                        return [
+                                                            4,
+                                                            batchConfig.template(item, this.resources)
+                                                        ];
+                                                    case 1:
+                                                        promptText = _state.sent();
+                                                        return [
+                                                            4,
+                                                            client.generateObject(_object_spread({
+                                                                schema: batchConfig.schema,
+                                                                schemaName: batchConfig.schemaName,
+                                                                prompt: promptText
+                                                            }, batchConfig.maxRetries !== undefined && {
+                                                                maxRetries: batchConfig.maxRetries
+                                                            }))
+                                                        ];
+                                                    case 2:
+                                                        output = _state.sent();
+                                                        return [
+                                                            2,
+                                                            [
+                                                                item,
+                                                                output
+                                                            ]
+                                                        ];
+                                                    case 3:
+                                                        error = _state.sent();
+                                                        if (batchConfig.error) {
+                                                            fallback = batchConfig.error(item, error);
+                                                            return [
+                                                                2,
+                                                                fallback !== null ? [
+                                                                    item,
+                                                                    fallback
+                                                                ] : undefined
+                                                            ];
+                                                        }
+                                                        throw error;
+                                                    case 4:
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        }).call(_this);
+                                    })))
+                                ];
+                            case 12:
+                                chunkResults = _state.sent();
+                                // Store chunk results at correct indices
+                                for(i = 0; i < chunkResults.length; i++){
+                                    results[chunkStart + i] = chunkResults[i];
+                                }
+                                // Yield ONE event per chunk
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.BATCH_CHUNK_COMPLETE,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        chunkStartIndex: chunkStart,
+                                        processedCount: chunkEnd,
+                                        totalItems: totalItems,
+                                        chunkResults: chunkResults,
+                                        schemaName: batchConfig.schemaName,
+                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 13:
+                                _state.sent();
+                                _state.label = 14;
+                            case 14:
+                                chunkStart += chunkSize;
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 15:
+                                // All chunks done - update state and complete step
+                                finalResults = results.filter(function(r) {
+                                    return r != null;
+                                });
+                                this.currentState = _object_spread_props(_object_spread({}, this.currentState), _define_property({}, batchConfig.schemaName, finalResults));
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 16:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "executeUIStep",
             value: /**
@@ -2168,6 +2497,243 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "executeWait",
+            value: function executeWait(step, waitBlock) {
+                return _wrap_async_generator(function() {
+                    var _this, steps, options, brainRunId, _this_options, result, webhooks, serializedWaitFor;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this, steps = _this.steps, options = _this.options, brainRunId = _this.brainRunId;
+                                // Emit STEP_START for the wait block
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.STEP_START,
+                                        status: STATUS.RUNNING,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        stepIndex: this.currentStepIndex,
+                                        options: options,
+                                        brainRunId: brainRunId
+                                    }
+                                ];
+                            case 1:
+                                _state.sent();
+                                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
+                                    }
+                                ];
+                            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
+                                    }, this.services)))
+                                ];
+                            case 3:
+                                result = _state.sent();
+                                // Complete step (state unchanged, generates empty patch)
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, this.currentState))))
+                                ];
+                            case 4:
+                                _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
+                                    }
+                                ];
+                            case 5:
+                                _state.sent();
+                                // Normalize result to array (handle single webhook case)
+                                webhooks = Array.isArray(result) ? result : [
+                                    result
+                                ];
+                                // Serialize webhooks (strip Zod schemas)
+                                serializedWaitFor = webhooks.map(function(registration) {
+                                    return {
+                                        slug: registration.slug,
+                                        identifier: registration.identifier
+                                    };
+                                });
+                                // Emit WEBHOOK event
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.WEBHOOK,
+                                        waitFor: serializedWaitFor,
+                                        options: this.options,
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 6:
+                                _state.sent();
+                                // Reset currentPage after wait consumes it (page is ephemeral)
+                                this.currentPage = undefined;
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "executeGuard",
+            value: function executeGuard(step, guard) {
+                var _this, steps, options, brainRunId, predicateResult, skipStep;
+                return _ts_generator(this, function(_state) {
+                    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
+                            });
+                            // Emit STEP_START for the guard
+                            return [
+                                4,
+                                {
+                                    type: BRAIN_EVENTS.STEP_START,
+                                    status: STATUS.RUNNING,
+                                    stepTitle: step.block.title,
+                                    stepId: step.id,
+                                    stepIndex: this.currentStepIndex,
+                                    options: options,
+                                    brainRunId: brainRunId
+                                }
+                            ];
+                        case 1:
+                            _state.sent();
+                            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
+                                }
+                            ];
+                        case 2:
+                            _state.sent();
+                            // Complete the guard step (state unchanged, empty patch)
+                            return [
+                                5,
+                                _ts_values(this.completeStep(step, this.currentState))
+                            ];
+                        case 3:
+                            _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
+                                }
+                            ];
+                        case 4:
+                            _state.sent();
+                            this.currentStepIndex++;
+                            if (!!predicateResult) return [
+                                3,
+                                9
+                            ];
+                            _state.label = 5;
+                        case 5:
+                            if (!(this.currentStepIndex < steps.length)) return [
+                                3,
+                                7
+                            ];
+                            skipStep = steps[this.currentStepIndex];
+                            skipStep.withStatus(STATUS.HALTED);
+                            return [
+                                4,
+                                {
+                                    type: BRAIN_EVENTS.STEP_COMPLETE,
+                                    status: STATUS.RUNNING,
+                                    stepTitle: skipStep.block.title,
+                                    stepId: skipStep.id,
+                                    patch: [],
+                                    halted: true,
+                                    options: options,
+                                    brainRunId: brainRunId
+                                }
+                            ];
+                        case 6:
+                            _state.sent();
+                            this.currentStepIndex++;
+                            return [
+                                3,
+                                5
+                            ];
+                        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
+                                }
+                            ];
+                        case 8:
+                            _state.sent();
+                            _state.label = 9;
+                        case 9:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            }
+        },
         {
             key: "completeStep",
             value: function completeStep(step, prevState) {