@positronic/spec 0.0.77 → 0.0.78

package/dist/src/api/brains.js

@@ -1794,392 +1794,6 @@ export var brains = {
             });
         })();
     },
-    watchAgentEvents: /**
-   * Test that agent steps emit proper AGENT_* events in the SSE stream.
-   * Requires a brain with an agent step that will pause on a webhook.
-   *
-   * Expected events before webhook pause:
-   * - AGENT_START (with prompt and optional system)
-   * - AGENT_ITERATION
-   * - AGENT_TOOL_CALL
-   * - AGENT_WEBHOOK (before WEBHOOK event)
-   * - WEBHOOK
-   */ function watchAgentEvents(fetch, agentBrainIdentifier) {
-        return _async_to_generator(function() {
-            var brainRunId, watchRequest, watchResponse, events, _tmp, hasAgentStart, agentStartEvent, hasAgentIteration, hasAgentToolCall, webhookIndex, agentWebhookIndex, agentWebhookEvent, error;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        _state.trys.push([
-                            0,
-                            6,
-                            ,
-                            7
-                        ]);
-                        return [
-                            4,
-                            startBrainRun(fetch, agentBrainIdentifier)
-                        ];
-                    case 1:
-                        brainRunId = _state.sent();
-                        if (!brainRunId) return [
-                            2,
-                            false
-                        ];
-                        // Watch the brain run
-                        watchRequest = new Request("http://example.com/brains/runs/".concat(brainRunId, "/watch"), {
-                            method: 'GET'
-                        });
-                        return [
-                            4,
-                            fetch(watchRequest)
-                        ];
-                    case 2:
-                        watchResponse = _state.sent();
-                        if (!watchResponse.ok) {
-                            console.error("GET /brains/runs/".concat(brainRunId, "/watch returned ").concat(watchResponse.status));
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        if (!watchResponse.body) return [
-                            3,
-                            4
-                        ];
-                        return [
-                            4,
-                            readSseUntil(watchResponse.body, function(event) {
-                                return event.type === BRAIN_EVENTS.WEBHOOK || event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR;
-                            })
-                        ];
-                    case 3:
-                        _tmp = _state.sent();
-                        return [
-                            3,
-                            5
-                        ];
-                    case 4:
-                        _tmp = [];
-                        _state.label = 5;
-                    case 5:
-                        events = _tmp;
-                        // Verify required agent events are present
-                        hasAgentStart = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.AGENT_START;
-                        });
-                        if (!hasAgentStart) {
-                            console.error('Missing AGENT_START event in SSE stream');
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        // Verify AGENT_START has prompt field
-                        agentStartEvent = events.find(function(e) {
-                            return e.type === BRAIN_EVENTS.AGENT_START;
-                        });
-                        if (!agentStartEvent.prompt || typeof agentStartEvent.prompt !== 'string') {
-                            console.error('AGENT_START event missing prompt field');
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        hasAgentIteration = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.AGENT_ITERATION;
-                        });
-                        if (!hasAgentIteration) {
-                            console.error('Missing AGENT_ITERATION event in SSE stream');
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        hasAgentToolCall = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.AGENT_TOOL_CALL;
-                        });
-                        if (!hasAgentToolCall) {
-                            console.error('Missing AGENT_TOOL_CALL event in SSE stream');
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        // If we got a WEBHOOK event, verify AGENT_WEBHOOK came before it
-                        webhookIndex = events.findIndex(function(e) {
-                            return e.type === BRAIN_EVENTS.WEBHOOK;
-                        });
-                        if (webhookIndex !== -1) {
-                            agentWebhookIndex = events.findIndex(function(e) {
-                                return e.type === BRAIN_EVENTS.AGENT_WEBHOOK;
-                            });
-                            if (agentWebhookIndex === -1) {
-                                console.error('Missing AGENT_WEBHOOK event before WEBHOOK event');
-                                return [
-                                    2,
-                                    false
-                                ];
-                            }
-                            if (agentWebhookIndex >= webhookIndex) {
-                                console.error('AGENT_WEBHOOK event must come before WEBHOOK event');
-                                return [
-                                    2,
-                                    false
-                                ];
-                            }
-                            // Verify AGENT_WEBHOOK has required fields
-                            agentWebhookEvent = events[agentWebhookIndex];
-                            if (!agentWebhookEvent.toolCallId || !agentWebhookEvent.toolName) {
-                                console.error('AGENT_WEBHOOK event missing toolCallId or toolName fields');
-                                return [
-                                    2,
-                                    false
-                                ];
-                            }
-                        }
-                        return [
-                            2,
-                            true
-                        ];
-                    case 6:
-                        error = _state.sent();
-                        console.error("Failed to test agent events for ".concat(agentBrainIdentifier, ":"), error);
-                        return [
-                            2,
-                            false
-                        ];
-                    case 7:
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    },
-    agentWebhookResume: /**
-   * Test full agent webhook resumption flow:
-   * 1. Start an agent 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 AGENT_TOOL_RESULT
-   *
-   * Requires:
-   * - A brain with an agent step that calls a tool returning { waitFor: webhook(...) }
-   * - The webhook slug and identifier to trigger
-   */ function agentWebhookResume(fetch, agentBrainIdentifier, webhookSlug, webhookPayload) {
-        return _async_to_generator(function() {
-            var brainRunId, watchRequest, watchResponse, earlyTermination, watchEvents, foundWebhookEvent, webhookRequest, webhookResponse, webhookResult, resumeWatchRequest, resumeWatchResponse, resumeEvents, _tmp, hasWebhookResponse, hasAgentToolResult, completeEvent, error;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        _state.trys.push([
-                            0,
-                            10,
-                            ,
-                            11
-                        ]);
-                        return [
-                            4,
-                            startBrainRun(fetch, agentBrainIdentifier)
-                        ];
-                    case 1:
-                        brainRunId = _state.sent();
-                        if (!brainRunId) return [
-                            2,
-                            false
-                        ];
-                        // 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 2:
-                        watchResponse = _state.sent();
-                        if (!watchResponse.ok) {
-                            console.error("GET /brains/runs/".concat(brainRunId, "/watch returned ").concat(watchResponse.status));
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        if (!watchResponse.body) {
-                            console.error('Watch response has no body');
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        earlyTermination = false;
-                        return [
-                            4,
-                            readSseUntil(watchResponse.body, function(event) {
-                                if (event.type === BRAIN_EVENTS.WEBHOOK) return true;
-                                if (event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR) {
-                                    console.error("Brain completed/errored before WEBHOOK event: ".concat(event.type));
-                                    earlyTermination = true;
-                                    return true;
-                                }
-                                return false;
-                            })
-                        ];
-                    case 3:
-                        watchEvents = _state.sent();
-                        if (earlyTermination) return [
-                            2,
-                            false
-                        ];
-                        foundWebhookEvent = watchEvents.some(function(e) {
-                            return e.type === BRAIN_EVENTS.WEBHOOK;
-                        });
-                        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 4:
-                        webhookResponse = _state.sent();
-                        if (!webhookResponse.ok) {
-                            console.error("POST /webhooks/".concat(webhookSlug, " returned ").concat(webhookResponse.status));
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        return [
-                            4,
-                            webhookResponse.json()
-                        ];
-                    case 5:
-                        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 6:
-                        resumeWatchResponse = _state.sent();
-                        if (!resumeWatchResponse.ok) {
-                            console.error("GET /brains/runs/".concat(brainRunId, "/watch (resume) returned ").concat(resumeWatchResponse.status));
-                            return [
-                                2,
-                                false
-                            ];
-                        }
-                        if (!resumeWatchResponse.body) return [
-                            3,
-                            8
-                        ];
-                        return [
-                            4,
-                            readSseUntil(resumeWatchResponse.body, function(event) {
-                                return event.type === BRAIN_EVENTS.COMPLETE || event.type === BRAIN_EVENTS.ERROR;
-                            })
-                        ];
-                    case 7:
-                        _tmp = _state.sent();
-                        return [
-                            3,
-                            9
-                        ];
-                    case 8:
-                        _tmp = [];
-                        _state.label = 9;
-                    case 9:
-                        resumeEvents = _tmp;
-                        // 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 AGENT_TOOL_RESULT event is present (with the webhook response as result)
-                        hasAgentToolResult = resumeEvents.some(function(e) {
-                            return e.type === BRAIN_EVENTS.AGENT_TOOL_RESULT;
-                        });
-                        if (!hasAgentToolResult) {
-                            console.error('Missing AGENT_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 10:
-                        error = _state.sent();
-                        console.error("Failed to test agent webhook resume for ".concat(agentBrainIdentifier, ":"), error);
-                        return [
-                            2,
-                            false
-                        ];
-                    case 11:
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    },
     innerBrainCompleteDoesNotAffectOuterStatus: /**
    * Test that inner brain COMPLETE events don't overwrite outer brain status.
    *