@olane/o-node 0.7.53 → 0.7.55

package/dist/src/connection/o-node-stream.manager.js

@@ -5,6 +5,7 @@ import { StreamManagerEvent, } from './stream-manager.events.js';
 import { isStreamInitMessage, } from './interfaces/stream-init-message.js';
 import { lpStream } from '@olane/o-config';
 import JSON5 from 'json5';
+import { v4 as uuidv4 } from 'uuid';
 /**
  * oNodeStreamManager handles the lifecycle and tracking of streams for a single connection.
  * Features:
@@ -16,12 +17,15 @@ import JSON5 from 'json5';
  */
 export class oNodeStreamManager extends oObject {
     constructor(config) {
-        super();
+        const id = uuidv4();
+        super('id:' + id);
         this.config = config;
         this.streams = new Map();
         this.eventEmitter = new EventEmitter();
         this.isInitialized = false;
         this.activeStreamHandlers = new Map();
+        this.streamMonitoringIntervals = new Map(); // Track monitoring intervals
+        this.id = id;
         this.p2pConnection = config.p2pConnection;
     }
     /**
@@ -59,17 +63,20 @@ export class oNodeStreamManager extends oObject {
      * @returns Wrapped stream
      */
     async getOrCreateStream(protocol, remoteAddress, config = {}) {
-        this.logger.debug('Getting or creating stream', this.callerReaderStream?.protocol, 'and status', this.callerReaderStream?.status);
+        this.logger.debug('Getting or creating stream', this.callerReaderStream?.protocol, 'and status', this.callerReaderStream?.status, 'json:', JSON.stringify(this.callerReaderStream));
         // If we have a caller's reader stream (from limited connection), use it for sending requests
         if (this.callerReaderStream && this.callerReaderStream.status === 'open') {
             this.logger.debug('Using caller reader stream for limited connection', {
                 streamId: this.callerReaderStream.id,
             });
+            // TODO: figure out why this would cause the node stream to be closed?
             // Wrap the reader stream for use (if not already wrapped)
-            const existingWrapped = Array.from(this.streams.values()).find((s) => s.p2pStream.id === this.callerReaderStream.id);
-            if (existingWrapped) {
-                return existingWrapped;
-            }
+            // const existingWrapped = Array.from(this.streams.values()).find(
+            //   (s) => s.p2pStream.id === this.callerReaderStream!.id,
+            // );
+            // if (existingWrapped) {
+            //   return existingWrapped;
+            // }
             // Wrap the reader stream
             const wrappedStream = new oNodeStream(this.callerReaderStream, {
                 direction: 'inbound', // It's inbound to us, we write to it
@@ -77,7 +84,7 @@ export class oNodeStreamManager extends oObject {
                 remoteAddress: remoteAddress,
                 streamType: 'request-response',
             });
-            this.streams.set(this.callerReaderStream.id, wrappedStream);
+            // this.streams.set(this.callerReaderStream.id, wrappedStream);
             return wrappedStream;
         }
         // Always create new stream (no reuse at base layer)
@@ -100,7 +107,7 @@ export class oNodeStreamManager extends oObject {
         const stream = await this.p2pConnection.newStream(protocol, {
             signal: config.signal,
             maxOutboundStreams: config.maxOutboundStreams ?? 1000,
-            runOnLimitedConnection: config.runOnLimitedConnection ?? false,
+            runOnLimitedConnection: config.runOnLimitedConnection ?? true,
         });
         // Wrap in oNodeStream with metadata
         const wrappedStream = new oNodeStream(stream, {
@@ -157,6 +164,72 @@ export class oNodeStreamManager extends oObject {
     getAllStreams() {
         return Array.from(this.streams.values());
     }
+    /**
+     * Gets a stream by its ID
+     * Checks persistent caller streams (reader/writer) and tracked streams
+     *
+     * @param streamId - The ID of the stream to retrieve
+     * @returns The libp2p Stream or undefined if not found
+     */
+    getStreamById(streamId) {
+        // Check caller writer stream
+        if (this.callerWriterStream?.id === streamId) {
+            return this.callerWriterStream;
+        }
+        // Check caller reader stream
+        if (this.callerReaderStream?.id === streamId) {
+            return this.callerReaderStream;
+        }
+        // Check tracked streams
+        const wrappedStream = this.streams.get(streamId);
+        return wrappedStream?.p2pStream;
+    }
+    /**
+     * Sets up monitoring for stream closure and emits events when detected
+     * Periodically checks stream status and cleans up when stream closes
+     *
+     * @param stream - The stream to monitor
+     * @param role - The role of the stream ('reader' or 'writer')
+     */
+    setupStreamCloseMonitoring(stream, role) {
+        const streamId = stream.id;
+        // Clear any existing monitoring for this stream
+        const existingInterval = this.streamMonitoringIntervals.get(streamId);
+        if (existingInterval) {
+            clearInterval(existingInterval);
+        }
+        // Check stream status every 5 seconds
+        const interval = setInterval(() => {
+            if (stream.status !== 'open') {
+                this.logger.info(`Caller ${role} stream closed`, {
+                    streamId,
+                    status: stream.status,
+                    role,
+                });
+                // Emit stream closed event
+                this.emit(StreamManagerEvent.StreamClosed, {
+                    streamId,
+                    role,
+                    status: stream.status,
+                });
+                // Clear the stream reference
+                if (role === 'reader') {
+                    this.callerReaderStream = undefined;
+                    this.logger.info('Limited connection reader stream closed, will create new streams for requests');
+                }
+                else if (role === 'writer') {
+                    this.callerWriterStream = undefined;
+                    this.logger.info('Limited connection writer stream closed, responses may be affected');
+                }
+                // Stop monitoring this stream
+                clearInterval(interval);
+                this.streamMonitoringIntervals.delete(streamId);
+            }
+        }, 5000);
+        // Track the interval for cleanup
+        this.streamMonitoringIntervals.set(streamId, interval);
+        this.logger.debug(`Started monitoring ${role} stream`, { streamId });
+    }
     /**
      * Emits an async event and waits for the first listener to return a result
      * This enables event-based request handling with async responses
@@ -194,23 +267,76 @@ export class oNodeStreamManager extends oObject {
     /**
      * Handles a stream initialization message
      * Stores reference to caller's reader stream for bidirectional communication
+     * Sends acknowledgment back to confirm stream registration
      *
      * @param message - The decoded stream init message
      * @param stream - The stream that sent the message
      */
-    handleStreamInitMessage(message, stream) {
-        if (message.role === 'reader') {
-            this.callerReaderStream = stream;
-            this.logger.info('Identified caller reader stream', {
+    async handleStreamInitMessage(message, stream) {
+        try {
+            if (message.role === 'reader') {
+                this.callerReaderStream = stream;
+                this.logger.info('Identified caller reader stream', {
+                    streamId: stream.id,
+                    connectionId: message.connectionId,
+                });
+                this.emit(StreamManagerEvent.StreamIdentified, {
+                    streamId: stream.id,
+                    role: message.role,
+                    connectionId: message.connectionId,
+                });
+                // Set up monitoring for reader stream closure
+                this.setupStreamCloseMonitoring(stream, 'reader');
+            }
+            else if (message.role === 'writer') {
+                this.callerWriterStream = stream;
+                this.logger.info('Identified caller writer stream', {
+                    streamId: stream.id,
+                    connectionId: message.connectionId,
+                });
+                this.emit(StreamManagerEvent.StreamIdentified, {
+                    streamId: stream.id,
+                    role: message.role,
+                    connectionId: message.connectionId,
+                });
+                // Set up monitoring for writer stream closure
+                this.setupStreamCloseMonitoring(stream, 'writer');
+            }
+            // Send acknowledgment back to caller
+            const ackMessage = {
+                type: 'stream-init-ack',
+                status: 'success',
                 streamId: stream.id,
-                connectionId: message.connectionId,
-            });
-            this.emit(StreamManagerEvent.StreamIdentified, {
+                role: message.role,
+                timestamp: Date.now(),
+            };
+            const ackBytes = new TextEncoder().encode(JSON.stringify(ackMessage));
+            await this.sendLengthPrefixed(stream, ackBytes, {});
+            this.logger.debug('Sent stream-init-ack', {
                 streamId: stream.id,
                 role: message.role,
-                connectionId: message.connectionId,
             });
         }
+        catch (error) {
+            this.logger.error('Failed to process stream-init message', error);
+            // Try to send error acknowledgment
+            try {
+                const errorAck = {
+                    type: 'stream-init-ack',
+                    status: 'error',
+                    streamId: stream.id,
+                    role: message.role,
+                    error: error.message,
+                    timestamp: Date.now(),
+                };
+                const errorAckBytes = new TextEncoder().encode(JSON.stringify(errorAck));
+                await this.sendLengthPrefixed(stream, errorAckBytes, {});
+            }
+            catch (ackError) {
+                this.logger.error('Failed to send error acknowledgment', ackError);
+            }
+            throw error;
+        }
     }
     /**
      * Extracts and parses JSON from various formats including:
@@ -301,7 +427,7 @@ export class oNodeStreamManager extends oObject {
                 // Parse JSON (handles markdown blocks, mixed content, and JSON5)
                 const message = this.extractAndParseJSON(decoded);
                 if (this.isStreamInit(message)) {
-                    this.handleStreamInitMessage(message, stream);
+                    await this.handleStreamInitMessage(message, stream);
                     // Continue reading for subsequent messages on this stream
                 }
                 else if (this.isRequest(message)) {
@@ -318,7 +444,6 @@ export class oNodeStreamManager extends oObject {
         catch (error) {
             // Stream closed or error occurred
             if (stream.status === 'open') {
-                this.logger.error('Error in length-prefixed stream handler:', error);
                 this.emit(StreamManagerEvent.StreamError, {
                     streamId: stream.id,
                     error,
@@ -330,6 +455,42 @@ export class oNodeStreamManager extends oObject {
             this.untrackStreamHandler(stream.id);
         }
     }
+    /**
+     * Determines which stream to use for sending the response
+     * Checks for _streamId in request params and routes accordingly
+     *
+     * @param request - The incoming request
+     * @param defaultStream - The stream the request came on (fallback)
+     * @returns The stream to use for the response
+     */
+    getResponseStream(request, defaultStream) {
+        const streamId = request.params._streamId;
+        // If no explicit response stream specified, use the request stream (backward compatibility)
+        if (!streamId) {
+            return defaultStream;
+        }
+        // Check if the response stream is the identified caller writer stream
+        if (this.callerWriterStream && this.callerWriterStream.id === streamId) {
+            this.logger.debug('Routing response to caller writer stream', {
+                requestId: request.id,
+                streamId,
+            });
+            return this.callerWriterStream;
+        }
+        if (this.callerReaderStream && this.callerReaderStream.id === streamId) {
+            this.logger.debug('Routing response to caller reader stream', {
+                requestId: request.id,
+                streamId,
+            });
+            return this.callerReaderStream;
+        }
+        // If specified stream not found, warn and fall back to request stream
+        this.logger.warn('Specified response stream not found, using request stream', {
+            requestId: request.id,
+            streamId,
+        });
+        return defaultStream;
+    }
     /**
      * Handles a request message by emitting an event and sending response
      *
@@ -340,6 +501,8 @@ export class oNodeStreamManager extends oObject {
     async handleRequestMessage(message, stream, connection) {
         const request = new oRequest(message);
         const responseBuilder = ResponseBuilder.create();
+        // Determine which stream to use for the response
+        const responseStream = this.getResponseStream(request, stream);
         try {
             // Emit InboundRequest event and wait for handler to process
             const result = await this.emitAsync(StreamManagerEvent.InboundRequest, {
@@ -348,13 +511,13 @@ export class oNodeStreamManager extends oObject {
                 connection,
             });
             const response = await responseBuilder.build(request, result, null);
-            await CoreUtils.sendResponse(response, stream);
+            await CoreUtils.sendResponse(response, responseStream);
             this.logger.debug(`Successfully processed request: method=${request.method}, id=${request.id}`);
         }
         catch (error) {
             this.logger.error(`Error processing request: method=${request.method}, id=${request.id}`, error);
             const errorResponse = await responseBuilder.buildError(request, error);
-            await CoreUtils.sendResponse(errorResponse, stream);
+            await CoreUtils.sendResponse(errorResponse, responseStream);
             this.emit(StreamManagerEvent.StreamError, {
                 streamId: stream.id,
                 error: error instanceof Error ? error : new Error(String(error)),
@@ -478,7 +641,14 @@ export class oNodeStreamManager extends oObject {
         this.logger.info('Closing stream manager', {
             activeStreams: this.streams.size,
             activeHandlers: this.activeStreamHandlers.size,
+            monitoringIntervals: this.streamMonitoringIntervals.size,
         });
+        // Clear all stream monitoring intervals
+        for (const [streamId, interval,] of this.streamMonitoringIntervals.entries()) {
+            clearInterval(interval);
+            this.logger.debug('Cleared monitoring interval', { streamId });
+        }
+        this.streamMonitoringIntervals.clear();
         // Abort all active stream handlers
         for (const [streamId, { abortController },] of this.activeStreamHandlers.entries()) {
             abortController.abort();

package/dist/src/connection/stream-manager.events.d.ts

@@ -5,12 +5,14 @@ export declare enum StreamManagerEvent {
     ManagerInitialized = "manager-initialized",
     ManagerClosed = "manager-closed",
     ReaderStarted = "reader-started",
+    WriterStarted = "writer-started",
     ReaderFailed = "reader-failed",
     ReaderRecovered = "reader-recovered",
     RecoveryFailed = "recovery-failed",
     StreamReplaced = "stream-replaced",
     StreamFailed = "stream-failed",
     StreamIdentified = "stream-identified",
+    StreamClosed = "stream-closed",
     InboundRequest = "inbound-request",
     InboundResponse = "inbound-response",
     StreamError = "stream-error"
@@ -23,6 +25,9 @@ export interface InitializedData {
 export interface ReaderStartedData {
     streamId: string;
 }
+export interface WriterStartedData {
+    streamId: string;
+}
 export interface ReaderFailedData {
     error?: string;
     failureCount: number;
@@ -46,9 +51,14 @@ export interface StreamFailedData {
 }
 export interface StreamIdentifiedData {
     streamId: string;
-    role: 'reader' | 'standard';
+    role: 'reader' | 'writer' | 'standard';
     connectionId?: string;
 }
+export interface StreamClosedData {
+    streamId: string;
+    role: 'reader' | 'writer';
+    status: string;
+}
 export interface InboundRequestData {
     request: any;
     stream: any;
@@ -70,12 +80,14 @@ export type StreamManagerEventData = {
     [StreamManagerEvent.ManagerInitialized]: InitializedData;
     [StreamManagerEvent.ManagerClosed]: void;
     [StreamManagerEvent.ReaderStarted]: ReaderStartedData;
+    [StreamManagerEvent.WriterStarted]: WriterStartedData;
     [StreamManagerEvent.ReaderFailed]: ReaderFailedData;
     [StreamManagerEvent.ReaderRecovered]: ReaderRecoveredData;
     [StreamManagerEvent.RecoveryFailed]: RecoveryFailedData;
     [StreamManagerEvent.StreamReplaced]: StreamReplacedData;
     [StreamManagerEvent.StreamFailed]: StreamFailedData;
     [StreamManagerEvent.StreamIdentified]: StreamIdentifiedData;
+    [StreamManagerEvent.StreamClosed]: StreamClosedData;
     [StreamManagerEvent.InboundRequest]: InboundRequestData;
     [StreamManagerEvent.InboundResponse]: InboundResponseData;
     [StreamManagerEvent.StreamError]: StreamErrorData;

package/dist/src/connection/stream-manager.events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-manager.events.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-manager.events.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,kBAAkB,wBAAwB;IAC1C,aAAa,mBAAmB;IAChC,aAAa,mBAAmB;IAChC,YAAY,kBAAkB;IAC9B,eAAe,qBAAqB;IACpC,cAAc,oBAAoB;IAClC,cAAc,oBAAoB;IAClC,YAAY,kBAAkB;IAC9B,gBAAgB,sBAAsB;IACtC,cAAc,oBAAoB;IAClC,eAAe,qBAAqB;IACpC,WAAW,iBAAiB;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;CAAG;AAEnC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,GAAG,CAAC;IACb,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,EAAE,GAAG,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,EAAE,eAAe,CAAC;IACzD,CAAC,kBAAkB,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC;IACzC,CAAC,kBAAkB,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IACtD,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IACpD,CAAC,kBAAkB,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;IAC1D,CAAC,kBAAkB,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACxD,CAAC,kBAAkB,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACxD,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IACpD,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;IAC5D,CAAC,kBAAkB,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACxD,CAAC,kBAAkB,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;IAC1D,CAAC,kBAAkB,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;CACnD,CAAC"}
+{"version":3,"file":"stream-manager.events.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-manager.events.ts"],"names":[],"mappings":"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"}

package/dist/src/connection/stream-manager.events.js

@@ -6,12 +6,14 @@ export var StreamManagerEvent;
     StreamManagerEvent["ManagerInitialized"] = "manager-initialized";
     StreamManagerEvent["ManagerClosed"] = "manager-closed";
     StreamManagerEvent["ReaderStarted"] = "reader-started";
+    StreamManagerEvent["WriterStarted"] = "writer-started";
     StreamManagerEvent["ReaderFailed"] = "reader-failed";
     StreamManagerEvent["ReaderRecovered"] = "reader-recovered";
     StreamManagerEvent["RecoveryFailed"] = "recovery-failed";
     StreamManagerEvent["StreamReplaced"] = "stream-replaced";
     StreamManagerEvent["StreamFailed"] = "stream-failed";
     StreamManagerEvent["StreamIdentified"] = "stream-identified";
+    StreamManagerEvent["StreamClosed"] = "stream-closed";
     StreamManagerEvent["InboundRequest"] = "inbound-request";
     StreamManagerEvent["InboundResponse"] = "inbound-response";
     StreamManagerEvent["StreamError"] = "stream-error";

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,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAOrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IACzC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAuBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAsBhC,mBAAmB;IAWnB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAwDV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAOrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IACzC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAuBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAyBhC,mBAAmB;IAWnB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IA+CV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}

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

@@ -3,7 +3,6 @@ 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 { ConnectionUtils } from './utils/connection.utils.js';
 import { StreamManagerEvent } from './connection/stream-manager.events.js';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
@@ -25,13 +24,16 @@ export class oNodeTool extends oTool(oServerNode) {
         await this.p2pNode.handle(reuseProtocol, this.handleStreamReuse.bind(this), {
             maxInboundStreams: 10000,
             maxOutboundStreams: maxOutboundsStreams,
-            runOnLimitedConnection: this.config.runOnLimitedConnection,
+            runOnLimitedConnection: true, // reuse is always on limited connections
         });
         this.logger.debug('Handled protocol reuse: ' + reuseProtocol);
     }
     async handleProtocol(address) {
+        if (!address || !address.protocol) {
+            throw new Error('Invalid address passed: ' + address);
+        }
         const protocols = this.p2pNode.getProtocols();
-        if (protocols.find((p) => p === address.protocol)) {
+        if (protocols.find((p) => p === address?.protocol)) {
             // already handling
             return;
         }
@@ -66,29 +68,22 @@ export class oNodeTool extends oTool(oServerNode) {
         return this.handleStream(stream, connection, true);
     }
     async handleStream(stream, connection, reuse) {
-        if (reuse) {
-            this.logger.debug('Handle stream with reuse = true');
-            // record inbound connection to manager
-        }
-        const remoteAddress = await ConnectionUtils.addressFromConnection({
-            currentNode: this,
-            connection: connection,
+        this.logger.debug('Handling incoming stream on connection:', {
+            connectionId: connection.id,
+            direction: connection.direction,
         });
-        await this.connectionManager.answer({
-            nextHopAddress: remoteAddress,
-            address: remoteAddress,
+        const unknown = new oNodeAddress('o://unknown', []);
+        const oConnection = await this.connectionManager.answer({
+            nextHopAddress: unknown,
+            address: unknown,
             callerAddress: this.address,
             p2pConnection: connection,
             reuse,
         });
         // Get the oNodeConnection for this libp2p connection
-        const oConnection = this.connectionManager.getConnectionByP2pConnection(connection);
         if (!oConnection) {
-            this.logger.error('No oNodeConnection found for incoming stream', {
-                remotePeer: connection.remotePeer.toString(),
-                connectionId: connection.id,
-            });
-            return;
+            this.logger.error('Failed to process inbound connection');
+            throw new Error('Failed to process inbound connection');
         }
         // Subscribe to InboundRequest events from the stream manager
         // This follows an event-driven pattern for handling incoming requests

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

@@ -2,10 +2,10 @@ import { Connection } from '@olane/o-config';
 import { oObject } from '@olane/o-core';
 export declare class ConnectionUtils extends oObject {
     /**
-     * Waits for a peer to appear in the peer store with sufficient protocol information.
-     * Implements retry logic to handle race conditions where peer store is not immediately populated.
+     * Waits for a peer to be identified via the identify protocol.
+     * Uses event-driven approach listening to peer store protocol updates.
      */
-    private static waitForPeerInStore;
+    private static waitForPeerIdentify;
     static addressFromConnection(options: {
         currentNode: any;
         connection: Connection;

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

@@ -1 +1 @@
-{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;mBACkB,kBAAkB;WAgCnB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CA0DF"}
+{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAKX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;mBACkB,mBAAmB;WA0EpB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CA4DF"}

package/dist/src/utils/connection.utils.js

@@ -3,38 +3,64 @@ import { oNodeAddress } from '../router/o-node.address.js';
 import { oNodeTransport } from '../router/o-node.transport.js';
 export class ConnectionUtils extends oObject {
     /**
-     * Waits for a peer to appear in the peer store with sufficient protocol information.
-     * Implements retry logic to handle race conditions where peer store is not immediately populated.
+     * Waits for a peer to be identified via the identify protocol.
+     * Uses event-driven approach listening to peer store protocol updates.
      */
-    static async waitForPeerInStore(p2pNode, remotePeerId) {
-        const MAX_RETRIES = 100; // 5 seconds total (100 * 50ms)
-        const RETRY_DELAY_MS = 50;
-        const MIN_PROTOCOLS = 2;
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    static async waitForPeerIdentify(p2pNode, remotePeerId, nodeProtocol) {
+        const TIMEOUT_MS = 5000; // 5 seconds timeout
+        // Helper to check if peer has sufficient protocols
+        const checkPeerProtocols = async () => {
             const peers = await p2pNode.peerStore.all();
             const remotePeer = peers.find((peer) => {
                 return peer.id.toString() === remotePeerId.toString();
             });
-            // Check if peer exists and has sufficient protocol information
-            if (remotePeer && remotePeer.protocols.length > MIN_PROTOCOLS) {
-                return remotePeer;
-            }
-            // Wait before next retry
-            if (attempt < MAX_RETRIES - 1) {
-                await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+            if (remotePeer) {
+                const oProtocols = remotePeer.protocols.filter((p) => p.startsWith('/o/') && p.startsWith(nodeProtocol) === false) || [];
+                console.log('Found o-protocols for peer:', oProtocols, 'with node address:', nodeProtocol);
+                if (oProtocols.length > 0) {
+                    return remotePeer;
+                }
             }
+            return null;
+        };
+        // Check if peer already has sufficient protocols
+        const existingPeer = await checkPeerProtocols();
+        if (existingPeer) {
+            return existingPeer;
         }
-        // Timeout exceeded
-        throw new Error(`Timeout waiting for peer ${remotePeerId.toString()} to appear in peer store with sufficient protocols (waited ${MAX_RETRIES * RETRY_DELAY_MS}ms)`);
+        // Wait for peer store protocol update event
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                // TypeScript doesn't have types for peerStore events, but they exist at runtime
+                p2pNode.removeEventListener('peer:identify', protocolChangeHandler);
+                reject(new Error(`Timeout waiting for peer ${remotePeerId.toString()} to be identified (waited ${TIMEOUT_MS}ms)`));
+            }, TIMEOUT_MS);
+            const protocolChangeHandler = async (evt) => {
+                const { peerId } = evt.detail;
+                console.log('evt.detail:', evt.detail);
+                // Check if this is the peer we're waiting for
+                if (peerId?.toString() === remotePeerId.toString()) {
+                    const peer = await checkPeerProtocols();
+                    if (peer) {
+                        clearTimeout(timeoutId);
+                        // TypeScript doesn't have types for peerStore events, but they exist at runtime
+                        p2pNode.removeEventListener('peer:identify', protocolChangeHandler);
+                        resolve(peer);
+                    }
+                }
+            };
+            // TypeScript doesn't have types for peerStore events, but they exist at runtime
+            p2pNode.addEventListener('peer:identify', protocolChangeHandler);
+        });
     }
     // TODO: improve this logic (poor implementation for now)
     static async addressFromConnection(options) {
         try {
             const { currentNode, connection } = options;
             const p2pNode = currentNode.p2pNode;
-            // Wait for peer to appear in peer store with sufficient protocol information
-            // This handles race conditions where peer store is not immediately populated
-            const remotePeer = await this.waitForPeerInStore(p2pNode, connection.remotePeer);
+            // Wait for peer to be identified via the identify protocol
+            // This uses an event-driven approach to detect when the peer store is updated
+            const remotePeer = await this.waitForPeerIdentify(p2pNode, connection.remotePeer, currentNode.address.protocol);
             // Get origin address for comparison
             const originAddress = currentNode.address?.value;
             if (!originAddress) {
@@ -43,6 +69,7 @@ export class ConnectionUtils extends oObject {
             const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/') &&
                 p.includes(currentNode?.address?.protocol) === false);
             if (!oProtocol) {
+                console.log('Remote peer protocols:', remotePeer.protocols);
                 throw new Error('Failed to extract remote address, could not find o-protocol in peer protocols.');
             }
             const address = oNodeAddress.fromProtocol(oProtocol);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.53",
+  "version": "0.7.55",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-test": "0.7.53",
+    "@olane/o-test": "0.7.55",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/json5": "^2.2.0",
@@ -60,13 +60,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.53",
-    "@olane/o-core": "0.7.53",
-    "@olane/o-protocol": "0.7.53",
-    "@olane/o-tool": "0.7.53",
+    "@olane/o-config": "0.7.55",
+    "@olane/o-core": "0.7.55",
+    "@olane/o-protocol": "0.7.55",
+    "@olane/o-tool": "0.7.55",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "cc41cbe72abffd5f2720aec92516aafea50ee9c3"
+  "gitHead": "f7d02a1ecfb0d28b7b1009a7c3eb6d0d4863adc2"
 }