@positronic/core 0.0.77 → 0.0.78

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

@@ -0,0 +1,67 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export var Continuation = /*#__PURE__*/ function() {
+    "use strict";
+    function Continuation(addBlock, createNextBrain) {
+        _class_call_check(this, Continuation);
+        _define_property(this, "addBlock", void 0);
+        _define_property(this, "createNextBrain", void 0);
+        this.addBlock = addBlock;
+        this.createNextBrain = createNextBrain;
+    }
+    _create_class(Continuation, [
+        {
+            key: "handle",
+            value: function handle(title, action) {
+                this.addBlock({
+                    type: 'step',
+                    title: title,
+                    action: action
+                });
+                return this.createNextBrain();
+            }
+        },
+        {
+            key: "guard",
+            value: function guard(predicate, title) {
+                this.addBlock({
+                    type: 'guard',
+                    title: title !== null && title !== void 0 ? title : 'Guard',
+                    predicate: predicate
+                });
+                return new Continuation(this.addBlock, this.createNextBrain);
+            }
+        }
+    ]);
+    return Continuation;
+}();

package/dist/src/dsl/constants.js

@@ -13,20 +13,22 @@ export var BRAIN_EVENTS = {
     RESUMED: 'brain:resumed',
     WEBHOOK: 'brain:webhook',
     WEBHOOK_RESPONSE: 'brain:webhook_response',
-    // Agent step events
-    AGENT_START: 'agent:start',
-    AGENT_ITERATION: 'agent:iteration',
-    AGENT_TOOL_CALL: 'agent:tool_call',
-    AGENT_TOOL_RESULT: 'agent:tool_result',
-    AGENT_ASSISTANT_MESSAGE: 'agent:assistant_message',
-    AGENT_COMPLETE: 'agent:complete',
-    AGENT_TOKEN_LIMIT: 'agent:token_limit',
-    AGENT_ITERATION_LIMIT: 'agent:iteration_limit',
-    AGENT_WEBHOOK: 'agent:webhook',
-    AGENT_RAW_RESPONSE_MESSAGE: 'agent:raw_response_message',
-    AGENT_USER_MESSAGE: 'agent:user_message',
     // Iterate events (prompt/brain with `over`)
-    ITERATE_ITEM_COMPLETE: 'iterate:item_complete'
+    ITERATE_ITEM_COMPLETE: 'iterate:item_complete',
+    // Prompt loop events
+    PROMPT_START: 'prompt:start',
+    PROMPT_ITERATION: 'prompt:iteration',
+    PROMPT_TOOL_CALL: 'prompt:tool_call',
+    PROMPT_TOOL_RESULT: 'prompt:tool_result',
+    PROMPT_ASSISTANT_MESSAGE: 'prompt:assistant_message',
+    PROMPT_COMPLETE: 'prompt:complete',
+    PROMPT_TOKEN_LIMIT: 'prompt:token_limit',
+    PROMPT_ITERATION_LIMIT: 'prompt:iteration_limit',
+    PROMPT_RAW_RESPONSE_MESSAGE: 'prompt:raw_response_message',
+    PROMPT_WEBHOOK: 'prompt:webhook',
+    // File events
+    FILE_WRITE_START: 'file:write_start',
+    FILE_WRITE_COMPLETE: 'file:write_complete'
 };
 export var STATUS = {
     PENDING: 'pending',
@@ -36,8 +38,5 @@ export var STATUS = {
     CANCELLED: 'cancelled',
     WAITING: 'waiting',
     PAUSED: 'paused',
-    HALTED: 'halted',
-    // Internal status for tracking when execution is inside an agent loop.
-    // Publicly this maps to RUNNING for consumers.
-    AGENT_LOOP: 'agent_loop'
+    HALTED: 'halted'
 };

package/dist/src/dsl/create-brain.js

@@ -1,69 +1,53 @@
 import { brain as coreBrain } from './builder/brain.js';
 /**
- * Creates a project-level brain function with pre-configured services, components, and tools.
+ * Creates a project-level brain function with pre-configured plugins and components.
  *
- * This is the recommended way to set up brains in a Positronic project. It provides:
- * - Type-safe access to services in all brain steps
- * - Automatic injection of components and default tools
- * - Support for both builder pattern and direct agent creation
+ * Plugin types are inferred from the array and propagated to all brains
+ * created by the returned factory function.
  *
  * @example
  * ```typescript
- * // brain.ts - your project's brain configuration
  * import { createBrain } from '@positronic/core';
+ * import { mem0 } from '@positronic/mem0';
  * import { components } from './components/index.js';
- * import slack from './services/slack.js';
- * import gmail from './services/gmail.js';
  *
  * export const brain = createBrain({
- *   services: { slack, gmail },
+ *   plugins: [mem0.setup({ provider })],
  *   components,
  * });
  * ```
- *
- * @example
- * ```typescript
- * // brains/my-brain.ts - using the configured brain
- * import { brain } from '../brain.js';
- *
- * // Builder pattern
- * export default brain('my-workflow')
- *   .step('Init', ({ slack }) => {
- *     slack.postMessage('#general', 'Starting workflow');
- *     return { started: true };
- *   });
- *
- * // Or direct agent creation
- * export default brain('my-agent', ({ slack, env }) => ({
- *   system: 'You are helpful',
- *   prompt: 'Help the user',
- *   tools: { ... }
- * }));
- * ```
  */ export function createBrain(config) {
-    var services = config.services, components = config.components, defaultTools = config.defaultTools, memory = config.memory, store = config.store;
+    var plugins = config.plugins, components = config.components;
     // Implementation
-    function brain(titleOrConfig, agentConfig) {
+    function brain(titleOrConfig) {
         var base = coreBrain(titleOrConfig);
         if (components) {
             base = base.withComponents(components);
         }
-        if (defaultTools) {
-            base = base.withTools(defaultTools);
-        }
-        if (memory) {
-            base = base.withMemory(memory);
-        }
-        if (store) {
-            base = base.withStore(store);
-        }
-        if (services) {
-            base = base.withServices(services);
-        }
-        if (agentConfig) {
-            return base.brain('main', agentConfig);
+        if (plugins) {
+            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;
+                    base = base.withPlugin(plugin);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
         }
         return base;
     }
+    brain.plugins = plugins !== null && plugins !== void 0 ? plugins : [];
     return brain;
 }

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

@@ -248,7 +248,7 @@ var myBrain = brain('My Brain').step('My Step', function(param) {
     ];
 }, {
     timeout: '24h'
-}).step('My Step 2', function(param) {
+}).handle('My Step 2', function(param) {
     var state = param.state, response = param.response;
     if (response) {
         if ('threadId' in response) {

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

@@ -5,7 +5,3 @@
     origin: 'http://localhost:8787',
     secrets: {}
 };
-/**
- * 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.";

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

@@ -0,0 +1,77 @@
+/**
+ * Simple async queue for passing events between a service (producer)
+ * and the event stream (consumer) during step execution.
+ *
+ * The event stream uses Promise.race between the step completing and
+ * channel.wait() to yield events mid-step without blocking.
+ */ function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export var EventChannel = /*#__PURE__*/ function() {
+    "use strict";
+    function EventChannel() {
+        _class_call_check(this, EventChannel);
+        _define_property(this, "queue", []);
+        _define_property(this, "waiter", null);
+    }
+    _create_class(EventChannel, [
+        {
+            key: "push",
+            value: function push(item) {
+                this.queue.push(item);
+                if (this.waiter) {
+                    this.waiter();
+                    this.waiter = null;
+                }
+            }
+        },
+        {
+            /** Resolves when at least one item is in the queue, or immediately if non-empty */ key: "wait",
+            value: function wait() {
+                var _this = this;
+                if (this.queue.length > 0) return Promise.resolve();
+                return new Promise(function(resolve) {
+                    _this.waiter = resolve;
+                });
+            }
+        },
+        {
+            key: "drain",
+            value: function drain() {
+                var items = this.queue;
+                this.queue = [];
+                return items;
+            }
+        }
+    ]);
+    return EventChannel;
+}();