@olane/o-node 0.7.40 → 0.7.41

package/dist/src/connection/stream-handler.js

@@ -1,7 +1,6 @@
 import { oRequest, oResponse, CoreUtils, oError, oErrorCodes, Logger, ResponseBuilder, } from '@olane/o-core';
 import { lpStream } from '@olane/o-config';
 import JSON5 from 'json5';
-import { oManagedStream } from './o-managed-stream.js';
 /**
  * StreamHandler centralizes all stream-related functionality including:
  * - Message type detection (request vs response)
@@ -12,7 +11,6 @@ import { oManagedStream } from './o-managed-stream.js';
  */
 export class StreamHandler {
     constructor(logger) {
-        this.streamCache = new Map();
         this.logger = logger ?? new Logger('StreamHandler');
     }
     /**
@@ -85,161 +83,110 @@ export class StreamHandler {
         const addresses = [callerAddress.value, receiverAddress.value].sort();
         return `${addresses[0]}↔${addresses[1]}`;
     }
-    /**
-     * Caches a managed stream for reuse
-     *
-     * @param managedStream - The managed stream to cache
-     */
-    cacheStream(managedStream) {
-        this.streamCache.set(managedStream.cacheKey, managedStream);
-        this.logger.debug('Cached stream', {
-            cacheKey: managedStream.cacheKey,
-            direction: managedStream.direction,
-            streamId: managedStream.stream.id,
-        });
-    }
-    /**
-     * Removes a stream from the cache
-     *
-     * @param stream - The stream to remove
-     */
-    removeStreamFromCache(stream) {
-        // Find and remove the stream from cache
-        for (const [key, managedStream] of this.streamCache.entries()) {
-            if (managedStream.stream.id === stream.id) {
-                this.streamCache.delete(key);
-                this.logger.debug('Removed stream from cache', {
-                    cacheKey: key,
-                    streamId: stream.id,
-                });
-                break;
-            }
-        }
-    }
-    /**
-     * Sets up cleanup listener for stream close events
-     *
-     * @param stream - The stream to monitor
-     */
-    setupStreamCleanup(stream) {
-        // Listen for stream close event
-        stream.addEventListener('close', () => {
-            this.removeStreamFromCache(stream);
-        });
-    }
-    /**
-     * Extracts the remote peer's address from a connection
-     * Falls back to creating an address from the peer ID if no address metadata is available
-     *
-     * @param connection - The libp2p connection
-     * @returns The remote peer's oAddress
-     */
-    extractRemotePeerAddress(connection) {
-        // Try to get address from connection metadata if available
-        // For now, create address from peer ID as fallback
-        const peerId = connection.remotePeer.toString();
-        // Import oAddress at runtime to avoid circular dependency
-        const { oAddress: oAddressClass } = require('@olane/o-core');
-        return new oAddressClass(`o://peer/${peerId}`);
-    }
-    /**
-     * Caches an inbound stream for bidirectional reuse
-     * This allows the same stream to be reused for responses
-     *
-     * @param stream - The inbound stream to cache
-     * @param callerAddress - The address of the caller
-     * @param receiverAddress - The address of the receiver (local node)
-     * @param reusePolicy - Whether to enable caching
-     */
-    cacheInboundStream(stream, callerAddress, receiverAddress, reusePolicy = 'none') {
-        if (reusePolicy !== 'reuse') {
-            return;
-        }
-        const cacheKey = this.buildCacheKey(callerAddress, receiverAddress);
-        // Check if already cached
-        if (this.streamCache.has(cacheKey)) {
-            this.logger.debug('Stream already cached', { cacheKey });
-            return;
-        }
-        const managedStream = new oManagedStream(stream, callerAddress, receiverAddress, 'inbound');
-        this.cacheStream(managedStream);
-        this.setupStreamCleanup(stream);
-    }
-    /**
-     * Gets an existing open stream or creates a new one based on reuse policy
-     *
-     * @param connection - The libp2p connection
-     * @param protocol - The protocol to use for the stream
-     * @param config - Stream handler configuration
-     * @param streamAddresses - Optional addresses for address-based stream reuse
-     */
-    async getOrCreateStream(connection, protocol, config = {}, streamAddresses) {
-        this.logger.debug(`Getting or creating stream for protocol: ${protocol}, connection`, {
-            status: connection.status,
-            remoteAddr: connection.remoteAddr.toString(),
-            streamCount: connection.streams.length,
-            reusePolicy: config.reusePolicy ?? 'none',
-            hasAddresses: !!streamAddresses,
-        });
-        if (connection.status !== 'open') {
-            throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
-        }
-        const reusePolicy = config.reusePolicy ?? 'none';
-        // Check address-based cache if reuse is enabled and addresses provided
-        if (reusePolicy === 'reuse' && streamAddresses) {
-            const cacheKey = this.buildCacheKey(streamAddresses.callerAddress, streamAddresses.receiverAddress);
-            const cachedStream = this.streamCache.get(cacheKey);
-            if (cachedStream?.isReusable) {
-                this.logger.debug('Reusing cached stream by address', {
-                    cacheKey,
-                    streamId: cachedStream.stream.id,
-                    direction: cachedStream.direction,
-                });
-                cachedStream.updateLastUsed();
-                return cachedStream.stream;
-            }
-            else if (cachedStream) {
-                // Stream exists but not reusable, remove from cache
-                this.logger.debug('Removing non-reusable stream from cache', {
-                    cacheKey,
-                    status: cachedStream.stream.status,
-                });
-                this.streamCache.delete(cacheKey);
-            }
-        }
-        this.logger.debug('No reusable cached stream found, checking connection streams', connection.streams.map((s) => ({
-            status: s.status,
-            protocol: s.protocol,
-            writeStatus: s.writeStatus,
-            remoteReadStatus: s.remoteReadStatus,
-            id: s.id,
-        })));
-        // Fallback to protocol-based check (legacy behavior)
-        if (reusePolicy === 'reuse' && !streamAddresses) {
-            const existingStream = connection.streams.find((stream) => stream.status === 'open' &&
-                stream.protocol === protocol &&
-                stream.writeStatus === 'writable' &&
-                stream.remoteReadStatus === 'readable');
-            if (existingStream) {
-                this.logger.debug('Reusing existing stream by protocol (legacy)', existingStream.id, existingStream.direction);
-                return existingStream;
-            }
-        }
-        // Create new stream
-        this.logger.debug('Creating new stream', { protocol });
-        const stream = await connection.newStream(protocol, {
-            signal: config.signal,
-            maxOutboundStreams: config.maxOutboundStreams ?? 1000,
-            runOnLimitedConnection: config.runOnLimitedConnection ?? false,
-        });
-        // Cache the stream if reuse is enabled and addresses are provided
-        if (reusePolicy === 'reuse' && streamAddresses) {
-            const managedStream = new oManagedStream(stream, streamAddresses.callerAddress, streamAddresses.receiverAddress, streamAddresses.direction);
-            this.cacheStream(managedStream);
-            this.setupStreamCleanup(stream);
-        }
-        return stream;
-    }
+    // /**
+    //  * Gets an existing open stream or creates a new one based on reuse policy
+    //  *
+    //  * @param connection - The libp2p connection
+    //  * @param protocol - The protocol to use for the stream
+    //  * @param config - Stream handler configuration
+    //  * @param streamAddresses - Optional addresses for address-based stream reuse
+    //  */
+    // async getOrCreateStream(
+    //   connection: Connection,
+    //   protocol: string,
+    //   config: StreamHandlerConfig = {},
+    //   streamAddresses?: {
+    //     callerAddress: oAddress;
+    //     receiverAddress: oAddress;
+    //     direction: 'inbound' | 'outbound';
+    //   },
+    // ): Promise<Stream> {
+    //   this.logger.debug(
+    //     `Getting or creating stream for protocol: ${protocol}, connection`,
+    //     {
+    //       status: connection.status,
+    //       remoteAddr: connection.remoteAddr.toString(),
+    //       streamCount: connection.streams.length,
+    //       reusePolicy: config.reusePolicy ?? 'none',
+    //       hasAddresses: !!streamAddresses,
+    //     },
+    //   );
+    //   if (connection.status !== 'open') {
+    //     throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
+    //   }
+    //   const reusePolicy = config.reusePolicy ?? 'none';
+    //   // Check address-based cache if reuse is enabled and addresses provided
+    //   if (reusePolicy === 'reuse' && streamAddresses) {
+    //     const cacheKey = this.buildCacheKey(
+    //       streamAddresses.callerAddress,
+    //       streamAddresses.receiverAddress,
+    //     );
+    //     const cachedStream = this.streamCache.get(cacheKey);
+    //     if (cachedStream?.isReusable) {
+    //       this.logger.debug('Reusing cached stream by address', {
+    //         cacheKey,
+    //         streamId: cachedStream.stream.id,
+    //         direction: cachedStream.direction,
+    //       });
+    //       cachedStream.updateLastUsed();
+    //       return cachedStream.stream;
+    //     } else if (cachedStream) {
+    //       // Stream exists but not reusable, remove from cache
+    //       this.logger.debug('Removing non-reusable stream from cache', {
+    //         cacheKey,
+    //         status: cachedStream.stream.status,
+    //       });
+    //       this.streamCache.delete(cacheKey);
+    //     }
+    //   }
+    //   this.logger.debug(
+    //     'No reusable cached stream found, checking connection streams',
+    //     connection.streams.map((s) => ({
+    //       status: s.status,
+    //       protocol: s.protocol,
+    //       writeStatus: s.writeStatus,
+    //       remoteReadStatus: s.remoteReadStatus,
+    //       id: s.id,
+    //     })),
+    //   );
+    //   // Fallback to protocol-based check (legacy behavior)
+    //   if (reusePolicy === 'reuse' && !streamAddresses) {
+    //     const existingStream = connection.streams.find(
+    //       (stream) =>
+    //         stream.status === 'open' &&
+    //         stream.protocol === protocol &&
+    //         stream.writeStatus === 'writable' &&
+    //         stream.remoteReadStatus === 'readable',
+    //     );
+    //     if (existingStream) {
+    //       this.logger.debug(
+    //         'Reusing existing stream by protocol (legacy)',
+    //         existingStream.id,
+    //         existingStream.direction,
+    //       );
+    //       return existingStream;
+    //     }
+    //   }
+    //   // Create new stream
+    //   this.logger.debug('Creating new stream', { protocol });
+    //   const stream = await connection.newStream(protocol, {
+    //     signal: config.signal,
+    //     maxOutboundStreams: config.maxOutboundStreams ?? 1000,
+    //     runOnLimitedConnection: config.runOnLimitedConnection ?? false,
+    //   });
+    //   // Cache the stream if reuse is enabled and addresses are provided
+    //   if (reusePolicy === 'reuse' && streamAddresses) {
+    //     const managedStream = new oNodeConnectionStream(
+    //       stream,
+    //       streamAddresses.callerAddress,
+    //       streamAddresses.receiverAddress,
+    //       streamAddresses.direction,
+    //     );
+    //     this.cacheStream(managedStream);
+    //     this.setupStreamCleanup(stream);
+    //   }
+    //   return stream;
+    // }
     /**
      * Sends data through a stream using length-prefixed encoding (libp2p v3 best practice)
      * Each message is automatically prefixed with a varint indicating the message length
@@ -253,28 +200,6 @@ export class StreamHandler {
         const lp = lpStream(stream);
         await lp.write(data, { signal: config.signal });
     }
-    /**
-     * Closes a stream safely with error handling
-     *
-     * @param stream - The stream to close
-     * @param config - Configuration including reuse policy
-     */
-    async close(stream, config = {}) {
-        // Don't close if reuse policy is enabled
-        if (config.reusePolicy === 'reuse') {
-            this.logger.debug('Stream reuse enabled, not closing stream');
-            return;
-        }
-        if (stream.status === 'open') {
-            try {
-                // force the close for now until we can implement a proper close
-                await stream.abort(new Error('Stream closed'));
-            }
-            catch (error) {
-                this.logger.debug('Error closing stream:', error.message);
-            }
-        }
-    }
     /**
      * Handles an incoming stream on the server side using length-prefixed protocol
      * Uses async read loops instead of event listeners (libp2p v3 best practice)

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

@@ -9,9 +9,11 @@ declare const oNodeTool_base: typeof oServerNode;
  */
 export declare class oNodeTool extends oNodeTool_base {
     private streamHandler;
+    handleProtocolReuse(address: oAddress): Promise<void>;
     handleProtocol(address: oAddress): Promise<void>;
     initialize(): Promise<void>;
-    handleStream(stream: Stream, connection: Connection): Promise<void>;
+    handleStreamReuse(stream: Stream, connection: Connection): Promise<void>;
+    handleStream(stream: Stream, connection: Connection, reuse?: boolean): Promise<void>;
     _tool_identify(): Promise<any>;
     _tool_child_register(request: oRequest): Promise<any>;
 }

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;;AAKrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAehC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCnE,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;;AAMrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAgBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAoBhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B,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;IAwCV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAgC5D"}

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

@@ -4,25 +4,46 @@ import { oServerNode } from './nodes/server.node.js';
 import { oNodeTransport } from './router/o-node.transport.js';
 import { oNodeAddress } from './router/o-node.address.js';
 import { StreamHandler } from './connection/stream-handler.js';
+import { ConnectionUtils } from './utils/connection.utils.js';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
  * @param Base - The base class to extend
  * @returns A new class that extends the base class and implements the oTool interface
  */
 export class oNodeTool extends oTool(oServerNode) {
+    async handleProtocolReuse(address) {
+        const reuseProtocol = address.protocol + '/reuse';
+        const protocols = this.p2pNode.getProtocols();
+        if (protocols.find((p) => p === reuseProtocol)) {
+            // already handling
+            return;
+        }
+        const maxOutboundsStreams = process.env.MAX_OUTBOUND_STREAMS
+            ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
+            : 1000;
+        await this.p2pNode.handle(reuseProtocol, this.handleStream.bind(this), {
+            maxInboundStreams: 10000,
+            maxOutboundStreams: maxOutboundsStreams,
+        });
+    }
     async handleProtocol(address) {
         const protocols = this.p2pNode.getProtocols();
         if (protocols.find((p) => p === address.protocol)) {
             // already handling
             return;
         }
-        this.logger.debug('Handling protocol: ' + address.protocol);
+        const maxOutboundsStreams = process.env.MAX_OUTBOUND_STREAMS
+            ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
+            : 1000;
+        this.logger.debug('Handling protocol: ' + address.protocol, {
+            maxInboundStreams: 10000,
+            maxOutboundStreams: maxOutboundsStreams,
+        });
         await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
             maxInboundStreams: 10000,
-            maxOutboundStreams: process.env.MAX_OUTBOUND_STREAMS
-                ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
-                : 1000,
+            maxOutboundStreams: maxOutboundsStreams,
         });
+        await this.handleProtocolReuse(address);
     }
     async initialize() {
         await super.initialize();
@@ -33,12 +54,25 @@ export class oNodeTool extends oTool(oServerNode) {
             await this.handleProtocol(this.staticAddress);
         }
     }
-    async handleStream(stream, connection) {
-        // Extract caller address from connection
-        const callerAddress = this.streamHandler.extractRemotePeerAddress(connection);
-        // Cache inbound stream for bidirectional reuse (if reuse policy is enabled)
-        // The cacheInboundStream method will check the reuse policy
-        this.streamHandler.cacheInboundStream(stream, callerAddress, this.address, 'reuse');
+    async handleStreamReuse(stream, connection) {
+        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.connectionManager.answer({
+            nextHopAddress: remoteAddress,
+            address: remoteAddress,
+            callerAddress: this.address,
+            p2pConnection: connection,
+            reuse,
+        });
         // Use StreamHandler for consistent stream handling
         // This follows libp2p v3 best practices for length-prefixed streaming
         await this.streamHandler.handleIncomingStream(stream, connection, async (request, stream) => {
@@ -61,7 +95,6 @@ export class oNodeTool extends oTool(oServerNode) {
         };
     }
     async _tool_child_register(request) {
-        this.logger.debug('Child register: ', request.params);
         const { address, transports } = request.params;
         const childAddress = new oNodeAddress(address, transports.map((t) => new oNodeTransport(t)));
         // Add child to hierarchy

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

@@ -14,5 +14,6 @@ export declare class oNodeAddress extends oAddress {
     toString(): string;
     toMultiaddr(): Multiaddr;
     static fromMultiaddr(ma: Multiaddr): oAddress;
+    static fromProtocol(protocol: string): oAddress;
 }
 //# sourceMappingURL=o-node.address.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.address.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAqB,QAAQ,EAAiB,MAAM,eAAe,CAAC;AAE3E,qBAAa,YAAa,SAAQ,QAAQ;aAItB,KAAK,EAAE,MAAM;IAHxB,UAAU,EAAE,cAAc,EAAE,CAAM;gBAGvB,KAAK,EAAE,MAAM,EAC7B,UAAU,GAAE,cAAc,EAAO;IAMnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;KACpC,GAAG,YAAY;IAShB,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,SAAS;IAIxB,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ;CAG9C"}
+{"version":3,"file":"o-node.address.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAiB,MAAM,eAAe,CAAC;AAExD,qBAAa,YAAa,SAAQ,QAAQ;aAItB,KAAK,EAAE,MAAM;IAHxB,UAAU,EAAE,cAAc,EAAE,CAAM;gBAGvB,KAAK,EAAE,MAAM,EAC7B,UAAU,GAAE,cAAc,EAAO;IAMnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;KACpC,GAAG,YAAY;IAShB,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,SAAS;IAIxB,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ;IAI7C,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ;CAIhD"}

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

@@ -26,4 +26,8 @@ export class oNodeAddress extends oAddress {
     static fromMultiaddr(ma) {
         return new oAddress(ma.toString().replace('/o/', 'o://'));
     }
+    static fromProtocol(protocol) {
+        const addressInput = protocol.replace('/o/', 'o://');
+        return new oAddress(addressInput);
+    }
 }

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

@@ -0,0 +1,9 @@
+import { Connection } from '@olane/o-config';
+import { oObject } from '@olane/o-core';
+export declare class ConnectionUtils extends oObject {
+    static addressFromConnection(options: {
+        currentNode: any;
+        connection: Connection;
+    }): Promise<import("@olane/o-core").oAddress>;
+}
+//# sourceMappingURL=connection.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,qBAAa,eAAgB,SAAQ,OAAO;WACtB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CAsCF"}

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

@@ -0,0 +1,26 @@
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+export class ConnectionUtils extends oObject {
+    static async addressFromConnection(options) {
+        const { currentNode, connection } = options;
+        const p2pNode = currentNode.p2pNode;
+        // Extract the actual olane address from the peer store
+        const peers = await p2pNode.peerStore.all();
+        const remotePeer = peers.find((peer) => peer.id.toString() === connection.remotePeer.toString());
+        if (!remotePeer) {
+            console.log('Failed to find peer:', remotePeer);
+            throw new Error(`Failed to extract remote address, peer ${connection.remotePeer.toString()} not found in peer store.`);
+        }
+        // Get origin address for comparison
+        const originAddress = currentNode.address?.value;
+        if (!originAddress) {
+            throw new Error('Origin address is not configured');
+        }
+        const originProtocol = originAddress.toString();
+        const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/') && p.startsWith(originProtocol) === false);
+        if (!oProtocol) {
+            throw new Error('Failed to extract remote address, could not find o-protocol in peer protocols.');
+        }
+        return oNodeAddress.fromProtocol(oProtocol);
+    }
+}

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

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

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

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

package/dist/src/utils/index.js

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

package/dist/test/astream-reuse.spec.d.ts

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

package/dist/test/astream-reuse.spec.d.ts.map

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

package/dist/test/astream-reuse.spec.js

@@ -0,0 +1,107 @@
+import { expect } from 'chai';
+import { TestEnvironment } from './helpers/index.js';
+import { NetworkTopologies, } from './helpers/network-builder.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+describe('Stream Reuse', () => {
+    const env = new TestEnvironment();
+    let builder;
+    afterEach(async () => {
+        if (builder) {
+            await builder.cleanup();
+        }
+        await env.cleanup();
+    });
+    describe('Stream Reuse with reusePolicy="reuse"', () => {
+        it('should reuse the same stream across multiple requests', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Track stream IDs
+            const streamIds = [];
+            // Make first request
+            const response1 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'first' },
+            });
+            expect(response1.result.success).to.be.true;
+            // Get active connection to inspect streams
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            connection.reusePolicy;
+            if (connection) {
+                // Store initial stream count and first stream ID
+                const initialStreamCount = connection.streams.length;
+                if (connection.streams.length > 0) {
+                    streamIds.push(connection.streams[0].id);
+                }
+                // Make second request
+                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: 'second' },
+                });
+                expect(response2.result.success).to.be.true;
+                // Get stream count after second request
+                const finalStreamCount = connection.streams.length;
+                if (connection.streams.length > 0) {
+                    streamIds.push(connection.streams[0].id);
+                }
+                // With default behavior (reusePolicy='none'), new streams are created
+                // This test verifies current behavior
+                expect(streamIds.length).to.be.greaterThan(0);
+                expect(finalStreamCount).to.be.greaterThan(0);
+            }
+        });
+    });
+    describe('Stream Creation with reusePolicy="none"', () => {
+        it('should create new streams for each request', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Make multiple requests
+            for (let i = 0; i < 3; i++) {
+                const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+                expect(response.result.success).to.be.true;
+            }
+            // Get connection to verify stream behavior
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            // With default reusePolicy='none', streams are closed after each request
+            // So we expect minimal open streams
+            expect(connection).to.exist;
+            if (connection) {
+                // The number of open streams should be limited since old ones are closed
+                expect(connection.streams.length).to.be.lessThan(10);
+            }
+        });
+    });
+    describe('Stream Persistence After Transmission', () => {
+        it('should close streams after transmission with reusePolicy="none"', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Make a request
+            const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            expect(response.result.success).to.be.true;
+            // Get connection
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            expect(connection).to.exist;
+            if (connection) {
+                // Make another request to verify new stream can be created
+                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: 'test2' },
+                });
+                expect(response2.result.success).to.be.true;
+                // Verify connection is still functional
+                expect(connection.status).to.equal('open');
+            }
+        });
+    });
+});

package/dist/test/connection-management.spec.js

@@ -16,6 +16,7 @@ describe('Connection Management', () => {
     describe('Connection Pooling', () => {
         it('should cache and reuse connections', async () => {
             builder = await NetworkTopologies.twoNode();
+            console.log('Built the 2 node network, starting test');
             const leader = builder.getNode('o://leader');
             const child = builder.getNode('o://child');
             const spy = createConnectionSpy(leader);