@positronic/core 0.0.76 → 0.0.78

package/dist/src/dsl/builder/brain.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_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function _async_generator(gen) {
     var front, back;
     function send(key, arg) {
@@ -216,6 +224,12 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -255,13 +269,47 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
+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;
+}
 function _overload_yield(value, kind) {
     this.v = value;
     this.k = kind;
 }
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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 _wrap_async_generator(fn) {
     return function() {
@@ -373,9 +421,59 @@ function _ts_values(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 }
-import { z } from 'zod';
+import { Continuation } from './continuation.js';
 import { BrainEventStream } from '../execution/event-stream.js';
 import { parseDuration } from '../duration.js';
+/**
+ * Merge parent and own plugin configs, call create() for each, separate adapters from injections.
+ */ function resolvePlugins(parentConfigs, ownConfigs, ctx) {
+    // Own configs override parent by plugin name
+    var merged = _to_consumable_array(parentConfigs.filter(function(p) {
+        return !ownConfigs.some(function(own) {
+            return own.__plugin.name === p.__plugin.name;
+        });
+    })).concat(_to_consumable_array(ownConfigs));
+    var injections = {};
+    var adapters = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = merged[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _ref = _step.value;
+            var configured = _ref;
+            var plugin = configured.__plugin, config = configured.__config;
+            var _plugin_create = plugin.create({
+                config: config,
+                brainTitle: ctx.brainTitle,
+                currentUser: ctx.currentUser,
+                brainRunId: ctx.brainRunId
+            }), adapter = _plugin_create.adapter, injection = _object_without_properties(_plugin_create, [
+                "adapter"
+            ]);
+            injections[plugin.name] = injection;
+            if (adapter) {
+                adapters.push(adapter);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        injections: injections,
+        adapters: adapters,
+        configs: merged
+    };
+}
 export var Brain = /*#__PURE__*/ function() {
     "use strict";
     function Brain(title, description) {
@@ -384,18 +482,15 @@ export var Brain = /*#__PURE__*/ function() {
         _define_property(this, "description", void 0);
         _define_property(this, "blocks", void 0);
         _define_property(this, "type", void 0);
-        _define_property(this, "services", void 0);
         _define_property(this, "optionsSchema", void 0);
         _define_property(this, "components", void 0);
-        _define_property(this, "defaultTools", void 0);
-        _define_property(this, "extraTools", void 0);
-        _define_property(this, "memoryProvider", void 0);
         _define_property(this, "storeSchema", void 0);
+        _define_property(this, "pluginConfigs", void 0);
         this.title = title;
         this.description = description;
         this.blocks = [];
         this.type = 'brain';
-        this.services = {};
+        this.pluginConfigs = [];
     }
     _create_class(Brain, [
         {
@@ -410,11 +505,6 @@ export var Brain = /*#__PURE__*/ function() {
                                 type: 'step',
                                 title: block.title
                             };
-                        } else if (block.type === 'agent') {
-                            return {
-                                type: 'agent',
-                                title: block.title
-                            };
                         } else if (block.type === 'guard') {
                             return {
                                 type: 'guard',
@@ -425,6 +515,16 @@ export var Brain = /*#__PURE__*/ function() {
                                 type: 'wait',
                                 title: block.title
                             };
+                        } else if (block.type === 'map') {
+                            return {
+                                type: 'map',
+                                title: block.title
+                            };
+                        } else if (block.type === 'prompt') {
+                            return {
+                                type: 'prompt',
+                                title: block.title
+                            };
                         } else {
                             // block.type === 'brain'
                             return {
@@ -438,39 +538,17 @@ export var Brain = /*#__PURE__*/ function() {
             }
         },
         {
-            // New method to add services
-            key: "withServices",
-            value: function withServices(services) {
-                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                // Set services
-                nextBrain.services = services;
-                // Copy optionsSchema to maintain it through the chain
-                nextBrain.optionsSchema = this.optionsSchema;
-                nextBrain.components = this.components;
-                nextBrain.defaultTools = this.defaultTools;
-                nextBrain.extraTools = this.extraTools;
-                nextBrain.memoryProvider = this.memoryProvider;
-                nextBrain.storeSchema = this.storeSchema;
-                return nextBrain;
-            }
-        },
-        {
-            key: "withOptionsSchema",
-            value: function withOptionsSchema(schema) {
+            key: "withOptions",
+            value: function withOptions(schema) {
                 var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
+                this.copyConfigTo(nextBrain);
                 nextBrain.optionsSchema = schema;
-                nextBrain.services = this.services;
-                nextBrain.components = this.components;
-                nextBrain.defaultTools = this.defaultTools;
-                nextBrain.extraTools = this.extraTools;
-                nextBrain.memoryProvider = this.memoryProvider;
-                nextBrain.storeSchema = this.storeSchema;
                 return nextBrain;
             }
         },
         {
             /**
-   * Configure UI components for generative UI steps.
+   * Configure UI components for page generation steps.
    *
    * @param components - Record of component definitions
    *
@@ -480,102 +558,18 @@ export var Brain = /*#__PURE__*/ function() {
    *
    * const myBrain = brain('my-brain')
    *   .withComponents(components)
-   *   .ui('Show Form', formPrompt);
+   *   .page('Show Form', ({ state }) => ({ prompt: `Create a form for ${state.userName}` }));
    * ```
    */ key: "withComponents",
             value: function withComponents(components) {
                 var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                nextBrain.optionsSchema = this.optionsSchema;
-                nextBrain.services = this.services;
+                this.copyConfigTo(nextBrain);
                 nextBrain.components = components;
-                nextBrain.defaultTools = this.defaultTools;
-                nextBrain.extraTools = this.extraTools;
-                nextBrain.memoryProvider = this.memoryProvider;
-                nextBrain.storeSchema = this.storeSchema;
                 return nextBrain;
             }
         },
         {
             /**
-   * Configure default tools for agent steps.
-   * These tools will be automatically available in all agent steps and can be
-   * extended or overridden in individual step configurations.
-   *
-   * @param tools - Record of default tool definitions
-   *
-   * @example
-   * ```typescript
-   * import { defaultTools } from '@positronic/core';
-   *
-   * const myBrain = brain('my-brain')
-   *   .withTools(defaultTools)
-   *   .brain('agent', ({ tools }) => ({
-   *     system: 'You are helpful',
-   *     prompt: 'Do something',
-   *     tools  // uses defaults
-   *   }));
-   * ```
-   */ key: "withTools",
-            value: function withTools(tools) {
-                var next = this.nextBrain();
-                next.defaultTools = tools;
-                return next;
-            }
-        },
-        {
-            /**
-   * Add extra tools on top of whatever default tools are already configured.
-   * Unlike `withTools()` which replaces defaults, this merges additively.
-   *
-   * @param tools - Record of additional tool definitions
-   *
-   * @example
-   * ```typescript
-   * const myBrain = createBrain({ defaultTools })
-   *   ('my-brain')
-   *   .withExtraTools({ myCustomTool })
-   *   .brain('agent', ({ tools }) => ({
-   *     system: 'You are helpful',
-   *     prompt: 'Do something',
-   *     tools  // includes both defaults and myCustomTool
-   *   }));
-   * ```
-   */ key: "withExtraTools",
-            value: function withExtraTools(tools) {
-                var next = this.nextBrain();
-                next.extraTools = tools;
-                return next;
-            }
-        },
-        {
-            /**
-   * Configure a memory provider for this brain.
-   * When configured, steps receive a scoped memory instance in their context.
-   *
-   * @param provider - The memory provider to use
-   *
-   * @example
-   * ```typescript
-   * import { createMem0Provider } from '@positronic/mem0';
-   *
-   * const memory = createMem0Provider({ apiKey: process.env.MEM0_API_KEY });
-   *
-   * const myBrain = brain('my-brain')
-   *   .withMemory(memory)
-   *   .brain('agent', async ({ memory }) => {
-   *     const prefs = await memory.search('user preferences');
-   *     return { system: `User preferences: ${prefs}`, prompt: 'Help me' };
-   *   });
-   * ```
-   */ key: "withMemory",
-            value: function withMemory(provider) {
-                var next = this.nextBrain();
-                next.memoryProvider = provider;
-                return next;
-            }
-        },
-        {
-            /**
    * Configure a typed key-value store for this brain.
    * When configured, steps receive a `store` object in their context with typed get/set/delete/has.
    *
@@ -598,16 +592,29 @@ export var Brain = /*#__PURE__*/ function() {
    */ key: "withStore",
             value: function withStore(storeSchema) {
                 var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                nextBrain.optionsSchema = this.optionsSchema;
-                nextBrain.services = this.services;
-                nextBrain.components = this.components;
-                nextBrain.defaultTools = this.defaultTools;
-                nextBrain.extraTools = this.extraTools;
-                nextBrain.memoryProvider = this.memoryProvider;
+                this.copyConfigTo(nextBrain);
                 nextBrain.storeSchema = storeSchema;
                 return nextBrain;
             }
         },
+        {
+            /**
+   * Add a plugin to this brain. The plugin's create() is called per brain run,
+   * and its return value is placed on StepContext under the plugin name.
+   *
+   * Replaces any existing plugin with the same name.
+   */ key: "withPlugin",
+            value: function withPlugin(plugin) {
+                var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
+                this.copyConfigTo(nextBrain);
+                nextBrain.pluginConfigs = _to_consumable_array(this.pluginConfigs.filter(function(p) {
+                    return p.__plugin.name !== plugin.__plugin.name;
+                })).concat([
+                    plugin
+                ]);
+                return nextBrain;
+            }
+        },
         {
             key: "step",
             value: function step(title, action) {
@@ -631,7 +638,7 @@ export var Brain = /*#__PURE__*/ function() {
                     timeout: parseDuration(options.timeout)
                 });
                 this.blocks.push(waitBlock);
-                return this.nextBrain();
+                return this.continuationCallbacks();
             }
         },
         {
@@ -647,264 +654,65 @@ export var Brain = /*#__PURE__*/ function() {
             }
         },
         {
-            // Implementation
+            // Nested brain — spreads inner brain's final state onto outer state
             key: "brain",
-            value: function brain(title, innerBrainOrConfig, actionOrIterateConfig, initialState) {
-                // Detect iterate config: 3rd arg is an object with `over` property
-                var isIterateConfig = actionOrIterateConfig && (typeof actionOrIterateConfig === "undefined" ? "undefined" : _type_of(actionOrIterateConfig)) === 'object' && 'over' in actionOrIterateConfig;
-                // Case 1: Nested brain instance
-                if (innerBrainOrConfig && (typeof innerBrainOrConfig === "undefined" ? "undefined" : _type_of(innerBrainOrConfig)) === 'object' && 'type' in innerBrainOrConfig && innerBrainOrConfig.type === 'brain') {
-                    if (isIterateConfig) {
-                        // Case 1b: Nested brain with iterate
-                        var iterateConfig = actionOrIterateConfig;
-                        var nestedBlock = {
-                            type: 'brain',
-                            title: title,
-                            innerBrain: innerBrainOrConfig,
-                            initialState: function() {
-                                return {};
-                            },
-                            action: function() {
-                                return {};
-                            },
-                            iterateConfig: iterateConfig
-                        };
-                        this.blocks.push(nestedBlock);
-                        return this.nextBrain();
-                    }
-                    // Case 1a: Single nested brain (existing behavior)
-                    var action = actionOrIterateConfig;
-                    var nestedBlock1 = {
-                        type: 'brain',
-                        title: title,
-                        innerBrain: innerBrainOrConfig,
-                        initialState: initialState || function() {
-                            return {};
-                        },
-                        action: function(outerState, innerState, services) {
-                            return action({
-                                state: outerState,
-                                brainState: innerState,
-                                services: services
-                            });
-                        }
-                    };
-                    this.blocks.push(nestedBlock1);
-                    return this.nextBrain();
-                }
-                // Case 2 & 3: Agent config (object or function)
-                if (isIterateConfig) {
-                    // Agent config with iterate — configFn receives (item, params)
-                    var iterateConfig1 = actionOrIterateConfig;
-                    var configFn = innerBrainOrConfig;
-                    var agentBlock = {
-                        type: 'agent',
-                        title: title,
-                        configFn: configFn,
-                        iterateConfig: iterateConfig1
-                    };
-                    this.blocks.push(agentBlock);
-                    return this.nextBrain();
-                }
-                var configFn1 = typeof innerBrainOrConfig === 'function' ? innerBrainOrConfig : function() {
-                    return innerBrainOrConfig;
+            value: function brain(title, innerBrain, config) {
+                var nestedConfig = config !== null && config !== void 0 ? config : {};
+                var nestedBlock = {
+                    type: 'brain',
+                    title: title,
+                    innerBrain: innerBrain,
+                    initialState: nestedConfig.initialState,
+                    options: nestedConfig.options
                 };
-                var agentBlock1 = {
-                    type: 'agent',
+                this.blocks.push(nestedBlock);
+                return this.nextBrain();
+            }
+        },
+        {
+            key: "prompt",
+            value: function prompt(title, configFn) {
+                var promptBlock = {
+                    type: 'prompt',
                     title: title,
-                    configFn: configFn1
+                    configFn: configFn
                 };
-                this.blocks.push(agentBlock1);
+                this.blocks.push(promptBlock);
                 return this.nextBrain();
             }
         },
         {
             // Implementation
-            key: "prompt",
-            value: function prompt(title, config, iterateConfig) {
-                // Schema-less prompt - returns text response for next step
-                if (!config.outputSchema) {
-                    var textSchema = z.object({
-                        text: z.string()
-                    });
-                    var promptBlock = {
-                        type: 'step',
-                        title: title,
-                        client: config.client,
-                        action: function(param) {
-                            var state = param.state, client = param.client, resources = param.resources;
-                            return _async_to_generator(function() {
-                                var prompt, result;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            return [
-                                                4,
-                                                config.template(state, resources)
-                                            ];
-                                        case 1:
-                                            prompt = _state.sent();
-                                            return [
-                                                4,
-                                                client.generateObject({
-                                                    schema: textSchema,
-                                                    schemaName: 'TextResponse',
-                                                    prompt: prompt
-                                                })
-                                            ];
-                                        case 2:
-                                            result = _state.sent();
-                                            return [
-                                                2,
-                                                {
-                                                    state: state,
-                                                    promptResponse: result.object
-                                                }
-                                            ];
-                                    }
-                                });
-                            })();
-                        }
-                    };
-                    this.blocks.push(promptBlock);
-                    return this.nextBrain();
-                }
-                // At this point, outputSchema is guaranteed to exist (schema-less case returned early)
-                var outputSchema = config.outputSchema;
-                if (iterateConfig) {
-                    // Iterate mode - store config on block for event-stream to execute with per-item events
-                    var promptBlock1 = {
-                        type: 'step',
-                        title: title,
-                        action: function(param) {
-                            var state = param.state;
-                            return _async_to_generator(function() {
-                                return _ts_generator(this, function(_state) {
-                                    return [
-                                        2,
-                                        state
-                                    ];
-                                });
-                            })();
-                        },
-                        iterateConfig: {
-                            over: iterateConfig.over,
-                            error: iterateConfig.error,
-                            template: config.template,
-                            schema: outputSchema.schema,
-                            schemaName: outputSchema.name,
-                            client: config.client
-                        }
-                    };
-                    this.blocks.push(promptBlock1);
-                    return this.nextBrain();
-                } else {
-                    // Single mode - run prompt once with current state
-                    var promptBlock2 = {
-                        type: 'step',
-                        title: title,
-                        client: config.client,
-                        action: function(param) {
-                            var state = param.state, client = param.client, resources = param.resources;
-                            return _async_to_generator(function() {
-                                var schema, schemaName, prompt, result;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            schema = outputSchema.schema, schemaName = outputSchema.name;
-                                            return [
-                                                4,
-                                                config.template(state, resources)
-                                            ];
-                                        case 1:
-                                            prompt = _state.sent();
-                                            return [
-                                                4,
-                                                client.generateObject({
-                                                    schema: schema,
-                                                    schemaName: schemaName,
-                                                    prompt: prompt
-                                                })
-                                            ];
-                                        case 2:
-                                            result = _state.sent();
-                                            return [
-                                                2,
-                                                _object_spread_props(_object_spread({}, state), _define_property({}, outputSchema.name, result.object))
-                                            ];
-                                    }
-                                });
-                            })();
-                        }
-                    };
-                    this.blocks.push(promptBlock2);
-                    return this.nextBrain();
-                }
+            key: "map",
+            value: function map(title, stateKey, configFn) {
+                var mapBlock = {
+                    type: 'map',
+                    title: title,
+                    stateKey: stateKey,
+                    configFn: configFn
+                };
+                this.blocks.push(mapBlock);
+                return this.nextBrain();
             }
         },
         {
-            /**
-   * Add a UI generation step that creates an interactive page.
-   *
-   * The step:
-   * 1. Calls an LLM agent to generate UI components based on the prompt
-   * 2. Renders the components to an HTML page
-   * 3. Stores the page and makes it available via URL
-   * 4. Creates a webhook for form submissions (typed based on responseSchema)
-   *
-   * The next step receives a `page` object with:
-   * - `url`: URL to the generated page
-   * - `webhook`: Pre-configured WebhookRegistration for form submissions
-   *
-   * The brain author is responsible for notifying users about the page (via Slack,
-   * email, etc.) and using `.wait()` to pause until the form is submitted.
-   * Form data arrives in the `response` parameter of the step after `.wait()`.
-   *
-   * @example
-   * ```typescript
-   * brain('feedback-form')
-   *   .step('Initialize', () => ({ userName: 'John' }))
-   *   .ui('Create Form', {
-   *     template: (state) => `Create a feedback form for ${state.userName}`,
-   *     responseSchema: z.object({
-   *       rating: z.number().min(1).max(5),
-   *       comments: z.string(),
-   *     }),
-   *   })
-   *   .step('Notify', async ({ state, page, slack }) => {
-   *     await slack.post('#general', `Please fill out: ${page.url}`);
-   *     return state;
-   *   })
-   *   .wait('Wait for submission', ({ page }) => page.webhook)
-   *   .step('Process Feedback', ({ state, response }) => ({
-   *     ...state,
-   *     // response is typed: { rating: number, comments: string }
-   *     rating: response.rating,
-   *     comments: response.comments,
-   *   }))
-   * ```
-   */ key: "ui",
-            value: function ui(title, config) {
-                var uiBlock = {
+            // Implementation
+            key: "page",
+            value: function page(title, configFn) {
+                var pageBlock = {
                     type: 'step',
                     title: title,
-                    isUIStep: true,
-                    uiConfig: {
-                        template: config.template,
-                        responseSchema: config.responseSchema
-                    },
-                    action: function(params) {
+                    isPageStep: true,
+                    pageConfigFn: configFn,
+                    action: function() {
                         return _async_to_generator(function() {
                             return _ts_generator(this, function(_state) {
-                                // The actual UI generation is handled by BrainRunner/BrainEventStream
-                                // This action is a placeholder that gets replaced during execution
-                                // when the runner detects `isUIStep: true` and has components configured
-                                throw new Error('UI step "'.concat(title, '" requires components to be configured via BrainRunner.withComponents(). ') + "The UI generation is handled by the runner, not the step action directly.");
+                                throw new Error('Page step "'.concat(title, '" requires components to be configured via brain.withComponents(). ') + "Page generation is handled by the runner, not the step action directly.");
                             });
                         })();
                     }
                 };
-                this.blocks.push(uiBlock);
+                this.blocks.push(pageBlock);
                 return this.nextBrain();
             }
         },
@@ -913,17 +721,25 @@ export var Brain = /*#__PURE__*/ function() {
             value: // Implementation signature
             function run(params) {
                 return _wrap_async_generator(function() {
-                    var _this, title, description, blocks, store, stream;
+                    var _this, title, description, blocks, _params_brainRunId, brainRunId, files, pages, store, _params_pluginConfigs, _resolvePlugins, pluginInjections, pluginAdapters, mergedPluginConfigs, stream;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 _this = this, title = _this.title, description = _this.description, blocks = _this.blocks;
-                                // Build store if withStore() was called and a store provider is given
+                                brainRunId = 'resume' in params && params.resume ? params.brainRunId : (_params_brainRunId = params.brainRunId) !== null && _params_brainRunId !== void 0 ? _params_brainRunId : '';
+                                // Platform services
+                                files = params.files;
+                                pages = params.pages;
                                 store = this.storeSchema && params.storeProvider ? params.storeProvider({
-                                    schema: this.storeSchema,
-                                    brainTitle: this.title,
-                                    currentUser: params.currentUser
+                                    brainTitle: title,
+                                    currentUser: params.currentUser,
+                                    schema: this.storeSchema
                                 }) : undefined;
+                                _resolvePlugins = resolvePlugins((_params_pluginConfigs = params.pluginConfigs) !== null && _params_pluginConfigs !== void 0 ? _params_pluginConfigs : [], this.pluginConfigs, {
+                                    brainTitle: title,
+                                    currentUser: params.currentUser,
+                                    brainRunId: brainRunId
+                                }), pluginInjections = _resolvePlugins.injections, pluginAdapters = _resolvePlugins.adapters, mergedPluginConfigs = _resolvePlugins.configs;
                                 stream = new BrainEventStream(_object_spread_props(_object_spread({
                                     title: title,
                                     description: description,
@@ -931,12 +747,13 @@ export var Brain = /*#__PURE__*/ function() {
                                 }, params), {
                                     options: params.options || {},
                                     optionsSchema: this.optionsSchema,
-                                    services: this.services,
                                     components: this.components,
-                                    defaultTools: this.defaultTools,
-                                    extraTools: this.extraTools,
-                                    memoryProvider: this.memoryProvider,
-                                    store: store
+                                    files: files,
+                                    pages: pages,
+                                    store: store,
+                                    pluginInjections: pluginInjections,
+                                    pluginAdapters: pluginAdapters,
+                                    pluginConfigs: mergedPluginConfigs
                                 }));
                                 return [
                                     5,
@@ -959,27 +776,36 @@ export var Brain = /*#__PURE__*/ function() {
                 return this;
             }
         },
+        {
+            key: "copyConfigTo",
+            value: function copyConfigTo(target) {
+                target.optionsSchema = this.optionsSchema;
+                target.components = this.components;
+                target.storeSchema = this.storeSchema;
+                target.pluginConfigs = this.pluginConfigs;
+            }
+        },
         {
             key: "nextBrain",
             value: function nextBrain() {
-                // Pass default options to the next brain
                 var nextBrain = new Brain(this.title, this.description).withBlocks(this.blocks);
-                // Copy services to the next brain
-                nextBrain.services = this.services;
-                // Copy optionsSchema to the next brain
-                nextBrain.optionsSchema = this.optionsSchema;
-                // Copy components to the next brain
-                nextBrain.components = this.components;
-                // Copy defaultTools to the next brain
-                nextBrain.defaultTools = this.defaultTools;
-                // Copy extraTools to the next brain
-                nextBrain.extraTools = this.extraTools;
-                // Copy memoryProvider to the next brain
-                nextBrain.memoryProvider = this.memoryProvider;
-                // Copy store schema to the next brain
-                nextBrain.storeSchema = this.storeSchema;
+                this.copyConfigTo(nextBrain);
                 return nextBrain;
             }
+        },
+        {
+            key: "continuationCallbacks",
+            value: function continuationCallbacks() {
+                var blocks = this.blocks;
+                var self = this;
+                return new Continuation(function(block) {
+                    return blocks.push(block);
+                }, function() {
+                    var next = new Brain(self.title, self.description).withBlocks(blocks);
+                    self.copyConfigTo(next);
+                    return next;
+                });
+            }
         }
     ]);
     return Brain;
@@ -997,14 +823,34 @@ var brainNames = new Set();
     }
 }
 // Implementation
-export function brain(titleOrConfig, agentConfig) {
-    var title = typeof titleOrConfig === 'string' ? titleOrConfig : titleOrConfig.title;
-    var description = typeof titleOrConfig === 'string' ? undefined : titleOrConfig.description;
+export function brain(titleOrConfig) {
+    var isString = typeof titleOrConfig === 'string';
+    var title = isString ? titleOrConfig : titleOrConfig.title;
+    var description = isString ? undefined : titleOrConfig.description;
+    var plugins = isString ? undefined : titleOrConfig.plugins;
     registerBrainName(title);
-    var newBrain = new Brain(title, description);
-    // If agentConfig is provided, create a brain with a single 'main' agent step
-    if (agentConfig !== undefined) {
-        return newBrain.brain('main', agentConfig);
+    var b = new Brain(title, description);
+    if (plugins) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.values(plugins)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var plugin = _step.value;
+                b = b.withPlugin(plugin);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
     }
-    return newBrain;
+    return b;
 }