@positronic/core 0.0.3 → 0.0.4

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

@@ -1,733 +0,0 @@
-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
-                        ];
-                }
-            });
-        })();
-    });
-});