@positronic/spec 0.0.37 → 0.0.39

package/dist/src/api.js

@@ -122,7 +122,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { STATUS } from '@positronic/core';
+import { STATUS, BRAIN_EVENTS } from '@positronic/core';
 export function testStatus(fetch) {
     return _async_to_generator(function() {
         var request, response, data, error;
@@ -1392,6 +1392,116 @@ export var brains = {
             });
         })();
     },
+    search: /**
+   * Test GET /brains?q=<query> - Search brains by query string
+   * Returns brains matching the query (by title, filename, or description).
+   * The matching algorithm is implementation-defined; the spec only verifies
+   * the response structure and that results are relevant to the query.
+   */ function search(fetch, query) {
+        return _async_to_generator(function() {
+            var url, request, response, data, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, brain, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            3,
+                            ,
+                            4
+                        ]);
+                        url = new URL('http://example.com/brains');
+                        url.searchParams.set('q', query);
+                        request = new Request(url.toString(), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(request)
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        if (!response.ok) {
+                            console.error("GET /brains?q=".concat(query, " returned ").concat(response.status));
+                            return [
+                                2,
+                                null
+                            ];
+                        }
+                        return [
+                            4,
+                            response.json()
+                        ];
+                    case 2:
+                        data = _state.sent();
+                        // Validate response structure
+                        if (!Array.isArray(data.brains)) {
+                            console.error("Expected brains to be an array, got ".concat(_type_of(data.brains)));
+                            return [
+                                2,
+                                null
+                            ];
+                        }
+                        if (typeof data.count !== 'number') {
+                            console.error("Expected count to be number, got ".concat(_type_of(data.count)));
+                            return [
+                                2,
+                                null
+                            ];
+                        }
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            // Validate each brain has required fields
+                            for(_iterator = data.brains[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                brain = _step.value;
+                                if (!brain.title || typeof brain.title !== 'string' || !brain.description || typeof brain.description !== 'string') {
+                                    console.error("Brain missing required fields or has invalid types: ".concat(JSON.stringify(brain)));
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        // Count should match array length
+                        if (data.count !== data.brains.length) {
+                            console.error("Count (".concat(data.count, ") does not match brains array length (").concat(data.brains.length, ")"));
+                            return [
+                                2,
+                                null
+                            ];
+                        }
+                        return [
+                            2,
+                            data
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        console.error("Failed to test GET /brains?q=".concat(query, ":"), error);
+                        return [
+                            2,
+                            null
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    },
     getBrainInfo: /**
    * Test GET /brains/:identifier - Get brain structure/definition
    * (For future brain exploration/info command)
@@ -2066,6 +2176,870 @@ export var brains = {
                 }
             });
         })();
+    },
+    killSuspended: /**
+   * Test DELETE /brains/runs/:runId for a brain suspended on a webhook.
+   * This tests that killing a webhook-suspended brain:
+   * 1. Returns 204 (not 409)
+   * 2. Updates status to CANCELLED
+   * 3. Clears webhook registrations (webhook no longer resumes the brain)
+   *
+   * Requires a brain with a loop step that will pause on a webhook.
+   */ function killSuspended(fetch, loopBrainIdentifier, webhookSlug, webhookPayload) {
+        return _async_to_generator(function() {
+            var runRequest, runResponse, brainRunId, watchRequest, watchResponse, foundWebhookEvent, reader, decoder, buffer, _ref, value, done, eventEndIndex, message, event, killRequest, killResponse, getRunRequest, getRunResponse, runData, webhookRequest, webhookResponse, webhookResult, finalCheckRequest, finalCheckResponse, finalRunData, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            18,
+                            ,
+                            19
+                        ]);
+                        // Step 1: Start the loop brain
+                        runRequest = new Request('http://example.com/brains/runs', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                identifier: loopBrainIdentifier
+                            })
+                        });
+                        return [
+                            4,
+                            fetch(runRequest)
+                        ];
+                    case 1:
+                        runResponse = _state.sent();
+                        if (runResponse.status !== 201) {
+                            console.error("POST /brains/runs returned ".concat(runResponse.status, ", expected 201"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            runResponse.json()
+                        ];
+                    case 2:
+                        brainRunId = _state.sent().brainRunId;
+                        // Step 2: Watch until WEBHOOK event (brain pauses)
+                        watchRequest = new Request("http://example.com/brains/runs/".concat(brainRunId, "/watch"), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(watchRequest)
+                        ];
+                    case 3:
+                        watchResponse = _state.sent();
+                        if (!watchResponse.ok) {
+                            console.error("GET /brains/runs/".concat(brainRunId, "/watch returned ").concat(watchResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        foundWebhookEvent = false;
+                        if (!watchResponse.body) return [
+                            3,
+                            10
+                        ];
+                        reader = watchResponse.body.getReader();
+                        decoder = new TextDecoder();
+                        buffer = '';
+                        _state.label = 4;
+                    case 4:
+                        _state.trys.push([
+                            4,
+                            ,
+                            8,
+                            10
+                        ]);
+                        _state.label = 5;
+                    case 5:
+                        if (!!foundWebhookEvent) return [
+                            3,
+                            7
+                        ];
+                        return [
+                            4,
+                            reader.read()
+                        ];
+                    case 6:
+                        _ref = _state.sent(), value = _ref.value, done = _ref.done;
+                        if (done) return [
+                            3,
+                            7
+                        ];
+                        buffer += decoder.decode(value, {
+                            stream: true
+                        });
+                        eventEndIndex = void 0;
+                        while((eventEndIndex = buffer.indexOf('\n\n')) !== -1){
+                            message = buffer.substring(0, eventEndIndex);
+                            buffer = buffer.substring(eventEndIndex + 2);
+                            if (message.startsWith('data: ')) {
+                                try {
+                                    event = JSON.parse(message.substring(6));
+                                    if (event.type === BRAIN_EVENTS.WEBHOOK) {
+                                        foundWebhookEvent = true;
+                                        break;
+                                    }
+                                    if (event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR) {
+                                        console.error("Brain completed/errored before WEBHOOK event: ".concat(event.type));
+                                        return [
+                                            2,
+                                            false
+                                        ];
+                                    }
+                                } catch (e) {
+                                // Ignore parse errors
+                                }
+                            }
+                        }
+                        return [
+                            3,
+                            5
+                        ];
+                    case 7:
+                        return [
+                            3,
+                            10
+                        ];
+                    case 8:
+                        return [
+                            4,
+                            reader.cancel()
+                        ];
+                    case 9:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 10:
+                        if (!foundWebhookEvent) {
+                            console.error('Brain did not emit WEBHOOK event');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Step 3: Kill the suspended brain
+                        killRequest = new Request("http://example.com/brains/runs/".concat(brainRunId), {
+                            method: 'DELETE'
+                        });
+                        return [
+                            4,
+                            fetch(killRequest)
+                        ];
+                    case 11:
+                        killResponse = _state.sent();
+                        if (killResponse.status !== 204) {
+                            console.error("DELETE /brains/runs/".concat(brainRunId, " returned ").concat(killResponse.status, ", expected 204"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Step 4: Verify status is CANCELLED via getRun
+                        getRunRequest = new Request("http://example.com/brains/runs/".concat(brainRunId), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(getRunRequest)
+                        ];
+                    case 12:
+                        getRunResponse = _state.sent();
+                        if (!getRunResponse.ok) {
+                            console.error("GET /brains/runs/".concat(brainRunId, " returned ").concat(getRunResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            getRunResponse.json()
+                        ];
+                    case 13:
+                        runData = _state.sent();
+                        if (runData.status !== STATUS.CANCELLED) {
+                            console.error("Expected status to be '".concat(STATUS.CANCELLED, "', got '").concat(runData.status, "'"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Step 5: Verify webhook no longer resumes the brain
+                        // Send a webhook - it should return 'no-match' since registrations were cleared
+                        webhookRequest = new Request("http://example.com/webhooks/".concat(encodeURIComponent(webhookSlug)), {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify(webhookPayload)
+                        });
+                        return [
+                            4,
+                            fetch(webhookRequest)
+                        ];
+                    case 14:
+                        webhookResponse = _state.sent();
+                        // Accept 200/202 - the important thing is it doesn't resume the brain
+                        if (!webhookResponse.ok) {
+                            console.error("POST /webhooks/".concat(webhookSlug, " returned ").concat(webhookResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            webhookResponse.json()
+                        ];
+                    case 15:
+                        webhookResult = _state.sent();
+                        // The action should be 'no-match' since webhook registrations were cleared
+                        if (webhookResult.action === 'resumed') {
+                            console.error('Webhook resumed the brain after it was killed - webhook registrations were not cleared');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Verify the brain is still CANCELLED (didn't restart)
+                        finalCheckRequest = new Request("http://example.com/brains/runs/".concat(brainRunId), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(finalCheckRequest)
+                        ];
+                    case 16:
+                        finalCheckResponse = _state.sent();
+                        if (!finalCheckResponse.ok) {
+                            console.error("Final GET /brains/runs/".concat(brainRunId, " returned ").concat(finalCheckResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            finalCheckResponse.json()
+                        ];
+                    case 17:
+                        finalRunData = _state.sent();
+                        if (finalRunData.status !== STATUS.CANCELLED) {
+                            console.error("Final status check: expected '".concat(STATUS.CANCELLED, "', got '").concat(finalRunData.status, "'"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            2,
+                            true
+                        ];
+                    case 18:
+                        error = _state.sent();
+                        console.error("Failed to test kill suspended brain for ".concat(loopBrainIdentifier, ":"), error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 19:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    },
+    watchLoopEvents: /**
+   * Test that loop steps emit proper LOOP_* events in the SSE stream.
+   * Requires a brain with a loop step that will pause on a webhook.
+   *
+   * Expected events before webhook pause:
+   * - LOOP_START (with prompt and optional system)
+   * - LOOP_ITERATION
+   * - LOOP_TOOL_CALL
+   * - LOOP_WEBHOOK (before WEBHOOK event)
+   * - WEBHOOK
+   */ function watchLoopEvents(fetch, loopBrainIdentifier) {
+        return _async_to_generator(function() {
+            var runRequest, runResponse, brainRunId, watchRequest, watchResponse, events, reader, decoder, buffer, done, _ref, value, streamDone, eventEndIndex, message, event, hasLoopStart, loopStartEvent, hasLoopIteration, hasLoopToolCall, webhookIndex, loopWebhookIndex, loopWebhookEvent, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            11,
+                            ,
+                            12
+                        ]);
+                        // Start the loop brain
+                        runRequest = new Request('http://example.com/brains/runs', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                identifier: loopBrainIdentifier
+                            })
+                        });
+                        return [
+                            4,
+                            fetch(runRequest)
+                        ];
+                    case 1:
+                        runResponse = _state.sent();
+                        if (runResponse.status !== 201) {
+                            console.error("POST /brains/runs returned ".concat(runResponse.status, ", expected 201"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            runResponse.json()
+                        ];
+                    case 2:
+                        brainRunId = _state.sent().brainRunId;
+                        // Watch the brain run
+                        watchRequest = new Request("http://example.com/brains/runs/".concat(brainRunId, "/watch"), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(watchRequest)
+                        ];
+                    case 3:
+                        watchResponse = _state.sent();
+                        if (!watchResponse.ok) {
+                            console.error("GET /brains/runs/".concat(brainRunId, "/watch returned ").concat(watchResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Read SSE events until we get WEBHOOK or COMPLETE/ERROR
+                        events = [];
+                        if (!watchResponse.body) return [
+                            3,
+                            10
+                        ];
+                        reader = watchResponse.body.getReader();
+                        decoder = new TextDecoder();
+                        buffer = '';
+                        done = false;
+                        _state.label = 4;
+                    case 4:
+                        _state.trys.push([
+                            4,
+                            ,
+                            8,
+                            10
+                        ]);
+                        _state.label = 5;
+                    case 5:
+                        if (!!done) return [
+                            3,
+                            7
+                        ];
+                        return [
+                            4,
+                            reader.read()
+                        ];
+                    case 6:
+                        _ref = _state.sent(), value = _ref.value, streamDone = _ref.done;
+                        if (streamDone) return [
+                            3,
+                            7
+                        ];
+                        buffer += decoder.decode(value, {
+                            stream: true
+                        });
+                        // Process complete SSE messages
+                        eventEndIndex = void 0;
+                        while((eventEndIndex = buffer.indexOf('\n\n')) !== -1){
+                            message = buffer.substring(0, eventEndIndex);
+                            buffer = buffer.substring(eventEndIndex + 2);
+                            if (message.startsWith('data: ')) {
+                                try {
+                                    event = JSON.parse(message.substring(6));
+                                    events.push(event);
+                                    // Stop on terminal events
+                                    if (event.type === BRAIN_EVENTS.WEBHOOK || event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR) {
+                                        done = true;
+                                        break;
+                                    }
+                                } catch (e) {
+                                // Ignore parse errors
+                                }
+                            }
+                        }
+                        return [
+                            3,
+                            5
+                        ];
+                    case 7:
+                        return [
+                            3,
+                            10
+                        ];
+                    case 8:
+                        return [
+                            4,
+                            reader.cancel()
+                        ];
+                    case 9:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 10:
+                        // Verify required loop events are present
+                        hasLoopStart = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.LOOP_START;
+                        });
+                        if (!hasLoopStart) {
+                            console.error('Missing LOOP_START event in SSE stream');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Verify LOOP_START has prompt field
+                        loopStartEvent = events.find(function(e) {
+                            return e.type === BRAIN_EVENTS.LOOP_START;
+                        });
+                        if (!loopStartEvent.prompt || typeof loopStartEvent.prompt !== 'string') {
+                            console.error('LOOP_START event missing prompt field');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        hasLoopIteration = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.LOOP_ITERATION;
+                        });
+                        if (!hasLoopIteration) {
+                            console.error('Missing LOOP_ITERATION event in SSE stream');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        hasLoopToolCall = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.LOOP_TOOL_CALL;
+                        });
+                        if (!hasLoopToolCall) {
+                            console.error('Missing LOOP_TOOL_CALL event in SSE stream');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // If we got a WEBHOOK event, verify LOOP_WEBHOOK came before it
+                        webhookIndex = events.findIndex(function(e) {
+                            return e.type === BRAIN_EVENTS.WEBHOOK;
+                        });
+                        if (webhookIndex !== -1) {
+                            loopWebhookIndex = events.findIndex(function(e) {
+                                return e.type === BRAIN_EVENTS.LOOP_WEBHOOK;
+                            });
+                            if (loopWebhookIndex === -1) {
+                                console.error('Missing LOOP_WEBHOOK event before WEBHOOK event');
+                                return [
+                                    2,
+                                    false
+                                ];
+                            }
+                            if (loopWebhookIndex >= webhookIndex) {
+                                console.error('LOOP_WEBHOOK event must come before WEBHOOK event');
+                                return [
+                                    2,
+                                    false
+                                ];
+                            }
+                            // Verify LOOP_WEBHOOK has required fields
+                            loopWebhookEvent = events[loopWebhookIndex];
+                            if (!loopWebhookEvent.toolCallId || !loopWebhookEvent.toolName) {
+                                console.error('LOOP_WEBHOOK event missing toolCallId or toolName fields');
+                                return [
+                                    2,
+                                    false
+                                ];
+                            }
+                        }
+                        return [
+                            2,
+                            true
+                        ];
+                    case 11:
+                        error = _state.sent();
+                        console.error("Failed to test loop events for ".concat(loopBrainIdentifier, ":"), error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 12:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    },
+    loopWebhookResume: /**
+   * Test full loop webhook resumption flow:
+   * 1. Start a loop brain that will pause on a webhook
+   * 2. Verify it pauses with WEBHOOK event
+   * 3. Trigger the webhook with a response
+   * 4. Verify the brain resumes and emits WEBHOOK_RESPONSE and LOOP_TOOL_RESULT
+   *
+   * Requires:
+   * - A brain with a loop step that calls a tool returning { waitFor: webhook(...) }
+   * - The webhook slug and identifier to trigger
+   */ function loopWebhookResume(fetch, loopBrainIdentifier, webhookSlug, webhookPayload) {
+        return _async_to_generator(function() {
+            var runRequest, runResponse, brainRunId, watchRequest, watchResponse, foundWebhookEvent, reader, decoder, buffer, _ref, value, done, eventEndIndex, message, event, webhookRequest, webhookResponse, webhookResult, resumeWatchRequest, resumeWatchResponse, resumeEvents, reader1, decoder1, buffer1, done1, _ref1, value1, streamDone, eventEndIndex1, message1, event1, hasWebhookResponse, hasLoopToolResult, completeEvent, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            21,
+                            ,
+                            22
+                        ]);
+                        // Step 1: Start the loop brain
+                        runRequest = new Request('http://example.com/brains/runs', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                identifier: loopBrainIdentifier
+                            })
+                        });
+                        return [
+                            4,
+                            fetch(runRequest)
+                        ];
+                    case 1:
+                        runResponse = _state.sent();
+                        if (runResponse.status !== 201) {
+                            console.error("POST /brains/runs returned ".concat(runResponse.status, ", expected 201"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            runResponse.json()
+                        ];
+                    case 2:
+                        brainRunId = _state.sent().brainRunId;
+                        // Step 2: Watch until WEBHOOK event (brain pauses)
+                        watchRequest = new Request("http://example.com/brains/runs/".concat(brainRunId, "/watch"), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(watchRequest)
+                        ];
+                    case 3:
+                        watchResponse = _state.sent();
+                        if (!watchResponse.ok) {
+                            console.error("GET /brains/runs/".concat(brainRunId, "/watch returned ").concat(watchResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        foundWebhookEvent = false;
+                        if (!watchResponse.body) return [
+                            3,
+                            10
+                        ];
+                        reader = watchResponse.body.getReader();
+                        decoder = new TextDecoder();
+                        buffer = '';
+                        _state.label = 4;
+                    case 4:
+                        _state.trys.push([
+                            4,
+                            ,
+                            8,
+                            10
+                        ]);
+                        _state.label = 5;
+                    case 5:
+                        if (!!foundWebhookEvent) return [
+                            3,
+                            7
+                        ];
+                        return [
+                            4,
+                            reader.read()
+                        ];
+                    case 6:
+                        _ref = _state.sent(), value = _ref.value, done = _ref.done;
+                        if (done) return [
+                            3,
+                            7
+                        ];
+                        buffer += decoder.decode(value, {
+                            stream: true
+                        });
+                        eventEndIndex = void 0;
+                        while((eventEndIndex = buffer.indexOf('\n\n')) !== -1){
+                            message = buffer.substring(0, eventEndIndex);
+                            buffer = buffer.substring(eventEndIndex + 2);
+                            if (message.startsWith('data: ')) {
+                                try {
+                                    event = JSON.parse(message.substring(6));
+                                    if (event.type === BRAIN_EVENTS.WEBHOOK) {
+                                        foundWebhookEvent = true;
+                                        break;
+                                    }
+                                    if (event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR) {
+                                        console.error("Brain completed/errored before WEBHOOK event: ".concat(event.type));
+                                        return [
+                                            2,
+                                            false
+                                        ];
+                                    }
+                                } catch (e) {
+                                // Ignore parse errors
+                                }
+                            }
+                        }
+                        return [
+                            3,
+                            5
+                        ];
+                    case 7:
+                        return [
+                            3,
+                            10
+                        ];
+                    case 8:
+                        return [
+                            4,
+                            reader.cancel()
+                        ];
+                    case 9:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 10:
+                        if (!foundWebhookEvent) {
+                            console.error('Brain did not emit WEBHOOK event');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Step 3: Trigger the webhook
+                        webhookRequest = new Request("http://example.com/webhooks/".concat(encodeURIComponent(webhookSlug)), {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify(webhookPayload)
+                        });
+                        return [
+                            4,
+                            fetch(webhookRequest)
+                        ];
+                    case 11:
+                        webhookResponse = _state.sent();
+                        if (!webhookResponse.ok) {
+                            console.error("POST /webhooks/".concat(webhookSlug, " returned ").concat(webhookResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            webhookResponse.json()
+                        ];
+                    case 12:
+                        webhookResult = _state.sent();
+                        if (!webhookResult.received) {
+                            console.error('Webhook was not received');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        if (webhookResult.action !== 'resumed') {
+                            console.error("Expected webhook action 'resumed', got '".concat(webhookResult.action, "'"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Step 4: Watch again for resumed events
+                        resumeWatchRequest = new Request("http://example.com/brains/runs/".concat(brainRunId, "/watch"), {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(resumeWatchRequest)
+                        ];
+                    case 13:
+                        resumeWatchResponse = _state.sent();
+                        if (!resumeWatchResponse.ok) {
+                            console.error("GET /brains/runs/".concat(brainRunId, "/watch (resume) returned ").concat(resumeWatchResponse.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        resumeEvents = [];
+                        if (!resumeWatchResponse.body) return [
+                            3,
+                            20
+                        ];
+                        reader1 = resumeWatchResponse.body.getReader();
+                        decoder1 = new TextDecoder();
+                        buffer1 = '';
+                        done1 = false;
+                        _state.label = 14;
+                    case 14:
+                        _state.trys.push([
+                            14,
+                            ,
+                            18,
+                            20
+                        ]);
+                        _state.label = 15;
+                    case 15:
+                        if (!!done1) return [
+                            3,
+                            17
+                        ];
+                        return [
+                            4,
+                            reader1.read()
+                        ];
+                    case 16:
+                        _ref1 = _state.sent(), value1 = _ref1.value, streamDone = _ref1.done;
+                        if (streamDone) return [
+                            3,
+                            17
+                        ];
+                        buffer1 += decoder1.decode(value1, {
+                            stream: true
+                        });
+                        eventEndIndex1 = void 0;
+                        while((eventEndIndex1 = buffer1.indexOf('\n\n')) !== -1){
+                            message1 = buffer1.substring(0, eventEndIndex1);
+                            buffer1 = buffer1.substring(eventEndIndex1 + 2);
+                            if (message1.startsWith('data: ')) {
+                                try {
+                                    event1 = JSON.parse(message1.substring(6));
+                                    resumeEvents.push(event1);
+                                    if (event1.type === BRAIN_EVENTS.COMPLETE || event1.type === BRAIN_EVENTS.ERROR) {
+                                        done1 = true;
+                                        break;
+                                    }
+                                } catch (e) {
+                                // Ignore parse errors
+                                }
+                            }
+                        }
+                        return [
+                            3,
+                            15
+                        ];
+                    case 17:
+                        return [
+                            3,
+                            20
+                        ];
+                    case 18:
+                        return [
+                            4,
+                            reader1.cancel()
+                        ];
+                    case 19:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 20:
+                        // Verify WEBHOOK_RESPONSE event is present
+                        hasWebhookResponse = resumeEvents.some(function(e) {
+                            return e.type === BRAIN_EVENTS.WEBHOOK_RESPONSE;
+                        });
+                        if (!hasWebhookResponse) {
+                            console.error('Missing WEBHOOK_RESPONSE event after resume');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Verify LOOP_TOOL_RESULT event is present (with the webhook response as result)
+                        hasLoopToolResult = resumeEvents.some(function(e) {
+                            return e.type === BRAIN_EVENTS.LOOP_TOOL_RESULT;
+                        });
+                        if (!hasLoopToolResult) {
+                            console.error('Missing LOOP_TOOL_RESULT event after resume');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Verify brain completed successfully
+                        completeEvent = resumeEvents.find(function(e) {
+                            return e.type === BRAIN_EVENTS.COMPLETE;
+                        });
+                        if (!completeEvent) {
+                            console.error('Brain did not complete after resume');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        if (completeEvent.status !== STATUS.COMPLETE) {
+                            console.error("Expected COMPLETE status, got ".concat(completeEvent.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            2,
+                            true
+                        ];
+                    case 21:
+                        error = _state.sent();
+                        console.error("Failed to test loop webhook resume for ".concat(loopBrainIdentifier, ":"), error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 22:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     }
 };
 export var schedules = {