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

package/dist/src/o-node.js

@@ -1,4 +1,4 @@
-import { createNode, defaultLibp2pConfig, } from '@olane/o-config';
+import { createNode, defaultLibp2pConfig, KEEP_ALIVE, } from '@olane/o-config';
 import { v4 as uuidv4 } from 'uuid';
 import { oNodeRouter } from './router/o-node.router.js';
 import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
@@ -12,7 +12,6 @@ import { oLeaderResolverFallback } from './router/index.js';
 import { oNodeNotificationManager } from './o-node.notification-manager.js';
 import { oConnectionHeartbeatManager } from './managers/o-connection-heartbeat.manager.js';
 import { oReconnectionManager } from './managers/o-reconnection.manager.js';
-import { LeaderRequestWrapper } from './utils/leader-request-wrapper.js';
 export class oNode extends oToolBase {
     constructor(config) {
         super(config);
@@ -103,18 +102,54 @@ export class oNode extends oToolBase {
                 peerId: this.peerId.toString(),
             },
         };
-        await this.use(address, params);
+        this.use(address, params).catch((error) => {
+            this.logger.error('Failed to unregister from network:', error);
+        });
+    }
+    async setKeepAliveTag(address) {
+        if (!address || !address.libp2pTransports?.length) {
+            this.logger.warn('Address has no transports, skipping keep alive tag!', address);
+            return;
+        }
+        try {
+            const peers = await this.p2pNode.peerStore.all();
+            // find the peer that is already indexed rather than building the PeerId from the string value to avoid browser issues
+            const peer = peers.find((p) => p.id.toString() === address.libp2pTransports[0].toPeerId().toString());
+            if (!peer) {
+                this.logger.warn('Peer not found, skipping keep alive tag!', address);
+                return;
+            }
+            await this.p2pNode.peerStore.merge(peer.id, {
+                tags: {
+                    [KEEP_ALIVE]: { value: 100 },
+                },
+            });
+            this.logger.debug('Set keep alive tag for peer:', peer.id.toString(), ' with address:', address.toString());
+        }
+        catch (error) {
+            this.logger.error('Failed to set keep alive tag:', error);
+        }
     }
     async registerParent() {
         if (this.type === NodeType.LEADER) {
             this.logger.debug('Skipping parent registration, node is leader');
             return;
         }
+        if (!this.parent?.libp2pTransports?.length) {
+            this.logger.debug('Parent has no transports, waiting for reconnection & leader ack');
+            if (this.parent?.toString() === oAddress.leader().toString()) {
+                this.parent.setTransports(this.leader?.libp2pTransports || []);
+            }
+            else {
+                this.logger.debug('Waiting for parent and reconnecting...');
+                await this.reconnectionManager?.waitForParentAndReconnect();
+            }
+        }
         // if no parent transports, register with the parent to get them
         // TODO: should we remove the transports check to make this more consistent?
-        if (this.config.parent && this.config.parent.transports.length === 0) {
-            this.logger.debug('Registering node with parent...', this.config.parent);
-            const parentRegistration = await this.use(this.config.parent, {
+        if (this.config.parent) {
+            this.logger.debug('Registering node with parent...', this.config.parent?.toString());
+            await this.use(this.config.parent, {
                 method: 'child_register',
                 params: {
                     address: this.address.toString(),
@@ -123,11 +158,24 @@ export class oNode extends oToolBase {
                     _token: this.config.joinToken,
                 },
             });
-            const { parentTransports } = parentRegistration.result.data;
-            // update the parent transports
-            this.config.parent.setTransports(parentTransports.map((t) => new oNodeTransport(t)));
+            this.setKeepAliveTag(this.parent);
         }
     }
+    async registerLeader() {
+        const address = oAddress.registry();
+        const params = {
+            method: 'commit',
+            params: {
+                peerId: this.peerId.toString(),
+                address: this.address.toString(),
+                protocols: this.p2pNode.getProtocols(),
+                transports: this.transports,
+                staticAddress: this.staticAddress.toString(),
+            },
+        };
+        await this.use(address, params);
+        this.setKeepAliveTag(this.leader);
+    }
     async register() {
         if (this.type === NodeType.LEADER) {
             this.logger.debug('Skipping registration, node is leader');
@@ -148,18 +196,7 @@ export class oNode extends oToolBase {
             this.logger.debug('Registering node with leader...');
         }
         await this.registerParent();
-        const address = oAddress.registry();
-        const params = {
-            method: 'commit',
-            params: {
-                peerId: this.peerId.toString(),
-                address: this.address.toString(),
-                protocols: this.p2pNode.getProtocols(),
-                transports: this.transports,
-                staticAddress: this.staticAddress.toString(),
-            },
-        };
-        await this.use(address, params);
+        await this.registerLeader();
         this.logger.debug('Registration successful');
     }
     extractMethod(address) {
@@ -171,11 +208,6 @@ export class oNode extends oToolBase {
         if (this.connectionHeartbeatManager) {
             await this.connectionHeartbeatManager.start();
         }
-        // await NetworkUtils.advertiseToNetwork(
-        //   this.address,
-        //   this.staticAddress,
-        //   this.p2pNode,
-        // );
     }
     async validateJoinRequest(request) {
         return true;
@@ -225,12 +257,32 @@ export class oNode extends oToolBase {
             // ];
             //   // let's make sure we only allow communication through the parent transports
             params.connectionGater = {
+                denyDialPeer: (peerId) => {
+                    // we can call the leader
+                    if (this.config.leader?.libp2pTransports.some((t) => t.toPeerId() === peerId.toString())) {
+                        return false;
+                    }
+                    // we can call our parent
+                    if (this.parentPeerId === peerId.toString()) {
+                        return false;
+                    }
+                    // we can call our children
+                    if (this.hierarchyManager.children.some((c) => c.libp2pTransports.some((t) => t.toPeerId() === peerId.toString()))) {
+                        return false;
+                    }
+                    // check for standalone node
+                    if (!this.config.parent && !this.config.leader) {
+                        return false;
+                    }
+                    return true;
+                },
                 // who can call us?
                 denyInboundEncryptedConnection: (peerId, maConn) => {
                     // deny all inbound connections unless they are from a parent transport
                     if (this.parentPeerId === peerId.toString()) {
                         return false;
                     }
+                    // allow connections from children (for ping)
                     if (this.hierarchyManager.children.some((c) => c.libp2pTransports.some((t) => t.toPeerId() === peerId.toString()))) {
                         return false;
                     }
@@ -245,6 +297,13 @@ export class oNode extends oToolBase {
                 ...(this.config.network?.connectionGater || {}),
             };
         }
+        params.connectionManager = {
+            ...(params.connectionManager || {}),
+            reconnectRetries: 20,
+            reconnectRetryInterval: 2000,
+            reconnectBackoffFactor: 1.2,
+            maxParallelReconnects: 10,
+        };
         // handle the address encapsulation
         if (this.config.leader &&
             !this.address.protocol.includes(this.config.leader.protocol)) {
@@ -258,17 +317,13 @@ export class oNode extends oToolBase {
         this.p2pNode = await createNode(params);
         return this.p2pNode;
     }
-    async connect(nextHopAddress, targetAddress) {
+    async connect(config) {
         if (!this.connectionManager) {
             this.logger.error('Connection manager not initialized');
             throw new Error('Node is not ready to connect to other nodes');
         }
         const connection = await this.connectionManager
-            .connect({
-            address: targetAddress,
-            nextHopAddress,
-            callerAddress: this.address,
-        })
+            .connect(config)
             .catch((error) => {
             // TODO: we need to handle this better and document
             if (error.message === 'Can not dial self') {
@@ -281,6 +336,28 @@ export class oNode extends oToolBase {
         }
         return connection;
     }
+    async initConnectionManager() {
+        this.connectionManager = new oNodeConnectionManager({
+            p2pNode: this.p2pNode,
+            defaultReadTimeoutMs: this.config.connectionTimeouts?.readTimeoutMs,
+            defaultDrainTimeoutMs: this.config.connectionTimeouts?.drainTimeoutMs,
+            runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
+        });
+    }
+    async hookInitializeFinished() { }
+    async hookStartFinished() {
+        // Initialize connection health monitor
+        this.connectionHeartbeatManager = new oConnectionHeartbeatManager(this, {
+            enabled: this.config.connectionHeartbeat?.enabled ?? true,
+            intervalMs: this.config.connectionHeartbeat?.intervalMs ?? 15000,
+            failureThreshold: this.config.connectionHeartbeat?.failureThreshold ?? 3,
+            checkChildren: this.config.connectionHeartbeat?.checkChildren ?? false,
+            checkParent: this.config.connectionHeartbeat?.checkParent ?? true,
+            checkLeader: true,
+        });
+        this.logger.info(`Connection heartbeat config: leader=${this.connectionHeartbeatManager.getConfig().checkLeader}, ` +
+            `parent=${this.connectionHeartbeatManager.getConfig().checkParent}`);
+    }
     async initialize() {
         this.logger.debug('Initializing node...');
         if (this.p2pNode && this.state !== NodeState.STOPPED) {
@@ -297,19 +374,7 @@ export class oNode extends oToolBase {
         this.address.setTransports(this.transports);
         this.peerId = this.p2pNode.peerId;
         // initialize connection manager
-        this.connectionManager = new oNodeConnectionManager({
-            p2pNode: this.p2pNode,
-        });
-        // Initialize leader request wrapper
-        this.leaderRequestWrapper = new LeaderRequestWrapper({
-            enabled: this.config.leaderRetry?.enabled ?? true,
-            maxAttempts: this.config.leaderRetry?.maxAttempts ?? 20,
-            baseDelayMs: this.config.leaderRetry?.baseDelayMs ?? 2000,
-            maxDelayMs: this.config.leaderRetry?.maxDelayMs ?? 30000,
-            timeoutMs: this.config.leaderRetry?.timeoutMs ?? 10000,
-        });
-        this.logger.info(`Leader retry config: enabled=${this.leaderRequestWrapper.getConfig().enabled}, ` +
-            `maxAttempts=${this.leaderRequestWrapper.getConfig().maxAttempts}`);
+        await this.initConnectionManager();
         // initialize address resolution
         this.router.addResolver(new oMethodResolver(this.address));
         this.router.addResolver(new oNodeResolver(this.address));
@@ -318,38 +383,34 @@ export class oNode extends oToolBase {
             this.logger.debug('Adding leader resolver fallback...');
             this.router.addResolver(new oLeaderResolverFallback(this.address));
         }
-        // Read ENABLE_LEADER_HEARTBEAT environment variable
-        const enableLeaderHeartbeat = process.env.ENABLE_LEADER_HEARTBEAT === 'true';
-        // Initialize connection heartbeat manager
-        this.connectionHeartbeatManager = new oConnectionHeartbeatManager(this.p2pNode, this.hierarchyManager, this.notificationManager, this.address, {
-            enabled: this.config.connectionHeartbeat?.enabled ?? true,
-            intervalMs: this.config.connectionHeartbeat?.intervalMs ?? 15000,
-            timeoutMs: this.config.connectionHeartbeat?.timeoutMs ?? 5000,
-            failureThreshold: this.config.connectionHeartbeat?.failureThreshold ?? 3,
-            checkChildren: this.config.connectionHeartbeat?.checkChildren ?? true,
-            checkParent: this.config.connectionHeartbeat?.checkParent ?? true,
-            checkLeader: this.config.connectionHeartbeat?.checkLeader ?? enableLeaderHeartbeat,
+        this.reconnectionManager = new oReconnectionManager(this, {
+            enabled: true,
+            maxAttempts: 10,
+            baseDelayMs: 5000,
+            maxDelayMs: 20000,
+            useLeaderFallback: true,
+            parentDiscoveryIntervalMs: 5000,
+            parentDiscoveryMaxDelayMs: 20000,
         });
-        this.logger.info(`Connection heartbeat config: leader=${this.connectionHeartbeatManager.getConfig().checkLeader}, ` +
-            `parent=${this.connectionHeartbeatManager.getConfig().checkParent}`);
-        // Initialize reconnection manager
-        if (this.config.reconnection?.enabled !== false) {
-            this.reconnectionManager = new oReconnectionManager(this, {
-                enabled: true,
-                maxAttempts: this.config.reconnection?.maxAttempts ?? 10,
-                baseDelayMs: this.config.reconnection?.baseDelayMs ?? 5000,
-                maxDelayMs: this.config.reconnection?.maxDelayMs ?? 60000,
-                useLeaderFallback: this.config.reconnection?.useLeaderFallback ?? true,
-            });
-        }
+        await this.hookInitializeFinished();
     }
     /**
      * Override use() to wrap leader/registry requests with retry logic
      */
-    async use(address, data) {
-        // Wrap leader/registry requests with retry logic
-        return this.leaderRequestWrapper.execute(() => super.use(address, data), address, data?.method);
-    }
+    // async use(
+    //   address: oAddress,
+    //   data?: {
+    //     method?: string;
+    //     params?: { [key: string]: any };
+    //     id?: string;
+    //   },
+    //   options?: UseOptions,
+    // ): Promise<any> {
+    //   // Wrap leader/registry requests with retry logic
+    //   return super.use(address, data, options),
+    //     address,
+    //     data?.method,
+    // }
     async teardown() {
         // Stop heartbeat before parent teardown
         if (this.connectionHeartbeatManager) {
@@ -361,4 +422,98 @@ export class oNode extends oToolBase {
             await this.p2pNode.stop();
         }
     }
+    // IHeartbeatableNode interface methods
+    getLeaders() {
+        return [this.leader];
+    }
+    getParents() {
+        return this.hierarchyManager.getParents();
+    }
+    getChildren() {
+        return this.hierarchyManager.getChildren();
+    }
+    removeChild(childAddress) {
+        this.hierarchyManager.removeChild(childAddress);
+    }
+    /**
+     * Get the total number of active streams across all connections
+     * @returns Total count of active streams
+     */
+    getStreamCount() {
+        if (!this.p2pNode) {
+            return 0;
+        }
+        const connections = this.p2pNode.getConnections();
+        return connections.reduce((count, conn) => {
+            return count + (conn.streams?.length || 0);
+        }, 0);
+    }
+    /**
+     * Get libp2p metrics for this node
+     * Tool method that can be called remotely by monitoring systems
+     */
+    async _tool_get_libp2p_metrics(request) {
+        if (!this.p2pNode) {
+            return {
+                error: 'libp2p node not available',
+                available: false,
+            };
+        }
+        try {
+            // Get basic connection stats
+            const connections = this.p2pNode.getConnections();
+            const peers = await this.p2pNode.peerStore.all();
+            const inbound = connections.filter((c) => c.direction === 'inbound').length;
+            const outbound = connections.filter((c) => c.direction === 'outbound').length;
+            // Get DHT info if available
+            const services = this.p2pNode.services;
+            const dht = services?.dht;
+            const routingTable = dht?.routingTable;
+            const kBuckets = routingTable?.kb || null;
+            let routingTableSize = 0;
+            if (kBuckets) {
+                // Handle both array and object-like structures
+                if (Array.isArray(kBuckets)) {
+                    for (const bucket of kBuckets) {
+                        routingTableSize += bucket.peers?.length || 0;
+                    }
+                }
+                else if (typeof kBuckets === 'object') {
+                    // If it's an object, iterate over its values
+                    for (const bucket of Object.values(kBuckets)) {
+                        routingTableSize += bucket?.peers?.length || 0;
+                    }
+                }
+            }
+            // Calculate total stream count across all connections
+            const streamCount = connections.reduce((count, conn) => {
+                return count + (conn.streams?.length || 0);
+            }, 0);
+            return {
+                available: true,
+                timestamp: Date.now(),
+                nodeAddress: this.address.toString(),
+                peerCount: peers.length,
+                connectionCount: connections.length,
+                inboundConnections: inbound,
+                outboundConnections: outbound,
+                streamCount,
+                dhtEnabled: !!dht,
+                dhtMode: dht?.clientMode ? 'client' : 'server',
+                dhtRoutingTableSize: routingTableSize,
+                protocols: Array.from(this.p2pNode.getProtocols()),
+                selfPeerId: this.p2pNode.peerId.toString(),
+                multiaddrs: this.p2pNode
+                    .getMultiaddrs()
+                    .map((ma) => ma.toString()),
+            };
+        }
+        catch (error) {
+            return {
+                error: `Failed to collect libp2p metrics: ${error.message}`,
+                available: false,
+                nodeAddress: this.address.toString(),
+            };
+        }
+    }
 }

package/dist/src/o-node.notification-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.notification-manager.d.ts","sourceRoot":"","sources":["../../src/o-node.notification-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,oBAAoB,EAQrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,oBAAoB;IAE9D,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,OAAO;gBAFP,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,qBAAqB,EACvC,OAAO,EAAE,YAAY;IAK/B;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAiBhC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAkD5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAK5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAkCvB;;OAEG;IACH,OAAO,CAAC,OAAO;IAMf;;OAEG;IACH,OAAO,CAAC,QAAQ;CAKjB"}
+{"version":3,"file":"o-node.notification-manager.d.ts","sourceRoot":"","sources":["../../src/o-node.notification-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,oBAAoB,EAQrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,oBAAoB;IAE9D,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,OAAO;gBAFP,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,qBAAqB,EACvC,OAAO,EAAE,YAAY;IAK/B;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAgChC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAkCvB;;OAEG;IACH,OAAO,CAAC,OAAO;IAMf;;OAEG;IACH,OAAO,CAAC,QAAQ;CAKjB"}

package/dist/src/o-node.notification-manager.js

@@ -17,7 +17,10 @@ export class oNodeNotificationManager extends oNotificationManager {
         this.logger.debug('Setting up libp2p event listeners...');
         // Peer connection events
         this.p2pNode.addEventListener('peer:connect', this.handlePeerConnect.bind(this));
-        this.p2pNode.addEventListener('peer:disconnect', this.handlePeerDisconnect.bind(this));
+        // this.p2pNode.addEventListener(
+        //   'peer:disconnect',
+        //   this.handlePeerDisconnect.bind(this),
+        // );
         // Peer discovery events
         this.p2pNode.addEventListener('peer:discovery', this.handlePeerDiscovery.bind(this));
         // Connection events
@@ -30,11 +33,13 @@ export class oNodeNotificationManager extends oNotificationManager {
      */
     handlePeerConnect(evt) {
         const peerId = evt.detail;
-        this.logger.debug(`Peer connected: ${peerId.toString()}`);
+        // this.logger.debug(`Peer connected: ${peerId.toString()}`);
         // Try to resolve peer ID to Olane address
         const nodeAddress = this.peerIdToAddress(peerId.toString());
         if (!nodeAddress) {
-            this.logger.debug(`Could not resolve peer ID ${peerId.toString()} to address`);
+            // this.logger.debug(
+            //   `Could not resolve peer ID ${peerId.toString()} to address`,
+            // );
             return;
         }
         // Emit generic node connected event
@@ -48,7 +53,7 @@ export class oNodeNotificationManager extends oNotificationManager {
         }));
         // Check if this is a child node
         if (this.isChild(nodeAddress)) {
-            this.logger.debug(`Child node connected: ${nodeAddress.toString()}`);
+            // this.logger.debug(`Child node connected: ${nodeAddress.toString()}`);
             this.emit(new ChildJoinedEvent({
                 source: this.address,
                 childAddress: nodeAddress,
@@ -57,7 +62,7 @@ export class oNodeNotificationManager extends oNotificationManager {
         }
         // Check if this is a parent node
         if (this.isParent(nodeAddress)) {
-            this.logger.debug(`Parent node connected: ${nodeAddress.toString()}`);
+            // this.logger.debug(`Parent node connected: ${nodeAddress.toString()}`);
             this.emit(new ParentConnectedEvent({
                 source: this.address,
                 parentAddress: nodeAddress,
@@ -69,11 +74,13 @@ export class oNodeNotificationManager extends oNotificationManager {
      */
     handlePeerDisconnect(evt) {
         const peerId = evt.detail;
-        this.logger.debug(`Peer disconnected: ${peerId.toString()}`);
+        // this.logger.debug(`Peer disconnected: ${peerId.toString()}`);
         // Try to resolve peer ID to Olane address
         const nodeAddress = this.peerIdToAddress(peerId.toString());
         if (!nodeAddress) {
-            this.logger.debug(`Could not resolve peer ID ${peerId.toString()} to address`);
+            // this.logger.debug(
+            //   `Could not resolve peer ID ${peerId.toString()} to address`,
+            // );
             return;
         }
         // Emit generic node disconnected event
@@ -109,7 +116,7 @@ export class oNodeNotificationManager extends oNotificationManager {
      */
     handlePeerDiscovery(evt) {
         const peerInfo = evt.detail;
-        this.logger.debug(`Peer discovered: ${peerInfo.id.toString()}`);
+        // this.logger.debug(`Peer discovered: ${peerInfo.id.toString()}`);
         // Try to resolve peer ID to Olane address
         const nodeAddress = this.peerIdToAddress(peerInfo.id.toString());
         if (!nodeAddress) {
@@ -124,15 +131,13 @@ export class oNodeNotificationManager extends oNotificationManager {
      * Handle connection open event from libp2p
      */
     handleConnectionOpen(evt) {
-        const remotePeer = evt.detail.remotePeer;
-        this.logger.debug(`Connection opened to: ${remotePeer.toString()}`);
+        // do nothing for now
     }
     /**
      * Handle connection close event from libp2p
      */
     handleConnectionClose(evt) {
-        const remotePeer = evt.detail.remotePeer;
-        this.logger.debug(`Connection closed to: ${remotePeer.toString()}`);
+        // do nothing for now
     }
     /**
      * Try to resolve a libp2p peer ID to an Olane address

package/dist/src/o-node.tool.d.ts

@@ -8,6 +8,7 @@ declare const oNodeTool_base: typeof oServerNode;
  * @returns A new class that extends the base class and implements the oTool interface
  */
 export declare class oNodeTool extends oNodeTool_base {
+    private streamHandler;
     handleProtocol(address: oAddress): Promise<void>;
     initialize(): Promise<void>;
     handleStream(stream: Stream, connection: Connection): Promise<void>;

package/dist/src/o-node.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAGR,QAAQ,EAGT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAIrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IACzC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAQhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDnE,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CA2B5D"}
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,QAAQ,EAET,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAKrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAUhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BnE,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CA2B5D"}

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

@@ -1,8 +1,9 @@
-import { CoreUtils, oError, oErrorCodes, oRequest, ChildJoinedEvent, } from '@olane/o-core';
+import { ChildJoinedEvent, } from '@olane/o-core';
 import { oTool } from '@olane/o-tool';
 import { oServerNode } from './nodes/server.node.js';
 import { oNodeTransport } from './router/o-node.transport.js';
 import { oNodeAddress } from './router/o-node.address.js';
+import { StreamHandler } from './connection/stream-handler.js';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
  * @param Base - The base class to extend
@@ -12,12 +13,15 @@ export class oNodeTool extends oTool(oServerNode) {
     async handleProtocol(address) {
         this.logger.debug('Handling protocol: ' + address.protocol);
         await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
-            maxInboundStreams: Infinity,
-            maxOutboundStreams: Infinity,
+            maxInboundStreams: 10000,
+            maxOutboundStreams: process.env.MAX_OUTBOUND_STREAMS
+                ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
+                : 1000,
         });
     }
     async initialize() {
         await super.initialize();
+        this.streamHandler = new StreamHandler(this.logger);
         await this.handleProtocol(this.address);
         if (this.staticAddress &&
             this.staticAddress?.toString() !== this.address.toString()) {
@@ -25,40 +29,20 @@ export class oNodeTool extends oTool(oServerNode) {
         }
     }
     async handleStream(stream, connection) {
-        // CRITICAL: Attach message listener immediately to prevent buffer overflow (libp2p v3)
-        // Per libp2p migration guide: "If no message event handler is added, streams will
-        // buffer incoming data until a pre-configured limit is reached, after which the stream will be reset."
-        const messageHandler = async (event) => {
-            if (!event.data) {
-                this.logger.warn('Malformed event data');
-                return;
+        this.logger.debug('Handling connection: ', connection.id);
+        // Use StreamHandler for consistent stream handling
+        // This follows libp2p v3 best practices for immediate message listener attachment
+        await this.streamHandler.handleIncomingStream(stream, connection, async (request, stream) => {
+            try {
+                const result = await this.execute(request, stream);
+                // Return the raw result - StreamHandler will build and send the response
+                return result;
             }
-            const requestConfig = await CoreUtils.processStream(event);
-            const request = new oRequest(requestConfig);
-            let success = true;
-            const result = await this.execute(request, stream).catch((error) => {
+            catch (error) {
                 this.logger.error('Error executing tool: ', request.toString(), error, typeof error);
-                success = false;
-                const responseError = error instanceof oError
-                    ? error
-                    : new oError(oErrorCodes.UNKNOWN, error.message);
-                return {
-                    error: responseError.toJSON(),
-                };
-            });
-            if (success) {
-                this.metrics.successCount++;
+                throw error; // StreamHandler will handle error response building
             }
-            else {
-                this.metrics.errorCount++;
-            }
-            // compose the response & add the expected connection + request fields
-            const response = CoreUtils.buildResponse(request, result, result?.error);
-            // add the request method to the response
-            await CoreUtils.sendResponse(response, stream);
-        };
-        // Attach listener synchronously before any async operations
-        stream.addEventListener('message', messageHandler);
+        });
     }
     async _tool_identify() {
         return {

package/dist/src/router/o-node.router.d.ts

@@ -17,6 +17,7 @@ export declare class oNodeRouter extends oToolRouter {
     protected forward(address: oNodeAddress, request: oRouterRequest, node: oNode): Promise<any>;
     /**
      * Executes a request locally when routing to self.
+     * Now uses ResponseBuilder for consistency with useSelf() behavior.
      */
     private executeSelfRouting;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA0Bf;;OAEG;YACW,kBAAkB;IAgBhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;OAEG;YACW,eAAe;IA2B7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAyB3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}
+{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EAGd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;OAGG;YACW,kBAAkB;IA8DhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAWhC;;OAEG;YACW,eAAe;IAsC7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAyB3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}