@positronic/core 0.0.52 → 0.0.53

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

@@ -0,0 +1,1638 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _async_generator(gen) {
+    var front, back;
+    function send(key, arg) {
+        return new Promise(function(resolve, reject) {
+            var request = {
+                key: key,
+                arg: arg,
+                resolve: resolve,
+                reject: reject,
+                next: null
+            };
+            if (back) back = back.next = request;
+            else {
+                front = back = request;
+                resume(key, arg);
+            }
+        });
+    }
+    function resume(key, arg) {
+        try {
+            var result = gen[key](arg);
+            var value = result.value;
+            var overloaded = value instanceof _overload_yield;
+            Promise.resolve(overloaded ? value.v : value).then(function(arg) {
+                if (overloaded) {
+                    var nextKey = key === "return" ? "return" : "next";
+                    if (!value.k || arg.done) return resume(nextKey, arg);
+                    else arg = gen[nextKey](arg).value;
+                }
+                settle(result.done ? "return" : "normal", arg);
+            }, function(err) {
+                resume("throw", err);
+            });
+        } catch (err) {
+            settle("throw", err);
+        }
+    }
+    function settle(type, value) {
+        switch(type){
+            case "return":
+                front.resolve({
+                    value: value,
+                    done: true
+                });
+                break;
+            case "throw":
+                front.reject(value);
+                break;
+            default:
+                front.resolve({
+                    value: value,
+                    done: false
+                });
+                break;
+        }
+        front = front.next;
+        if (front) resume(front.key, front.arg);
+        else back = null;
+    }
+    this._invoke = send;
+    if (typeof gen.return !== "function") this.return = undefined;
+}
+_async_generator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+};
+_async_generator.prototype.next = function(arg) {
+    return this._invoke("next", arg);
+};
+_async_generator.prototype.throw = function(arg) {
+    return this._invoke("throw", arg);
+};
+_async_generator.prototype.return = function(arg) {
+    return this._invoke("return", arg);
+};
+function _async_generator_delegate(inner) {
+    var iter = {}, waiting = false;
+    function pump(key, value) {
+        waiting = true;
+        value = new Promise(function(resolve) {
+            resolve(inner[key](value));
+        });
+        return {
+            done: false,
+            value: new _overload_yield(value, 1)
+        };
+    }
+    iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function() {
+        return this;
+    };
+    iter.next = function(value) {
+        if (waiting) {
+            waiting = false;
+            return value;
+        }
+        return pump("next", value);
+    };
+    if (typeof inner.throw === "function") {
+        iter.throw = function(value) {
+            if (waiting) {
+                waiting = false;
+                throw value;
+            }
+            return pump("throw", value);
+        };
+    }
+    if (typeof inner.return === "function") {
+        iter.return = function(value) {
+            if (waiting) {
+                waiting = false;
+                return value;
+            }
+            return pump("return", value);
+        };
+    }
+    return iter;
+}
+function _async_iterator(iterable) {
+    var method, async, sync, retry = 2;
+    for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+        var done = r.done;
+        return Promise.resolve(r.value).then(function(value) {
+            return {
+                value: value,
+                done: done
+            };
+        });
+    }
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    }, AsyncFromSyncIterator.prototype = {
+        s: null,
+        n: null,
+        next: function() {
+            return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+        },
+        return: function(value) {
+            var ret = this.s.return;
+            return void 0 === ret ? Promise.resolve({
+                value: value,
+                done: !0
+            }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+        },
+        throw: function(value) {
+            var thr = this.s.return;
+            return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+        }
+    }, new AsyncFromSyncIterator(s);
+}
+function _await_async_generator(value) {
+    return new _overload_yield(value, 0);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _overload_yield(value, kind) {
+    this.v = value;
+    this.k = kind;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _wrap_async_generator(fn) {
+    return function() {
+        return new _async_generator(fn.apply(this, arguments));
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+import { z } from 'zod';
+import { v4 as uuidv4 } from 'uuid';
+import { STATUS, BRAIN_EVENTS } from '../constants.js';
+import { createPatch, applyPatches } from '../json-patch.js';
+import { generateUI } from '../../ui/generate-ui.js';
+import { generatePageHtml } from '../../ui/generate-page-html.js';
+import { Step } from '../builder/step.js';
+import { DEFAULT_ENV, DEFAULT_AGENT_SYSTEM_PROMPT, MAX_RETRIES } from './constants.js';
+var clone = function(value) {
+    return structuredClone(value);
+};
+export var BrainEventStream = /*#__PURE__*/ function() {
+    "use strict";
+    function BrainEventStream(params) {
+        _class_call_check(this, BrainEventStream);
+        _define_property(this, "currentState", void 0);
+        _define_property(this, "steps", void 0);
+        _define_property(this, "currentStepIndex", 0);
+        _define_property(this, "initialState", void 0);
+        _define_property(this, "brainRunId", void 0);
+        _define_property(this, "title", void 0);
+        _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, "agentResumeContext", undefined);
+        _define_property(this, "initialCompletedSteps", void 0);
+        _define_property(this, "components", void 0);
+        _define_property(this, "defaultTools", void 0);
+        var _params_initialState = params.initialState, initialState = _params_initialState === void 0 ? {} : _params_initialState, initialCompletedSteps = params.initialCompletedSteps, 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, response = params.response, agentResumeContext = params.agentResumeContext, components = params.components, defaultTools = params.defaultTools;
+        this.initialState = initialState;
+        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.initialCompletedSteps = initialCompletedSteps;
+        this.components = components;
+        this.defaultTools = defaultTools;
+        // Initialize steps array with UUIDs and pending status
+        this.steps = blocks.map(function(block, index) {
+            var completedStep = initialCompletedSteps === null || initialCompletedSteps === void 0 ? void 0 : initialCompletedSteps[index];
+            if (completedStep) {
+                return new Step(block, completedStep.id).withStatus(completedStep.status).withPatch(completedStep.patch);
+            }
+            return new Step(block);
+        });
+        this.currentState = clone(this.initialState);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = this.steps[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var step = _step.value;
+                if (step.serialized.status === STATUS.COMPLETE && step.serialized.patch) {
+                    this.currentState = applyPatches(this.currentState, [
+                        step.serialized.patch
+                    ]);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        // Use provided ID if available, otherwise generate one
+        this.brainRunId = providedBrainRunId !== null && providedBrainRunId !== void 0 ? providedBrainRunId : uuidv4();
+        // Set agent resume context if provided (for agent webhook restarts)
+        if (agentResumeContext) {
+            this.agentResumeContext = agentResumeContext;
+        // Note: We intentionally do NOT set currentResponse here.
+        // For agent resumption, the webhook response should flow through
+        // the messages array (via agentResumeContext), not through the
+        // config function's response parameter. The config function is
+        // for agent setup, not for processing webhook responses.
+        } else if (response) {
+            // Set initial response only for non-agent webhook restarts
+            this.currentResponse = response;
+        }
+    }
+    _create_class(BrainEventStream, [
+        {
+            key: "next",
+            value: function next() {
+                return _wrap_async_generator(function() {
+                    var _this, steps, brainTitle, brainDescription, currentState, options, brainRunId, hasCompletedSteps, step, err, error, currentStep;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this, steps = _this.steps, brainTitle = _this.title, brainDescription = _this.description, currentState = _this.currentState, options = _this.options, brainRunId = _this.brainRunId;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    11,
+                                    ,
+                                    14
+                                ]);
+                                hasCompletedSteps = steps.some(function(step) {
+                                    return step.serialized.status !== STATUS.PENDING;
+                                });
+                                return [
+                                    4,
+                                    _object_spread_props(_object_spread({
+                                        type: hasCompletedSteps ? BRAIN_EVENTS.RESTART : BRAIN_EVENTS.START,
+                                        status: STATUS.RUNNING,
+                                        brainTitle: brainTitle,
+                                        brainDescription: brainDescription
+                                    }, hasCompletedSteps ? {} : {
+                                        initialState: currentState
+                                    }), {
+                                        options: options,
+                                        brainRunId: brainRunId
+                                    })
+                                ];
+                            case 2:
+                                _state.sent();
+                                // 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
+                                    }
+                                ];
+                            case 3:
+                                _state.sent();
+                                _state.label = 4;
+                            case 4:
+                                if (!(this.currentStepIndex < steps.length)) return [
+                                    3,
+                                    9
+                                ];
+                                step = steps[this.currentStepIndex];
+                                // Skip completed steps
+                                if (step.serialized.status === STATUS.COMPLETE) {
+                                    this.currentStepIndex++;
+                                    return [
+                                        3,
+                                        4
+                                    ];
+                                }
+                                // Step start event
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.STEP_START,
+                                        status: STATUS.RUNNING,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        options: options,
+                                        brainRunId: brainRunId
+                                    }
+                                ];
+                            case 5:
+                                _state.sent();
+                                step.withStatus(STATUS.RUNNING);
+                                // 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
+                                    }
+                                ];
+                            case 6:
+                                _state.sent();
+                                // Execute step and yield the STEP_COMPLETE event and
+                                // all events from inner brains if any
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeStep(step))))
+                                ];
+                            case 7:
+                                _state.sent();
+                                // 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
+                                    }
+                                ];
+                            case 8:
+                                _state.sent();
+                                this.currentStepIndex++;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 9:
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.COMPLETE,
+                                        status: STATUS.COMPLETE,
+                                        brainTitle: brainTitle,
+                                        brainDescription: brainDescription,
+                                        brainRunId: brainRunId,
+                                        options: options
+                                    }
+                                ];
+                            case 10:
+                                _state.sent();
+                                return [
+                                    3,
+                                    14
+                                ];
+                            case 11:
+                                err = _state.sent();
+                                error = err;
+                                currentStep = steps[this.currentStepIndex];
+                                currentStep === null || currentStep === void 0 ? void 0 : currentStep.withStatus(STATUS.ERROR);
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.ERROR,
+                                        status: STATUS.ERROR,
+                                        brainTitle: brainTitle,
+                                        brainDescription: brainDescription,
+                                        brainRunId: brainRunId,
+                                        error: {
+                                            name: error.name,
+                                            message: error.message,
+                                            stack: error.stack
+                                        },
+                                        options: options
+                                    }
+                                ];
+                            case 12:
+                                _state.sent();
+                                // 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
+                                    }
+                                ];
+                            case 13:
+                                _state.sent();
+                                throw error;
+                            case 14:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "executeStep",
+            value: function executeStep(step) {
+                return _wrap_async_generator(function() {
+                    var block, stepBlock, _this_initialCompletedSteps, brainBlock, initialState, stepIndex, completedStepEntry, innerCompletedSteps, patches, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, completedStep, innerBrainPaused, _this_options, _this_options1, innerRun, _iteratorAbruptCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, _value, event, err1, innerState, prevState, _, prevState1, stepBlock1, retries, result, _this_options2, actionPromise, error, _this_options3, serializedWaitFor;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                block = step.block;
+                                if (!(block.type === 'step')) return [
+                                    3,
+                                    2
+                                ];
+                                stepBlock = block;
+                                if (!stepBlock.isUIStep) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeUIStep(step, stepBlock))))
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 2:
+                                if (!(block.type === 'brain')) return [
+                                    3,
+                                    18
+                                ];
+                                brainBlock = block;
+                                initialState = typeof brainBlock.initialState === 'function' ? brainBlock.initialState(this.currentState) : brainBlock.initialState;
+                                // Check if this inner brain step has completed inner steps (for resume)
+                                stepIndex = this.steps.indexOf(step);
+                                completedStepEntry = (_this_initialCompletedSteps = this.initialCompletedSteps) === null || _this_initialCompletedSteps === void 0 ? void 0 : _this_initialCompletedSteps[stepIndex];
+                                innerCompletedSteps = completedStepEntry === null || completedStepEntry === void 0 ? void 0 : completedStepEntry.innerSteps;
+                                // Run inner brain and yield all its events
+                                // Pass brainRunId so inner brain shares outer brain's run ID
+                                // Pass innerSteps and response for resume scenarios
+                                patches = [];
+                                // If resuming, include patches from already-completed inner steps
+                                // These won't be re-emitted as STEP_COMPLETE events
+                                if (innerCompletedSteps) {
+                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                    try {
+                                        for(_iterator = innerCompletedSteps[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                            completedStep = _step.value;
+                                            if (completedStep.patch) {
+                                                patches.push(completedStep.patch);
+                                            }
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError = true;
+                                        _iteratorError = err;
+                                    } finally{
+                                        try {
+                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                _iterator.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError) {
+                                                throw _iteratorError;
+                                            }
+                                        }
+                                    }
+                                }
+                                innerBrainPaused = false;
+                                innerRun = innerCompletedSteps ? brainBlock.innerBrain.run({
+                                    resources: this.resources,
+                                    client: this.client,
+                                    initialState: initialState,
+                                    initialCompletedSteps: innerCompletedSteps,
+                                    options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
+                                    pages: this.pages,
+                                    env: this.env,
+                                    brainRunId: this.brainRunId,
+                                    response: this.currentResponse
+                                }) : brainBlock.innerBrain.run({
+                                    resources: this.resources,
+                                    client: this.client,
+                                    initialState: initialState,
+                                    options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
+                                    pages: this.pages,
+                                    env: this.env,
+                                    brainRunId: this.brainRunId
+                                });
+                                _iteratorAbruptCompletion = false, _didIteratorError1 = false;
+                                _state.label = 3;
+                            case 3:
+                                _state.trys.push([
+                                    3,
+                                    9,
+                                    10,
+                                    15
+                                ]);
+                                _iterator1 = _async_iterator(innerRun);
+                                _state.label = 4;
+                            case 4:
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator1.next())
+                                ];
+                            case 5:
+                                if (!(_iteratorAbruptCompletion = !(_step1 = _state.sent()).done)) return [
+                                    3,
+                                    8
+                                ];
+                                _value = _step1.value;
+                                event = _value;
+                                return [
+                                    4,
+                                    event
+                                ];
+                            case 6:
+                                _state.sent(); // Forward all inner brain events
+                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
+                                    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,
+                                        8
+                                    ];
+                                }
+                                _state.label = 7;
+                            case 7:
+                                _iteratorAbruptCompletion = false;
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 8:
+                                return [
+                                    3,
+                                    15
+                                ];
+                            case 9:
+                                err1 = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err1;
+                                return [
+                                    3,
+                                    15
+                                ];
+                            case 10:
+                                _state.trys.push([
+                                    10,
+                                    ,
+                                    13,
+                                    14
+                                ]);
+                                if (!(_iteratorAbruptCompletion && _iterator1.return != null)) return [
+                                    3,
+                                    12
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator1.return())
+                                ];
+                            case 11:
+                                _state.sent();
+                                _state.label = 12;
+                            case 12:
+                                return [
+                                    3,
+                                    14
+                                ];
+                            case 13:
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                                return [
+                                    7
+                                ];
+                            case 14:
+                                return [
+                                    7
+                                ];
+                            case 15:
+                                // If inner brain paused for webhook, don't complete the outer brain step
+                                // The outer brain should also pause
+                                if (innerBrainPaused) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                // Apply collected patches to get final inner state
+                                innerState = applyPatches(initialState, 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 16:
+                                _.currentState = _state.sent();
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 17:
+                                _state.sent();
+                                return [
+                                    3,
+                                    33
+                                ];
+                            case 18:
+                                if (!(block.type === 'agent')) return [
+                                    3,
+                                    20
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeAgent(step))))
+                                ];
+                            case 19:
+                                _state.sent();
+                                return [
+                                    3,
+                                    33
+                                ];
+                            case 20:
+                                // Get previous state before action
+                                prevState1 = this.currentState;
+                                stepBlock1 = block;
+                                // Execute step with automatic retry on failure
+                                retries = 0;
+                                _state.label = 21;
+                            case 21:
+                                if (!true) return [
+                                    3,
+                                    29
+                                ];
+                                _state.label = 22;
+                            case 22:
+                                _state.trys.push([
+                                    22,
+                                    24,
+                                    ,
+                                    28
+                                ]);
+                                actionPromise = Promise.resolve(stepBlock1.action(_object_spread({
+                                    state: this.currentState,
+                                    options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
+                                    client: this.client,
+                                    resources: this.resources,
+                                    response: this.currentResponse,
+                                    page: this.currentPage,
+                                    pages: this.pages,
+                                    env: this.env
+                                }, this.services)));
+                                return [
+                                    4,
+                                    _await_async_generator(actionPromise)
+                                ];
+                            case 23:
+                                result = _state.sent();
+                                return [
+                                    3,
+                                    29
+                                ]; // Success
+                            case 24:
+                                error = _state.sent();
+                                if (!(retries < MAX_RETRIES)) return [
+                                    3,
+                                    26
+                                ];
+                                retries++;
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.STEP_RETRY,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        error: {
+                                            name: error.name,
+                                            message: error.message,
+                                            stack: error.stack
+                                        },
+                                        attempt: retries,
+                                        options: (_this_options3 = this.options) !== null && _this_options3 !== void 0 ? _this_options3 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 25:
+                                _state.sent();
+                                return [
+                                    3,
+                                    27
+                                ];
+                            case 26:
+                                throw error;
+                            case 27:
+                                return [
+                                    3,
+                                    28
+                                ];
+                            case 28:
+                                return [
+                                    3,
+                                    21
+                                ];
+                            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)) {
+                                    this.currentState = result.state;
+                                } else {
+                                    this.currentState = result;
+                                }
+                                return [
+                                    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:
+                                // Handle promptResponse - set currentResponse for next step
+                                if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
+                                    this.currentResponse = result.promptResponse;
+                                }
+                                // Reset currentPage after step consumes it (page is ephemeral)
+                                this.currentPage = undefined;
+                                _state.label = 33;
+                            case 33:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "executeAgent",
+            value: function executeAgent(step) {
+                return _wrap_async_generator(function() {
+                    var block, prevState, _this_defaultTools, defaultTools, _this_components, components, _this_options, config, _config_tools, mergedTools, messages, resumeContext, _this_options1, _this_options2, _this_options3, totalTokens, iteration, _this_options4, toolsForClient, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, toolDef, tool, systemPrompt, response, _this_options5, _this_options6, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, toolCall, _this_options7, tool1, _this_options8, toolResult, waitForResult, webhooks, _this_options9, _this_options10, _this_options11, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                block = step.block;
+                                prevState = this.currentState;
+                                // Get default tools and components for injection into configFn
+                                defaultTools = (_this_defaultTools = this.defaultTools) !== null && _this_defaultTools !== void 0 ? _this_defaultTools : {};
+                                components = (_this_components = this.components) !== null && _this_components !== void 0 ? _this_components : {};
+                                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: defaultTools,
+                                        components: components,
+                                        client: this.client,
+                                        resources: this.resources,
+                                        response: this.currentResponse,
+                                        page: this.currentPage,
+                                        pages: this.pages,
+                                        env: this.env
+                                    }, this.services)))
+                                ];
+                            case 1:
+                                config = _state.sent();
+                                // Reset currentPage after configFn consumes it (page is ephemeral)
+                                this.currentPage = undefined;
+                                // Merge tools: step tools override defaults
+                                mergedTools = _object_spread({}, defaultTools, (_config_tools = config.tools) !== null && _config_tools !== void 0 ? _config_tools : {});
+                                if (!this.agentResumeContext) return [
+                                    3,
+                                    4
+                                ];
+                                resumeContext = this.agentResumeContext;
+                                // Emit WEBHOOK_RESPONSE event to record the response
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.WEBHOOK_RESPONSE,
+                                        response: resumeContext.webhookResponse,
+                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 2:
+                                _state.sent();
+                                // Emit AGENT_TOOL_RESULT for the pending tool (webhook response injected as tool result)
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_TOOL_RESULT,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        toolCallId: resumeContext.pendingToolCallId,
+                                        toolName: resumeContext.pendingToolName,
+                                        result: resumeContext.webhookResponse,
+                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 3:
+                                _state.sent();
+                                // Use restored messages from the resume context
+                                messages = resumeContext.messages;
+                                // Clear the context so it's only used once
+                                this.agentResumeContext = undefined;
+                                return [
+                                    3,
+                                    6
+                                ];
+                            case 4:
+                                // Emit agent start event (only for fresh starts)
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_START,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        prompt: config.prompt,
+                                        system: config.system,
+                                        options: (_this_options3 = this.options) !== null && _this_options3 !== void 0 ? _this_options3 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 5:
+                                _state.sent();
+                                // Initialize messages for fresh start
+                                messages = [
+                                    {
+                                        role: 'user',
+                                        content: config.prompt
+                                    }
+                                ];
+                                _state.label = 6;
+                            case 6:
+                                // Initialize token tracking
+                                totalTokens = 0;
+                                iteration = 0;
+                                _state.label = 7;
+                            case 7:
+                                if (!true) return [
+                                    3,
+                                    33
+                                ];
+                                iteration++;
+                                // Emit iteration event
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_ITERATION,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        iteration: iteration,
+                                        options: (_this_options4 = this.options) !== null && _this_options4 !== void 0 ? _this_options4 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 8:
+                                _state.sent();
+                                // 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 = {};
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = Object.entries(mergedTools)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], toolDef = _step_value[1];
+                                        tool = toolDef;
+                                        toolsForClient[name] = {
+                                            description: tool.description,
+                                            inputSchema: tool.inputSchema
+                                        };
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        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: messages,
+                                        tools: toolsForClient
+                                    }))
+                                ];
+                            case 9:
+                                response = _state.sent();
+                                // Track tokens
+                                totalTokens += response.usage.totalTokens;
+                                if (!(config.maxTokens && totalTokens > config.maxTokens)) return [
+                                    3,
+                                    12
+                                ];
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_TOKEN_LIMIT,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        totalTokens: totalTokens,
+                                        maxTokens: config.maxTokens,
+                                        options: (_this_options5 = this.options) !== null && _this_options5 !== void 0 ? _this_options5 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 10:
+                                _state.sent();
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 11:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 12:
+                                if (!response.text) return [
+                                    3,
+                                    14
+                                ];
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        content: response.text,
+                                        options: (_this_options6 = this.options) !== null && _this_options6 !== void 0 ? _this_options6 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 13:
+                                _state.sent();
+                                messages.push({
+                                    role: 'assistant',
+                                    content: response.text
+                                });
+                                _state.label = 14;
+                            case 14:
+                                if (!(!response.toolCalls || response.toolCalls.length === 0)) return [
+                                    3,
+                                    16
+                                ];
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 15:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 16:
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                _state.label = 17;
+                            case 17:
+                                _state.trys.push([
+                                    17,
+                                    30,
+                                    31,
+                                    32
+                                ]);
+                                _iterator1 = response.toolCalls[Symbol.iterator]();
+                                _state.label = 18;
+                            case 18:
+                                if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                                    3,
+                                    29
+                                ];
+                                toolCall = _step1.value;
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_TOOL_CALL,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        toolName: toolCall.toolName,
+                                        toolCallId: toolCall.toolCallId,
+                                        input: toolCall.args,
+                                        options: (_this_options7 = this.options) !== null && _this_options7 !== void 0 ? _this_options7 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 19:
+                                _state.sent();
+                                tool1 = mergedTools[toolCall.toolName];
+                                if (!tool1) {
+                                    throw new Error("Unknown tool: ".concat(toolCall.toolName));
+                                }
+                                if (!tool1.terminal) return [
+                                    3,
+                                    22
+                                ];
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_COMPLETE,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        terminalToolName: toolCall.toolName,
+                                        result: toolCall.args,
+                                        totalIterations: iteration,
+                                        options: (_this_options8 = this.options) !== null && _this_options8 !== void 0 ? _this_options8 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 20:
+                                _state.sent();
+                                // Merge terminal result into state
+                                this.currentState = _object_spread({}, this.currentState, toolCall.args);
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 21:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 22:
+                                if (!tool1.execute) return [
+                                    3,
+                                    28
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(tool1.execute(toolCall.args))
+                                ];
+                            case 23:
+                                toolResult = _state.sent();
+                                if (!(toolResult && (typeof toolResult === "undefined" ? "undefined" : _type_of(toolResult)) === 'object' && 'waitFor' in toolResult)) return [
+                                    3,
+                                    26
+                                ];
+                                waitForResult = toolResult;
+                                // Normalize waitFor to array (supports single or multiple webhooks)
+                                webhooks = Array.isArray(waitForResult.waitFor) ? waitForResult.waitFor : [
+                                    waitForResult.waitFor
+                                ];
+                                // Emit agent webhook event first (captures pending tool context)
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_WEBHOOK,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        toolCallId: toolCall.toolCallId,
+                                        toolName: toolCall.toolName,
+                                        input: toolCall.args,
+                                        options: (_this_options9 = this.options) !== null && _this_options9 !== void 0 ? _this_options9 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 24:
+                                _state.sent();
+                                // Then emit webhook event with all webhooks (first response wins)
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.WEBHOOK,
+                                        waitFor: webhooks.map(function(w) {
+                                            return {
+                                                slug: w.slug,
+                                                identifier: w.identifier
+                                            };
+                                        }),
+                                        options: (_this_options10 = this.options) !== null && _this_options10 !== void 0 ? _this_options10 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 25:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                            case 26:
+                                // Normal tool result
+                                return [
+                                    4,
+                                    {
+                                        type: BRAIN_EVENTS.AGENT_TOOL_RESULT,
+                                        stepTitle: step.block.title,
+                                        stepId: step.id,
+                                        toolName: toolCall.toolName,
+                                        toolCallId: toolCall.toolCallId,
+                                        result: toolResult,
+                                        options: (_this_options11 = this.options) !== null && _this_options11 !== void 0 ? _this_options11 : {},
+                                        brainRunId: this.brainRunId
+                                    }
+                                ];
+                            case 27:
+                                _state.sent();
+                                messages.push({
+                                    role: 'tool',
+                                    content: JSON.stringify(toolResult),
+                                    toolCallId: toolCall.toolCallId,
+                                    toolName: toolCall.toolName
+                                });
+                                _state.label = 28;
+                            case 28:
+                                _iteratorNormalCompletion1 = true;
+                                return [
+                                    3,
+                                    18
+                                ];
+                            case 29:
+                                return [
+                                    3,
+                                    32
+                                ];
+                            case 30:
+                                err = _state.sent();
+                                _didIteratorError1 = true;
+                                _iteratorError1 = err;
+                                return [
+                                    3,
+                                    32
+                                ];
+                            case 31:
+                                try {
+                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                        _iterator1.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError1) {
+                                        throw _iteratorError1;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 32:
+                                return [
+                                    3,
+                                    7
+                                ];
+                            case 33:
+                                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, prompt, uiResult, placementCount, placementInfo, _uiResult_text, webhookIdentifier, 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()'));
+                                }
+                                if (!this.pages) {
+                                    throw new Error('UI step "'.concat(stepBlock.title, '" requires pages service to be configured'));
+                                }
+                                uiConfig = stepBlock.uiConfig;
+                                return [
+                                    4,
+                                    _await_async_generator(uiConfig.template(this.currentState, this.resources))
+                                ];
+                            case 1:
+                                prompt = _state.sent();
+                                return [
+                                    4,
+                                    _await_async_generator(generateUI({
+                                        client: this.client,
+                                        prompt: prompt,
+                                        components: this.components,
+                                        schema: uiConfig.responseSchema,
+                                        data: this.currentState
+                                    }))
+                                ];
+                            case 2:
+                                uiResult = _state.sent();
+                                if (!uiResult.rootId) {
+                                    // Provide detailed debug information
+                                    placementCount = uiResult.placements.length;
+                                    placementInfo = uiResult.placements.map(function(p) {
+                                        var _p_parentId;
+                                        return "".concat(p.component, "(parentId: ").concat((_p_parentId = p.parentId) !== null && _p_parentId !== void 0 ? _p_parentId : 'null', ")");
+                                    }).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)'));
+                                    } 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.");
+                                    }
+                                }
+                                // Create unique identifier for this form submission webhook
+                                webhookIdentifier = "".concat(this.brainRunId, "-").concat(step.id);
+                                // 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,
+                                    title: stepBlock.title,
+                                    formAction: formAction
+                                });
+                                return [
+                                    4,
+                                    _await_async_generator(this.pages.create(html))
+                                ];
+                            case 3:
+                                page = _state.sent();
+                                // Create webhook registration for form submissions
+                                // Uses a built-in 'ui-form' webhook slug that the backend knows how to handle
+                                webhook = {
+                                    slug: 'ui-form',
+                                    identifier: webhookIdentifier,
+                                    schema: (_uiConfig_responseSchema = uiConfig.responseSchema) !== null && _uiConfig_responseSchema !== void 0 ? _uiConfig_responseSchema : z.record(z.unknown())
+                                };
+                                // 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
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 4:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "completeStep",
+            value: function completeStep(step, prevState) {
+                var patch, _this_options;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            step.withStatus(STATUS.COMPLETE);
+                            // Create patch for the state change
+                            patch = createPatch(prevState, this.currentState);
+                            step.withPatch(patch);
+                            return [
+                                4,
+                                {
+                                    type: BRAIN_EVENTS.STEP_COMPLETE,
+                                    status: STATUS.RUNNING,
+                                    stepTitle: step.block.title,
+                                    stepId: step.id,
+                                    patch: patch,
+                                    options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
+                                    brainRunId: this.brainRunId
+                                }
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            }
+        }
+    ]);
+    return BrainEventStream;
+}();