libp2p-mesh 2026.5.26 → 2026.5.28

package/dist/src/identity-exchange.js

@@ -18,6 +18,18 @@ export async function handleIdentityMessage(msg, deps) {
         // Malformed payload — skip silently
         return;
     }
+    // sendToPeer 包装了一层 direct 外壳后，payload 里可能嵌套了 identity 消息：
+    //   outer: {"type":"identity","from":"A","payload":"{\"agentId\":\"A\",\"channel\":\"feishu\",...}"}
+    // 先解析拿到外层，再检测 type 并递归解析内层 payload。
+    if (parsed.type === "identity" && typeof parsed.payload === "string") {
+        try {
+            parsed = JSON.parse(parsed.payload);
+        }
+        catch {
+            // Inner payload malformed — skip silently
+            return;
+        }
+    }
     const { agentId, channel, accountId, instanceId } = parsed;
     // Only register if all required fields are present
     if (agentId && channel && accountId) {

package/dist/src/inbound.js

@@ -120,25 +120,8 @@ export async function handleP2PInbound(msg, deps) {
                     }
                 }
             }
-            // If the sender is not yet registered, register them synchronously
-            // (in-memory only) so that subsequent message routing works correctly.
-            // This handles NAT/relay scenarios where peer:connect may not fire
-            // bidirectionally, causing the identity exchange to be one-sided.
-            // Persistence (saveNow) is fire-and-forget to avoid blocking the
-            // message handler.
             if (!deps.peerIdentityMap.hasIdentity(msg.from)) {
-                const localIdentity = deps.peerIdentityMap.getLocalIdentity();
-                if (localIdentity) {
-                    deps.peerIdentityMap.registerSync(msg.from, {
-                        agentId: localIdentity.agentId,
-                        channel: localIdentity.channel,
-                        accountId: localIdentity.accountId,
-                        sessionKey: "",
-                        instanceId: msg.instanceId,
-                    });
-                    deps.peerIdentityMap.saveNow().catch(() => { });
-                    logger?.debug?.(`[libp2p-mesh] Auto-registered unknown sender ${msg.from} from direct message`);
-                }
+                logger?.debug?.(`[libp2p-mesh] Unknown sender ${msg.from}, waiting for identity exchange`);
             }
         }
         else if (msg.type === "broadcast") {
@@ -171,20 +154,8 @@ export async function handleP2PInbound(msg, deps) {
                 });
                 deps.enqueueNextTurnInjection({ sessionKey, text, placement: "prepend_context" });
             }
-            // If the sender is not yet registered, register them synchronously
             if (!deps.peerIdentityMap.hasIdentity(msg.from)) {
-                const localIdentity = deps.peerIdentityMap.getLocalIdentity();
-                if (localIdentity) {
-                    deps.peerIdentityMap.registerSync(msg.from, {
-                        agentId: localIdentity.agentId,
-                        channel: localIdentity.channel,
-                        accountId: localIdentity.accountId,
-                        sessionKey: "",
-                        instanceId: msg.instanceId,
-                    });
-                    deps.peerIdentityMap.saveNow().catch(() => { });
-                    logger?.debug?.(`[libp2p-mesh] Auto-registered unknown sender ${msg.from} from broadcast`);
-                }
+                logger?.debug?.(`[libp2p-mesh] Unknown sender ${msg.from}, waiting for identity exchange`);
             }
         }
     }

package/dist/src/plugin.js

@@ -1,99 +1,36 @@
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
-import { handleIdentityMessage } from "./identity-exchange.js";
 import { createMeshNetwork } from "./mesh.js";
 import { buildP2PTools } from "./agent-tools.js";
 import { createPeerIdentityMap } from "./peer-identity.js";
-import { buildIdentityMessage } from "./identity-exchange.js";
 export function registerLibp2pMesh(api) {
     const mesh = createMeshNetwork({
         config: api.pluginConfig,
         logger: api.logger,
     });
     // Singleton: maps peerId -> { agentId, channel, accountId, sessionKey }
-    // Declared here (not inside start) so tool registration below can attach
-    // it to tool objects via closure.
     const peerIdentityMap = createPeerIdentityMap();
+    // Helper: build the deps object for the relay-aware inbound handler
+    function buildInboundDeps() {
+        return {
+            peerIdentityMap,
+            enqueueNextTurnInjection: (injection) => api.session.workflow.enqueueNextTurnInjection(injection),
+            logger: api.logger,
+        };
+    }
     // 1. Register Service (manages libp2p node lifecycle)
     api.registerService({
         id: "libp2p-mesh",
         start: async () => {
-            // Gather config before starting (needed for onMessage handler)
-            const config = api.pluginConfig;
-            const relayChannel = config?.relayChannel;
-            const relayAccountId = config?.relayAccountId;
-            function buildInboundDeps() {
-                return {
-                    peerIdentityMap,
-                    enqueueNextTurnInjection: (injection) => api.session.workflow.enqueueNextTurnInjection(injection),
-                    logger: api.logger,
-                };
-            }
-            // Wire up relay-aware message handler BEFORE mesh.start() so that
-            // any identity messages arriving during startup are queued by libp2p
-            // and processed as soon as the protocol handler is ready.
-            mesh.onMessage((msg) => {
-                if (msg.type === "identity") {
-                    const localIdentity = peerIdentityMap.getLocalIdentity();
-                    handleIdentityMessage(msg, {
-                        peerIdentityMap,
-                        localPeerId: localIdentity?.sessionKey ?? "",
-                        localAgentId: api.name,
-                        localChannel: relayChannel ?? "",
-                        localAccountId: relayAccountId ?? "",
-                        localInstanceId: localIdentity?.instanceId,
-                        send: async (targetPeerId, replyMsg) => {
-                            mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => { });
-                        },
-                        logger: api.logger,
-                    }).catch((err) => {
-                        api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-                    });
-                }
-                else if (msg.type === "direct") {
-                    // sendToPeer 包装了一层 direct 外壳，原始 identity 消息藏在 payload 里。
-                    // 检测并处理：注册对方 + 发送自己的身份回复。
-                    let handled = false;
-                    try {
-                        const raw = JSON.parse(msg.payload);
-                        if (raw && raw.type === "identity") {
-                            const localIdentity = peerIdentityMap.getLocalIdentity();
-                            handleIdentityMessage(msg, {
-                                peerIdentityMap,
-                                localPeerId: localIdentity?.sessionKey ?? "",
-                                localAgentId: api.name,
-                                localChannel: relayChannel ?? "",
-                                localAccountId: relayAccountId ?? "",
-                                localInstanceId: localIdentity?.instanceId,
-                                send: async (targetPeerId, replyMsg) => {
-                                    mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => { });
-                                },
-                                logger: api.logger,
-                            }).catch((err) => {
-                                api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-                            });
-                            handled = true;
-                        }
-                    }
-                    catch {
-                        // payload 不是 JSON，正常走 direct 消息逻辑
-                    }
-                    if (!handled) {
-                        handleP2PInbound(msg, buildInboundDeps());
-                    }
-                }
-                else {
-                    handleP2PInbound(msg, buildInboundDeps());
-                }
-            });
             await mesh.start();
-            // Load persisted peer identities from disk
+            // Load persisted peer identities so dedup checks work on restart
             await peerIdentityMap.load();
-            const instanceIdentity = mesh.getInstanceIdentity();
-            const localInstanceId = instanceIdentity?.id;
-            const localPeerId = mesh.getLocalPeerId();
             // Register local identity so remote peers can route messages back to us
+            const config = api.pluginConfig;
+            const relayChannel = config?.relayChannel;
+            const relayAccountId = config?.relayAccountId;
             if (relayChannel && relayAccountId) {
+                const localPeerId = mesh.getLocalPeerId();
                 const { buildAgentSessionKey } = await import("openclaw/plugin-sdk/core");
                 const sessionKey = buildAgentSessionKey({
                     agentId: api.name,
@@ -105,83 +42,80 @@ export function registerLibp2pMesh(api) {
                     channel: relayChannel,
                     accountId: relayAccountId,
                     sessionKey,
-                    instanceId: localInstanceId,
                 });
-                await peerIdentityMap.register(localPeerId, {
-                    agentId: api.name,
-                    channel: relayChannel,
-                    accountId: relayAccountId,
-                    sessionKey,
-                    instanceId: localInstanceId,
-                });
-                api.logger.info?.(`[libp2p-mesh] Local identity registered: agent=${api.name}, channel=${relayChannel}, account=${relayAccountId}, instanceId=${localInstanceId}`);
+                api.logger.info?.(`[libp2p-mesh] Local identity registered: agent=${api.name}, channel=${relayChannel}, account=${relayAccountId}`);
                 // Announce identity to all currently-connected peers
-                const identityMsg = buildIdentityMessage(localPeerId, api.name, relayChannel, relayAccountId, localInstanceId);
-                for (const peerId of mesh.getConnectedPeers()) {
+                const identityMsg = JSON.stringify({
+                    id: crypto.randomUUID(),
+                    type: "identity",
+                    from: localPeerId,
+                    payload: JSON.stringify({
+                        agentId: api.name,
+                        channel: relayChannel,
+                        accountId: relayAccountId,
+                    }),
+                    timestamp: Date.now(),
+                });
+                const connectedPeers = mesh.getConnectedPeers();
+                for (const peerId of connectedPeers) {
                     try {
-                        await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
+                        await mesh.sendToPeer(peerId, identityMsg);
                     }
-                    catch (err) {
-                        api.logger.warn?.(`[libp2p-mesh] Failed to send initial identity to ${peerId}: ${String(err)}`);
+                    catch {
+                        // Best-effort; peer may be stale in the connection list
                     }
                 }
             }
-            // Register peer lifecycle handlers AFTER mesh.start() so that
-            // sendToPeer can establish streams reliably.  Without this deferral,
-            // onPeerConnect can fire during mDNS discovery (before node.start()
-            // completes), causing dialProtocol to fail because the protocol
-            // handler isn't fully wired yet — and the .catch(() => {}) swallows
-            // the error silently, breaking identity exchange entirely.
+            // Wire up relay-aware message handler
+            mesh.onMessage((msg) => {
+                handleP2PInbound(msg, buildInboundDeps());
+            });
+            // Dedup: skip identity send if peer is already known
             mesh.onPeerConnect((peerId) => {
+                if (peerIdentityMap.hasIdentity(peerId)) {
+                    api.logger.debug?.(`[libp2p-mesh] Peer ${peerId} already known, skipping identity send`);
+                    return;
+                }
                 api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
-                // Only send identity if relay config is set (otherwise there's no
-                // identity to announce).
+                // Only send identity if relay config is set
                 if (!relayChannel || !relayAccountId)
                     return;
-                const msg = buildIdentityMessage(localPeerId ?? "", api.name, relayChannel, relayAccountId, localInstanceId);
-                // Retry up to 3 times with 500ms间隔, log failures
-                const maxRetries = 3;
-                let attempt = 0;
-                const sendWithRetry = async () => {
-                    try {
-                        await mesh.sendToPeer(peerId, JSON.stringify(msg));
-                    }
-                    catch (err) {
-                        attempt++;
-                        if (attempt < maxRetries) {
-                            api.logger.debug?.(`[libp2p-mesh] Identity send to ${peerId} failed (attempt ${attempt}/${maxRetries}), retrying...`);
-                            setTimeout(sendWithRetry, 500);
-                        }
-                        else {
-                            api.logger.warn?.(`[libp2p-mesh] Failed to send identity to ${peerId} after ${maxRetries} attempts: ${String(err)}`);
-                        }
-                    }
-                };
-                sendWithRetry();
-            });
-            mesh.onPeerDisconnect((peerId) => {
-                api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
-                peerIdentityMap.unregister(peerId);
-                peerIdentityMap.saveNow().catch(() => { });
+                const msg = JSON.stringify({
+                    id: crypto.randomUUID(),
+                    type: "identity",
+                    from: mesh.getLocalPeerId(),
+                    payload: JSON.stringify({
+                        agentId: api.name,
+                        channel: relayChannel,
+                        accountId: relayAccountId,
+                    }),
+                    timestamp: Date.now(),
+                });
+                mesh.sendToPeer(peerId, msg).catch(() => { });
             });
-            // Actively announce identity to all currently-connected peers.
-            // This covers the race where mDNS discovery fires peer:connect during
-            // node.start() before onPeerConnect was registered — those peers are
-            // already connected but never received our identity.
+            // Dedup: skip initial identity announce for known peers
             if (relayChannel && relayAccountId) {
-                const identityMsg = buildIdentityMessage(localPeerId ?? "", api.name, relayChannel, relayAccountId, localInstanceId);
-                const connectedNow = mesh.getConnectedPeers();
-                if (connectedNow.length > 0) {
-                    api.logger.info?.(`[libp2p-mesh] Sending initial identity to ${connectedNow.length} connected peer(s)`);
-                    for (const peerId of connectedNow) {
-                        mesh.sendToPeer(peerId, JSON.stringify(identityMsg)).catch((err) => {
-                            api.logger.debug?.(`[libp2p-mesh] Initial identity send to ${peerId} failed: ${String(err)}`);
-                        });
+                const identityMsg = JSON.stringify({
+                    id: crypto.randomUUID(),
+                    type: "identity",
+                    from: mesh.getLocalPeerId(),
+                    payload: JSON.stringify({
+                        agentId: api.name,
+                        channel: relayChannel,
+                        accountId: relayAccountId,
+                    }),
+                    timestamp: Date.now(),
+                });
+                for (const peerId of mesh.getConnectedPeers()) {
+                    if (peerIdentityMap.hasIdentity(peerId)) {
+                        api.logger.debug?.(`[libp2p-mesh] Peer ${peerId} already known, skipping initial identity`);
+                        continue;
                     }
+                    mesh.sendToPeer(peerId, identityMsg).catch(() => { });
                 }
             }
             const identity = mesh.getInstanceIdentity();
-            api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${localPeerId}`);
+            api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
             if (identity) {
                 api.logger.info?.(`[libp2p-mesh] Instance Identity: ${identity.id}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-mesh",
-  "version": "2026.5.26",
+  "version": "2026.5.28",
   "description": "OpenClaw libp2p P2P mesh network plugin for cross-instance agent communication",
   "type": "module",
   "main": "dist/index.js",

package/src/identity-exchange.ts

@@ -40,7 +40,7 @@ export async function handleIdentityMessage(
   const logger = deps.logger;
 
   // Parse remote identity payload
-  let parsed: { agentId?: string; channel?: string; accountId?: string; instanceId?: string } = {};
+  let parsed: Record<string, unknown> = {};
   try {
     parsed = JSON.parse(msg.payload);
   } catch {
@@ -48,7 +48,24 @@ export async function handleIdentityMessage(
     return;
   }
 
-  const { agentId, channel, accountId, instanceId } = parsed;
+  // sendToPeer 包装了一层 direct 外壳后，payload 里可能嵌套了 identity 消息：
+  //   outer: {"type":"identity","from":"A","payload":"{\"agentId\":\"A\",\"channel\":\"feishu\",...}"}
+  // 先解析拿到外层，再检测 type 并递归解析内层 payload。
+  if (parsed.type === "identity" && typeof parsed.payload === "string") {
+    try {
+      parsed = JSON.parse(parsed.payload);
+    } catch {
+      // Inner payload malformed — skip silently
+      return;
+    }
+  }
+
+  const { agentId, channel, accountId, instanceId } = parsed as {
+    agentId?: string;
+    channel?: string;
+    accountId?: string;
+    instanceId?: string;
+  };
 
   // Only register if all required fields are present
   if (agentId && channel && accountId) {

package/src/inbound.ts

@@ -137,27 +137,10 @@ export async function handleP2PInbound(msg: P2PMessage, deps?: InboundHandlerDep
         }
       }
 
-      // If the sender is not yet registered, register them synchronously
-      // (in-memory only) so that subsequent message routing works correctly.
-      // This handles NAT/relay scenarios where peer:connect may not fire
-      // bidirectionally, causing the identity exchange to be one-sided.
-      // Persistence (saveNow) is fire-and-forget to avoid blocking the
-      // message handler.
       if (!deps.peerIdentityMap.hasIdentity(msg.from)) {
-        const localIdentity = deps.peerIdentityMap.getLocalIdentity();
-        if (localIdentity) {
-          deps.peerIdentityMap.registerSync(msg.from, {
-            agentId: localIdentity.agentId,
-            channel: localIdentity.channel,
-            accountId: localIdentity.accountId,
-            sessionKey: "",
-            instanceId: msg.instanceId,
-          });
-          deps.peerIdentityMap.saveNow().catch(() => {});
-          logger?.debug?.(
-            `[libp2p-mesh] Auto-registered unknown sender ${msg.from} from direct message`,
-          );
-        }
+        logger?.debug?.(
+          `[libp2p-mesh] Unknown sender ${msg.from}, waiting for identity exchange`,
+        );
       }
     } else if (msg.type === "broadcast") {
       const topic = msg.topic || "(none)";
@@ -191,22 +174,10 @@ export async function handleP2PInbound(msg: P2PMessage, deps?: InboundHandlerDep
         deps.enqueueNextTurnInjection({ sessionKey, text, placement: "prepend_context" });
       }
 
-      // If the sender is not yet registered, register them synchronously
       if (!deps.peerIdentityMap.hasIdentity(msg.from)) {
-        const localIdentity = deps.peerIdentityMap.getLocalIdentity();
-        if (localIdentity) {
-          deps.peerIdentityMap.registerSync(msg.from, {
-            agentId: localIdentity.agentId,
-            channel: localIdentity.channel,
-            accountId: localIdentity.accountId,
-            sessionKey: "",
-            instanceId: msg.instanceId,
-          });
-          deps.peerIdentityMap.saveNow().catch(() => {});
-          logger?.debug?.(
-            `[libp2p-mesh] Auto-registered unknown sender ${msg.from} from broadcast`,
-          );
-        }
+        logger?.debug?.(
+          `[libp2p-mesh] Unknown sender ${msg.from}, waiting for identity exchange`,
+        );
       }
     }
   }

package/src/plugin.ts

@@ -1,11 +1,9 @@
-import type { OpenClawPluginApi, PluginNextTurnInjection } from "openclaw/plugin-sdk/core";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
-import { handleIdentityMessage } from "./identity-exchange.js";
 import { createMeshNetwork } from "./mesh.js";
 import { buildP2PTools } from "./agent-tools.js";
 import { createPeerIdentityMap } from "./peer-identity.js";
-import { buildIdentityMessage } from "./identity-exchange.js";
 import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
 import type { MeshConfig } from "./types.js";
 
@@ -16,94 +14,33 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
   });
 
   // Singleton: maps peerId -> { agentId, channel, accountId, sessionKey }
-  // Declared here (not inside start) so tool registration below can attach
-  // it to tool objects via closure.
   const peerIdentityMap = createPeerIdentityMap();
 
+  // Helper: build the deps object for the relay-aware inbound handler
+  function buildInboundDeps() {
+    return {
+      peerIdentityMap,
+      enqueueNextTurnInjection: (injection: any) =>
+        api.session.workflow.enqueueNextTurnInjection(injection),
+      logger: api.logger,
+    };
+  }
+
   // 1. Register Service (manages libp2p node lifecycle)
   api.registerService({
     id: "libp2p-mesh",
     start: async () => {
-      // Gather config before starting (needed for onMessage handler)
-      const config = api.pluginConfig as MeshConfig | undefined;
-      const relayChannel = config?.relayChannel;
-      const relayAccountId = config?.relayAccountId;
-
-      function buildInboundDeps() {
-        return {
-          peerIdentityMap,
-          enqueueNextTurnInjection: (injection: PluginNextTurnInjection) =>
-            api.session.workflow.enqueueNextTurnInjection(injection),
-          logger: api.logger,
-        };
-      }
-
-      // Wire up relay-aware message handler BEFORE mesh.start() so that
-      // any identity messages arriving during startup are queued by libp2p
-      // and processed as soon as the protocol handler is ready.
-      mesh.onMessage((msg) => {
-        if (msg.type === "identity") {
-          const localIdentity = peerIdentityMap.getLocalIdentity();
-          handleIdentityMessage(msg, {
-            peerIdentityMap,
-            localPeerId: localIdentity?.sessionKey ?? "",
-            localAgentId: api.name,
-            localChannel: relayChannel ?? "",
-            localAccountId: relayAccountId ?? "",
-            localInstanceId: localIdentity?.instanceId,
-            send: async (targetPeerId: string, replyMsg: any) => {
-              mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => {});
-            },
-            logger: api.logger,
-          }).catch((err) => {
-            api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-          });
-        } else if (msg.type === "direct") {
-          // sendToPeer 包装了一层 direct 外壳，原始 identity 消息藏在 payload 里。
-          // 检测并处理：注册对方 + 发送自己的身份回复。
-          let handled = false;
-          try {
-            const raw = JSON.parse(msg.payload);
-            if (raw && raw.type === "identity") {
-              const localIdentity = peerIdentityMap.getLocalIdentity();
-              handleIdentityMessage(msg, {
-                peerIdentityMap,
-                localPeerId: localIdentity?.sessionKey ?? "",
-                localAgentId: api.name,
-                localChannel: relayChannel ?? "",
-                localAccountId: relayAccountId ?? "",
-                localInstanceId: localIdentity?.instanceId,
-                send: async (targetPeerId: string, replyMsg: any) => {
-                  mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => {});
-                },
-                logger: api.logger,
-              }).catch((err) => {
-                api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-              });
-              handled = true;
-            }
-          } catch {
-            // payload 不是 JSON，正常走 direct 消息逻辑
-          }
-          if (!handled) {
-            handleP2PInbound(msg, buildInboundDeps());
-          }
-        } else {
-          handleP2PInbound(msg, buildInboundDeps());
-        }
-      });
-
       await mesh.start();
 
-      // Load persisted peer identities from disk
+      // Load persisted peer identities so dedup checks work on restart
       await peerIdentityMap.load();
 
-      const instanceIdentity = mesh.getInstanceIdentity();
-      const localInstanceId = instanceIdentity?.id;
-      const localPeerId = mesh.getLocalPeerId();
-
       // Register local identity so remote peers can route messages back to us
+      const config = api.pluginConfig as MeshConfig | undefined;
+      const relayChannel = config?.relayChannel;
+      const relayAccountId = config?.relayAccountId;
       if (relayChannel && relayAccountId) {
+        const localPeerId = mesh.getLocalPeerId();
         const { buildAgentSessionKey } = await import("openclaw/plugin-sdk/core");
         const sessionKey = buildAgentSessionKey({
           agentId: api.name,
@@ -115,115 +52,85 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
           channel: relayChannel,
           accountId: relayAccountId,
           sessionKey,
-          instanceId: localInstanceId,
-        });
-        await peerIdentityMap.register(localPeerId, {
-          agentId: api.name,
-          channel: relayChannel,
-          accountId: relayAccountId,
-          sessionKey,
-          instanceId: localInstanceId,
         });
         api.logger.info?.(
-          `[libp2p-mesh] Local identity registered: agent=${api.name}, channel=${relayChannel}, account=${relayAccountId}, instanceId=${localInstanceId}`,
+          `[libp2p-mesh] Local identity registered: agent=${api.name}, channel=${relayChannel}, account=${relayAccountId}`,
         );
 
         // Announce identity to all currently-connected peers
-        const identityMsg = buildIdentityMessage(
-          localPeerId,
-          api.name,
-          relayChannel,
-          relayAccountId,
-          localInstanceId,
-        );
-        for (const peerId of mesh.getConnectedPeers()) {
+        const identityMsg = JSON.stringify({
+          id: crypto.randomUUID(),
+          type: "identity",
+          from: localPeerId,
+          payload: JSON.stringify({
+            agentId: api.name,
+            channel: relayChannel,
+            accountId: relayAccountId,
+          }),
+          timestamp: Date.now(),
+        });
+        const connectedPeers = mesh.getConnectedPeers();
+        for (const peerId of connectedPeers) {
           try {
-            await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
-          } catch (err) {
-            api.logger.warn?.(
-              `[libp2p-mesh] Failed to send initial identity to ${peerId}: ${String(err)}`,
-            );
+            await mesh.sendToPeer(peerId, identityMsg);
+          } catch {
+            // Best-effort; peer may be stale in the connection list
           }
         }
       }
 
-      // Register peer lifecycle handlers AFTER mesh.start() so that
-      // sendToPeer can establish streams reliably.  Without this deferral,
-      // onPeerConnect can fire during mDNS discovery (before node.start()
-      // completes), causing dialProtocol to fail because the protocol
-      // handler isn't fully wired yet — and the .catch(() => {}) swallows
-      // the error silently, breaking identity exchange entirely.
+      // Wire up relay-aware message handler
+      mesh.onMessage((msg) => {
+        handleP2PInbound(msg, buildInboundDeps());
+      });
 
+      // Dedup: skip identity send if peer is already known
       mesh.onPeerConnect((peerId: string) => {
+        if (peerIdentityMap.hasIdentity(peerId)) {
+          api.logger.debug?.(`[libp2p-mesh] Peer ${peerId} already known, skipping identity send`);
+          return;
+        }
         api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
-        // Only send identity if relay config is set (otherwise there's no
-        // identity to announce).
+        // Only send identity if relay config is set
         if (!relayChannel || !relayAccountId) return;
-        const msg = buildIdentityMessage(
-          localPeerId ?? "",
-          api.name,
-          relayChannel,
-          relayAccountId,
-          localInstanceId,
-        );
-        // Retry up to 3 times with 500ms间隔, log failures
-        const maxRetries = 3;
-        let attempt = 0;
-        const sendWithRetry = async (): Promise<void> => {
-          try {
-            await mesh.sendToPeer(peerId, JSON.stringify(msg));
-          } catch (err) {
-            attempt++;
-            if (attempt < maxRetries) {
-              api.logger.debug?.(
-                `[libp2p-mesh] Identity send to ${peerId} failed (attempt ${attempt}/${maxRetries}), retrying...`,
-              );
-              setTimeout(sendWithRetry, 500);
-            } else {
-              api.logger.warn?.(
-                `[libp2p-mesh] Failed to send identity to ${peerId} after ${maxRetries} attempts: ${String(err)}`,
-              );
-            }
-          }
-        };
-        sendWithRetry();
-      });
-
-      mesh.onPeerDisconnect((peerId: string) => {
-        api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
-        peerIdentityMap.unregister(peerId);
-        peerIdentityMap.saveNow().catch(() => {});
+        const msg = JSON.stringify({
+          id: crypto.randomUUID(),
+          type: "identity",
+          from: mesh.getLocalPeerId(),
+          payload: JSON.stringify({
+            agentId: api.name,
+            channel: relayChannel,
+            accountId: relayAccountId,
+          }),
+          timestamp: Date.now(),
+        });
+        mesh.sendToPeer(peerId, msg).catch(() => {});
       });
 
-      // Actively announce identity to all currently-connected peers.
-      // This covers the race where mDNS discovery fires peer:connect during
-      // node.start() before onPeerConnect was registered — those peers are
-      // already connected but never received our identity.
+      // Dedup: skip initial identity announce for known peers
       if (relayChannel && relayAccountId) {
-        const identityMsg = buildIdentityMessage(
-          localPeerId ?? "",
-          api.name,
-          relayChannel,
-          relayAccountId,
-          localInstanceId,
-        );
-        const connectedNow = mesh.getConnectedPeers();
-        if (connectedNow.length > 0) {
-          api.logger.info?.(
-            `[libp2p-mesh] Sending initial identity to ${connectedNow.length} connected peer(s)`,
-          );
-          for (const peerId of connectedNow) {
-            mesh.sendToPeer(peerId, JSON.stringify(identityMsg)).catch((err) => {
-              api.logger.debug?.(
-                `[libp2p-mesh] Initial identity send to ${peerId} failed: ${String(err)}`,
-              );
-            });
+        const identityMsg = JSON.stringify({
+          id: crypto.randomUUID(),
+          type: "identity",
+          from: mesh.getLocalPeerId(),
+          payload: JSON.stringify({
+            agentId: api.name,
+            channel: relayChannel,
+            accountId: relayAccountId,
+          }),
+          timestamp: Date.now(),
+        });
+        for (const peerId of mesh.getConnectedPeers()) {
+          if (peerIdentityMap.hasIdentity(peerId)) {
+            api.logger.debug?.(`[libp2p-mesh] Peer ${peerId} already known, skipping initial identity`);
+            continue;
           }
+          mesh.sendToPeer(peerId, identityMsg).catch(() => {});
         }
       }
 
       const identity = mesh.getInstanceIdentity();
-      api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${localPeerId}`);
+      api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
       if (identity) {
         api.logger.info?.(`[libp2p-mesh] Instance Identity: ${identity.id}`);
       }