@olane/o-node 0.7.54 → 0.7.56

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

@@ -1,5 +1,10 @@
 import { oConnectionManager } from '@olane/o-core';
 import { oNodeConnection } from './o-node-connection.js';
+import { EventEmitter } from 'events';
+import { oNodeStream } from './o-node-stream.js';
+/**
+ * Manages oNodeConnection instances, reusing connections when possible.
+ */
 export class oNodeConnectionManager extends oConnectionManager {
     constructor(config) {
         super(config);
@@ -7,10 +12,11 @@ export class oNodeConnectionManager extends oConnectionManager {
         /** Single cache of oNodeConnection instances keyed by address */
         this.cachedConnections = new Map();
         this.pendingDialsByAddress = new Map();
+        this.eventEmitter = new EventEmitter();
         this.p2pNode = config.p2pNode;
         this.defaultReadTimeoutMs = config.defaultReadTimeoutMs;
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
-        this.logger.setNamespace(`oNodeConnectionManager[${config.originAddress}]`);
+        this.logger.setNamespace(`oNodeConnectionManager[${config.callerAddress}]`);
         // Set up connection lifecycle listeners for cache management
         this.setupConnectionListeners();
     }
@@ -24,35 +30,9 @@ export class oNodeConnectionManager extends oConnectionManager {
                 return;
             }
             const connectionId = connection.id;
-            // Clean up cached connections by filtering out the closed connection
-            for (const [key, conns] of this.cachedConnections.entries()) {
-                const filtered = conns.filter((c) => c.p2pConnection.id !== connectionId);
-                if (filtered.length === 0) {
-                    this.logger.debug('Connection closed, removing all cached connections for address:', key);
-                    this.cachedConnections.delete(key);
-                }
-                else if (filtered.length !== conns.length) {
-                    this.logger.debug('Connection closed, updating cached connections for address:', key);
-                    this.cachedConnections.set(key, filtered);
-                }
-            }
+            this.cachedConnections.delete(connectionId);
         });
     }
-    /**
-     * Build a stable cache key from an address.
-     *
-     * We key the cache by address value (e.g., "o://my-tool") to maintain
-     * a simple one-to-one mapping between addresses and connections.
-     */
-    getAddressKey(address) {
-        try {
-            return address.value || null;
-        }
-        catch (error) {
-            this.logger.debug('Error extracting address key from address:', error);
-            return null;
-        }
-    }
     /**
      * Extract peer ID string from an address
      * @param address - The address to extract peer ID from
@@ -71,71 +51,22 @@ export class oNodeConnectionManager extends oConnectionManager {
             return null;
         }
     }
-    /**
-     * Get the first valid (open) connection for the given address key.
-     * Cleans up stale connections from the cache automatically.
-     *
-     * @param addressKey - The address key to look up
-     * @returns A valid oNodeConnection or null if none found
-     */
-    getValidConnection(addressKey) {
-        const connections = this.cachedConnections.get(addressKey) || [];
-        // Filter to open connections
-        const valid = connections.filter((c) => c.p2pConnection?.status === 'open');
-        // Update cache if we cleaned any stale connections
-        if (valid.length !== connections.length) {
-            if (valid.length === 0) {
-                this.cachedConnections.delete(addressKey);
-            }
-            else {
-                this.cachedConnections.set(addressKey, valid);
-            }
-        }
-        return valid[0] ?? null;
-    }
     /**
      * Cache an oNodeConnection by its address key.
      * @param conn - The oNodeConnection to cache
      * @param addressKey - The address key to cache under
      */
-    cacheConnection(conn, addressKey) {
-        this.logger.debug('Caching connection for address:', addressKey, conn.p2pConnection.id, conn.p2pConnection.direction);
-        const existing = this.cachedConnections.get(addressKey) || [];
-        existing.push(conn);
-        this.cachedConnections.set(addressKey, existing);
-    }
-    /**
-     * Get oNodeConnection by libp2p Connection reference
-     * Used to find the correct oNodeConnection for incoming streams
-     * @param p2pConnection - The libp2p connection to search for
-     * @returns The oNodeConnection or undefined if not found
-     */
-    getConnectionByP2pConnection(p2pConnection) {
-        // Search through all cached connections
-        for (const connections of this.cachedConnections.values()) {
-            const found = connections.find((conn) => conn.p2pConnection.id === p2pConnection.id);
-            if (found) {
-                return found;
-            }
-        }
-        return undefined;
+    cacheConnection(conn) {
+        this.logger.debug('Caching connection for address:', conn.p2pConnection.id, conn.p2pConnection.direction, conn.nextHopAddress.value, conn.p2pConnection.streams.map((s) => s.protocol).join(', '));
+        this.cachedConnections.set(conn.p2pConnection.id, conn);
     }
     /**
      * Get or create a raw p2p connection to the given address.
      * Subclasses can override connect() and use this method to get the underlying p2p connection.
      */
     async getOrCreateP2pConnection(nextHopAddress, addressKey) {
-        // Check if libp2p already has an active connection for this peer
-        const peerId = this.getPeerIdFromAddress(nextHopAddress);
-        if (peerId) {
-            const connections = this.p2pNode.getConnections();
-            const existingConnection = connections.find((conn) => conn.remotePeer?.toString() === peerId && conn.status === 'open');
-            if (existingConnection) {
-                this.logger.debug('Found existing libp2p connection for address:', addressKey);
-                return existingConnection;
-            }
-        }
         // Check if dial is already in progress for this address key
+        this.logger.debug('Checking for pending dial for address:', addressKey);
         const pendingDial = this.pendingDialsByAddress.get(addressKey);
         if (pendingDial) {
             this.logger.debug('Awaiting existing dial for address:', addressKey);
@@ -164,37 +95,46 @@ export class oNodeConnectionManager extends oConnectionManager {
         });
         return connection;
     }
-    async answer(config) {
-        const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, reuse, } = config;
-        const addressKey = this.getAddressKey(nextHopAddress);
-        if (!addressKey) {
-            this.logger.error('Failed to generate an address key for address:', nextHopAddress);
-            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
-        }
+    async createConnection(config) {
+        return new oNodeConnection(config);
+    }
+    async answer(config, stream) {
+        const { targetAddress, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, } = config;
+        if (!p2pConnection) {
+            throw new Error('Failed to answer connection, p2pConnection is undefined');
+        }
+        this.logger.debug('Answering connection for address:', {
+            address: nextHopAddress?.value,
+            connectionId: p2pConnection.id,
+            direction: p2pConnection.direction,
+        });
         // Check if we already have a cached connection for this address with the same connection id
-        const connections = this.cachedConnections.get(addressKey) || [];
-        // Filter to open connections
-        const validConnections = connections.filter((c) => c.p2pConnection?.id === p2pConnection.id &&
-            c.p2pConnection?.status === 'open');
-        if (validConnections.length > 0) {
-            const existingConnection = validConnections[0];
-            this.logger.debug('Reusing cached connection for answer:', addressKey, existingConnection.p2pConnection.id);
+        const existingConnection = this.cachedConnections.get(p2pConnection.id);
+        if (existingConnection) {
+            this.logger.debug('Reusing cached connection for answer:', existingConnection.id);
+            existingConnection.trackStream(new oNodeStream(stream, {
+                remoteAddress: nextHopAddress,
+                limited: this.config.runOnLimitedConnection,
+            }), config);
             return existingConnection;
         }
-        const connection = new oNodeConnection({
+        const connection = await this.createConnection({
             nextHopAddress: nextHopAddress,
-            address: address,
-            p2pConnection: p2pConnection,
+            targetAddress: targetAddress,
             callerAddress: callerAddress,
             readTimeoutMs: readTimeoutMs ?? this.defaultReadTimeoutMs,
             drainTimeoutMs: drainTimeoutMs ?? this.defaultDrainTimeoutMs,
             isStream: config.isStream ?? false,
             abortSignal: config.abortSignal,
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
-            reusePolicy: reuse ? 'reuse' : 'none',
+            p2pConnection: p2pConnection,
         });
+        connection.trackStream(new oNodeStream(stream, {
+            remoteAddress: nextHopAddress,
+            limited: this.config.runOnLimitedConnection,
+        }), config);
         // Cache the new connection
-        this.cacheConnection(connection, addressKey);
+        this.cacheConnection(connection);
         return connection;
     }
     /**
@@ -203,26 +143,29 @@ export class oNodeConnectionManager extends oConnectionManager {
      * @returns The connection object
      */
     async connect(config) {
-        const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
+        const { targetAddress, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
         if (!nextHopAddress) {
             throw new Error('Invalid address passed');
         }
-        const addressKey = this.getAddressKey(nextHopAddress);
-        if (!addressKey) {
-            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
+        if (nextHopAddress.libp2pTransports?.length === 0) {
+            throw new Error('No transports provided for the address, cannot connect');
         }
         // Check for existing valid cached connection
-        const existingConnection = this.getValidConnection(addressKey);
+        const existingConnection = this.getCachedConnectionFromAddress(nextHopAddress);
         if (existingConnection) {
-            this.logger.debug('Reusing cached connection for address:', addressKey, existingConnection.p2pConnection.id);
+            this.logger.debug('Reusing cached connection for address:', existingConnection.p2pConnection.id);
             return existingConnection;
         }
+        else {
+            this.logger.debug('No cached connection found for address:', {
+                address: nextHopAddress.value,
+            });
+        }
         // Get or create the underlying p2p connection
-        const p2pConnection = await this.getOrCreateP2pConnection(nextHopAddress, addressKey);
-        // Create new oNodeConnection
-        const connection = new oNodeConnection({
+        const p2pConnection = await this.getOrCreateP2pConnection(nextHopAddress, nextHopAddress.value);
+        const connection = await this.createConnection({
             nextHopAddress: nextHopAddress,
-            address: address,
+            targetAddress: targetAddress,
             p2pConnection: p2pConnection,
             callerAddress: callerAddress,
             readTimeoutMs: readTimeoutMs ?? this.defaultReadTimeoutMs,
@@ -232,89 +175,22 @@ export class oNodeConnectionManager extends oConnectionManager {
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
         });
         // Cache the new connection
-        this.cacheConnection(connection, addressKey);
+        this.cacheConnection(connection);
         return connection;
     }
-    /**
-     * Check if we have an active connection to the target peer
-     * @param address - The address to check
-     * @returns true if an active connection exists
-     */
-    isCached(address) {
-        try {
-            const addressKey = this.getAddressKey(address);
-            if (!addressKey) {
-                return false;
+    getCachedConnectionFromAddress(address) {
+        const vals = Array.from(this.cachedConnections.values());
+        for (const c in vals) {
+            const connection = c;
+            const peerId = address.libp2pTransports?.[0].toPeerId();
+            if (connection.p2pConnection?.remotePeer.toString() === peerId &&
+                connection.isOpen) {
+                return connection;
             }
-            return this.getValidConnection(addressKey) !== null;
-        }
-        catch (error) {
-            this.logger.debug('Error checking cached connection:', error);
-            return false;
         }
+        return null;
     }
-    /**
-     * Get an existing cached oNodeConnection for the target address
-     * @param address - The address to get a connection for
-     * @returns The oNodeConnection or null if not found
-     */
-    getCachedConnection(address) {
-        try {
-            const addressKey = this.getAddressKey(address);
-            if (!addressKey) {
-                return null;
-            }
-            return this.getValidConnection(addressKey);
-        }
-        catch (error) {
-            this.logger.debug('Error getting cached connection:', error);
-            return null;
-        }
-    }
-    /**
-     * Get cache statistics for monitoring and debugging
-     * @returns Object containing cache statistics
-     */
-    getCacheStats() {
-        const allConnections = [];
-        for (const [addressKey, connections] of this.cachedConnections.entries()) {
-            for (const conn of connections) {
-                allConnections.push({
-                    peerId: conn.p2pConnection?.remotePeer?.toString() ?? 'unknown',
-                    status: conn.p2pConnection?.status ?? 'unknown',
-                    addressKey,
-                });
-            }
-        }
-        return {
-            cachedAddresses: this.cachedConnections.size,
-            totalCachedConnections: allConnections.length,
-            pendingDials: this.pendingDialsByAddress.size,
-            connectionsByPeer: allConnections,
-        };
-    }
-    /**
-     * Clean up all stale (non-open) connections from cache
-     * @returns Number of connections removed
-     */
-    cleanupStaleConnections() {
-        let removed = 0;
-        for (const [addressKey, connections] of this.cachedConnections.entries()) {
-            const openConnections = connections.filter((conn) => conn.p2pConnection?.status === 'open');
-            const staleCount = connections.length - openConnections.length;
-            if (staleCount > 0) {
-                removed += staleCount;
-                if (openConnections.length === 0) {
-                    this.cachedConnections.delete(addressKey);
-                }
-                else {
-                    this.cachedConnections.set(addressKey, openConnections);
-                }
-            }
-        }
-        if (removed > 0) {
-            this.logger.debug(`Cleaned up ${removed} stale connections`);
-        }
-        return removed;
+    get connectionCount() {
+        return this.cachedConnections.size;
     }
 }

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

@@ -1,21 +1,53 @@
+/// <reference types="node" />
 import type { Stream } from '@libp2p/interface';
-import { oObject } from '@olane/o-core';
+import { oObject, oRequest, oResponse } from '@olane/o-core';
 import { oNodeStreamConfig } from './interfaces/o-node-stream.config.js';
+import { LengthPrefixedStream } from '@olane/o-config';
+import { AbortSignalConfig } from './interfaces/abort-signal.config.js';
+import { EventEmitter } from 'events';
+import { oNodeMessageEvent, oNodeMessageEventData } from './enums/o-node-message-event.js';
 /**
- * oNodeStream wraps a libp2p Stream with caller/receiver address metadata
- * to enable proper stream reuse based on address pairs rather than protocol only.
- *
- * Key features:
- * - Bidirectional cache keys: A↔B === B↔A
- * - Automatic reusability checking
- * - Idle time tracking for cleanup
+ * oNodeStream wraps a libp2p Stream and transmits or receives messages across the libp2p streams
  */
 export declare class oNodeStream extends oObject {
     readonly p2pStream: Stream;
     readonly config: oNodeStreamConfig;
     readonly createdAt: number;
+    protected readonly lp: LengthPrefixedStream;
+    protected readonly eventEmitter: EventEmitter;
     constructor(p2pStream: Stream, config: oNodeStreamConfig);
+    listenForLibp2pEvents(): void;
     validate(): void;
+    /**
+     * Extracts and parses JSON from various formats including:
+     * - Already parsed objects
+     * - Plain JSON
+     * - Markdown code blocks (```json ... ``` or ``` ... ```)
+     * - Mixed content with explanatory text
+     * - JSON5 format (trailing commas, comments, unquoted keys, etc.)
+     *
+     * @param decoded - The decoded string that may contain JSON, or an already parsed object
+     * @returns Parsed JSON object
+     * @throws Error if JSON parsing fails even with JSON5 fallback
+     */
+    protected extractAndParseJSON(decoded: string | any): any;
+    send(request: oRequest, options: AbortSignalConfig): Promise<void>;
+    /**
+     * listen - process every message inbound on the stream and emit it for the connection to bubble up
+     * @param options
+     */
+    listen(options: AbortSignalConfig): Promise<void>;
+    listenOnce(options: AbortSignalConfig): Promise<void>;
+    waitForResponse(requestId: string): Promise<oResponse>;
+    /**
+     * Detects if a decoded message is a request
+     * Requests have a 'method' field and no 'result' field
+     */
+    isRequest(message: any): boolean;
+    /**
+     * Detects if a decoded message is a response
+     */
+    isResponse(message: any): boolean;
     /**
      * Checks if the stream is in a valid state:
      * - Stream status is 'open'
@@ -29,18 +61,19 @@ export declare class oNodeStream extends oObject {
      * Gets the age of the stream in milliseconds
      */
     get age(): number;
+    close(): Promise<void>;
+    get id(): string;
     /**
-     * Returns the stream type (defaults to 'general' for backward compatibility)
+     * Add event listener
      */
-    get streamType(): string;
+    on<K extends oNodeMessageEvent>(event: K, listener: (data: oNodeMessageEventData[K]) => void): void;
     /**
-     * Checks if this stream is designated as a dedicated reader
+     * Remove event listener
      */
-    get isDedicatedReader(): boolean;
+    off<K extends oNodeMessageEvent>(event: K, listener: (data: oNodeMessageEventData[K]) => void): void;
     /**
-     * Checks if this stream is designated for request-response cycles
+     * Emit event
      */
-    get isRequestResponse(): boolean;
-    close(): Promise<void>;
+    private emit;
 }
 //# sourceMappingURL=o-node-stream.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAuB,OAAO,EAAiB,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAEzE;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,OAAO;aAIpB,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,iBAAiB;IAJ3C,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAGhB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,iBAAiB;IAO3C,QAAQ;IA6BR;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAgB7B"}
+{"version":3,"file":"o-node-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-stream.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAGL,OAAO,EACP,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAY,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AAGzC;;GAEG;AACH,qBAAa,WAAY,SAAQ,OAAO;aAMpB,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,iBAAiB;IAN3C,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,oBAAoB,CAAC;IAC5C,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAsB;gBAGjD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,iBAAiB;IAQ3C,qBAAqB;IAOrB,QAAQ;IA6BR;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG;IAqCnD,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB;IAUxD;;;OAGG;IACG,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMjD,UAAU,CAAC,OAAO,EAAE,iBAAiB;IAqBrC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAe5D;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAQhC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIjC;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,iBAAiB,EAC5B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,iBAAiB,EAC7B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;IACH,OAAO,CAAC,IAAI;CAMb"}

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

@@ -1,19 +1,26 @@
-import { oError, oErrorCodes, oObject } from '@olane/o-core';
+import { oError, oErrorCodes, oObject, oResponse, } from '@olane/o-core';
+import { lpStream } from '@olane/o-config';
+import JSON5 from 'json5';
+import { EventEmitter } from 'events';
+import { oNodeMessageEvent, } from './enums/o-node-message-event.js';
+import { oStreamRequest } from './o-stream.request.js';
 /**
- * oNodeStream wraps a libp2p Stream with caller/receiver address metadata
- * to enable proper stream reuse based on address pairs rather than protocol only.
- *
- * Key features:
- * - Bidirectional cache keys: A↔B === B↔A
- * - Automatic reusability checking
- * - Idle time tracking for cleanup
+ * oNodeStream wraps a libp2p Stream and transmits or receives messages across the libp2p streams
  */
 export class oNodeStream extends oObject {
     constructor(p2pStream, config) {
         super();
         this.p2pStream = p2pStream;
         this.config = config;
+        this.eventEmitter = new EventEmitter();
         this.createdAt = Date.now();
+        this.lp = lpStream(p2pStream);
+        this.listenForLibp2pEvents();
+    }
+    listenForLibp2pEvents() {
+        this.p2pStream.addEventListener('close', () => {
+            this.close();
+        });
     }
     // callable pattern to disrupt flow if not in valid state
     validate() {
@@ -30,6 +37,113 @@ export class oNodeStream extends oObject {
             throw new oError(oErrorCodes.INVALID_STATE, 'Session is not in a valid state');
         }
     }
+    /**
+     * Extracts and parses JSON from various formats including:
+     * - Already parsed objects
+     * - Plain JSON
+     * - Markdown code blocks (```json ... ``` or ``` ... ```)
+     * - Mixed content with explanatory text
+     * - JSON5 format (trailing commas, comments, unquoted keys, etc.)
+     *
+     * @param decoded - The decoded string that may contain JSON, or an already parsed object
+     * @returns Parsed JSON object
+     * @throws Error if JSON parsing fails even with JSON5 fallback
+     */
+    extractAndParseJSON(decoded) {
+        // If already an object (not a string), return it directly
+        if (typeof decoded !== 'string') {
+            return decoded;
+        }
+        let jsonString = decoded.trim();
+        // Attempt standard JSON.parse first
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (jsonError) {
+            this.logger.debug('Standard JSON parse failed, trying JSON5', {
+                error: jsonError.message,
+                position: jsonError.message.match(/position (\d+)/)?.[1],
+                preview: jsonString,
+            });
+            // Fallback to JSON5 for more relaxed parsing
+            try {
+                return JSON5.parse(jsonString);
+            }
+            catch (json5Error) {
+                // Enhanced error with context
+                this.logger.error('JSON5 parse also failed', {
+                    originalError: jsonError.message,
+                    json5Error: json5Error.message,
+                    preview: jsonString.substring(0, 200),
+                    length: jsonString.length,
+                });
+                throw new Error(`Failed to parse JSON: ${jsonError.message}\nJSON5 also failed: ${json5Error.message}\nPreview: ${jsonString.substring(0, 200)}${jsonString.length > 200 ? '...' : ''}`);
+            }
+        }
+    }
+    async send(request, options) {
+        // Ensure stream is valid
+        this.validate();
+        // Send the request with backpressure handling
+        const data = new TextEncoder().encode(request.toString());
+        await this.lp.write(data, { signal: options?.abortSignal });
+    }
+    /**
+     * listen - process every message inbound on the stream and emit it for the connection to bubble up
+     * @param options
+     */
+    async listen(options) {
+        while (this.isValid && !options?.abortSignal?.aborted) {
+            await this.listenOnce(options);
+        }
+    }
+    async listenOnce(options) {
+        const messageBytes = await this.lp.read({ signal: options?.abortSignal });
+        const decoded = new TextDecoder().decode(messageBytes.subarray());
+        const message = this.extractAndParseJSON(decoded);
+        if (this.isRequest(message)) {
+            // package up the request + stream and emit
+            const request = new oStreamRequest({
+                ...message,
+                stream: this.p2pStream,
+            });
+            this.emit(oNodeMessageEvent.request, request);
+        }
+        else if (this.isResponse(message)) {
+            const response = new oResponse({
+                ...message.result,
+                id: message.id,
+            });
+            this.emit(oNodeMessageEvent.response, response);
+        }
+    }
+    async waitForResponse(requestId) {
+        return new Promise((resolve, reject) => {
+            const handler = (data) => {
+                if (data.id === requestId) {
+                    this.off(oNodeMessageEvent.response, handler);
+                    this.logger.debug('Stream stopped listening for responses due to "waitForResponse", technically should continue if listen was called elsewhere');
+                    resolve(data);
+                }
+            };
+            this.on(oNodeMessageEvent.response, handler);
+        });
+    }
+    /**
+     * Detects if a decoded message is a request
+     * Requests have a 'method' field and no 'result' field
+     */
+    isRequest(message) {
+        return (typeof message?.method === 'string' &&
+            message.result === undefined &&
+            message.error === undefined);
+    }
+    /**
+     * Detects if a decoded message is a response
+     */
+    isResponse(message) {
+        return message?.result !== undefined || message?.error !== undefined;
+    }
     /**
      * Checks if the stream is in a valid state:
      * - Stream status is 'open'
@@ -49,33 +163,11 @@ export class oNodeStream extends oObject {
     get age() {
         return Date.now() - this.createdAt;
     }
-    /**
-     * Returns the stream type (defaults to 'general' for backward compatibility)
-     */
-    get streamType() {
-        return this.config.streamType || 'general';
-    }
-    /**
-     * Checks if this stream is designated as a dedicated reader
-     */
-    get isDedicatedReader() {
-        return this.streamType === 'dedicated-reader';
-    }
-    /**
-     * Checks if this stream is designated for request-response cycles
-     */
-    get isRequestResponse() {
-        return this.streamType === 'request-response';
-    }
     async close() {
-        // Don't close if reuse policy is enabled
-        if (this.config.reusePolicy === 'reuse') {
-            this.logger.debug('Stream reuse enabled, not closing stream');
-            return;
-        }
         if (this.p2pStream.status === 'open') {
             try {
                 // force the close for now until we can implement a proper close
+                this.logger.debug('Closing p2p stream');
                 await this.p2pStream.abort(new Error('Stream closed'));
             }
             catch (error) {
@@ -83,4 +175,25 @@ export class oNodeStream extends oObject {
             }
         }
     }
+    get id() {
+        return this.p2pStream?.id;
+    }
+    /**
+     * Add event listener
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Remove event listener
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Emit event
+     */
+    emit(event, data) {
+        this.eventEmitter.emit(event, data);
+    }
 }

package/dist/src/connection/stream-handler.config.d.ts

@@ -1,20 +1,9 @@
 /// <reference types="node" />
 import type { Stream } from '@libp2p/interface';
-/**
- * Stream reuse policy determines how streams are managed across multiple requests
- */
-export type StreamReusePolicy = 'none' | 'reuse' | 'pool';
 /**
  * Configuration for StreamHandler behavior
  */
 export interface StreamHandlerConfig {
-    /**
-     * Stream reuse policy:
-     * - 'none': Create new stream for each request (default)
-     * - 'reuse': Reuse existing open streams
-     * - 'pool': (Future) Maintain a pool of streams
-     */
-    reusePolicy?: StreamReusePolicy;
     /**
      * Timeout in milliseconds to wait for stream drain when buffer is full
      * @default 30000 (30 seconds)