@positronic/core 0.0.1 → 0.0.2

package/dist/src/dsl/brain-runner.test.js

@@ -0,0 +1,733 @@
+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 _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;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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 { BrainRunner } from './brain-runner.js';
+import { brain } from './brain.js';
+import { BRAIN_EVENTS, STATUS } from './constants.js';
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import { createResources } from '../resources/resources.js';
+import { z } from 'zod';
+describe('BrainRunner', function() {
+    var mockGenerateObject = jest.fn();
+    var mockClient = {
+        generateObject: mockGenerateObject
+    };
+    var mockDispatch = jest.fn();
+    var mockAdapter = {
+        dispatch: mockDispatch
+    };
+    beforeEach(function() {
+        jest.clearAllMocks();
+    });
+    it('should run a brain and dispatch events to adapters', function() {
+        return _async_to_generator(function() {
+            var runner, testBrain, stepCompletions;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        runner = new BrainRunner({
+                            adapters: [
+                                mockAdapter
+                            ],
+                            client: mockClient
+                        });
+                        testBrain = brain('Test Brain').step('First Step', function() {
+                            return {
+                                value: 42
+                            };
+                        }).step('Async Step', function(param) {
+                            var state = param.state;
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                new Promise(function(resolve) {
+                                                    return setTimeout(resolve, 10);
+                                                })
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                2,
+                                                _object_spread_props(_object_spread({}, state), {
+                                                    asyncValue: 'completed'
+                                                })
+                                            ];
+                                    }
+                                });
+                            })();
+                        }).step('Final Step', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                finalValue: state.value * 2
+                            });
+                        });
+                        return [
+                            4,
+                            runner.run(testBrain)
+                        ];
+                    case 1:
+                        _state.sent();
+                        // Verify adapter received all events in correct order
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.START,
+                            brainTitle: 'Test Brain'
+                        }));
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.STEP_COMPLETE,
+                            stepTitle: 'First Step'
+                        }));
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.STEP_COMPLETE,
+                            stepTitle: 'Async Step'
+                        }));
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.STEP_COMPLETE,
+                            stepTitle: 'Final Step'
+                        }));
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.COMPLETE,
+                            status: STATUS.COMPLETE
+                        }));
+                        // Verify the order of events
+                        stepCompletions = mockAdapter.dispatch.mock.calls.filter(function(call) {
+                            return call[0].type === BRAIN_EVENTS.STEP_COMPLETE;
+                        }).map(function(call) {
+                            return call[0].stepTitle;
+                        });
+                        expect(stepCompletions).toEqual([
+                            'First Step',
+                            'Async Step',
+                            'Final Step'
+                        ]);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should handle brain errors', function() {
+        return _async_to_generator(function() {
+            var runner, errorBrain, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        runner = new BrainRunner({
+                            adapters: [
+                                mockAdapter
+                            ],
+                            client: mockClient
+                        });
+                        errorBrain = brain('Error Brain').step('Error Step', function() {
+                            throw new Error('Test error');
+                        });
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            runner.run(errorBrain)
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        error = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 4:
+                        // Verify error event was dispatched
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.ERROR,
+                            error: expect.objectContaining({
+                                message: 'Test error'
+                            })
+                        }));
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should maintain state between steps', function() {
+        return _async_to_generator(function() {
+            var runner, testBrain, result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        runner = new BrainRunner({
+                            adapters: [],
+                            client: mockClient
+                        });
+                        testBrain = brain('Test Brain').step('First Step', function() {
+                            return {
+                                count: 1
+                            };
+                        }).step('Second Step', function(param) {
+                            var state = param.state;
+                            return {
+                                count: state.count + 1
+                            };
+                        });
+                        return [
+                            4,
+                            runner.run(testBrain)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        expect(result.count).toEqual(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should pass resources to step actions', function() {
+        return _async_to_generator(function() {
+            var mockLoad, mockResourceLoader, testManifest, testResources, runner, textContent, binaryContent, resourceConsumingBrain;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        mockLoad = jest.fn(function(resourceName, type) {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    if (type === 'binary') {
+                                        return [
+                                            2,
+                                            Buffer.from("content of ".concat(resourceName))
+                                        ];
+                                    }
+                                    return [
+                                        2,
+                                        "content of ".concat(resourceName)
+                                    ];
+                                });
+                            })();
+                        });
+                        mockResourceLoader = {
+                            load: mockLoad
+                        };
+                        testManifest = {
+                            myTextFile: {
+                                type: 'text',
+                                key: 'myTextFile',
+                                path: '/test/myTextFile.txt'
+                            },
+                            myBinaryFile: {
+                                type: 'binary',
+                                key: 'myBinaryFile',
+                                path: '/test/myBinaryFile.bin'
+                            }
+                        };
+                        testResources = createResources(mockResourceLoader, testManifest);
+                        runner = new BrainRunner({
+                            adapters: [],
+                            client: mockClient
+                        }).withResources(testResources);
+                        resourceConsumingBrain = brain('Resource Brain').step('Load Resources', function(param) {
+                            var resources = param.resources;
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                resources.myTextFile.loadText()
+                                            ];
+                                        case 1:
+                                            textContent = _state.sent();
+                                            return [
+                                                4,
+                                                resources.myBinaryFile.loadBinary()
+                                            ];
+                                        case 2:
+                                            binaryContent = _state.sent();
+                                            return [
+                                                2,
+                                                {}
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        return [
+                            4,
+                            runner.run(resourceConsumingBrain)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(mockLoad).toHaveBeenCalledWith('myTextFile', 'text');
+                        expect(mockLoad).toHaveBeenCalledWith('myBinaryFile', 'binary');
+                        expect(textContent).toBe('content of myTextFile');
+                        expect(binaryContent === null || binaryContent === void 0 ? void 0 : binaryContent.toString()).toBe('content of myBinaryFile');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should chain adapters with withAdapters method', function() {
+        return _async_to_generator(function() {
+            var mockAdapter2, mockAdapter3, runner, updatedRunner, testBrain;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        mockAdapter2 = {
+                            dispatch: jest.fn()
+                        };
+                        mockAdapter3 = {
+                            dispatch: jest.fn()
+                        };
+                        runner = new BrainRunner({
+                            adapters: [
+                                mockAdapter
+                            ],
+                            client: mockClient
+                        });
+                        // Chain additional adapters
+                        updatedRunner = runner.withAdapters([
+                            mockAdapter2,
+                            mockAdapter3
+                        ]);
+                        testBrain = brain('Test Brain').step('Step 1', function() {
+                            return {
+                                value: 1
+                            };
+                        });
+                        return [
+                            4,
+                            updatedRunner.run(testBrain)
+                        ];
+                    case 1:
+                        _state.sent();
+                        // Verify all adapters received events
+                        expect(mockAdapter.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.START
+                        }));
+                        expect(mockAdapter2.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.START
+                        }));
+                        expect(mockAdapter3.dispatch).toHaveBeenCalledWith(expect.objectContaining({
+                            type: BRAIN_EVENTS.START
+                        }));
+                        // Verify all adapters received the same number of events
+                        expect(mockAdapter.dispatch).toHaveBeenCalledTimes(mockAdapter2.dispatch.mock.calls.length);
+                        expect(mockAdapter2.dispatch).toHaveBeenCalledTimes(mockAdapter3.dispatch.mock.calls.length);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should replace client with withClient method', function() {
+        return _async_to_generator(function() {
+            var originalClient, newClient, runner, updatedRunner, testSchema, testBrain, result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        originalClient = {
+                            generateObject: jest.fn()
+                        };
+                        newClient = {
+                            generateObject: jest.fn()
+                        };
+                        // Configure the new client's response
+                        newClient.generateObject.mockResolvedValue({
+                            result: 'from new client'
+                        });
+                        runner = new BrainRunner({
+                            adapters: [],
+                            client: originalClient
+                        });
+                        // Replace the client
+                        updatedRunner = runner.withClient(newClient);
+                        // Define schema once to ensure same reference
+                        testSchema = z.object({
+                            result: z.string()
+                        });
+                        testBrain = brain('Test Brain').step('Generate', function(param) {
+                            var client = param.client;
+                            return _async_to_generator(function() {
+                                var response;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                client.generateObject({
+                                                    prompt: 'test prompt',
+                                                    schema: testSchema,
+                                                    schemaName: 'TestSchema'
+                                                })
+                                            ];
+                                        case 1:
+                                            response = _state.sent();
+                                            return [
+                                                2,
+                                                {
+                                                    generated: response.result
+                                                }
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                        return [
+                            4,
+                            updatedRunner.run(testBrain)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        // Verify new client was used, not the original
+                        expect(originalClient.generateObject).not.toHaveBeenCalled();
+                        expect(newClient.generateObject).toHaveBeenCalledWith({
+                            prompt: 'test prompt',
+                            schema: testSchema,
+                            schemaName: 'TestSchema'
+                        });
+                        expect(result.generated).toBe('from new client');
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should apply patches from initialCompletedSteps and continue from correct state', function() {
+        return _async_to_generator(function() {
+            var runner, completedSteps, testBrain, result, stepCompleteEvents;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        runner = new BrainRunner({
+                            adapters: [
+                                mockAdapter
+                            ],
+                            client: mockClient
+                        });
+                        // Simulate completed steps with patches
+                        completedSteps = [
+                            {
+                                id: 'step-1',
+                                title: 'First Step',
+                                status: STATUS.COMPLETE,
+                                patch: [
+                                    {
+                                        op: 'add',
+                                        path: '/count',
+                                        value: 10
+                                    }
+                                ]
+                            },
+                            {
+                                id: 'step-2',
+                                title: 'Second Step',
+                                status: STATUS.COMPLETE,
+                                patch: [
+                                    {
+                                        op: 'add',
+                                        path: '/name',
+                                        value: 'test'
+                                    }
+                                ]
+                            }
+                        ];
+                        testBrain = brain('Test Brain').step('First Step', function() {
+                            return {
+                                count: 10
+                            };
+                        }).step('Second Step', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                name: 'test'
+                            });
+                        }).step('Third Step', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                count: state.count + 5,
+                                message: "".concat(state.name, " completed")
+                            });
+                        });
+                        return [
+                            4,
+                            runner.run(testBrain, {
+                                initialCompletedSteps: completedSteps,
+                                brainRunId: 'test-run-123'
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        // Verify the final state includes patches from completed steps
+                        expect(result).toEqual({
+                            count: 15,
+                            name: 'test',
+                            message: 'test completed'
+                        });
+                        // Verify that the brain runner applied the patches correctly
+                        // The runner should have seen all steps execute, but the first two were already completed
+                        stepCompleteEvents = mockAdapter.dispatch.mock.calls.filter(function(call) {
+                            return call[0].type === BRAIN_EVENTS.STEP_COMPLETE;
+                        });
+                        // All steps will emit complete events in the current implementation
+                        expect(stepCompleteEvents.length).toBeGreaterThanOrEqual(1);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should stop execution after specified number of steps with endAfter parameter', function() {
+        return _async_to_generator(function() {
+            var runner, testBrain, result, stepCompleteEvents, completeEvents;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        runner = new BrainRunner({
+                            adapters: [
+                                mockAdapter
+                            ],
+                            client: mockClient
+                        });
+                        testBrain = brain('Test Brain').step('Step 1', function() {
+                            return {
+                                step1: 'done'
+                            };
+                        }).step('Step 2', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                step2: 'done'
+                            });
+                        }).step('Step 3', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                step3: 'done'
+                            });
+                        }).step('Step 4', function(param) {
+                            var state = param.state;
+                            return _object_spread_props(_object_spread({}, state), {
+                                step4: 'done'
+                            });
+                        });
+                        return [
+                            4,
+                            runner.run(testBrain, {
+                                endAfter: 2
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        // Verify state only has results from first 2 steps
+                        expect(result).toEqual({
+                            step1: 'done',
+                            step2: 'done'
+                        });
+                        // Verify only 2 step complete events were dispatched
+                        stepCompleteEvents = mockAdapter.dispatch.mock.calls.filter(function(call) {
+                            return call[0].type === BRAIN_EVENTS.STEP_COMPLETE;
+                        }).map(function(call) {
+                            return call[0].stepTitle;
+                        });
+                        expect(stepCompleteEvents).toEqual([
+                            'Step 1',
+                            'Step 2'
+                        ]);
+                        // Verify that COMPLETE event was NOT dispatched (brain didn't finish)
+                        completeEvents = mockAdapter.dispatch.mock.calls.filter(function(call) {
+                            return call[0].type === BRAIN_EVENTS.COMPLETE;
+                        });
+                        expect(completeEvents.length).toBe(0);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});