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

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

@@ -0,0 +1,337 @@
+import { expect } from 'chai';
+import { oCapabilitySearch, oCapabilityType } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+describe('oCapabilitySearch @capability @search', () => {
+    let os;
+    let laneTool;
+    let searchCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        searchCapability = new oCapabilitySearch();
+    });
+    describe('type identification', () => {
+        it('should return SEARCH type from instance getter', () => {
+            expect(searchCapability.type).to.equal(oCapabilityType.SEARCH);
+        });
+        it('should return SEARCH type from static getter', () => {
+            expect(oCapabilitySearch.type).to.equal(oCapabilityType.SEARCH);
+        });
+    });
+    describe('configuration getters', () => {
+        it('should provide access to external flag', async () => {
+            const params = {
+                isExternal: true,
+                queries: [{ query: 'test query' }],
+                explanation: 'Test explanation'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            await searchCapability.execute(config);
+            expect(searchCapability.external).to.be.true;
+        });
+        it('should provide access to queries', async () => {
+            const queries = [
+                { query: 'first query', limit: 10 },
+                { query: 'second query', limit: 20 }
+            ];
+            const params = {
+                isExternal: false,
+                queries,
+                explanation: 'Test explanation'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            await searchCapability.execute(config);
+            expect(searchCapability.queries).to.deep.equal(queries);
+        });
+        it('should provide access to explanation', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'This is why we are searching'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            await searchCapability.execute(config);
+            expect(searchCapability.explanation).to.equal('This is why we are searching');
+        });
+        it('should handle internal search flag', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Internal search'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            await searchCapability.execute(config);
+            expect(searchCapability.external).to.be.false;
+        });
+    });
+    describe('internal search', () => {
+        it('should execute internal search when isExternal is false', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test internal search', limit: 5 }],
+                explanation: 'Testing internal search'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Internal search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should handle multiple internal search queries', async () => {
+            const params = {
+                isExternal: false,
+                queries: [
+                    { query: 'first query', limit: 5 },
+                    { query: 'second query', limit: 10 },
+                    { query: 'third query', limit: 15 }
+                ],
+                explanation: 'Multiple queries'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should handle query without limit', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test query' }], // No limit specified
+                explanation: 'Query without limit'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            // Default limit of 20 should be used
+        });
+        it('should format internal search results', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'formatting test', limit: 3 }],
+                explanation: 'Test formatting'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.result).to.be.a('string');
+            // Should contain search result markers
+            if (typeof result.result === 'string') {
+                expect(result.result).to.include('[Search Results Begin]');
+                expect(result.result).to.include('[Search Results End]');
+            }
+        });
+        it('should handle empty search results', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'query_that_returns_nothing_xyz123', limit: 5 }],
+                explanation: 'Empty results test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            // Should handle empty results gracefully
+        });
+    });
+    describe('external search', () => {
+        it('should execute external search when isExternal is true', async () => {
+            const params = {
+                isExternal: true,
+                queries: [{ query: 'test external search' }],
+                explanation: 'Testing external search'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'External search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should handle multiple external search queries', async () => {
+            const params = {
+                isExternal: true,
+                queries: [
+                    { query: 'first external query' },
+                    { query: 'second external query' }
+                ],
+                explanation: 'Multiple external queries'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Multiple search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should format external search results', async () => {
+            const params = {
+                isExternal: true,
+                queries: [{ query: 'external formatting test' }],
+                explanation: 'Test external formatting'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.result).to.be.a('string');
+            // Should contain search result markers
+            if (typeof result.result === 'string') {
+                expect(result.result).to.include('[Search Results Begin]');
+                expect(result.result).to.include('[Search Results End]');
+            }
+        });
+        it('should handle external search with streaming', async () => {
+            const chunks = [];
+            const params = {
+                isExternal: true,
+                queries: [{ query: 'streaming test query' }],
+                explanation: 'Test streaming'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(config.useStream).to.be.true;
+        });
+    });
+    describe('result structure', () => {
+        it('should return oCapabilitySearchResult', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Result structure test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+            expect(result.result).to.exist;
+            expect(result.config).to.equal(config);
+        });
+        it('should include formatted result string', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Formatted result test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result.result).to.be.a('string');
+        });
+        it('should include humanResult with raw data', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Human result test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result.humanResult).to.exist;
+        });
+        it('should set type to EVALUATE in result', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Type test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+    });
+    describe('query handling', () => {
+        it('should handle single query', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'single query test' }],
+                explanation: 'Single query'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(searchCapability.queries.length).to.equal(1);
+        });
+        it('should handle empty queries array', async () => {
+            const params = {
+                isExternal: false,
+                queries: [],
+                explanation: 'Empty queries'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(searchCapability.queries.length).to.equal(0);
+        });
+        it('should handle complex query strings', async () => {
+            const params = {
+                isExternal: false,
+                queries: [
+                    { query: 'query with special chars !@#$%^&*()' },
+                    { query: 'query with "quotes" and \'apostrophes\'' },
+                    { query: 'multi\nline\nquery' }
+                ],
+                explanation: 'Complex queries'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            const result = await searchCapability.execute(config);
+            expect(result).to.exist;
+            expect(searchCapability.queries.length).to.equal(3);
+        });
+        it('should preserve query limits', async () => {
+            const params = {
+                isExternal: false,
+                queries: [
+                    { query: 'query 1', limit: 5 },
+                    { query: 'query 2', limit: 15 },
+                    { query: 'query 3', limit: 25 }
+                ],
+                explanation: 'Limit preservation test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            await searchCapability.execute(config);
+            expect(searchCapability.queries[0].limit).to.equal(5);
+            expect(searchCapability.queries[1].limit).to.equal(15);
+            expect(searchCapability.queries[2].limit).to.equal(25);
+        });
+    });
+    describe('error handling', () => {
+        it('should handle search service unavailable', async () => {
+            const params = {
+                isExternal: false,
+                queries: [{ query: 'test' }],
+                explanation: 'Service unavailable test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            // Search may fail if service not available
+            try {
+                const result = await searchCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if search service is not configured
+                expect(error).to.exist;
+            }
+        });
+        it('should handle external provider unavailable', async () => {
+            const params = {
+                isExternal: true,
+                queries: [{ query: 'test' }],
+                explanation: 'External provider unavailable test'
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Search intent', params);
+            // External search may fail if Perplexity is not configured
+            try {
+                const result = await searchCapability.execute(config);
+                expect(result).to.exist;
+            }
+            catch (error) {
+                // Expected if external search service is not configured
+                expect(error).to.exist;
+            }
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,335 @@
+import { expect } from 'chai';
+import { oCapabilityTask, oCapabilityType } from '@olane/o-lane';
+import { createTestOS, createTestLaneTool, createMockCapabilityConfig } from './utils/capability-test-utils.js';
+describe('oCapabilityTask @capability @task', () => {
+    let os;
+    let laneTool;
+    let taskCapability;
+    before(async () => {
+        os = await createTestOS();
+        laneTool = await createTestLaneTool(os);
+    });
+    after(async () => {
+        if (laneTool) {
+            await laneTool.stop();
+        }
+        if (os) {
+            await os.stop();
+        }
+    });
+    beforeEach(() => {
+        taskCapability = new oCapabilityTask();
+    });
+    describe('type identification', () => {
+        it('should return TASK type from instance getter', () => {
+            expect(taskCapability.type).to.equal(oCapabilityType.TASK);
+        });
+        it('should return TASK type from static getter', () => {
+            expect(oCapabilityTask.type).to.equal(oCapabilityType.TASK);
+        });
+    });
+    describe('task getter', () => {
+        it('should provide access to task from params', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: { arg1: 'value1' }
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            await taskCapability.execute(config);
+            expect(taskCapability.task).to.deep.equal(task);
+        });
+        it('should handle undefined task params', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test task', {});
+            await taskCapability.execute(config);
+            expect(taskCapability.task).to.be.undefined;
+        });
+    });
+    describe('run() method - validation', () => {
+        it('should fail if task is missing', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test task', {});
+            const result = await taskCapability.execute(config);
+            expect(result.error).to.exist;
+            expect(result.error).to.include('Failed to configure the tool use');
+        });
+        it('should fail if task.address is missing', async () => {
+            const task = {
+                payload: {
+                    method: 'testMethod',
+                    params: { arg1: 'value1' }
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result.error).to.exist;
+            expect(result.error).to.include('Failed to configure the tool use');
+        });
+        it('should fail if task object is null', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task: null });
+            const result = await taskCapability.execute(config);
+            expect(result.error).to.exist;
+        });
+    });
+    describe('run() method - approval system', () => {
+        it('should handle missing approval service gracefully', async () => {
+            const task = {
+                address: 'o://nonexistent-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            // This should attempt approval and continue even if service is not available
+            const result = await taskCapability.execute(config);
+            // The task will fail because the tool doesn't exist, but not because of approval
+            expect(result).to.exist;
+        });
+        it('should handle task with params for approval', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: { arg1: 'value1', arg2: 123 }
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task with params', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            // Result may have error if tool/approval doesn't exist, but validates structure
+        });
+    });
+    describe('run() method - task execution', () => {
+        it('should handle tool not found error', async () => {
+            const task = {
+                address: 'o://nonexistent-tool',
+                payload: {
+                    method: 'someMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.error).to.exist;
+        });
+        it('should handle method not found error', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'nonexistentMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            // Will likely error because tool doesn't exist
+        });
+        it('should include task address in execution', async () => {
+            const toolAddress = 'o://test-calculation-tool';
+            const task = {
+                address: toolAddress,
+                payload: {
+                    method: 'calculate',
+                    params: { a: 5, b: 10 }
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Calculate something', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+    });
+    describe('result structure', () => {
+        it('should return oCapabilityTaskResult', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+            expect(result.config).to.equal(config);
+        });
+        it('should set type to EVALUATE in result', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+        it('should include config in result', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result.config).to.exist;
+            expect(result.config).to.equal(config);
+        });
+    });
+    describe('streaming support', () => {
+        it('should call onChunk when provided', async () => {
+            const chunks = [];
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task }, {
+                useStream: true,
+                onChunk: (chunk) => chunks.push(chunk)
+            });
+            await taskCapability.execute(config);
+            // onChunk is called with the response
+            // May not have chunks if tool doesn't exist, but validates structure
+            expect(config.onChunk).to.be.a('function');
+        });
+        it('should handle streaming without onChunk callback', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task }, { useStream: true });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+        });
+    });
+    describe('replay mode', () => {
+        it('should handle replay mode flag', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task }, { isReplay: true });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(config.isReplay).to.be.true;
+        });
+        it('should execute task even in replay mode', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: { replay: true }
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task }, { isReplay: true });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+        });
+    });
+    describe('error handling', () => {
+        it('should return error in result on failure', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test task', {});
+            const result = await taskCapability.execute(config);
+            expect(result.error).to.exist;
+            expect(result.error).to.be.a('string');
+        });
+        it('should handle oError instances', async () => {
+            const task = {
+                address: null, // Invalid address
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result.error).to.exist;
+        });
+        it('should include error type in result', async () => {
+            const config = createMockCapabilityConfig(laneTool, 'Test task', {});
+            const result = await taskCapability.execute(config);
+            expect(result.type).to.equal(oCapabilityType.EVALUATE);
+            expect(result.error).to.exist;
+        });
+    });
+    describe('persistence flag', () => {
+        it('should detect _save flag in tool response', async () => {
+            // This tests the structure - actual _save detection requires tool response
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            // shouldPersist would be set if tool response contained _save: true
+            expect(result.hasOwnProperty('shouldPersist')).to.be.true;
+        });
+    });
+    describe('parameter handling', () => {
+        it('should pass params to tool execution', async () => {
+            const params = {
+                stringParam: 'test',
+                numberParam: 123,
+                boolParam: true,
+                objectParam: { nested: 'value' },
+                arrayParam: [1, 2, 3]
+            };
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+            expect(taskCapability.task.payload.params).to.deep.equal(params);
+        });
+        it('should handle empty params', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod',
+                    params: {}
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+        });
+        it('should handle undefined params', async () => {
+            const task = {
+                address: 'o://test-tool',
+                payload: {
+                    method: 'testMethod'
+                }
+            };
+            const config = createMockCapabilityConfig(laneTool, 'Test task', { task });
+            const result = await taskCapability.execute(config);
+            expect(result).to.exist;
+        });
+    });
+});