@olane/o-node 0.7.50 → 0.7.52

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

@@ -1,357 +0,0 @@
-import { oRequest, oResponse, CoreUtils, oError, oErrorCodes, Logger, ResponseBuilder, } from '@olane/o-core';
-import { lpStream } from '@olane/o-config';
-import JSON5 from 'json5';
-/**
- * StreamHandler centralizes all stream-related functionality including:
- * - Message type detection (request vs response)
- * - Stream lifecycle management (create, reuse, close)
- * - Backpressure handling
- * - Request/response handling
- * - Stream routing for middleware nodes
- */
-export class StreamHandler {
-    constructor(logger) {
-        this.logger = logger ?? new Logger('StreamHandler');
-    }
-    /**
-     * 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;
-    }
-    /**
-     * Detects if a decoded message is a response
-     * Responses have a 'result' field and no 'method' field
-     */
-    isResponse(message) {
-        return message?.result !== undefined && message.method === undefined;
-    }
-    /**
-     * 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 ? '...' : ''}`);
-            }
-        }
-    }
-    /**
-     * Builds a bidirectional cache key from caller and receiver addresses
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @param callerAddress - The caller's address
-     * @param receiverAddress - The receiver's address
-     * @returns Cache key string
-     */
-    buildCacheKey(callerAddress, receiverAddress) {
-        const addresses = [callerAddress.value, receiverAddress.value].sort();
-        return `${addresses[0]}↔${addresses[1]}`;
-    }
-    // /**
-    //  * Gets an existing open stream or creates a new one based on reuse policy
-    //  *
-    //  * @param connection - The libp2p connection
-    //  * @param protocol - The protocol to use for the stream
-    //  * @param config - Stream handler configuration
-    //  * @param streamAddresses - Optional addresses for address-based stream reuse
-    //  */
-    // async getOrCreateStream(
-    //   connection: Connection,
-    //   protocol: string,
-    //   config: StreamHandlerConfig = {},
-    //   streamAddresses?: {
-    //     callerAddress: oAddress;
-    //     receiverAddress: oAddress;
-    //     direction: 'inbound' | 'outbound';
-    //   },
-    // ): Promise<Stream> {
-    //   this.logger.debug(
-    //     `Getting or creating stream for protocol: ${protocol}, connection`,
-    //     {
-    //       status: connection.status,
-    //       remoteAddr: connection.remoteAddr.toString(),
-    //       streamCount: connection.streams.length,
-    //       reusePolicy: config.reusePolicy ?? 'none',
-    //       hasAddresses: !!streamAddresses,
-    //     },
-    //   );
-    //   if (connection.status !== 'open') {
-    //     throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
-    //   }
-    //   const reusePolicy = config.reusePolicy ?? 'none';
-    //   // Check address-based cache if reuse is enabled and addresses provided
-    //   if (reusePolicy === 'reuse' && streamAddresses) {
-    //     const cacheKey = this.buildCacheKey(
-    //       streamAddresses.callerAddress,
-    //       streamAddresses.receiverAddress,
-    //     );
-    //     const cachedStream = this.streamCache.get(cacheKey);
-    //     if (cachedStream?.isReusable) {
-    //       this.logger.debug('Reusing cached stream by address', {
-    //         cacheKey,
-    //         streamId: cachedStream.stream.id,
-    //         direction: cachedStream.direction,
-    //       });
-    //       cachedStream.updateLastUsed();
-    //       return cachedStream.stream;
-    //     } else if (cachedStream) {
-    //       // Stream exists but not reusable, remove from cache
-    //       this.logger.debug('Removing non-reusable stream from cache', {
-    //         cacheKey,
-    //         status: cachedStream.stream.status,
-    //       });
-    //       this.streamCache.delete(cacheKey);
-    //     }
-    //   }
-    //   this.logger.debug(
-    //     'No reusable cached stream found, checking connection streams',
-    //     connection.streams.map((s) => ({
-    //       status: s.status,
-    //       protocol: s.protocol,
-    //       writeStatus: s.writeStatus,
-    //       remoteReadStatus: s.remoteReadStatus,
-    //       id: s.id,
-    //     })),
-    //   );
-    //   // Fallback to protocol-based check (legacy behavior)
-    //   if (reusePolicy === 'reuse' && !streamAddresses) {
-    //     const existingStream = connection.streams.find(
-    //       (stream) =>
-    //         stream.status === 'open' &&
-    //         stream.protocol === protocol &&
-    //         stream.writeStatus === 'writable' &&
-    //         stream.remoteReadStatus === 'readable',
-    //     );
-    //     if (existingStream) {
-    //       this.logger.debug(
-    //         'Reusing existing stream by protocol (legacy)',
-    //         existingStream.id,
-    //         existingStream.direction,
-    //       );
-    //       return existingStream;
-    //     }
-    //   }
-    //   // Create new stream
-    //   this.logger.debug('Creating new stream', { protocol });
-    //   const stream = await connection.newStream(protocol, {
-    //     signal: config.signal,
-    //     maxOutboundStreams: config.maxOutboundStreams ?? 1000,
-    //     runOnLimitedConnection: config.runOnLimitedConnection ?? false,
-    //   });
-    //   // Cache the stream if reuse is enabled and addresses are provided
-    //   if (reusePolicy === 'reuse' && streamAddresses) {
-    //     const managedStream = new oNodeConnectionStream(
-    //       stream,
-    //       streamAddresses.callerAddress,
-    //       streamAddresses.receiverAddress,
-    //       streamAddresses.direction,
-    //     );
-    //     this.cacheStream(managedStream);
-    //     this.setupStreamCleanup(stream);
-    //   }
-    //   return stream;
-    // }
-    /**
-     * Sends data through a stream using length-prefixed encoding (libp2p v3 best practice)
-     * Each message is automatically prefixed with a varint indicating the message length
-     * 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
-     */
-    async sendLengthPrefixed(stream, data, config = {}) {
-        const lp = lpStream(stream);
-        await lp.write(data, { signal: config.signal });
-    }
-    /**
-     * 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
-     * @param toolExecutor - Function to execute tools for requests
-     */
-    async handleIncomingStream(stream, connection, toolExecutor) {
-        const lp = lpStream(stream);
-        try {
-            while (stream.status === 'open') {
-                // Read complete length-prefixed message
-                const messageBytes = await lp.read();
-                const decoded = new TextDecoder().decode(messageBytes.subarray());
-                // Parse JSON (handles markdown blocks, mixed content, and JSON5)
-                const message = this.extractAndParseJSON(decoded);
-                if (this.isRequest(message)) {
-                    await this.handleRequestMessage(message, stream, toolExecutor);
-                }
-                else if (this.isResponse(message)) {
-                    this.logger.warn('Received response message on server-side stream, ignoring', message);
-                }
-                else {
-                    this.logger.warn('Received unknown message type', message);
-                }
-            }
-        }
-        catch (error) {
-            // Stream closed or error occurred
-            if (stream.status === 'open') {
-                this.logger.error('Error in length-prefixed stream handler:', error);
-            }
-        }
-    }
-    /**
-     * Handles a request message by executing the tool and sending response
-     *
-     * @param message - The decoded request message
-     * @param stream - The stream to send the response on
-     * @param toolExecutor - Function to execute the tool
-     */
-    async handleRequestMessage(message, stream, toolExecutor) {
-        const request = new oRequest(message);
-        const responseBuilder = ResponseBuilder.create();
-        try {
-            // this.logger.debug(
-            //   `Processing request on stream: method=${request.method}, id=${request.id}`,
-            // );
-            const result = await toolExecutor(request, stream);
-            const response = await responseBuilder.build(request, result, null);
-            await CoreUtils.sendResponse(response, stream);
-            this.logger.debug(`Successfully processed request: method=${request.method}, id=${request.id}`);
-        }
-        catch (error) {
-            this.logger.error(`Error processing request: method=${request.method}, id=${request.id}`, error);
-            const errorResponse = await responseBuilder.buildError(request, error);
-            await CoreUtils.sendResponse(errorResponse, stream);
-        }
-    }
-    /**
-     * 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 requestHandler - Optional handler for processing router requests received on this stream
-     * @param requestId - Optional request ID to filter responses (for stream reuse scenarios)
-     * @returns Promise that resolves with the final response
-     */
-    async handleOutgoingStream(stream, emitter, config = {}, requestHandler, requestId) {
-        const lp = lpStream(stream);
-        try {
-            while (stream.status === 'open') {
-                this.logger.debug('Waiting for response...');
-                // Read complete length-prefixed message
-                const messageBytes = await lp.read({ signal: config.signal });
-                const decoded = new TextDecoder().decode(messageBytes.subarray());
-                // Parse JSON (handles markdown blocks, mixed content, and JSON5)
-                const message = this.extractAndParseJSON(decoded);
-                if (this.isResponse(message)) {
-                    const response = new oResponse({
-                        ...message.result,
-                        id: message.id,
-                    });
-                    // Filter by request ID if provided
-                    if (requestId !== undefined && response.id !== requestId) {
-                        this.logger.debug(`Ignoring response for different request (expected: ${requestId}, received: ${response.id})`);
-                        continue;
-                    }
-                    // Emit chunk for streaming responses
-                    emitter.emit('chunk', response);
-                    // Check if this is the last chunk
-                    if (response.result._last || !response.result._isStreaming) {
-                        return response;
-                    }
-                }
-                else if (this.isRequest(message)) {
-                    // Process incoming router requests if handler is provided
-                    if (requestHandler) {
-                        this.logger.debug('Received router request on client-side stream, processing...', message);
-                        await this.handleRequestMessage(message, stream, requestHandler);
-                    }
-                    else {
-                        this.logger.warn('Received request message on client-side stream, ignoring (no handler)', message);
-                    }
-                }
-                else {
-                    this.logger.warn('Received unknown message type', message);
-                }
-            }
-            throw new oError(oErrorCodes.TIMEOUT, 'Stream closed before response received');
-        }
-        catch (error) {
-            if (config.signal?.aborted) {
-                throw new oError(oErrorCodes.TIMEOUT, 'Request aborted');
-            }
-            throw error;
-        }
-    }
-    /**
-     * 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
-     */
-    async forwardRequest(request, incomingStream, dialFn) {
-        try {
-            // Connect to next hop
-            const nextHopConnection = await dialFn(request.params.address);
-            // Set up chunk relay - forward responses from next hop back to incoming stream
-            nextHopConnection.onChunk(async (response) => {
-                try {
-                    await CoreUtils.sendResponse(response, incomingStream);
-                }
-                catch (error) {
-                    this.logger.error('Error forwarding chunk:', error);
-                }
-            });
-            // Transmit the request to next hop
-            await nextHopConnection.transmit(request);
-        }
-        catch (error) {
-            this.logger.error('Error forwarding request:', error);
-            // Send error response back on incoming stream using ResponseBuilder
-            const responseBuilder = ResponseBuilder.create();
-            const errorResponse = await responseBuilder.buildError(request, error);
-            await CoreUtils.sendResponse(errorResponse, incomingStream);
-        }
-    }
-}