@positronic/core 0.0.56 → 0.0.57

package/dist/src/dsl/agent-messages.js

@@ -1,76 +1,5 @@
-import { BRAIN_EVENTS } from './constants.js';
 /**
- * Reconstructs the agent context from stored events and a webhook response.
- * Returns null if this is not an agent resume (no AGENT_WEBHOOK event found).
- */ export function reconstructAgentContext(events, webhookResponse) {
-    // Find AGENT_WEBHOOK event - if not present, this is not an agent resume
-    var agentWebhookEvent = events.find(function(e) {
-        return e.type === BRAIN_EVENTS.AGENT_WEBHOOK;
-    });
-    if (!agentWebhookEvent) {
-        return null;
-    }
-    // Find AGENT_START to get the initial prompt and system
-    var agentStartEvent = events.find(function(e) {
-        return e.type === BRAIN_EVENTS.AGENT_START;
-    });
-    if (!agentStartEvent) {
-        throw new Error('AGENT_START event not found but AGENT_WEBHOOK exists - invalid event sequence');
-    }
-    var messages = [];
-    // Add initial user message from the prompt
-    messages.push({
-        role: 'user',
-        content: agentStartEvent.prompt
-    });
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        // Process events in order to rebuild conversation
-        for(var _iterator = events[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var event = _step.value;
-            if (event.type === BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE) {
-                var assistantEvent = event;
-                messages.push({
-                    role: 'assistant',
-                    content: assistantEvent.content
-                });
-            } else if (event.type === BRAIN_EVENTS.AGENT_TOOL_RESULT) {
-                var toolResultEvent = event;
-                messages.push({
-                    role: 'tool',
-                    content: JSON.stringify(toolResultEvent.result),
-                    toolCallId: toolResultEvent.toolCallId,
-                    toolName: toolResultEvent.toolName
-                });
-            }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    // Add the webhook response as the pending tool's result
-    messages.push({
-        role: 'tool',
-        content: JSON.stringify(webhookResponse),
-        toolCallId: agentWebhookEvent.toolCallId,
-        toolName: agentWebhookEvent.toolName
-    });
-    return {
-        messages: messages,
-        pendingToolCallId: agentWebhookEvent.toolCallId,
-        pendingToolName: agentWebhookEvent.toolName,
-        prompt: agentStartEvent.prompt,
-        system: agentStartEvent.system,
-        webhookResponse: webhookResponse
-    };
-}
+ * Context for resuming an agent execution.
+ * Extends the state machine's AgentContext with an optional webhook response.
+ * The webhook response is only present when resuming from a webhook (vs a pause).
+ */ export { };

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

@@ -273,11 +273,52 @@ function _ts_values(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-import { BRAIN_EVENTS } from './constants.js';
-import { applyPatches } from './json-patch.js';
-import { reconstructAgentContext } from './agent-messages.js';
+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) {
+    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 (webhook response comes from signals now)
+            context = {
+                stepIndex: entry.stepIndex,
+                state: entry.state,
+                agentContext: agentContext !== null && agentContext !== void 0 ? agentContext : 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.
+ */ function createCancelledEvent(brainRunId, options) {
+    return {
+        type: BRAIN_EVENTS.CANCELLED,
+        brainRunId: brainRunId,
+        brainTitle: '',
+        status: STATUS.CANCELLED,
+        options: options
+    };
+}
 export var BrainRunner = /*#__PURE__*/ function() {
     "use strict";
     function BrainRunner(options) {
@@ -327,56 +368,106 @@ export var BrainRunner = /*#__PURE__*/ function() {
                 }));
             }
         },
+        {
+            key: "withSignalProvider",
+            value: function withSignalProvider(signalProvider) {
+                return new BrainRunner(_object_spread_props(_object_spread({}, this.options), {
+                    signalProvider: signalProvider
+                }));
+            }
+        },
         {
             key: "run",
-            value: function run(_0) {
-                return _async_to_generator(function(brain) {
-                    var _ref, _ref_initialState, initialState, options, initialCompletedSteps, brainRunId, endAfter, signal, response, agentEvents, _this_options, adapters, client, resources, pages, env, resolvedEnv, machineInitialState, initialStepCount, machine, agentResumeContext, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, cancelledEvent;
-                    var _arguments = arguments;
+            value: /**
+   * Run a brain from the beginning with fresh state.
+   */ function run(brain, options) {
+                return _async_to_generator(function() {
+                    var _ref, _ref_initialState, initialState, brainOptions, brainRunId, endAfter, signal;
+                    return _ts_generator(this, function(_state) {
+                        _ref = options !== null && options !== void 0 ? options : {}, _ref_initialState = _ref.initialState, initialState = _ref_initialState === void 0 ? {} : _ref_initialState, brainOptions = _ref.options, brainRunId = _ref.brainRunId, endAfter = _ref.endAfter, signal = _ref.signal;
+                        return [
+                            2,
+                            this.execute(brain, {
+                                initialState: initialState,
+                                options: brainOptions,
+                                brainRunId: brainRunId,
+                                endAfter: endAfter,
+                                signal: signal,
+                                initialStepCount: 0
+                            })
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "resume",
+            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.
+   * 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, _machine_context, executionStack, agentContext, resumeContext;
+                    return _ts_generator(this, function(_state) {
+                        machine = options.machine, brainRunId = options.brainRunId, brainOptions = options.options, endAfter = options.endAfter, signal = options.signal;
+                        // 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;
+                        resumeContext = executionStackToResumeContext(executionStack, agentContext);
+                        return [
+                            2,
+                            this.execute(brain, {
+                                resumeContext: resumeContext,
+                                machine: machine,
+                                options: brainOptions,
+                                brainRunId: brainRunId,
+                                endAfter: endAfter,
+                                signal: signal,
+                                initialStepCount: resumeContext.stepIndex
+                            })
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "execute",
+            value: /**
+   * Internal execution method shared by run() and resume().
+   */ function execute(brain, params) {
+                return _async_to_generator(function() {
+                    var _this_options, adapters, client, resources, pages, env, signalProvider, resolvedEnv, initialState, resumeContext, providedMachine, options, brainRunId, endAfter, signal, initialStepCount, _resumeContext_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:
-                                _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, agentEvents = _ref.agentEvents;
-                                _this_options = this.options, adapters = _this_options.adapters, client = _this_options.client, resources = _this_options.resources, pages = _this_options.pages, env = _this_options.env;
+                                _this_options = this.options, adapters = _this_options.adapters, client = _this_options.client, resources = _this_options.resources, pages = _this_options.pages, env = _this_options.env, signalProvider = _this_options.signalProvider;
                                 resolvedEnv = env !== null && env !== void 0 ? env : DEFAULT_ENV;
-                                // 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) {
-                                        machineInitialState = applyPatches(machineInitialState, [
-                                            step.patch
-                                        ]);
-                                        initialStepCount++;
-                                    }
+                                initialState = params.initialState, resumeContext = params.resumeContext, providedMachine = params.machine, options = params.options, brainRunId = params.brainRunId, endAfter = params.endAfter, signal = params.signal, 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 : {}
                                 });
-                                // Create state machine with pre-populated state
-                                // The machine tracks: currentState, isTopLevel, topLevelStepCount, etc.
-                                machine = createBrainExecutionMachine({
-                                    initialState: machineInitialState
-                                });
-                                // If agentEvents and response are provided, reconstruct agent context
-                                agentResumeContext = agentEvents && response ? reconstructAgentContext(agentEvents, response) : null;
-                                brainRun = brainRunId && initialCompletedSteps ? brain.run({
-                                    initialState: initialState,
-                                    initialCompletedSteps: initialCompletedSteps,
+                                brainRun = resumeContext ? brain.run({
+                                    resumeContext: resumeContext,
                                     brainRunId: brainRunId,
                                     options: options,
                                     client: client,
                                     resources: resources !== null && resources !== void 0 ? resources : {},
                                     pages: pages,
                                     env: resolvedEnv,
-                                    response: response,
-                                    agentResumeContext: agentResumeContext
+                                    signalProvider: signalProvider
                                 }) : brain.run({
-                                    initialState: initialState,
+                                    initialState: initialState !== null && initialState !== void 0 ? initialState : {},
                                     options: options,
                                     client: client,
                                     brainRunId: brainRunId,
                                     resources: resources !== null && resources !== void 0 ? resources : {},
                                     pages: pages,
-                                    env: resolvedEnv
+                                    env: resolvedEnv,
+                                    signalProvider: signalProvider
                                 });
                                 _state.label = 1;
                             case 1:
@@ -396,7 +487,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                     14
                                 ]);
                                 _loop = function() {
-                                    var _value, event, cancelledEvent, totalSteps;
+                                    var _value, event, _machine_context_brainRunId, cancelledEvent, totalSteps;
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
                                             case 0:
@@ -406,11 +497,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                                     3,
                                                     2
                                                 ];
-                                                // Use state machine to create cancelled event
-                                                sendEvent(machine, {
-                                                    type: BRAIN_EVENTS.CANCELLED
-                                                });
-                                                cancelledEvent = machine.context.currentEvent;
+                                                cancelledEvent = createCancelledEvent((_machine_context_brainRunId = machine.context.brainRunId) !== null && _machine_context_brainRunId !== void 0 ? _machine_context_brainRunId : '', options !== null && options !== void 0 ? options : {});
                                                 return [
                                                     4,
                                                     Promise.all(adapters.map(function(adapter) {
@@ -453,8 +540,8 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                                         ];
                                                     }
                                                 }
-                                                // Stop execution when machine enters paused state (webhook)
-                                                if (machine.context.isPaused) {
+                                                // Stop execution when machine enters paused or waiting state
+                                                if (machine.context.isPaused || machine.context.isWaiting) {
                                                     // Cast is safe: state started as TState and patches maintain the structure
                                                     return [
                                                         2,
@@ -556,10 +643,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                     3,
                                     17
                                 ];
-                                sendEvent(machine, {
-                                    type: BRAIN_EVENTS.CANCELLED
-                                });
-                                cancelledEvent = machine.context.currentEvent;
+                                cancelledEvent = createCancelledEvent((_machine_context_brainRunId = machine.context.brainRunId) !== null && _machine_context_brainRunId !== void 0 ? _machine_context_brainRunId : '', options !== null && options !== void 0 ? options : {});
                                 return [
                                     4,
                                     Promise.all(adapters.map(function(adapter) {
@@ -583,7 +667,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                 ];
                         }
                     });
-                }).apply(this, arguments);
+                }).call(this);
             }
         }
     ]);