@olane/os 0.7.12-alpha.9 → 0.7.13-alpha.0

package/dist/test/capabilities/evaluate-capability.spec.js

@@ -0,0 +1,323 @@
+import { expect } from 'chai';
+import { oCapabilityEvaluate, oCapabilityType } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+describe('oCapabilityEvaluate @capability @evaluate', () => {
+    let os;
+    let laneTool;
+    let evaluateCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        evaluateCapability = new oCapabilityEvaluate();
+    });
+    describe('type identification', () => {
+        it('should return EVALUATE type from instance getter', () => {
+            expect(evaluateCapability.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should return EVALUATE type from static getter', () => {
+            expect(oCapabilityEvaluate.type).to.equal(oCapabilityType.EVALUATE);
+        });
+    });
+    describe('inheritance', () => {
+        it('should extend oCapabilityIntelligence', async () => {
+            expect(evaluateCapability).to.respondTo('intelligence');
+        });
+        it('should have access to intelligence method', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate this intent');
+            await evaluateCapability.execute(config);
+            expect(evaluateCapability.intelligence).to.be.a('function');
+        });
+    });
+    describe('run() method', () => {
+        it('should execute intelligence with intent', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate this test intent');
+            // May fail if intelligence service not available
+            try {
+                const result = await evaluateCapability.execute(config);
+                expect(result).to.exist;
+                expect(result).to.have.property('type');
+            }
+            catch (error) {
+                // Expected if intelligence service is not configured
+                expect(error).to.exist;
+            }
+        });
+        it('should include intent in intelligence prompt', async () => {
+            const intent = 'Evaluate this specific intent for testing';
+            const config = createMockCapabilityConfig(laneTool, intent);
+            try {
+                await evaluateCapability.execute(config);
+                // Validates structure even if intelligence service unavailable
+                expect(evaluateCapability.config.intent.value).to.equal(intent);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should include history in intelligence prompt', async () => {
+            const history = 'Previous steps:\n1. User asked a question\n2. Searched for information';
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate with history');
+            config.history = history;
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.history).to.equal(history);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should include context in intelligence prompt', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate with context');
+            config.laneConfig.context = {
+                toString: () => 'Test context data'
+            };
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.laneConfig.context).to.exist;
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should include extra instructions in intelligence prompt', async () => {
+            const extraInstructions = 'Please be concise and focus on key points';
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate with instructions');
+            config.laneConfig.extraInstructions = extraInstructions;
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.laneConfig.extraInstructions).to.equal(extraInstructions);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle missing context gracefully', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate without context');
+            // Don't set context
+            try {
+                await evaluateCapability.execute(config);
+                // Should handle missing context
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle missing history gracefully', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate without history');
+            config.history = '';
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.history).to.equal('');
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle missing extra instructions gracefully', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate without instructions');
+            // Don't set extra instructions
+            try {
+                await evaluateCapability.execute(config);
+                // Should handle missing instructions
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+    });
+    describe('result structure', () => {
+        it('should return capability result', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test result structure');
+            try {
+                const result = await evaluateCapability.execute(config);
+                expect(result).to.exist;
+                expect(result.type).to.equal(oCapabilityType.EVALUATE);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should include config in result', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test config inclusion');
+            try {
+                const result = await evaluateCapability.execute(config);
+                if (result.config) {
+                    expect(result.config).to.exist;
+                }
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+    });
+    describe('streaming support', () => {
+        it('should support streaming evaluation', async () => {
+            const chunks = [];
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate with streaming', {}, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            try {
+                await evaluateCapability.execute(config);
+                expect(config.useStream).to.be.true;
+                expect(config.onChunk).to.be.a('function');
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should work without streaming', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Evaluate without streaming');
+            try {
+                await evaluateCapability.execute(config);
+                expect(config.useStream).to.be.false;
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+    });
+    describe('complex scenarios', () => {
+        it('should handle evaluation with all context elements', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Complex evaluation scenario');
+            config.history = 'Step 1: User requested action\nStep 2: Searched for information';
+            config.laneConfig.context = {
+                toString: () => 'Relevant context about the domain'
+            };
+            config.laneConfig.extraInstructions = 'Be detailed but concise';
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.intent.value).to.equal('Complex evaluation scenario');
+                expect(evaluateCapability.config.history).to.exist;
+                expect(evaluateCapability.config.laneConfig.context).to.exist;
+                expect(evaluateCapability.config.laneConfig.extraInstructions).to.exist;
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle evaluation with minimal config', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Minimal evaluation');
+            try {
+                const result = await evaluateCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle long intent strings', async () => {
+            const longIntent = 'Evaluate this very long intent that contains multiple sentences and complex requirements. '.repeat(10);
+            const config = createMockCapabilityConfig(laneTool, longIntent);
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.intent.value).to.equal(longIntent);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle intent with special characters', async () => {
+            const intent = 'Evaluate: "What is 2+2?" & other questions! #test';
+            const config = createMockCapabilityConfig(laneTool, intent);
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.intent.value).to.equal(intent);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+        it('should handle multiline intent', async () => {
+            const intent = `Evaluate this scenario:
+      Line 1: First requirement
+      Line 2: Second requirement
+      Line 3: Third requirement`;
+            const config = createMockCapabilityConfig(laneTool, intent);
+            try {
+                await evaluateCapability.execute(config);
+                expect(evaluateCapability.config.intent.value).to.equal(intent);
+            }
+            catch (error) {
+                // Expected if service not available
+            }
+        });
+    });
+    describe('integration with base capabilities', () => {
+        it('should have access to node through base class', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test node access');
+            await evaluateCapability.execute(config);
+            expect(evaluateCapability.node).to.equal(laneTool);
+        });
+        it('should have access to intent through base class', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent access');
+            await evaluateCapability.execute(config);
+            expect(evaluateCapability.intent).to.exist;
+            expect(evaluateCapability.intent.value).to.equal('Test intent access');
+        });
+        it('should support cancellation', () => {
+            evaluateCapability.cancel();
+            // Should not throw - validates cancel method exists
+        });
+    });
+    describe('error handling', () => {
+        it('should handle intelligence service unavailable', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test error handling');
+            try {
+                const result = await evaluateCapability.execute(config);
+                // If no error, validate result structure
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if intelligence service is not available
+                expect(error).to.exist;
+            }
+        });
+        it('should handle node not running', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test with stopped node');
+            await evaluateCapability.execute(config);
+            // Stop the node
+            await laneTool.stop();
+            try {
+                const result = await evaluateCapability.intelligence('Test prompt');
+                // Should have error
+                if (result.error) {
+                    expect(result.error).to.exist;
+                }
+            }
+            catch (error) {
+                // Expected
+                expect(error).to.exist;
+            }
+            // Restart for cleanup
+            await laneTool.start();
+        });
+    });
+    describe('parameter handling', () => {
+        it('should handle custom parameters', async () => {
+            const params = {
+                customParam1: 'value1',
+                customParam2: 123,
+                customParam3: { nested: 'object' }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test custom params', params);
+            await evaluateCapability.execute(config);
+            expect(evaluateCapability.config.params).to.deep.include(params);
+        });
+        it('should handle empty parameters', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test empty params', {});
+            await evaluateCapability.execute(config);
+            expect(evaluateCapability.config.params).to.exist;
+        });
+    });
+});

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

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

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

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

package/dist/test/capabilities/intelligence-capability.spec.js

@@ -0,0 +1,171 @@
+import { expect } from 'chai';
+// TODO: oCapabilityIntelligence is not yet implemented
+// import { oCapabilityIntelligence, oCapabilityType, oCapabilityResult } from '@olane/o-lane';
+import { oCapabilityType, oCapabilityResult } from '@olane/o-lane';
+import { NodeState, RestrictedAddresses } from '@olane/o-core';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+/**
+ * Test implementation of oCapabilityIntelligence
+ * TODO: This test is skipped until oCapabilityIntelligence is implemented
+ */
+class TestIntelligenceCapability {
+    async execute(_config) {
+        return null;
+    }
+    async run() {
+        const result = await this.intelligence('Test intelligence prompt');
+        return new oCapabilityResult({
+            type: result.type,
+            result: result.result,
+            humanResult: result.humanResult,
+            error: result.error
+        });
+    }
+    get type() {
+        return oCapabilityType.EVALUATE;
+    }
+    static get type() {
+        return oCapabilityType.EVALUATE;
+    }
+}
+describe.skip('oCapabilityIntelligence @capability @intelligence', () => {
+    let os;
+    let laneTool;
+    let testCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        testCapability = new TestIntelligenceCapability();
+    });
+    describe('intelligence() method', () => {
+        it('should require node to be running', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            // Stop the node
+            await laneTool.stop();
+            try {
+                await testCapability.intelligence('Test prompt');
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error.message).to.include('Node is not running');
+            }
+            // Restart for cleanup
+            await laneTool.start();
+        });
+        it('should call intelligence service with correct address', async () => {
+            // This test validates the structure but may fail if intelligence service is not configured
+            // We're testing that the method attempts to use the correct address
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            expect(laneTool.state).to.equal(NodeState.RUNNING);
+            // The intelligence method should attempt to use RestrictedAddresses.INTELLIGENCE
+            // We can't easily test the actual call without mocking, but we can verify the node is running
+            expect(RestrictedAddresses.INTELLIGENCE).to.equal('o://intelligence');
+        });
+        it('should handle streaming configuration', async () => {
+            const chunks = [];
+            const config = createMockCapabilityConfig(laneTool, 'Test intent', {}, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            await testCapability.execute(config);
+            expect(testCapability.config.useStream).to.be.true;
+            expect(testCapability.config.onChunk).to.be.a('function');
+        });
+        it('should use non-streaming by default', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            expect(testCapability.config.useStream).to.be.false;
+        });
+    });
+    describe('result structure', () => {
+        it('should return oCapabilityIntelligenceResult', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            // This may fail if intelligence service is not available, but tests the structure
+            try {
+                const result = await testCapability.execute(config);
+                expect(result).to.exist;
+                expect(result.type).to.be.a('string');
+            }
+            catch (error) {
+                // Expected if intelligence service is not configured
+                // The test still validates the code structure
+            }
+        });
+        it('should handle errors gracefully', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            // Stop the node to force an error
+            await laneTool.stop();
+            const result = await testCapability.intelligence('Test prompt');
+            expect(result).to.exist;
+            expect(result.error).to.exist;
+            expect(result.error).to.be.a('string');
+            expect(result.result).to.be.null;
+            // Restart for cleanup
+            await laneTool.start();
+        });
+    });
+    describe('prompt handling', () => {
+        it('should accept string prompts', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            const testPrompts = [
+                'Simple prompt',
+                'Multi-line\nprompt\nwith\nbreaks',
+                'Prompt with special characters: !@#$%^&*()',
+                ''
+            ];
+            for (const prompt of testPrompts) {
+                try {
+                    const result = await testCapability.intelligence(prompt);
+                    expect(result).to.exist;
+                }
+                catch (error) {
+                    // Expected if service not available
+                }
+            }
+        });
+    });
+    describe('integration with base capability', () => {
+        it('should extend oCapability properly', () => {
+            expect(testCapability).to.be.instanceOf(TestIntelligenceCapability);
+        });
+        it('should have access to config through base class', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent', { param1: 'value1' });
+            await testCapability.execute(config);
+            expect(testCapability.config).to.exist;
+            expect(testCapability.config.params).to.deep.equal({ param1: 'value1' });
+        });
+        it('should have access to node through base class', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intent');
+            await testCapability.execute(config);
+            expect(testCapability.node).to.equal(laneTool);
+        });
+        it('should have access to intent through base class', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test intelligence intent');
+            await testCapability.execute(config);
+            expect(testCapability.intent).to.exist;
+            expect(testCapability.intent.intent).to.equal('Test intelligence intent');
+        });
+    });
+    describe('type identification', () => {
+        it('should return correct type from instance getter', () => {
+            expect(testCapability.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should return correct type from static getter', () => {
+            expect(TestIntelligenceCapability.type).to.equal(oCapabilityType.EVALUATE);
+        });
+    });
+});

package/dist/test/capabilities/multiple-step-capability.spec.d.ts

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

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

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