@olane/os 0.7.12-alpha.59 → 0.7.12-alpha.60

package/dist/test/capabilities/multiple-step-capability.spec.js

@@ -0,0 +1,441 @@
+import { expect } from 'chai';
+import { oCapabilityMultipleStep, oCapabilityType } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig, createMockIntent } from './utils/capability-test-utils.js';
+describe('oCapabilityMultipleStep @capability @multiple-step', () => {
+    let os;
+    let laneTool;
+    let multiStepCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        multiStepCapability = new oCapabilityMultipleStep();
+    });
+    describe('type identification', () => {
+        it('should return MULTIPLE_STEP type from instance getter', () => {
+            expect(multiStepCapability.type).to.equal(oCapabilityType.MULTIPLE_STEP);
+        });
+        it('should return MULTIPLE_STEP type from static getter', () => {
+            expect(oCapabilityMultipleStep.type).to.equal(oCapabilityType.MULTIPLE_STEP);
+        });
+    });
+    describe('inheritance', () => {
+        it('should extend oCapabilityIntelligence', async () => {
+            expect(multiStepCapability).to.respondTo('intelligence');
+        });
+        it('should have access to intelligence method', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Test explanation'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.intelligence).to.be.a('function');
+        });
+    });
+    describe('configuration getters', () => {
+        it('should provide access to intents array', async () => {
+            const intents = [
+                createMockIntent('First step', {}),
+                createMockIntent('Second step', {}),
+                createMockIntent('Third step', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Multi-step process'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.intents).to.deep.equal(intents);
+            expect(multiStepCapability.intents.length).to.equal(3);
+        });
+        it('should provide access to explanation', async () => {
+            const explanation = 'This explains why we need multiple steps';
+            const params = {
+                intents: [],
+                explanation
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.explanation).to.equal(explanation);
+        });
+        it('should handle empty intents array', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Empty intents test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.intents).to.be.an('array');
+            expect(multiStepCapability.intents.length).to.equal(0);
+        });
+    });
+    describe('run() method - intent execution', () => {
+        it('should handle empty intents array', async () => {
+            const params = {
+                intents: [],
+                explanation: 'No intents to execute'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            const result = await multiStepCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should handle single intent', async () => {
+            const intents = [
+                createMockIntent('Single step', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Single step execution'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            // May fail if services not available, but tests structure
+            try {
+                const result = await multiStepCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if sub-lane services unavailable
+            }
+        });
+        it('should handle multiple intents', async () => {
+            const intents = [
+                createMockIntent('Step one', {}),
+                createMockIntent('Step two', {}),
+                createMockIntent('Step three', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Three step process'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            // May fail if services not available, but tests structure
+            try {
+                const result = await multiStepCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if sub-lane services unavailable
+            }
+        });
+        it('should execute intents sequentially', async () => {
+            const intents = [
+                createMockIntent('First', {}),
+                createMockIntent('Second', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Sequential execution'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // If successful, intents were executed in order
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+    });
+    describe('sub-lane management', () => {
+        it('should create sub-lanes for each intent', async () => {
+            const intents = [
+                createMockIntent('Step 1', {}),
+                createMockIntent('Step 2', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Sub-lane creation test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // Sub-lanes are created and cleaned up during execution
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should clean up sub-lanes after execution', async () => {
+            const intents = [
+                createMockIntent('Step 1', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Sub-lane cleanup test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // Sub-lanes should be removed from the map after execution
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should pass lane config to sub-lanes', async () => {
+            const intents = [
+                createMockIntent('Step with config', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Config propagation test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            config.laneConfig.maxCycles = 15;
+            try {
+                await multiStepCapability.execute(config);
+                expect(config.laneConfig.maxCycles).to.equal(15);
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should preserve parent lane ID', async () => {
+            const intents = [
+                createMockIntent('Child step', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Parent lane ID test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            config.parentLaneId = 'parent-lane-123';
+            try {
+                await multiStepCapability.execute(config);
+                expect(config.parentLaneId).to.equal('parent-lane-123');
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+    });
+    describe('cancellation', () => {
+        it('should support cancellation', () => {
+            multiStepCapability.cancel();
+            // Should not throw - validates cancel method exists
+        });
+        it('should cancel all active sub-lanes', async () => {
+            const intents = [
+                createMockIntent('Step 1', {}),
+                createMockIntent('Step 2', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Cancellation test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            // Start execution in background (conceptually)
+            const executionPromise = multiStepCapability.execute(config);
+            // Cancel immediately
+            multiStepCapability.cancel();
+            try {
+                await executionPromise;
+            }
+            catch (error) {
+                // May error during cancellation
+            }
+        });
+        it('should handle cancel when no sub-lanes active', () => {
+            multiStepCapability.cancel();
+            // Should not throw even with no active sub-lanes
+        });
+    });
+    describe('result structure', () => {
+        it('should return capability result', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Result structure test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            const result = await multiStepCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should include results array', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Results array test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            const result = await multiStepCapability.execute(config);
+            expect(result.result).to.be.an('array');
+            expect(result.humanResult).to.be.an('array');
+        });
+        it('should set type to EVALUATE in result', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Type test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            const result = await multiStepCapability.execute(config);
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should aggregate results from all intents', async () => {
+            const intents = [
+                createMockIntent('Step 1', {}),
+                createMockIntent('Step 2', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Result aggregation test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                const result = await multiStepCapability.execute(config);
+                expect(result.result).to.be.an('array');
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+    });
+    describe('intent handling', () => {
+        it('should handle intents with parameters', async () => {
+            const intents = [
+                createMockIntent('Step with params', { key1: 'value1', key2: 123 })
+            ];
+            const params = {
+                intents,
+                explanation: 'Intent params test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // Params are stored in the config, not on the intent object
+                expect(multiStepCapability.config.params.intents[0]).to.exist;
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should handle intents with complex parameters', async () => {
+            const intents = [
+                createMockIntent('Complex intent', {
+                    nested: { object: { structure: 'value' } },
+                    array: [1, 2, 3],
+                    boolean: true
+                })
+            ];
+            const params = {
+                intents,
+                explanation: 'Complex params test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // Check that intents exist
+                expect(multiStepCapability.intents[0]).to.exist;
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should handle long intent strings', async () => {
+            const longIntentText = 'This is a very long intent that describes a complex multi-step process. '.repeat(10);
+            const intents = [
+                createMockIntent(longIntentText, {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Long intent test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                expect(multiStepCapability.intents[0].value).to.equal(longIntentText);
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+        it('should handle intents with special characters', async () => {
+            const intents = [
+                createMockIntent('Intent with "quotes" and \'apostrophes\'', {}),
+                createMockIntent('Intent with special chars: !@#$%^&*()', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Special chars test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                expect(multiStepCapability.intents.length).to.equal(2);
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should handle sub-lane execution errors', async () => {
+            const intents = [
+                createMockIntent('Step that might fail', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Error handling test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                const result = await multiStepCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if services unavailable
+                expect(error).to.exist;
+            }
+        });
+        it('should continue execution after sub-lane error', async () => {
+            const intents = [
+                createMockIntent('First step', {}),
+                createMockIntent('Second step (might fail)', {}),
+                createMockIntent('Third step', {})
+            ];
+            const params = {
+                intents,
+                explanation: 'Continue after error test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            try {
+                await multiStepCapability.execute(config);
+                // Should attempt all steps even if some fail
+            }
+            catch (error) {
+                // Expected if services unavailable
+            }
+        });
+    });
+    describe('integration with base capabilities', () => {
+        it('should have access to node through base class', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Node access test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.node).to.equal(laneTool);
+        });
+        it('should have access to intent through base class', async () => {
+            const params = {
+                intents: [],
+                explanation: 'Intent access test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple step main intent', params);
+            await multiStepCapability.execute(config);
+            expect(multiStepCapability.intent).to.exist;
+            expect(multiStepCapability.intent.value).to.equal('Multiple step main intent');
+        });
+    });
+});

package/dist/test/capabilities/search-capability.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=search-capability.spec.d.ts.map

package/dist/test/capabilities/search-capability.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-capability.spec.d.ts","sourceRoot":"","sources":["../../../test/capabilities/search-capability.spec.ts"],"names":[],"mappings":""}