@positronic/core 0.0.52 → 0.0.54

package/dist/src/dsl/{loop-messages.js → agent-messages.js}

@@ -1,40 +1,40 @@
 import { BRAIN_EVENTS } from './constants.js';
 /**
- * Reconstructs the loop context from stored events and a webhook response.
- * Returns null if this is not a loop resume (no LOOP_WEBHOOK event found).
- */ export function reconstructLoopContext(events, webhookResponse) {
-    // Find LOOP_WEBHOOK event - if not present, this is not a loop resume
-    var loopWebhookEvent = events.find(function(e) {
-        return e.type === BRAIN_EVENTS.LOOP_WEBHOOK;
+ * 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 (!loopWebhookEvent) {
+    if (!agentWebhookEvent) {
         return null;
     }
-    // Find LOOP_START to get the initial prompt and system
-    var loopStartEvent = events.find(function(e) {
-        return e.type === BRAIN_EVENTS.LOOP_START;
+    // Find AGENT_START to get the initial prompt and system
+    var agentStartEvent = events.find(function(e) {
+        return e.type === BRAIN_EVENTS.AGENT_START;
     });
-    if (!loopStartEvent) {
-        throw new Error('LOOP_START event not found but LOOP_WEBHOOK exists - invalid event sequence');
+    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: loopStartEvent.prompt
+        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.LOOP_ASSISTANT_MESSAGE) {
+            if (event.type === BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE) {
                 var assistantEvent = event;
                 messages.push({
                     role: 'assistant',
                     content: assistantEvent.content
                 });
-            } else if (event.type === BRAIN_EVENTS.LOOP_TOOL_RESULT) {
+            } else if (event.type === BRAIN_EVENTS.AGENT_TOOL_RESULT) {
                 var toolResultEvent = event;
                 messages.push({
                     role: 'tool',
@@ -62,15 +62,15 @@ import { BRAIN_EVENTS } from './constants.js';
     messages.push({
         role: 'tool',
         content: JSON.stringify(webhookResponse),
-        toolCallId: loopWebhookEvent.toolCallId,
-        toolName: loopWebhookEvent.toolName
+        toolCallId: agentWebhookEvent.toolCallId,
+        toolName: agentWebhookEvent.toolName
     });
     return {
         messages: messages,
-        pendingToolCallId: loopWebhookEvent.toolCallId,
-        pendingToolName: loopWebhookEvent.toolName,
-        prompt: loopStartEvent.prompt,
-        system: loopStartEvent.system,
+        pendingToolCallId: agentWebhookEvent.toolCallId,
+        pendingToolName: agentWebhookEvent.toolName,
+        prompt: agentStartEvent.prompt,
+        system: agentStartEvent.system,
         webhookResponse: webhookResponse
     };
 }

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

@@ -275,7 +275,7 @@ function _ts_values(o) {
 }
 import { BRAIN_EVENTS } from './constants.js';
 import { applyPatches } from './json-patch.js';
-import { reconstructLoopContext } from './loop-messages.js';
+import { reconstructAgentContext } from './agent-messages.js';
 import { createBrainExecutionMachine, sendEvent } from './brain-state-machine.js';
 import { DEFAULT_ENV } from './brain.js';
 export var BrainRunner = /*#__PURE__*/ function() {
@@ -331,12 +331,12 @@ 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, machineInitialState, initialStepCount, machine, loopResumeContext, brainRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, _ret, err, error, cancelledEvent;
+                    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;
                     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, loopEvents = _ref.loopEvents;
+                                _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;
                                 resolvedEnv = env !== null && env !== void 0 ? env : DEFAULT_ENV;
                                 // Apply any patches from completed steps to get the initial state
@@ -356,8 +356,8 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                 machine = createBrainExecutionMachine({
                                     initialState: machineInitialState
                                 });
-                                // If loopEvents and response are provided, reconstruct loop context
-                                loopResumeContext = loopEvents && response ? reconstructLoopContext(loopEvents, response) : null;
+                                // 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,
@@ -368,7 +368,7 @@ export var BrainRunner = /*#__PURE__*/ function() {
                                     pages: pages,
                                     env: resolvedEnv,
                                     response: response,
-                                    loopResumeContext: loopResumeContext
+                                    agentResumeContext: agentResumeContext
                                 }) : brain.run({
                                     initialState: initialState,
                                     options: options,

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

@@ -661,8 +661,8 @@ var makeBrainMachine = function(initialContext) {
         transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // Webhook -> paused
         transition(BRAIN_EVENTS.WEBHOOK, 'paused', webhookPause), // Webhook response (for resume from webhook - machine is already running)
         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), transition(BRAIN_EVENTS.STEP_RETRY, 'running', stepRetry), // Loop events (pass-through with event data)
-        transition(BRAIN_EVENTS.LOOP_START, 'running', passthrough(BRAIN_EVENTS.LOOP_START)), transition(BRAIN_EVENTS.LOOP_ITERATION, 'running', passthrough(BRAIN_EVENTS.LOOP_ITERATION)), transition(BRAIN_EVENTS.LOOP_TOOL_CALL, 'running', passthrough(BRAIN_EVENTS.LOOP_TOOL_CALL)), transition(BRAIN_EVENTS.LOOP_TOOL_RESULT, 'running', passthrough(BRAIN_EVENTS.LOOP_TOOL_RESULT)), transition(BRAIN_EVENTS.LOOP_ASSISTANT_MESSAGE, 'running', passthrough(BRAIN_EVENTS.LOOP_ASSISTANT_MESSAGE)), transition(BRAIN_EVENTS.LOOP_COMPLETE, 'running', passthrough(BRAIN_EVENTS.LOOP_COMPLETE)), transition(BRAIN_EVENTS.LOOP_TOKEN_LIMIT, 'running', passthrough(BRAIN_EVENTS.LOOP_TOKEN_LIMIT)), transition(BRAIN_EVENTS.LOOP_WEBHOOK, 'running', passthrough(BRAIN_EVENTS.LOOP_WEBHOOK)), transition(BRAIN_EVENTS.HEARTBEAT, 'running', passthrough(BRAIN_EVENTS.HEARTBEAT))),
+        transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), transition(BRAIN_EVENTS.STEP_RETRY, 'running', stepRetry), // Agent events (pass-through with event data)
+        transition(BRAIN_EVENTS.AGENT_START, 'running', passthrough(BRAIN_EVENTS.AGENT_START)), transition(BRAIN_EVENTS.AGENT_ITERATION, 'running', passthrough(BRAIN_EVENTS.AGENT_ITERATION)), transition(BRAIN_EVENTS.AGENT_TOOL_CALL, 'running', passthrough(BRAIN_EVENTS.AGENT_TOOL_CALL)), transition(BRAIN_EVENTS.AGENT_TOOL_RESULT, 'running', passthrough(BRAIN_EVENTS.AGENT_TOOL_RESULT)), transition(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE, 'running', passthrough(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE)), transition(BRAIN_EVENTS.AGENT_COMPLETE, 'running', passthrough(BRAIN_EVENTS.AGENT_COMPLETE)), transition(BRAIN_EVENTS.AGENT_TOKEN_LIMIT, 'running', passthrough(BRAIN_EVENTS.AGENT_TOKEN_LIMIT)), transition(BRAIN_EVENTS.AGENT_WEBHOOK, 'running', passthrough(BRAIN_EVENTS.AGENT_WEBHOOK))),
         paused: state(transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // RESTART happens when resuming from webhook
         transition(BRAIN_EVENTS.RESTART, 'running', restartBrain)),
         // Terminal states - limited outgoing transitions