@positronic/core 0.0.1 → 0.0.3

package/dist/src/dsl/brain.js

@@ -0,0 +1,1128 @@
+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 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);
+}
+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 _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 _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 { v4 as uuidv4 } from 'uuid';
+import { STATUS, BRAIN_EVENTS } from './constants.js';
+import { createPatch, applyPatches } from './json-patch.js';
+export var Brain = /*#__PURE__*/ function() {
+    "use strict";
+    function Brain(title, description) {
+        _class_call_check(this, Brain);
+        _define_property(this, "title", void 0);
+        _define_property(this, "description", void 0);
+        _define_property(this, "blocks", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "defaultOptions", void 0);
+        _define_property(this, "services", void 0);
+        this.title = title;
+        this.description = description;
+        this.blocks = [];
+        this.type = 'brain';
+        this.defaultOptions = {};
+        this.services = {};
+    }
+    _create_class(Brain, [
+        {
+            key: "structure",
+            get: function get() {
+                return {
+                    title: this.title,
+                    description: this.description,
+                    steps: this.blocks.map(function(block) {
+                        if (block.type === 'step') {
+                            return {
+                                type: 'step',
+                                title: block.title
+                            };
+                        } else {
+                            // block.type === 'brain'
+                            return {
+                                type: 'brain',
+                                title: block.title,
+                                innerBrain: block.innerBrain.structure
+                            };
+                        }
+                    })
+                };
+            }
+        },
+        {
+            // New method to specify default options
+            key: "withOptions",
+            value: function withOptions(options) {
+                this.defaultOptions = _object_spread({}, this.defaultOptions, options);
+                return this;
+            }
+        },
+        {
+            // New method to add services
+            key: "withServices",
+            value: function withServices(services) {
+                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
+                // Copy default options
+                nextBrain.withOptions(this.defaultOptions);
+                // Set services
+                nextBrain.services = services;
+                return nextBrain;
+            }
+        },
+        {
+            key: "step",
+            value: function step(title, action) {
+                var stepBlock = {
+                    type: 'step',
+                    title: title,
+                    action: action
+                };
+                this.blocks.push(stepBlock);
+                return this.nextBrain();
+            }
+        },
+        {
+            key: "brain",
+            value: function brain(title, innerBrain, action, initialState) {
+                var nestedBlock = {
+                    type: 'brain',
+                    title: title,
+                    innerBrain: innerBrain,
+                    initialState: initialState || function() {
+                        return {};
+                    },
+                    action: function(outerState, innerState, services) {
+                        return action({
+                            state: outerState,
+                            brainState: innerState,
+                            services: services
+                        });
+                    }
+                };
+                this.blocks.push(nestedBlock);
+                return this.nextBrain();
+            }
+        },
+        {
+            // TResponseKey:
+            // The response key must be a string literal, so if defining a response model
+            // a consumer of this brain must use "as const" to ensure the key is a string literal
+            // this type makes sure that the will get a ts error if they don't.
+            key: "prompt",
+            value: function prompt(title, config, reduce) {
+                var promptBlock = {
+                    type: 'step',
+                    title: title,
+                    action: function(_param) {
+                        return _async_to_generator(function() {
+                            var state, runClient, options, resources, services, template, outputSchema, stepClient, schema, schemaName, client, prompt, response, stateWithResponse;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        state = _param.state, runClient = _param.client, options = _param.options, resources = _param.resources, services = _object_without_properties(_param, [
+                                            "state",
+                                            "client",
+                                            "options",
+                                            "resources"
+                                        ]);
+                                        template = config.template, outputSchema = config.outputSchema, stepClient = config.client;
+                                        schema = outputSchema.schema, schemaName = outputSchema.name;
+                                        client = stepClient !== null && stepClient !== void 0 ? stepClient : runClient;
+                                        return [
+                                            4,
+                                            template(state, resources)
+                                        ];
+                                    case 1:
+                                        prompt = _state.sent();
+                                        return [
+                                            4,
+                                            client.generateObject({
+                                                schema: schema,
+                                                schemaName: schemaName,
+                                                prompt: prompt
+                                            })
+                                        ];
+                                    case 2:
+                                        response = _state.sent();
+                                        stateWithResponse = _object_spread_props(_object_spread({}, state), _define_property({}, config.outputSchema.name, response));
+                                        return [
+                                            2,
+                                            reduce ? reduce(_object_spread({
+                                                state: state,
+                                                response: response,
+                                                options: options,
+                                                prompt: prompt,
+                                                resources: resources
+                                            }, services)) : stateWithResponse
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                };
+                this.blocks.push(promptBlock);
+                return this.nextBrain();
+            }
+        },
+        {
+            key: "run",
+            value: // Implementation signature
+            function run(params) {
+                return _wrap_async_generator(function() {
+                    var _this, title, description, blocks, mergedOptions, stream;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this, title = _this.title, description = _this.description, blocks = _this.blocks;
+                                // Merge default options with provided options
+                                mergedOptions = _object_spread({}, this.defaultOptions, params.options || {});
+                                stream = new BrainEventStream(_object_spread_props(_object_spread({
+                                    title: title,
+                                    description: description,
+                                    blocks: blocks
+                                }, params), {
+                                    options: mergedOptions,
+                                    services: this.services
+                                }));
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(stream.next())))
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "withBlocks",
+            value: function withBlocks(blocks) {
+                this.blocks = blocks;
+                return this;
+            }
+        },
+        {
+            key: "nextBrain",
+            value: function nextBrain() {
+                // Pass default options to the next brain
+                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
+                // Copy default options to the next brain
+                nextBrain.withOptions(this.defaultOptions);
+                // Copy services to the next brain
+                nextBrain.services = this.services;
+                return nextBrain;
+            }
+        }
+    ]);
+    return Brain;
+}();
+var Step = /*#__PURE__*/ function() {
+    "use strict";
+    function Step(block, id) {
+        _class_call_check(this, Step);
+        _define_property(this, "block", void 0);
+        _define_property(this, "id", void 0);
+        _define_property(this, "patch", void 0);
+        _define_property(this, "status", void 0);
+        this.block = block;
+        this.status = STATUS.PENDING;
+        this.id = id || uuidv4();
+    }
+    _create_class(Step, [
+        {
+            key: "withPatch",
+            value: function withPatch(patch) {
+                this.patch = patch;
+                return this;
+            }
+        },
+        {
+            key: "withStatus",
+            value: function withStatus(status) {
+                this.status = status;
+                return this;
+            }
+        },
+        {
+            key: "serialized",
+            get: function get() {
+                return {
+                    id: this.id,
+                    title: this.block.title,
+                    status: this.status,
+                    patch: typeof this.patch === 'string' ? JSON.parse(this.patch) : this.patch
+                };
+            }
+        }
+    ]);
+    return Step;
+}();
+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);
+        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;
+        this.initialState = initialState;
+        this.title = title;
+        this.description = description;
+        this.client = client;
+        this.options = options;
+        this.services = services;
+        this.resources = resources;
+        // 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();
+    }
+    _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,
+                                    {
+                                        type: hasCompletedSteps ? BRAIN_EVENTS.RESTART : BRAIN_EVENTS.START,
+                                        status: STATUS.RUNNING,
+                                        brainTitle: brainTitle,
+                                        brainDescription: brainDescription,
+                                        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, initialState, patches, _this_options, innerRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err, innerState, prevState, _, prevState1, _this_options1, _1;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                block = step.block;
+                                if (!(block.type === 'brain')) return [
+                                    3,
+                                    16
+                                ];
+                                initialState = typeof block.initialState === 'function' ? block.initialState(this.currentState) : block.initialState;
+                                // Run inner brain and yield all its events
+                                patches = [];
+                                innerRun = block.innerBrain.run({
+                                    resources: this.resources,
+                                    client: this.client,
+                                    initialState: initialState,
+                                    options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {}
+                                });
+                                _iteratorAbruptCompletion = false, _didIteratorError = false;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    7,
+                                    8,
+                                    13
+                                ]);
+                                _iterator = _async_iterator(innerRun);
+                                _state.label = 2;
+                            case 2:
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator.next())
+                                ];
+                            case 3:
+                                if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                                    3,
+                                    6
+                                ];
+                                _value = _step.value;
+                                event = _value;
+                                return [
+                                    4,
+                                    event
+                                ];
+                            case 4:
+                                _state.sent(); // Forward all inner brain events
+                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
+                                    patches.push(event.patch);
+                                }
+                                _state.label = 5;
+                            case 5:
+                                _iteratorAbruptCompletion = false;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 6:
+                                return [
+                                    3,
+                                    13
+                                ];
+                            case 7:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    13
+                                ];
+                            case 8:
+                                _state.trys.push([
+                                    8,
+                                    ,
+                                    11,
+                                    12
+                                ]);
+                                if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                                    3,
+                                    10
+                                ];
+                                return [
+                                    4,
+                                    _await_async_generator(_iterator.return())
+                                ];
+                            case 9:
+                                _state.sent();
+                                _state.label = 10;
+                            case 10:
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 11:
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                                return [
+                                    7
+                                ];
+                            case 12:
+                                return [
+                                    7
+                                ];
+                            case 13:
+                                // 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(block.action(this.currentState, innerState, this.services))
+                                ];
+                            case 14:
+                                _.currentState = _state.sent();
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState))))
+                                ];
+                            case 15:
+                                _state.sent();
+                                return [
+                                    3,
+                                    19
+                                ];
+                            case 16:
+                                // Get previous state before action
+                                prevState1 = this.currentState;
+                                // Execute regular step
+                                _1 = this;
+                                return [
+                                    4,
+                                    _await_async_generator(block.action(_object_spread({
+                                        state: this.currentState,
+                                        options: (_this_options1 = this.options) !== null && _this_options1 !== void 0 ? _this_options1 : {},
+                                        client: this.client,
+                                        resources: this.resources
+                                    }, this.services)))
+                                ];
+                            case 17:
+                                _1.currentState = _state.sent();
+                                return [
+                                    5,
+                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
+                                ];
+                            case 18:
+                                _state.sent();
+                                _state.label = 19;
+                            case 19:
+                                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;
+}();
+var brainNamesAreUnique = process.env.NODE_ENV !== 'test';
+var brainNames = new Set();
+export var brain = function brain(brainConfig) {
+    var title = typeof brainConfig === 'string' ? brainConfig : brainConfig.title;
+    var description = typeof brainConfig === 'string' ? undefined : brainConfig.description;
+    if (brainNamesAreUnique && brainNames.has(title)) {
+        throw new Error('Brain with name "'.concat(title, '" already exists. Brain names must be unique.'));
+    }
+    if (brainNamesAreUnique) {
+        brainNames.add(title);
+    }
+    return new Brain(title, description);
+};
+var clone = function(value) {
+    return structuredClone(value);
+};