@olane/o-node 0.7.11 → 0.7.12-alpha.10

package/dist/src/managers/o-reconnection.manager.js

@@ -0,0 +1,255 @@
+import { oObject, oAddress, NodeState, } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { oNodeTransport } from '../router/o-node.transport.js';
+/**
+ * Reconnection Manager
+ *
+ * Automatically attempts to reconnect to parent when connection is lost.
+ *
+ * Strategy:
+ * 1. Listen for ParentDisconnectedEvent (from heartbeat or libp2p)
+ * 2. Attempt direct reconnection with exponential backoff
+ * 3. If direct reconnection fails, query leader for new parent
+ * 4. Register with new parent and continue operation
+ * 5. If all attempts fail, transition node to ERROR state
+ */
+export class oReconnectionManager extends oObject {
+    constructor(node, config) {
+        super();
+        this.node = node;
+        this.config = config;
+        this.reconnecting = false;
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        // Listen for parent disconnection (from heartbeat or libp2p)
+        this.node.notificationManager.on('parent:disconnected', this.handleParentDisconnected.bind(this));
+        // Listen for leader disconnection (from heartbeat)
+        this.node.notificationManager.on('leader:disconnected', this.handleLeaderDisconnected.bind(this));
+        // Listen for connection degradation as early warning
+        this.node.notificationManager.on('connection:degraded', this.handleConnectionDegraded.bind(this));
+    }
+    async handleConnectionDegraded(event) {
+        const degradedEvent = event;
+        if (degradedEvent.role !== 'parent')
+            return;
+        this.logger.warn(`Parent connection degraded: ${degradedEvent.targetAddress} ` +
+            `(failures: ${degradedEvent.consecutiveFailures})`);
+        // Could implement pre-emptive parent discovery here
+        // For now, just log the warning and wait for full disconnection
+    }
+    async handleLeaderDisconnected(event) {
+        const disconnectEvent = event;
+        this.logger.warn(`Leader disconnected: ${disconnectEvent.leaderAddress} (reason: ${disconnectEvent.reason})`);
+        // Don't attempt reconnection for leader - the LeaderRequestWrapper
+        // will handle retries automatically when we make requests
+        // Just log the event for observability
+        this.logger.info('Leader requests will use automatic retry mechanism (LeaderRequestWrapper)');
+    }
+    async handleParentDisconnected(event) {
+        const disconnectEvent = event;
+        if (this.reconnecting) {
+            this.logger.debug('Already reconnecting, ignoring duplicate event');
+            return;
+        }
+        this.logger.warn(`Parent disconnected: ${disconnectEvent.parentAddress} (reason: ${disconnectEvent.reason})`);
+        await this.attemptReconnection();
+    }
+    async attemptReconnection() {
+        if (!this.config.enabled) {
+            this.logger.warn('Reconnection disabled - node will remain disconnected');
+            return;
+        }
+        this.reconnecting = true;
+        let attempt = 0;
+        while (attempt < this.config.maxAttempts) {
+            attempt++;
+            this.logger.info(`Reconnection attempt ${attempt}/${this.config.maxAttempts} to parent: ${this.node.config.parent}`);
+            try {
+                // Strategy 1: Try direct parent reconnection
+                await this.tryDirectParentReconnection();
+                // Success!
+                this.reconnecting = false;
+                this.logger.info(`Successfully reconnected to parent after ${attempt} attempts`);
+                return;
+            }
+            catch (error) {
+                this.logger.warn(`Reconnection attempt ${attempt} failed:`, error instanceof Error ? error.message : error);
+                if (attempt < this.config.maxAttempts) {
+                    const delay = this.calculateBackoffDelay(attempt);
+                    this.logger.debug(`Waiting ${delay}ms before next attempt...`);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All direct attempts failed - try leader fallback
+        if (this.config.useLeaderFallback) {
+            await this.tryLeaderFallback();
+        }
+        else {
+            this.handleReconnectionFailure();
+        }
+    }
+    async tryDirectParentReconnection() {
+        if (!this.node.config.parent) {
+            throw new Error('No parent configured');
+        }
+        // Re-register with parent (might have new transports)
+        await this.node.registerParent();
+        // Verify connection works with a ping
+        await this.node.use(this.node.config.parent, {
+            method: 'ping',
+            params: {},
+        });
+        this.logger.info('Direct parent reconnection successful');
+    }
+    async tryLeaderFallback() {
+        // Check if parent is the leader - special case
+        const parentIsLeader = this.node.config.parent?.toString() === oAddress.leader().toString();
+        if (parentIsLeader) {
+            this.logger.info('Parent is the leader - waiting for leader to become available');
+            await this.waitForLeaderAndReconnect();
+        }
+        else {
+            this.logger.info('Starting infinite parent discovery via leader registry');
+            await this.waitForParentAndReconnect();
+        }
+    }
+    /**
+     * Wait for leader to become available and reconnect
+     * Leader transports are static (configured), so we just need to detect when it's back
+     */
+    async waitForLeaderAndReconnect() {
+        const startTime = Date.now();
+        let attempt = 0;
+        let currentDelay = this.config.parentDiscoveryIntervalMs;
+        // Infinite retry loop - keep trying until leader is back
+        while (true) {
+            attempt++;
+            const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
+            this.logger.info(`Leader discovery attempt ${attempt} (elapsed: ${elapsedMinutes}m)`);
+            try {
+                // Try to ping the leader using its configured transports
+                // The leader address should already have transports configured
+                await this.node.use(this.node.config.parent, {
+                    method: 'ping',
+                    params: {},
+                });
+                // Leader is back! Now re-register with parent and registry
+                this.logger.info(`Leader is back online after ${elapsedMinutes}m, re-registering...`);
+                try {
+                    // Register with parent (leader)
+                    await this.node.registerParent();
+                    // Force re-registration with registry by resetting the flag
+                    this.node.didRegister = false;
+                    await this.node.register();
+                    // Success!
+                    this.reconnecting = false;
+                    this.logger.info(`Successfully reconnected to leader and re-registered after ${elapsedMinutes}m`);
+                    return;
+                }
+                catch (registrationError) {
+                    this.logger.warn('Leader online but registration failed, will retry:', registrationError instanceof Error
+                        ? registrationError.message
+                        : registrationError);
+                    // Fall through to retry with backoff
+                }
+            }
+            catch (error) {
+                // Leader not yet available
+                this.logger.debug(`Leader not yet available (will retry): ${error instanceof Error ? error.message : error}`);
+            }
+            // Calculate backoff delay
+            const delay = Math.min(currentDelay, this.config.parentDiscoveryMaxDelayMs);
+            // Log periodic status updates (every 5 minutes)
+            if (attempt % 30 === 0) {
+                this.logger.info(`Still waiting for leader to come back online... (${elapsedMinutes}m elapsed, ${attempt} attempts)`);
+            }
+            this.logger.debug(`Waiting ${delay}ms before next discovery attempt...`);
+            await this.sleep(delay);
+            // Exponential backoff for next iteration
+            currentDelay = Math.min(currentDelay * 2, this.config.parentDiscoveryMaxDelayMs);
+        }
+    }
+    /**
+     * Wait for non-leader parent to appear in registry and reconnect
+     */
+    async waitForParentAndReconnect() {
+        const startTime = Date.now();
+        let attempt = 0;
+        let currentDelay = this.config.parentDiscoveryIntervalMs;
+        // Infinite retry loop - keep trying until parent is found
+        while (true) {
+            attempt++;
+            const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
+            this.logger.info(`Parent discovery attempt ${attempt} (elapsed: ${elapsedMinutes}m)`);
+            try {
+                // Query registry for parent by its known address
+                const response = await this.node.use(new oAddress('o://registry'), {
+                    method: 'find_available_parent',
+                    params: {
+                        parentAddress: this.node.config.parent?.toString(),
+                    },
+                });
+                const { parentAddress, parentTransports } = response.result.data;
+                // Check if parent was found in registry
+                if (parentAddress && parentTransports && parentTransports.length > 0) {
+                    this.logger.info(`Parent found in registry: ${parentAddress} with ${parentTransports.length} transports`);
+                    // Update parent reference with fresh transports
+                    this.node.config.parent = new oNodeAddress(parentAddress, parentTransports.map((t) => new oNodeTransport(t)));
+                    // Attempt to register with parent and re-register with registry
+                    try {
+                        await this.tryDirectParentReconnection();
+                        // Force re-registration with registry by resetting the flag
+                        this.node.didRegister = false;
+                        await this.node.register();
+                        // Success!
+                        this.reconnecting = false;
+                        this.logger.info(`Successfully reconnected to parent and re-registered after ${elapsedMinutes}m of discovery attempts`);
+                        return;
+                    }
+                    catch (registrationError) {
+                        this.logger.warn('Parent found but registration failed, will retry:', registrationError instanceof Error
+                            ? registrationError.message
+                            : registrationError);
+                        // Fall through to retry with backoff
+                    }
+                }
+                else {
+                    this.logger.debug(`Parent not yet available in registry: ${this.node.config.parent?.toString()}`);
+                }
+            }
+            catch (error) {
+                // Network error communicating with leader/registry
+                this.logger.warn('Error querying registry for parent (will retry):', error instanceof Error ? error.message : error);
+            }
+            // Calculate backoff delay with exponential increase, capped at max
+            const delay = Math.min(currentDelay, this.config.parentDiscoveryMaxDelayMs);
+            // Log periodic status updates (every 5 minutes)
+            if (attempt % 30 === 0) {
+                this.logger.info(`Still waiting for parent to appear in registry... (${elapsedMinutes}m elapsed, ${attempt} attempts)`);
+            }
+            this.logger.debug(`Waiting ${delay}ms before next discovery attempt...`);
+            await this.sleep(delay);
+            // Exponential backoff for next iteration
+            currentDelay = Math.min(currentDelay * 2, this.config.parentDiscoveryMaxDelayMs);
+        }
+    }
+    handleReconnectionFailure() {
+        this.reconnecting = false;
+        this.logger.error('Failed to reconnect to parent after all attempts - node in ERROR state');
+        // Transition to error state
+        this.node.state = NodeState.ERROR;
+        // Could emit custom event here for monitoring
+    }
+    calculateNodeLevel() {
+        return this.node.address.paths.length;
+    }
+    calculateBackoffDelay(attempt) {
+        const delay = this.config.baseDelayMs * Math.pow(2, attempt - 1);
+        return Math.min(delay, this.config.maxDelayMs);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

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

@@ -3,11 +3,14 @@ import { PeerId } from '@olane/o-config';
 import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
 import { oNodeConfig } from './interfaces/o-node.config.js';
 import { oNodeTransport } from './router/o-node.transport.js';
-import { oRequest } from '@olane/o-core';
+import { oAddress, oRequest, oNotificationManager } from '@olane/o-core';
 import { oNodeAddress } from './router/o-node.address.js';
 import { oNodeConnection } from './connection/o-node-connection.js';
 import { oNodeConnectionManager } from './connection/o-node-connection.manager.js';
 import { oToolBase } from '@olane/o-tool';
+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 declare class oNode extends oToolBase {
     peerId: PeerId;
     p2pNode: Libp2p;
@@ -15,6 +18,9 @@ export declare class oNode extends oToolBase {
     config: oNodeConfig;
     connectionManager: oNodeConnectionManager;
     hierarchyManager: oNodeHierarchyManager;
+    connectionHeartbeatManager?: oConnectionHeartbeatManager;
+    reconnectionManager?: oReconnectionManager;
+    leaderRequestWrapper: LeaderRequestWrapper;
     protected didRegister: boolean;
     constructor(config: oNodeConfig);
     get leader(): oNodeAddress | null;
@@ -22,6 +28,7 @@ export declare class oNode extends oToolBase {
     get parentPeerId(): string | null;
     configureTransports(): any[];
     initializeRouter(): Promise<void>;
+    protected createNotificationManager(): oNotificationManager;
     get staticAddress(): oNodeAddress;
     get parentTransports(): oNodeTransport[];
     get transports(): oNodeTransport[];
@@ -39,6 +46,16 @@ export declare class oNode extends oToolBase {
     protected createNode(): Promise<Libp2p>;
     connect(nextHopAddress: oNodeAddress, targetAddress: oNodeAddress): Promise<oNodeConnection>;
     initialize(): Promise<void>;
+    /**
+     * Override use() to wrap leader/registry requests with retry logic
+     */
+    use(address: oAddress, data?: {
+        method?: string;
+        params?: {
+            [key: string]: any;
+        };
+        id?: string;
+    }): Promise<any>;
     teardown(): Promise<void>;
 }
 //# sourceMappingURL=o-node.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAKL,QAAQ,EAET,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAI3D,qBAAa,KAAM,SAAQ,SAAS;IAC3B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,MAAM,CAAC;IACjB,OAAO,EAAG,YAAY,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAG,sBAAsB,CAAC;IAC3C,gBAAgB,EAAG,qBAAqB,CAAC;IAChD,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,WAAW;IAK/B,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;IAED,IAAI,aAAa,IAAI,YAAY,CAKhC;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAOhC;IAED,mBAAmB,IAAI,GAAG,EAAE;IAItB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IASvC,IAAI,aAAa,IAAI,YAAY,CAEhC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,UAAU,IAAI,cAAc,EAAE,CAIjC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB3B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAItC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAG1D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;cA0FxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMvC,OAAO,CACX,cAAc,EAAE,YAAY,EAC5B,aAAa,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC;IA0BrB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoC3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAOhC"}
+{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAIL,QAAQ,EACR,QAAQ,EAER,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qBAAa,KAAM,SAAQ,SAAS;IAC3B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,MAAM,CAAC;IACjB,OAAO,EAAG,YAAY,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAG,sBAAsB,CAAC;IAC3C,gBAAgB,EAAG,qBAAqB,CAAC;IACzC,0BAA0B,CAAC,EAAE,2BAA2B,CAAC;IACzD,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,oBAAoB,EAAG,oBAAoB,CAAC;IACnD,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,WAAW;IAK/B,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;IAED,IAAI,aAAa,IAAI,YAAY,CAKhC;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAOhC;IAED,mBAAmB,IAAI,GAAG,EAAE;IAItB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IASvC,SAAS,CAAC,yBAAyB,IAAI,oBAAoB;IAQ3D,IAAI,aAAa,IAAI,YAAY,CAEhC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,UAAU,IAAI,cAAc,EAAE,CAIjC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsD3B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAItC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAG1D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;cA0FxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMvC,OAAO,CACX,cAAc,EAAE,YAAY,EAC5B,aAAa,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC;IA0BrB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+FjC;;OAEG;IACG,GAAG,CACP,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC;IAST,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/src/o-node.js

@@ -9,6 +9,10 @@ import { oNodeConnectionManager } from './connection/o-node-connection.manager.j
 import { oNodeResolver } from './router/resolvers/o-node.resolver.js';
 import { oMethodResolver, oToolBase } from '@olane/o-tool';
 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);
@@ -43,6 +47,9 @@ export class oNode extends oToolBase {
         });
         this.router = new oNodeRouter();
     }
+    createNotificationManager() {
+        return new oNodeNotificationManager(this.p2pNode, this.hierarchyManager, this.address);
+    }
     get staticAddress() {
         return this.config.address;
     }
@@ -60,6 +67,30 @@ export class oNode extends oToolBase {
             this.logger.debug('Skipping unregistration, node is leader');
             return;
         }
+        // Notify parent we're stopping (best-effort, 2s timeout)
+        if (this.config.parent) {
+            try {
+                await Promise.race([
+                    this.use(this.config.parent, {
+                        method: 'notify',
+                        params: {
+                            eventType: 'node:stopping',
+                            eventData: {
+                                address: this.address.toString(),
+                                reason: 'graceful_shutdown',
+                                expectedDowntime: null,
+                            },
+                            source: this.address.toString(),
+                        },
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 2000)),
+                ]);
+                this.logger.debug('Notified parent of shutdown');
+            }
+            catch (error) {
+                this.logger.warn('Failed to notify parent (will be detected by heartbeat):', error instanceof Error ? error.message : error);
+            }
+        }
         if (!this.config.leader) {
             this.logger.debug('No leader found, skipping unregistration');
             return;
@@ -136,6 +167,10 @@ export class oNode extends oToolBase {
     }
     async start() {
         await super.start();
+        // Start heartbeat after node is running
+        if (this.connectionHeartbeatManager) {
+            await this.connectionHeartbeatManager.start();
+        }
         // await NetworkUtils.advertiseToNetwork(
         //   this.address,
         //   this.staticAddress,
@@ -256,6 +291,8 @@ export class oNode extends oToolBase {
         }
         await this.createNode();
         await this.initializeRouter();
+        // need to wait until our libpp2 node is initialized before calling super.initialize
+        await super.initialize();
         this.logger.debug('Node initialized!', this.transports.map((t) => t.toString()));
         this.address.setTransports(this.transports);
         this.peerId = this.p2pNode.peerId;
@@ -263,6 +300,16 @@ export class oNode extends oToolBase {
         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}`);
         // initialize address resolution
         this.router.addResolver(new oMethodResolver(this.address));
         this.router.addResolver(new oNodeResolver(this.address));
@@ -271,8 +318,46 @@ 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 = this.parent?.toString() === oAddress.leader().toString();
+        this.logger.debug(`Enable leader heartbeat: ${enableLeaderHeartbeat}`);
+        // 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: enableLeaderHeartbeat,
+        });
+        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,
+                parentDiscoveryIntervalMs: this.config.reconnection?.parentDiscoveryIntervalMs ?? 10000,
+                parentDiscoveryMaxDelayMs: this.config.reconnection?.parentDiscoveryMaxDelayMs ?? 60000,
+            });
+        }
+    }
+    /**
+     * 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 teardown() {
+        // Stop heartbeat before parent teardown
+        if (this.connectionHeartbeatManager) {
+            await this.connectionHeartbeatManager.stop();
+        }
         await this.unregister();
         await super.teardown();
         if (this.p2pNode) {

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

@@ -0,0 +1,52 @@
+import { Libp2p } from '@olane/o-config';
+import { oNotificationManager } from '@olane/o-core';
+import { oNodeAddress } from './router/o-node.address.js';
+import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
+/**
+ * libp2p-specific implementation of oNotificationManager
+ * Wraps libp2p events and enriches them with Olane context
+ */
+export declare class oNodeNotificationManager extends oNotificationManager {
+    private p2pNode;
+    private hierarchyManager;
+    private address;
+    constructor(p2pNode: Libp2p, hierarchyManager: oNodeHierarchyManager, address: oNodeAddress);
+    /**
+     * Wire up libp2p event listeners
+     */
+    protected setupListeners(): void;
+    /**
+     * Handle peer connect event from libp2p
+     */
+    private handlePeerConnect;
+    /**
+     * Handle peer disconnect event from libp2p
+     */
+    private handlePeerDisconnect;
+    /**
+     * Handle peer discovery event from libp2p
+     */
+    private handlePeerDiscovery;
+    /**
+     * Handle connection open event from libp2p
+     */
+    private handleConnectionOpen;
+    /**
+     * Handle connection close event from libp2p
+     */
+    private handleConnectionClose;
+    /**
+     * Try to resolve a libp2p peer ID to an Olane address
+     * Checks hierarchy manager for known peers
+     */
+    private peerIdToAddress;
+    /**
+     * Check if an address is a direct child
+     */
+    private isChild;
+    /**
+     * Check if an address is a parent
+     */
+    private isParent;
+}
+//# sourceMappingURL=o-node.notification-manager.d.ts.map

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

@@ -0,0 +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;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"}