@olane/o-node 0.7.12-alpha.3 → 0.7.12-alpha.31

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

@@ -1,7 +1,8 @@
-import { oAddress, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { CoreUtils, oAddress, oError, oErrorCodes, oRequest, ResponseBuilder, } from '@olane/o-core';
 import { oToolRouter } from '@olane/o-tool';
 import { oNodeConnection } from '../connection/o-node-connection.js';
 import { oNodeRoutingPolicy } from './o-node.routing-policy.js';
+import { oStreamRequest } from '../connection/o-stream.request.js';
 export class oNodeRouter extends oToolRouter {
     constructor() {
         super();
@@ -25,6 +26,9 @@ export class oNodeRouter extends oToolRouter {
             params: request.params,
             id: request.id,
         });
+        if (request.stream) {
+            nextHopRequest.stream = request.stream;
+        }
         // Handle self-routing: execute locally instead of dialing
         if (this.routingPolicy.isSelfAddress(address, node)) {
             return this.executeSelfRouting(request, node);
@@ -39,17 +43,55 @@ export class oNodeRouter extends oToolRouter {
     }
     /**
      * Executes a request locally when routing to self.
+     * Now uses ResponseBuilder for consistency with useSelf() behavior.
      */
     async executeSelfRouting(request, node) {
         const { payload } = request.params;
         const params = payload.params;
         const localRequest = new oRequest({
             method: payload.method,
-            params: { ...params },
+            params: {
+                ...params,
+                _connectionId: request.params._connectionId,
+                _requestMethod: payload.method,
+            },
             id: request.id,
         });
-        const result = await node.execute(localRequest);
-        return result;
+        // Create ResponseBuilder with metrics tracking
+        const responseBuilder = ResponseBuilder.create().withMetrics(node.metrics);
+        // Handle streaming requests
+        const isStream = request.params._isStreaming;
+        if (isStream && request.stream) {
+            // For streaming, we need to handle the stream chunks
+            try {
+                const result = await node.execute(localRequest, request.stream);
+                const response = await responseBuilder.build(localRequest, result, null, {
+                    isStream: true,
+                });
+                // Return unwrapped data for consistency with dialAndTransmit
+                return response.result.data;
+            }
+            catch (error) {
+                const errorResponse = await responseBuilder.buildError(localRequest, error, {
+                    isStream: true,
+                });
+                // For errors, throw to match remote behavior
+                throw responseBuilder.normalizeError(error);
+            }
+        }
+        // Handle non-streaming requests with error handling
+        try {
+            const result = await node.execute(localRequest);
+            const response = await responseBuilder.build(localRequest, result, null);
+            // Return unwrapped data to match dialAndTransmit behavior
+            return response.result.data;
+        }
+        catch (error) {
+            // Build error response for metrics tracking
+            await responseBuilder.buildError(localRequest, error);
+            // Then throw the normalized error
+            throw responseBuilder.normalizeError(error);
+        }
     }
     /**
      * Checks if the next hop is the final destination address.
@@ -65,10 +107,11 @@ export class oNodeRouter extends oToolRouter {
     unwrapDestinationRequest(request) {
         const { payload } = request.params;
         const params = payload.params;
-        return new oRequest({
+        return new oStreamRequest({
             method: payload.method,
             params: { ...params },
             id: request.id,
+            stream: request.stream,
         });
     }
     /**
@@ -76,13 +119,26 @@ export class oNodeRouter extends oToolRouter {
      */
     async dialAndTransmit(address, request, node) {
         try {
+            const isStream = request.params._isStreaming ||
+                request.params.payload?.params?._isStreaming;
             const connection = await node.p2pNode.dial(address.libp2pTransports.map((t) => t.toMultiaddr()));
             const nodeConnection = new oNodeConnection({
                 p2pConnection: connection,
                 nextHopAddress: address,
                 address: node.address,
                 callerAddress: node.address,
+                isStream: isStream,
             });
+            if (isStream) {
+                const routeRequest = request;
+                if (!routeRequest.stream) {
+                    throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+                }
+                nodeConnection.onChunk(async (response) => {
+                    CoreUtils.sendStreamResponse(response, routeRequest.stream);
+                });
+                // 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);
             return response.result.data;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAkB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAuBxB"}
+{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAuB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}

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

@@ -17,11 +17,16 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
      */
     isInternalAddress(address, node) {
         const nodeAddress = address;
+        // if we are trying to connect to a parent, it's internal
+        if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
+            return true;
+        }
         if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
             nodeAddress.libp2pTransports?.length > 0) {
             // transports are provided, let's see if they match our known leaders
             const isLeaderRef = nodeAddress.toString() === oAddress.leader().toString();
-            const isOurLeaderRef = node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
+            const isOurLeaderRef = node.address.equals(nodeAddress) ||
+                node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
             return isLeaderRef || isOurLeaderRef;
         }
         return true;
@@ -40,7 +45,7 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
         const isInternal = this.isInternalAddress(address, node);
         if (!isInternal) {
             // external address, so we need to route
-            this.logger.debug('Address is external, routing...', nodeAddress.toString(), nodeAddress.libp2pTransports.map((t) => t.toString()));
+            this.logger.debug('Address is external, routing...', nodeAddress);
             // route to leader of external OS
             return {
                 nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAsC1E"}
+{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAId,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA8C1E"}

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

@@ -1,4 +1,4 @@
-import { oAddressResolver, TransportType, } from '@olane/o-core';
+import { oAddressResolver, oAddress, TransportType, oError, oErrorCodes, } from '@olane/o-core';
 import { oNodeAddress } from '../o-node.address.js';
 export class oNodeResolver extends oAddressResolver {
     constructor(address) {
@@ -32,6 +32,10 @@ export class oNodeResolver extends oAddressResolver {
                 requestOverride: request,
             };
         }
+        // no child address, and we have already been to the leader, fail
+        if (address.toString().indexOf(oAddress.leader().toString()) > -1) {
+            throw new oError(oErrorCodes.NOT_FOUND, targetAddress.toString() + ' node not found.');
+        }
         return {
             nextHopAddress: address,
             targetAddress: targetAddress,

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAsBL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA8D/D"}
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAeL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAsG/D"}

package/dist/src/router/resolvers/o-node.search-resolver.js

@@ -1,4 +1,4 @@
-import { oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
+import { NodeState, oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
 import { oNodeTransport } from '../o-node.transport.js';
 /**
  * Address resolver that searches a registry to find transports for addresses.
@@ -78,7 +78,7 @@ export class oSearchResolver extends oAddressResolver {
      * @returns The registry address to query
      */
     getRegistryAddress() {
-        return new oAddress(RestrictedAddresses.REGISTRY);
+        return new oAddress('o://leader/registry');
     }
     /**
      * Returns the method name to call on the registry.
@@ -201,7 +201,6 @@ export class oSearchResolver extends oAddressResolver {
     determineNextHop(node, resolvedTargetAddress, searchResult) {
         // Determine next hop using standard hierarchy logic
         const nextHopAddress = oAddress.next(node.address, resolvedTargetAddress);
-        this.logger.debug('determineNextHop with params', 'node.address: ' + node.address.toString(), 'resolvedTargetAddress: ' + resolvedTargetAddress.toString(), 'searchResult.address: ' + searchResult.address, 'next hop: ' + nextHopAddress.toString());
         // Map transports from search result
         const targetTransports = this.mapTransports(searchResult);
         // Set transports on the next hop based on routing logic
@@ -218,13 +217,40 @@ export class oSearchResolver extends oAddressResolver {
                 requestOverride: resolveRequest,
             };
         }
-        // Perform registry search
+        if (node.state !== NodeState.RUNNING) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // Perform registry search with error handling
         const searchParams = this.buildSearchParams(address);
         const registryAddress = this.getRegistryAddress();
-        const searchResponse = await node.use(registryAddress, {
-            method: this.getSearchMethod(),
-            params: searchParams,
-        });
+        let searchResponse;
+        try {
+            searchResponse = await node.use(registryAddress, {
+                method: this.getSearchMethod(),
+                params: searchParams,
+            });
+        }
+        catch (error) {
+            // Log the error but don't throw - allow fallback resolvers to handle it
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this is a circuit breaker error (fast-fail scenario)
+            if (errorMessage.includes('Circuit breaker is OPEN')) {
+                this.logger.warn(`Registry search blocked by circuit breaker for ${address.toString()}: ${errorMessage}`);
+            }
+            else {
+                this.logger.error(`Registry search failed for ${address.toString()}: ${errorMessage}`);
+            }
+            // Return original address without transports, letting next resolver in chain handle it
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
         // Filter and select result
         const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
         const selectedResult = this.selectResult(filteredResults);
@@ -240,8 +266,12 @@ export class oSearchResolver extends oAddressResolver {
         const extraParams = address
             .toString() // o://embeddings-text replace o://embeddings-text = ''
             .replace(address.toRootAddress().toString(), '');
-        this.logger.debug('Extra params:', extraParams);
-        const resolvedTargetAddress = new oAddress(selectedResult.address + extraParams);
+        // Check if selectedResult.address already contains the complete path
+        // This happens when registry finds via staticAddress - the returned address
+        // is the canonical hierarchical location, so we shouldn't append extraParams
+        const resultAddress = selectedResult.address;
+        const shouldAppendParams = extraParams && !resultAddress.endsWith(extraParams);
+        const resolvedTargetAddress = new oAddress(shouldAppendParams ? resultAddress + extraParams : resultAddress);
         // Set transports on the target address
         resolvedTargetAddress.setTransports(this.mapTransports(selectedResult));
         // Determine next hop and configure transports

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

@@ -0,0 +1,10 @@
+/**
+ * Streaming functionality for o-node
+ *
+ * This module provides libp2p-specific implementations of the streaming
+ * abstractions defined in o-core.
+ */
+export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
+export { NodeStreamHandler, NodeStreamHandlerOptions, } from './node-stream-handler.js';
+export { oNodeStreamingClient } from './o-node-streaming-client.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/streaming/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/src/streaming/index.js

@@ -0,0 +1,12 @@
+/**
+ * Streaming functionality for o-node
+ *
+ * This module provides libp2p-specific implementations of the streaming
+ * abstractions defined in o-core.
+ */
+// libp2p-specific stream transport
+export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
+// o-node stream handler with metrics
+export { NodeStreamHandler, } from './node-stream-handler.js';
+// o-node streaming client for client-side streaming orchestration
+export { oNodeStreamingClient } from './o-node-streaming-client.js';

package/dist/src/streaming/libp2p-stream-transport.d.ts

@@ -0,0 +1,50 @@
+import { Stream } from '@olane/o-config';
+import { IStreamTransport, StreamStatus, StreamTransportConfig } from '@olane/o-core';
+/**
+ * libp2p-specific implementation of IStreamTransport.
+ * Wraps a libp2p Stream and handles backpressure, message listening,
+ * and stream lifecycle management.
+ */
+export declare class Libp2pStreamTransport implements IStreamTransport {
+    private readonly stream;
+    private messageHandler?;
+    private config;
+    constructor(stream: Stream, config?: StreamTransportConfig);
+    /**
+     * Get the underlying libp2p Stream (useful for advanced use cases)
+     */
+    getStream(): Stream;
+    /**
+     * Send data through the stream with backpressure handling
+     */
+    send(data: Uint8Array): Promise<void>;
+    /**
+     * Set up a message handler for incoming data.
+     * IMPORTANT: For libp2p v3, this must be called synchronously after
+     * receiving the stream to prevent buffer overflow.
+     */
+    onMessage(handler: (data: Uint8Array) => void): void;
+    /**
+     * Remove the message handler
+     */
+    removeMessageHandler(): void;
+    /**
+     * Close the stream and clean up resources
+     */
+    close(): Promise<void>;
+    /**
+     * Get the current status of the stream
+     */
+    getStatus(): StreamStatus;
+    /**
+     * Check if the stream is in a usable state
+     */
+    isOpen(): boolean;
+    /**
+     * Wait for the first message with timeout
+     * @param timeoutMs - Optional timeout in milliseconds (defaults to config.readTimeoutMs)
+     * @returns Promise that resolves with the first message
+     */
+    waitForMessage(timeoutMs?: number): Promise<Uint8Array>;
+}
+//# sourceMappingURL=libp2p-stream-transport.d.ts.map

package/dist/src/streaming/libp2p-stream-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libp2p-stream-transport.d.ts","sourceRoot":"","sources":["../../../src/streaming/libp2p-stream-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,EACtB,MAAM,eAAe,CAAC;AAUvB;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAK1D,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,cAAc,CAAC,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAkC;gBAG7B,MAAM,EAAE,MAAM,EAC/B,MAAM,CAAC,EAAE,qBAAqB;IAQhC;;OAEG;IACI,SAAS,IAAI,MAAM;IAI1B;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB3C;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAcpD;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAO5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,SAAS,IAAI,YAAY;IAkBzB;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;;OAIG;IACG,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAe9D"}

package/dist/src/streaming/libp2p-stream-transport.js

@@ -0,0 +1,137 @@
+import { StreamStatus, } from '@olane/o-core';
+/**
+ * Default configuration for libp2p stream transport
+ */
+const DEFAULT_CONFIG = {
+    drainTimeoutMs: 30000, // 30 seconds
+    readTimeoutMs: 120000, // 2 minutes
+};
+/**
+ * libp2p-specific implementation of IStreamTransport.
+ * Wraps a libp2p Stream and handles backpressure, message listening,
+ * and stream lifecycle management.
+ */
+export class Libp2pStreamTransport {
+    constructor(stream, config) {
+        this.stream = stream;
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+    }
+    /**
+     * Get the underlying libp2p Stream (useful for advanced use cases)
+     */
+    getStream() {
+        return this.stream;
+    }
+    /**
+     * Send data through the stream with backpressure handling
+     */
+    async send(data) {
+        // Check stream status before sending
+        if (this.stream.status !== 'open') {
+            throw new Error(`Cannot send on stream with status: ${this.stream.status}`);
+        }
+        try {
+            // Attempt to send the data
+            const sent = this.stream.send(data);
+            // Handle backpressure if the buffer is full
+            if (!sent) {
+                // Wait for the stream to drain with timeout
+                await this.stream.onDrain({
+                    signal: AbortSignal.timeout(this.config.drainTimeoutMs),
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to send data: ${error}`);
+        }
+    }
+    /**
+     * Set up a message handler for incoming data.
+     * IMPORTANT: For libp2p v3, this must be called synchronously after
+     * receiving the stream to prevent buffer overflow.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+        // Attach the message listener to the stream
+        // This is synchronous and must be done immediately for libp2p v3
+        this.stream.addEventListener('message', (event) => {
+            if (this.messageHandler) {
+                // Extract the data from the event
+                const data = event.detail;
+                this.messageHandler(data);
+            }
+        });
+    }
+    /**
+     * Remove the message handler
+     */
+    removeMessageHandler() {
+        this.messageHandler = undefined;
+        // Note: We don't remove the event listener because libp2p doesn't
+        // provide a clean way to do this. The handler being undefined
+        // effectively disables it.
+    }
+    /**
+     * Close the stream and clean up resources
+     */
+    async close() {
+        try {
+            if (this.stream.status === 'open' || this.stream.status === 'closing') {
+                await this.stream.close();
+            }
+        }
+        catch (error) {
+            console.error('Error closing stream:', error);
+            // Don't throw - closing errors are not critical
+        }
+        finally {
+            this.removeMessageHandler();
+        }
+    }
+    /**
+     * Get the current status of the stream
+     */
+    getStatus() {
+        // Map libp2p status to our StreamStatus enum
+        const status = this.stream.status;
+        switch (status) {
+            case 'open':
+                return StreamStatus.OPEN;
+            case 'closing':
+                return StreamStatus.CLOSING;
+            case 'closed':
+                return StreamStatus.CLOSED;
+            case 'reset':
+                return StreamStatus.RESET;
+            default:
+                return StreamStatus.CLOSED;
+        }
+    }
+    /**
+     * Check if the stream is in a usable state
+     */
+    isOpen() {
+        return this.stream.status === 'open';
+    }
+    /**
+     * Wait for the first message with timeout
+     * @param timeoutMs - Optional timeout in milliseconds (defaults to config.readTimeoutMs)
+     * @returns Promise that resolves with the first message
+     */
+    async waitForMessage(timeoutMs) {
+        const timeout = timeoutMs ?? this.config.readTimeoutMs;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.removeMessageHandler();
+                reject(new Error(`Timeout waiting for message after ${timeout}ms`));
+            }, timeout);
+            this.onMessage((data) => {
+                clearTimeout(timer);
+                resolve(data);
+            });
+        });
+    }
+}

package/dist/src/streaming/node-stream-handler.d.ts

@@ -0,0 +1,65 @@
+import { StreamHandlerBase, StreamHandlerOptions } from '@olane/o-core';
+import { oRequest } from '@olane/o-protocol';
+import { Libp2pStreamTransport } from './libp2p-stream-transport.js';
+/**
+ * Options for NodeStreamHandler
+ */
+export interface NodeStreamHandlerOptions extends StreamHandlerOptions {
+    /**
+     * Enable success count tracking
+     */
+    trackSuccessCount?: boolean;
+    /**
+     * Enable error count tracking
+     */
+    trackErrorCount?: boolean;
+}
+/**
+ * o-node specific implementation of StreamHandlerBase.
+ * Integrates with libp2p streams and tracks metrics for o-node tools.
+ */
+export declare class NodeStreamHandler extends StreamHandlerBase {
+    private successCount;
+    private errorCount;
+    private transport;
+    private nodeOptions;
+    constructor(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions);
+    /**
+     * Get the success count (number of chunks successfully sent)
+     */
+    getSuccessCount(): number;
+    /**
+     * Get the error count
+     */
+    getErrorCount(): number;
+    /**
+     * Reset metrics
+     */
+    resetMetrics(): void;
+    /**
+     * Implementation of sendChunk using libp2p transport and protocol builder
+     */
+    protected sendChunk(chunk: unknown, sequence: number, isLast: boolean, request: oRequest): Promise<void>;
+    /**
+     * Hook: Called when streaming starts
+     */
+    protected onStreamStart(request: oRequest): void;
+    /**
+     * Hook: Called when streaming completes successfully
+     */
+    protected onStreamComplete(request: oRequest, totalChunks: number): void;
+    /**
+     * Hook: Called when streaming encounters an error
+     */
+    protected onStreamError(request: oRequest, error: any): void;
+    /**
+     * Reset the handler for reuse with a new transport
+     */
+    reset(): void;
+    /**
+     * Create a new NodeStreamHandler with a different transport
+     * (useful for handling multiple streams)
+     */
+    static create(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions): NodeStreamHandler;
+}
+//# sourceMappingURL=node-stream-handler.d.ts.map

package/dist/src/streaming/node-stream-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-stream-handler.d.ts","sourceRoot":"","sources":["../../../src/streaming/node-stream-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EAErB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;IACtD,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,WAAW,CAA2B;gBAG5C,SAAS,EAAE,qBAAqB,EAChC,OAAO,GAAE,wBAA6B;IAWxC;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,aAAa,IAAI,MAAM;IAI9B;;OAEG;IACI,YAAY,IAAI,IAAI;IAK3B;;OAEG;cACa,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IA0BhB;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAOzD;;OAEG;cACgB,gBAAgB,CACjC,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI;IASP;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAUrE;;OAEG;IACI,KAAK,IAAI,IAAI;IAOpB;;;OAGG;WACW,MAAM,CAClB,SAAS,EAAE,qBAAqB,EAChC,OAAO,CAAC,EAAE,wBAAwB,GACjC,iBAAiB;CAGrB"}

package/dist/src/streaming/node-stream-handler.js

@@ -0,0 +1,101 @@
+import { StreamHandlerBase, ProtocolBuilder, } from '@olane/o-core';
+/**
+ * o-node specific implementation of StreamHandlerBase.
+ * Integrates with libp2p streams and tracks metrics for o-node tools.
+ */
+export class NodeStreamHandler extends StreamHandlerBase {
+    constructor(transport, options = {}) {
+        super(options);
+        this.successCount = 0;
+        this.errorCount = 0;
+        this.transport = transport;
+        this.nodeOptions = {
+            trackSuccessCount: true,
+            trackErrorCount: true,
+            ...options,
+        };
+    }
+    /**
+     * Get the success count (number of chunks successfully sent)
+     */
+    getSuccessCount() {
+        return this.successCount;
+    }
+    /**
+     * Get the error count
+     */
+    getErrorCount() {
+        return this.errorCount;
+    }
+    /**
+     * Reset metrics
+     */
+    resetMetrics() {
+        this.successCount = 0;
+        this.errorCount = 0;
+    }
+    /**
+     * Implementation of sendChunk using libp2p transport and protocol builder
+     */
+    async sendChunk(chunk, sequence, isLast, request) {
+        // Build the JSON-RPC streaming chunk message
+        const message = ProtocolBuilder.buildStreamChunkFromRequest(chunk, sequence, isLast, request);
+        // Encode the message to bytes
+        const encoded = ProtocolBuilder.encodeMessage(message);
+        // Send through the transport (handles backpressure)
+        await this.transport.send(encoded);
+        // Track metrics if enabled
+        if (this.nodeOptions.trackSuccessCount) {
+            this.successCount++;
+        }
+        // Close the stream if this is the last chunk
+        if (isLast) {
+            await this.transport.close();
+        }
+    }
+    /**
+     * Hook: Called when streaming starts
+     */
+    onStreamStart(request) {
+        // Reset metrics for this stream
+        if (this.nodeOptions.enableMetrics) {
+            this.resetMetrics();
+        }
+    }
+    /**
+     * Hook: Called when streaming completes successfully
+     */
+    onStreamComplete(request, totalChunks) {
+        // Log completion if metrics enabled
+        if (this.nodeOptions.enableMetrics) {
+            console.log(`Stream completed for ${request.method}: ${totalChunks} chunks sent`);
+        }
+    }
+    /**
+     * Hook: Called when streaming encounters an error
+     */
+    onStreamError(request, error) {
+        // Track error count
+        if (this.nodeOptions.trackErrorCount) {
+            this.errorCount++;
+        }
+        // Log error
+        console.error(`Stream error for ${request.method}:`, error);
+    }
+    /**
+     * Reset the handler for reuse with a new transport
+     */
+    reset() {
+        // Call parent reset
+        this.state = 0; // Reset state (IDLE)
+        this.currentSequence = 0;
+        this.resetMetrics();
+    }
+    /**
+     * Create a new NodeStreamHandler with a different transport
+     * (useful for handling multiple streams)
+     */
+    static create(transport, options) {
+        return new NodeStreamHandler(transport, options);
+    }
+}