@positronic/cloudflare 0.0.74 → 0.0.76

package/dist/src/api/brains.js

@@ -158,6 +158,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { Cron } from 'croner';
 import Fuse from 'fuse.js';
 import { isSignalValid, brainMachineDefinition } from '@positronic/core';
+import { zodToJsonSchema } from 'zod-to-json-schema';
 import { getManifest } from '../brain-runner-do.js';
 var brains = new Hono();
 /**
@@ -171,7 +172,7 @@ var brains = new Hono();
 }
 brains.post('/runs', function(context) {
     return _async_to_generator(function() {
-        var requestBody, options, identifier, manifest, resolution, brain, brainRunId, namespace, doId, stub, auth, currentUser, initialData, brainTitle, response;
+        var requestBody, options, initialState, identifier, manifest, resolution, brain, brainRunId, namespace, doId, stub, auth, currentUser, initialData, brainTitle, response;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -181,7 +182,7 @@ brains.post('/runs', function(context) {
                     ];
                 case 1:
                     requestBody = _state.sent();
-                    options = requestBody.options;
+                    options = requestBody.options, initialState = requestBody.initialState;
                     // Support both identifier and brainTitle for backward compatibility
                     identifier = requestBody.identifier || requestBody.brainTitle;
                     if (!identifier) {
@@ -240,10 +241,12 @@ brains.post('/runs', function(context) {
                     currentUser = {
                         name: auth.userName || 'root'
                     };
-                    // Pass options to the brain runner if provided
-                    initialData = options ? {
+                    // Pass options and initialState to the brain runner if provided
+                    initialData = options || initialState ? _object_spread({}, options && {
                         options: options
-                    } : undefined;
+                    }, initialState && {
+                        initialState: initialState
+                    }) : undefined;
                     // Get the actual brain title from the resolved brain
                     brainTitle = brain.title || identifier;
                     return [
@@ -265,7 +268,7 @@ brains.post('/runs', function(context) {
 });
 brains.post('/runs/rerun', function(context) {
     return _async_to_generator(function() {
-        var requestBody, runId, startsAt, stopsAfter, identifier, manifest, resolution, brain, monitorId, monitorStub, existingRun, auth, currentUser, newBrainRunId, namespace, doId, stub, rerunOptions, brainTitle, response;
+        var requestBody, runId, startsAt, userName, monitorId, monitorStub, existingRun, namespace, doId, stub, error;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -275,57 +278,30 @@ brains.post('/runs/rerun', function(context) {
                     ];
                 case 1:
                     requestBody = _state.sent();
-                    runId = requestBody.runId, startsAt = requestBody.startsAt, stopsAfter = requestBody.stopsAfter;
-                    // Support both identifier and brainTitle for backward compatibility
-                    identifier = requestBody.identifier || requestBody.brainTitle;
-                    if (!identifier) {
+                    runId = requestBody.runId, startsAt = requestBody.startsAt;
+                    if (!runId) {
                         return [
                             2,
                             context.json({
-                                error: 'Missing identifier or brainTitle in request body'
+                                error: 'Missing runId in request body'
                             }, 400)
                         ];
                     }
-                    // Validate that the brain exists
-                    manifest = getManifest();
-                    if (!manifest) {
-                        return [
-                            2,
-                            context.json({
-                                error: 'Manifest not initialized'
-                            }, 500)
-                        ];
-                    }
-                    // Resolve the identifier to find the brain
-                    resolution = manifest.resolve(identifier);
-                    if (resolution.matchType === 'none') {
-                        return [
-                            2,
-                            context.json({
-                                error: "Brain '".concat(identifier, "' not found")
-                            }, 404)
-                        ];
-                    }
-                    if (resolution.matchType === 'multiple') {
+                    if (startsAt === undefined || typeof startsAt !== 'number' || startsAt < 1) {
                         return [
                             2,
                             context.json({
-                                error: 'Multiple brains match the identifier',
-                                matchType: 'multiple',
-                                candidates: resolution.candidates
-                            }, 409)
+                                error: 'Missing or invalid startsAt in request body (must be >= 1)'
+                            }, 400)
                         ];
                     }
-                    brain = resolution.brain;
-                    if (!runId) return [
-                        3,
-                        3
-                    ];
+                    // Validate the run exists and the user owns it
+                    userName = scopeUserName(context);
                     monitorId = context.env.MONITOR_DO.idFromName('singleton');
                     monitorStub = context.env.MONITOR_DO.get(monitorId);
                     return [
                         4,
-                        monitorStub.getLastEvent(runId)
+                        monitorStub.getRun(runId, userName)
                     ];
                 case 2:
                     existingRun = _state.sent();
@@ -337,48 +313,43 @@ brains.post('/runs/rerun', function(context) {
                             }, 404)
                         ];
                     }
-                    _state.label = 3;
-                case 3:
-                    // Read auth context for currentUser (every brain run must have an owner)
-                    auth = context.get('auth');
-                    if (!(auth === null || auth === void 0 ? void 0 : auth.userName) && !(auth === null || auth === void 0 ? void 0 : auth.isRoot)) {
-                        return [
-                            2,
-                            context.json({
-                                error: 'Authentication required to run a brain'
-                            }, 401)
-                        ];
-                    }
-                    currentUser = {
-                        name: auth.userName || 'root'
-                    };
-                    // Create a new brain run with rerun parameters
-                    newBrainRunId = uuidv4();
+                    // Get the existing DO and call rerun
                     namespace = context.env.BRAIN_RUNNER_DO;
-                    doId = namespace.idFromName(newBrainRunId);
+                    doId = namespace.idFromName(runId);
                     stub = namespace.get(doId);
-                    // Start the brain with rerun options
-                    rerunOptions = _object_spread({}, runId && {
-                        originalRunId: runId
-                    }, startsAt !== undefined && {
-                        startsAt: startsAt
-                    }, stopsAfter !== undefined && {
-                        stopsAfter: stopsAfter
-                    });
-                    // Get the actual brain title from the resolved brain
-                    brainTitle = brain.title || identifier;
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        5,
+                        ,
+                        6
+                    ]);
                     return [
                         4,
-                        stub.start(brainTitle, newBrainRunId, currentUser, rerunOptions)
+                        stub.rerun(startsAt)
                     ];
                 case 4:
                     _state.sent();
-                    response = {
-                        brainRunId: newBrainRunId
-                    };
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    error = _state.sent();
                     return [
                         2,
-                        context.json(response, 201)
+                        context.json({
+                            error: error.message || 'Rerun failed'
+                        }, 500)
+                    ];
+                case 6:
+                    return [
+                        2,
+                        context.json({
+                            brainRunId: runId,
+                            brainTitle: existingRun.brainTitle
+                        }, 200)
                     ];
             }
         });
@@ -1081,7 +1052,7 @@ brains.post('/schedules', function(context) {
                     }
                     return [
                         4,
-                        scheduleStub.createSchedule(brainTitle, cronExpression, timezone, runAsUserName)
+                        scheduleStub.createSchedule(brainTitle, cronExpression, timezone, runAsUserName, body.options, body.initialState)
                     ];
                 case 4:
                     schedule = _state.sent();
@@ -1307,11 +1278,13 @@ brains.get('/:identifier', function(context) {
             structure = brain.structure;
             return [
                 2,
-                context.json({
+                context.json(_object_spread({
                     title: structure.title,
                     description: structure.description || "".concat(structure.title, " brain"),
                     steps: structure.steps
-                })
+                }, brain.optionsSchema && {
+                    options: zodToJsonSchema(brain.optionsSchema)
+                }))
             ];
         });
     })();

package/dist/src/api/secrets.js

@@ -206,7 +206,7 @@ import { requireRoot } from './auth-middleware.js';
                 2,
                 fetch(url, _object_spread_props(_object_spread({}, options), {
                     headers: _object_spread({
-                        'Authorization': "Bearer ".concat(config.apiToken),
+                        Authorization: "Bearer ".concat(config.apiToken),
                         'Content-Type': 'application/json'
                     }, options.headers)
                 }))

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

@@ -443,21 +443,21 @@ var ScheduleAdapter = /*#__PURE__*/ function() {
     return ScheduleAdapter;
 }();
 /**
- * Adapter that intercepts BATCH_CHUNK_COMPLETE events and triggers a
- * DO alarm-based restart to reclaim memory between chunks.
- * After each chunk, it queues a PAUSE signal and sets an immediate alarm.
+ * Adapter that intercepts ITERATE_ITEM_COMPLETE events and triggers a
+ * DO alarm-based restart to reclaim memory between items.
+ * After each item, it queues a PAUSE signal and sets an immediate alarm.
  * The alarm fires, calls wakeUp(), which replays events, reconstructs
- * batch progress, and resumes from the next chunk.
- */ var BatchChunkAdapter = /*#__PURE__*/ function() {
+ * iterate progress, and resumes from the next item.
+ */ var IterateItemAdapter = /*#__PURE__*/ function() {
     "use strict";
-    function BatchChunkAdapter(doQueueSignal, doSetAlarm) {
-        _class_call_check(this, BatchChunkAdapter);
+    function IterateItemAdapter(doQueueSignal, doSetAlarm) {
+        _class_call_check(this, IterateItemAdapter);
         _define_property(this, "doQueueSignal", void 0);
         _define_property(this, "doSetAlarm", void 0);
         this.doQueueSignal = doQueueSignal;
         this.doSetAlarm = doSetAlarm;
     }
-    _create_class(BatchChunkAdapter, [
+    _create_class(IterateItemAdapter, [
         {
             key: "dispatch",
             value: function dispatch(event) {
@@ -466,13 +466,13 @@ var ScheduleAdapter = /*#__PURE__*/ function() {
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                if (!(event.type === BRAIN_EVENTS.BATCH_CHUNK_COMPLETE)) return [
+                                if (!(event.type === BRAIN_EVENTS.ITERATE_ITEM_COMPLETE)) return [
                                     3,
                                     3
                                 ];
-                                // Only pause and restart between chunks, not after the last chunk.
-                                // After the last chunk the brain continues to subsequent steps naturally.
-                                // A spurious alarm after the last chunk would call wakeUp() while the
+                                // Only pause and restart between items, not after the last item.
+                                // After the last item the brain continues to subsequent steps naturally.
+                                // A spurious alarm after the last item would call wakeUp() while the
                                 // brain is still running, corrupting execution state.
                                 processedCount = event.processedCount, totalItems = event.totalItems;
                                 if (!(processedCount < totalItems)) return [
@@ -504,7 +504,7 @@ var ScheduleAdapter = /*#__PURE__*/ function() {
             }
         }
     ]);
-    return BatchChunkAdapter;
+    return IterateItemAdapter;
 }();
 // SQL to initialize the run owner table (stores who started this brain run)
 var runOwnerTableSQL = "\nCREATE TABLE IF NOT EXISTS run_owner (\n  user_name TEXT NOT NULL\n);\n";
@@ -1024,6 +1024,122 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                 }).call(this);
             }
         },
+        {
+            key: "rerun",
+            value: /**
+   * Destructive rerun: truncate event history to just before step N,
+   * then resume from there using the existing wakeUp() machinery.
+   * startsAt is 1-indexed: --starts-at 3 keeps steps 1-2, re-executes from step 3.
+   */ function rerun(startsAt) {
+                return _async_to_generator(function() {
+                    var _this, eventLoader, eventsWithIds, startEntry, initialState, machine, stepsToKeep, topLevelStepCount, cutoffEventId, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, eventId, event, r2Rows;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                if (this.abortController) {
+                                    throw new Error('Cannot rerun while brain is actively running');
+                                }
+                                eventLoader = new EventLoader(this.sql, this.env.RESOURCES_BUCKET);
+                                return [
+                                    4,
+                                    eventLoader.loadAllEventsWithIds()
+                                ];
+                            case 1:
+                                eventsWithIds = _state.sent();
+                                if (eventsWithIds.length === 0) {
+                                    throw new Error('No events found for this brain run');
+                                }
+                                // Find the START event to get initialState
+                                startEntry = eventsWithIds.find(function(e) {
+                                    return e.event.type === BRAIN_EVENTS.START;
+                                });
+                                if (!startEntry) {
+                                    throw new Error('No START event found');
+                                }
+                                initialState = startEntry.event.initialState || {};
+                                // Replay events through a state machine and count top-level STEP_COMPLETE events
+                                machine = createBrainExecutionMachine({
+                                    initialState: initialState
+                                });
+                                stepsToKeep = startsAt - 1;
+                                topLevelStepCount = 0;
+                                cutoffEventId = startEntry.eventId; // Default: keep only START
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = eventsWithIds[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        _step_value = _step.value, eventId = _step_value.eventId, event = _step_value.event;
+                                        sendEvent(machine, event);
+                                        if (event.type === BRAIN_EVENTS.STEP_COMPLETE && machine.context.isTopLevel) {
+                                            topLevelStepCount++;
+                                            if (topLevelStepCount === stepsToKeep) {
+                                                cutoffEventId = eventId;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                                // If startsAt is 1, cutoff stays at the START event's ID
+                                // Find R2 keys that need to be deleted (overflow events beyond the cutoff)
+                                r2Rows = this.sql.exec("SELECT r2_key FROM brain_events WHERE event_id > ? AND r2_key IS NOT NULL", cutoffEventId).toArray();
+                                if (!(r2Rows.length > 0)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    Promise.all(r2Rows.map(function(row) {
+                                        return _this.env.RESOURCES_BUCKET.delete(row.r2_key);
+                                    }))
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                // Truncate events beyond cutoff
+                                this.sql.exec("DELETE FROM brain_events WHERE event_id > ?", cutoffEventId);
+                                // Clear signals and wait timeouts
+                                // Use DROP + recreate pattern since tables may not exist if the brain
+                                // never used signals/wait (e.g. basic-brain with no wait steps)
+                                this.sql.exec("DROP TABLE IF EXISTS brain_signals");
+                                this.sql.exec("DROP TABLE IF EXISTS wait_timeout");
+                                this.signalsTableInitialized = false;
+                                this.waitTimeoutTableInitialized = false;
+                                // Cancel any pending alarm
+                                return [
+                                    4,
+                                    this.ctx.storage.deleteAlarm()
+                                ];
+                            case 4:
+                                _state.sent();
+                                // Resume from the truncation point
+                                return [
+                                    4,
+                                    this.wakeUp(this.brainRunId)
+                                ];
+                            case 5:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "alarm",
             value: function alarm() {
@@ -1066,7 +1182,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
             key: "start",
             value: function start(brainTitle, brainRunId, currentUser, initialData) {
                 return _async_to_generator(function() {
-                    var _this, sql, resolution, brainToRun, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider, options, initialState, batchChunkAdapter, timeoutAdapter;
+                    var _this, sql, resolution, brainToRun, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider, options, _initialData_initialState, initialState, iterateItemAdapter, timeoutAdapter;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -1130,14 +1246,14 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 runnerWithResources = runnerWithResources.withSignalProvider(signalProvider).withGovernor(function(c) {
                                     return rateGoverned(c);
                                 }).withStoreProvider(createR2Backend(this.env.RESOURCES_BUCKET));
-                                // Extract options from initialData if present
+                                // Extract options and initialState from initialData if present
                                 options = initialData === null || initialData === void 0 ? void 0 : initialData.options;
-                                initialState = initialData && !initialData.options ? initialData : {};
+                                initialState = (_initialData_initialState = initialData === null || initialData === void 0 ? void 0 : initialData.initialState) !== null && _initialData_initialState !== void 0 ? _initialData_initialState : initialData && !initialData.options && !initialData.initialState ? initialData : {};
                                 // Persist run owner durably (immutable, not derived from events)
                                 this.storeRunOwner(currentUser.name);
                                 // Create abort controller for this run
                                 this.abortController = new AbortController();
-                                batchChunkAdapter = new BatchChunkAdapter(function(signal) {
+                                iterateItemAdapter = new IterateItemAdapter(function(signal) {
                                     return _this.queueSignal(signal);
                                 }, function(time) {
                                     return _this.ctx.storage.setAlarm(time);
@@ -1154,7 +1270,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     scheduleAdapter,
                                     webhookAdapter,
                                     this.pageAdapter,
-                                    batchChunkAdapter,
+                                    iterateItemAdapter,
                                     timeoutAdapter
                                 ]).run(brainToRun, _object_spread_props(_object_spread({
                                     currentUser: currentUser,
@@ -1187,7 +1303,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
    * This method reconstructs state and calls BrainRunner.resume().
    */ function wakeUp(brainRunId) {
                 return _async_to_generator(function() {
-                    var _this, sql, pendingTimeout, eventLoader, startEvent, brainTitle, initialState, ownerId, currentUser, originalBrainRunId, resolution, brainToRun, allEvents, machine, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider, batchChunkAdapter, timeoutAdapter;
+                    var _this, sql, pendingTimeout, eventLoader, startEvent, brainTitle, initialState, options, ownerId, currentUser, originalBrainRunId, resolution, brainToRun, allEvents, machine, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider, iterateItemAdapter, timeoutAdapter;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -1195,7 +1311,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 sql = this.sql;
                                 // Clear any pending timeout and cancel the alarm to prevent spurious alarm
                                 // fires after explicit resume. Safe because wakeUp() is only called when a
-                                // brain is suspended (waiting/paused), never during active batch execution.
+                                // brain is suspended (waiting/paused), never during active iterate execution.
                                 pendingTimeout = this.getWaitTimeout();
                                 if (!pendingTimeout) return [
                                     3,
@@ -1226,6 +1342,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 }
                                 brainTitle = startEvent.brainTitle;
                                 initialState = startEvent.initialState || {};
+                                options = startEvent.options || {};
                                 // Read run owner from durable storage (set once in start(), not from events)
                                 ownerId = this.getRunOwner();
                                 if (!ownerId) {
@@ -1327,7 +1444,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 }).withStoreProvider(createR2Backend(this.env.RESOURCES_BUCKET));
                                 // Create abort controller for this run
                                 this.abortController = new AbortController();
-                                batchChunkAdapter = new BatchChunkAdapter(function(signal) {
+                                iterateItemAdapter = new IterateItemAdapter(function(signal) {
                                     return _this.queueSignal(signal);
                                 }, function(time) {
                                     return _this.ctx.storage.setAlarm(time);
@@ -1344,12 +1461,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     scheduleAdapter,
                                     webhookAdapter,
                                     this.pageAdapter,
-                                    batchChunkAdapter,
+                                    iterateItemAdapter,
                                     timeoutAdapter
                                 ]).resume(brainToRun, {
                                     currentUser: currentUser,
                                     machine: machine,
                                     brainRunId: originalBrainRunId,
+                                    options: options,
                                     signal: this.abortController.signal
                                 }).catch(function(err) {
                                     console.error("[DO ".concat(originalBrainRunId, "] BrainRunner wakeUp failed:"), err);
@@ -1385,7 +1503,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 stream = new ReadableStream({
                                     start: function(controller) {
                                         return _async_to_generator(function() {
-                                            var existingEvents, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, err1;
+                                            var existingEvents, err;
                                             return _ts_generator(this, function(_state) {
                                                 switch(_state.label){
                                                     case 0:
@@ -1404,25 +1522,10 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                                         ];
                                                     case 2:
                                                         existingEvents = _state.sent();
-                                                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                                        try {
-                                                            for(_iterator = existingEvents[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                                                event = _step.value;
-                                                                sendEvent(controller, event);
-                                                            }
-                                                        } catch (err) {
-                                                            _didIteratorError = true;
-                                                            _iteratorError = err;
-                                                        } finally{
-                                                            try {
-                                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                                                    _iterator.return();
-                                                                }
-                                                            } finally{
-                                                                if (_didIteratorError) {
-                                                                    throw _iteratorError;
-                                                                }
-                                                            }
+                                                        // Send all historical events as a single array message
+                                                        // so clients can process them in one batch instead of re-rendering per event
+                                                        if (existingEvents.length > 0) {
+                                                            sendEvent(controller, existingEvents);
                                                         }
                                                         eventStreamAdapter.subscribe(controller);
                                                         return [
@@ -1430,13 +1533,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                                             4
                                                         ];
                                                     case 3:
-                                                        err1 = _state.sent();
-                                                        console.error("[DO ".concat(brainRunId, " WATCH] Error during stream start:"), err1);
+                                                        err = _state.sent();
+                                                        console.error("[DO ".concat(brainRunId, " WATCH] Error during stream start:"), err);
                                                         controller.close();
                                                         if (streamController) {
                                                             eventStreamAdapter.unsubscribe(streamController);
                                                         }
-                                                        throw err1;
+                                                        throw err;
                                                     case 4:
                                                         return [
                                                             2

package/dist/src/dev-server.js

@@ -1934,7 +1934,7 @@ export var CloudflareDevServer = /*#__PURE__*/ function() {
                                     fetch(url, {
                                         method: 'PUT',
                                         headers: {
-                                            'Authorization': "Bearer ".concat(apiToken),
+                                            Authorization: "Bearer ".concat(apiToken),
                                             'Content-Type': 'application/json'
                                         },
                                         body: JSON.stringify({

package/dist/src/event-loader.js

@@ -180,6 +180,37 @@ function _ts_generator(thisArg, body) {
                 }).call(this);
             }
         },
+        {
+            key: "loadAllEventsWithIds",
+            value: /**
+   * Load all events with their SQL row IDs, for truncation operations.
+   */ function loadAllEventsWithIds() {
+                return _async_to_generator(function() {
+                    var rows, events;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                rows = this.sql.exec("SELECT event_id, event_type, serialized_event, r2_key\n         FROM brain_events\n         ORDER BY event_id ASC").toArray();
+                                return [
+                                    4,
+                                    this.hydrateEvents(rows)
+                                ];
+                            case 1:
+                                events = _state.sent();
+                                return [
+                                    2,
+                                    rows.map(function(row, i) {
+                                        return {
+                                            eventId: row.event_id,
+                                            event: events[i]
+                                        };
+                                    })
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "loadEventByType",
             value: /**

package/dist/src/governor-client-wrapper.js

@@ -263,7 +263,8 @@ export function rateGoverned(client) {
                             estimated = estimateRequestTokens({
                                 prompt: params.prompt,
                                 messages: params.messages,
-                                system: params.system
+                                system: params.system,
+                                schema: params.schema
                             });
                             return [
                                 2,
@@ -302,7 +303,8 @@ export function rateGoverned(client) {
                             estimated = estimateRequestTokens({
                                 prompt: params.prompt,
                                 messages: params.messages,
-                                system: params.system
+                                system: params.system,
+                                tools: params.tools
                             });
                             return [
                                 2,
@@ -339,7 +341,8 @@ export function rateGoverned(client) {
                             governorStub = getGovernorStub(identity);
                             estimated = estimateRequestTokens({
                                 messages: params.messages,
-                                system: params.system
+                                system: params.system,
+                                tools: params.tools
                             });
                             return [
                                 2,

package/dist/src/governor-do.js

@@ -258,6 +258,7 @@ export var GovernorDO = /*#__PURE__*/ function(DurableObject) {
                             }
                         }
                         if (!this.limitsLoaded) {
+                            console.warn("Governor: no rate limits known for model '".concat(modelId, "', requests will not be throttled"));
                             return [
                                 2
                             ];