@positronic/core 0.0.45 → 0.0.47

package/dist/src/dsl/brain-runner.js

@@ -273,9 +273,10 @@ function _ts_values(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-import { BRAIN_EVENTS, STATUS } from './constants.js';
+import { BRAIN_EVENTS } from './constants.js';
 import { applyPatches } from './json-patch.js';
 import { reconstructLoopContext } from './loop-messages.js';
+import { createBrainExecutionMachine, sendEvent, sendAction, BRAIN_ACTIONS } from './brain-state-machine.js';
 import { DEFAULT_ENV } from './brain.js';
 export var BrainRunner = /*#__PURE__*/ function() {
     "use strict";
@@ -330,7 +331,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
             key: "run",
             value: function run(_0) {
                 return _async_to_generator(function(brain) {
-                    var _ref, _ref_initialState, initialState, options, initialCompletedSteps, brainRunId, endAfter, signal, response, loopEvents, _this_options, adapters, client, resources, pages, env, resolvedEnv, currentState, stepNumber, loopResumeContext, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, cancelledEvent;
+                    var _ref, _ref_initialState, initialState, options, initialCompletedSteps, brainRunId, endAfter, signal, response, loopEvents, _this_options, adapters, client, resources, pages, env, resolvedEnv, machineInitialState, initialStepCount, machine, loopResumeContext, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, cancelledEvent;
                     var _arguments = arguments;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
@@ -338,20 +339,23 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                 _ref = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {}, _ref_initialState = _ref.initialState, initialState = _ref_initialState === void 0 ? {} : _ref_initialState, options = _ref.options, initialCompletedSteps = _ref.initialCompletedSteps, brainRunId = _ref.brainRunId, endAfter = _ref.endAfter, signal = _ref.signal, response = _ref.response, loopEvents = _ref.loopEvents;
                                 _this_options = this.options, adapters = _this_options.adapters, client = _this_options.client, resources = _this_options.resources, pages = _this_options.pages, env = _this_options.env;
                                 resolvedEnv = env !== null && env !== void 0 ? env : DEFAULT_ENV;
-                                currentState = initialState !== null && initialState !== void 0 ? initialState : {};
-                                stepNumber = 1;
-                                // Apply any patches from completed steps
-                                // to the initial state so that the brain
-                                // starts with a state that reflects all of the completed steps.
-                                // Need to do this when a brain is restarted with completed steps.
+                                // Apply any patches from completed steps to get the initial state
+                                // for the state machine. The machine will then track all subsequent state changes.
+                                machineInitialState = initialState !== null && initialState !== void 0 ? initialState : {};
+                                initialStepCount = 0;
                                 initialCompletedSteps === null || initialCompletedSteps === void 0 ? void 0 : initialCompletedSteps.forEach(function(step) {
                                     if (step.patch) {
-                                        currentState = applyPatches(currentState, [
+                                        machineInitialState = applyPatches(machineInitialState, [
                                             step.patch
                                         ]);
-                                        stepNumber++;
+                                        initialStepCount++;
                                     }
                                 });
+                                // Create state machine with pre-populated state
+                                // The machine tracks: currentState, isTopLevel, topLevelStepCount, etc.
+                                machine = createBrainExecutionMachine({
+                                    initialState: machineInitialState
+                                });
                                 // If loopEvents and response are provided, reconstruct loop context
                                 loopResumeContext = loopEvents && response ? reconstructLoopContext(loopEvents, response) : null;
                                 brainRun = brainRunId && initialCompletedSteps ? brain.run({
@@ -392,7 +396,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                     14
                                 ]);
                                 _loop = function() {
-                                    var _value, event, cancelledEvent;
+                                    var _value, event, cancelledEvent, totalSteps;
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
                                             case 0:
@@ -402,15 +406,9 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                                     3,
                                                     2
                                                 ];
-                                                // Emit a cancelled event
-                                                cancelledEvent = {
-                                                    type: BRAIN_EVENTS.CANCELLED,
-                                                    status: STATUS.CANCELLED,
-                                                    brainTitle: brain.title,
-                                                    brainDescription: brain.structure.description,
-                                                    brainRunId: brainRunId || event.brainRunId,
-                                                    options: event.options
-                                                };
+                                                // Use state machine to create cancelled event
+                                                sendAction(machine, BRAIN_ACTIONS.CANCEL_BRAIN, {});
+                                                cancelledEvent = machine.context.currentEvent;
                                                 return [
                                                     4,
                                                     Promise.all(adapters.map(function(adapter) {
@@ -419,13 +417,16 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                                 ];
                                             case 1:
                                                 _state.sent();
+                                                // Cast is safe: state started as TState and patches maintain the structure
                                                 return [
                                                     2,
                                                     {
-                                                        v: currentState
+                                                        v: machine.context.currentState
                                                     }
                                                 ];
                                             case 2:
+                                                // Feed event to state machine - this updates currentState, isTopLevel, stepCount, etc.
+                                                sendEvent(machine, event);
                                                 // Dispatch event to all adapters
                                                 return [
                                                     4,
@@ -435,30 +436,28 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                                 ];
                                             case 3:
                                                 _state.sent();
-                                                // Update current state when steps complete
-                                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE) {
-                                                    if (event.patch) {
-                                                        currentState = applyPatches(currentState, [
-                                                            event.patch
-                                                        ]);
-                                                    }
-                                                    // Check if we should stop after this step
-                                                    if (endAfter && stepNumber >= endAfter) {
+                                                // Check if we should stop after this step (only for top-level steps)
+                                                // The machine's topLevelStepCount tracks steps since this run started,
+                                                // so we add initialStepCount to get the total step count.
+                                                if (event.type === BRAIN_EVENTS.STEP_COMPLETE && machine.context.isTopLevel) {
+                                                    totalSteps = machine.context.topLevelStepCount + initialStepCount;
+                                                    if (endAfter && totalSteps >= endAfter) {
+                                                        // Cast is safe: state started as TState and patches maintain the structure
                                                         return [
                                                             2,
                                                             {
-                                                                v: currentState
+                                                                v: machine.context.currentState
                                                             }
                                                         ];
                                                     }
-                                                    stepNumber++;
                                                 }
-                                                // Stop execution when webhook event is encountered
-                                                if (event.type === BRAIN_EVENTS.WEBHOOK) {
+                                                // Stop execution when machine enters paused state (webhook)
+                                                if (machine.context.isPaused) {
+                                                    // Cast is safe: state started as TState and patches maintain the structure
                                                     return [
                                                         2,
                                                         {
-                                                            v: currentState
+                                                            v: machine.context.currentState
                                                         }
                                                     ];
                                                 }
@@ -555,14 +554,8 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                     3,
                                     17
                                 ];
-                                cancelledEvent = {
-                                    type: BRAIN_EVENTS.CANCELLED,
-                                    status: STATUS.CANCELLED,
-                                    brainTitle: brain.title,
-                                    brainDescription: brain.structure.description,
-                                    brainRunId: brainRunId || '',
-                                    options: options || {}
-                                };
+                                sendAction(machine, BRAIN_ACTIONS.CANCEL_BRAIN, {});
+                                cancelledEvent = machine.context.currentEvent;
                                 return [
                                     4,
                                     Promise.all(adapters.map(function(adapter) {
@@ -571,16 +564,18 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                 ];
                             case 16:
                                 _state.sent();
+                                // Cast is safe: state started as TState and patches maintain the structure
                                 return [
                                     2,
-                                    currentState
+                                    machine.context.currentState
                                 ];
                             case 17:
                                 throw error;
                             case 18:
+                                // Cast is safe: state started as TState and patches maintain the structure
                                 return [
                                     2,
-                                    currentState
+                                    machine.context.currentState
                                 ];
                         }
                     });