@positronic/spec 0.0.52 → 0.0.54

package/dist/src/api.js

@@ -1,3 +1,11 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -27,10 +35,48 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
 function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -2461,19 +2507,19 @@ export var brains = {
             });
         })();
     },
-    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.
+    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:
-   * - LOOP_START (with prompt and optional system)
-   * - LOOP_ITERATION
-   * - LOOP_TOOL_CALL
-   * - LOOP_WEBHOOK (before WEBHOOK event)
+   * - AGENT_START (with prompt and optional system)
+   * - AGENT_ITERATION
+   * - AGENT_TOOL_CALL
+   * - AGENT_WEBHOOK (before WEBHOOK event)
    * - WEBHOOK
-   */ function watchLoopEvents(fetch, loopBrainIdentifier) {
+   */ function watchAgentEvents(fetch, agentBrainIdentifier) {
         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;
+            var runRequest, runResponse, brainRunId, watchRequest, watchResponse, events, reader, decoder, buffer, done, _ref, value, streamDone, eventEndIndex, message, event, hasAgentStart, agentStartEvent, hasAgentIteration, hasAgentToolCall, webhookIndex, agentWebhookIndex, agentWebhookEvent, error;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -2483,14 +2529,14 @@ export var brains = {
                             ,
                             12
                         ]);
-                        // Start the loop brain
+                        // Start the agent brain
                         runRequest = new Request('http://example.com/brains/runs', {
                             method: 'POST',
                             headers: {
                                 'Content-Type': 'application/json'
                             },
                             body: JSON.stringify({
-                                identifier: loopBrainIdentifier
+                                identifier: agentBrainIdentifier
                             })
                         });
                         return [
@@ -2605,74 +2651,74 @@ export var brains = {
                             7
                         ];
                     case 10:
-                        // Verify required loop events are present
-                        hasLoopStart = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.LOOP_START;
+                        // Verify required agent events are present
+                        hasAgentStart = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.AGENT_START;
                         });
-                        if (!hasLoopStart) {
-                            console.error('Missing LOOP_START event in SSE stream');
+                        if (!hasAgentStart) {
+                            console.error('Missing AGENT_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;
+                        // Verify AGENT_START has prompt field
+                        agentStartEvent = events.find(function(e) {
+                            return e.type === BRAIN_EVENTS.AGENT_START;
                         });
-                        if (!loopStartEvent.prompt || typeof loopStartEvent.prompt !== 'string') {
-                            console.error('LOOP_START event missing prompt field');
+                        if (!agentStartEvent.prompt || typeof agentStartEvent.prompt !== 'string') {
+                            console.error('AGENT_START event missing prompt field');
                             return [
                                 2,
                                 false
                             ];
                         }
-                        hasLoopIteration = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.LOOP_ITERATION;
+                        hasAgentIteration = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.AGENT_ITERATION;
                         });
-                        if (!hasLoopIteration) {
-                            console.error('Missing LOOP_ITERATION event in SSE stream');
+                        if (!hasAgentIteration) {
+                            console.error('Missing AGENT_ITERATION event in SSE stream');
                             return [
                                 2,
                                 false
                             ];
                         }
-                        hasLoopToolCall = events.some(function(e) {
-                            return e.type === BRAIN_EVENTS.LOOP_TOOL_CALL;
+                        hasAgentToolCall = events.some(function(e) {
+                            return e.type === BRAIN_EVENTS.AGENT_TOOL_CALL;
                         });
-                        if (!hasLoopToolCall) {
-                            console.error('Missing LOOP_TOOL_CALL event in SSE stream');
+                        if (!hasAgentToolCall) {
+                            console.error('Missing AGENT_TOOL_CALL event in SSE stream');
                             return [
                                 2,
                                 false
                             ];
                         }
-                        // If we got a WEBHOOK event, verify LOOP_WEBHOOK came before it
+                        // 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) {
-                            loopWebhookIndex = events.findIndex(function(e) {
-                                return e.type === BRAIN_EVENTS.LOOP_WEBHOOK;
+                            agentWebhookIndex = events.findIndex(function(e) {
+                                return e.type === BRAIN_EVENTS.AGENT_WEBHOOK;
                             });
-                            if (loopWebhookIndex === -1) {
-                                console.error('Missing LOOP_WEBHOOK event before WEBHOOK event');
+                            if (agentWebhookIndex === -1) {
+                                console.error('Missing AGENT_WEBHOOK event before WEBHOOK event');
                                 return [
                                     2,
                                     false
                                 ];
                             }
-                            if (loopWebhookIndex >= webhookIndex) {
-                                console.error('LOOP_WEBHOOK event must come before WEBHOOK event');
+                            if (agentWebhookIndex >= webhookIndex) {
+                                console.error('AGENT_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');
+                            // 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
@@ -2685,7 +2731,7 @@ export var brains = {
                         ];
                     case 11:
                         error = _state.sent();
-                        console.error("Failed to test loop events for ".concat(loopBrainIdentifier, ":"), error);
+                        console.error("Failed to test agent events for ".concat(agentBrainIdentifier, ":"), error);
                         return [
                             2,
                             false
@@ -2698,19 +2744,19 @@ export var brains = {
             });
         })();
     },
-    loopWebhookResume: /**
-   * Test full loop webhook resumption flow:
-   * 1. Start a loop brain that will pause on a webhook
+    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 LOOP_TOOL_RESULT
+   * 4. Verify the brain resumes and emits WEBHOOK_RESPONSE and AGENT_TOOL_RESULT
    *
    * Requires:
-   * - A brain with a loop step that calls a tool returning { waitFor: webhook(...) }
+   * - A brain with an agent step that calls a tool returning { waitFor: webhook(...) }
    * - The webhook slug and identifier to trigger
-   */ function loopWebhookResume(fetch, loopBrainIdentifier, webhookSlug, webhookPayload) {
+   */ function agentWebhookResume(fetch, agentBrainIdentifier, 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;
+            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, hasAgentToolResult, completeEvent, error;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -2720,14 +2766,14 @@ export var brains = {
                             ,
                             22
                         ]);
-                        // Step 1: Start the loop brain
+                        // Step 1: Start the agent brain
                         runRequest = new Request('http://example.com/brains/runs', {
                             method: 'POST',
                             headers: {
                                 'Content-Type': 'application/json'
                             },
                             body: JSON.stringify({
-                                identifier: loopBrainIdentifier
+                                identifier: agentBrainIdentifier
                             })
                         });
                         return [
@@ -2993,12 +3039,12 @@ export var brains = {
                                 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;
+                        // 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 (!hasLoopToolResult) {
-                            console.error('Missing LOOP_TOOL_RESULT event after resume');
+                        if (!hasAgentToolResult) {
+                            console.error('Missing AGENT_TOOL_RESULT event after resume');
                             return [
                                 2,
                                 false
@@ -3028,7 +3074,7 @@ export var brains = {
                         ];
                     case 21:
                         error = _state.sent();
-                        console.error("Failed to test loop webhook resume for ".concat(loopBrainIdentifier, ":"), error);
+                        console.error("Failed to test agent webhook resume for ".concat(agentBrainIdentifier, ":"), error);
                         return [
                             2,
                             false
@@ -4430,6 +4476,213 @@ export var webhooks = {
                 }
             });
         })();
+    },
+    uiForm: /**
+   * Test POST /webhooks/system/ui-form - Built-in webhook for UI form submissions.
+   * This is used by pages generated via .ui() steps to submit form data.
+   *
+   * The endpoint:
+   * - Accepts form data (application/x-www-form-urlencoded or multipart/form-data)
+   * - Requires an `identifier` query parameter to match the waiting brain
+   * - Returns { received: true, action: 'resumed' | 'not_found', ... }
+   */ function uiForm(fetch, identifier, formData) {
+        return _async_to_generator(function() {
+            var params, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, v, request, response, data, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            3,
+                            ,
+                            4
+                        ]);
+                        // Build URLSearchParams from form data
+                        params = new URLSearchParams();
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = Object.entries(formData)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                                if (Array.isArray(value)) {
+                                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                    try {
+                                        for(_iterator1 = value[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                            v = _step1.value;
+                                            params.append("".concat(key, "[]"), v);
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError1 = true;
+                                        _iteratorError1 = err;
+                                    } finally{
+                                        try {
+                                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                                _iterator1.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError1) {
+                                                throw _iteratorError1;
+                                            }
+                                        }
+                                    }
+                                } else {
+                                    params.append(key, value);
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        request = new Request("http://example.com/webhooks/system/ui-form?identifier=".concat(encodeURIComponent(identifier)), {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/x-www-form-urlencoded'
+                            },
+                            body: params.toString()
+                        });
+                        return [
+                            4,
+                            fetch(request)
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        // Accept 200 (found and processed) or 404 (no brain waiting)
+                        if (response.status !== 200 && response.status !== 404) {
+                            console.error("POST /webhooks/system/ui-form returned ".concat(response.status, ", expected 200 or 404"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            response.json()
+                        ];
+                    case 2:
+                        data = _state.sent();
+                        // Validate response structure
+                        if (typeof data.received !== 'boolean') {
+                            console.error("Expected received to be boolean, got ".concat(_type_of(data.received)));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        if (!data.action || typeof data.action !== 'string') {
+                            console.error("Expected action to be string, got ".concat(_type_of(data.action)));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        // Action should be 'resumed' or 'not_found'
+                        if (data.action !== 'resumed' && data.action !== 'not_found') {
+                            console.error("Expected action to be 'resumed' or 'not_found', got '".concat(data.action, "'"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            2,
+                            true
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        console.error('Failed to test POST /webhooks/system/ui-form:', error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    },
+    uiFormMissingIdentifier: /**
+   * Test POST /webhooks/system/ui-form with missing identifier - Should return 400
+   */ function uiFormMissingIdentifier(fetch) {
+        return _async_to_generator(function() {
+            var request, response, data, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            3,
+                            ,
+                            4
+                        ]);
+                        request = new Request('http://example.com/webhooks/system/ui-form', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/x-www-form-urlencoded'
+                            },
+                            body: 'test=data'
+                        });
+                        return [
+                            4,
+                            fetch(request)
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        if (response.status !== 400) {
+                            console.error("POST /webhooks/system/ui-form without identifier returned ".concat(response.status, ", expected 400"));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            4,
+                            response.json()
+                        ];
+                    case 2:
+                        data = _state.sent();
+                        if (!data.error || typeof data.error !== 'string') {
+                            console.error("Expected error to be string, got ".concat(_type_of(data.error)));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        if (!data.error.toLowerCase().includes('identifier')) {
+                            console.error("Expected error message to mention identifier, got: ".concat(data.error));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        return [
+                            2,
+                            true
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        console.error('Failed to test POST /webhooks/system/ui-form without identifier:', error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     }
 };
 export var pages = {
@@ -5148,3 +5401,111 @@ export var pages = {
         })();
     }
 };
+/**
+ * Bundle API Tests
+ *
+ * Tests for the /bundle/components.js endpoint which serves the component bundle.
+ *
+ * NOTE: These tests only verify the API endpoint behavior. The bundle build and
+ * upload process is backend-specific and must be tested separately by each
+ * backend implementation.
+ */ export var bundle = {
+    get: /**
+   * Test GET /bundle/components.js - Serve the component bundle
+   */ function get(fetch) {
+        return _async_to_generator(function() {
+            var request, response, contentType, content, content1, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            6,
+                            ,
+                            7
+                        ]);
+                        request = new Request('http://example.com/bundle/components.js', {
+                            method: 'GET'
+                        });
+                        return [
+                            4,
+                            fetch(request)
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        // Bundle may or may not exist depending on project setup
+                        // 200 = bundle exists and served correctly
+                        // 404 = bundle not found (expected if no components/ directory)
+                        if (response.status !== 200 && response.status !== 404) {
+                            console.error("GET /bundle/components.js returned unexpected status ".concat(response.status));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        contentType = response.headers.get('Content-Type');
+                        if (!contentType || !contentType.includes('application/javascript')) {
+                            console.error("Expected Content-Type application/javascript, got ".concat(contentType));
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        if (!(response.status === 200)) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            response.text()
+                        ];
+                    case 2:
+                        content = _state.sent();
+                        if (!content || content.length === 0) {
+                            console.error('Bundle endpoint returned 200 but empty content');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        _state.label = 3;
+                    case 3:
+                        if (!(response.status === 404)) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            4,
+                            response.text()
+                        ];
+                    case 4:
+                        content1 = _state.sent();
+                        if (!content1.includes('Bundle not found')) {
+                            console.error('Bundle 404 response missing helpful error message');
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        _state.label = 5;
+                    case 5:
+                        return [
+                            2,
+                            true
+                        ];
+                    case 6:
+                        error = _state.sent();
+                        console.error("Failed to test GET /bundle/components.js:", error);
+                        return [
+                            2,
+                            false
+                        ];
+                    case 7:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }
+};

package/dist/src/index.js

@@ -13,4 +13,4 @@
  *
  * This interface provides lifecycle management for a server instance,
  * abstracting away the underlying implementation details (process, worker, etc.)
- */ export { testStatus, resources, brains, schedules, secrets, webhooks, pages } from './api.js';
+ */ export { testStatus, resources, brains, schedules, secrets, webhooks, pages, bundle } from './api.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@positronic/spec",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "publishConfig": {
     "access": "public"
   },