libp2p-mesh 2026.5.12

package/dist/src/discovery.d.ts

@@ -0,0 +1,6 @@
+import type { MeshConfig } from "./types.js";
+export declare function resolveDiscoveryConfig(config?: MeshConfig): {
+    enabled: boolean;
+    mechanism: "mdns" | "bootstrap" | "dht";
+    bootstrapList: string[];
+};

package/dist/src/discovery.js

@@ -0,0 +1,7 @@
+export function resolveDiscoveryConfig(config) {
+    return {
+        enabled: true,
+        mechanism: config?.discovery ?? "mdns",
+        bootstrapList: config?.bootstrapList ?? [],
+    };
+}

package/dist/src/inbound.d.ts

@@ -0,0 +1,11 @@
+import type { P2PMessage } from "./types.js";
+export type InboundHandlerDeps = {
+    logger?: {
+        info?: (msg: string) => void;
+        debug?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+    sendToChannel?: (channelId: string, target: string, text: string) => Promise<void>;
+};
+export declare function handleP2PInbound(msg: P2PMessage, deps: InboundHandlerDeps): void;

package/dist/src/inbound.js

@@ -0,0 +1,16 @@
+export function handleP2PInbound(msg, deps) {
+    const { logger, sendToChannel } = deps;
+    if (msg.type === "broadcast") {
+        logger?.info?.(`[libp2p-mesh] Broadcast from ${msg.from} on topic ${msg.topic ?? "(none)"}: ${msg.payload}`);
+        return;
+    }
+    // Direct message — log and forward to local channel
+    logger?.info?.(`[libp2p-mesh] Direct message from ${msg.from}: ${msg.payload}`);
+    if (!sendToChannel || !msg.payload) {
+        return;
+    }
+    const text = `[来自 ${msg.from}]\n${msg.payload}`;
+    sendToChannel("libp2p-mesh", msg.from, text).catch((err) => {
+        logger?.error?.(`[libp2p-mesh] Failed to forward direct message from ${msg.from}: ${err}`);
+    });
+}

package/dist/src/mesh.d.ts

@@ -0,0 +1,10 @@
+import type { MeshConfig, MeshNetwork } from "./types.js";
+export declare function createMeshNetwork(options: {
+    config?: MeshConfig;
+    logger?: {
+        info?: (msg: string) => void;
+        debug?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}): MeshNetwork;

package/dist/src/mesh.js

@@ -0,0 +1,305 @@
+// Polyfill for Node.js < 22 (libp2p dependencies use Promise.withResolvers)
+if (!Promise.withResolvers) {
+    Promise.withResolvers = function () {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { promise, resolve: resolve, reject: reject };
+    };
+}
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { mdns } from "@libp2p/mdns";
+import { mplex } from "@libp2p/mplex";
+import { noise } from "@libp2p/noise";
+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 { encode, decode } from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import { createLibp2p } from "libp2p";
+import { Uint8ArrayList } from "uint8arraylist";
+const PROTOCOL = "/openclaw-msg/1.0.0";
+const MAX_SEEN_MESSAGES = 1000;
+function resolvePeerIdPath(customPath) {
+    if (customPath)
+        return customPath;
+    const stateDir = process.env.OPENCLAW_STATE_DIR;
+    if (stateDir) {
+        return path.join(stateDir, "libp2p", "peer-id.json");
+    }
+    return path.join(homedir(), ".openclaw", "libp2p", "peer-id.json");
+}
+async function loadOrCreatePeerId(customPath) {
+    const peerIdPath = resolvePeerIdPath(customPath);
+    try {
+        const saved = JSON.parse(await readFile(peerIdPath, "utf8"));
+        const peerId = await createFromProtobuf(Buffer.from(saved.protobuf, "base64"));
+        return peerId;
+    }
+    catch {
+        const peerId = await createEd25519PeerId();
+        const protobuf = Buffer.from(exportToProtobuf(peerId)).toString("base64");
+        await mkdir(path.dirname(peerIdPath), { recursive: true });
+        await writeFile(peerIdPath, JSON.stringify({ protobuf }, null, 2));
+        return peerId;
+    }
+}
+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,
+    };
+    const seenMessages = new Set();
+    const messageHandlers = new Set();
+    const topicHandlers = new Map();
+    async function start() {
+        const peerId = await loadOrCreatePeerId(config.peerIdPath);
+        // Build transports dynamically
+        const transports = [tcp()];
+        if (config.enableWebSocket) {
+            transports.push(webSockets());
+        }
+        // Build peer discovery dynamically
+        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") {
+            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 {
+                logger?.warn?.("[libp2p-mesh] discovery=bootstrap but bootstrapList is empty; falling back to mDNS");
+                peerDiscovery.push(mdns({ interval: 1000 }));
+            }
+        }
+        else if (discoveryMechanism === "dht") {
+            logger?.warn?.("[libp2p-mesh] DHT discovery is not yet implemented; falling back to mDNS");
+            peerDiscovery.push(mdns({ interval: 1000 }));
+        }
+        state.node = await createLibp2p({
+            peerId,
+            start: false,
+            transports,
+            connectionEncryption: [noise()],
+            streamMuxers: [mplex()],
+            addresses: {
+                listen: config.listenAddrs ?? ["/ip4/0.0.0.0/tcp/0"],
+            },
+            peerDiscovery,
+        });
+        state.node.addEventListener("peer:connect", (evt) => {
+            const peerIdStr = evt.detail.toString();
+            logger?.debug?.(`[libp2p-mesh] Peer connected: ${peerIdStr}`);
+        });
+        state.node.addEventListener("peer:disconnect", (evt) => {
+            const peerIdStr = evt.detail.toString();
+            logger?.debug?.(`[libp2p-mesh] Peer disconnected: ${peerIdStr}`);
+        });
+        await state.node.handle(PROTOCOL, async ({ stream, connection }) => {
+            try {
+                await pipe(stream.source, decode, async (source) => {
+                    for await (const msg of source) {
+                        const data = new TextDecoder().decode(msg.subarray());
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(data);
+                        }
+                        catch {
+                            logger?.warn?.(`[libp2p-mesh] Failed to parse message from ${connection.remotePeer.toString()}`);
+                            continue;
+                        }
+                        if (seenMessages.has(parsed.id)) {
+                            continue;
+                        }
+                        if (seenMessages.size >= MAX_SEEN_MESSAGES) {
+                            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
+                        for (const handler of messageHandlers) {
+                            try {
+                                handler(parsed);
+                            }
+                            catch (err) {
+                                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) {
+                                for (const h of handlers) {
+                                    try {
+                                        h(parsed.payload);
+                                    }
+                                    catch (err) {
+                                        logger?.error?.(`[libp2p-mesh] Topic handler error: ${String(err)}`);
+                                    }
+                                }
+                            }
+                            // Flood-fill forward to other connected peers (with TTL guard)
+                            await forwardBroadcast(parsed, connection.remotePeer.toString());
+                        }
+                    }
+                });
+            }
+            catch (err) {
+                logger?.error?.(`[libp2p-mesh] Protocol handler error: ${String(err)}`);
+            }
+        });
+        await state.node.start();
+        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(", ")}`);
+    }
+    async function stop() {
+        if (state.node) {
+            await state.node.stop();
+            state.node = null;
+            logger?.info?.("[libp2p-mesh] Node stopped.");
+        }
+    }
+    async function sendToPeer(peerId, message) {
+        if (!state.node) {
+            throw new Error("Mesh network is not started");
+        }
+        const msg = {
+            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");
+            logger?.debug?.(`[libp2p-mesh] dialProtocol to ${peerId}`);
+            const stream = await state.node.dialProtocol(peerIdFromString(peerId), PROTOCOL, {
+                signal: abortController.signal,
+            });
+            if (!stream) {
+                throw new Error(`Failed to establish stream to ${peerId}; peer may be unreachable`);
+            }
+            logger?.debug?.(`[libp2p-mesh] stream opened to ${peerId}`);
+            await pipe([new Uint8ArrayList(data)], encode, stream.sink);
+            logger?.debug?.(`[libp2p-mesh] message sent to ${peerId}`);
+        }
+        catch (err) {
+            logger?.error?.(`[libp2p-mesh] sendToPeer error: ${String(err)}`);
+            if (abortController.signal.aborted) {
+                throw new Error(`Send to ${peerId} timed out after 8s`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async function publishToTopic(topic, message) {
+        if (!state.node) {
+            throw new Error("Mesh network is not started");
+        }
+        const msg = {
+            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;
+        for (const conn of connections) {
+            const abortController = new AbortController();
+            const timeout = setTimeout(() => abortController.abort(), 5000);
+            try {
+                const stream = await conn.newStream(PROTOCOL, { signal: abortController.signal });
+                await pipe([new Uint8ArrayList(data)], encode, stream.sink);
+                sent++;
+            }
+            catch {
+                // Ignore individual forwarding errors
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        logger?.debug?.(`[libp2p-mesh] Broadcast sent to ${sent} peer(s) on topic ${topic}`);
+    }
+    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();
+            if (remotePeerId === fromPeerId)
+                continue;
+            const abortController = new AbortController();
+            const timeout = setTimeout(() => abortController.abort(), 5000);
+            try {
+                const stream = await conn.newStream(PROTOCOL, { signal: abortController.signal });
+                await pipe([new Uint8ArrayList(data)], encode, stream.sink);
+            }
+            catch {
+                // Ignore forwarding errors
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    function onMessage(handler) {
+        messageHandlers.add(handler);
+        return () => {
+            messageHandlers.delete(handler);
+        };
+    }
+    async function subscribeToTopic(topic, handler) {
+        if (!topicHandlers.has(topic)) {
+            topicHandlers.set(topic, new Set());
+        }
+        topicHandlers.get(topic).add(handler);
+    }
+    function getLocalPeerId() {
+        return state.node?.peerId.toString() ?? "";
+    }
+    function getConnectedPeers() {
+        if (!state.node)
+            return [];
+        const peers = state.node.getConnections().map((c) => c.remotePeer.toString());
+        return [...new Set(peers)];
+    }
+    return {
+        start,
+        stop,
+        sendToPeer,
+        onMessage,
+        publishToTopic,
+        subscribeToTopic,
+        getLocalPeerId,
+        getConnectedPeers,
+    };
+}

package/dist/src/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+export declare function registerLibp2pMesh(api: OpenClawPluginApi): void;

package/dist/src/plugin.js

@@ -0,0 +1,84 @@
+import { createLibp2pMeshChannel } from "./channel.js";
+import { handleP2PInbound } from "./inbound.js";
+import { createMeshNetwork } from "./mesh.js";
+import { buildP2PTools } from "./agent-tools.js";
+import { sendViaMesh } from "./send.js";
+export function registerLibp2pMesh(api) {
+    const mesh = createMeshNetwork({
+        config: api.pluginConfig,
+        logger: api.logger,
+    });
+    const channel = createLibp2pMeshChannel(mesh);
+    // 1. Register Service (manages libp2p node lifecycle)
+    api.registerService({
+        id: "libp2p-mesh",
+        start: async () => {
+            api.logger.info?.("[libp2p-mesh] >>> Service start called");
+            await mesh.start();
+            api.logger.info?.(`[libp2p-mesh] >>> mesh.start() done, Peer ID: ${mesh.getLocalPeerId()}`);
+            mesh.onMessage((msg) => {
+                api.logger.info?.("[libp2p-mesh] >>> onMessage handler registered");
+                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 });
+            });
+            api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
+        },
+        stop: async () => {
+            await mesh.stop();
+            api.logger.info?.("[libp2p-mesh] Service stopped.");
+        },
+    });
+    // 2. Register Channel (lightweight debugging surface)
+    api.registerChannel({
+        plugin: channel,
+    });
+    // 3. Register Agent Tools
+    const tools = buildP2PTools(mesh);
+    for (const tool of tools) {
+        api.registerTool(tool);
+    }
+    // 4. Register Command (injects agent prompt guidance so the LLM knows to use
+    //    p2p_list_peers / p2p_send_message / p2p_broadcast for P2P mesh operations
+    //    instead of the built-in `nodes` tool, which only manages OpenClaw paired nodes.)
+    api.registerCommand({
+        name: "p2p",
+        description: "P2P mesh network operations (list peers, send messages, broadcast).",
+        agentPromptGuidance: [
+            "When the user asks to list, show, or discover P2P mesh peers or connected agents, use the p2p_list_peers tool. Do NOT use the built-in `nodes` tool for this — `nodes` lists OpenClaw paired nodes, not P2P mesh peers.",
+            "When the user asks to send a direct message to another peer/agent, use p2p_send_message.",
+            "When the user asks to broadcast a message to all peers on a topic, use p2p_broadcast.",
+        ],
+        handler: (_ctx) => {
+            return { text: "P2P mesh tools are available. Use p2p_list_peers, p2p_send_message, or p2p_broadcast." };
+        },
+    });
+    // 5. Register CLI commands for operator access
+    api.registerCli((ctx) => {
+        ctx.program
+            .command("status")
+            .description("Show local peer ID and connected peers")
+            .action(async () => {
+            const peers = mesh.getConnectedPeers();
+            ctx.logger.info?.(`Local Peer ID: ${mesh.getLocalPeerId()}\nConnected peers (${peers.length}): ${peers.join(", ") || "none"}`);
+        });
+        ctx.program
+            .command("peers")
+            .description("Alias for mesh status — list connected peers")
+            .action(async () => {
+            const peers = mesh.getConnectedPeers();
+            ctx.logger.info?.(`Connected peers (${peers.length}): ${peers.join(", ") || "none"}`);
+        });
+    }, { parentPath: ["p2p"] });
+    // 6. 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" });
+}

package/dist/src/pubsub.d.ts

@@ -0,0 +1,3 @@
+import type { MeshNetwork } from "./types.js";
+export declare function broadcastToMesh(mesh: MeshNetwork, topic: string, message: string): Promise<void>;
+export declare function subscribeToMeshTopic(mesh: MeshNetwork, topic: string, handler: (msg: string) => void): Promise<() => void>;

package/dist/src/pubsub.js

@@ -0,0 +1,10 @@
+export async function broadcastToMesh(mesh, topic, message) {
+    await mesh.publishToTopic(topic, message);
+}
+export async function subscribeToMeshTopic(mesh, topic, handler) {
+    await mesh.subscribeToTopic(topic, handler);
+    return () => {
+        // Unsubscribe is not directly supported in the current MeshNetwork interface;
+        // the handler reference could be stored externally for future cleanup.
+    };
+}

package/dist/src/send.d.ts

@@ -0,0 +1,2 @@
+import type { MeshNetwork } from "./types.js";
+export declare function sendViaMesh(mesh: MeshNetwork, peerId: string, text: string): Promise<void>;

package/dist/src/send.js

@@ -0,0 +1,9 @@
+export async function sendViaMesh(mesh, peerId, text) {
+    if (!peerId || !peerId.trim()) {
+        throw new Error("Peer ID is required");
+    }
+    if (!text || !text.trim()) {
+        throw new Error("Message text is required");
+    }
+    await mesh.sendToPeer(peerId.trim(), text.trim());
+}

package/dist/src/types.d.ts

@@ -0,0 +1,33 @@
+export interface P2PMessage {
+    id: string;
+    type: "direct" | "broadcast" | "agent-sync";
+    from: string;
+    to?: string;
+    topic?: string;
+    payload: string;
+    timestamp: number;
+}
+export interface MeshConfig {
+    listenAddrs?: string[];
+    discovery?: "mdns" | "bootstrap" | "dht";
+    bootstrapList?: string[];
+    meshTopic?: string;
+    enableAgentSync?: boolean;
+    enableWebSocket?: boolean;
+    peerIdPath?: string;
+}
+export interface MeshNetwork {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendToPeer(peerId: string, message: string): Promise<void>;
+    onMessage(handler: (msg: P2PMessage) => void): () => void;
+    publishToTopic(topic: string, message: string): Promise<void>;
+    subscribeToTopic(topic: string, handler: (msg: string) => void): Promise<void>;
+    getLocalPeerId(): string;
+    getConnectedPeers(): string[];
+}
+export type MeshAccount = {
+    accountId: string;
+    configured: boolean;
+    enabled: boolean;
+};

package/dist/src/types.js

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

package/index.ts

@@ -0,0 +1,65 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
+import type { OpenClawPluginConfigSchema } from "openclaw/plugin-sdk/core";
+import { registerLibp2pMesh } from "./src/plugin.js";
+
+function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema {
+  return {
+    safeParse(value: unknown) {
+      if (value === undefined) {
+        return { success: true, data: undefined };
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {
+          success: false,
+          error: { issues: [{ path: [], message: "expected config object" }] },
+        };
+      }
+      return { success: true, data: value };
+    },
+    jsonSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        listenAddrs: {
+          type: "array",
+          items: { type: "string" },
+          default: ["/ip4/0.0.0.0/tcp/0"],
+        },
+        enableWebSocket: {
+          type: "boolean",
+          default: false,
+          description: "Enable WebSocket transport (useful for browser compatibility)",
+        },
+        discovery: {
+          type: "string",
+          enum: ["mdns", "bootstrap", "dht"],
+          default: "mdns",
+        },
+        bootstrapList: {
+          type: "array",
+          items: { type: "string" },
+        },
+        meshTopic: {
+          type: "string",
+          default: "openclaw-mesh",
+        },
+        enablePubsub: {
+          type: "boolean",
+          default: true,
+        },
+        enableAgentSync: {
+          type: "boolean",
+          default: true,
+        },
+      },
+    },
+  };
+}
+
+export default definePluginEntry({
+  id: "libp2p-mesh",
+  name: "libp2p Mesh Network",
+  description: "P2P network for cross-instance agent communication via libp2p.",
+  configSchema: createLibp2pMeshConfigSchema(),
+  register: registerLibp2pMesh,
+});

package/openclaw.plugin.json

@@ -0,0 +1,97 @@
+{
+  "id": "libp2p-mesh",
+  "name": "libp2p Mesh Network",
+  "description": "P2P network for cross-instance agent communication via libp2p.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "listenAddrs": {
+        "type": "array",
+        "items": { "type": "string" },
+        "default": ["/ip4/0.0.0.0/tcp/0"]
+      },
+      "enableWebSocket": {
+        "type": "boolean",
+        "default": false,
+        "description": "Enable WebSocket transport (useful for browser compatibility)"
+      },
+      "discovery": {
+        "type": "string",
+        "enum": ["mdns", "bootstrap", "dht"],
+        "default": "mdns"
+      },
+      "bootstrapList": {
+        "type": "array",
+        "items": { "type": "string" }
+      },
+      "meshTopic": {
+        "type": "string",
+        "default": "openclaw-mesh"
+      },
+      "enablePubsub": {
+        "type": "boolean",
+        "default": true
+      },
+      "enableAgentSync": {
+        "type": "boolean",
+        "default": true
+      }
+    }
+  },
+  "channels": ["libp2p-mesh"],
+  "channelConfigs": {
+    "libp2p-mesh": {
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "listenAddrs": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["/ip4/0.0.0.0/tcp/0"]
+          },
+          "enableWebSocket": {
+            "type": "boolean",
+            "default": false,
+            "description": "Enable WebSocket transport"
+          },
+          "discovery": {
+            "type": "string",
+            "enum": ["mdns", "bootstrap", "dht"],
+            "default": "mdns"
+          },
+          "bootstrapList": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "meshTopic": {
+            "type": "string",
+            "default": "openclaw-mesh"
+          }
+        }
+      }
+    }
+  },
+  "uiHints": {
+    "listenAddrs": {
+      "label": "Listen Addresses",
+      "help": "libp2p listen multiaddrs (e.g. /ip4/0.0.0.0/tcp/0).",
+      "advanced": true
+    },
+    "discovery": {
+      "label": "Discovery Mechanism",
+      "help": "Peer discovery: mdns (LAN), bootstrap (static list), or dht (Kademlia)."
+    },
+    "bootstrapList": {
+      "label": "Bootstrap Peers",
+      "help": "Static bootstrap peer multiaddrs when discovery=bootstrap.",
+      "advanced": true
+    },
+    "meshTopic": {
+      "label": "Mesh Topic",
+      "help": "Default topic used for P2P broadcasts.",
+      "advanced": true
+    }
+  }
+}