@positronic/core 0.0.77 → 0.0.78

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

@@ -1,11 +1,3 @@
-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_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
 function _async_iterator(iterable) {
     var method, async, sync, retry = 2;
     for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
@@ -108,66 +100,10 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread 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 _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
 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 _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -276,39 +212,6 @@ function _ts_values(o) {
 import { BRAIN_EVENTS, STATUS } from './constants.js';
 import { createBrainExecutionMachine, sendEvent } from './brain-state-machine.js';
 import { DEFAULT_ENV } from './brain.js';
-/**
- * Convert execution stack to ResumeContext tree.
- * Adds agent context to the deepest level.
- * Webhook response is no longer passed here - it comes from signals during execution.
- * This is internal to BrainRunner - external consumers don't need to know about ResumeContext.
- */ function executionStackToResumeContext(stack, agentContext, iterateContext, currentPage) {
-    if (stack.length === 0) {
-        throw new Error('Cannot convert empty execution stack to ResumeContext');
-    }
-    // Build from bottom of stack up (deepest to root)
-    var context;
-    for(var i = stack.length - 1; i >= 0; i--){
-        var entry = stack[i];
-        if (i === stack.length - 1) {
-            // Deepest level - add agent context, iterate progress, and page context
-            context = {
-                stepIndex: entry.stepIndex,
-                state: entry.state,
-                agentContext: agentContext !== null && agentContext !== void 0 ? agentContext : undefined,
-                iterateProgress: iterateContext !== null && iterateContext !== void 0 ? iterateContext : undefined,
-                currentPage: currentPage !== null && currentPage !== void 0 ? currentPage : undefined
-            };
-        } else {
-            // Outer level - wrap inner context
-            context = {
-                stepIndex: entry.stepIndex,
-                state: entry.state,
-                innerResumeContext: context
-            };
-        }
-    }
-    return context;
-}
 /**
  * Create a CANCELLED event for when the brain is aborted via signal.
  * This is synthesized by the runner, not yielded from the brain's event stream.
@@ -323,75 +226,16 @@ import { DEFAULT_ENV } from './brain.js';
 }
 export var BrainRunner = /*#__PURE__*/ function() {
     "use strict";
-    function BrainRunner(options) {
+    function BrainRunner(config) {
         _class_call_check(this, BrainRunner);
-        _define_property(this, "options", void 0);
-        this.options = options;
+        _define_property(this, "config", void 0);
+        this.config = config;
     }
     _create_class(BrainRunner, [
         {
-            key: "withAdapters",
-            value: function withAdapters(adapters) {
-                var _this_options = this.options, existingAdapters = _this_options.adapters;
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    adapters: _to_consumable_array(existingAdapters).concat(_to_consumable_array(adapters))
-                }));
-            }
-        },
-        {
-            key: "withClient",
-            value: function withClient(client) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    client: client
-                }));
-            }
-        },
-        {
-            key: "withResources",
-            value: function withResources(resources) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    resources: resources
-                }));
-            }
-        },
-        {
-            key: "withPages",
-            value: function withPages(pages) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    pages: pages
-                }));
-            }
-        },
-        {
-            key: "withEnv",
-            value: function withEnv(env) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    env: env
-                }));
-            }
-        },
-        {
-            key: "withSignalProvider",
-            value: function withSignalProvider(signalProvider) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    signalProvider: signalProvider
-                }));
-            }
-        },
-        {
-            key: "withGovernor",
-            value: function withGovernor(governor) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    governor: governor
-                }));
-            }
-        },
-        {
-            key: "withStoreProvider",
-            value: function withStoreProvider(storeProvider) {
-                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
-                    storeProvider: storeProvider
-                }));
+            key: "client",
+            get: function get() {
+                return this.config.client;
             }
         },
         {
@@ -424,28 +268,37 @@ export var BrainRunner = /*#__PURE__*/ function() {
             value: /**
    * Resume a brain from a previous execution point.
    * The machine should have historical events already replayed to reconstruct execution state.
-   * The BrainRunner will derive the ResumeContext from the machine's execution stack.
+   * The BrainRunner builds a ResumeParams from the machine's execution stack.
    * Webhook response data comes from signals, not as a parameter.
    */ function resume(brain, options) {
                 return _async_to_generator(function() {
-                    var machine, brainRunId, brainOptions, endAfter, signal, currentUser, _machine_context, executionStack, agentContext, iterateContext, currentPage, resumeContext;
+                    var machine, brainRunId, brainOptions, endAfter, signal, currentUser, _machine_context, executionStack, iterateContext, currentPage, promptLoopContext, topEntry, innerStack;
                     return _ts_generator(this, function(_state) {
                         machine = options.machine, brainRunId = options.brainRunId, brainOptions = options.options, endAfter = options.endAfter, signal = options.signal, currentUser = options.currentUser;
-                        // Build ResumeContext from machine's execution stack
-                        // Webhook response comes from signals during execution, not from resume parameters
-                        _machine_context = machine.context, executionStack = _machine_context.executionStack, agentContext = _machine_context.agentContext, iterateContext = _machine_context.iterateContext, currentPage = _machine_context.currentPage;
-                        resumeContext = executionStackToResumeContext(executionStack, agentContext, iterateContext, currentPage);
+                        _machine_context = machine.context, executionStack = _machine_context.executionStack, iterateContext = _machine_context.iterateContext, currentPage = _machine_context.currentPage, promptLoopContext = _machine_context.promptLoopContext;
+                        if (executionStack.length === 0) {
+                            throw new Error('Cannot resume from empty execution stack');
+                        }
+                        topEntry = executionStack[0];
+                        innerStack = executionStack.length > 1 ? executionStack.slice(1) : undefined;
                         return [
                             2,
                             this.execute(brain, {
-                                resumeContext: resumeContext,
+                                resume: {
+                                    state: topEntry.state,
+                                    stepIndex: topEntry.stepIndex,
+                                    innerStack: innerStack,
+                                    iterateProgress: iterateContext !== null && iterateContext !== void 0 ? iterateContext : undefined,
+                                    currentPage: currentPage !== null && currentPage !== void 0 ? currentPage : undefined,
+                                    promptLoopContext: promptLoopContext !== null && promptLoopContext !== void 0 ? promptLoopContext : undefined
+                                },
                                 machine: machine,
                                 options: brainOptions,
                                 brainRunId: brainRunId,
                                 endAfter: endAfter,
                                 signal: signal,
                                 currentUser: currentUser,
-                                initialStepCount: resumeContext.stepIndex
+                                initialStepCount: topEntry.stepIndex
                             })
                         ];
                     });
@@ -458,43 +311,45 @@ export var BrainRunner = /*#__PURE__*/ function() {
    * Internal execution method shared by run() and resume().
    */ function execute(brain, params) {
                 return _async_to_generator(function() {
-                    var _this_options, adapters, rawClient, resources, pages, env, signalProvider, governor, storeProvider, client, resolvedEnv, initialState, resumeContext, providedMachine, options, brainRunId, endAfter, signal, currentUser, initialStepCount, _resumeContext_state, _ref, machine, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, _machine_context_brainRunId, cancelledEvent;
+                    var _this_config, rawClient, adapters, env, resources, signalProvider, governor, files, pages, storeProvider, client, resolvedEnv, initialState, resume, providedMachine, options, brainRunId, endAfter, signal, currentUser, initialStepCount, _resume_state, _ref, machine, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, _machine_context_brainRunId, cancelledEvent;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                _this_options = this.options, adapters = _this_options.adapters, rawClient = _this_options.client, resources = _this_options.resources, pages = _this_options.pages, env = _this_options.env, signalProvider = _this_options.signalProvider, governor = _this_options.governor, storeProvider = _this_options.storeProvider;
+                                _this_config = this.config, rawClient = _this_config.client, adapters = _this_config.adapters, env = _this_config.env, resources = _this_config.resources, signalProvider = _this_config.signalProvider, governor = _this_config.governor, files = _this_config.files, pages = _this_config.pages, storeProvider = _this_config.storeProvider;
                                 client = governor ? governor(rawClient) : rawClient;
                                 resolvedEnv = env !== null && env !== void 0 ? env : DEFAULT_ENV;
-                                initialState = params.initialState, resumeContext = params.resumeContext, providedMachine = params.machine, options = params.options, brainRunId = params.brainRunId, endAfter = params.endAfter, signal = params.signal, currentUser = params.currentUser, initialStepCount = params.initialStepCount;
+                                initialState = params.initialState, resume = params.resume, providedMachine = params.machine, options = params.options, brainRunId = params.brainRunId, endAfter = params.endAfter, signal = params.signal, currentUser = params.currentUser, initialStepCount = params.initialStepCount;
                                 // Use provided state machine if available (for resumes with historical events),
                                 // otherwise create a new one
                                 machine = providedMachine !== null && providedMachine !== void 0 ? providedMachine : createBrainExecutionMachine({
-                                    initialState: (_ref = (_resumeContext_state = resumeContext === null || resumeContext === void 0 ? void 0 : resumeContext.state) !== null && _resumeContext_state !== void 0 ? _resumeContext_state : initialState) !== null && _ref !== void 0 ? _ref : {}
+                                    initialState: (_ref = (_resume_state = resume === null || resume === void 0 ? void 0 : resume.state) !== null && _resume_state !== void 0 ? _resume_state : initialState) !== null && _ref !== void 0 ? _ref : {}
                                 });
-                                brainRun = resumeContext ? brain.run({
-                                    resumeContext: resumeContext,
+                                brainRun = resume ? brain.run({
+                                    resume: resume,
                                     brainRunId: brainRunId,
                                     options: options,
                                     client: client,
                                     resources: resources !== null && resources !== void 0 ? resources : {},
-                                    pages: pages,
                                     env: resolvedEnv,
                                     signalProvider: signalProvider,
                                     governor: governor,
-                                    storeProvider: storeProvider,
-                                    currentUser: currentUser
+                                    currentUser: currentUser,
+                                    files: files,
+                                    pages: pages,
+                                    storeProvider: storeProvider
                                 }) : brain.run({
                                     initialState: initialState !== null && initialState !== void 0 ? initialState : {},
                                     options: options,
                                     client: client,
                                     brainRunId: brainRunId,
                                     resources: resources !== null && resources !== void 0 ? resources : {},
-                                    pages: pages,
                                     env: resolvedEnv,
                                     signalProvider: signalProvider,
                                     governor: governor,
-                                    storeProvider: storeProvider,
-                                    currentUser: currentUser
+                                    currentUser: currentUser,
+                                    files: files,
+                                    pages: pages,
+                                    storeProvider: storeProvider
                                 });
                                 _state.label = 1;
                             case 1:

package/dist/src/dsl/brain-state-machine.js

@@ -125,8 +125,8 @@ var createInitialContext = function(opts) {
         pendingWebhooks: null,
         currentState: (_opts_initialState = opts === null || opts === void 0 ? void 0 : opts.initialState) !== null && _opts_initialState !== void 0 ? _opts_initialState : {},
         options: (_opts_options = opts === null || opts === void 0 ? void 0 : opts.options) !== null && _opts_options !== void 0 ? _opts_options : {},
-        agentContext: null,
         iterateContext: null,
+        promptLoopContext: null,
         currentPage: null,
         status: STATUS.PENDING,
         isTopLevel: false,
@@ -136,9 +136,7 @@ var createInitialContext = function(opts) {
         isWaiting: false,
         isError: false,
         isCancelled: false,
-        isInAgentLoop: false,
-        topLevelStepCount: 0,
-        totalTokens: 0
+        topLevelStepCount: 0
     };
 };
 // ============================================================================
@@ -146,7 +144,6 @@ var createInitialContext = function(opts) {
 // ============================================================================
 var updateDerivedState = function(ctx, executionState) {
     // Map ExecutionState to STATUS - this gives consumers the authoritative status
-    // Note: agentLoop maps to RUNNING publicly (consumers don't need to know the difference)
     var status;
     switch(executionState){
         case 'idle':
@@ -155,9 +152,6 @@ var updateDerivedState = function(ctx, executionState) {
         case 'running':
             status = STATUS.RUNNING;
             break;
-        case 'agentLoop':
-            status = STATUS.RUNNING; // Publicly still "running"
-            break;
         case 'paused':
             status = STATUS.PAUSED;
             break;
@@ -179,13 +173,12 @@ var updateDerivedState = function(ctx, executionState) {
     return _object_spread_props(_object_spread({}, ctx), {
         status: status,
         isTopLevel: ctx.depth === 1,
-        isRunning: executionState === 'running' || executionState === 'agentLoop',
+        isRunning: executionState === 'running',
         isComplete: executionState === 'complete',
         isPaused: executionState === 'paused',
         isWaiting: executionState === 'waiting',
         isError: executionState === 'error',
-        isCancelled: executionState === 'cancelled',
-        isInAgentLoop: executionState === 'agentLoop'
+        isCancelled: executionState === 'cancelled'
     });
 };
 // ============================================================================
@@ -287,8 +280,7 @@ var completeInnerBrainError = reduce(function(ctx, param) {
         brainIdStack: brainIdStack.slice(0, -1),
         executionStack: executionStack.slice(0, -1),
         depth: depth - 1,
-        error: error,
-        agentContext: null
+        error: error
     });
     return updateDerivedState(newCtx, 'running');
 });
@@ -336,7 +328,7 @@ var startStep = reduce(function(ctx, param) {
 });
 var completeStep = reduce(function(ctx, param) {
     var stepId = param.stepId, stepTitle = param.stepTitle, patch = param.patch, halted = param.halted, pageContext = param.pageContext;
-    var _ctx_iterateContext;
+    var _ctx_iterateContext, _ctx_promptLoopContext;
     var brains = ctx.brains, brainIdStack = ctx.brainIdStack, executionStack = ctx.executionStack, depth = ctx.depth, currentState = ctx.currentState, topLevelStepCount = ctx.topLevelStepCount;
     if (brainIdStack.length === 0) return ctx;
     // === NEW: Update flat structures ===
@@ -394,7 +386,9 @@ var completeStep = reduce(function(ctx, param) {
     // Only clear iterateContext when the iterate step itself completes,
     // not when inner brain steps complete during iteration
     var newIterateContext = ((_ctx_iterateContext = ctx.iterateContext) === null || _ctx_iterateContext === void 0 ? void 0 : _ctx_iterateContext.stepId) === stepId ? null : ctx.iterateContext;
-    // Track page context: set when UI step completes (has pageContext),
+    // Clear promptLoopContext when the prompt step completes
+    var newPromptLoopContext = ((_ctx_promptLoopContext = ctx.promptLoopContext) === null || _ctx_promptLoopContext === void 0 ? void 0 : _ctx_promptLoopContext.stepId) === stepId ? null : ctx.promptLoopContext;
+    // Track page context: set when page step completes (has pageContext),
     // clear when the next step completes (page is ephemeral)
     var newCurrentPage = pageContext !== null && pageContext !== void 0 ? pageContext : null;
     return _object_spread_props(_object_spread({}, ctx), {
@@ -403,6 +397,7 @@ var completeStep = reduce(function(ctx, param) {
         currentState: newState1,
         topLevelStepCount: newStepCount,
         iterateContext: newIterateContext,
+        promptLoopContext: newPromptLoopContext,
         currentPage: newCurrentPage
     });
 });
@@ -419,9 +414,6 @@ var pauseBrain = reduce(function(ctx) {
 var resumeBrain = reduce(function(ctx) {
     return updateDerivedState(ctx, 'running');
 });
-var resumeToAgentLoop = reduce(function(ctx) {
-    return updateDerivedState(ctx, 'agentLoop');
-});
 var webhookResponse = reduce(function(ctx) {
     var newCtx = _object_spread_props(_object_spread({}, ctx), {
         pendingWebhooks: null
@@ -460,12 +452,6 @@ var stepStatus = reduce(function(ctx, param) {
         brains: newBrains
     });
 });
-// passthrough is now a no-op - we just let the event pass through
-var passthrough = function() {
-    return reduce(function(ctx) {
-        return ctx;
-    });
-};
 // Reducer for ITERATE_ITEM_COMPLETE - appends a single item result into iterateContext
 var iterateItemComplete = reduce(function(ctx, payload) {
     var existing = ctx.iterateContext;
@@ -480,72 +466,68 @@ var iterateItemComplete = reduce(function(ctx, payload) {
             accumulatedResults: newResults,
             processedCount: payload.processedCount,
             totalItems: payload.totalItems,
-            schemaName: payload.schemaName
+            stateKey: payload.stateKey
         }
     });
 });
-// Reducer for agent iteration events that tracks tokens per-iteration
-// This ensures tokens are counted even if the agent doesn't complete (e.g., webhook interruption)
-var agentIteration = reduce(function(ctx, ev) {
-    var totalTokens = ctx.totalTokens;
-    var _ev_tokensThisIteration;
-    return _object_spread_props(_object_spread({}, ctx), {
-        totalTokens: totalTokens + ((_ev_tokensThisIteration = ev.tokensThisIteration) !== null && _ev_tokensThisIteration !== void 0 ? _ev_tokensThisIteration : 0)
-    });
-});
-// Reducer for agent terminal events - clears agentContext since the agent has completed
-var agentTerminal = function() {
-    return reduce(function(ctx) {
-        return _object_spread_props(_object_spread({}, ctx), {
-            agentContext: null
-        });
-    });
-};
-// Reducer for AGENT_START - initializes agentContext
-var agentStart = reduce(function(ctx, param) {
+// Prompt loop reducers
+// responseMessages and pendingToolCallId/Name are tracked here because on
+// resume the DO replays persisted events through a fresh state machine to
+// reconstruct context, then runner.resume() extracts promptLoopContext to
+// pass into the new event stream's ResumeParams.
+var promptStart = reduce(function(ctx, param) {
     var stepId = param.stepId, stepTitle = param.stepTitle, prompt = param.prompt, system = param.system;
-    var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        agentContext: {
+    return _object_spread_props(_object_spread({}, ctx), {
+        promptLoopContext: {
             stepId: stepId,
             stepTitle: stepTitle,
             prompt: prompt,
             system: system,
             responseMessages: [],
             pendingToolCallId: null,
-            pendingToolName: null
+            pendingToolName: null,
+            iteration: 0,
+            totalTokens: 0
         }
     });
-    return updateDerivedState(newCtx, 'agentLoop');
 });
-// Reducer for AGENT_RAW_RESPONSE_MESSAGE - accumulates messages in agentContext
-var agentRawResponseMessage = reduce(function(ctx, param) {
+var promptIteration = reduce(function(ctx, param) {
+    var iteration = param.iteration, totalTokens = param.totalTokens;
+    if (!ctx.promptLoopContext) return ctx;
+    return _object_spread_props(_object_spread({}, ctx), {
+        promptLoopContext: _object_spread_props(_object_spread({}, ctx.promptLoopContext), {
+            iteration: iteration,
+            totalTokens: totalTokens
+        })
+    });
+});
+var promptRawMessage = reduce(function(ctx, param) {
     var message = param.message;
-    var agentContext = ctx.agentContext;
-    // Accumulate the message in agentContext
-    var updatedAgentContext = agentContext ? _object_spread_props(_object_spread({}, agentContext), {
-        responseMessages: _to_consumable_array(agentContext.responseMessages).concat([
-            message
-        ])
-    }) : null;
+    if (!ctx.promptLoopContext) return ctx;
+    // Replace, don't append — each emission carries the full conversation
+    // history from generateText (the SDK accumulates internally)
     return _object_spread_props(_object_spread({}, ctx), {
-        agentContext: updatedAgentContext
+        promptLoopContext: _object_spread_props(_object_spread({}, ctx.promptLoopContext), {
+            responseMessages: message
+        })
     });
 });
-// Reducer for AGENT_WEBHOOK - records pending tool call in agentContext
-var agentWebhook = reduce(function(ctx, param) {
+var promptWebhook = reduce(function(ctx, param) {
     var toolCallId = param.toolCallId, toolName = param.toolName;
-    var agentContext = ctx.agentContext;
-    // Update agentContext with pending tool info
-    var updatedAgentContext = agentContext ? _object_spread_props(_object_spread({}, agentContext), {
-        pendingToolCallId: toolCallId,
-        pendingToolName: toolName
-    }) : null;
+    if (!ctx.promptLoopContext) return ctx;
     return _object_spread_props(_object_spread({}, ctx), {
-        agentContext: updatedAgentContext
+        promptLoopContext: _object_spread_props(_object_spread({}, ctx.promptLoopContext), {
+            pendingToolCallId: toolCallId,
+            pendingToolName: toolName
+        })
     });
 });
-// Reducer for AGENT_USER_MESSAGE - no-op, just stays in agentLoop
-var agentUserMessage = reduce(function(ctx) {
+var promptComplete = reduce(function(ctx) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        promptLoopContext: null
+    });
+});
+var passthrough = reduce(function(ctx) {
     return ctx;
 });
 // ============================================================================
@@ -557,25 +539,9 @@ var isOuterBrain = guard(function(ctx) {
 var isInnerBrain = guard(function(ctx) {
     return ctx.depth > 1;
 });
-// Guard to check if we have agentContext (for resuming to agentLoop)
-var hasAgentContext = guard(function(ctx) {
-    return ctx.agentContext !== null;
-});
 // ============================================================================
 // State Machine Definition
 // ============================================================================
-// Define agent loop transitions as a reusable array for cleaner code
-var agentLoopTransitions = [
-    // Agent micro-events that stay in agentLoop
-    transition(BRAIN_EVENTS.AGENT_ITERATION, 'agentLoop', agentIteration),
-    transition(BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE, 'agentLoop', agentRawResponseMessage),
-    transition(BRAIN_EVENTS.AGENT_TOOL_CALL, 'agentLoop', passthrough()),
-    transition(BRAIN_EVENTS.AGENT_TOOL_RESULT, 'agentLoop', passthrough()),
-    transition(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE, 'agentLoop', passthrough()),
-    transition(BRAIN_EVENTS.AGENT_USER_MESSAGE, 'agentLoop', agentUserMessage),
-    // AGENT_WEBHOOK records pending tool call but stays in agentLoop
-    transition(BRAIN_EVENTS.AGENT_WEBHOOK, 'agentLoop', agentWebhook)
-];
 // Internal machine factory - called with pre-built context
 var makeBrainMachine = function(initialContext) {
     return createMachine('idle', {
@@ -588,41 +554,21 @@ var makeBrainMachine = function(initialContext) {
         transition(BRAIN_EVENTS.ERROR, 'error', isOuterBrain, errorBrain), // Inner brain error -> stay running (pop the inner brain off the stack)
         transition(BRAIN_EVENTS.ERROR, 'running', isInnerBrain, completeInnerBrainError), // Cancelled
         transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // Paused (by signal)
-        transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain), // Webhook -> waiting (for non-agent webhooks)
-        transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause), // Webhook response (for resume from non-agent webhook)
+        transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain), // Webhook -> waiting
+        transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause), // Webhook response
         transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), // Step events
         transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), // Iterate item complete - stays in running, accumulates results
-        transition(BRAIN_EVENTS.ITERATE_ITEM_COMPLETE, 'running', iterateItemComplete), // AGENT_START transitions to the agentLoop state
-        transition(BRAIN_EVENTS.AGENT_START, 'agentLoop', agentStart)),
-        // Explicit agent loop state - isolates agent execution logic
-        agentLoop: state.apply(void 0, // Spread agent micro-transitions
-        _to_consumable_array(agentLoopTransitions).concat([
-            // Exit strategies - agent terminal events return to running
-            transition(BRAIN_EVENTS.AGENT_COMPLETE, 'running', agentTerminal()),
-            transition(BRAIN_EVENTS.AGENT_TOKEN_LIMIT, 'running', agentTerminal()),
-            transition(BRAIN_EVENTS.AGENT_ITERATION_LIMIT, 'running', agentTerminal()),
-            // Interruption handling - can pause or wait from agentLoop
-            transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain),
-            transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause),
-            // Error handling
-            transition(BRAIN_EVENTS.ERROR, 'error', isOuterBrain, errorBrain),
-            // Inner brain error -> back to running (pop inner brain, clear agentContext)
-            transition(BRAIN_EVENTS.ERROR, 'running', isInnerBrain, completeInnerBrainError),
-            transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain)
-        ])),
+        transition(BRAIN_EVENTS.ITERATE_ITEM_COMPLETE, 'running', iterateItemComplete), // Prompt loop events - stay in running, update promptLoopContext
+        transition(BRAIN_EVENTS.PROMPT_START, 'running', promptStart), transition(BRAIN_EVENTS.PROMPT_ITERATION, 'running', promptIteration), transition(BRAIN_EVENTS.PROMPT_TOOL_CALL, 'running', passthrough), transition(BRAIN_EVENTS.PROMPT_TOOL_RESULT, 'running', passthrough), transition(BRAIN_EVENTS.PROMPT_ASSISTANT_MESSAGE, 'running', passthrough), transition(BRAIN_EVENTS.PROMPT_COMPLETE, 'running', promptComplete), transition(BRAIN_EVENTS.PROMPT_TOKEN_LIMIT, 'running', promptComplete), transition(BRAIN_EVENTS.PROMPT_ITERATION_LIMIT, 'running', promptComplete), transition(BRAIN_EVENTS.PROMPT_RAW_RESPONSE_MESSAGE, 'running', promptRawMessage), transition(BRAIN_EVENTS.PROMPT_WEBHOOK, 'running', promptWebhook)),
         paused: state(transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // RESUMED transitions out of paused state without creating a new brain
-        // If we have agentContext, resume to agentLoop; otherwise to running
-        transition(BRAIN_EVENTS.RESUMED, 'agentLoop', hasAgentContext, resumeToAgentLoop), transition(BRAIN_EVENTS.RESUMED, 'running', resumeBrain), // START is kept for backwards compatibility but RESUMED is preferred
-        transition(BRAIN_EVENTS.START, 'agentLoop', hasAgentContext, startBrain), transition(BRAIN_EVENTS.START, 'running', startBrain)),
+        transition(BRAIN_EVENTS.RESUMED, 'running', resumeBrain), // START is kept for backwards compatibility but RESUMED is preferred
+        transition(BRAIN_EVENTS.START, 'running', startBrain)),
         waiting: state(// TODO: Could add PAUSED transition here to allow pausing a waiting brain.
         // This would require queueing webhook responses (similar to USER_MESSAGE signals)
         // so they can be processed when the brain is resumed.
-        // Webhook response - if we have agentContext, go back to agentLoop
-        transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'agentLoop', hasAgentContext, webhookResponse), // Otherwise go to running
         transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // RESUMED transitions out of waiting (e.g., timeout-triggered wakeUp with no webhook response)
         transition(BRAIN_EVENTS.RESUMED, 'running', resumeBrain), // START can resume from waiting (after webhook response is processed)
-        // If we have agentContext, resume to agentLoop; otherwise to running
-        transition(BRAIN_EVENTS.START, 'agentLoop', hasAgentContext, startBrain), transition(BRAIN_EVENTS.START, 'running', startBrain)),
+        transition(BRAIN_EVENTS.START, 'running', startBrain)),
         // Terminal states - limited outgoing transitions
         complete: state(),
         error: state(// Allow STEP_STATUS after error so we can emit the final step statuses

package/dist/src/dsl/brain.js

@@ -1,5 +1,6 @@
 // Re-export from new modular structure for backwards compatibility
 // Builder
 export { Brain, brain } from './builder/brain.js';
+export { Continuation } from './builder/continuation.js';
 // Execution - Constants
 export { DEFAULT_ENV } from './execution/constants.js';