libp2p-mesh 2026.5.13 → 2026.5.15

package/dist/src/mesh.js

@@ -16,14 +16,22 @@ import path from "node:path";
 import { mdns } from "@libp2p/mdns";
 import { mplex } from "@libp2p/mplex";
 import { noise } from "@libp2p/noise";
+import { kadDHT } from "@libp2p/kad-dht";
 import { createEd25519PeerId, createFromProtobuf, exportToProtobuf, } from "@libp2p/peer-id-factory";
 import { tcp } from "@libp2p/tcp";
 import { webSockets } from "@libp2p/websockets";
 import { bootstrap } from "@libp2p/bootstrap";
+import { identifyService } from "libp2p/identify";
+import { autoNATService } from "libp2p/autonat";
+import { circuitRelayServer, circuitRelayTransport } from "libp2p/circuit-relay";
+import { dcutrService } from "libp2p/dcutr";
+import { uPnPNATService } from "libp2p/upnp-nat";
 import { encode, decode } from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { createLibp2p } from "libp2p";
 import { Uint8ArrayList } from "uint8arraylist";
+import { loadOrCreateInstanceIdentity, verifyInstanceSignature, } from "./instance-id.js";
+import { registerPubkey, lookupPubkey } from "./dht-registry.js";
 const PROTOCOL = "/openclaw-msg/1.0.0";
 const MAX_SEEN_MESSAGES = 1000;
 function resolvePeerIdPath(customPath) {
@@ -53,43 +61,138 @@ async function loadOrCreatePeerId(customPath) {
 export function createMeshNetwork(options) {
     const config = options.config ?? {};
     const logger = options.logger;
-    // Use an object property instead of a bare `let` so all closures share
-    // the same mutable reference even if the bundler rewrites scopes.
     const state = {
         node: null,
+        instanceIdentity: null,
+        signMessage: null,
+        natFlags: {
+            identify: false,
+            autoNAT: false,
+            upnp: false,
+            circuitRelay: false,
+            circuitRelayServer: false,
+            dcutr: false,
+        },
     };
     const seenMessages = new Set();
     const messageHandlers = new Set();
     const topicHandlers = new Map();
+    function getDHTService() {
+        return state.node?.services?.dht;
+    }
     async function start() {
+        // Load or create lightweight BAID-inspired instance identity
+        const instanceResult = await loadOrCreateInstanceIdentity({
+            name: config.instanceName,
+        });
+        state.instanceIdentity = instanceResult.identity;
+        state.signMessage = instanceResult.signMessage;
+        logger?.info?.(`[libp2p-mesh] Instance Identity: ${instanceResult.identity.id}`);
+        logger?.info?.(`[libp2p-mesh] Bound to: ${instanceResult.identity.bindingComponents.username}@${instanceResult.identity.bindingComponents.hostname} (${instanceResult.identity.bindingComponents.platform})`);
         const peerId = await loadOrCreatePeerId(config.peerIdPath);
-        // Build transports dynamically
         const transports = [tcp()];
         if (config.enableWebSocket) {
             transports.push(webSockets());
         }
-        // Build peer discovery dynamically
+        // Peer discovery: mDNS for LAN, bootstrap for WAN entry points
         const peerDiscovery = [];
         const discoveryMechanism = config.discovery ?? "mdns";
         if (discoveryMechanism === "mdns") {
             peerDiscovery.push(mdns({ interval: 1000 }));
             logger?.info?.("[libp2p-mesh] Using mDNS discovery (LAN)");
         }
-        else if (discoveryMechanism === "bootstrap") {
+        if (discoveryMechanism === "bootstrap" || discoveryMechanism === "dht") {
             const bootstrapList = config.bootstrapList ?? [];
             if (bootstrapList.length > 0) {
                 peerDiscovery.push(bootstrap({ list: bootstrapList }));
                 logger?.info?.(`[libp2p-mesh] Using bootstrap discovery (${bootstrapList.length} node(s))`);
             }
-            else {
+            else if (discoveryMechanism === "bootstrap") {
                 logger?.warn?.("[libp2p-mesh] discovery=bootstrap but bootstrapList is empty; falling back to mDNS");
                 peerDiscovery.push(mdns({ interval: 1000 }));
             }
+            else {
+                logger?.warn?.("[libp2p-mesh] discovery=dht but bootstrapList is empty; DHT may not find peers");
+            }
         }
-        else if (discoveryMechanism === "dht") {
-            logger?.warn?.("[libp2p-mesh] DHT discovery is not yet implemented; falling back to mDNS");
-            peerDiscovery.push(mdns({ interval: 1000 }));
+        // Configure DHT for both WAN peer discovery and pubkey registry
+        const enableDHT = discoveryMechanism === "dht" || config.enableDHT !== false;
+        const services = {};
+        if (enableDHT) {
+            services.dht = kadDHT({
+                protocolPrefix: "/openclaw",
+                clientMode: false,
+            });
+            logger?.info?.("[libp2p-mesh] DHT enabled (protocol: /openclaw/kad/1.0.0)");
+        }
+        // -------------------------------------------------------------------
+        // NAT traversal stack (identify + autonat + upnp + circuit-relay + dcutr)
+        // -------------------------------------------------------------------
+        const natOn = config.enableNATTraversal !== false;
+        const useIdentify = natOn && config.enableIdentify !== false;
+        const useAutoNAT = natOn && config.enableAutoNAT !== false;
+        const useUPnP = natOn && config.enableUPnP !== false;
+        const useRelay = natOn && config.enableCircuitRelay !== false;
+        const useRelayServer = natOn && config.enableCircuitRelayServer === true;
+        const useDCUtR = natOn && config.enableDCUtR !== false;
+        const relayList = config.relayList ?? [];
+        const discoverRelays = Math.max(0, config.discoverRelays ?? 0);
+        if (useIdentify) {
+            services.identify = identifyService();
+            state.natFlags.identify = true;
+            logger?.info?.("[libp2p-mesh] identify service enabled");
+        }
+        else if (useAutoNAT || useDCUtR) {
+            logger?.warn?.("[libp2p-mesh] enableIdentify=false but AutoNAT/DCUtR rely on identify; they may not function correctly");
+        }
+        if (useAutoNAT) {
+            services.autoNAT = autoNATService();
+            state.natFlags.autoNAT = true;
+            logger?.info?.("[libp2p-mesh] AutoNAT enabled (will probe reachability)");
+        }
+        if (useUPnP) {
+            services.upnp = uPnPNATService({
+                description: `openclaw-libp2p-mesh/${state.instanceIdentity?.bindingComponents?.hostname ?? "node"}`,
+                keepAlive: true,
+            });
+            state.natFlags.upnp = true;
+            logger?.info?.("[libp2p-mesh] UPnP NAT port-mapping enabled");
+        }
+        if (useRelay) {
+            transports.push(circuitRelayTransport({
+                discoverRelays,
+            }));
+            state.natFlags.circuitRelay = true;
+            logger?.info?.(`[libp2p-mesh] Circuit Relay v2 transport enabled (discoverRelays=${discoverRelays})`);
+        }
+        if (useRelayServer) {
+            services.circuitRelay = circuitRelayServer({
+                // Advertise via content-routing only if DHT is up — otherwise the
+                // service still runs but won't auto-publish itself.
+                advertise: enableDHT,
+            });
+            state.natFlags.circuitRelayServer = true;
+            logger?.info?.(`[libp2p-mesh] Circuit Relay v2 SERVER enabled (advertise=${enableDHT}) — this node will relay traffic for other peers`);
+        }
+        if (useDCUtR) {
+            services.dcutr = dcutrService();
+            state.natFlags.dcutr = true;
+            logger?.info?.("[libp2p-mesh] DCUtR (hole-punching) enabled");
+        }
+        // Build the addresses block. listen always honours user config. The
+        // circuit-relay transport reserves a slot on each relay we listen on
+        // via /p2p-circuit — auto-derive those entries from relayList when the
+        // user hasn't already specified them.
+        const listenAddrs = [...(config.listenAddrs ?? ["/ip4/0.0.0.0/tcp/0"])];
+        if (useRelay) {
+            for (const relay of relayList) {
+                const circuitListen = relay.endsWith("/p2p-circuit") ? relay : `${relay}/p2p-circuit`;
+                if (!listenAddrs.includes(circuitListen)) {
+                    listenAddrs.push(circuitListen);
+                }
+            }
         }
+        const announce = config.announceAddrs ?? [];
         state.node = await createLibp2p({
             peerId,
             start: false,
@@ -97,9 +200,17 @@ export function createMeshNetwork(options) {
             connectionEncryption: [noise()],
             streamMuxers: [mplex()],
             addresses: {
-                listen: config.listenAddrs ?? ["/ip4/0.0.0.0/tcp/0"],
+                listen: listenAddrs,
+                announce,
             },
             peerDiscovery,
+            services,
+            // Circuit-relay-v2 transport can't bind to a listen address until a
+            // relay reservation is established, so allow per-transport listen
+            // failures when it's enabled rather than crashing the whole node.
+            transportManager: useRelay
+                ? { faultTolerance: 1 /* FaultTolerance.NO_FATAL */ }
+                : undefined,
         });
         state.node.addEventListener("peer:connect", (evt) => {
             const peerIdStr = evt.detail.toString();
@@ -129,12 +240,51 @@ export function createMeshNetwork(options) {
                             seenMessages.clear();
                         }
                         seenMessages.add(parsed.id);
-                        // Enrich with local timestamp if missing
                         if (!parsed.timestamp) {
                             parsed.timestamp = Date.now();
                         }
-                        logger?.debug?.(`[libp2p-mesh] Received ${parsed.type} from ${parsed.from}`);
-                        // Notify direct message handlers
+                        // Verify instance identity signature if present
+                        if (parsed.instanceId && parsed.signature) {
+                            const dht = getDHTService();
+                            if (dht) {
+                                // Reconstruct the signed payload
+                                const signedPayload = JSON.stringify({
+                                    id: parsed.id,
+                                    type: parsed.type,
+                                    from: parsed.from,
+                                    to: parsed.to,
+                                    topic: parsed.topic,
+                                    payload: parsed.payload,
+                                    timestamp: parsed.timestamp,
+                                    instanceId: parsed.instanceId,
+                                });
+                                // Look up sender's pubkey from DHT
+                                const senderPubkey = await lookupPubkey(dht, parsed.instanceId, logger);
+                                if (senderPubkey) {
+                                    const valid = verifyInstanceSignature({
+                                        id: parsed.instanceId,
+                                        name: "",
+                                        pubkey: senderPubkey,
+                                        binding: "",
+                                        bindingComponents: { username: "", hostname: "", platform: "" },
+                                        createdAt: 0,
+                                    }, signedPayload, parsed.signature);
+                                    if (valid) {
+                                        logger?.info?.(`[libp2p-mesh] Verified signature from instance ${parsed.instanceId}`);
+                                    }
+                                    else {
+                                        logger?.warn?.(`[libp2p-mesh] Invalid signature from instance ${parsed.instanceId}`);
+                                    }
+                                }
+                                else {
+                                    logger?.warn?.(`[libp2p-mesh] No pubkey in DHT for instance ${parsed.instanceId}; skipping verification`);
+                                }
+                            }
+                            else {
+                                logger?.debug?.(`[libp2p-mesh] DHT disabled; cannot verify signature from ${parsed.instanceId}`);
+                            }
+                        }
+                        logger?.debug?.(`[libp2p-mesh] Received ${parsed.type} from ${parsed.from}${parsed.instanceId ? ` (instance: ${parsed.instanceId})` : ""}`);
                         for (const handler of messageHandlers) {
                             try {
                                 handler(parsed);
@@ -143,7 +293,6 @@ export function createMeshNetwork(options) {
                                 logger?.error?.(`[libp2p-mesh] Message handler error: ${String(err)}`);
                             }
                         }
-                        // Handle broadcast / topic subscription
                         if (parsed.type === "broadcast" && parsed.topic) {
                             const handlers = topicHandlers.get(parsed.topic);
                             if (handlers) {
@@ -156,7 +305,6 @@ export function createMeshNetwork(options) {
                                     }
                                 }
                             }
-                            // Flood-fill forward to other connected peers (with TTL guard)
                             await forwardBroadcast(parsed, connection.remotePeer.toString());
                         }
                     }
@@ -165,8 +313,55 @@ export function createMeshNetwork(options) {
             catch (err) {
                 logger?.error?.(`[libp2p-mesh] Protocol handler error: ${String(err)}`);
             }
+        }, {
+            // Allow the openclaw protocol to be served over relayed (transient)
+            // connections; without this, peers behind NAT can't deliver messages.
+            runOnTransientConnection: true,
         });
         await state.node.start();
+        // Wait for DHT routing table to populate before registering pubkey
+        if (enableDHT) {
+            const dht = getDHTService();
+            if (dht) {
+                let attempts = 0;
+                const maxAttempts = 30;
+                while (attempts < maxAttempts) {
+                    const rtSize = dht.routingTable?.size ?? 0;
+                    const peerCount = state.node.getPeers().length;
+                    if (rtSize > 0 || peerCount > 0) {
+                        logger?.info?.(`[libp2p-mesh] DHT routing table ready (peers: ${peerCount}, rt: ${rtSize})`);
+                        break;
+                    }
+                    await new Promise((r) => setTimeout(r, 1000));
+                    attempts++;
+                }
+                if (attempts >= maxAttempts) {
+                    logger?.warn?.(`[libp2p-mesh] DHT routing table still empty after ${maxAttempts}s; continuing anyway`);
+                }
+                if (state.instanceIdentity) {
+                    await registerPubkey(dht, state.instanceIdentity.id, state.instanceIdentity.pubkey, logger).catch(() => {
+                        // Already logged inside registerPubkey
+                    });
+                }
+            }
+        }
+        // Reserve a slot on each configured relay so other peers can dial us
+        // through them via /p2p-circuit. Fire-and-forget; failures are logged.
+        if (useRelay && relayList.length > 0) {
+            const { multiaddr } = await import("@multiformats/multiaddr");
+            for (const addr of relayList) {
+                const node = state.node;
+                (async () => {
+                    try {
+                        await node.dial(multiaddr(addr));
+                        logger?.info?.(`[libp2p-mesh] Connected to relay ${addr} — reservation in progress`);
+                    }
+                    catch (err) {
+                        logger?.warn?.(`[libp2p-mesh] Failed to connect to relay ${addr}: ${String(err)}`);
+                    }
+                })();
+            }
+        }
         logger?.info?.(`[libp2p-mesh] Node started. Peer ID: ${state.node.peerId.toString()}`);
         logger?.info?.(`[libp2p-mesh] Listening on: ${state.node.getMultiaddrs().map((ma) => ma.toString()).join(", ")}`);
     }
@@ -177,26 +372,77 @@ export function createMeshNetwork(options) {
             logger?.info?.("[libp2p-mesh] Node stopped.");
         }
     }
+    function buildSignedMessage(base) {
+        const instanceId = state.instanceIdentity?.id;
+        const sign = state.signMessage;
+        const msg = { ...base };
+        if (instanceId && sign) {
+            msg.instanceId = instanceId;
+            msg.pubkey = state.instanceIdentity?.pubkey;
+            const signedPayload = JSON.stringify({
+                id: msg.id,
+                type: msg.type,
+                from: msg.from,
+                to: msg.to,
+                topic: msg.topic,
+                payload: msg.payload,
+                timestamp: msg.timestamp,
+                instanceId: msg.instanceId,
+            });
+            msg.signature = sign(signedPayload);
+        }
+        return msg;
+    }
     async function sendToPeer(peerId, message) {
         if (!state.node) {
             throw new Error("Mesh network is not started");
         }
-        const msg = {
+        const msg = buildSignedMessage({
             id: crypto.randomUUID(),
             type: "direct",
             from: state.node.peerId.toString(),
             to: peerId,
             payload: message,
             timestamp: Date.now(),
-        };
+        });
         const data = new TextEncoder().encode(JSON.stringify(msg));
         const abortController = new AbortController();
         const timeout = setTimeout(() => abortController.abort(), 8000);
         try {
             const { peerIdFromString } = await import("@libp2p/peer-id");
+            const targetPid = peerIdFromString(peerId);
+            // If we have no open connection to the target and no peer-store
+            // address (typical when both ends are NAT-isolated and only share a
+            // configured relay), proactively dial via each /p2p-circuit path we
+            // know — this is what makes the relay configuration actually deliver
+            // messages when peer discovery hasn't propagated yet.
+            const alreadyConnected = state.node
+                .getConnections()
+                .some((c) => c.remotePeer.equals(targetPid));
+            if (!alreadyConnected) {
+                const relayAddrs = config.relayList ?? [];
+                for (const relayAddr of relayAddrs) {
+                    try {
+                        const circuit = relayAddr.endsWith("/p2p-circuit")
+                            ? `${relayAddr}/p2p/${peerId}`
+                            : `${relayAddr}/p2p-circuit/p2p/${peerId}`;
+                        const { multiaddr } = await import("@multiformats/multiaddr");
+                        logger?.debug?.(`[libp2p-mesh] sendToPeer: pre-dialling ${peerId} via relay path ${circuit}`);
+                        await state.node.dial(multiaddr(circuit), {
+                            signal: abortController.signal,
+                        });
+                        logger?.debug?.(`[libp2p-mesh] sendToPeer: established relayed connection to ${peerId}`);
+                        break;
+                    }
+                    catch (relayErr) {
+                        logger?.debug?.(`[libp2p-mesh] sendToPeer: relay pre-dial via ${relayAddr} failed: ${String(relayErr)}`);
+                    }
+                }
+            }
             logger?.debug?.(`[libp2p-mesh] dialProtocol to ${peerId}`);
-            const stream = await state.node.dialProtocol(peerIdFromString(peerId), PROTOCOL, {
+            const stream = await state.node.dialProtocol(targetPid, PROTOCOL, {
                 signal: abortController.signal,
+                runOnTransientConnection: true,
             });
             if (!stream) {
                 throw new Error(`Failed to establish stream to ${peerId}; peer may be unreachable`);
@@ -220,14 +466,14 @@ export function createMeshNetwork(options) {
         if (!state.node) {
             throw new Error("Mesh network is not started");
         }
-        const msg = {
+        const msg = buildSignedMessage({
             id: crypto.randomUUID(),
             type: "broadcast",
             from: state.node.peerId.toString(),
             topic,
             payload: message,
             timestamp: Date.now(),
-        };
+        });
         const data = new TextEncoder().encode(JSON.stringify(msg));
         const connections = state.node.getConnections();
         let sent = 0;
@@ -235,7 +481,10 @@ export function createMeshNetwork(options) {
             const abortController = new AbortController();
             const timeout = setTimeout(() => abortController.abort(), 5000);
             try {
-                const stream = await conn.newStream(PROTOCOL, { signal: abortController.signal });
+                const stream = await conn.newStream(PROTOCOL, {
+                    signal: abortController.signal,
+                    runOnTransientConnection: true,
+                });
                 await pipe([new Uint8ArrayList(data)], encode, stream.sink);
                 sent++;
             }
@@ -251,7 +500,6 @@ export function createMeshNetwork(options) {
     async function forwardBroadcast(msg, fromPeerId) {
         if (!state.node)
             return;
-        // Simple flood-fill: forward to all connected peers except the sender
         const data = new TextEncoder().encode(JSON.stringify(msg));
         for (const conn of state.node.getConnections()) {
             const remotePeerId = conn.remotePeer.toString();
@@ -260,7 +508,10 @@ export function createMeshNetwork(options) {
             const abortController = new AbortController();
             const timeout = setTimeout(() => abortController.abort(), 5000);
             try {
-                const stream = await conn.newStream(PROTOCOL, { signal: abortController.signal });
+                const stream = await conn.newStream(PROTOCOL, {
+                    signal: abortController.signal,
+                    runOnTransientConnection: true,
+                });
                 await pipe([new Uint8ArrayList(data)], encode, stream.sink);
             }
             catch {
@@ -292,6 +543,38 @@ export function createMeshNetwork(options) {
         const peers = state.node.getConnections().map((c) => c.remotePeer.toString());
         return [...new Set(peers)];
     }
+    function getMultiaddrs() {
+        if (!state.node)
+            return [];
+        return state.node.getMultiaddrs().map((ma) => ma.toString());
+    }
+    function getInstanceIdentity() {
+        return state.instanceIdentity ?? undefined;
+    }
+    async function dial(multiaddr) {
+        if (!state.node) {
+            throw new Error("Mesh network is not started");
+        }
+        const { multiaddr: ma } = await import("@multiformats/multiaddr");
+        await state.node.dial(ma(multiaddr));
+    }
+    function getNATStatus() {
+        const enabled = { ...state.natFlags };
+        const reservedRelays = [];
+        let hasRelayedListenAddr = false;
+        if (state.node) {
+            // Listen multiaddrs that include /p2p-circuit are reservations the
+            // circuit-relay transport managed to acquire from a relay server.
+            for (const ma of state.node.getMultiaddrs()) {
+                const s = ma.toString();
+                if (s.includes("/p2p-circuit")) {
+                    hasRelayedListenAddr = true;
+                    reservedRelays.push(s);
+                }
+            }
+        }
+        return { enabled, reservedRelays, hasRelayedListenAddr };
+    }
     return {
         start,
         stop,
@@ -301,5 +584,9 @@ export function createMeshNetwork(options) {
         subscribeToTopic,
         getLocalPeerId,
         getConnectedPeers,
+        getMultiaddrs,
+        dial,
+        getInstanceIdentity,
+        getNATStatus,
     };
 }

package/dist/src/plugin.d.ts

@@ -1,3 +1,2 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import type { FeishuChannelConfig } from "./feishu-types.js";
-export declare function registerLibp2pMesh(api: OpenClawPluginApi, feishuConfig?: FeishuChannelConfig): void;
+export declare function registerLibp2pMesh(api: OpenClawPluginApi): void;

package/dist/src/plugin.js

@@ -1,36 +1,35 @@
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
 import { createMeshNetwork } from "./mesh.js";
-import { buildP2PTools, buildFeishuTools } from "./agent-tools.js";
-import { sendViaMesh } from "./send.js";
-import { FeishuApiClient } from "./feishu-client.js";
-import { createFeishuChannel } from "./feishu-channel.js";
-export function registerLibp2pMesh(api, feishuConfig) {
+import { buildP2PTools } from "./agent-tools.js";
+export function registerLibp2pMesh(api) {
     const mesh = createMeshNetwork({
         config: api.pluginConfig,
         logger: api.logger,
     });
-    const channel = createLibp2pMeshChannel(mesh);
-    const feishuClient = feishuConfig?.appId
-        ? new FeishuApiClient(feishuConfig, { logger: api.logger })
-        : undefined;
     // 1. Register Service (manages libp2p node lifecycle)
     api.registerService({
         id: "libp2p-mesh",
         start: async () => {
             await mesh.start();
             mesh.onMessage((msg) => {
-                const sendToChannel = async (_channelId, target, text) => {
-                    try {
-                        await sendViaMesh(mesh, target, text);
-                    }
-                    catch (err) {
-                        api.logger.error?.(`[libp2p-mesh] sendToChannel error: ${err}`);
-                    }
-                };
-                handleP2PInbound(msg, { logger: api.logger, sendToChannel, feishuClient });
+                handleP2PInbound(msg, { logger: api.logger });
             });
+            const identity = mesh.getInstanceIdentity();
             api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
+            if (identity) {
+                api.logger.info?.(`[libp2p-mesh] Instance Identity: ${identity.id}`);
+            }
+            const nat = mesh.getNATStatus();
+            const enabledNames = Object.entries(nat.enabled)
+                .filter(([, on]) => on)
+                .map(([k]) => k);
+            if (enabledNames.length > 0) {
+                api.logger.info?.(`[libp2p-mesh] NAT traversal services: ${enabledNames.join(", ")}`);
+            }
+            if (nat.reservedRelays.length > 0) {
+                api.logger.info?.(`[libp2p-mesh] Active relay reservations: ${nat.reservedRelays.join(", ")}`);
+            }
         },
         stop: async () => {
             await mesh.stop();
@@ -39,27 +38,16 @@ export function registerLibp2pMesh(api, feishuConfig) {
     });
     // 2. Register Channel (lightweight debugging surface)
     api.registerChannel({
-        plugin: channel,
+        plugin: createLibp2pMeshChannel(mesh),
     });
     // 3. Register Agent Tools
     const tools = buildP2PTools(mesh);
     for (const tool of tools) {
         api.registerTool(tool);
     }
-    const feishuTools = buildFeishuTools(feishuClient ?? null);
-    for (const tool of feishuTools) {
-        api.registerTool(tool);
-    }
     // 4. Register Hook (log received messages for observability)
     api.registerHook("message:received", async (event) => {
         const ctx = event.context;
         api.logger.debug?.(`[libp2p-mesh] message received on channel ${ctx?.channelId ?? "unknown"}`);
     }, { name: "libp2p-mesh-message-received" });
-    // 5. Conditionally register Feishu channel
-    if (feishuClient && feishuConfig) {
-        const feishuChannel = createFeishuChannel(feishuConfig, { logger: api.logger }, feishuClient);
-        api.registerChannel({
-            plugin: feishuChannel,
-        });
-    }
 }