@positronic/core 0.0.52 → 0.0.53

package/dist/src/dsl/brain.js

@@ -1,1912 +1,5 @@
-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 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 _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 { v4 as uuidv4 } from 'uuid';
-import { STATUS, BRAIN_EVENTS } from './constants.js';
-import { createPatch, applyPatches } from './json-patch.js';
-/**
- * Default runtime environment used when env is not provided.
- * This ensures backward compatibility with existing code.
- */ export var DEFAULT_ENV = {
-    origin: 'http://localhost:3000',
-    secrets: {}
-};
-/**
- * Heartbeat interval in milliseconds.
- * Emits heartbeat events during long-running operations to keep Durable Objects alive.
- */ export var HEARTBEAT_INTERVAL_MS = 5000;
-/**
- * Default system prompt prepended to all loop steps.
- * Explains tool execution quirks to the LLM.
- */ var DEFAULT_LOOP_SYSTEM_PROMPT = "## Tool Execution Behavior\n- Tools are executed sequentially in the order you call them\n- If a tool triggers a webhook (e.g., human approval), remaining tools in your response will NOT execute - you'll need to call them again after resuming\n- When waiting on multiple webhooks (e.g., Slack + email), the first webhook response received will resume execution\n- Terminal tools end the loop immediately - no further tools or iterations will run\n\n## Resumption Context\nWhen resuming after a webhook response, that response appears as the tool result in your conversation history.";
-/**
- * Simple sleep helper that returns a promise resolving after the specified delay.
- */ var sleep = function(ms) {
-    return new Promise(function(resolve) {
-        return setTimeout(resolve, ms);
-    });
-};
-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, "services", void 0);
-        _define_property(this, "optionsSchema", void 0);
-        this.title = title;
-        this.description = description;
-        this.blocks = [];
-        this.type = 'brain';
-        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 if (block.type === 'loop') {
-                            return {
-                                type: 'loop',
-                                title: block.title
-                            };
-                        } else {
-                            // block.type === 'brain'
-                            return {
-                                type: 'brain',
-                                title: block.title,
-                                innerBrain: block.innerBrain.structure
-                            };
-                        }
-                    })
-                };
-            }
-        },
-        {
-            // New method to add services
-            key: "withServices",
-            value: function withServices(services) {
-                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                // Set services
-                nextBrain.services = services;
-                // Copy optionsSchema to maintain it through the chain
-                nextBrain.optionsSchema = this.optionsSchema;
-                return nextBrain;
-            }
-        },
-        {
-            key: "withOptionsSchema",
-            value: function withOptionsSchema(schema) {
-                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                nextBrain.optionsSchema = schema;
-                nextBrain.services = this.services;
-                return nextBrain;
-            }
-        },
-        {
-            key: "step",
-            value: function step(title, action) {
-                var stepBlock = {
-                    type: 'step',
-                    title: title,
-                    action: action
-                };
-                this.blocks.push(stepBlock);
-                // Create next brain with inferred response type
-                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                nextBrain.services = this.services;
-                nextBrain.optionsSchema = this.optionsSchema;
-                return 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();
-            }
-        },
-        {
-            /**
-   * Add an agentic loop step that runs an LLM with tools.
-   * The loop continues until a terminal tool is called, no tool calls are returned,
-   * or maxTokens is exceeded.
-   */ key: "loop",
-            value: function loop(title, configFn) {
-                var loopBlock = {
-                    type: 'loop',
-                    title: title,
-                    configFn: configFn
-                };
-                this.blocks.push(loopBlock);
-                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                nextBrain.services = this.services;
-                nextBrain.optionsSchema = this.optionsSchema;
-                return 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, webhookResponse, 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, webhookResponse = _param.response, services = _object_without_properties(_param, [
-                                            "state",
-                                            "client",
-                                            "options",
-                                            "resources",
-                                            "response"
-                                        ]);
-                                        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, validatedOptions, stream;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                _this = this, title = _this.title, description = _this.description, blocks = _this.blocks;
-                                if (this.optionsSchema) {
-                                    // Just call parse - Zod handles defaults automatically
-                                    validatedOptions = this.optionsSchema.parse(params.options || {});
-                                } else {
-                                    // If no schema is defined but options are provided, throw error
-                                    if (params.options && Object.keys(params.options).length > 0) {
-                                        throw new Error("Brain '".concat(this.title, "' received options but no schema was defined. Use withOptionsSchema() to define a schema for options."));
-                                    }
-                                    validatedOptions = {};
-                                }
-                                stream = new BrainEventStream(_object_spread_props(_object_spread({
-                                    title: title,
-                                    description: description,
-                                    blocks: blocks
-                                }, params), {
-                                    options: validatedOptions,
-                                    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 services to the next brain
-                nextBrain.services = this.services;
-                // Copy optionsSchema to the next brain
-                nextBrain.optionsSchema = this.optionsSchema;
-                return nextBrain;
-            }
-        }
-    ]);
-    return Brain;
-}();
-var MAX_RETRIES = 1;
-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);
-        _define_property(this, "pages", void 0);
-        _define_property(this, "env", void 0);
-        _define_property(this, "currentResponse", undefined);
-        _define_property(this, "loopResumeContext", undefined);
-        _define_property(this, "initialCompletedSteps", 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, loopResumeContext = params.loopResumeContext;
-        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;
-        // 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 loop resume context if provided (for loop webhook restarts)
-        if (loopResumeContext) {
-            this.loopResumeContext = loopResumeContext;
-        // Note: We intentionally do NOT set currentResponse here.
-        // For loop resumption, the webhook response should flow through
-        // the messages array (via loopResumeContext), not through the
-        // config function's response parameter. The config function is
-        // for loop setup, not for processing webhook responses.
-        } else if (response) {
-            // Set initial response only for non-loop 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,
-                                    {
-                                        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, _this_initialCompletedSteps, 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, stepBlock, 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 === 'brain')) return [
-                                    3,
-                                    16
-                                ];
-                                initialState = typeof block.initialState === 'function' ? block.initialState(this.currentState) : block.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 ? block.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
-                                }) : block.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 = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    7,
-                                    8,
-                                    13
-                                ]);
-                                _iterator1 = _async_iterator(innerRun);
-                                _state.label = 2;
-                            case 2:
-                                return [
-                                    4,
-                                    _await_async_generator(_iterator1.next())
-                                ];
-                            case 3:
-                                if (!(_iteratorAbruptCompletion = !(_step1 = _state.sent()).done)) return [
-                                    3,
-                                    6
-                                ];
-                                _value = _step1.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);
-                                }
-                                // 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,
-                                        6
-                                    ];
-                                }
-                                _state.label = 5;
-                            case 5:
-                                _iteratorAbruptCompletion = false;
-                                return [
-                                    3,
-                                    2
-                                ];
-                            case 6:
-                                return [
-                                    3,
-                                    13
-                                ];
-                            case 7:
-                                err1 = _state.sent();
-                                _didIteratorError1 = true;
-                                _iteratorError1 = err1;
-                                return [
-                                    3,
-                                    13
-                                ];
-                            case 8:
-                                _state.trys.push([
-                                    8,
-                                    ,
-                                    11,
-                                    12
-                                ]);
-                                if (!(_iteratorAbruptCompletion && _iterator1.return != null)) return [
-                                    3,
-                                    10
-                                ];
-                                return [
-                                    4,
-                                    _await_async_generator(_iterator1.return())
-                                ];
-                            case 9:
-                                _state.sent();
-                                _state.label = 10;
-                            case 10:
-                                return [
-                                    3,
-                                    12
-                                ];
-                            case 11:
-                                if (_didIteratorError1) {
-                                    throw _iteratorError1;
-                                }
-                                return [
-                                    7
-                                ];
-                            case 12:
-                                return [
-                                    7
-                                ];
-                            case 13:
-                                // 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(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,
-                                    30
-                                ];
-                            case 16:
-                                if (!(block.type === 'loop')) return [
-                                    3,
-                                    18
-                                ];
-                                return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.executeLoop(step))))
-                                ];
-                            case 17:
-                                _state.sent();
-                                return [
-                                    3,
-                                    30
-                                ];
-                            case 18:
-                                // Get previous state before action
-                                prevState1 = this.currentState;
-                                stepBlock = block;
-                                // Execute step with automatic retry on failure
-                                retries = 0;
-                                _state.label = 19;
-                            case 19:
-                                if (!true) return [
-                                    3,
-                                    27
-                                ];
-                                _state.label = 20;
-                            case 20:
-                                _state.trys.push([
-                                    20,
-                                    22,
-                                    ,
-                                    26
-                                ]);
-                                actionPromise = Promise.resolve(stepBlock.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,
-                                    pages: this.pages,
-                                    env: this.env
-                                }, this.services)));
-                                return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.withHeartbeat(actionPromise, step))))
-                                ];
-                            case 21:
-                                // Use withHeartbeat to emit heartbeat events during long-running operations
-                                result = _state.sent();
-                                return [
-                                    3,
-                                    27
-                                ]; // Success
-                            case 22:
-                                error = _state.sent();
-                                if (!(retries < MAX_RETRIES)) return [
-                                    3,
-                                    24
-                                ];
-                                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 23:
-                                _state.sent();
-                                return [
-                                    3,
-                                    25
-                                ];
-                            case 24:
-                                throw error;
-                            case 25:
-                                return [
-                                    3,
-                                    26
-                                ];
-                            case 26:
-                                return [
-                                    3,
-                                    19
-                                ];
-                            case 27:
-                                this.currentState = result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'waitFor' in result ? result.state : result;
-                                return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
-                                ];
-                            case 28:
-                                _state.sent();
-                                if (!(result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'waitFor' in result)) return [
-                                    3,
-                                    30
-                                ];
-                                // 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 29:
-                                _state.sent();
-                                _state.label = 30;
-                            case 30:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "executeLoop",
-            value: function executeLoop(step) {
-                return _wrap_async_generator(function() {
-                    var block, prevState, _this_options, config, 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;
-                                return [
-                                    4,
-                                    _await_async_generator(block.configFn(_object_spread({
-                                        state: this.currentState,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                        client: this.client,
-                                        resources: this.resources,
-                                        response: this.currentResponse,
-                                        pages: this.pages,
-                                        env: this.env
-                                    }, this.services)))
-                                ];
-                            case 1:
-                                config = _state.sent();
-                                if (!this.loopResumeContext) return [
-                                    3,
-                                    4
-                                ];
-                                resumeContext = this.loopResumeContext;
-                                // 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 LOOP_TOOL_RESULT for the pending tool (webhook response injected as tool result)
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.LOOP_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.loopResumeContext = undefined;
-                                return [
-                                    3,
-                                    6
-                                ];
-                            case 4:
-                                // Emit loop start event (only for fresh starts)
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.LOOP_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.LOOP_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 loop steps.');
-                                }
-                                // Build tools object for the client (description and inputSchema only)
-                                toolsForClient = {};
-                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                try {
-                                    for(_iterator = Object.entries(config.tools)[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_LOOP_SYSTEM_PROMPT, "\n\n").concat(config.system) : DEFAULT_LOOP_SYSTEM_PROMPT;
-                                return [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.withHeartbeat(this.client.generateText({
-                                        system: systemPrompt,
-                                        messages: messages,
-                                        tools: toolsForClient
-                                    }), step))))
-                                ];
-                            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.LOOP_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.LOOP_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.LOOP_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 = config.tools[toolCall.toolName];
-                                if (!tool1) {
-                                    throw new Error("Unknown tool: ".concat(toolCall.toolName));
-                                }
-                                if (!tool1.terminal) return [
-                                    3,
-                                    22
-                                ];
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.LOOP_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 [
-                                    5,
-                                    _ts_values(_async_generator_delegate(_async_iterator(this.withHeartbeat(Promise.resolve(tool1.execute(toolCall.args)), step))))
-                                ];
-                            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 loop webhook event first (captures pending tool context)
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.LOOP_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.LOOP_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: "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
-                            ];
-                    }
-                });
-            }
-        },
-        {
-            key: "withHeartbeat",
-            value: /**
-   * Wraps a promise with heartbeat emission to keep Durable Objects alive during long-running operations.
-   * Emits HEARTBEAT events at regular intervals while waiting for the promise to resolve.
-   */ function withHeartbeat(promise, step) {
-                return _wrap_async_generator(function() {
-                    var resolved, result, error, promiseHandler, _this_options;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                // Create a deferred to track completion
-                                resolved = false;
-                                promiseHandler = promise.then(function(r) {
-                                    resolved = true;
-                                    result = r;
-                                }).catch(function(e) {
-                                    resolved = true;
-                                    error = e;
-                                });
-                                _state.label = 1;
-                            case 1:
-                                if (!!resolved) return [
-                                    3,
-                                    5
-                                ];
-                                // Race between the promise and the heartbeat interval
-                                return [
-                                    4,
-                                    _await_async_generator(Promise.race([
-                                        promiseHandler,
-                                        sleep(HEARTBEAT_INTERVAL_MS)
-                                    ]))
-                                ];
-                            case 2:
-                                _state.sent();
-                                if (!!resolved) return [
-                                    3,
-                                    4
-                                ];
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.HEARTBEAT,
-                                        stepId: step.id,
-                                        stepTitle: step.block.title,
-                                        options: (_this_options = this.options) !== null && _this_options !== void 0 ? _this_options : {},
-                                        brainRunId: this.brainRunId
-                                    }
-                                ];
-                            case 3:
-                                _state.sent();
-                                _state.label = 4;
-                            case 4:
-                                return [
-                                    3,
-                                    1
-                                ];
-                            case 5:
-                                if (error) {
-                                    throw error;
-                                }
-                                return [
-                                    2,
-                                    result
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        }
-    ]);
-    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 title "'.concat(title, '" already exists. Brain titles must be unique.'));
-    }
-    if (brainNamesAreUnique) {
-        brainNames.add(title);
-    }
-    return new Brain(title, description);
-};
-var clone = function(value) {
-    return structuredClone(value);
-};
+// Re-export from new modular structure for backwards compatibility
+// Builder
+export { Brain, brain } from './builder/brain.js';
+// Execution - Constants
+export { DEFAULT_ENV } from './execution/constants.js';