@olane/o-leader 0.7.10 → 0.7.11

package/dist/test/address-resolution-integration.spec.d.ts

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

package/dist/test/address-resolution-integration.spec.d.ts.map

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

package/dist/test/address-resolution-integration.spec.js

@@ -0,0 +1,704 @@
+import { expect } from 'chai';
+import { oLeaderNode } from '../src/leader.node.js';
+import { oNode } from '@olane/o-node';
+import { oNodeAddress } from '@olane/o-node';
+import { oAddress, RestrictedAddresses, NodeState } from '@olane/o-core';
+describe('Address Resolution Integration Tests', () => {
+    describe('Leader + Registry + Resolver Integration', () => {
+        let leader;
+        beforeEach(async () => {
+            leader = new oLeaderNode({
+                name: 'test-leader',
+                parent: null,
+                leader: null,
+                network: {
+                    listeners: [],
+                },
+            });
+            await leader.start();
+        });
+        afterEach(async () => {
+            if (leader && leader.state === NodeState.RUNNING) {
+                await leader.stop();
+            }
+        });
+        it('should start leader with registry as child', async () => {
+            expect(leader.state).to.equal(NodeState.RUNNING);
+            expect(leader.address.value).to.equal(RestrictedAddresses.LEADER);
+            // Verify registry is a child
+            const registryChild = leader.hierarchyManager.getChild(new oAddress(RestrictedAddresses.REGISTRY));
+            expect(registryChild).to.not.be.null;
+            expect(registryChild?.value).to.equal(RestrictedAddresses.REGISTRY);
+        });
+        it('should be able to register a node in the registry', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-embeddings',
+                address: 'o://leader/services/embeddings',
+                staticAddress: 'o://embeddings-text',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/6001'],
+            };
+            const result = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            expect(result.result.success).to.be.true;
+        });
+        it('should be able to search for registered nodes', async () => {
+            // Register a node
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-search-test',
+                address: 'o://leader/services/search-test',
+                staticAddress: 'o://search-test',
+                protocols: ['/test/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/7001'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Search for the node
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://search-test' },
+            });
+            expect(searchResult.result.data).to.be.an('array');
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].peerId).to.equal('peer-search-test');
+        });
+        it('should resolve address using search resolver', async () => {
+            // Register a service
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-embeddings',
+                address: 'o://leader/services/embeddings',
+                staticAddress: 'o://embeddings-text',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/6001'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Try to use the service by static address
+            // The resolver should find it in the registry
+            try {
+                const result = await leader.use(new oAddress('o://embeddings-text'), {
+                    method: 'ping', // Some method that may not exist, but routing should work
+                    params: {},
+                });
+                // If we get here without error, routing worked
+                // The actual method call may fail, but that's expected
+            }
+            catch (error) {
+                // Expected - the service doesn't actually exist, but we should have resolved the address
+                // Check that the error is about the method, not about routing
+                expect(error.message).to.not.include('No route');
+            }
+        });
+        it('should handle multiple services with same protocol', async () => {
+            // Register two embedding services
+            const service1 = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-embeddings-1',
+                address: 'o://leader/services/embeddings-text',
+                staticAddress: 'o://embeddings-text',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/6001'],
+                registeredAt: 1000,
+            };
+            const service2 = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-embeddings-2',
+                address: 'o://leader/services/embeddings-image',
+                staticAddress: 'o://embeddings-image',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/6002'],
+                registeredAt: 2000, // More recent
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: service1,
+            });
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: service2,
+            });
+            // Search by protocol - should return both, sorted by registeredAt
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/embeddings/1.0.0'] },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(2);
+            expect(searchResult.result.data[0].peerId).to.equal('peer-embeddings-2'); // Most recent
+            expect(searchResult.result.data[1].peerId).to.equal('peer-embeddings-1');
+        });
+        it('should handle service removal', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-temporary',
+                address: 'o://leader/services/temporary',
+                staticAddress: 'o://temporary',
+                protocols: ['/temp/1.0.0'],
+                transports: ['/memory'],
+            };
+            // Register
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Verify it exists
+            let searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://temporary' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            // Remove
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'remove',
+                params: { peerId: 'peer-temporary' },
+            });
+            // Verify it's gone
+            searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://temporary' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(0);
+        });
+        it('should list all registered nodes', async () => {
+            // Register multiple nodes
+            const nodes = [
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-1',
+                    address: 'o://node-1',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-2',
+                    address: 'o://node-2',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-3',
+                    address: 'o://node-3',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+            ];
+            for (const node of nodes) {
+                await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                    method: 'commit',
+                    params: node,
+                });
+            }
+            // Get all nodes
+            const result = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'find_all',
+                params: {},
+            });
+            expect(result.result.data).to.be.an('array');
+            expect(result.result.data.length).to.be.at.least(3); // At least our 3 nodes
+            const peerIds = result.result.data.map((n) => n.peerId);
+            expect(peerIds).to.include('peer-1');
+            expect(peerIds).to.include('peer-2');
+            expect(peerIds).to.include('peer-3');
+        });
+    });
+    describe('Multi-node scenarios', () => {
+        let leader;
+        let childNode;
+        beforeEach(async () => {
+            leader = new oLeaderNode({
+                name: 'test-leader',
+                parent: null,
+                leader: null,
+                network: {
+                    listeners: [],
+                },
+            });
+            await leader.start();
+        });
+        afterEach(async () => {
+            if (childNode && childNode.state === NodeState.RUNNING) {
+                await childNode.stop();
+            }
+            if (leader && leader.state === NodeState.RUNNING) {
+                await leader.stop();
+            }
+        });
+        it('should handle hierarchical node registration', async () => {
+            // Create child node
+            childNode = new oNode({
+                address: new oNodeAddress('o://leader/services'),
+                parent: leader.address,
+                leader: leader.address,
+                network: {
+                    listeners: [],
+                },
+            });
+            await childNode.start();
+            // Register the child in the registry
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-services',
+                address: 'o://leader/services',
+                protocols: ['/services/1.0.0'],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Search for it
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { address: 'o://leader/services' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].address).to.equal('o://leader/services');
+        });
+        it('should support service discovery by protocol', async () => {
+            // Register services with different protocols
+            const services = [
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-embeddings',
+                    address: 'o://leader/ai/embeddings',
+                    protocols: ['/ai/embeddings/1.0.0', '/text/1.0.0'],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-chat',
+                    address: 'o://leader/ai/chat',
+                    protocols: ['/ai/chat/1.0.0', '/text/1.0.0'],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-vision',
+                    address: 'o://leader/ai/vision',
+                    protocols: ['/ai/vision/1.0.0', '/image/1.0.0'],
+                    transports: ['/memory'],
+                },
+            ];
+            for (const service of services) {
+                await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                    method: 'commit',
+                    params: service,
+                });
+            }
+            // Find all text-based services
+            const textServices = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/text/1.0.0'] },
+            });
+            expect(textServices.result.data).to.have.lengthOf(2);
+            const peerIds = textServices.result.data.map((s) => s.peerId);
+            expect(peerIds).to.include.members(['peer-embeddings', 'peer-chat']);
+            // Find embeddings service specifically
+            const embeddingsService = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/ai/embeddings/1.0.0'] },
+            });
+            expect(embeddingsService.result.data).to.have.lengthOf(1);
+            expect(embeddingsService.result.data[0].peerId).to.equal('peer-embeddings');
+        });
+        it('should handle service updates on re-registration', async () => {
+            const initialRegistration = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-dynamic',
+                address: 'o://leader/services/dynamic',
+                protocols: ['/service/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/4001'],
+                registeredAt: 1000,
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: initialRegistration,
+            });
+            // Simulate service update (new transport)
+            const updatedRegistration = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-dynamic',
+                address: 'o://leader/services/dynamic',
+                protocols: ['/service/1.0.0', '/service/2.0.0'], // Added new protocol
+                transports: ['/ip4/192.168.1.1/tcp/4001'], // New transport
+                registeredAt: 2000,
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: updatedRegistration,
+            });
+            // Verify update
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { address: 'o://leader/services/dynamic' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].protocols).to.include('/service/2.0.0');
+            expect(searchResult.result.data[0].transports[0]).to.equal('/ip4/192.168.1.1/tcp/4001');
+            expect(searchResult.result.data[0].registeredAt).to.equal(2000);
+        });
+    });
+    describe('Real-world routing scenarios', () => {
+        let leader;
+        beforeEach(async () => {
+            leader = new oLeaderNode({
+                name: 'test-leader',
+                parent: null,
+                leader: null,
+                network: {
+                    listeners: [],
+                },
+            });
+            await leader.start();
+        });
+        afterEach(async () => {
+            if (leader && leader.state === NodeState.RUNNING) {
+                await leader.stop();
+            }
+        });
+        it('should route to static address via registry lookup', async () => {
+            // Register service with static address
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-static-service',
+                address: 'o://leader/services/my-service',
+                staticAddress: 'o://my-service',
+                protocols: ['/service/1.0.0'],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Verify static address search works
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://my-service' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].address).to.equal('o://leader/services/my-service');
+            expect(searchResult.result.data[0].staticAddress).to.equal('o://my-service');
+        });
+        it('should handle hierarchical routing through services', async () => {
+            // Register nested services
+            const services = [
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-services-parent',
+                    address: 'o://leader/services',
+                    protocols: ['/services/1.0.0'],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-embeddings-child',
+                    address: 'o://leader/services/embeddings',
+                    protocols: ['/embeddings/1.0.0'],
+                    transports: ['/memory'],
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-embeddings-text-leaf',
+                    address: 'o://leader/services/embeddings/text',
+                    staticAddress: 'o://embeddings-text',
+                    protocols: ['/embeddings/text/1.0.0'],
+                    transports: ['/memory'],
+                },
+            ];
+            for (const service of services) {
+                await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                    method: 'commit',
+                    params: service,
+                });
+            }
+            // Verify all are registered
+            const allServices = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'find_all',
+                params: {},
+            });
+            const peerIds = allServices.result.data.map((s) => s.peerId);
+            expect(peerIds).to.include.members([
+                'peer-services-parent',
+                'peer-embeddings-child',
+                'peer-embeddings-text-leaf',
+            ]);
+            // Test routing through hierarchy using oAddress.next()
+            const currentAddress = new oAddress('o://leader');
+            const targetAddress = new oAddress('o://leader/services/embeddings/text');
+            // First hop: leader -> leader/services
+            const firstHop = oAddress.next(currentAddress, targetAddress);
+            expect(firstHop.toString()).to.equal('o://leader/services');
+            // Second hop: leader/services -> leader/services/embeddings
+            const secondHop = oAddress.next(firstHop, targetAddress);
+            expect(secondHop.toString()).to.equal('o://leader/services/embeddings');
+            // Third hop: leader/services/embeddings -> leader/services/embeddings/text
+            const thirdHop = oAddress.next(secondHop, targetAddress);
+            expect(thirdHop.toString()).to.equal('o://leader/services/embeddings/text');
+            // Fourth hop: at destination
+            const fourthHop = oAddress.next(thirdHop, targetAddress);
+            expect(fourthHop.toString()).to.equal('o://leader/services/embeddings/text');
+        });
+        it('should support searching with combined parameters', async () => {
+            // Register service with multiple attributes
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-complex',
+                address: 'o://leader/ai/embeddings',
+                staticAddress: 'o://embeddings-text',
+                protocols: ['/embeddings/1.0.0', '/text/1.0.0', '/ai/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/6001'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            // Search by static address
+            const byStatic = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://embeddings-text' },
+            });
+            expect(byStatic.result.data).to.have.lengthOf(1);
+            // Search by exact address
+            const byAddress = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { address: 'o://leader/ai/embeddings' },
+            });
+            expect(byAddress.result.data).to.have.lengthOf(1);
+            // Search by multiple protocols (AND logic)
+            const byProtocols = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/embeddings/1.0.0', '/text/1.0.0'] },
+            });
+            expect(byProtocols.result.data).to.have.lengthOf(1);
+            // Search by single protocol
+            const bySingleProtocol = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/ai/1.0.0'] },
+            });
+            expect(bySingleProtocol.result.data).to.have.lengthOf(1);
+        });
+        it('should handle registry preventing infinite loops', async () => {
+            // Try to register registry itself (should work, but search should filter it)
+            const registryRegistration = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-registry',
+                address: RestrictedAddresses.REGISTRY,
+                staticAddress: RestrictedAddresses.REGISTRY,
+                protocols: ['/registry/1.0.0'],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registryRegistration,
+            });
+            // Verify it's in the registry
+            const allNodes = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'find_all',
+                params: {},
+            });
+            const registryNode = allNodes.result.data.find((n) => n.peerId === 'peer-registry');
+            expect(registryNode).to.exist;
+            // But search resolver should filter it out to prevent loops
+            // This is tested in the resolver unit tests
+        });
+        it('should handle empty registry gracefully', async () => {
+            // Search empty registry
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://nonexistent' },
+            });
+            expect(searchResult.result.data).to.be.an('array');
+            expect(searchResult.result.data).to.have.lengthOf(0);
+        });
+        it('should handle multiple transports per service', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-multi-transport',
+                address: 'o://leader/services/multi',
+                staticAddress: 'o://multi-transport',
+                protocols: ['/multi/1.0.0'],
+                transports: [
+                    '/ip4/127.0.0.1/tcp/4001',
+                    '/ip4/192.168.1.1/tcp/4001',
+                    '/ip6/::1/tcp/4001',
+                ],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://multi-transport' },
+            });
+            expect(searchResult.result.data[0].transports).to.have.lengthOf(3);
+            expect(searchResult.result.data[0].transports).to.include('/ip4/127.0.0.1/tcp/4001');
+            expect(searchResult.result.data[0].transports).to.include('/ip4/192.168.1.1/tcp/4001');
+            expect(searchResult.result.data[0].transports).to.include('/ip6/::1/tcp/4001');
+        });
+    });
+    describe('Edge cases and error handling', () => {
+        let leader;
+        beforeEach(async () => {
+            leader = new oLeaderNode({
+                name: 'test-leader',
+                parent: null,
+                leader: null,
+                network: {
+                    listeners: [],
+                },
+            });
+            await leader.start();
+        });
+        afterEach(async () => {
+            if (leader && leader.state === NodeState.RUNNING) {
+                await leader.stop();
+            }
+        });
+        it('should handle service with long address path', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-deep',
+                address: 'o://leader/a/b/c/d/e/f/g/h/i/j/service',
+                protocols: ['/deep/1.0.0'],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { address: 'o://leader/a/b/c/d/e/f/g/h/i/j/service' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+        });
+        it('should handle service with special characters', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-special-chars',
+                address: 'o://leader/my-service_v2.0',
+                staticAddress: 'o://my-service_v2.0',
+                protocols: ['/service/2.0.0'],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { staticAddress: 'o://my-service_v2.0' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].address).to.equal('o://leader/my-service_v2.0');
+        });
+        it('should handle service with empty protocols array', async () => {
+            const registrationParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-no-protocols',
+                address: 'o://leader/services/no-protocols',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params: registrationParams,
+            });
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { address: 'o://leader/services/no-protocols' },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(1);
+            expect(searchResult.result.data[0].protocols).to.be.an('array')
+                .that.is.empty;
+        });
+        it('should handle concurrent registrations', async () => {
+            const registrations = [];
+            for (let i = 0; i < 10; i++) {
+                registrations.push({
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: `peer-concurrent-${i}`,
+                    address: `o://leader/services/concurrent-${i}`,
+                    protocols: ['/concurrent/1.0.0'],
+                    transports: ['/memory'],
+                    registeredAt: Date.now() + i,
+                });
+            }
+            // Register concurrently
+            const promises = registrations.map((params) => leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'commit',
+                params,
+            }));
+            await Promise.all(promises);
+            // Verify all were registered
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/concurrent/1.0.0'] },
+            });
+            expect(searchResult.result.data).to.have.lengthOf(10);
+        });
+        it('should maintain sort order after multiple operations', async () => {
+            const nodes = [
+                { peerId: 'peer-1', registeredAt: 1000 },
+                { peerId: 'peer-2', registeredAt: 2000 },
+                { peerId: 'peer-3', registeredAt: 3000 },
+            ];
+            for (const node of nodes) {
+                await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                    method: 'commit',
+                    params: {
+                        ...node,
+                        address: `o://${node.peerId}`,
+                        protocols: ['/test/1.0.0'],
+                        transports: ['/memory'],
+                    },
+                });
+            }
+            const searchResult = await leader.use(new oAddress(RestrictedAddresses.REGISTRY), {
+                method: 'search',
+                params: { protocols: ['/test/1.0.0'] },
+            });
+            // Should be sorted by registeredAt descending (most recent first)
+            expect(searchResult.result.data[0].peerId).to.equal('peer-3');
+            expect(searchResult.result.data[1].peerId).to.equal('peer-2');
+            expect(searchResult.result.data[2].peerId).to.equal('peer-1');
+        });
+    });
+});

package/dist/test/registry-memory.spec.d.ts

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

package/dist/test/registry-memory.spec.d.ts.map

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

package/dist/test/registry-memory.spec.js

@@ -0,0 +1,528 @@
+import { expect } from 'chai';
+import { RegistryMemoryTool } from '../src/registry/registry-memory.tool.js';
+import { oAddress } from '@olane/o-core';
+describe('RegistryMemoryTool', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new RegistryMemoryTool({
+            name: 'test-registry',
+            parent: oAddress.leader(),
+            leader: oAddress.leader(),
+            network: {
+                listeners: [],
+            },
+        });
+    });
+    describe('_tool_commit()', () => {
+        it('should register a node with all fields', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-123',
+                address: 'o://leader/services/embeddings',
+                protocols: ['/embeddings/1.0.0', '/text/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/4001'],
+                staticAddress: 'o://embeddings-text',
+                registeredAt: Date.now(),
+            };
+            const request = {
+                params,
+            };
+            const result = await registry._tool_commit(request);
+            expect(result.success).to.be.true;
+            // Verify node is in registry
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(1);
+            expect(allNodes[0].peerId).to.equal('peer-123');
+            expect(allNodes[0].address).to.equal('o://leader/services/embeddings');
+        });
+        it('should register a node with minimal fields', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-456',
+                address: 'o://worker',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            const request = {
+                params,
+            };
+            const result = await registry._tool_commit(request);
+            expect(result.success).to.be.true;
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(1);
+            expect(allNodes[0].peerId).to.equal('peer-456');
+        });
+        it('should update an existing node on re-registration', async () => {
+            const initialParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-789',
+                address: 'o://service-v1',
+                protocols: ['/service/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/4001'],
+            };
+            await registry._tool_commit({
+                params: initialParams,
+            });
+            // Re-register with updated info
+            const updatedParams = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-789',
+                address: 'o://service-v2',
+                protocols: ['/service/2.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/4002'],
+            };
+            await registry._tool_commit({
+                params: updatedParams,
+            });
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(1);
+            expect(allNodes[0].address).to.equal('o://service-v2');
+            expect(allNodes[0].protocols).to.deep.equal(['/service/2.0.0']);
+        });
+        it('should register multiple nodes with same protocols', async () => {
+            const node1 = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-001',
+                address: 'o://embeddings-node-1',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/5001'],
+            };
+            const node2 = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-002',
+                address: 'o://embeddings-node-2',
+                protocols: ['/embeddings/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/5002'],
+            };
+            await registry._tool_commit({ params: node1 });
+            await registry._tool_commit({ params: node2 });
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(2);
+        });
+        it('should set registeredAt timestamp if not provided', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-timestamp',
+                address: 'o://test',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            const beforeTime = Date.now();
+            await registry._tool_commit({ params });
+            const afterTime = Date.now();
+            const allNodes = await registry._tool_find_all({});
+            const registeredNode = allNodes[0];
+            expect(registeredNode.registeredAt).to.be.a('number');
+            expect(registeredNode.registeredAt).to.be.at.least(beforeTime);
+            expect(registeredNode.registeredAt).to.be.at.most(afterTime);
+        });
+        it('should preserve custom registeredAt timestamp', async () => {
+            const customTimestamp = 1234567890;
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-custom-time',
+                address: 'o://test',
+                protocols: [],
+                transports: ['/memory'],
+                registeredAt: customTimestamp,
+            };
+            await registry._tool_commit({ params });
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes[0].registeredAt).to.equal(customTimestamp);
+        });
+        it('should update protocol mapping on registration', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-protocol-map',
+                address: 'o://test',
+                protocols: ['/embeddings/1.0.0', '/chat/1.0.0'],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            // Search by protocol to verify mapping
+            const searchResult = await registry._tool_search({
+                params: { protocols: ['/embeddings/1.0.0'] },
+            });
+            expect(searchResult).to.have.lengthOf(1);
+            expect(searchResult[0].peerId).to.equal('peer-protocol-map');
+        });
+    });
+    describe('_tool_search()', () => {
+        beforeEach(async () => {
+            // Setup test data
+            const nodes = [
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-embeddings-1',
+                    address: 'o://leader/services/embeddings-text',
+                    staticAddress: 'o://embeddings-text',
+                    protocols: ['/embeddings/1.0.0', '/text/1.0.0'],
+                    transports: ['/ip4/127.0.0.1/tcp/6001'],
+                    registeredAt: 1000,
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-embeddings-2',
+                    address: 'o://leader/services/embeddings-image',
+                    staticAddress: 'o://embeddings-image',
+                    protocols: ['/embeddings/1.0.0', '/image/1.0.0'],
+                    transports: ['/ip4/127.0.0.1/tcp/6002'],
+                    registeredAt: 2000,
+                },
+                {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: 'peer-chat',
+                    address: 'o://leader/services/chat',
+                    staticAddress: 'o://chat',
+                    protocols: ['/chat/1.0.0'],
+                    transports: ['/ip4/127.0.0.1/tcp/6003'],
+                    registeredAt: 3000,
+                },
+            ];
+            for (const node of nodes) {
+                await registry._tool_commit({ params: node });
+            }
+        });
+        it('should search by staticAddress (exact match)', async () => {
+            const result = await registry._tool_search({
+                params: { staticAddress: 'o://embeddings-text' },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('peer-embeddings-1');
+            expect(result[0].staticAddress).to.equal('o://embeddings-text');
+        });
+        it('should search by address (exact match)', async () => {
+            const result = await registry._tool_search({
+                params: { address: 'o://leader/services/chat' },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('peer-chat');
+        });
+        it('should search by single protocol', async () => {
+            const result = await registry._tool_search({
+                params: { protocols: ['/chat/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('peer-chat');
+        });
+        it('should search by multiple protocols (AND logic)', async () => {
+            const result = await registry._tool_search({
+                params: { protocols: ['/embeddings/1.0.0', '/text/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('peer-embeddings-1');
+        });
+        it('should return multiple nodes matching protocol', async () => {
+            const result = await registry._tool_search({
+                params: { protocols: ['/embeddings/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(2);
+            expect(result[0].peerId).to.equal('peer-embeddings-2'); // More recent
+            expect(result[1].peerId).to.equal('peer-embeddings-1');
+        });
+        it('should return empty array when no results found', async () => {
+            const result = await registry._tool_search({
+                params: { staticAddress: 'o://nonexistent' },
+            });
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(0);
+        });
+        it('should return empty array for non-matching protocol', async () => {
+            const result = await registry._tool_search({
+                params: { protocols: ['/nonexistent/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(0);
+        });
+        it('should sort results by registeredAt (most recent first)', async () => {
+            const result = await registry._tool_search({
+                params: { protocols: ['/embeddings/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(2);
+            expect(result[0].registeredAt).to.equal(2000);
+            expect(result[1].registeredAt).to.equal(1000);
+            expect(result[0].registeredAt).to.be.greaterThan(result[1].registeredAt);
+        });
+        it('should handle combined search parameters', async () => {
+            const result = await registry._tool_search({
+                params: {
+                    staticAddress: 'o://embeddings-text',
+                    protocols: ['/embeddings/1.0.0'],
+                },
+            });
+            // Should return the node that matches staticAddress
+            // Note: Current implementation concatenates results, may have duplicates
+            expect(result.length).to.be.at.least(1);
+            const textEmbedding = result.find((r) => r.peerId === 'peer-embeddings-1');
+            expect(textEmbedding).to.exist;
+        });
+        it('should handle search with no parameters', async () => {
+            const result = await registry._tool_search({
+                params: {},
+            });
+            // Empty search should return empty array
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(0);
+        });
+        it('should handle partial protocol match failure', async () => {
+            // Search for both protocols when node only has one
+            const result = await registry._tool_search({
+                params: { protocols: ['/chat/1.0.0', '/embeddings/1.0.0'] },
+            });
+            // AND logic: node must have ALL protocols
+            expect(result).to.have.lengthOf(0);
+        });
+        it('should handle nodes without registeredAt timestamp', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-no-timestamp',
+                address: 'o://test-no-timestamp',
+                protocols: ['/test/1.0.0'],
+                transports: ['/memory'],
+                // No registeredAt
+            };
+            await registry._tool_commit({ params });
+            const result = await registry._tool_search({
+                params: { protocols: ['/test/1.0.0'] },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('peer-no-timestamp');
+        });
+    });
+    describe('_tool_find_all()', () => {
+        it('should return empty array for empty registry', async () => {
+            const result = await registry._tool_find_all({});
+            expect(result).to.be.an('array');
+            expect(result).to.have.lengthOf(0);
+        });
+        it('should return single node', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'single-peer',
+                address: 'o://single',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            const result = await registry._tool_find_all({});
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].peerId).to.equal('single-peer');
+        });
+        it('should return all registered nodes', async () => {
+            const nodes = [
+                {
+                    peerId: 'peer-1',
+                    address: 'o://node-1',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    peerId: 'peer-2',
+                    address: 'o://node-2',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    peerId: 'peer-3',
+                    address: 'o://node-3',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+            ];
+            for (const node of nodes) {
+                await registry._tool_commit({
+                    params: node,
+                });
+            }
+            const result = await registry._tool_find_all({});
+            expect(result).to.have.lengthOf(3);
+            const peerIds = result.map((r) => r.peerId);
+            expect(peerIds).to.include.members(['peer-1', 'peer-2', 'peer-3']);
+        });
+        it('should return nodes with all their properties', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'full-peer',
+                address: 'o://full-node',
+                staticAddress: 'o://static',
+                protocols: ['/protocol/1.0.0'],
+                transports: ['/ip4/127.0.0.1/tcp/4001'],
+                ttl: 3600,
+                registeredAt: 12345,
+            };
+            await registry._tool_commit({ params });
+            const result = await registry._tool_find_all({});
+            expect(result[0]).to.deep.include({
+                peerId: 'full-peer',
+                address: 'o://full-node',
+                staticAddress: 'o://static',
+                ttl: 3600,
+                registeredAt: 12345,
+            });
+            expect(result[0].protocols).to.deep.equal(['/protocol/1.0.0']);
+            expect(result[0].transports).to.deep.equal(['/ip4/127.0.0.1/tcp/4001']);
+        });
+    });
+    describe('_tool_remove()', () => {
+        it('should remove an existing node', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-to-remove',
+                address: 'o://removable',
+                protocols: ['/test/1.0.0'],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            let allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(1);
+            const result = await registry._tool_remove({
+                params,
+            });
+            expect(result.success).to.be.true;
+            allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(0);
+        });
+        it('should handle removing non-existent node', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'nonexistent-peer',
+                address: 'o://nonexistent',
+                protocols: [],
+                transports: [],
+            };
+            const result = await registry._tool_remove({
+                params,
+            });
+            expect(result.success).to.be.true; // Should succeed silently
+        });
+        it('should remove correct node when multiple exist', async () => {
+            const nodes = [
+                {
+                    peerId: 'peer-1',
+                    address: 'o://node-1',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    peerId: 'peer-2',
+                    address: 'o://node-2',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+                {
+                    peerId: 'peer-3',
+                    address: 'o://node-3',
+                    protocols: [],
+                    transports: ['/memory'],
+                },
+            ];
+            for (const node of nodes) {
+                await registry._tool_commit({
+                    params: node,
+                });
+            }
+            await registry._tool_remove({
+                params: { peerId: 'peer-2' },
+            });
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(2);
+            const peerIds = allNodes.map((r) => r.peerId);
+            expect(peerIds).to.not.include('peer-2');
+            expect(peerIds).to.include.members(['peer-1', 'peer-3']);
+        });
+        it('should not affect search results after removal', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-search-remove',
+                address: 'o://test',
+                staticAddress: 'o://test-static',
+                protocols: ['/test/1.0.0'],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            let searchResult = await registry._tool_search({
+                params: { staticAddress: 'o://test-static' },
+            });
+            expect(searchResult).to.have.lengthOf(1);
+            await registry._tool_remove({ params });
+            searchResult = await registry._tool_search({
+                params: { staticAddress: 'o://test-static' },
+            });
+            expect(searchResult).to.have.lengthOf(0);
+        });
+    });
+    describe('Edge cases and error scenarios', () => {
+        it('should handle registry with large number of nodes', async () => {
+            const nodeCount = 100;
+            for (let i = 0; i < nodeCount; i++) {
+                const params = {
+                    _connectionId: 'test-connection',
+                    _requestMethod: 'test-method',
+                    peerId: `peer-${i}`,
+                    address: `o://node-${i}`,
+                    protocols: ['/test/1.0.0'],
+                    transports: ['/memory'],
+                    registeredAt: i,
+                };
+                await registry._tool_commit({ params });
+            }
+            const allNodes = await registry._tool_find_all({});
+            expect(allNodes).to.have.lengthOf(nodeCount);
+            // Verify sorting still works
+            const searchResult = await registry._tool_search({
+                params: { protocols: ['/test/1.0.0'] },
+            });
+            expect(searchResult[0].registeredAt).to.equal(nodeCount - 1); // Most recent
+        });
+        it('should handle nodes with empty protocols array', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-no-protocols',
+                address: 'o://no-protocols',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            const result = await registry._tool_search({
+                params: { address: 'o://no-protocols' },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].protocols).to.be.an('array').that.is.empty;
+        });
+        it('should handle special characters in addresses', async () => {
+            const params = {
+                _connectionId: 'test-connection',
+                _requestMethod: 'test-method',
+                peerId: 'peer-special',
+                address: 'o://service-name_v2.0',
+                staticAddress: 'o://service-name_v2.0',
+                protocols: [],
+                transports: ['/memory'],
+            };
+            await registry._tool_commit({ params });
+            const result = await registry._tool_search({
+                params: { staticAddress: 'o://service-name_v2.0' },
+            });
+            expect(result).to.have.lengthOf(1);
+            expect(result[0].address).to.equal('o://service-name_v2.0');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-leader",
-  "version": "0.7.10",
+  "version": "0.7.11",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -55,12 +55,12 @@
     "typescript": "5.4.5"
   },
   "peerDependencies": {
-    "@olane/o-config": "^0.7.9",
-    "@olane/o-core": "^0.7.9",
-    "@olane/o-gateway-olane": "^0.7.9",
-    "@olane/o-lane": "^0.7.9",
-    "@olane/o-protocol": "^0.7.9",
-    "@olane/o-tool": "^0.7.9"
+    "@olane/o-config": "^0.7.11",
+    "@olane/o-core": "^0.7.11",
+    "@olane/o-gateway-olane": "^0.7.11",
+    "@olane/o-lane": "^0.7.11",
+    "@olane/o-protocol": "^0.7.11",
+    "@olane/o-tool": "^0.7.11"
   },
   "dependencies": {
     "debug": "^4.4.1",