@positronic/cloudflare 0.0.56 → 0.0.57

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

@@ -289,11 +289,13 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { STATUS, BRAIN_EVENTS, createBrainExecutionMachine, sendEvent, getCompletedSteps } from '@positronic/core';
+import { STATUS, BRAIN_EVENTS, createBrainExecutionMachine, sendEvent } from '@positronic/core';
 import { DurableObject } from 'cloudflare:workers';
+import { CloudflareSignalProvider } from './signal-provider.js';
 import { BrainRunSQLiteAdapter } from './sqlite-adapter.js';
 import { WebhookAdapter } from './webhook-adapter.js';
 import { PageAdapter } from './page-adapter.js';
+import { EventLoader } from './event-loader.js';
 import { createPagesService } from './pages-service.js';
 import { CloudflareR2Loader } from './r2-loader.js';
 import { createResources } from '@positronic/core';
@@ -436,6 +438,8 @@ var ScheduleAdapter = /*#__PURE__*/ function() {
     ]);
     return ScheduleAdapter;
 }();
+// SQL to initialize the signals table
+var signalsTableSQL = "\nCREATE TABLE IF NOT EXISTS brain_signals (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  signal_type TEXT NOT NULL,\n  content TEXT,\n  queued_at INTEGER NOT NULL\n);\n";
 export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
     "use strict";
     _inherits(BrainRunnerDO, DurableObject);
@@ -445,13 +449,99 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
         _this = _call_super(this, BrainRunnerDO, [
             state,
             env
-        ]), _define_property(_this, "sql", void 0), _define_property(_this, "brainRunId", void 0), _define_property(_this, "eventStreamAdapter", new EventStreamAdapter()), _define_property(_this, "abortController", null);
+        ]), _define_property(_this, "sql", void 0), _define_property(_this, "brainRunId", void 0), _define_property(_this, "eventStreamAdapter", new EventStreamAdapter()), _define_property(_this, "abortController", null), _define_property(_this, "pageAdapter", null), _define_property(_this, "signalsTableInitialized", false);
         _this.sql = state.storage.sql;
         _this.brainRunId = state.id.toString();
         _this.env = env;
         return _this;
     }
     _create_class(BrainRunnerDO, [
+        {
+            key: "initializeSignalsTable",
+            value: function initializeSignalsTable() {
+                if (!this.signalsTableInitialized) {
+                    this.sql.exec(signalsTableSQL);
+                    this.signalsTableInitialized = true;
+                }
+            }
+        },
+        {
+            key: "queueSignal",
+            value: /**
+   * Queue a signal for this brain run.
+   * Returns the queued signal with timestamp.
+   * For WEBHOOK_RESPONSE signals, the response object is JSON-stringified and stored in content.
+   */ function queueSignal(signal) {
+                return _async_to_generator(function() {
+                    var _signal_content, content, queuedAt;
+                    return _ts_generator(this, function(_state) {
+                        this.initializeSignalsTable();
+                        // For WEBHOOK_RESPONSE, store the response as JSON in the content field
+                        content = signal.type === 'WEBHOOK_RESPONSE' && signal.response ? JSON.stringify(signal.response) : (_signal_content = signal.content) !== null && _signal_content !== void 0 ? _signal_content : null;
+                        queuedAt = Date.now();
+                        this.sql.exec("INSERT INTO brain_signals (signal_type, content, queued_at) VALUES (?, ?, ?)", signal.type, content, queuedAt);
+                        return [
+                            2,
+                            {
+                                type: signal.type,
+                                queuedAt: queuedAt
+                            }
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            /**
+   * Get and consume (delete) pending signals.
+   * Signals are returned in priority order: KILL > PAUSE > WEBHOOK_RESPONSE > RESUME > USER_MESSAGE
+   * @param filter 'CONTROL' returns only KILL/PAUSE, 'WEBHOOK' returns only WEBHOOK_RESPONSE, 'ALL' includes all signal types
+   */ key: "getAndConsumeSignals",
+            value: function getAndConsumeSignals(filter) {
+                this.initializeSignalsTable();
+                // Query signals ordered by priority
+                var whereClause = '';
+                if (filter === 'CONTROL') {
+                    whereClause = "WHERE signal_type IN ('KILL', 'PAUSE')";
+                } else if (filter === 'WEBHOOK') {
+                    whereClause = "WHERE signal_type = 'WEBHOOK_RESPONSE'";
+                }
+                var results = this.sql.exec("SELECT id, signal_type, content FROM brain_signals ".concat(whereClause, "\n         ORDER BY CASE signal_type\n           WHEN 'KILL' THEN 1\n           WHEN 'PAUSE' THEN 2\n           WHEN 'WEBHOOK_RESPONSE' THEN 3\n           WHEN 'RESUME' THEN 4\n           WHEN 'USER_MESSAGE' THEN 5\n         END")).toArray();
+                if (results.length === 0) {
+                    return [];
+                }
+                // Delete the returned signals (consume them)
+                var ids = results.map(function(r) {
+                    return r.id;
+                });
+                this.sql.exec("DELETE FROM brain_signals WHERE id IN (".concat(ids.join(','), ")"));
+                // Convert to BrainSignal format
+                return results.map(function(r) {
+                    if (r.signal_type === 'USER_MESSAGE') {
+                        var _r_content;
+                        return {
+                            type: 'USER_MESSAGE',
+                            content: (_r_content = r.content) !== null && _r_content !== void 0 ? _r_content : ''
+                        };
+                    }
+                    if (r.signal_type === 'WEBHOOK_RESPONSE') {
+                        var _r_content1;
+                        return {
+                            type: 'WEBHOOK_RESPONSE',
+                            response: JSON.parse((_r_content1 = r.content) !== null && _r_content1 !== void 0 ? _r_content1 : '{}')
+                        };
+                    }
+                    if (r.signal_type === 'RESUME') {
+                        return {
+                            type: 'RESUME'
+                        };
+                    }
+                    return {
+                        type: r.signal_type
+                    };
+                });
+            }
+        },
         {
             key: "loadResourcesFromR2",
             value: function loadResourcesFromR2() {
@@ -633,7 +723,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
    * SQLite state is missing (zombie brain scenario).
    */ function kill(brainRunId, brainTitle) {
                 return _async_to_generator(function() {
-                    var monitorStub, actualBrainRunId, actualBrainTitle, startEvent, sql, startEventResult, existingRun, cancelledEvent;
+                    var monitorStub, actualBrainRunId, actualBrainTitle, startEvent, eventLoader, err, existingRun, activeStatuses, cancelledEvent, _this_pageAdapter, pageAdapter;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -654,21 +744,43 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 actualBrainRunId = brainRunId;
                                 actualBrainTitle = brainTitle;
                                 startEvent = null;
-                                // Only query SQLite if we don't have the brainRunId from the API
-                                if (!actualBrainRunId) {
-                                    sql = this.sql;
-                                    try {
-                                        startEventResult = sql.exec("SELECT serialized_event FROM brain_events WHERE event_type IN (?, ?) ORDER BY event_id DESC LIMIT 1", BRAIN_EVENTS.START, BRAIN_EVENTS.RESTART).toArray();
-                                        if (startEventResult.length > 0) {
-                                            startEvent = JSON.parse(startEventResult[0].serialized_event);
-                                            actualBrainRunId = startEvent.brainRunId;
-                                            actualBrainTitle = startEvent.brainTitle;
-                                        }
-                                    } catch (err) {
-                                        // Table doesn't exist - brain was killed before any events were written to DO's SQLite
-                                        console.log("[DO ".concat(this.brainRunId, "] kill() could not query brain_events (table may not exist)"));
-                                    }
+                                if (!!actualBrainRunId) return [
+                                    3,
+                                    4
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                // Use EventLoader to handle R2 overflow transparently
+                                eventLoader = new EventLoader(this.sql, this.env.RESOURCES_BUCKET);
+                                return [
+                                    4,
+                                    eventLoader.loadEventByType(BRAIN_EVENTS.START, 'DESC')
+                                ];
+                            case 2:
+                                startEvent = _state.sent();
+                                if (startEvent) {
+                                    actualBrainRunId = startEvent.brainRunId;
+                                    actualBrainTitle = startEvent.brainTitle;
                                 }
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                err = _state.sent();
+                                // Table doesn't exist - brain was killed before any events were written to DO's SQLite
+                                console.log("[DO ".concat(this.brainRunId, "] kill() could not query brain_events (table may not exist)"));
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
                                 // If we still don't have a brainRunId, we can't proceed
                                 if (!actualBrainRunId) {
                                     return [
@@ -683,7 +795,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     4,
                                     monitorStub.getLastEvent(actualBrainRunId)
                                 ];
-                            case 1:
+                            case 5:
                                 existingRun = _state.sent();
                                 if (!existingRun) {
                                     return [
@@ -695,7 +807,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     ];
                                 }
                                 // If already completed/cancelled/errored, nothing to do
-                                if (existingRun.status !== STATUS.RUNNING) {
+                                // Active statuses that can be killed: RUNNING, PAUSED, WAITING
+                                activeStatuses = [
+                                    STATUS.RUNNING,
+                                    STATUS.PAUSED,
+                                    STATUS.WAITING
+                                ];
+                                if (!activeStatuses.includes(existingRun.status)) {
                                     return [
                                         2,
                                         {
@@ -704,7 +822,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                         }
                                     ];
                                 }
-                                // Emit CANCELLED event to MonitorDO
+                                // Emit CANCELLED event
                                 cancelledEvent = {
                                     type: BRAIN_EVENTS.CANCELLED,
                                     status: STATUS.CANCELLED,
@@ -713,11 +831,22 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     brainRunId: actualBrainRunId,
                                     options: (startEvent === null || startEvent === void 0 ? void 0 : startEvent.options) || {}
                                 };
+                                // Dispatch to PageAdapter for cleanup (deletes non-persistent pages from R2)
+                                // This is needed because when a brain is paused (waiting for webhook), the BrainRunner
+                                // has already returned and adapters aren't receiving events through the normal pipeline.
+                                // For zombie brains (server restarted), pageAdapter may be null, so we create one on the fly.
+                                pageAdapter = (_this_pageAdapter = this.pageAdapter) !== null && _this_pageAdapter !== void 0 ? _this_pageAdapter : new PageAdapter(monitorStub, this.env.RESOURCES_BUCKET);
+                                return [
+                                    4,
+                                    pageAdapter.dispatch(cancelledEvent)
+                                ];
+                            case 6:
+                                _state.sent();
                                 return [
                                     4,
                                     monitorStub.handleBrainEvent(cancelledEvent)
                                 ];
-                            case 2:
+                            case 7:
                                 _state.sent();
                                 return [
                                     2,
@@ -735,7 +864,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
             key: "start",
             value: function start(brainTitle, brainRunId, initialData) {
                 return _async_to_generator(function() {
-                    var _this, sql, resolution, brainToRun, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, pageAdapter, env, pagesService, r2Resources, runnerWithResources, options, initialState;
+                    var _this, sql, resolution, brainToRun, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider, options, initialState;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -759,13 +888,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 if (!brainToRun) {
                                     throw new Error("Brain ".concat(brainTitle, " resolved but brain object is missing"));
                                 }
-                                sqliteAdapter = new BrainRunSQLiteAdapter(sql);
+                                sqliteAdapter = new BrainRunSQLiteAdapter(sql, this.env.RESOURCES_BUCKET, brainRunId);
                                 eventStreamAdapter = this.eventStreamAdapter;
                                 monitorDOStub = this.env.MONITOR_DO.get(this.env.MONITOR_DO.idFromName('singleton'));
                                 monitorAdapter = new MonitorAdapter(monitorDOStub);
                                 scheduleAdapter = new ScheduleAdapter(this.env.SCHEDULE_DO.get(this.env.SCHEDULE_DO.idFromName('singleton')));
                                 webhookAdapter = new WebhookAdapter(monitorDOStub);
-                                pageAdapter = new PageAdapter(monitorDOStub, this.env.RESOURCES_BUCKET);
+                                this.pageAdapter = new PageAdapter(monitorDOStub, this.env.RESOURCES_BUCKET);
                                 // Create runtime environment with origin and secrets
                                 env = this.buildRuntimeEnv();
                                 // Create pages service for brain to use
@@ -787,6 +916,11 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 }
                                 // Add pages service and runtime env
                                 runnerWithResources = runnerWithResources.withPages(pagesService).withEnv(env);
+                                // Add signal provider for signal handling
+                                signalProvider = new CloudflareSignalProvider(function(filter) {
+                                    return _this.getAndConsumeSignals(filter);
+                                });
+                                runnerWithResources = runnerWithResources.withSignalProvider(signalProvider);
                                 // Extract options from initialData if present
                                 options = initialData === null || initialData === void 0 ? void 0 : initialData.options;
                                 initialState = initialData && !initialData.options ? initialData : {};
@@ -798,7 +932,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     monitorAdapter,
                                     scheduleAdapter,
                                     webhookAdapter,
-                                    pageAdapter
+                                    this.pageAdapter
                                 ]).run(brainToRun, _object_spread_props(_object_spread({
                                     initialState: initialState,
                                     brainRunId: brainRunId
@@ -822,10 +956,14 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
             }
         },
         {
-            key: "resume",
-            value: function resume(brainRunId, webhookResponse) {
+            key: "wakeUp",
+            value: /**
+   * Wake up (resume) a brain from a previous execution point.
+   * Webhook response data comes from signals, not as a parameter.
+   * This method reconstructs state and calls BrainRunner.resume().
+   */ function wakeUp(brainRunId) {
                 return _async_to_generator(function() {
-                    var _this, sql, startEventResult, startEvent, brainTitle, initialState, resolution, brainToRun, allEventsResult, machine, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, event, initialCompletedSteps, agentEventsResult, agentEvents, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, pageAdapter, env, pagesService, r2Resources, runnerWithResources;
+                    var _this, sql, eventLoader, startEvent, brainTitle, initialState, resolution, brainToRun, allEvents, machine, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, sqliteAdapter, eventStreamAdapter, monitorDOStub, monitorAdapter, scheduleAdapter, webhookAdapter, env, pagesService, r2Resources, runnerWithResources, signalProvider;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -834,17 +972,21 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 if (!manifest) {
                                     throw new Error('Runtime manifest not initialized');
                                 }
-                                // Get the initial state and brain title by loading the FIRST START or RESTART event
-                                // (the outer brain's event, not an inner brain's)
-                                startEventResult = sql.exec("SELECT serialized_event FROM brain_events WHERE event_type IN (?, ?) ORDER BY event_id ASC LIMIT 1", BRAIN_EVENTS.START, BRAIN_EVENTS.RESTART).toArray();
-                                if (startEventResult.length === 0) {
-                                    throw new Error("No START or RESTART event found for brain run ".concat(brainRunId));
+                                // Use EventLoader to load events (handles R2 overflow transparently)
+                                eventLoader = new EventLoader(sql, this.env.RESOURCES_BUCKET);
+                                return [
+                                    4,
+                                    eventLoader.loadEventByType(BRAIN_EVENTS.START, 'ASC')
+                                ];
+                            case 1:
+                                startEvent = _state.sent();
+                                if (!startEvent) {
+                                    throw new Error("No START event found for brain run ".concat(brainRunId));
                                 }
-                                startEvent = JSON.parse(startEventResult[0].serialized_event);
                                 brainTitle = startEvent.brainTitle;
                                 initialState = startEvent.initialState || {};
                                 if (!brainTitle) {
-                                    throw new Error("Brain title not found in START/RESTART event for brain run ".concat(brainRunId));
+                                    throw new Error("Brain title not found in START event for brain run ".concat(brainRunId));
                                 }
                                 // Resolve the brain using the title
                                 resolution = manifest.resolve(brainTitle);
@@ -860,17 +1002,20 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 if (!brainToRun) {
                                     throw new Error("Brain ".concat(brainTitle, " resolved but brain object is missing"));
                                 }
-                                // Load all events and feed them to the state machine to build nested initialCompletedSteps
-                                allEventsResult = sql.exec("SELECT serialized_event FROM brain_events ORDER BY event_id ASC").toArray();
-                                // Create state machine and feed all historical events to reconstruct step hierarchy
+                                return [
+                                    4,
+                                    eventLoader.loadAllEvents()
+                                ];
+                            case 2:
+                                allEvents = _state.sent();
+                                // Create state machine and feed all historical events to reconstruct execution state
                                 machine = createBrainExecutionMachine({
                                     initialState: initialState
                                 });
                                 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 try {
-                                    for(_iterator = allEventsResult[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                        row = _step.value;
-                                        event = JSON.parse(row.serialized_event);
+                                    for(_iterator = allEvents[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        event = _step.value;
                                         sendEvent(machine, event);
                                     }
                                 } catch (err) {
@@ -887,20 +1032,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                         }
                                     }
                                 }
-                                // Get the reconstructed step hierarchy from the state machine
-                                initialCompletedSteps = getCompletedSteps(machine);
-                                // Load AGENT_* events for potential agent resume
-                                agentEventsResult = sql.exec("SELECT serialized_event FROM brain_events WHERE event_type LIKE 'agent:%' ORDER BY event_id ASC").toArray();
-                                agentEvents = agentEventsResult.map(function(row) {
-                                    return JSON.parse(row.serialized_event);
-                                });
-                                sqliteAdapter = new BrainRunSQLiteAdapter(sql);
+                                sqliteAdapter = new BrainRunSQLiteAdapter(sql, this.env.RESOURCES_BUCKET, brainRunId);
                                 eventStreamAdapter = this.eventStreamAdapter;
                                 monitorDOStub = this.env.MONITOR_DO.get(this.env.MONITOR_DO.idFromName('singleton'));
                                 monitorAdapter = new MonitorAdapter(monitorDOStub);
                                 scheduleAdapter = new ScheduleAdapter(this.env.SCHEDULE_DO.get(this.env.SCHEDULE_DO.idFromName('singleton')));
                                 webhookAdapter = new WebhookAdapter(monitorDOStub);
-                                pageAdapter = new PageAdapter(monitorDOStub, this.env.RESOURCES_BUCKET);
+                                this.pageAdapter = new PageAdapter(monitorDOStub, this.env.RESOURCES_BUCKET);
                                 // Create runtime environment with origin and secrets
                                 env = this.buildRuntimeEnv();
                                 // Create pages service for brain to use
@@ -912,7 +1050,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     4,
                                     this.loadResourcesFromR2()
                                 ];
-                            case 1:
+                            case 3:
                                 r2Resources = _state.sent();
                                 runnerWithResources = brainRunner;
                                 if (r2Resources) {
@@ -920,6 +1058,12 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 }
                                 // Add pages service and runtime env
                                 runnerWithResources = runnerWithResources.withPages(pagesService).withEnv(env);
+                                // Add signal provider for signal handling
+                                // Webhook response comes from signals, consumed by the brain during execution
+                                signalProvider = new CloudflareSignalProvider(function(filter) {
+                                    return _this.getAndConsumeSignals(filter);
+                                });
+                                runnerWithResources = runnerWithResources.withSignalProvider(signalProvider);
                                 // Create abort controller for this run
                                 this.abortController = new AbortController();
                                 runnerWithResources.withAdapters([
@@ -928,16 +1072,13 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                     monitorAdapter,
                                     scheduleAdapter,
                                     webhookAdapter,
-                                    pageAdapter
-                                ]).run(brainToRun, {
-                                    initialState: initialState,
-                                    initialCompletedSteps: initialCompletedSteps,
+                                    this.pageAdapter
+                                ]).resume(brainToRun, {
+                                    machine: machine,
                                     brainRunId: brainRunId,
-                                    response: webhookResponse,
-                                    signal: this.abortController.signal,
-                                    agentEvents: agentEvents
+                                    signal: this.abortController.signal
                                 }).catch(function(err) {
-                                    console.error("[DO ".concat(brainRunId, "] BrainRunner resume failed:"), err);
+                                    console.error("[DO ".concat(brainRunId, "] BrainRunner wakeUp failed:"), err);
                                     throw err;
                                 }).finally(function() {
                                     _this.abortController = null;
@@ -954,7 +1095,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
             key: "fetch",
             value: function fetch(request) {
                 return _async_to_generator(function() {
-                    var _this, sql, eventStreamAdapter, brainRunId, url, encoder, sendEvent, streamController, stream;
+                    var _this, sql, eventStreamAdapter, brainRunId, url, encoder, sendEvent, streamController, eventLoader, stream;
                     return _ts_generator(this, function(_state) {
                         _this = this, sql = _this.sql, eventStreamAdapter = _this.eventStreamAdapter, brainRunId = _this.brainRunId;
                         url = new URL(request.url);
@@ -965,55 +1106,72 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                         streamController = null;
                         try {
                             if (url.pathname === '/watch') {
+                                // Create EventLoader for loading historical events (handles R2 overflow)
+                                eventLoader = new EventLoader(sql, this.env.RESOURCES_BUCKET);
                                 stream = new ReadableStream({
-                                    start: function start(controller) {
+                                    start: function(controller) {
                                         return _async_to_generator(function() {
-                                            var existingEventsSql, existingEventsResult, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, event;
+                                            var existingEvents, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, event, err1;
                                             return _ts_generator(this, function(_state) {
-                                                streamController = controller;
-                                                try {
-                                                    streamController = controller;
-                                                    existingEventsSql = "\n                SELECT serialized_event\n                FROM brain_events\n                ORDER BY event_id ASC;\n              ";
-                                                    existingEventsResult = sql.exec(existingEventsSql).toArray();
-                                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                                    try {
-                                                        for(_iterator = existingEventsResult[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                                            row = _step.value;
-                                                            try {
-                                                                event = JSON.parse(row.serialized_event);
-                                                                sendEvent(controller, event);
-                                                            } catch (parseError) {
-                                                                console.error("[DO ".concat(brainRunId, " WATCH] Failed to parse historical event JSON: ").concat(row.serialized_event), parseError);
-                                                            }
-                                                        }
-                                                    } catch (err) {
-                                                        _didIteratorError = true;
-                                                        _iteratorError = err;
-                                                    } finally{
+                                                switch(_state.label){
+                                                    case 0:
+                                                        streamController = controller;
+                                                        _state.label = 1;
+                                                    case 1:
+                                                        _state.trys.push([
+                                                            1,
+                                                            3,
+                                                            ,
+                                                            4
+                                                        ]);
+                                                        return [
+                                                            4,
+                                                            eventLoader.loadAllEvents()
+                                                        ];
+                                                    case 2:
+                                                        existingEvents = _state.sent();
+                                                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                                         try {
-                                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                                                _iterator.return();
+                                                            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{
-                                                            if (_didIteratorError) {
-                                                                throw _iteratorError;
+                                                            try {
+                                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                                    _iterator.return();
+                                                                }
+                                                            } finally{
+                                                                if (_didIteratorError) {
+                                                                    throw _iteratorError;
+                                                                }
                                                             }
                                                         }
-                                                    }
-                                                    eventStreamAdapter.subscribe(controller);
-                                                } catch (err) {
-                                                    console.error("[DO ".concat(brainRunId, " WATCH] Error during stream start:"), err);
-                                                    controller.close();
-                                                    eventStreamAdapter.unsubscribe(streamController);
-                                                    throw err;
+                                                        eventStreamAdapter.subscribe(controller);
+                                                        return [
+                                                            3,
+                                                            4
+                                                        ];
+                                                    case 3:
+                                                        err1 = _state.sent();
+                                                        console.error("[DO ".concat(brainRunId, " WATCH] Error during stream start:"), err1);
+                                                        controller.close();
+                                                        if (streamController) {
+                                                            eventStreamAdapter.unsubscribe(streamController);
+                                                        }
+                                                        throw err1;
+                                                    case 4:
+                                                        return [
+                                                            2
+                                                        ];
                                                 }
-                                                return [
-                                                    2
-                                                ];
                                             });
                                         })();
                                     },
-                                    cancel: function cancel(reason) {
+                                    cancel: function(reason) {
                                         if (streamController) eventStreamAdapter.unsubscribe(streamController);
                                     }
                                 });