@olane/o-client-limited 0.7.52 → 0.7.54

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

@@ -1,3 +1,4 @@
 export * from './o-limited-connection.js';
 export * from './o-limited-connection-manager.js';
+export * from './o-limited.stream-manager.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC"}

package/dist/src/connection/index.js

@@ -1,2 +1,3 @@
 export * from './o-limited-connection.js';
 export * from './o-limited-connection-manager.js';
+export * from './o-limited.stream-manager.js';

package/dist/src/connection/o-limited-connection-manager.js

@@ -18,7 +18,7 @@ export class oLimitedConnectionManager extends oNodeConnectionManager {
                 address: address,
                 p2pConnection: p2pConnection,
                 callerAddress: callerAddress,
-                runOnLimitedConnection: this.config.runOnLimitedConnection ?? true,
+                runOnLimitedConnection: true,
                 requestHandler: config.requestHandler,
             });
             return connection;

package/dist/src/connection/o-limited-connection.d.ts

@@ -1,29 +1,40 @@
 import { oNodeConnection } from '@olane/o-node';
 import type { oNodeConnectionConfig } from '@olane/o-node';
 import { oLimitedStreamManager } from './o-limited.stream-manager.js';
+import type { oRequest, oResponse } from '@olane/o-core';
 /**
- * oLimitedConnection extends oNodeConnection with stream reuse for limited connections.
+ * oLimitedConnection extends oNodeConnection with dual persistent streams for limited connections.
  *
- * This is optimized for limited connections where creating new streams is expensive
- * (mobile clients, browsers, resource-constrained environments).
+ * This is optimized for limited connections where the caller cannot be dialed
+ * (browser clients, mobile clients, resource-constrained environments).
  *
  * Stream Architecture:
- * - 1 dedicated reader stream for receiving requests from receiver
- * - Reuses outbound streams for multiple request-response cycles
+ * - 1 dedicated reader stream for receiving ALL inbound data from receiver
+ *   (receiver-initiated requests AND responses to limited client's outbound requests)
+ * - 1 dedicated writer stream for sending ALL outbound data to receiver
+ *   (responses to receiver's requests AND limited client's outbound requests)
+ * - No ephemeral streams - all communication uses persistent streams for efficiency
  *
  * Features:
- * - Automatic reader stream creation and maintenance
+ * - Automatic reader/writer stream creation and maintenance
  * - Single retry on reader failure
- * - Stream reuse for outbound requests
- * - Event emission for monitoring (reader-started, reader-failed, reader-recovered)
+ * - Stream reuse for all outbound requests (no ephemeral streams)
+ * - Response routing via _streamId and _responseConnectionId in request params
+ * - Event emission for monitoring (reader-started, writer-started, reader-failed, reader-recovered)
  *
  * Default Behavior:
  * - Uses 'reuse' stream policy by default
- * - Automatically initializes dedicated reader on connection start
+ * - Automatically initializes persistent streams on connection start
  */
 export declare class oLimitedConnection extends oNodeConnection {
     streamManager: oLimitedStreamManager;
     constructor(config: oNodeConnectionConfig);
+    /**
+     * Override transmit to inject response routing params
+     * Adds _streamId and _responseConnectionId to enable receiver to route responses
+     * to the persistent reader stream
+     */
+    transmit(request: oRequest): Promise<oResponse>;
     /**
      * Override close to cleanup stream manager properly
      */

package/dist/src/connection/o-limited-connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-limited-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,qBAAqB,EAEtB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IAC7C,aAAa,EAAE,qBAAqB,CAAC;gBAEjC,MAAM,EAAE,qBAAqB;IAmCzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}
+{"version":3,"file":"o-limited-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,qBAAqB,EAEtB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IAC7C,aAAa,EAAE,qBAAqB,CAAC;gBAEjC,MAAM,EAAE,qBAAqB;IAsCzC;;;;OAIG;IACG,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA6BrD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}

package/dist/src/connection/o-limited-connection.js

@@ -2,24 +2,28 @@ import { oNodeConnection } from '@olane/o-node';
 import { oLimitedStreamManager, } from './o-limited.stream-manager.js';
 import { StreamManagerEvent } from '@olane/o-node';
 /**
- * oLimitedConnection extends oNodeConnection with stream reuse for limited connections.
+ * oLimitedConnection extends oNodeConnection with dual persistent streams for limited connections.
  *
- * This is optimized for limited connections where creating new streams is expensive
- * (mobile clients, browsers, resource-constrained environments).
+ * This is optimized for limited connections where the caller cannot be dialed
+ * (browser clients, mobile clients, resource-constrained environments).
  *
  * Stream Architecture:
- * - 1 dedicated reader stream for receiving requests from receiver
- * - Reuses outbound streams for multiple request-response cycles
+ * - 1 dedicated reader stream for receiving ALL inbound data from receiver
+ *   (receiver-initiated requests AND responses to limited client's outbound requests)
+ * - 1 dedicated writer stream for sending ALL outbound data to receiver
+ *   (responses to receiver's requests AND limited client's outbound requests)
+ * - No ephemeral streams - all communication uses persistent streams for efficiency
  *
  * Features:
- * - Automatic reader stream creation and maintenance
+ * - Automatic reader/writer stream creation and maintenance
  * - Single retry on reader failure
- * - Stream reuse for outbound requests
- * - Event emission for monitoring (reader-started, reader-failed, reader-recovered)
+ * - Stream reuse for all outbound requests (no ephemeral streams)
+ * - Response routing via _streamId and _responseConnectionId in request params
+ * - Event emission for monitoring (reader-started, writer-started, reader-failed, reader-recovered)
  *
  * Default Behavior:
  * - Uses 'reuse' stream policy by default
- * - Automatically initializes dedicated reader on connection start
+ * - Automatically initializes persistent streams on connection start
  */
 export class oLimitedConnection extends oNodeConnection {
     constructor(config) {
@@ -29,8 +33,7 @@ export class oLimitedConnection extends oNodeConnection {
             reusePolicy,
         });
         // Replace the base streamManager with our limited version
-        const protocol = this.nextHopAddress.protocol +
-            (reusePolicy === 'reuse' ? '/reuse' : '');
+        const protocol = this.nextHopAddress.protocol + (reusePolicy === 'reuse' ? '/reuse' : '');
         const limitedConfig = {
             p2pConnection: this.p2pConnection,
             protocol,
@@ -42,6 +45,9 @@ export class oLimitedConnection extends oNodeConnection {
         this.streamManager.on(StreamManagerEvent.ReaderStarted, (data) => {
             this.logger.info('Reader stream started', data);
         });
+        this.streamManager.on(StreamManagerEvent.WriterStarted, (data) => {
+            this.logger.info('Writer stream started', data);
+        });
         this.streamManager.on(StreamManagerEvent.ReaderFailed, (data) => {
             this.logger.warn('Reader stream failed', data);
         });
@@ -49,6 +55,35 @@ export class oLimitedConnection extends oNodeConnection {
             this.logger.info('Reader stream recovered', data);
         });
     }
+    /**
+     * Override transmit to inject response routing params
+     * Adds _streamId and _responseConnectionId to enable receiver to route responses
+     * to the persistent reader stream
+     */
+    async transmit(request) {
+        // Wait for stream manager initialization to ensure streams are available
+        if (!this.streamManager.isInitialized) {
+            await this.streamManager.initialize();
+        }
+        // Inject response routing params to route responses to reader stream
+        // Writer stream sends the request, reader stream receives the response
+        if (this.streamManager.readerStream) {
+            request.params._streamId = this.streamManager.readerStream.p2pStream.id;
+            request.params._responseConnectionId = this.p2pConnection.id;
+            if (request.params.payload) {
+                request.params.payload.params._streamId = request.params._streamId;
+            }
+            this.logger.debug('Injected response routing params', {
+                streamId: request.params._streamId,
+                responseConnectionId: request.params._responseConnectionId,
+            });
+        }
+        else {
+            this.logger.warn('Reader stream not available, response routing params not injected');
+        }
+        // Call parent transmit with modified request
+        return await super.transmit(request);
+    }
     /**
      * Override close to cleanup stream manager properly
      */

package/dist/src/connection/o-limited.stream-manager.d.ts

@@ -21,16 +21,19 @@ export interface oLimitedStreamManagerConfig extends StreamManagerConfig {
 /**
  * Limited Stream Manager handles stream lifecycle for limited connections
  * Features:
- * - Maintains dedicated reader stream for receiving requests from receiver
- * - Reuses outbound streams (no close after use)
+ * - Maintains dedicated reader stream for receiving all inbound data from receiver
+ *   (both receiver-initiated requests and responses to limited client's outbound requests)
+ * - Maintains dedicated writer stream for sending all outbound data to receiver
+ *   (both responses to receiver's requests and limited client's outbound requests)
+ * - No ephemeral streams - all communication uses persistent streams
  * - Single retry on reader failure
  * - No health checks (error handling on use)
  */
 export declare class oLimitedStreamManager extends oNodeStreamManager {
-    private readerStream?;
+    readerStream?: oNodeStream;
+    writerStream?: oNodeStream;
     private isReaderLoopActive;
     private readerLoopAbortController?;
-    private outboundStream?;
     private limitedConfig;
     private closing;
     constructor(config: oLimitedStreamManagerConfig);
@@ -44,7 +47,12 @@ export declare class oLimitedStreamManager extends oNodeStreamManager {
      */
     private createReaderStream;
     /**
-     * Sends stream initialization message to identify this as a reader stream
+     * Creates and initializes the dedicated writer stream
+     */
+    private createWriterStream;
+    /**
+     * Sends stream initialization message to identify the stream role
+     * Waits for acknowledgment from receiver before proceeding
      */
     private sendStreamInitMessage;
     /**
@@ -61,16 +69,25 @@ export declare class oLimitedStreamManager extends oNodeStreamManager {
      */
     private recoverReaderStream;
     /**
-     * Override getOrCreateStream to reuse outbound streams
-     * Does not create new stream for every request
+     * Override getOrCreateStream to use persistent writer stream for outbound requests
+     * This eliminates ephemeral stream creation for limited connections
      * Auto-initializes on first use
      */
     getOrCreateStream(protocol: string, remoteAddress: any, config?: StreamHandlerConfig): Promise<oNodeStream>;
     /**
-     * Override releaseStream to NOT close the stream
-     * Keep streams open for reuse
+     * Override releaseStream to protect persistent streams from being closed
+     * Persistent streams (reader/writer) should never be released via this method
+     * Only closes streams that are not the dedicated reader or writer streams
      */
     releaseStream(streamId: string): Promise<void>;
+    /**
+     * Override getStreamById to check persistent streams first
+     * Provides access to reader and writer streams by ID
+     *
+     * @param streamId - The ID of the stream to retrieve
+     * @returns The libp2p Stream or undefined if not found
+     */
+    getStreamById(streamId: string): Stream | undefined;
     /**
      * Close the stream manager and cleanup all resources
      */

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

@@ -1 +1 @@
-{"version":3,"file":"o-limited.stream-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited.stream-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EACL,kBAAkB,EAElB,WAAW,EACX,mBAAmB,EAGpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,mBAAmB;IACtE;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,aAAa,EAAE,GAAG,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACjE;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IAC3D,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,kBAAkB,CAAkB;IAC5C,OAAO,CAAC,yBAAyB,CAAC,CAAkB;IACpD,OAAO,CAAC,cAAc,CAAC,CAAc;IACrC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAkB;gBAErB,MAAM,EAAE,2BAA2B;IAK/C;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqDjC;;OAEG;YACW,kBAAkB;IA4BhC;;OAEG;YACW,qBAAqB;IAiBnC;;;OAGG;YACW,eAAe;IAe7B;;OAEG;YACW,aAAa;IAwB3B;;OAEG;YACW,mBAAmB;IAgCjC;;;;OAIG;IACG,iBAAiB,CACrB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,GAAG,EAClB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,WAAW,CAAC;IA6BvB;;;OAGG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC7B"}
+{"version":3,"file":"o-limited.stream-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited.stream-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EACL,kBAAkB,EAElB,WAAW,EACX,mBAAmB,EAKpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGzD;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,mBAAmB;IACtE;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,aAAa,EAAE,GAAG,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACjE;AAED;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IACpD,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,WAAW,CAAC;IAClC,OAAO,CAAC,kBAAkB,CAAkB;IAC5C,OAAO,CAAC,yBAAyB,CAAC,CAAkB;IACpD,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAkB;gBAErB,MAAM,EAAE,2BAA2B;IAK/C;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsDjC;;OAEG;YACW,kBAAkB;IA4BhC;;OAEG;YACW,kBAAkB;IAyBhC;;;OAGG;YACW,qBAAqB;IA0EnC;;;OAGG;YACW,eAAe;IAe7B;;OAEG;YACW,aAAa;IAqB3B;;OAEG;YACW,mBAAmB;IAgCjC;;;;OAIG;IACG,iBAAiB,CACrB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,GAAG,EAClB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,WAAW,CAAC;IAqBvB;;;;OAIG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAepD;;;;;;OAMG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAcnD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC7B"}

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

@@ -1,10 +1,14 @@
 import { oError, oErrorCodes } from '@olane/o-core';
-import { oNodeStreamManager, StreamManagerEvent, } from '@olane/o-node';
+import { oNodeStreamManager, StreamManagerEvent, isStreamInitAckMessage, } from '@olane/o-node';
+import { lpStream } from '@olane/o-config';
 /**
  * Limited Stream Manager handles stream lifecycle for limited connections
  * Features:
- * - Maintains dedicated reader stream for receiving requests from receiver
- * - Reuses outbound streams (no close after use)
+ * - Maintains dedicated reader stream for receiving all inbound data from receiver
+ *   (both receiver-initiated requests and responses to limited client's outbound requests)
+ * - Maintains dedicated writer stream for sending all outbound data to receiver
+ *   (both responses to receiver's requests and limited client's outbound requests)
+ * - No ephemeral streams - all communication uses persistent streams
  * - Single retry on reader failure
  * - No health checks (error handling on use)
  */
@@ -40,8 +44,9 @@ export class oLimitedStreamManager extends oNodeStreamManager {
             this.logger.debug('Registered InboundRequest handler for limited connection');
         }
         try {
-            // Create dedicated reader stream
+            // Create dedicated reader and writer streams
             await this.createReaderStream();
+            await this.createWriterStream();
             this.isInitialized = true;
             this.logger.info('Limited stream manager initialized', {
                 remotePeer: this.limitedConfig.p2pConnection.remotePeer.toString(),
@@ -60,7 +65,7 @@ export class oLimitedStreamManager extends oNodeStreamManager {
             // Create reader stream using parent's createStream method
             this.readerStream = await this.createStream(this.limitedConfig.protocol, this.limitedConfig.remoteAddress, {});
             // Send self-identification message
-            await this.sendStreamInitMessage(this.readerStream.p2pStream);
+            await this.sendStreamInitMessage(this.readerStream.p2pStream, 'reader');
             // Start background reader loop
             await this.startReaderLoop();
             this.eventEmitter.emit(StreamManagerEvent.ReaderStarted, {
@@ -76,21 +81,80 @@ export class oLimitedStreamManager extends oNodeStreamManager {
         }
     }
     /**
-     * Sends stream initialization message to identify this as a reader stream
+     * Creates and initializes the dedicated writer stream
      */
-    async sendStreamInitMessage(stream) {
+    async createWriterStream() {
+        try {
+            // Create writer stream using parent's createStream method
+            this.writerStream = await this.createStream(this.limitedConfig.protocol, this.limitedConfig.remoteAddress, {});
+            // Send self-identification message
+            await this.sendStreamInitMessage(this.writerStream.p2pStream, 'writer');
+            this.eventEmitter.emit(StreamManagerEvent.WriterStarted, {
+                streamId: this.writerStream.p2pStream.id,
+            });
+            this.logger.info('Writer stream created', {
+                streamId: this.writerStream.p2pStream.id,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to create writer stream:', error);
+            throw error;
+        }
+    }
+    /**
+     * Sends stream initialization message to identify the stream role
+     * Waits for acknowledgment from receiver before proceeding
+     */
+    async sendStreamInitMessage(stream, role) {
         const initMessage = {
             type: 'stream-init',
-            role: 'reader',
+            role,
             timestamp: Date.now(),
             connectionId: this.limitedConfig.p2pConnection.id,
         };
         const messageBytes = new TextEncoder().encode(JSON.stringify(initMessage));
         await this.sendLengthPrefixed(stream, messageBytes, {});
-        this.logger.debug('Sent stream-init message', {
+        this.logger.debug('Sent stream-init message, waiting for ack', {
             streamId: stream.id,
-            role: 'reader',
+            role,
         });
+        // Wait for acknowledgment with timeout
+        const ackTimeout = 5000; // 5 seconds
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, ackTimeout);
+        try {
+            const lp = lpStream(stream);
+            // Read acknowledgment message
+            const ackBytes = await lp.read({ signal: abortController.signal });
+            const ackDecoded = new TextDecoder().decode(ackBytes.subarray());
+            const ackMessage = this.extractAndParseJSON(ackDecoded);
+            // Validate acknowledgment
+            if (!isStreamInitAckMessage(ackMessage)) {
+                throw new oError(oErrorCodes.INTERNAL_ERROR, `Invalid stream-init-ack message received: ${JSON.stringify(ackMessage)}`);
+            }
+            if (ackMessage.status === 'error') {
+                throw new oError(oErrorCodes.INTERNAL_ERROR, `Stream initialization failed: ${ackMessage.error || 'Unknown error'}`);
+            }
+            if (ackMessage.role !== role) {
+                throw new oError(oErrorCodes.INTERNAL_ERROR, `Stream role mismatch: expected ${role}, got ${ackMessage.role}`);
+            }
+            this.logger.info('Received stream-init-ack', {
+                streamId: stream.id,
+                role,
+                ackStreamId: ackMessage.streamId,
+            });
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                throw new oError(oErrorCodes.TIMEOUT, `Stream initialization acknowledgment timeout after ${ackTimeout}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
     }
     /**
      * Starts the background reader loop
@@ -163,8 +227,8 @@ export class oLimitedStreamManager extends oNodeStreamManager {
         }
     }
     /**
-     * Override getOrCreateStream to reuse outbound streams
-     * Does not create new stream for every request
+     * Override getOrCreateStream to use persistent writer stream for outbound requests
+     * This eliminates ephemeral stream creation for limited connections
      * Auto-initializes on first use
      */
     async getOrCreateStream(protocol, remoteAddress, config = {}) {
@@ -172,28 +236,49 @@ export class oLimitedStreamManager extends oNodeStreamManager {
         if (!this.isInitialized) {
             await this.initialize();
         }
-        // Check if we have an existing outbound stream that's still valid
-        if (this.outboundStream &&
-            this.outboundStream.p2pStream.status === 'open' &&
-            this.outboundStream.p2pStream.writeStatus === 'writable') {
-            this.logger.debug('Reusing existing outbound stream', {
-                streamId: this.outboundStream.p2pStream.id,
+        // Use persistent writer stream for all outbound requests
+        if (this.writerStream && this.writerStream.p2pStream.status === 'open') {
+            this.logger.debug('Reusing writer stream for outbound request', {
+                streamId: this.writerStream.p2pStream.id,
             });
-            return this.outboundStream;
+            return this.writerStream;
         }
-        // Create new outbound stream if none exists or current is invalid
-        this.logger.debug('Creating new outbound stream (no valid stream to reuse)');
-        this.outboundStream = await this.createStream(protocol, remoteAddress, config);
-        return this.outboundStream;
+        // Writer stream should always be available after initialization
+        throw new oError(oErrorCodes.INTERNAL_ERROR, 'Writer stream not available or not open');
     }
     /**
-     * Override releaseStream to NOT close the stream
-     * Keep streams open for reuse
+     * Override releaseStream to protect persistent streams from being closed
+     * Persistent streams (reader/writer) should never be released via this method
+     * Only closes streams that are not the dedicated reader or writer streams
      */
     async releaseStream(streamId) {
-        // Don't close the stream - just log that we're keeping it open
-        this.logger.debug('Keeping stream open for reuse', { streamId });
-        // Do NOT call super.releaseStream() as that would close the stream
+        // Check if this is a persistent stream - don't close those
+        if ((this.readerStream && this.readerStream.p2pStream.id === streamId) ||
+            (this.writerStream && this.writerStream.p2pStream.id === streamId)) {
+            this.logger.debug('Skipping release of persistent stream', { streamId });
+            return;
+        }
+        // Close any other streams (should not occur in normal operation)
+        this.logger.debug('Releasing non-persistent stream', { streamId });
+        await super.releaseStream(streamId);
+    }
+    /**
+     * Override getStreamById to check persistent streams first
+     * Provides access to reader and writer streams by ID
+     *
+     * @param streamId - The ID of the stream to retrieve
+     * @returns The libp2p Stream or undefined if not found
+     */
+    getStreamById(streamId) {
+        // Check our persistent streams first
+        if (this.writerStream?.p2pStream.id === streamId) {
+            return this.writerStream.p2pStream;
+        }
+        if (this.readerStream?.p2pStream.id === streamId) {
+            return this.readerStream.p2pStream;
+        }
+        // Fall back to parent implementation (checks tracked ephemeral streams)
+        return super.getStreamById(streamId);
     }
     /**
      * Close the stream manager and cleanup all resources
@@ -219,15 +304,15 @@ export class oLimitedStreamManager extends oNodeStreamManager {
             }
             this.readerStream = undefined;
         }
-        // Close outbound stream
-        if (this.outboundStream) {
+        // Close writer stream
+        if (this.writerStream) {
             try {
-                await this.outboundStream.p2pStream.close();
+                await this.writerStream.p2pStream.close();
             }
             catch (error) {
-                this.logger.warn('Error closing outbound stream:', error);
+                this.logger.warn('Error closing writer stream:', error);
             }
-            this.outboundStream = undefined;
+            this.writerStream = undefined;
         }
         this.eventEmitter.emit(StreamManagerEvent.ManagerClosed, undefined);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"o-limited.tool.d.ts","sourceRoot":"","sources":["../../src/o-limited.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,MAAM,EAAE,WAAW;IAUzB,OAAO,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC;IAkBhE,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ7C"}
+{"version":3,"file":"o-limited.tool.d.ts","sourceRoot":"","sources":["../../src/o-limited.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,MAAM,EAAE,WAAW;IAWzB,OAAO,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC;IAkBhE,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ7C"}

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

@@ -8,6 +8,7 @@ export class oLimitedTool extends oNodeTool {
                 ...(config.network || {}),
                 listeners: config.network?.listeners || [], // default to no listeners
             },
+            runOnLimitedConnection: true,
         });
     }
     async connect(config) {

package/dist/test/bidirectional-communication.spec.js

@@ -1,50 +1,123 @@
 import { expect } from 'chai';
 import { TestEnvironment, createConnectionSpy, } from '@olane/o-node/test/helpers';
-import { oNodeAddress } from '@olane/o-node';
+import { oNodeAddress, oNodeTransport } from '@olane/o-node';
 import { LimitedTestTool, ReceiverTestTool } from './helpers/index.js';
+import { RelayTestTool } from './helpers/relay-test-tool.js';
 describe('Bidirectional Communication', () => {
     const env = new TestEnvironment();
     let caller;
     let receiver;
+    let relay;
     afterEach(async () => {
         await env.cleanup();
     });
-    describe('Caller → Receiver', () => {
-        it('should send request and receive response', async () => {
+    // describe('Caller → Receiver', () => {
+    //   it('should send request and receive response', async () => {
+    //     caller = await env.createNode<any>(LimitedTestTool, {
+    //       address: new oNodeAddress('o://caller'),
+    //     });
+    //     receiver = await env.createNode<any>(ReceiverTestTool, {
+    //       address: new oNodeAddress('o://receiver'),
+    //     });
+    //     const response = await caller.use(
+    //       new oNodeAddress(
+    //         receiver.address.toString(),
+    //         receiver.address.libp2pTransports,
+    //       ),
+    //       {
+    //         method: 'echo',
+    //         params: { message: 'hello-receiver' },
+    //       },
+    //     );
+    //     expect(response.result.success).to.be.true;
+    //     expect(response.result.data.message).to.equal('hello-receiver');
+    //     expect(receiver.receivedRequests).to.have.lengthOf(1);
+    //   });
+    //   it('should handle multiple sequential requests', async () => {
+    //     caller = await env.createNode<any>(LimitedTestTool, {
+    //       address: new oNodeAddress('o://caller'),
+    //     });
+    //     receiver = await env.createNode<any>(ReceiverTestTool, {
+    //       address: new oNodeAddress('o://receiver'),
+    //     });
+    //     const receiverAddr = new oNodeAddress(
+    //       receiver.address.toString(),
+    //       receiver.address.libp2pTransports,
+    //     );
+    //     for (let i = 0; i < 5; i++) {
+    //       const response = await caller.use(receiverAddr, {
+    //         method: 'echo',
+    //         params: { message: `request-${i}` },
+    //       });
+    //       expect(response.result.success).to.be.true;
+    //       expect(response.result.data.message).to.equal(`request-${i}`);
+    //     }
+    //     expect(receiver.receivedRequests).to.have.lengthOf(5);
+    //   });
+    // });
+    describe('Receiver → Caller', () => {
+        it('should fail when receiver tries to dial limited caller directly', async () => {
             caller = await env.createNode(LimitedTestTool, {
                 address: new oNodeAddress('o://caller'),
+                runOnLimitedConnection: true,
             });
             receiver = await env.createNode(ReceiverTestTool, {
                 address: new oNodeAddress('o://receiver'),
+                runOnLimitedConnection: true,
+                network: {
+                    listeners: ['/p2p-circuit'],
+                },
             });
-            const response = await caller.use(new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports), {
-                method: 'echo',
-                params: { message: 'hello-receiver' },
+            relay = await env.createNode(RelayTestTool, {
+                address: new oNodeAddress('o://relay'),
+                runOnLimitedConnection: true,
             });
-            expect(response.result.success).to.be.true;
-            expect(response.result.data.message).to.equal('hello-receiver');
-            expect(receiver.receivedRequests).to.have.lengthOf(1);
-        });
-        it('should handle multiple sequential requests', async () => {
-            caller = await env.createNode(LimitedTestTool, {
-                address: new oNodeAddress('o://caller'),
+            await receiver.use(relay.address, {
+                method: 'ping',
+                params: {},
             });
-            receiver = await env.createNode(ReceiverTestTool, {
-                address: new oNodeAddress('o://receiver'),
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.p2pNode
+                .getMultiaddrs()
+                .filter((t) => t.toString().includes('p2p-circuit'))
+                .map((ma) => new oNodeTransport(ma.toString())));
+            console.log('Receiver connected to relay', receiverAddr.libp2pTransports);
+            const callerAddr = new oNodeAddress(caller.address.toString(), caller.address.libp2pTransports);
+            // First: Caller establishes connection to receiver (this should succeed)
+            const initialResponse = await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
             });
-            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
-            for (let i = 0; i < 5; i++) {
-                const response = await caller.use(receiverAddr, {
-                    method: 'echo',
-                    params: { message: `request-${i}` },
+            console.log('Initial response from receiver:', initialResponse);
+            expect(initialResponse.result.success).to.be.true;
+            // Now: Receiver attempts to create a stream directly to caller - should fail
+            // Get the underlying libp2p connection from receiver side
+            const receiverConn = receiver.getFirstConnection();
+            const receiverP2pConnection = receiverConn.p2pConnection;
+            console.log('receiverP2pConnection:', receiverP2pConnection.streams[0].protocol);
+            expect(receiverP2pConnection.direction).to.equal('inbound');
+            expect(receiverP2pConnection).to.exist;
+            // Get caller's protocol string (e.g., "/o/caller")
+            const callerProtocol = caller.address.protocol;
+            // Try to manually spawn a new stream to the limited caller
+            // This should fail because LimitedTestTool has no protocol handlers registered
+            let errorThrown = false;
+            try {
+                await receiverP2pConnection.newStream('/o/caller', {
+                    runOnLimitedConnection: true,
+                    maxOutboundStreams: 1000,
                 });
-                expect(response.result.success).to.be.true;
-                expect(response.result.data.message).to.equal(`request-${i}`);
+                console.log('Created new stream!');
+                // Should not reach here
+                expect.fail('Should have thrown UnsupportedProtocolError');
+            }
+            catch (error) {
+                console.log('Error thrown as expected:', error);
+                errorThrown = true;
+                // libp2p throws UnsupportedProtocolError when peer has no handler for protocol
+                expect(error.name).to.equal('UnsupportedProtocolError');
             }
-            expect(receiver.receivedRequests).to.have.lengthOf(5);
+            expect(errorThrown).to.be.true;
         });
-    });
-    describe('Receiver → Caller', () => {
         it('should send request via reader stream and receive response', async () => {
             caller = await env.createNode(LimitedTestTool, {
                 address: new oNodeAddress('o://caller'),
@@ -63,13 +136,14 @@ describe('Bidirectional Communication', () => {
             const callerConn = caller.getFirstConnection();
             const receiverConn = receiver.getFirstConnection();
             await new Promise((resolve) => setTimeout(resolve, 1000));
+            // the following code will not work since the stream listeners are setup after the connections are made
             // if (callerConn) {
             //   caller.setupEventListeners(callerConn);
             // }
             // if (receiverConn) {
             //   receiver.setupStreamListeners(receiverConn);
             // }
-            // // Wait for receiver to identify reader stream
+            // Wait for receiver to identify reader stream
             // await env.waitFor(() => receiver.identifiedStreams.length > 0, 5000, 100);
             // expect(receiver.identifiedStreams).to.have.lengthOf(1);
             // expect(receiver.identifiedStreams[0].role).to.equal('reader');

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

@@ -1,5 +1,6 @@
 import type { oRequest } from '@olane/o-core';
 import { oLimitedTool } from '../../src/o-limited.tool.js';
+import { Libp2pConfig } from '@olane/o-config';
 /**
  * Test tool that uses limited connections
  * Tracks events and call counts for verification
@@ -12,6 +13,7 @@ export declare class LimitedTestTool extends oLimitedTool {
     }>;
     private eventListenersSetup;
     initialize(): Promise<void>;
+    configure(): Promise<Libp2pConfig>;
     /**
      * Set up event listeners for stream manager events
      * Call this after first connection is established

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

@@ -1 +1 @@
-{"version":3,"file":"limited-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/limited-test-tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IACxC,SAAS,SAAK;IACd,mBAAmB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC,CAAM;IACpE,OAAO,CAAC,mBAAmB,CAAS;IAE9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;;OAGG;IACH,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAiD1C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAUjD;;;OAGG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAczD;;OAEG;IACH,eAAe,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC;IAIrD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAO1B"}
+{"version":3,"file":"limited-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/limited-test-tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAEL,YAAY,EAKb,MAAM,iBAAiB,CAAC;AAGzB;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IACxC,SAAS,SAAK;IACd,mBAAmB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC,CAAM;IACpE,OAAO,CAAC,mBAAmB,CAAS;IAE9B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IA+BxC;;;OAGG;IACH,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAiD1C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAUjD;;;OAGG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAczD;;OAEG;IACH,eAAe,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,CAAC;IAIrD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAO1B"}

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

@@ -1,6 +1,8 @@
 import { oLimitedConnectionManager } from '../../src/connection/o-limited-connection-manager.js';
 import { StreamManagerEvent } from '@olane/o-node';
 import { oLimitedTool } from '../../src/o-limited.tool.js';
+import { identify, memory, ping, webSockets, webTransport, } from '@olane/o-config';
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2';
 /**
  * Test tool that uses limited connections
  * Tracks events and call counts for verification
@@ -20,6 +22,35 @@ export class LimitedTestTool extends oLimitedTool {
             runOnLimitedConnection: true,
         });
     }
+    async configure() {
+        const config = await super.configure();
+        config.transports = [
+            memory(),
+            webSockets(),
+            webTransport(),
+            circuitRelayTransport({
+                reservationCompletionTimeout: 30000,
+            }),
+        ];
+        config.services = {
+            identify: identify(),
+            ping: ping({
+                maxOutboundStreams: 1000,
+                maxInboundStreams: 1000,
+            }),
+        };
+        config.connectionGater = {
+            ...config.connectionGater,
+            denyDialPeer: (peerId) => {
+                // as a leader, we can dial anything
+                return false;
+            },
+            denyDialMultiaddr: (multiaddr) => {
+                return false;
+            },
+        };
+        return config;
+    }
     /**
      * Set up event listeners for stream manager events
      * Call this after first connection is established
@@ -93,6 +124,6 @@ export class LimitedTestTool extends oLimitedTool {
      */
     getFirstConnection() {
         const firstEntry = Array.from(this.connectionManager?.cachedConnections?.values() || []);
-        return firstEntry?.[0];
+        return (firstEntry?.[0])[0];
     }
 }

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

@@ -1,5 +1,6 @@
 import { oNodeTool } from '@olane/o-node';
 import type { oRequest } from '@olane/o-core';
+import { Libp2pConfig } from '@olane/o-config';
 /**
  * Standard receiver tool (uses base connection manager)
  * Tracks received requests and identified streams
@@ -12,6 +13,7 @@ export declare class ReceiverTestTool extends oNodeTool {
     }>;
     private eventListenersSetup;
     constructor(config: any);
+    configure(): Promise<Libp2pConfig>;
     /**
      * Set up event listeners for stream identification
      * Call this after tool is started

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

@@ -1 +1 @@
-{"version":3,"file":"receiver-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/receiver-test-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAI9C;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IACtC,gBAAgB,EAAE,QAAQ,EAAE,CAAM;IAClC,iBAAiB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IACzE,OAAO,CAAC,mBAAmB,CAAS;gBAExB,MAAM,EAAE,GAAG;IAIvB;;;OAGG;IACH,oBAAoB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAmB3C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAUjD;;;OAGG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAiBxD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAM1B"}
+{"version":3,"file":"receiver-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/receiver-test-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAG9C,OAAO,EAEL,YAAY,EAKb,MAAM,iBAAiB,CAAC;AAGzB;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IACtC,gBAAgB,EAAE,QAAQ,EAAE,CAAM;IAClC,iBAAiB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IACzE,OAAO,CAAC,mBAAmB,CAAS;gBAExB,MAAM,EAAE,GAAG;IAOjB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAyBxC;;;OAGG;IACH,oBAAoB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAmB3C;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAWjD;;;OAGG;IACG,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAiBxD;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAY1B"}

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

@@ -1,16 +1,45 @@
 import { oNodeTool } from '@olane/o-node';
 import { StreamManagerEvent } from '@olane/o-node';
+import { identify, memory, ping, tcp, webSockets, } from '@olane/o-config';
+import { circuitRelayTransport } from '@libp2p/circuit-relay-v2';
 /**
  * Standard receiver tool (uses base connection manager)
  * Tracks received requests and identified streams
  */
 export class ReceiverTestTool extends oNodeTool {
     constructor(config) {
-        super(config);
+        super({
+            ...config,
+            runOnLimitedConnection: true,
+        });
         this.receivedRequests = [];
         this.identifiedStreams = [];
         this.eventListenersSetup = false;
     }
+    async configure() {
+        const config = await super.configure();
+        config.transports = [
+            webSockets(),
+            circuitRelayTransport({
+                reservationCompletionTimeout: 30000,
+            }),
+            tcp(),
+            memory(),
+        ];
+        config.services = {
+            identify: identify({
+                maxOutboundStreams: 1000,
+                maxInboundStreams: 1000,
+                runOnLimitedConnection: true,
+            }),
+            ping: ping({
+                maxOutboundStreams: 1000,
+                maxInboundStreams: 1000,
+                runOnLimitedConnection: true,
+            }),
+        };
+        return config;
+    }
     /**
      * Set up event listeners for stream identification
      * Call this after tool is started
@@ -32,6 +61,7 @@ export class ReceiverTestTool extends oNodeTool {
      * Simple echo method
      */
     async _tool_echo(request) {
+        this.logger.info('Echo request received');
         this.receivedRequests.push(request);
         return {
             message: request.params.message,
@@ -62,6 +92,10 @@ export class ReceiverTestTool extends oNodeTool {
      */
     getFirstConnection() {
         const firstEntry = Array.from(this.connectionManager?.cachedConnections?.values() || []);
-        return firstEntry?.[0];
+        // filter out relay addresses if there are some
+        const nonRelayConnections = firstEntry?.filter((entry) => {
+            return entry.some((conn) => conn.nextHopAddress.value !== 'o://relay');
+        });
+        return (nonRelayConnections?.[0])[0];
     }
 }

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

@@ -0,0 +1,27 @@
+import { oNodeTool } from '@olane/o-node';
+import type { oRequest } from '@olane/o-core';
+import { Libp2pConfig } from '@olane/o-config';
+/**
+ * Standard receiver tool (uses base connection manager)
+ * Tracks received requests and identified streams
+ */
+export declare class RelayTestTool extends oNodeTool {
+    receivedRequests: oRequest[];
+    identifiedStreams: Array<{
+        streamId: string;
+        role: string;
+    }>;
+    private eventListenersSetup;
+    constructor(config: any);
+    configure(): Promise<Libp2pConfig>;
+    /**
+     * Set up event listeners for stream identification
+     * Call this after tool is started
+     */
+    setupStreamListeners(connection: any): void;
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection(): any;
+}
+//# sourceMappingURL=relay-test-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-test-tool.d.ts","sourceRoot":"","sources":["../../../test/helpers/relay-test-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAY,YAAY,EAAQ,MAAM,iBAAiB,CAAC;AAG/D;;;GAGG;AACH,qBAAa,aAAc,SAAQ,SAAS;IACnC,gBAAgB,EAAE,QAAQ,EAAE,CAAM;IAClC,iBAAiB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IACzE,OAAO,CAAC,mBAAmB,CAAS;gBAExB,MAAM,EAAE,GAAG;IAOjB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAmCxC;;;OAGG;IACH,oBAAoB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAmB3C;;OAEG;IACH,kBAAkB,IAAI,GAAG;CAM1B"}

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

@@ -0,0 +1,75 @@
+import { oNodeTool } from '@olane/o-node';
+import { StreamManagerEvent } from '@olane/o-node';
+import { identify, ping } from '@olane/o-config';
+import { circuitRelayServer } from '@libp2p/circuit-relay-v2';
+/**
+ * Standard receiver tool (uses base connection manager)
+ * Tracks received requests and identified streams
+ */
+export class RelayTestTool extends oNodeTool {
+    constructor(config) {
+        super({
+            ...config,
+            runOnLimitedConnection: true,
+        });
+        this.receivedRequests = [];
+        this.identifiedStreams = [];
+        this.eventListenersSetup = false;
+    }
+    async configure() {
+        const config = await super.configure();
+        config.services = {
+            identify: identify({
+                maxOutboundStreams: Infinity,
+                maxInboundStreams: Infinity,
+                runOnLimitedConnection: true,
+            }),
+            ping: ping({
+                maxOutboundStreams: Infinity,
+                maxInboundStreams: Infinity,
+                runOnLimitedConnection: true,
+            }),
+            relay: circuitRelayServer({
+                reservations: {
+                    maxReservations: Infinity, // need to figure this out
+                    reservationClearInterval: 60000 * 5, // 15 minutes
+                    defaultDurationLimit: 60000 * 15, // 15 minutes
+                    defaultDataLimit: BigInt(1024 * 1024 * 10000), // 10GB
+                },
+            }),
+        };
+        config.listeners = config.listeners?.filter((l) => l.indexOf('/memory/') === -1);
+        config.connectionManager = {
+            ...(config?.connectionManager || {}),
+            maxConnections: 500,
+            maxParallelDials: 100,
+            maxDialQueueLength: 100,
+            maxPeerAddrsToDial: 25,
+        };
+        return config;
+    }
+    /**
+     * Set up event listeners for stream identification
+     * Call this after tool is started
+     */
+    setupStreamListeners(connection) {
+        if (this.eventListenersSetup || !connection?.streamManager) {
+            return;
+        }
+        this.eventListenersSetup = true;
+        // Listen for stream identification events
+        connection.streamManager.on(StreamManagerEvent.StreamIdentified, (data) => {
+            this.identifiedStreams.push({
+                streamId: data.streamId,
+                role: data.role,
+            });
+        });
+    }
+    /**
+     * Get the first connection (for accessing stream manager)
+     */
+    getFirstConnection() {
+        const firstEntry = Array.from(this.connectionManager?.cachedConnections?.values() || []);
+        return (firstEntry?.[0])[0];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-client-limited",
-  "version": "0.7.52",
+  "version": "0.7.54",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -35,6 +35,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
+    "@libp2p/circuit-relay-v2": "^4.0.5",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@typescript-eslint/eslint-plugin": "^8.34.1",
@@ -53,13 +54,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.52",
-    "@olane/o-core": "0.7.52",
-    "@olane/o-node": "0.7.52",
-    "@olane/o-protocol": "0.7.52",
-    "@olane/o-tool": "0.7.52",
+    "@olane/o-config": "0.7.54",
+    "@olane/o-core": "0.7.54",
+    "@olane/o-node": "0.7.54",
+    "@olane/o-protocol": "0.7.54",
+    "@olane/o-tool": "0.7.54",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "706ee0d5b546e96b6c05270b39035ee7e08dadbd"
+  "gitHead": "8e527a1481c6aeaf0840ea30198500a9baef1e98"
 }