@olane/o-node 0.7.54 → 0.7.56

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

@@ -3,35 +3,40 @@ import { oTool } from '@olane/o-tool';
 import { oServerNode } from './nodes/server.node.js';
 import { oNodeTransport } from './router/o-node.transport.js';
 import { oNodeAddress } from './router/o-node.address.js';
-import { ConnectionUtils } from './utils/connection.utils.js';
-import { StreamManagerEvent } from './connection/stream-manager.events.js';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
  * @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';
-        this.logger.debug('Handling protocol reuse: ' + reuseProtocol);
-        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.handleStreamReuse.bind(this), {
-            maxInboundStreams: 10000,
-            maxOutboundStreams: maxOutboundsStreams,
-            runOnLimitedConnection: true, // reuse is always on limited connections
-        });
-        this.logger.debug('Handled protocol reuse: ' + reuseProtocol);
-    }
+    // async handleProtocolReuse(address: oAddress) {
+    //   const reuseProtocol = address.protocol + '/reuse';
+    //   this.logger.debug('Handling protocol reuse: ' + reuseProtocol);
+    //   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.handleStreamReuse.bind(this),
+    //     {
+    //       maxInboundStreams: 10_000,
+    //       maxOutboundStreams: maxOutboundsStreams,
+    //       runOnLimitedConnection: true, // reuse is always on limited connections
+    //     },
+    //   );
+    //   this.logger.debug('Handled protocol reuse: ' + reuseProtocol);
+    // }
     async handleProtocol(address) {
+        if (!address || !address.protocol) {
+            throw new Error('Invalid address passed: ' + address);
+        }
         const protocols = this.p2pNode.getProtocols();
-        if (protocols.find((p) => p === address.protocol)) {
+        if (protocols.find((p) => p === address?.protocol)) {
             // already handling
             return;
         }
@@ -48,7 +53,7 @@ export class oNodeTool extends oTool(oServerNode) {
             maxOutboundStreams: maxOutboundsStreams,
             runOnLimitedConnection: this.config.runOnLimitedConnection,
         });
-        await this.handleProtocolReuse(address);
+        // await this.handleProtocolReuse(address);
     }
     async initializeProtocols() {
         this.logger.info('Initializing custom protocols for node...');
@@ -62,50 +67,11 @@ export class oNodeTool extends oTool(oServerNode) {
         await super.initialize();
         await this.initializeProtocols();
     }
-    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,
-        });
-        await this.connectionManager.answer({
-            nextHopAddress: remoteAddress,
-            address: remoteAddress,
-            callerAddress: this.address,
-            p2pConnection: connection,
-            reuse,
-        });
-        // Get the oNodeConnection for this libp2p connection
-        const oConnection = this.connectionManager.getConnectionByP2pConnection(connection);
-        if (!oConnection) {
-            this.logger.error('No oNodeConnection found for incoming stream', {
-                remotePeer: connection.remotePeer.toString(),
-                connectionId: connection.id,
-            });
-            return;
-        }
-        // Subscribe to InboundRequest events from the stream manager
-        // This follows an event-driven pattern for handling incoming requests
-        oConnection.streamManager.on(StreamManagerEvent.InboundRequest, async (data) => {
-            try {
-                const result = await this.execute(data.request, data.stream);
-                // Return the raw result - StreamManager will build and send the response
-                return result;
-            }
-            catch (error) {
-                this.logger.error('Error executing tool: ', data.request.toString(), error, typeof error);
-                throw error; // StreamManager will handle error response building
-            }
+    async handleStream(stream, connection) {
+        return this.requestManager.receiveStream({
+            stream,
+            connection,
         });
-        // Use the connection's StreamManager for consistent stream handling
-        // This follows libp2p v3 best practices for length-prefixed streaming
-        await oConnection.streamManager.handleIncomingStream(stream, connection);
     }
     async _tool_identify() {
         return {

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EAGd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;OAGG;YACW,kBAAkB;IA8DhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAWhC;;OAEG;YACW,eAAe;IA4C7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IA+B3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}
+{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EAGd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;OAGG;YACW,kBAAkB;IA8DhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAWhC;;OAEG;YACW,eAAe;IA+C7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IA+B3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}

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

@@ -122,7 +122,7 @@ export class oNodeRouter extends oToolRouter {
                 request.params.payload?.params?._isStreaming;
             const nodeConnection = await node.connectionManager.connect({
                 nextHopAddress: address,
-                address: node.address,
+                targetAddress: node.address,
                 callerAddress: node.address,
                 isStream: isStream,
             });
@@ -136,7 +136,9 @@ export class oNodeRouter extends oToolRouter {
                 });
                 // allow this to continue as we will tell the transmitter to stream the response and we will intercept via the above listener
             }
-            const response = await nodeConnection.transmit(request);
+            const stream = await nodeConnection.transmit(request, {});
+            const response = await stream.waitForResponse(String(request.id));
+            stream.close();
             return response.result.data;
         }
         catch (error) {

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

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

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

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

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

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

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

@@ -14,11 +14,14 @@ describe('Connection Management', () => {
         await env.cleanup();
     });
     describe('Connection Pooling', () => {
+        // TODO: add more concurrency tests for first connection to a node since there is a race condition issue with 2 connections being possible (discovered when reviewing the event response mechanism for parent connection detected = retry register. Bandaid workaround currently working where we simply prevent trying in the reconnection manager)
         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');
+            // at most there should only be 1 connection (the parent / leader shared)
+            expect(child.requestManager.connectionManager.connectionCount).to.equal(1);
             const spy = createConnectionSpy(leader);
             spy.start();
             // Make first request (establishes connection)

package/package.json

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

package/dist/src/connection/interfaces/stream-init-message.d.ts

@@ -1,64 +0,0 @@
-/**
- * Message sent by limited connection clients to identify their dedicated persistent streams
- * This allows the receiver to identify which streams to use for bidirectional communication
- */
-export interface StreamInitMessage {
-    /**
-     * Message type identifier
-     */
-    type: 'stream-init';
-    /**
-     * Role of this stream
-     * - 'reader': Dedicated reader stream for receiving requests from receiver
-     * - 'writer': Dedicated writer stream for sending responses back to receiver
-     * - 'standard': Standard request-response stream
-     */
-    role: 'reader' | 'writer' | 'standard';
-    /**
-     * Timestamp when the stream was created
-     */
-    timestamp: number;
-    /**
-     * Optional connection identifier for correlation
-     */
-    connectionId?: string;
-}
-/**
- * Type guard to check if a message is a StreamInitMessage
- */
-export declare function isStreamInitMessage(message: any): message is StreamInitMessage;
-/**
- * Acknowledgment message sent by receiver in response to stream-init
- * This confirms that the receiver has processed and registered the stream
- */
-export interface StreamInitAckMessage {
-    /**
-     * Message type identifier
-     */
-    type: 'stream-init-ack';
-    /**
-     * Status of the initialization
-     */
-    status: 'success' | 'error';
-    /**
-     * The stream ID that was registered
-     */
-    streamId: string;
-    /**
-     * The role that was registered
-     */
-    role: 'reader' | 'writer' | 'standard';
-    /**
-     * Optional error message if status is 'error'
-     */
-    error?: string;
-    /**
-     * Timestamp when the ack was sent
-     */
-    timestamp: number;
-}
-/**
- * Type guard to check if a message is a StreamInitAckMessage
- */
-export declare function isStreamInitAckMessage(message: any): message is StreamInitAckMessage;
-//# sourceMappingURL=stream-init-message.d.ts.map

package/dist/src/connection/interfaces/stream-init-message.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-init-message.d.ts","sourceRoot":"","sources":["../../../../src/connection/interfaces/stream-init-message.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,IAAI,EAAE,aAAa,CAAC;IAEpB;;;;;OAKG;IACH,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;IAEvC;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,IAAI,iBAAiB,CAM9E;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,IAAI,EAAE,iBAAiB,CAAC;IAExB;;OAEG;IACH,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;IAEvC;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,GAAG,GACX,OAAO,IAAI,oBAAoB,CAQjC"}

package/dist/src/connection/interfaces/stream-init-message.js

@@ -1,18 +0,0 @@
-/**
- * Type guard to check if a message is a StreamInitMessage
- */
-export function isStreamInitMessage(message) {
-    return (message?.type === 'stream-init' &&
-        (message.role === 'reader' || message.role === 'writer' || message.role === 'standard') &&
-        typeof message.timestamp === 'number');
-}
-/**
- * Type guard to check if a message is a StreamInitAckMessage
- */
-export function isStreamInitAckMessage(message) {
-    return (message?.type === 'stream-init-ack' &&
-        (message.status === 'success' || message.status === 'error') &&
-        typeof message.streamId === 'string' &&
-        (message.role === 'reader' || message.role === 'writer' || message.role === 'standard') &&
-        typeof message.timestamp === 'number');
-}

package/dist/src/connection/interfaces/stream-manager.config.d.ts

@@ -1,8 +0,0 @@
-import type { Connection } from '@libp2p/interface';
-export interface StreamManagerConfig {
-    /**
-     * The libp2p connection this manager handles streams for
-     */
-    p2pConnection: Connection;
-}
-//# sourceMappingURL=stream-manager.config.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream-manager.config.d.ts","sourceRoot":"","sources":["../../../../src/connection/interfaces/stream-manager.config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,aAAa,EAAE,UAAU,CAAC;CAC3B"}

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

@@ -1,200 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import type { Connection, Stream } from '@libp2p/interface';
-import { oObject, oRequest, oResponse } from '@olane/o-core';
-import type { oRouterRequest, oConnection } from '@olane/o-core';
-import { oNodeStream } from './o-node-stream.js';
-import { StreamManagerConfig } from './interfaces/stream-manager.config.js';
-import type { StreamHandlerConfig } from './stream-handler.config.js';
-import { StreamManagerEvent, StreamManagerEventData } from './stream-manager.events.js';
-import { StreamInitMessage } from './interfaces/stream-init-message.js';
-/**
- * oNodeStreamManager handles the lifecycle and tracking of streams for a single connection.
- * Features:
- * - Tracks all streams by ID
- * - Creates new streams on demand
- * - Manages stream lifecycle (cleanup after use)
- * - Provides events for monitoring
- * - No reuse at base layer (extensible in subclasses)
- */
-export declare class oNodeStreamManager extends oObject {
-    readonly config: StreamManagerConfig;
-    private streams;
-    protected eventEmitter: EventEmitter;
-    isInitialized: boolean;
-    private p2pConnection;
-    private activeStreamHandlers;
-    protected callerReaderStream?: Stream;
-    protected callerWriterStream?: Stream;
-    constructor(config: StreamManagerConfig);
-    /**
-     * Initialize the stream manager
-     */
-    initialize(): Promise<void>;
-    /**
-     * Gets or creates a stream for the connection
-     * Always creates a new stream (no reuse at base layer)
-     *
-     * For limited connections (where caller has identified a reader stream):
-     * - If callerReaderStream exists, wrap and return it for sending requests
-     * - Otherwise, create new stream as normal
-     *
-     * @param protocol - The protocol string for the stream
-     * @param remoteAddress - The remote address for the stream
-     * @param config - Stream handler configuration
-     * @returns Wrapped stream
-     */
-    getOrCreateStream(protocol: string, remoteAddress: any, config?: StreamHandlerConfig): Promise<oNodeStream>;
-    /**
-     * Creates a new stream from the connection
-     *
-     * @param protocol - The protocol string for the stream
-     * @param remoteAddress - The remote address for the stream
-     * @param config - Stream handler configuration
-     * @returns Wrapped stream
-     */
-    createStream(protocol: string, remoteAddress: any, config?: StreamHandlerConfig): Promise<oNodeStream>;
-    /**
-     * Releases and cleans up a stream
-     *
-     * @param streamId - The ID of the stream to release
-     */
-    releaseStream(streamId: string): Promise<void>;
-    /**
-     * Gets all tracked streams
-     *
-     * @returns Array of wrapped streams
-     */
-    getAllStreams(): oNodeStream[];
-    /**
-     * Gets a stream by its ID
-     * Checks persistent caller streams (reader/writer) and tracked streams
-     *
-     * @param streamId - The ID of the stream to retrieve
-     * @returns The libp2p Stream or undefined if not found
-     */
-    getStreamById(streamId: string): Stream | undefined;
-    /**
-     * Emits an async event and waits for the first listener to return a result
-     * This enables event-based request handling with async responses
-     */
-    private emitAsync;
-    /**
-     * 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
-     * Responses have a 'result' field and no 'method' field
-     */
-    isResponse(message: any): boolean;
-    /**
-     * Detects if a decoded message is a stream initialization message
-     * Uses the imported type guard from stream-init-message.ts
-     */
-    isStreamInit(message: any): message is StreamInitMessage;
-    /**
-     * Handles a stream initialization message
-     * Stores reference to caller's reader stream for bidirectional communication
-     * Sends acknowledgment back to confirm stream registration
-     *
-     * @param message - The decoded stream init message
-     * @param stream - The stream that sent the message
-     */
-    protected handleStreamInitMessage(message: StreamInitMessage, stream: Stream): Promise<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;
-    /**
-     * 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
-     * This ensures proper message boundaries and eliminates concatenation issues
-     *
-     * @param stream - The stream to send data through
-     * @param data - The data to send
-     * @param config - Configuration for timeout and other options
-     */
-    sendLengthPrefixed(stream: Stream, data: Uint8Array, config?: StreamHandlerConfig): Promise<void>;
-    /**
-     * Tracks an active stream handler
-     */
-    private trackStreamHandler;
-    /**
-     * Untracks a stream handler
-     */
-    private untrackStreamHandler;
-    /**
-     * Handles an incoming stream on the server side using length-prefixed protocol
-     * Uses async read loops instead of event listeners (libp2p v3 best practice)
-     * Processes complete messages with proper boundaries
-     *
-     * @param stream - The incoming stream
-     * @param connection - The connection the stream belongs to
-     */
-    handleIncomingStream(stream: Stream, connection: Connection): Promise<void>;
-    /**
-     * Determines which stream to use for sending the response
-     * Checks for _streamId in request params and routes accordingly
-     *
-     * @param request - The incoming request
-     * @param defaultStream - The stream the request came on (fallback)
-     * @returns The stream to use for the response
-     */
-    protected getResponseStream(request: oRequest, defaultStream: Stream): Stream;
-    /**
-     * Handles a request message by emitting an event and sending response
-     *
-     * @param message - The decoded request message
-     * @param stream - The stream to send the response on
-     * @param connection - The connection the stream belongs to
-     */
-    protected handleRequestMessage(message: any, stream: Stream, connection: Connection): Promise<void>;
-    /**
-     * Handles an outgoing stream on the client side using length-prefixed protocol
-     * Uses async read loops to process responses with proper message boundaries
-     *
-     * @param stream - The outgoing stream
-     * @param emitter - Event emitter for chunk events
-     * @param config - Configuration including abort signal
-     * @param requestId - Optional request ID to filter responses (for stream reuse scenarios)
-     * @returns Promise that resolves with the final response
-     */
-    handleOutgoingStream(stream: Stream, emitter: EventEmitter, config?: StreamHandlerConfig, requestId?: string | number): Promise<oResponse>;
-    /**
-     * Forwards a request to the next hop and relays response chunks back
-     * This implements the middleware/proxy pattern for intermediate nodes
-     *
-     * @param request - The router request to forward
-     * @param incomingStream - The stream to send responses back on
-     * @param dialFn - Function to dial the next hop connection
-     */
-    forwardRequest(request: oRouterRequest, incomingStream: Stream, dialFn: (address: string) => Promise<oConnection>): Promise<void>;
-    /**
-     * Close the stream manager and cleanup resources
-     */
-    close(): Promise<void>;
-    /**
-     * Add event listener
-     */
-    on<K extends StreamManagerEvent>(event: K | string, listener: (data: StreamManagerEventData[K]) => void): void;
-    /**
-     * Remove event listener
-     */
-    off<K extends StreamManagerEvent>(event: K | string, listener: (data: StreamManagerEventData[K]) => void): void;
-    /**
-     * Emit event
-     */
-    private emit;
-}
-//# sourceMappingURL=o-node-stream.manager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-stream.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-stream.manager.ts"],"names":[],"mappings":"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"}