@olane/o-node 0.7.12-alpha.9 → 0.7.13-alpha.0

package/dist/src/router/o-node.router.js

@@ -1,7 +1,7 @@
-import { oAddress, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { CoreUtils, oAddress, oError, oErrorCodes, oRequest, ResponseBuilder, } from '@olane/o-core';
 import { oToolRouter } from '@olane/o-tool';
-import { oNodeConnection } from '../connection/o-node-connection.js';
 import { oNodeRoutingPolicy } from './o-node.routing-policy.js';
+import { oStreamRequest } from '../connection/o-stream.request.js';
 export class oNodeRouter extends oToolRouter {
     constructor() {
         super();
@@ -25,6 +25,9 @@ export class oNodeRouter extends oToolRouter {
             params: request.params,
             id: request.id,
         });
+        if (request.stream) {
+            nextHopRequest.stream = request.stream;
+        }
         // Handle self-routing: execute locally instead of dialing
         if (this.routingPolicy.isSelfAddress(address, node)) {
             return this.executeSelfRouting(request, node);
@@ -39,17 +42,55 @@ export class oNodeRouter extends oToolRouter {
     }
     /**
      * Executes a request locally when routing to self.
+     * Now uses ResponseBuilder for consistency with useSelf() behavior.
      */
     async executeSelfRouting(request, node) {
         const { payload } = request.params;
         const params = payload.params;
         const localRequest = new oRequest({
             method: payload.method,
-            params: { ...params },
+            params: {
+                ...params,
+                _connectionId: request.params._connectionId,
+                _requestMethod: payload.method,
+            },
             id: request.id,
         });
-        const result = await node.execute(localRequest);
-        return result;
+        // Create ResponseBuilder with metrics tracking
+        const responseBuilder = ResponseBuilder.create().withMetrics(node.metrics);
+        // Handle streaming requests
+        const isStream = request.params._isStreaming;
+        if (isStream && request.stream) {
+            // For streaming, we need to handle the stream chunks
+            try {
+                const result = await node.execute(localRequest, request.stream);
+                const response = await responseBuilder.build(localRequest, result, null, {
+                    isStream: true,
+                });
+                // Return unwrapped data for consistency with dialAndTransmit
+                return response.result.data;
+            }
+            catch (error) {
+                const errorResponse = await responseBuilder.buildError(localRequest, error, {
+                    isStream: true,
+                });
+                // For errors, throw to match remote behavior
+                throw responseBuilder.normalizeError(error);
+            }
+        }
+        // Handle non-streaming requests with error handling
+        try {
+            const result = await node.execute(localRequest);
+            const response = await responseBuilder.build(localRequest, result, null);
+            // Return unwrapped data to match dialAndTransmit behavior
+            return response.result.data;
+        }
+        catch (error) {
+            // Build error response for metrics tracking
+            await responseBuilder.buildError(localRequest, error);
+            // Then throw the normalized error
+            throw responseBuilder.normalizeError(error);
+        }
     }
     /**
      * Checks if the next hop is the final destination address.
@@ -65,10 +106,11 @@ export class oNodeRouter extends oToolRouter {
     unwrapDestinationRequest(request) {
         const { payload } = request.params;
         const params = payload.params;
-        return new oRequest({
+        return new oStreamRequest({
             method: payload.method,
             params: { ...params },
             id: request.id,
+            stream: request.stream,
         });
     }
     /**
@@ -76,13 +118,24 @@ export class oNodeRouter extends oToolRouter {
      */
     async dialAndTransmit(address, request, node) {
         try {
-            const connection = await node.p2pNode.dial(address.libp2pTransports.map((t) => t.toMultiaddr()));
-            const nodeConnection = new oNodeConnection({
-                p2pConnection: connection,
+            const isStream = request.params._isStreaming ||
+                request.params.payload?.params?._isStreaming;
+            const nodeConnection = await node.connectionManager.connect({
                 nextHopAddress: address,
                 address: node.address,
                 callerAddress: node.address,
+                isStream: isStream,
             });
+            if (isStream) {
+                const routeRequest = request;
+                if (!routeRequest.stream) {
+                    throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+                }
+                nodeConnection.onChunk(async (response) => {
+                    CoreUtils.sendStreamResponse(response, routeRequest.stream);
+                });
+                // allow this to continue as we will tell the transmitter to stream the response and we will intercept via the above listener
+            }
             const response = await nodeConnection.transmit(request);
             return response.result.data;
         }

package/dist/src/router/o-node.routing-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAkB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAuBxB"}
+{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAuB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}

package/dist/src/router/o-node.routing-policy.js

@@ -17,11 +17,16 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
      */
     isInternalAddress(address, node) {
         const nodeAddress = address;
+        // if we are trying to connect to a parent, it's internal
+        if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
+            return true;
+        }
         if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
             nodeAddress.libp2pTransports?.length > 0) {
             // transports are provided, let's see if they match our known leaders
             const isLeaderRef = nodeAddress.toString() === oAddress.leader().toString();
-            const isOurLeaderRef = node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
+            const isOurLeaderRef = node.address.equals(nodeAddress) ||
+                node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
             return isLeaderRef || isOurLeaderRef;
         }
         return true;
@@ -40,7 +45,7 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
         const isInternal = this.isInternalAddress(address, node);
         if (!isInternal) {
             // external address, so we need to route
-            this.logger.debug('Address is external, routing...', nodeAddress.toString(), nodeAddress.libp2pTransports.map((t) => t.toString()));
+            this.logger.debug('Address is external, routing...', nodeAddress);
             // route to leader of external OS
             return {
                 nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),

package/dist/src/router/resolvers/o-node.resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAsC1E"}
+{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAId,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA8C1E"}

package/dist/src/router/resolvers/o-node.resolver.js

@@ -1,4 +1,4 @@
-import { oAddressResolver, TransportType, } from '@olane/o-core';
+import { oAddressResolver, oAddress, TransportType, oError, oErrorCodes, } from '@olane/o-core';
 import { oNodeAddress } from '../o-node.address.js';
 export class oNodeResolver extends oAddressResolver {
     constructor(address) {
@@ -32,6 +32,10 @@ export class oNodeResolver extends oAddressResolver {
                 requestOverride: request,
             };
         }
+        // no child address, and we have already been to the leader, fail
+        if (address.toString().indexOf(oAddress.leader().toString()) > -1) {
+            throw new oError(oErrorCodes.NOT_FOUND, targetAddress.toString() + ' node not found.');
+        }
         return {
             nextHopAddress: address,
             targetAddress: targetAddress,

package/dist/src/router/resolvers/o-node.search-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAsBL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAoE/D"}
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAeL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAsG/D"}

package/dist/src/router/resolvers/o-node.search-resolver.js

@@ -1,4 +1,4 @@
-import { oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
+import { NodeState, oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
 import { oNodeTransport } from '../o-node.transport.js';
 /**
  * Address resolver that searches a registry to find transports for addresses.
@@ -78,7 +78,7 @@ export class oSearchResolver extends oAddressResolver {
      * @returns The registry address to query
      */
     getRegistryAddress() {
-        return new oAddress(RestrictedAddresses.REGISTRY);
+        return new oAddress('o://leader/registry');
     }
     /**
      * Returns the method name to call on the registry.
@@ -201,7 +201,6 @@ export class oSearchResolver extends oAddressResolver {
     determineNextHop(node, resolvedTargetAddress, searchResult) {
         // Determine next hop using standard hierarchy logic
         const nextHopAddress = oAddress.next(node.address, resolvedTargetAddress);
-        this.logger.debug('determineNextHop with params', 'node.address: ' + node.address.toString(), 'resolvedTargetAddress: ' + resolvedTargetAddress.toString(), 'searchResult.address: ' + searchResult.address, 'next hop: ' + nextHopAddress.toString());
         // Map transports from search result
         const targetTransports = this.mapTransports(searchResult);
         // Set transports on the next hop based on routing logic
@@ -218,13 +217,40 @@ export class oSearchResolver extends oAddressResolver {
                 requestOverride: resolveRequest,
             };
         }
-        // Perform registry search
+        if (node.state !== NodeState.RUNNING) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // Perform registry search with error handling
         const searchParams = this.buildSearchParams(address);
         const registryAddress = this.getRegistryAddress();
-        const searchResponse = await node.use(registryAddress, {
-            method: this.getSearchMethod(),
-            params: searchParams,
-        });
+        let searchResponse;
+        try {
+            searchResponse = await node.use(registryAddress, {
+                method: this.getSearchMethod(),
+                params: searchParams,
+            });
+        }
+        catch (error) {
+            // Log the error but don't throw - allow fallback resolvers to handle it
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this is a circuit breaker error (fast-fail scenario)
+            if (errorMessage.includes('Circuit breaker is OPEN')) {
+                this.logger.warn(`Registry search blocked by circuit breaker for ${address.toString()}: ${errorMessage}`);
+            }
+            else {
+                this.logger.error(`Registry search failed for ${address.toString()}: ${errorMessage}`);
+            }
+            // Return original address without transports, letting next resolver in chain handle it
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
         // Filter and select result
         const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
         const selectedResult = this.selectResult(filteredResults);
@@ -240,7 +266,6 @@ export class oSearchResolver extends oAddressResolver {
         const extraParams = address
             .toString() // o://embeddings-text replace o://embeddings-text = ''
             .replace(address.toRootAddress().toString(), '');
-        this.logger.debug('Extra params:', extraParams);
         // Check if selectedResult.address already contains the complete path
         // This happens when registry finds via staticAddress - the returned address
         // is the canonical hierarchical location, so we shouldn't append extraParams

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

@@ -0,0 +1,3 @@
+export * from './stream.utils.js';
+export * from './network.utils.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/src/utils/index.js

@@ -0,0 +1,2 @@
+export * from './stream.utils.js';
+export * from './network.utils.js';

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.12-alpha.9",
+  "version": "0.7.13-alpha.0",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,12 +54,12 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.12-alpha.9",
-    "@olane/o-core": "0.7.12-alpha.9",
-    "@olane/o-protocol": "0.7.12-alpha.9",
-    "@olane/o-tool": "0.7.12-alpha.9",
+    "@olane/o-config": "0.7.13-alpha.0",
+    "@olane/o-core": "0.7.13-alpha.0",
+    "@olane/o-protocol": "0.7.13-alpha.0",
+    "@olane/o-tool": "0.7.13-alpha.0",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "21427acbdc1d87ff9465bf19bda58cca89e8d3c7"
+  "gitHead": "8a956c0823d63d66cde155bd88f4aa7fcf0ca1a4"
 }

package/dist/src/router/resolvers/o-node.child-resolver.d.ts

@@ -1,11 +0,0 @@
-import { oAddressResolver, TransportType } from '@olane/o-core';
-import { oNodeAddress } from '../o-node.address.js';
-import { oNodeRouterResponse } from '../interfaces/o-node-router.response.js';
-import { ResolveRequest } from '@olane/o-core';
-export declare class oNodeChildResolver extends oAddressResolver {
-    protected readonly address: oNodeAddress;
-    constructor(address: oNodeAddress);
-    get supportedTransports(): TransportType[];
-    resolve(routeRequest: ResolveRequest): Promise<oNodeRouterResponse>;
-}
-//# sourceMappingURL=o-node.child-resolver.d.ts.map

package/dist/src/router/resolvers/o-node.child-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node.child-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.child-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,kBAAmB,SAAQ,gBAAgB;IAC1C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA4D1E"}

package/dist/src/router/resolvers/o-node.child-resolver.js

@@ -1,58 +0,0 @@
-import { oAddressResolver, TransportType, } from '@olane/o-core';
-export class oNodeChildResolver extends oAddressResolver {
-    constructor(address) {
-        super(address);
-        this.address = address;
-    }
-    get supportedTransports() {
-        return [TransportType.LIBP2P];
-    }
-    async resolve(routeRequest) {
-        const { address, node, request } = routeRequest;
-        if (!node) {
-            return {
-                nextHopAddress: address,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        // if we are the same address, return the address
-        if (address.toStaticAddress().equals(node.address.toStaticAddress())) {
-            return {
-                nextHopAddress: node.address,
-                targetAddress: node.address,
-                requestOverride: request,
-            };
-        }
-        // get the next node & check for child address existence
-        const remainingPath = address.protocol.replace(node.address.protocol + '/', '');
-        // ensure this is going down in the hierarchy
-        if (remainingPath === address.protocol && node.isLeader === false) {
-            return {
-                nextHopAddress: node.address,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        // static resolver
-        this.logger.debug(`[${node?.address}]: Next node: ${address.toString()}`);
-        const childAddress = node?.hierarchyManager.getChild(address);
-        this.logger.debug(`[${node?.address}]: Children: ${node?.hierarchyManager.children.map((c) => c.toString()).join(', ')}`);
-        this.logger.debug(`[${node?.address}]: Resolving address: ${address.toString()} and child address: ${childAddress?.toString()}`);
-        this.logger.debug('Child transports: ' +
-            childAddress?.transports.map((t) => t.toString()).join(', '));
-        // get the child address from hierarchy (which includes transports)
-        if (childAddress) {
-            return {
-                nextHopAddress: childAddress,
-                targetAddress: address,
-                requestOverride: request,
-            };
-        }
-        return {
-            nextHopAddress: address,
-            targetAddress: address,
-            requestOverride: request,
-        };
-    }
-}

package/dist/src/utils/leader-request-wrapper.d.ts

@@ -1,45 +0,0 @@
-import { oObject, oAddress } from '@olane/o-core';
-export interface LeaderRetryConfig {
-    enabled: boolean;
-    maxAttempts: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    timeoutMs: number;
-}
-/**
- * Leader Request Wrapper
- *
- * Wraps requests to leader/registry with aggressive retry logic.
- * Used when leader may be temporarily unavailable (healing, maintenance).
- *
- * Strategy:
- * 1. Detect if request is to leader or registry
- * 2. Apply retry logic with exponential backoff
- * 3. Timeout individual attempts
- * 4. Log retries for observability
- */
-export declare class LeaderRequestWrapper extends oObject {
-    private config;
-    constructor(config: LeaderRetryConfig);
-    /**
-     * Check if address is a leader-related address that needs retry
-     */
-    private isLeaderAddress;
-    /**
-     * Execute request with retry logic
-     */
-    execute<T>(requestFn: () => Promise<T>, address: oAddress, context?: string): Promise<T>;
-    /**
-     * Calculate exponential backoff delay
-     */
-    private calculateBackoffDelay;
-    /**
-     * Sleep utility
-     */
-    private sleep;
-    /**
-     * Get current configuration
-     */
-    getConfig(): LeaderRetryConfig;
-}
-//# sourceMappingURL=leader-request-wrapper.d.ts.map

package/dist/src/utils/leader-request-wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leader-request-wrapper.d.ts","sourceRoot":"","sources":["../../../src/utils/leader-request-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAuB,MAAM,eAAe,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,iBAAiB;IAI7C;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACG,OAAO,CAAC,CAAC,EACb,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,CAAC,CAAC;IAoEb;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,SAAS,IAAI,iBAAiB;CAG/B"}

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

@@ -1,89 +0,0 @@
-import { oObject } from '@olane/o-core';
-/**
- * Leader Request Wrapper
- *
- * Wraps requests to leader/registry with aggressive retry logic.
- * Used when leader may be temporarily unavailable (healing, maintenance).
- *
- * Strategy:
- * 1. Detect if request is to leader or registry
- * 2. Apply retry logic with exponential backoff
- * 3. Timeout individual attempts
- * 4. Log retries for observability
- */
-export class LeaderRequestWrapper extends oObject {
-    constructor(config) {
-        super();
-        this.config = config;
-    }
-    /**
-     * Check if address is a leader-related address that needs retry
-     */
-    isLeaderAddress(address) {
-        const addressStr = address.toString();
-        return addressStr === 'o://leader' || addressStr === 'o://registry';
-    }
-    /**
-     * Execute request with retry logic
-     */
-    async execute(requestFn, address, context) {
-        // If retry disabled or not a leader address, execute directly
-        if (!this.config.enabled || !this.isLeaderAddress(address)) {
-            return await requestFn();
-        }
-        let attempt = 0;
-        let lastError;
-        while (attempt < this.config.maxAttempts) {
-            attempt++;
-            try {
-                this.logger.debug(`Leader request attempt ${attempt}/${this.config.maxAttempts}` +
-                    (context ? ` (${context})` : ''));
-                // Create timeout promise
-                const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error(`Leader request timeout after ${this.config.timeoutMs}ms`)), this.config.timeoutMs);
-                });
-                // Race between request and timeout
-                const result = await Promise.race([requestFn(), timeoutPromise]);
-                // Success!
-                if (attempt > 1) {
-                    this.logger.info(`Leader request succeeded after ${attempt} attempts` +
-                        (context ? ` (${context})` : ''));
-                }
-                return result;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                this.logger.warn(`Leader request attempt ${attempt} failed: ${lastError.message}` +
-                    (context ? ` (${context})` : ''));
-                if (attempt < this.config.maxAttempts) {
-                    const delay = this.calculateBackoffDelay(attempt);
-                    this.logger.debug(`Waiting ${delay}ms before next attempt...`);
-                    await this.sleep(delay);
-                }
-            }
-        }
-        // All attempts failed
-        this.logger.error(`Leader request failed after ${this.config.maxAttempts} attempts` +
-            (context ? ` (${context})` : ''));
-        throw lastError || new Error('Leader request failed');
-    }
-    /**
-     * Calculate exponential backoff delay
-     */
-    calculateBackoffDelay(attempt) {
-        const delay = this.config.baseDelayMs * Math.pow(2, attempt - 1);
-        return Math.min(delay, this.config.maxDelayMs);
-    }
-    /**
-     * Sleep utility
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-}

package/dist/test/o-node.spec.d.ts

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

package/dist/test/o-node.spec.d.ts.map

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

package/dist/test/o-node.spec.js

@@ -1,20 +0,0 @@
-import { NodeState } from '@olane/o-core';
-import { expect } from 'chai';
-import { oNode } from '../src/index.js';
-import { oNodeAddress } from '../src/router/o-node.address.js';
-describe('in-process @memory', () => {
-    it('should be able to start a single node with no leader', async () => {
-        const node = new oNode({
-            address: new oNodeAddress('o://test'),
-            leader: null,
-            parent: null,
-        });
-        await node.start();
-        expect(node.state).to.equal(NodeState.RUNNING);
-        const transports = node.transports;
-        // expect(transports.length).to.equal(1);
-        // expect(transports[0].toString()).to.contain('/memory');
-        await node.stop();
-        expect(node.state).to.equal(NodeState.STOPPED);
-    });
-});

package/dist/test/search-resolver.spec.d.ts

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

package/dist/test/search-resolver.spec.d.ts.map

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