@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/src/utils/leader-request-wrapper.test.js

@@ -0,0 +1,246 @@
+"use strict";
+// import { expect } from 'chai';
+// import { LeaderRequestWrapper } from './leader-request-wrapper.js';
+// import { oAddress } from '@olane/o-core';
+// import { CircuitState } from './circuit-breaker.js';
+// describe('LeaderRequestWrapper with Circuit Breaker', () => {
+//   let wrapper: LeaderRequestWrapper;
+//   const leaderAddress = new oAddress('o://leader');
+//   const registryAddress = new oAddress('o://registry');
+//   const regularAddress = new oAddress('o://some-service');
+//   beforeEach(() => {
+//     wrapper = new LeaderRequestWrapper({
+//       enabled: true,
+//       maxAttempts: 5,
+//       baseDelayMs: 10,
+//       maxDelayMs: 100,
+//       timeoutMs: 1000,
+//       circuitBreaker: {
+//         enabled: true,
+//         failureThreshold: 3,
+//         openTimeoutMs: 500,
+//         halfOpenMaxAttempts: 1,
+//       },
+//     });
+//   });
+//   describe('Circuit Breaker Integration', () => {
+//     it('should execute request successfully and record success', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalSuccesses).toBe(1);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should record failures in circuit breaker', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//       expect(stats.leader.consecutiveFailures).toBeGreaterThan(0);
+//     });
+//     it('should open circuit after threshold failures', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Attempt request multiple times to trigger circuit breaker
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//     });
+//     it('should fast-fail when circuit is open', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // First request to open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Reset mock to verify it's not called
+//       mockRequest.mockClear();
+//       // Second request should fast-fail
+//       await expect(wrapper.execute(mockRequest, leaderAddress)).rejects.toThrow(
+//         /Circuit breaker is OPEN/,
+//       );
+//       // Request function should not have been called
+//       expect(mockRequest).not.toHaveBeenCalled();
+//     });
+//     it('should stop retrying when circuit opens mid-retry', async () => {
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Service down');
+//       });
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should have stopped retrying after circuit opened
+//       expect(callCount).toBeLessThan(5); // Less than maxAttempts
+//       expect(callCount).toBeGreaterThanOrEqual(3); // At least threshold attempts
+//     });
+//     it('should track separate circuits for leader and registry', async () => {
+//       const failingRequest = vi
+//         .fn()
+//         .mockRejectedValue(new Error('Service down'));
+//       // Fail leader requests
+//       await expect(
+//         wrapper.execute(failingRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//       expect(stats.registry.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should allow recovery after timeout in HALF_OPEN state', async () => {
+//       const mockRequest = vi
+//         .fn()
+//         .mockRejectedValueOnce(new Error('Service down'))
+//         .mockResolvedValue('recovered');
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Wait for circuit to attempt recovery
+//       await new Promise((resolve) => setTimeout(resolve, 600));
+//       // Should succeed and close circuit
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('recovered');
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Non-Leader Addresses', () => {
+//     it('should not use circuit breaker for non-leader addresses', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, regularAddress),
+//       ).rejects.toThrow('Service down');
+//       // Should execute directly without retry
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       // Should not affect circuit breaker stats
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBe(0);
+//       expect(stats.registry.totalFailures).toBe(0);
+//     });
+//     it('should execute successful requests directly', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, regularAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//   });
+//   describe('Timeout Handling', () => {
+//     it('should timeout long-running requests', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(wrapper.execute(longRequest, leaderAddress)).rejects.toThrow(
+//         /timeout/,
+//       );
+//     });
+//     it('should record timeout as failure in circuit breaker', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(
+//         wrapper.execute(longRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//     });
+//   });
+//   describe('Configuration', () => {
+//     it('should bypass retry when disabled', async () => {
+//       const disabledWrapper = new LeaderRequestWrapper({
+//         enabled: false,
+//         maxAttempts: 5,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//       });
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Fail'));
+//       await expect(
+//         disabledWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow('Fail');
+//       // Should only call once (no retry)
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//     it('should allow circuit breaker to be disabled', async () => {
+//       const noBreakerWrapper = new LeaderRequestWrapper({
+//         enabled: true,
+//         maxAttempts: 3,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//         circuitBreaker: {
+//           enabled: false,
+//           failureThreshold: 3,
+//           openTimeoutMs: 500,
+//           halfOpenMaxAttempts: 1,
+//         },
+//       });
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Fail');
+//       });
+//       await expect(
+//         noBreakerWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should retry all attempts even with failures
+//       expect(callCount).toBe(3);
+//     });
+//   });
+//   describe('Manual Reset', () => {
+//     it('should reset circuit breakers manually', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Reset
+//       wrapper.resetCircuitBreakers();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//       expect(wrapper.getCircuitBreakerStats().registry.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Registry Address', () => {
+//     it('should use separate circuit breaker for registry', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Registry down'));
+//       await expect(
+//         wrapper.execute(mockRequest, registryAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.registry.totalFailures).toBeGreaterThan(0);
+//       expect(stats.registry.state).toBe(CircuitState.OPEN);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//   });
+//   describe('Statistics', () => {
+//     it('should provide circuit breaker statistics', () => {
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats).toHaveProperty('leader');
+//       expect(stats).toHaveProperty('registry');
+//       expect(stats.leader).toHaveProperty('state');
+//       expect(stats.leader).toHaveProperty('consecutiveFailures');
+//       expect(stats.registry).toHaveProperty('state');
+//     });
+//   });
+// });

package/dist/src/utils/stream.utils.d.ts

@@ -0,0 +1,6 @@
+import { Stream } from '@olane/o-config';
+import { oObject, oRequest } from '@olane/o-core';
+export declare class StreamUtils extends oObject {
+    static processGenerator(request: oRequest, generator: AsyncGenerator<any>, stream: Stream): Promise<any>;
+}
+//# sourceMappingURL=stream.utils.d.ts.map

package/dist/src/utils/stream.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/stream.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAEL,OAAO,EACP,QAAQ,EAGT,MAAM,eAAe,CAAC;AAEvB,qBAAa,WAAY,SAAQ,OAAO;WAClB,gBAAgB,CAClC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,GAAG,CAAC;CA6BhB"}

package/dist/src/utils/stream.utils.js

@@ -0,0 +1,31 @@
+import { CoreUtils, oObject, ResponseBuilder, } from '@olane/o-core';
+export class StreamUtils extends oObject {
+    static async processGenerator(request, generator, stream) {
+        const utils = new StreamUtils();
+        const responseBuilder = ResponseBuilder.create();
+        let aggregatedResult = '';
+        try {
+            // Send each chunk from the generator
+            // result should not be an oResponse, but rather a key value pair dict
+            for await (const result of generator) {
+                if (result.delta) {
+                    aggregatedResult += result.delta;
+                }
+                const chunkResponse = await responseBuilder.buildChunk(request, result);
+                await CoreUtils.sendStreamResponse(chunkResponse, stream);
+            }
+            return {
+                message: aggregatedResult,
+            };
+        }
+        catch (error) {
+            // If error occurs during streaming, send error response
+            const errorResponse = await responseBuilder.buildError(request, error, {
+                isStream: true,
+                isLast: true,
+            });
+            await CoreUtils.sendStreamResponse(errorResponse, stream);
+            throw error;
+        }
+    }
+}

package/dist/test/circuit-breaker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=circuit-breaker.test.d.ts.map

package/dist/test/circuit-breaker.test.d.ts.map

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

package/dist/test/circuit-breaker.test.js

@@ -0,0 +1,262 @@
+import { expect } from 'chai';
+import { CircuitBreaker, CircuitState } from '../src/utils/circuit-breaker.js';
+describe('CircuitBreaker', () => {
+    let breaker;
+    beforeEach(() => {
+        breaker = new CircuitBreaker('test-service', {
+            enabled: true,
+            failureThreshold: 3,
+            openTimeoutMs: 1000,
+            halfOpenMaxAttempts: 1,
+        });
+    });
+    describe('State Transitions', () => {
+        it('should start in CLOSED state', () => {
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+        it('should transition to OPEN after threshold failures', () => {
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Record failures up to threshold
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Third failure should open circuit
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should transition to HALF_OPEN after timeout', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait for timeout
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // Next request should transition to HALF_OPEN
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+        });
+        it('should transition from HALF_OPEN to CLOSED on success', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            // Success should close circuit
+            breaker.recordSuccess();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+        it('should transition from HALF_OPEN to OPEN on failure', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Failure should reopen circuit
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+    });
+    describe('Request Gating', () => {
+        it('should allow all requests in CLOSED state', () => {
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+        it('should block all requests in OPEN state', () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should limit requests in HALF_OPEN state', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // First request allowed
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Subsequent requests blocked until result recorded
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+    });
+    describe('Failure Tracking', () => {
+        it('should track consecutive failures', () => {
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(1);
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(2);
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(3);
+        });
+        it('should reset consecutive failures on success', () => {
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(2);
+            breaker.recordSuccess();
+            expect(breaker.getStats().consecutiveFailures).to.equal(0);
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+        it('should track total failures and successes', () => {
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            const stats = breaker.getStats();
+            expect(stats.totalFailures).to.equal(2);
+            expect(stats.totalSuccesses).to.equal(2);
+        });
+        it('should track timestamps', () => {
+            const beforeFailure = Date.now();
+            breaker.recordFailure();
+            const afterFailure = Date.now();
+            const stats = breaker.getStats();
+            expect(stats.lastFailureTime).greaterThanOrEqual(beforeFailure);
+            expect(stats.lastFailureTime).lessThanOrEqual(afterFailure);
+            const beforeSuccess = Date.now();
+            breaker.recordSuccess();
+            const afterSuccess = Date.now();
+            const stats2 = breaker.getStats();
+            expect(stats2.lastSuccessTime).greaterThanOrEqual(beforeSuccess);
+            expect(stats2.lastSuccessTime).lessThanOrEqual(afterSuccess);
+        });
+    });
+    describe('Configuration', () => {
+        it('should respect custom failure threshold', () => {
+            const customBreaker = new CircuitBreaker('test', {
+                enabled: true,
+                failureThreshold: 5,
+                openTimeoutMs: 1000,
+                halfOpenMaxAttempts: 1,
+            });
+            // Should not open before threshold
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            expect(customBreaker.getState()).to.equal(CircuitState.CLOSED);
+            // Should open at threshold
+            customBreaker.recordFailure();
+            expect(customBreaker.getState()).to.equal(CircuitState.OPEN);
+        });
+        it('should respect custom half-open attempts', async () => {
+            const customBreaker = new CircuitBreaker('test', {
+                enabled: true,
+                failureThreshold: 2,
+                openTimeoutMs: 100,
+                halfOpenMaxAttempts: 3,
+            });
+            // Open circuit
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            // Wait for timeout
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            // Should allow 3 attempts in HALF_OPEN
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should bypass all logic when disabled', () => {
+            const disabledBreaker = new CircuitBreaker('test', {
+                enabled: false,
+                failureThreshold: 1,
+                openTimeoutMs: 1000,
+                halfOpenMaxAttempts: 1,
+            });
+            // Record many failures
+            disabledBreaker.recordFailure();
+            disabledBreaker.recordFailure();
+            disabledBreaker.recordFailure();
+            // Should still allow requests
+            expect(disabledBreaker.shouldAllowRequest()).to.equal(true);
+            expect(disabledBreaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+    });
+    describe('Manual Control', () => {
+        it('should reset to CLOSED state', () => {
+            // Open circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Reset
+            breaker.reset();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            expect(breaker.getStats().consecutiveFailures).to.equal(0);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+    });
+    describe('Statistics', () => {
+        it('should provide comprehensive stats', () => {
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            const stats = breaker.getStats();
+            expect(stats).to.have.property('state');
+            expect(stats).to.have.property('consecutiveFailures');
+            expect(stats).to.have.property('totalFailures');
+            expect(stats).to.have.property('totalSuccesses');
+            expect(stats).to.have.property('lastFailureTime');
+            expect(stats).to.have.property('lastSuccessTime');
+            expect(stats).to.have.property('openedAt');
+            expect(stats.state).to.equal(CircuitState.CLOSED);
+            expect(stats.consecutiveFailures).to.equal(0);
+            expect(stats.totalFailures).to.equal(2);
+            expect(stats.totalSuccesses).to.equal(1);
+        });
+        it('should track openedAt timestamp', () => {
+            const before = Date.now();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            const after = Date.now();
+            const stats = breaker.getStats();
+            expect(stats.openedAt).greaterThanOrEqual(before);
+            expect(stats.openedAt).lessThanOrEqual(after);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle rapid state transitions', async () => {
+            // Open
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait for HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Close
+            breaker.recordSuccess();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Open again
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+        it('should not open before timeout expires in OPEN state', async () => {
+            // Open circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait less than timeout
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            // Should still be closed
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+    });
+});

package/dist/test/helpers/test-node.tool.d.ts

@@ -0,0 +1,15 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+/**
+ * Test-only extension of oNodeTool that adds streaming test methods.
+ * This class should only be used in test files and is not part of the production code.
+ */
+export declare class TestNodeTool extends oNodeTool {
+    /**
+     * Test method that emits chunks for 10 seconds at 100ms intervals.
+     * Used for testing streaming functionality across hierarchical networks.
+     *
+     * @returns AsyncGenerator that yields 100 chunks over 10 seconds
+     */
+    _tool_test_stream(): AsyncGenerator<any>;
+}
+//# sourceMappingURL=test-node.tool.d.ts.map

package/dist/test/helpers/test-node.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-node.tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/test-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD;;;GAGG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC;;;;;OAKG;IACI,iBAAiB,IAAI,cAAc,CAAC,GAAG,CAAC;CAehD"}

package/dist/test/helpers/test-node.tool.js

@@ -0,0 +1,27 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+/**
+ * Test-only extension of oNodeTool that adds streaming test methods.
+ * This class should only be used in test files and is not part of the production code.
+ */
+export class TestNodeTool extends oNodeTool {
+    /**
+     * Test method that emits chunks for 10 seconds at 100ms intervals.
+     * Used for testing streaming functionality across hierarchical networks.
+     *
+     * @returns AsyncGenerator that yields 100 chunks over 10 seconds
+     */
+    async *_tool_test_stream() {
+        const totalDuration = 10000; // 10 seconds
+        const intervalMs = 100; // 100ms between chunks
+        const totalChunks = totalDuration / intervalMs; // 100 chunks
+        for (let i = 0; i < totalChunks; i++) {
+            yield {
+                chunk: i + 1,
+                timestamp: new Date().toISOString(),
+                nodeAddress: this.address.toString(),
+                message: `Chunk ${i + 1} of ${totalChunks}`,
+            };
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+}

package/dist/test/leader-request-wrapper.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=leader-request-wrapper.test.d.ts.map

package/dist/test/leader-request-wrapper.test.d.ts.map

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