@positronic/core 0.0.63 → 0.0.65

package/dist/src/dsl/brain-state-machine.js

@@ -436,10 +436,6 @@ var stepStatus = reduce(function(ctx, param) {
         brains: newBrains
     });
 });
-// stepRetry is a no-op - we just let the event pass through
-var stepRetry = reduce(function(ctx) {
-    return ctx;
-});
 // passthrough is now a no-op - we just let the event pass through
 var passthrough = function() {
     return reduce(function(ctx) {
@@ -568,7 +564,7 @@ var makeBrainMachine = function(initialContext) {
         transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain), // Webhook -> waiting (for non-agent webhooks)
         transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause), // Webhook response (for resume from non-agent webhook)
         transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), // Step events
-        transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), transition(BRAIN_EVENTS.STEP_RETRY, 'running', stepRetry), // Batch chunk complete - stays in running, accumulates results
+        transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), // Batch chunk complete - stays in running, accumulates results
         transition(BRAIN_EVENTS.BATCH_CHUNK_COMPLETE, 'running', batchChunkComplete), // AGENT_START transitions to the agentLoop state
         transition(BRAIN_EVENTS.AGENT_START, 'agentLoop', agentStart)),
         // Explicit agent loop state - isolates agent execution logic

package/dist/src/dsl/builder/brain.js

@@ -375,6 +375,7 @@ function _ts_values(o) {
 }
 import { z } from 'zod';
 import { BrainEventStream } from '../execution/event-stream.js';
+import { parseDuration } from '../duration.js';
 export var Brain = /*#__PURE__*/ function() {
     "use strict";
     function Brain(title, description) {
@@ -554,12 +555,14 @@ export var Brain = /*#__PURE__*/ function() {
         },
         {
             key: "wait",
-            value: function wait(title, action) {
-                var waitBlock = {
+            value: function wait(title, action, options) {
+                var waitBlock = _object_spread({
                     type: 'wait',
                     title: title,
                     action: action
-                };
+                }, (options === null || options === void 0 ? void 0 : options.timeout) !== undefined && {
+                    timeout: parseDuration(options.timeout)
+                });
                 this.blocks.push(waitBlock);
                 return this.nextBrain();
             }
@@ -685,13 +688,12 @@ export var Brain = /*#__PURE__*/ function() {
                         },
                         batchConfig: {
                             over: batchConfig.over,
-                            maxRetries: batchConfig.maxRetries,
                             error: batchConfig.error,
                             template: config.template,
                             schema: outputSchema.schema,
                             schemaName: outputSchema.name,
                             client: config.client,
-                            chunkSize: batchConfig.chunkSize
+                            concurrency: batchConfig.concurrency
                         }
                     };
                     this.blocks.push(promptBlock1);

package/dist/src/dsl/constants.js

@@ -5,7 +5,6 @@ export var BRAIN_EVENTS = {
     RESTART: 'brain:restart',
     STEP_START: 'step:start',
     STEP_COMPLETE: 'step:complete',
-    STEP_RETRY: 'step:retry',
     STEP_STATUS: 'step:status',
     ERROR: 'brain:error',
     COMPLETE: 'brain:complete',

package/dist/src/dsl/duration.js

@@ -0,0 +1,23 @@
+import ms from 'ms';
+/**
+ * Parse a duration value to milliseconds.
+ * Accepts a number (ms passthrough) or a string parsed by `ms` (e.g., '1h', '30m', '7d').
+ * Throws on invalid input.
+ */ export function parseDuration(input) {
+    if (typeof input === 'number') {
+        if (!Number.isFinite(input) || input <= 0) {
+            throw new Error("Invalid duration: ".concat(input, ". Must be a positive finite number of milliseconds."));
+        }
+        return input;
+    }
+    var result;
+    try {
+        result = ms(input);
+    } catch (e) {
+        throw new Error('Invalid duration string: "'.concat(input, '". Use formats like "30m", "1h", "24h", "7d".'));
+    }
+    if (result === undefined || result <= 0) {
+        throw new Error('Invalid duration string: "'.concat(input, '". Use formats like "30m", "1h", "24h", "7d".'));
+    }
+    return result;
+}

package/dist/src/dsl/example-webhook.js

@@ -246,6 +246,8 @@ var myBrain = brain('My Brain').step('My Step', function(param) {
         slackWebhook('thread-123'),
         emailWebhook('email-456')
     ];
+}, {
+    timeout: '24h'
 }).step('My Step 2', function(param) {
     var state = param.state, response = param.response;
     if (response) {

package/dist/src/dsl/execution/constants.js

@@ -9,6 +9,3 @@
  * Default system prompt prepended to all agent steps.
  * Explains the headless nature of Positronic Brains.
  */ export var DEFAULT_AGENT_SYSTEM_PROMPT = "## You Are a Positronic Brain\n\nYou are running as an automated agent in a headless workflow. This is NOT a chat interface - there is no user watching your text output.\n\n**To communicate with users, you MUST use tool calls.** Look at your available tools and use them to send messages, notifications, or create pages for user interaction.\n\n## Tool Execution\n- Tools execute sequentially in the order you call them\n- Webhook-triggering tools pause execution until the webhook fires\n- Terminal tools (like 'done') end the agent immediately\n\n## Resumption\nWhen resuming after a webhook, that response appears as the tool result in your conversation history.";
-/**
- * Maximum number of retries for step execution.
- */ export var MAX_RETRIES = 1;

package/dist/src/dsl/execution/event-stream.js

@@ -469,11 +469,50 @@ import { generateUI } from '../../ui/generate-ui.js';
 import { generatePageHtml } from '../../ui/generate-page-html.js';
 import { createScopedMemory } from '../../memory/scoped-memory.js';
 import { Step } from '../builder/step.js';
-import { DEFAULT_ENV, DEFAULT_AGENT_SYSTEM_PROMPT, MAX_RETRIES } from './constants.js';
+import { DEFAULT_ENV, DEFAULT_AGENT_SYSTEM_PROMPT } from './constants.js';
 import { defaultDoneSchema } from '../../tools/index.js';
 var clone = function(value) {
     return structuredClone(value);
 };
+function createSemaphore(limit) {
+    var running = 0;
+    var queue = [];
+    return {
+        acquire: function acquire() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    if (running < limit) {
+                        running++;
+                        return [
+                            2,
+                            function() {
+                                running--;
+                                if (queue.length > 0) {
+                                    running++;
+                                    queue.shift()();
+                                }
+                            }
+                        ];
+                    }
+                    return [
+                        2,
+                        new Promise(function(resolve) {
+                            queue.push(function() {
+                                return resolve(function() {
+                                    running--;
+                                    if (queue.length > 0) {
+                                        running++;
+                                        queue.shift()();
+                                    }
+                                });
+                            });
+                        })
+                    ];
+                });
+            })();
+        }
+    };
+}
 export var BrainEventStream = /*#__PURE__*/ function() {
     "use strict";
     function BrainEventStream(params) {
@@ -1009,7 +1048,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
             key: "executeStep",
             value: function executeStep(step) {
                 return _wrap_async_generator(function() {
-                    var block, stepBlock, _this_resumeContext, brainBlock, initialState, innerResumeContext, patches, innerBrainPaused, _this_options, _this_options1, innerRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err, _innerResumeContext_state, baseState, innerState, prevState, _, prevState1, stepBlock1, retries, result, _this_options2, actionPromise, error, _this_options3;
+                    var block, stepBlock, _this_resumeContext, brainBlock, initialState, innerResumeContext, patches, innerBrainPaused, _this_options, _this_options1, innerRun, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, event, err, _innerResumeContext_state, baseState, innerState, prevState, _, prevState1, stepBlock1, _this_options2, result;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -1203,7 +1242,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 _state.sent();
                                 return [
                                     3,
-                                    33
+                                    25
                                 ];
                             case 20:
                                 if (!(block.type === 'agent')) return [
@@ -1218,91 +1257,28 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 _state.sent();
                                 return [
                                     3,
-                                    33
+                                    25
                                 ];
                             case 22:
                                 // Get previous state before action
                                 prevState1 = this.currentState;
                                 stepBlock1 = block;
-                                // Execute step with automatic retry on failure
-                                retries = 0;
-                                _state.label = 23;
-                            case 23:
-                                if (!true) return [
-                                    3,
-                                    31
-                                ];
-                                _state.label = 24;
-                            case 24:
-                                _state.trys.push([
-                                    24,
-                                    26,
-                                    ,
-                                    30
-                                ]);
-                                actionPromise = Promise.resolve(stepBlock1.action(_object_spread({
-                                    state: this.currentState,
-                                    options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
-                                    client: this.client,
-                                    resources: this.resources,
-                                    response: this.currentResponse,
-                                    page: this.currentPage,
-                                    pages: this.pages,
-                                    env: this.env,
-                                    memory: this.scopedMemory
-                                }, this.services)));
                                 return [
                                     4,
-                                    _await_async_generator(actionPromise)
+                                    _await_async_generator(Promise.resolve(stepBlock1.action(_object_spread({
+                                        state: this.currentState,
+                                        options: (_this_options2 = this.options) !== null && _this_options2 !== void 0 ? _this_options2 : {},
+                                        client: this.client,
+                                        resources: this.resources,
+                                        response: this.currentResponse,
+                                        page: this.currentPage,
+                                        pages: this.pages,
+                                        env: this.env,
+                                        memory: this.scopedMemory
+                                    }, this.services))))
                                 ];
-                            case 25:
+                            case 23:
                                 result = _state.sent();
-                                return [
-                                    3,
-                                    31
-                                ]; // Success
-                            case 26:
-                                error = _state.sent();
-                                if (!(retries < MAX_RETRIES)) return [
-                                    3,
-                                    28
-                                ];
-                                retries++;
-                                return [
-                                    4,
-                                    {
-                                        type: BRAIN_EVENTS.STEP_RETRY,
-                                        stepTitle: step.block.title,
-                                        stepId: step.id,
-                                        error: {
-                                            name: error.name,
-                                            message: error.message,
-                                            stack: error.stack
-                                        },
-                                        attempt: retries,
-                                        options: (_this_options3 = this.options) !== null && _this_options3 !== void 0 ? _this_options3 : {},
-                                        brainRunId: this.brainRunId
-                                    }
-                                ];
-                            case 27:
-                                _state.sent();
-                                return [
-                                    3,
-                                    29
-                                ];
-                            case 28:
-                                throw error;
-                            case 29:
-                                return [
-                                    3,
-                                    30
-                                ];
-                            case 30:
-                                return [
-                                    3,
-                                    23
-                                ];
-                            case 31:
                                 // Extract state from result (handles promptResponse case)
                                 if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
                                     this.currentState = result.state;
@@ -1313,7 +1289,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     5,
                                     _ts_values(_async_generator_delegate(_async_iterator(this.completeStep(step, prevState1))))
                                 ];
-                            case 32:
+                            case 24:
                                 _state.sent();
                                 // Handle promptResponse - set currentResponse for next step
                                 if (result && (typeof result === "undefined" ? "undefined" : _type_of(result)) === 'object' && 'promptResponse' in result) {
@@ -1321,8 +1297,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 // Reset currentPage after step consumes it (page is ephemeral)
                                 this.currentPage = undefined;
-                                _state.label = 33;
-                            case 33:
+                                _state.label = 25;
+                            case 25:
                                 return [
                                     2
                                 ];
@@ -1734,7 +1710,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                                 var desc = comp.description.split('\n')[0]; // First line only
                                                 return "- ".concat(compName, ": ").concat(desc);
                                             }).join('\n');
-                                            description = "Generate a web page for displaying rich content or collecting user input.\n\nSometimes you need more than simple notifications to communicate with users. This tool creates web pages that can display formatted content, dashboards, or forms to collect information.\n\nAVAILABLE COMPONENTS:\n".concat(componentList, "\n\nRETURNS: { url: string, webhook: { slug: string, identifier: string } | null }\n- url: The page URL\n- webhook: For forms (hasForm=true), contains slug and identifier that can be passed to waitForWebhook to pause execution until the user submits the form\n\nIMPORTANT: Users have no way to discover the page URL on their own. After generating a page, you must tell them the URL using whatever communication tools are available.");
+                                            description = "Generate a web page for displaying rich content or collecting user input.\n\nSometimes you need more than simple notifications to communicate with users. This tool creates web pages that can display formatted content, dashboards, or forms to collect information.\n\nAVAILABLE COMPONENTS:\n".concat(componentList, "\n\nRETURNS: { url: string, webhook: { slug: string, identifier: string, token: string } | null }\n- url: The page URL\n- webhook: For forms (hasForm=true), contains slug, identifier, and token that must all be passed to waitForWebhook to pause execution until the user submits the form\n\nIMPORTANT: Users have no way to discover the page URL on their own. After generating a page, you must tell them the URL using whatever communication tools are available.");
                                         }
                                         toolsForClient[name1] = {
                                             description: description,
@@ -1995,9 +1971,11 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     webhooks: webhooks.map(function(w) {
                                         return {
                                             slug: w.slug,
-                                            identifier: w.identifier
+                                            identifier: w.identifier,
+                                            token: w.token
                                         };
-                                    })
+                                    }),
+                                    timeout: waitForResult.timeout
                                 };
                                 // Emit tool result event for debugging/visibility (with pending status)
                                 return [
@@ -2133,12 +2111,15 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 // Emit WEBHOOK event with all webhooks (first response wins)
                                 return [
                                     4,
-                                    {
+                                    _object_spread_props(_object_spread({
                                         type: BRAIN_EVENTS.WEBHOOK,
-                                        waitFor: pendingWebhook.webhooks,
+                                        waitFor: pendingWebhook.webhooks
+                                    }, pendingWebhook.timeout !== undefined && {
+                                        timeout: pendingWebhook.timeout
+                                    }), {
                                         options: (_this_options18 = this.options) !== null && _this_options18 !== void 0 ? _this_options18 : {},
                                         brainRunId: this.brainRunId
-                                    }
+                                    })
                                 ];
                             case 58:
                                 _state.sent();
@@ -2167,7 +2148,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
    * Cloudflare backends can restart the DO to reclaim memory.
    */ function executeBatchPrompt(step) {
                 return _wrap_async_generator(function() {
-                    var _this, _this_resumeContext, block, batchConfig, prevState, _batchConfig_client, client, items, totalItems, _batchConfig_chunkSize, chunkSize, batchProgress, _batchProgress_processedCount, startIndex, results, chunkStart, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, chunkEnd, chunk, chunkResults, i, _this_options1, finalResults;
+                    var _this, _this_resumeContext, block, batchConfig, prevState, _batchConfig_client, client, items, totalItems, _batchConfig_concurrency, concurrency, semaphore, batchProgress, _batchProgress_processedCount, startIndex, results, chunkStart, signals, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, signal, _this_options, err, chunkEnd, chunk, chunkResults, i, _this_options1, finalResults;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -2178,7 +2159,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 client = (_batchConfig_client = batchConfig.client) !== null && _batchConfig_client !== void 0 ? _batchConfig_client : this.client;
                                 items = batchConfig.over(this.currentState);
                                 totalItems = items.length;
-                                chunkSize = (_batchConfig_chunkSize = batchConfig.chunkSize) !== null && _batchConfig_chunkSize !== void 0 ? _batchConfig_chunkSize : 10;
+                                concurrency = (_batchConfig_concurrency = batchConfig.concurrency) !== null && _batchConfig_concurrency !== void 0 ? _batchConfig_concurrency : 10;
+                                semaphore = createSemaphore(concurrency);
                                 // Resume support: pick up from where we left off
                                 batchProgress = (_this_resumeContext = this.resumeContext) === null || _this_resumeContext === void 0 ? void 0 : _this_resumeContext.batchProgress;
                                 startIndex = (_batchProgress_processedCount = batchProgress === null || batchProgress === void 0 ? void 0 : batchProgress.processedCount) !== null && _batchProgress_processedCount !== void 0 ? _batchProgress_processedCount : 0;
@@ -2285,39 +2267,45 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     7
                                 ];
                             case 11:
-                                chunkEnd = Math.min(chunkStart + chunkSize, totalItems);
+                                chunkEnd = Math.min(chunkStart + concurrency, totalItems);
                                 chunk = items.slice(chunkStart, chunkEnd);
                                 return [
                                     4,
                                     _await_async_generator(Promise.all(chunk.map(function(item) {
                                         return _async_to_generator(function() {
-                                            var promptText, output, error, fallback;
+                                            var release, promptText, output, error, fallback;
                                             return _ts_generator(this, function(_state) {
                                                 switch(_state.label){
                                                     case 0:
+                                                        return [
+                                                            4,
+                                                            semaphore.acquire()
+                                                        ];
+                                                    case 1:
+                                                        release = _state.sent();
+                                                        _state.label = 2;
+                                                    case 2:
                                                         _state.trys.push([
-                                                            0,
-                                                            3,
-                                                            ,
-                                                            4
+                                                            2,
+                                                            5,
+                                                            6,
+                                                            7
                                                         ]);
                                                         return [
                                                             4,
                                                             batchConfig.template(item, this.resources)
                                                         ];
-                                                    case 1:
+                                                    case 3:
                                                         promptText = _state.sent();
                                                         return [
                                                             4,
-                                                            client.generateObject(_object_spread({
+                                                            client.generateObject({
                                                                 schema: batchConfig.schema,
                                                                 schemaName: batchConfig.schemaName,
                                                                 prompt: promptText
-                                                            }, batchConfig.maxRetries !== undefined && {
-                                                                maxRetries: batchConfig.maxRetries
-                                                            }))
+                                                            })
                                                         ];
-                                                    case 2:
+                                                    case 4:
                                                         output = _state.sent();
                                                         return [
                                                             2,
@@ -2326,7 +2314,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                                                 output
                                                             ]
                                                         ];
-                                                    case 3:
+                                                    case 5:
                                                         error = _state.sent();
                                                         if (batchConfig.error) {
                                                             fallback = batchConfig.error(item, error);
@@ -2339,7 +2327,12 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                                             ];
                                                         }
                                                         throw error;
-                                                    case 4:
+                                                    case 6:
+                                                        release();
+                                                        return [
+                                                            7
+                                                        ];
+                                                    case 7:
                                                         return [
                                                             2
                                                         ];
@@ -2374,7 +2367,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 _state.sent();
                                 _state.label = 14;
                             case 14:
-                                chunkStart += chunkSize;
+                                chunkStart += concurrency;
                                 return [
                                     3,
                                     1
@@ -2406,7 +2399,7 @@ export var BrainEventStream = /*#__PURE__*/ function() {
    * Generates UI components, renders to HTML, creates page, and sets up webhook.
    */ function executeUIStep(step, stepBlock) {
                 return _wrap_async_generator(function() {
-                    var prevState, uiConfig, prompt, uiResult, placementCount, placementInfo, _uiResult_text, webhookIdentifier, formAction, html, page, _uiConfig_responseSchema, webhook;
+                    var prevState, uiConfig, prompt, uiResult, placementCount, placementInfo, _uiResult_text, webhookIdentifier, formToken, formAction, html, page, _uiConfig_responseSchema, webhook;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -2453,6 +2446,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 }
                                 // Create unique identifier for this form submission webhook
                                 webhookIdentifier = "".concat(this.brainRunId, "-").concat(step.id);
+                                // Generate CSRF token for form submission validation
+                                formToken = crypto.randomUUID();
                                 // Construct form action URL for the webhook
                                 formAction = "".concat(this.env.origin, "/webhooks/system/ui-form?identifier=").concat(encodeURIComponent(webhookIdentifier));
                                 // Generate HTML page
@@ -2461,7 +2456,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                     rootId: uiResult.rootId,
                                     data: this.currentState,
                                     title: stepBlock.title,
-                                    formAction: formAction
+                                    formAction: formAction,
+                                    formToken: formToken
                                 });
                                 return [
                                     4,
@@ -2474,7 +2470,8 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 webhook = {
                                     slug: 'ui-form',
                                     identifier: webhookIdentifier,
-                                    schema: (_uiConfig_responseSchema = uiConfig.responseSchema) !== null && _uiConfig_responseSchema !== void 0 ? _uiConfig_responseSchema : z.record(z.unknown())
+                                    schema: (_uiConfig_responseSchema = uiConfig.responseSchema) !== null && _uiConfig_responseSchema !== void 0 ? _uiConfig_responseSchema : z.record(z.unknown()),
+                                    token: formToken
                                 };
                                 // Set currentPage for the next step to access
                                 this.currentPage = {
@@ -2583,18 +2580,22 @@ export var BrainEventStream = /*#__PURE__*/ function() {
                                 serializedWaitFor = webhooks.map(function(registration) {
                                     return {
                                         slug: registration.slug,
-                                        identifier: registration.identifier
+                                        identifier: registration.identifier,
+                                        token: registration.token
                                     };
                                 });
                                 // Emit WEBHOOK event
                                 return [
                                     4,
-                                    {
+                                    _object_spread_props(_object_spread({
                                         type: BRAIN_EVENTS.WEBHOOK,
-                                        waitFor: serializedWaitFor,
+                                        waitFor: serializedWaitFor
+                                    }, waitBlock.timeout !== undefined && {
+                                        timeout: waitBlock.timeout
+                                    }), {
                                         options: this.options,
                                         brainRunId: this.brainRunId
-                                    }
+                                    })
                                 ];
                             case 6:
                                 _state.sent();

package/dist/src/dsl/webhook.js

@@ -1,11 +1,12 @@
 // Factory function to create webhooks
 export function createWebhook(slug, schema, handler) {
     // Create the registration function
-    var webhookFn = function(identifier) {
+    var webhookFn = function(identifier, token) {
         return {
             slug: slug,
             identifier: identifier,
-            schema: schema
+            schema: schema,
+            token: token
         };
     };
     // Attach properties to the function

package/dist/src/index.js

@@ -3,6 +3,7 @@ export { BrainRunner } from './dsl/brain-runner.js';
 export { createBrain } from './dsl/create-brain.js';
 export { STATUS, BRAIN_EVENTS } from './dsl/constants.js';
 export { applyPatches } from './dsl/json-patch.js';
+export { parseDuration } from './dsl/duration.js';
 // Only needed for development to ensure that zod version numbers are the same, it's a peer
 // dependency so when not using file://..path/to/package links the version numbers
 // will match just fine if the user has the same version of zod installed.
@@ -14,6 +15,11 @@ export { RESOURCE_TYPES } from './resources/resources.js';
 // Default tools
 export { createTool, defaultTools, defaultDoneSchema, generateUI, waitForWebhook, print, consoleLog } from './tools/index.js';
 export { createScopedMemory } from './memory/scoped-memory.js';
+// UI utilities
+export { generateFormToken } from './ui/generate-page-html.js';
+export { parseFormData } from './ui/parse-form-data.js';
+// Webhook token validation
+export { validateWebhookToken } from './validate-webhook-token.js';
 // Brain state machine
 export { createBrainExecutionMachine, createBrainMachine, sendEvent, reconstructBrainTree, brainMachineDefinition } from './dsl/brain-state-machine.js';
 // Signal validation