@positronic/core 0.0.61 → 0.0.62

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

@@ -281,7 +281,7 @@ import { DEFAULT_ENV } from './brain.js';
  * 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) {
+ */ function executionStackToResumeContext(stack, agentContext, batchContext) {
     if (stack.length === 0) {
         throw new Error('Cannot convert empty execution stack to ResumeContext');
     }
@@ -290,11 +290,12 @@ import { DEFAULT_ENV } from './brain.js';
     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)
+            // Deepest level - add agent context and batch progress (webhook response comes from signals now)
             context = {
                 stepIndex: entry.stepIndex,
                 state: entry.state,
-                agentContext: agentContext !== null && agentContext !== void 0 ? agentContext : undefined
+                agentContext: agentContext !== null && agentContext !== void 0 ? agentContext : undefined,
+                batchProgress: batchContext !== null && batchContext !== void 0 ? batchContext : undefined
             };
         } else {
             // Outer level - wrap inner context
@@ -409,13 +410,13 @@ export var BrainRunner = /*#__PURE__*/ function() {
    * 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;
+                    var machine, brainRunId, brainOptions, endAfter, signal, _machine_context, executionStack, agentContext, batchContext, 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);
+                        _machine_context = machine.context, executionStack = _machine_context.executionStack, agentContext = _machine_context.agentContext, batchContext = _machine_context.batchContext;
+                        resumeContext = executionStackToResumeContext(executionStack, agentContext, batchContext);
                         return [
                             2,
                             this.execute(brain, {

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

@@ -125,6 +125,7 @@ var createInitialContext = function(opts) {
         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,
+        batchContext: null,
         status: STATUS.PENDING,
         isTopLevel: false,
         isRunning: false,
@@ -318,20 +319,33 @@ var startStep = reduce(function(ctx, param) {
     });
 });
 var completeStep = reduce(function(ctx, param) {
-    var stepId = param.stepId, patch = param.patch;
+    var stepId = param.stepId, stepTitle = param.stepTitle, patch = param.patch, halted = param.halted;
     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 ===
     var currentBrainId = brainIdStack[brainIdStack.length - 1];
     var currentBrain = brains[currentBrainId];
     if (!currentBrain) return ctx;
-    // Update step status
-    var newSteps = currentBrain.steps.map(function(s) {
+    // Use explicit halted flag from the event
+    var isHalted = halted === true;
+    // Update step status - HALTED if explicitly marked, COMPLETE otherwise
+    var stepStatus = isHalted ? STATUS.HALTED : STATUS.COMPLETE;
+    var existingStep = currentBrain.steps.find(function(s) {
+        return s.id === stepId;
+    });
+    var newSteps = existingStep ? currentBrain.steps.map(function(s) {
         return s.id === stepId ? _object_spread_props(_object_spread({}, s), {
-            status: STATUS.COMPLETE,
+            status: stepStatus,
             patch: patch
         }) : s;
-    });
+    }) : _to_consumable_array(currentBrain.steps).concat([
+        {
+            id: stepId,
+            title: stepTitle,
+            status: stepStatus,
+            patch: patch
+        }
+    ]);
     var newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, currentBrainId, _object_spread_props(_object_spread({}, currentBrain), {
         steps: newSteps
     })));
@@ -339,7 +353,7 @@ var completeStep = reduce(function(ctx, param) {
     var newExecutionStack = executionStack;
     if (executionStack.length > 0) {
         var topEntry = executionStack[executionStack.length - 1];
-        var newState = patch ? applyPatches(topEntry.state, [
+        var newState = patch && !isHalted ? applyPatches(topEntry.state, [
             patch
         ]) : topEntry.state;
         // Increment stepIndex so resume knows to start from the NEXT step
@@ -351,9 +365,10 @@ var completeStep = reduce(function(ctx, param) {
         ]);
     }
     // Apply patch to currentState only for top-level brain (for backwards compat)
+    // Skipped steps don't change state or count toward topLevelStepCount
     var newState1 = currentState;
     var newStepCount = topLevelStepCount;
-    if (depth === 1 && patch) {
+    if (depth === 1 && patch && !isHalted) {
         newState1 = applyPatches(currentState, [
             patch
         ]);
@@ -363,7 +378,8 @@ var completeStep = reduce(function(ctx, param) {
         brains: newBrains,
         executionStack: newExecutionStack,
         currentState: newState1,
-        topLevelStepCount: newStepCount
+        topLevelStepCount: newStepCount,
+        batchContext: null
     });
 });
 var webhookPause = reduce(function(ctx, param) {
@@ -430,6 +446,22 @@ var passthrough = function() {
         return ctx;
     });
 };
+// Reducer for BATCH_CHUNK_COMPLETE - merges chunk results into batchContext
+var batchChunkComplete = reduce(function(ctx, payload) {
+    var existing = ctx.batchContext;
+    var newResults = (existing === null || existing === void 0 ? void 0 : existing.accumulatedResults) ? _to_consumable_array(existing.accumulatedResults) : [];
+    for(var i = 0; i < payload.chunkResults.length; i++){
+        newResults[payload.chunkStartIndex + i] = payload.chunkResults[i];
+    }
+    return _object_spread_props(_object_spread({}, ctx), {
+        batchContext: {
+            accumulatedResults: newResults,
+            processedCount: payload.processedCount,
+            totalItems: payload.totalItems,
+            schemaName: payload.schemaName
+        }
+    });
+});
 // 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) {
@@ -536,7 +568,8 @@ var makeBrainMachine = function(initialContext) {
         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.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), // AGENT_START transitions to the agentLoop state
+        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), // Batch chunk complete - stays in running, accumulates results
+        transition(BRAIN_EVENTS.BATCH_CHUNK_COMPLETE, 'running', batchChunkComplete), // 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

package/dist/src/dsl/builder/brain.js

@@ -375,7 +375,6 @@ function _ts_values(o) {
 }
 import { z } from 'zod';
 import { BrainEventStream } from '../execution/event-stream.js';
-import { Semaphore, normalizeRetryConfig, executeWithRetry } from '../execution/retry.js';
 export var Brain = /*#__PURE__*/ function() {
     "use strict";
     function Brain(title, description) {
@@ -413,6 +412,11 @@ export var Brain = /*#__PURE__*/ function() {
                                 type: 'agent',
                                 title: block.title
                             };
+                        } else if (block.type === 'guard') {
+                            return {
+                                type: 'guard',
+                                title: block.title
+                            };
                         } else {
                             // block.type === 'brain'
                             return {
@@ -543,6 +547,18 @@ export var Brain = /*#__PURE__*/ function() {
                 return this.nextBrain();
             }
         },
+        {
+            key: "guard",
+            value: function guard(predicate, title) {
+                var guardBlock = {
+                    type: 'guard',
+                    title: title !== null && title !== void 0 ? title : 'Guard',
+                    predicate: predicate
+                };
+                this.blocks.push(guardBlock);
+                return this.nextBrain();
+            }
+        },
         {
             // Implementation
             key: "brain",
@@ -635,134 +651,30 @@ export var Brain = /*#__PURE__*/ function() {
                 // At this point, outputSchema is guaranteed to exist (schema-less case returned early)
                 var outputSchema = config.outputSchema;
                 if (batchConfig) {
-                    // Batch mode - run prompt for each item
+                    // Batch mode - store config on block for event-stream to execute with per-item events
                     var promptBlock1 = {
                         type: 'step',
                         title: title,
                         action: function(param) {
-                            var state = param.state, runClient = param.client, resources = param.resources;
+                            var state = param.state;
                             return _async_to_generator(function() {
-                                var template, stepClient, schema, schemaName, client, items, _batchConfig_concurrency, semaphore, _batchConfig_stagger, stagger, retryConfig, results, sleep, promises, finalResults;
                                 return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            template = config.template, stepClient = config.client;
-                                            schema = outputSchema.schema, schemaName = outputSchema.name;
-                                            client = stepClient !== null && stepClient !== void 0 ? stepClient : runClient;
-                                            items = batchConfig.over(state);
-                                            semaphore = new Semaphore((_batchConfig_concurrency = batchConfig.concurrency) !== null && _batchConfig_concurrency !== void 0 ? _batchConfig_concurrency : 10);
-                                            stagger = (_batchConfig_stagger = batchConfig.stagger) !== null && _batchConfig_stagger !== void 0 ? _batchConfig_stagger : 0;
-                                            retryConfig = normalizeRetryConfig(batchConfig.retry);
-                                            results = new Array(items.length);
-                                            sleep = function(ms) {
-                                                return new Promise(function(r) {
-                                                    return setTimeout(r, ms);
-                                                });
-                                            };
-                                            promises = items.map(function(item, index) {
-                                                return _async_to_generator(function() {
-                                                    var promptText, output, error, fallback;
-                                                    return _ts_generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                if (!(stagger > 0 && index > 0)) return [
-                                                                    3,
-                                                                    2
-                                                                ];
-                                                                return [
-                                                                    4,
-                                                                    sleep(stagger * index)
-                                                                ];
-                                                            case 1:
-                                                                _state.sent();
-                                                                _state.label = 2;
-                                                            case 2:
-                                                                return [
-                                                                    4,
-                                                                    semaphore.acquire()
-                                                                ];
-                                                            case 3:
-                                                                _state.sent();
-                                                                _state.label = 4;
-                                                            case 4:
-                                                                _state.trys.push([
-                                                                    4,
-                                                                    7,
-                                                                    8,
-                                                                    9
-                                                                ]);
-                                                                return [
-                                                                    4,
-                                                                    template(item, resources)
-                                                                ];
-                                                            case 5:
-                                                                promptText = _state.sent();
-                                                                return [
-                                                                    4,
-                                                                    executeWithRetry(function() {
-                                                                        return client.generateObject({
-                                                                            schema: schema,
-                                                                            schemaName: schemaName,
-                                                                            prompt: promptText
-                                                                        });
-                                                                    }, retryConfig)
-                                                                ];
-                                                            case 6:
-                                                                output = _state.sent();
-                                                                results[index] = [
-                                                                    item,
-                                                                    output
-                                                                ];
-                                                                return [
-                                                                    3,
-                                                                    9
-                                                                ];
-                                                            case 7:
-                                                                error = _state.sent();
-                                                                if (batchConfig.error) {
-                                                                    fallback = batchConfig.error(item, error);
-                                                                    if (fallback !== null) {
-                                                                        results[index] = [
-                                                                            item,
-                                                                            fallback
-                                                                        ];
-                                                                    }
-                                                                } else {
-                                                                    throw error;
-                                                                }
-                                                                return [
-                                                                    3,
-                                                                    9
-                                                                ];
-                                                            case 8:
-                                                                semaphore.release();
-                                                                return [
-                                                                    7
-                                                                ];
-                                                            case 9:
-                                                                return [
-                                                                    2
-                                                                ];
-                                                        }
-                                                    });
-                                                })();
-                                            });
-                                            return [
-                                                4,
-                                                Promise.all(promises)
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            finalResults = results.filter(function(r) {
-                                                return r !== undefined;
-                                            });
-                                            return [
-                                                2,
-                                                _object_spread_props(_object_spread({}, state), _define_property({}, outputSchema.name, finalResults))
-                                            ];
-                                    }
+                                    return [
+                                        2,
+                                        state
+                                    ];
                                 });
                             })();
+                        },
+                        batchConfig: {
+                            over: batchConfig.over,
+                            maxRetries: batchConfig.maxRetries,
+                            error: batchConfig.error,
+                            template: config.template,
+                            schema: outputSchema.schema,
+                            schemaName: outputSchema.name,
+                            client: config.client,
+                            chunkSize: batchConfig.chunkSize
                         }
                     };
                     this.blocks.push(promptBlock1);

package/dist/src/dsl/constants.js

@@ -25,7 +25,9 @@ export var BRAIN_EVENTS = {
     AGENT_ITERATION_LIMIT: 'agent:iteration_limit',
     AGENT_WEBHOOK: 'agent:webhook',
     AGENT_RAW_RESPONSE_MESSAGE: 'agent:raw_response_message',
-    AGENT_USER_MESSAGE: 'agent:user_message'
+    AGENT_USER_MESSAGE: 'agent:user_message',
+    // Batch prompt events (prompt with `over`)
+    BATCH_CHUNK_COMPLETE: 'batch:chunk_complete'
 };
 export var STATUS = {
     PENDING: 'pending',
@@ -35,6 +37,7 @@ export var STATUS = {
     CANCELLED: 'cancelled',
     WAITING: 'waiting',
     PAUSED: 'paused',
+    HALTED: 'halted',
     // Internal status for tracking when execution is inside an agent loop.
     // Publicly this maps to RUNNING for consumers.
     AGENT_LOOP: 'agent_loop'