@positronic/core 0.0.76 → 0.0.78

package/dist/src/dsl/signal-validation.js

@@ -65,7 +65,6 @@ import { BRAIN_EVENTS, STATUS } from './constants.js';
     KILL: BRAIN_EVENTS.CANCELLED,
     PAUSE: BRAIN_EVENTS.PAUSED,
     RESUME: BRAIN_EVENTS.RESUMED,
-    USER_MESSAGE: BRAIN_EVENTS.AGENT_USER_MESSAGE,
     WEBHOOK_RESPONSE: BRAIN_EVENTS.WEBHOOK_RESPONSE
 };
 var _obj;

package/dist/src/dsl/webhook.js

@@ -1,5 +1,5 @@
 // Factory function to create webhooks
-export function createWebhook(slug, schema, handler) {
+export function createWebhook(slug, schema, handler, triggers) {
     // Create the registration function
     var webhookFn = function(identifier, token) {
         return {
@@ -13,5 +13,8 @@ export function createWebhook(slug, schema, handler) {
     webhookFn.handler = handler;
     webhookFn.slug = slug;
     webhookFn.schema = schema;
+    if (triggers) {
+        webhookFn.triggers = triggers;
+    }
     return webhookFn;
 }

package/dist/src/files/event-wrapper.js

@@ -0,0 +1,268 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { BRAIN_EVENTS } from '../dsl/constants.js';
+function startEvent(ctx, fileName) {
+    return {
+        type: BRAIN_EVENTS.FILE_WRITE_START,
+        fileName: fileName,
+        stepTitle: ctx.stepTitle,
+        options: ctx.options,
+        brainRunId: ctx.brainRunId
+    };
+}
+function completeEvent(ctx, fileName) {
+    return {
+        type: BRAIN_EVENTS.FILE_WRITE_COMPLETE,
+        fileName: fileName,
+        stepTitle: ctx.stepTitle,
+        options: ctx.options,
+        brainRunId: ctx.brainRunId
+    };
+}
+function wrapFileHandle(handle, channel, ctx) {
+    return {
+        name: handle.name,
+        get url () {
+            return handle.url;
+        },
+        read: function() {
+            return handle.read();
+        },
+        readBytes: function() {
+            return handle.readBytes();
+        },
+        write: function write(content) {
+            return _async_to_generator(function() {
+                var ref;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            channel.push(startEvent(ctx, handle.name));
+                            return [
+                                4,
+                                handle.write(content)
+                            ];
+                        case 1:
+                            ref = _state.sent();
+                            channel.push(completeEvent(ctx, handle.name));
+                            return [
+                                2,
+                                ref
+                            ];
+                    }
+                });
+            })();
+        },
+        exists: function() {
+            return handle.exists();
+        },
+        delete: function() {
+            return handle.delete();
+        }
+    };
+}
+function wrapZipBuilder(zip, channel, ctx, zipName) {
+    return {
+        write: function write(name, content) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            channel.push(startEvent(ctx, name));
+                            return [
+                                4,
+                                zip.write(name, content)
+                            ];
+                        case 1:
+                            _state.sent();
+                            channel.push(completeEvent(ctx, name));
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        },
+        finalize: function finalize() {
+            return _async_to_generator(function() {
+                var ref;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            channel.push(startEvent(ctx, zipName));
+                            return [
+                                4,
+                                zip.finalize()
+                            ];
+                        case 1:
+                            ref = _state.sent();
+                            channel.push(completeEvent(ctx, zipName));
+                            return [
+                                2,
+                                ref
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
+/**
+ * Wraps a FilesService to push events onto a channel during write operations.
+ * The wrapper is transparent — same interface, brain authors see no change.
+ */ export function wrapFilesWithEvents(files, channel, ctx) {
+    return {
+        open: function open(name, options) {
+            return wrapFileHandle(files.open(name, options), channel, ctx);
+        },
+        write: function write(name, content, options) {
+            return _async_to_generator(function() {
+                var ref;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            channel.push(startEvent(ctx, name));
+                            return [
+                                4,
+                                files.write(name, content, options)
+                            ];
+                        case 1:
+                            ref = _state.sent();
+                            channel.push(completeEvent(ctx, name));
+                            return [
+                                2,
+                                ref
+                            ];
+                    }
+                });
+            })();
+        },
+        list: function() {
+            return files.list();
+        },
+        delete: function(name) {
+            return files.delete(name);
+        },
+        zip: function zip(name, options) {
+            return wrapZipBuilder(files.zip(name, options), channel, ctx, name);
+        }
+    };
+}

package/dist/src/files/index.js

@@ -0,0 +1 @@
+export { };

package/dist/src/files/mime.js

@@ -0,0 +1,31 @@
+var MIME_TYPES = {
+    txt: 'text/plain',
+    json: 'application/json',
+    html: 'text/html',
+    css: 'text/css',
+    js: 'application/javascript',
+    xml: 'application/xml',
+    csv: 'text/csv',
+    mp3: 'audio/mpeg',
+    m4a: 'audio/mp4',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    pdf: 'application/pdf',
+    zip: 'application/zip',
+    gz: 'application/gzip',
+    tar: 'application/x-tar'
+};
+export function guessMimeType(name) {
+    var _name_split_pop;
+    var ext = (_name_split_pop = name.split('.').pop()) === null || _name_split_pop === void 0 ? void 0 : _name_split_pop.toLowerCase();
+    var _MIME_TYPES_;
+    return (_MIME_TYPES_ = MIME_TYPES[ext !== null && ext !== void 0 ? ext : '']) !== null && _MIME_TYPES_ !== void 0 ? _MIME_TYPES_ : 'application/octet-stream';
+}

package/dist/src/files/types.js

@@ -0,0 +1,13 @@
+/**
+ * Accepted input types for file write operations.
+ * - string: text content, written as UTF-8
+ * - Uint8Array: binary content
+ * - Response: fetch response — body is streamed, never fully buffered
+ * - ReadableStream: streamed directly to storage
+ * - FileHandle: another file — content is streamed from storage to storage
+ */ /**
+ * Service for creating and managing files during brain execution.
+ * Available on the step context as `files`.
+ *
+ * Files are always scoped per-user. Default scope is 'brain' (persists across runs).
+ */ export { };

package/dist/src/index.js

@@ -1,7 +1,10 @@
-export { Brain, brain } from './dsl/brain.js';
+export { Brain, brain, Continuation } from './dsl/brain.js';
 export { BrainRunner } from './dsl/brain-runner.js';
 export { createBrain } from './dsl/create-brain.js';
 export { STATUS, BRAIN_EVENTS } from './dsl/constants.js';
+export { Fragment, File, Resource, Form } from './jsx-runtime.js';
+export { renderTemplate, isTemplateNode, resolveTemplate, buildTemplateContext } from './template/render.js';
+export { renderHtml } from './template/render-html.js';
 export { applyPatches } from './dsl/json-patch.js';
 export { IterateResult } from './dsl/iterate-result.js';
 export { parseDuration } from './dsl/duration.js';
@@ -14,8 +17,12 @@ export { createResources } from './resources/resources.js';
 export { createWebhook } from './dsl/webhook.js';
 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';
+export { createTool, defaultTools, generatePage, waitForWebhook, print, consoleLog, readFile, writeFile } from './tools/index.js';
+// Files
+export { guessMimeType } from './files/mime.js';
+// Plugin system
+export { definePlugin } from './plugins/index.js';
+export { collectPluginWebhooks } from './plugins/collect-webhooks.js';
 // UI utilities
 export { generateFormToken } from './ui/generate-page-html.js';
 export { parseFormData } from './ui/parse-form-data.js';

package/dist/src/jsx-runtime.js

@@ -0,0 +1,49 @@
+// Custom JSX runtime for Positronic template authoring.
+// This module is imported automatically by the JSX transform when
+// jsxImportSource is set to "@positronic/core".
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+export var Fragment = Symbol.for('positronic.fragment');
+export var File = Symbol.for('positronic.file');
+export var Resource = Symbol.for('positronic.resource');
+export var Form = Symbol.for('positronic.form');
+// Called by the automatic JSX transform for elements with a single child
+export function jsx(type, props) {
+    var children = props.children, rest = _object_without_properties(props, [
+        "children"
+    ]);
+    return {
+        type: type,
+        props: rest,
+        children: children == null ? [] : [
+            children
+        ]
+    };
+}
+// Called by the automatic JSX transform for elements with multiple children
+export var jsxs = jsx;

package/dist/src/memory/{scoped-memory.js → create-memory.js}

@@ -119,7 +119,7 @@ function _ts_generator(thisArg, body) {
     }
 }
 /**
- * Creates a scoped memory instance with agentId and userId pre-bound.
+ * Creates a Memory instance with agentId and userId pre-bound.
  *
  * This wraps a MemoryProvider and automatically includes the agentId
  * and userId in all calls, so brain steps don't need to pass them explicitly.
@@ -127,17 +127,17 @@ function _ts_generator(thisArg, body) {
  * @param provider - The underlying memory provider
  * @param agentId - The agent/brain ID to scope memories to
  * @param userId - The user name to scope memories to (from currentUser.name)
- * @returns A ScopedMemory instance
+ * @returns A Memory instance
  *
  * @example
  * ```typescript
  * const provider = createMem0Provider({ apiKey: '...' });
- * const scopedMemory = createScopedMemory(provider, 'my-brain', 'user-123');
+ * const memory = createMemory(provider, 'my-brain', 'user-123');
  *
  * // Now search without passing agentId or userId
- * const memories = await scopedMemory.search('user preferences');
+ * const memories = await memory.search('user preferences');
  * ```
- */ export function createScopedMemory(provider, agentId, userId) {
+ */ export function createMemory(provider, agentId, userId) {
     return {
         search: function search(query, options) {
             return _async_to_generator(function() {

package/dist/src/plugins/collect-webhooks.js

@@ -0,0 +1,49 @@
+/**
+ * Collect webhook declarations from all plugins.
+ * Returns a manifest-compatible record mapping slug -> WebhookFunction.
+ */ export function collectPluginWebhooks(plugins) {
+    var result = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var plugin = _step.value;
+            var webhooks = plugin.__plugin.webhooks;
+            if (webhooks) {
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = Object.values(webhooks)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var wh = _step1.value;
+                        result[wh.slug] = wh;
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}

package/dist/src/plugins/define-plugin.js

@@ -0,0 +1,15 @@
+export function definePlugin(definition) {
+    var plugin = {
+        __plugin: definition,
+        __config: undefined
+    };
+    if (definition.setup) {
+        plugin.setup = function(config) {
+            return {
+                __plugin: definition,
+                __config: definition.setup(config)
+            };
+        };
+    }
+    return plugin;
+}

package/dist/src/plugins/index.js

@@ -0,0 +1 @@
+export { definePlugin } from './define-plugin.js';

package/dist/src/plugins/types.js

@@ -0,0 +1,4 @@
+/**
+ * A configured plugin that also has a .setup() method for per-brain configuration.
+ * Returned by definePlugin() when a setup function is provided.
+ */ export { };

package/dist/src/store/types.js

@@ -1,5 +1,4 @@
 /**
- * Conditional type that adds `store` to step params only when withStore() is used.
- * When TStore is `never` (default), this resolves to `{}` — no store in params.
- * When TStore is a record type, this adds `{ store: Store<TStore> }`.
+ * Factory function that creates a typed Store from a schema and runtime context.
+ * Backends implement this to handle persistence and key resolution.
  */ export { };