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

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

@@ -0,0 +1,185 @@
+import { oNotificationManager, NodeConnectedEvent, NodeDisconnectedEvent, NodeDiscoveredEvent, ChildJoinedEvent, ChildLeftEvent, ParentConnectedEvent, ParentDisconnectedEvent, } from '@olane/o-core';
+/**
+ * libp2p-specific implementation of oNotificationManager
+ * Wraps libp2p events and enriches them with Olane context
+ */
+export class oNodeNotificationManager extends oNotificationManager {
+    constructor(p2pNode, hierarchyManager, address) {
+        super();
+        this.p2pNode = p2pNode;
+        this.hierarchyManager = hierarchyManager;
+        this.address = address;
+    }
+    /**
+     * Wire up libp2p event listeners
+     */
+    setupListeners() {
+        this.logger.debug('Setting up libp2p event listeners...');
+        // Peer connection events
+        this.p2pNode.addEventListener('peer:connect', this.handlePeerConnect.bind(this));
+        this.p2pNode.addEventListener('peer:disconnect', this.handlePeerDisconnect.bind(this));
+        // Peer discovery events
+        this.p2pNode.addEventListener('peer:discovery', this.handlePeerDiscovery.bind(this));
+        // Connection events
+        this.p2pNode.addEventListener('connection:open', this.handleConnectionOpen.bind(this));
+        this.p2pNode.addEventListener('connection:close', this.handleConnectionClose.bind(this));
+        this.logger.debug('libp2p event listeners configured');
+    }
+    /**
+     * Handle peer connect event from libp2p
+     */
+    handlePeerConnect(evt) {
+        const peerId = evt.detail;
+        // this.logger.debug(`Peer connected: ${peerId.toString()}`);
+        // Try to resolve peer ID to Olane address
+        const nodeAddress = this.peerIdToAddress(peerId.toString());
+        if (!nodeAddress) {
+            // this.logger.debug(
+            //   `Could not resolve peer ID ${peerId.toString()} to address`,
+            // );
+            return;
+        }
+        // Emit generic node connected event
+        this.emit(new NodeConnectedEvent({
+            source: this.address,
+            nodeAddress,
+            connectionMetadata: {
+                peerId: peerId.toString(),
+                transport: 'libp2p',
+            },
+        }));
+        // Check if this is a child node
+        if (this.isChild(nodeAddress)) {
+            // this.logger.debug(`Child node connected: ${nodeAddress.toString()}`);
+            this.emit(new ChildJoinedEvent({
+                source: this.address,
+                childAddress: nodeAddress,
+                parentAddress: this.address,
+            }));
+        }
+        // Check if this is a parent node
+        if (this.isParent(nodeAddress)) {
+            // this.logger.debug(`Parent node connected: ${nodeAddress.toString()}`);
+            this.emit(new ParentConnectedEvent({
+                source: this.address,
+                parentAddress: nodeAddress,
+            }));
+        }
+    }
+    /**
+     * Handle peer disconnect event from libp2p
+     */
+    handlePeerDisconnect(evt) {
+        const peerId = evt.detail;
+        // this.logger.debug(`Peer disconnected: ${peerId.toString()}`);
+        // Try to resolve peer ID to Olane address
+        const nodeAddress = this.peerIdToAddress(peerId.toString());
+        if (!nodeAddress) {
+            // this.logger.debug(
+            //   `Could not resolve peer ID ${peerId.toString()} to address`,
+            // );
+            return;
+        }
+        // Emit generic node disconnected event
+        this.emit(new NodeDisconnectedEvent({
+            source: this.address,
+            nodeAddress,
+            reason: 'peer_disconnected',
+        }));
+        // Check if this is a child node
+        if (this.isChild(nodeAddress)) {
+            this.logger.debug(`Child node disconnected: ${nodeAddress.toString()}`);
+            this.emit(new ChildLeftEvent({
+                source: this.address,
+                childAddress: nodeAddress,
+                parentAddress: this.address,
+                reason: 'peer_disconnected',
+            }));
+            // Optionally remove from hierarchy (auto-cleanup)
+            // this.hierarchyManager.removeChild(nodeAddress);
+        }
+        // Check if this is a parent node
+        if (this.isParent(nodeAddress)) {
+            this.logger.debug(`Parent node disconnected: ${nodeAddress.toString()}`);
+            this.emit(new ParentDisconnectedEvent({
+                source: this.address,
+                parentAddress: nodeAddress,
+                reason: 'peer_disconnected',
+            }));
+        }
+    }
+    /**
+     * Handle peer discovery event from libp2p
+     */
+    handlePeerDiscovery(evt) {
+        const peerInfo = evt.detail;
+        // this.logger.debug(`Peer discovered: ${peerInfo.id.toString()}`);
+        // Try to resolve peer ID to Olane address
+        const nodeAddress = this.peerIdToAddress(peerInfo.id.toString());
+        if (!nodeAddress) {
+            return;
+        }
+        this.emit(new NodeDiscoveredEvent({
+            source: this.address,
+            nodeAddress,
+        }));
+    }
+    /**
+     * Handle connection open event from libp2p
+     */
+    handleConnectionOpen(evt) {
+        // do nothing for now
+    }
+    /**
+     * Handle connection close event from libp2p
+     */
+    handleConnectionClose(evt) {
+        // do nothing for now
+    }
+    /**
+     * Try to resolve a libp2p peer ID to an Olane address
+     * Checks hierarchy manager for known peers
+     */
+    peerIdToAddress(peerId) {
+        // Check children
+        for (const child of this.hierarchyManager.children) {
+            const childTransports = child.transports;
+            for (const transport of childTransports) {
+                if (transport.toString().includes(peerId)) {
+                    return child;
+                }
+            }
+        }
+        // Check parents
+        for (const parent of this.hierarchyManager.parents) {
+            const parentTransports = parent.transports;
+            for (const transport of parentTransports) {
+                if (transport.toString().includes(peerId)) {
+                    return parent;
+                }
+            }
+        }
+        // Check leaders
+        for (const leader of this.hierarchyManager.leaders) {
+            const leaderTransports = leader.transports;
+            for (const transport of leaderTransports) {
+                if (transport.toString().includes(peerId)) {
+                    return leader;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if an address is a direct child
+     */
+    isChild(address) {
+        return this.hierarchyManager.children.some((child) => child.toString() === address.toString());
+    }
+    /**
+     * Check if an address is a parent
+     */
+    isParent(address) {
+        return this.hierarchyManager.parents.some((parent) => parent.toString() === address.toString());
+    }
+}

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

@@ -0,0 +1,18 @@
+import { oAddress, oRequest } from '@olane/o-core';
+import { oServerNode } from './nodes/server.node.js';
+import { Connection, Stream } from '@olane/o-config';
+declare const oNodeTool_base: typeof oServerNode;
+/**
+ * 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 declare class oNodeTool extends oNodeTool_base {
+    handleProtocol(address: oAddress): Promise<void>;
+    initialize(): Promise<void>;
+    handleStream(stream: Stream, connection: Connection): Promise<void>;
+    _tool_identify(): Promise<any>;
+    _tool_child_register(request: oRequest): Promise<any>;
+}
+export {};
+//# sourceMappingURL=o-node.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAGR,QAAQ,EAGT,MAAM,eAAe,CAAC;AAMvB,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAIrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IACzC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAQhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoDnE,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CA2B5D"}

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

@@ -0,0 +1,90 @@
+import { CoreUtils, oError, oErrorCodes, oRequest, ChildJoinedEvent, } from '@olane/o-core';
+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';
+/**
+ * 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 handleProtocol(address) {
+        this.logger.debug('Handling protocol: ' + address.protocol);
+        await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
+            maxInboundStreams: Infinity,
+            maxOutboundStreams: Infinity,
+        });
+    }
+    async initialize() {
+        await super.initialize();
+        await this.handleProtocol(this.address);
+        if (this.staticAddress &&
+            this.staticAddress?.toString() !== this.address.toString()) {
+            await this.handleProtocol(this.staticAddress);
+        }
+    }
+    async handleStream(stream, connection) {
+        // CRITICAL: Attach message listener immediately to prevent buffer overflow (libp2p v3)
+        // Per libp2p migration guide: "If no message event handler is added, streams will
+        // buffer incoming data until a pre-configured limit is reached, after which the stream will be reset."
+        const messageHandler = async (event) => {
+            if (!event.data) {
+                this.logger.warn('Malformed event data');
+                return;
+            }
+            const requestConfig = await CoreUtils.processStreamRequest(event);
+            const request = new oRequest(requestConfig);
+            let success = true;
+            const result = await this.execute(request, stream).catch((error) => {
+                this.logger.error('Error executing tool: ', request.toString(), error, typeof error);
+                success = false;
+                const responseError = error instanceof oError
+                    ? error
+                    : new oError(oErrorCodes.UNKNOWN, error.message);
+                return {
+                    error: responseError.toJSON(),
+                };
+            });
+            // Non-streaming response - original behavior
+            if (success) {
+                this.metrics.successCount++;
+            }
+            else {
+                this.metrics.errorCount++;
+            }
+            // compose the response & add the expected connection + request fields
+            const response = CoreUtils.buildResponse(request, result, result?.error);
+            // add the request method to the response
+            await CoreUtils.sendResponse(response, stream);
+        };
+        // Attach listener synchronously before any async operations
+        stream.addEventListener('message', messageHandler);
+    }
+    async _tool_identify() {
+        return {
+            address: this.address.toString(),
+            staticAddress: this.staticAddress?.toString(),
+            transports: this.transports.map((t) => t.toMultiaddr().toString()),
+        };
+    }
+    async _tool_child_register(request) {
+        this.logger.debug('Child register: ', request.params);
+        const { address, transports } = request.params;
+        const childAddress = new oNodeAddress(address, transports.map((t) => new oNodeTransport(t)));
+        // Add child to hierarchy
+        this.hierarchyManager.addChild(childAddress);
+        // Emit child joined event
+        if (this.notificationManager) {
+            this.notificationManager.emit(new ChildJoinedEvent({
+                source: this.address,
+                childAddress,
+                parentAddress: this.address,
+            }));
+        }
+        return {
+            message: `Child node registered with parent! ${childAddress.toString()}`,
+            parentTransports: this.parentTransports.map((t) => t.toString()),
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from './o-node.address.js';
+export * from './o-node.router.js';
+export * from './o-node.transport.js';
+export * from './resolvers/index.js';
+export * from './route.request.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/router/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './o-node.address.js';
+export * from './o-node.router.js';
+export * from './o-node.transport.js';
+export * from './resolvers/index.js';
+export * from './route.request.js';

package/dist/o-node/src/router/interfaces/o-node-router.config.d.ts

@@ -0,0 +1,3 @@
+export interface oNodeRouterConfig {
+}
+//# sourceMappingURL=o-node-router.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-router.config.d.ts","sourceRoot":"","sources":["../../../../../src/router/interfaces/o-node-router.config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;CAAG"}

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

@@ -0,0 +1 @@
+export {};

package/dist/o-node/src/router/interfaces/o-node-router.response.d.ts

@@ -0,0 +1,8 @@
+import { oNodeAddress } from '../o-node.address';
+import { oRouterRequest, RouteResponse } from '@olane/o-core';
+export interface oNodeRouterResponse extends RouteResponse {
+    nextHopAddress: oNodeAddress;
+    targetAddress: oNodeAddress;
+    requestOverride?: oRouterRequest;
+}
+//# sourceMappingURL=o-node-router.response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-router.response.d.ts","sourceRoot":"","sources":["../../../../../src/router/interfaces/o-node-router.response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9D,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,cAAc,EAAE,YAAY,CAAC;IAC7B,aAAa,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import { Multiaddr } from '@olane/o-config';
+import { oNodeTransport } from './o-node.transport.js';
+import { oAddress } from '@olane/o-core';
+export declare class oNodeAddress extends oAddress {
+    readonly value: string;
+    transports: oNodeTransport[];
+    constructor(value: string, transports?: oNodeTransport[]);
+    static fromJSON(json: {
+        value: string;
+        transports: string[] | Multiaddr[];
+    }): oNodeAddress;
+    get libp2pTransports(): oNodeTransport[];
+    get customTransports(): oNodeTransport[];
+    toString(): string;
+    toMultiaddr(): Multiaddr;
+    static fromMultiaddr(ma: Multiaddr): oAddress;
+}
+//# sourceMappingURL=o-node.address.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+import { multiaddr } from '@olane/o-config';
+import { oNodeTransport } from './o-node.transport.js';
+import { oAddress, TransportType } from '@olane/o-core';
+export class oNodeAddress extends oAddress {
+    constructor(value, transports = []) {
+        super(value);
+        this.value = value;
+        this.transports = [];
+        this.transports = transports;
+    }
+    static fromJSON(json) {
+        return new oNodeAddress(json.value, json.transports.map((t) => new oNodeTransport(t)));
+    }
+    get libp2pTransports() {
+        return this.transports.filter((t) => t.type === TransportType.LIBP2P) || [];
+    }
+    get customTransports() {
+        return this.transports.filter((t) => t.type === TransportType.CUSTOM) || [];
+    }
+    toString() {
+        return this.value;
+    }
+    toMultiaddr() {
+        return multiaddr(this.protocol);
+    }
+    static fromMultiaddr(ma) {
+        return new oAddress(ma.toString().replace('/o/', 'o://'));
+    }
+}

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

@@ -0,0 +1,45 @@
+import { oNodeAddress } from './o-node.address.js';
+import { oRouterRequest, RouteResponse } from '@olane/o-core';
+import type { oNode } from '../o-node.js';
+import { oToolRouter } from '@olane/o-tool';
+export declare class oNodeRouter extends oToolRouter {
+    private routingPolicy;
+    constructor();
+    /**
+     * Forwards a request to the specified address via libp2p transport.
+     * Handles self-routing (local execution) and destination detection.
+     *
+     * @param address The next hop address to forward to
+     * @param request The router request to forward
+     * @param node The current node context
+     * @returns The response from the forwarded request
+     */
+    protected forward(address: oNodeAddress, request: oRouterRequest, node: oNode): Promise<any>;
+    /**
+     * Executes a request locally when routing to self.
+     */
+    private executeSelfRouting;
+    /**
+     * Checks if the next hop is the final destination address.
+     */
+    private isDestinationAddress;
+    /**
+     * Unwraps the routing envelope when we've reached the destination.
+     */
+    private unwrapDestinationRequest;
+    /**
+     * Dials a remote node and transmits the request via libp2p.
+     */
+    private dialAndTransmit;
+    /**
+     * Translates an address to determine the next hop and target addresses.
+     * First checks routing policy for external routing, then applies resolver chain.
+     */
+    translate(address: oNodeAddress, node: oNode): Promise<RouteResponse>;
+    /**
+     * Determines if an address is internal to this node's hierarchy.
+     * Delegates to the routing policy for the decision.
+     */
+    isInternal(addressWithTransports: oNodeAddress, node: oNode): boolean;
+}
+//# sourceMappingURL=o-node.router.d.ts.map

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

@@ -0,0 +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,EACd,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;IA0Bf;;OAEG;YACW,kBAAkB;IAgBhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;OAEG;YACW,eAAe;IAsC7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAyB3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}

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

@@ -0,0 +1,135 @@
+import { CoreUtils, oAddress, oError, oErrorCodes, oRequest, } 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';
+export class oNodeRouter extends oToolRouter {
+    constructor() {
+        super();
+        this.routingPolicy = new oNodeRoutingPolicy();
+    }
+    /**
+     * Forwards a request to the specified address via libp2p transport.
+     * Handles self-routing (local execution) and destination detection.
+     *
+     * @param address The next hop address to forward to
+     * @param request The router request to forward
+     * @param node The current node context
+     * @returns The response from the forwarded request
+     */
+    async forward(address, request, node) {
+        if (!request.stream) {
+            throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+        }
+        let nextHopRequest = new oRequest({
+            method: request.method,
+            params: request.params,
+            id: request.id,
+        });
+        // Handle self-routing: execute locally instead of dialing
+        if (this.routingPolicy.isSelfAddress(address, node)) {
+            return this.executeSelfRouting(request, node);
+        }
+        // Check if we've reached the final destination
+        const isDestination = this.isDestinationAddress(address, request);
+        if (isDestination) {
+            nextHopRequest = this.unwrapDestinationRequest(request);
+        }
+        // Dial and transmit to remote node
+        return this.dialAndTransmit(address, nextHopRequest, node);
+    }
+    /**
+     * Executes a request locally when routing to self.
+     */
+    async executeSelfRouting(request, node) {
+        const { payload } = request.params;
+        const params = payload.params;
+        const localRequest = new oRequest({
+            method: payload.method,
+            params: { ...params },
+            id: request.id,
+        });
+        const result = await node.execute(localRequest);
+        return result;
+    }
+    /**
+     * Checks if the next hop is the final destination address.
+     */
+    isDestinationAddress(address, request) {
+        return address
+            ?.toStaticAddress()
+            .equals(new oAddress(request?.params?.address).toStaticAddress());
+    }
+    /**
+     * Unwraps the routing envelope when we've reached the destination.
+     */
+    unwrapDestinationRequest(request) {
+        const { payload } = request.params;
+        const params = payload.params;
+        return new oRequest({
+            method: payload.method,
+            params: { ...params },
+            id: request.id,
+        });
+    }
+    /**
+     * Dials a remote node and transmits the request via libp2p.
+     */
+    async dialAndTransmit(address, request, node) {
+        try {
+            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,
+            });
+            if (request.params._isStream) {
+                const routeRequest = request;
+                if (!routeRequest.stream) {
+                    throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+                }
+                nodeConnection.onChunk((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;
+        }
+        catch (error) {
+            if (error?.name === 'UnsupportedProtocolError') {
+                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Translates an address to determine the next hop and target addresses.
+     * First checks routing policy for external routing, then applies resolver chain.
+     */
+    async translate(address, node) {
+        // Check if external routing is needed
+        const externalRoute = this.routingPolicy.getExternalRoutingStrategy(address, node);
+        if (externalRoute) {
+            return externalRoute;
+        }
+        // Apply resolver chain for internal routing
+        const { nextHopAddress, targetAddress, requestOverride } = await this.addressResolution.resolve({
+            address,
+            node,
+            targetAddress: address,
+        });
+        return {
+            nextHopAddress,
+            targetAddress: targetAddress,
+            requestOverride,
+        };
+    }
+    /**
+     * Determines if an address is internal to this node's hierarchy.
+     * Delegates to the routing policy for the decision.
+     */
+    isInternal(addressWithTransports, node) {
+        return this.routingPolicy.isInternalAddress(addressWithTransports, node);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { oAddress, oRoutingPolicy, RouteResponse } from '@olane/o-core';
+import type { oNode } from '../o-node.js';
+/**
+ * Routing policy implementation for oNode that handles internal/external routing decisions
+ * and leader-based routing strategies.
+ */
+export declare class oNodeRoutingPolicy extends oRoutingPolicy {
+    /**
+     * Determines if an address is internal to the current node's hierarchy.
+     * An address is considered internal if:
+     * 1. It doesn't have leader references, OR
+     * 2. Its leader references match our known leaders
+     *
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal to this hierarchy
+     */
+    isInternalAddress(address: oAddress, node: oNode): boolean;
+    /**
+     * Determines the routing strategy for external addresses.
+     * External addresses are routed to the leader of the external OS using
+     * the address's libp2p transports.
+     *
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse if external routing is needed, null if internal
+     */
+    getExternalRoutingStrategy(address: oAddress, node: oNode): RouteResponse | null;
+}
+//# sourceMappingURL=o-node.routing-policy.d.ts.map

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

@@ -0,0 +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;IAuB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}