libp2p-mesh 2026.6.2 → 2026.6.4

package/README.md

@@ -42,29 +42,49 @@ openclaw plugins registry --refresh
 
 The published npm package includes compiled JavaScript under `dist/`, so OpenClaw and acpx can load it directly.
 
-Then add to your `~/.openclaw/openclaw.json`:
+## Configuration
 
-```json
-{
-  "plugins": {
-    "libp2p-mesh": {
-      "enabled": true,
-      "config": {
-        "discovery": "mdns"
-      }
-    }
-  },
-  "channels": {
-    "libp2p-mesh": {
-      "enabled": true
-    }
-  }
-}
+### Quick Setup (Recommended)
+
+After installation, run the interactive setup wizard:
+
+```bash
+openclaw libp2p-mesh setup
 ```
 
-## Configuration
+The wizard will guide you through:
+- Discovery mode (mDNS / Bootstrap / DHT)
+- Bootstrap peer addresses (for cross-network scenarios)
+- Inbound channel targets (where to display received P2P messages)
+- Optional: NAT traversal, circuit relay, fixed ports, and custom instance name
+
+The configuration is written to `~/.openclaw/openclaw.json` automatically.
+
+### Incremental Config Management
+
+```bash
+# View all current non-default settings
+openclaw libp2p-mesh config list
+
+# Read a single value
+openclaw libp2p-mesh config get discovery
+
+# Set a value
+openclaw libp2p-mesh config set discovery bootstrap
+
+# Add to an array
+openclaw libp2p-mesh config set bootstrapList --add /ip4/10.0.0.5/tcp/4001/p2p/12D3KooW...
+
+# Remove from an array
+openclaw libp2p-mesh config set bootstrapList --remove /ip4/203.0.113.10/tcp/4001/p2p/12D3KooW...
 
-Add a `libp2p-mesh` block to your `openclaw.json` under `plugins`:
+# Reset a key to default
+openclaw libp2p-mesh config unset relayList
+```
+
+### Manual Configuration (Advanced)
+
+You can still directly edit `~/.openclaw/openclaw.json`:
 
 ### Minimal LAN Setup (Default)
 
@@ -158,6 +178,7 @@ If peers are on different networks, use a bootstrap node:
 | `announceAddrs` | `string[]` | `[]` | Extra multiaddrs to announce on top of auto-detected ones |
 | `inboundChannel` | `string` | `undefined` | OpenClaw channel used to display inbound P2P user messages, for example `"feishu"` |
 | `inboundTarget` | `string` | `undefined` | OpenClaw channel target for inbound P2P messages, for example `user:ou_xxx` or `chat:oc_xxx` |
+| `inboundTargets` | `{ id?: string, channel: string, target: string }[]` | `undefined` | Receiver-owned list of channel targets for inbound P2P user messages. When present, overrides `inboundChannel`/`inboundTarget`; an empty array disables inbound delivery |
 | `deliveryAckTimeoutMs` | `number` | `15000` | Timeout for waiting on remote channel delivery ACKs |
 
 ## NAT Traversal
@@ -316,6 +337,47 @@ p2p_send_instance_message({ "instanceId": "<target-instance-id>", "message": "
 
 The sender reports success only after the remote OpenClaw instance forwards the message to its configured inbound channel and returns a delivery ACK.
 
+### Multi-channel inbound delivery
+
+To display the same inbound P2P message in multiple local OpenClaw channel targets, configure `inboundTargets` on the receiving instance:
+
+```json
+{
+  "plugins": {
+    "libp2p-mesh": {
+      "enabled": true,
+      "config": {
+        "discovery": "mdns",
+        "inboundTargets": [
+          {
+            "id": "feishu-user",
+            "channel": "feishu",
+            "target": "user:ou_xxx"
+          },
+          {
+            "id": "telegram-chat",
+            "channel": "telegram",
+            "target": "chat:123456"
+          }
+        ],
+        "deliveryAckTimeoutMs": 15000
+      }
+    }
+  },
+  "channels": {
+    "libp2p-mesh": { "enabled": true }
+  }
+}
+```
+
+The sender still calls only:
+
+```text
+p2p_send_instance_message({ "instanceId": "<target-instance-id>", "message": "今晚出来吃饭" })
+```
+
+The sender does not choose the receiver channel. The receiving instance owns that routing decision through `inboundTargets`, and the message appears in each configured `channel`/`target`. Each target can include an `id`, which is shown in the sender-side tool result alongside each target's success or failure status.
+
 Tools are not configured in `openclaw.json`; they are registered automatically by the plugin through `api.registerTool()`.
 
 ## Troubleshooting

package/api.ts

@@ -3,9 +3,11 @@ export { createInstancePeerStore } from "./src/instance-peer-store.js";
 export { createInstanceRouter } from "./src/instance-router.js";
 export type {
   DeliveryAckPayload,
+  DeliveryTargetResult,
   InboundDeliveryAdapter,
   InboundDeliveryRequest,
   InboundDeliveryResult,
+  InboundTargetConfig,
   InstanceAnnouncePayload,
   InstanceIdentity,
   InstancePeerRecord,

package/dist/api.d.ts

@@ -1,4 +1,4 @@
 export { createMeshNetwork } from "./src/mesh.js";
 export { createInstancePeerStore } from "./src/instance-peer-store.js";
 export { createInstanceRouter } from "./src/instance-router.js";
-export type { DeliveryAckPayload, InboundDeliveryAdapter, InboundDeliveryRequest, InboundDeliveryResult, InstanceAnnouncePayload, InstanceIdentity, InstancePeerRecord, InstancePeerStore, InstancePeerTable, InstanceRouter, MeshConfig, MeshNetwork, P2PMessage, P2PMessageType, UserMessagePayload, } from "./src/types.js";
+export type { DeliveryAckPayload, DeliveryTargetResult, InboundDeliveryAdapter, InboundDeliveryRequest, InboundDeliveryResult, InboundTargetConfig, InstanceAnnouncePayload, InstanceIdentity, InstancePeerRecord, InstancePeerStore, InstancePeerTable, InstanceRouter, MeshConfig, MeshNetwork, P2PMessage, P2PMessageType, UserMessagePayload, } from "./src/types.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { registerLibp2pMesh } from "./src/plugin.js";
+import { registerLibp2pMeshCli } from "./src/cli.js";
 function createLibp2pMeshConfigSchema() {
     return {
         safeParse(value) {
@@ -127,6 +128,29 @@ function createLibp2pMeshConfigSchema() {
                     type: "string",
                     description: "OpenClaw channel target for inbound P2P user messages, for example user:ou_xxx or chat:oc_xxx.",
                 },
+                inboundTargets: {
+                    type: "array",
+                    description: "OpenClaw channel targets used to display inbound P2P user messages. When present, this overrides inboundChannel/inboundTarget. An empty array disables inbound delivery.",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "Optional local display name used in logs and delivery ACK output.",
+                            },
+                            channel: {
+                                type: "string",
+                                description: "OpenClaw channel used to display this inbound P2P user message, for example \"feishu\".",
+                            },
+                            target: {
+                                type: "string",
+                                description: "OpenClaw channel target for this inbound P2P user message, for example user:ou_xxx or chat:oc_xxx.",
+                            },
+                        },
+                        required: ["channel", "target"],
+                    },
+                },
                 deliveryAckTimeoutMs: {
                     type: "number",
                     default: 15000,
@@ -141,5 +165,11 @@ export default definePluginEntry({
     name: "libp2p Mesh Network",
     description: "P2P network for cross-instance agent communication via libp2p.",
     configSchema: createLibp2pMeshConfigSchema(),
-    register: registerLibp2pMesh,
+    register: (api) => {
+        registerLibp2pMesh(api);
+        // 5. Register CLI commands (setup wizard + config management)
+        api.registerCli(registerLibp2pMeshCli, {
+            commands: ["libp2p-mesh"],
+        });
+    },
 });

package/dist/src/agent-tools.d.ts

@@ -1,4 +1,4 @@
-import type { InstanceRouter, MeshNetwork } from "./types.js";
+import type { DeliveryTargetResult, InstanceRouter, MeshNetwork } from "./types.js";
 export declare function buildP2PTools(mesh: MeshNetwork, router?: InstanceRouter): ({
     name: string;
     label: string;
@@ -407,9 +407,11 @@ export declare function buildP2PTools(mesh: MeshNetwork, router?: InstanceRouter
             toPeerId: string;
             ackMessageId?: string;
             inboundChannel?: string;
+            inboundTarget?: string;
+            deliveryResults?: DeliveryTargetResult[];
             error?: string;
         };
-        isError: boolean;
+        isError: boolean | undefined;
     } | {
         content: {
             type: "text";
@@ -422,6 +424,8 @@ export declare function buildP2PTools(mesh: MeshNetwork, router?: InstanceRouter
             toPeerId: string;
             ackMessageId?: string;
             inboundChannel?: string;
+            inboundTarget?: string;
+            deliveryResults?: DeliveryTargetResult[];
             error?: string;
         };
         isError?: undefined;

package/dist/src/agent-tools.js

@@ -1,3 +1,20 @@
+function targetLabel(result) {
+    const id = result.id?.trim();
+    const location = `${result.channel} / ${result.target}`;
+    return id ? `${id} (${location})` : location;
+}
+function formatDeliveryResults(instanceId, delivered, results) {
+    const header = delivered
+        ? `发往 ${instanceId} 的消息投递结果：`
+        : `发往 ${instanceId} 的消息投递失败：`;
+    const lines = results.map((result) => {
+        if (result.ok) {
+            return `- ${targetLabel(result)}：已送达`;
+        }
+        return `- ${targetLabel(result)}：失败：${result.error ?? "unknown error"}`;
+    });
+    return [header, ...lines].join("\n");
+}
 export function buildP2PTools(mesh, router) {
     return [
         {
@@ -320,6 +337,18 @@ export function buildP2PTools(mesh, router) {
                     };
                 }
                 const result = await router.sendInstanceMessage(instanceId, message);
+                if (result.deliveryResults && result.deliveryResults.length > 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: formatDeliveryResults(instanceId, result.delivered, result.deliveryResults),
+                            },
+                        ],
+                        details: result,
+                        isError: result.delivered ? undefined : true,
+                    };
+                }
                 if (!result.delivered) {
                     return {
                         content: [

package/dist/src/cli.d.ts

@@ -0,0 +1,15 @@
+import type { PluginLogger } from "openclaw/plugin-sdk/core";
+interface MinimalCommand {
+    command(name: string): MinimalCommand;
+    description(desc: string): MinimalCommand;
+    option(flags: string, description?: string): MinimalCommand;
+    action(fn: (...args: any[]) => void | Promise<void>): MinimalCommand;
+}
+interface OpenClawPluginCliContext {
+    program: MinimalCommand;
+    config: Record<string, unknown>;
+    workspaceDir?: string;
+    logger: PluginLogger;
+}
+export declare function registerLibp2pMeshCli(ctx: OpenClawPluginCliContext): void;
+export {};

package/dist/src/cli.js

@@ -0,0 +1,196 @@
+import { resolveConfigPath, readFullConfig, writeFullConfig, getNonDefaultConfig, getDefaultConfig, } from "./config-io.js";
+import { createReadlinePrompter, runSetupWizard, WizardCancelledError, } from "./wizard.js";
+export function registerLibp2pMeshCli(ctx) {
+    const { program, config: openclawConfig } = ctx;
+    const meshCmd = program
+        .command("libp2p-mesh")
+        .description("P2P Mesh 网络插件配置管理");
+    // ---- setup ----
+    meshCmd
+        .command("setup")
+        .description("交互式配置向导")
+        .action(async () => {
+        const configPath = resolveConfigPath();
+        const { pluginConfig } = readFullConfig(configPath);
+        // Discover available chat channels from config
+        const channels = openclawConfig.channels;
+        const availableChannels = [];
+        if (channels && typeof channels === "object" && !Array.isArray(channels)) {
+            for (const [id, entry] of Object.entries(channels)) {
+                if (id !== "libp2p-mesh" &&
+                    entry &&
+                    typeof entry === "object" &&
+                    entry.enabled !== false) {
+                    availableChannels.push(id);
+                }
+            }
+        }
+        const prompter = createReadlinePrompter();
+        try {
+            const newConfig = await runSetupWizard(prompter, pluginConfig, availableChannels);
+            writeFullConfig(configPath, newConfig);
+            console.log(`\n✓ 配置已写入 ${configPath}`);
+            console.log("  运行 openclaw gateway restart 使新配置生效。");
+        }
+        catch (err) {
+            if (err instanceof WizardCancelledError) {
+                process.exit(0);
+            }
+            if (err instanceof Error) {
+                console.error(`\n✗ ${err.message}`);
+            }
+            process.exit(1);
+        }
+        finally {
+            prompter.close();
+        }
+    });
+    // ---- config subcommand ----
+    const configCmd = meshCmd
+        .command("config")
+        .description("增量配置管理");
+    // ---- config list ----
+    configCmd
+        .command("list")
+        .description("列出当前所有非默认配置")
+        .action(() => {
+        const configPath = resolveConfigPath();
+        const { pluginConfig } = readFullConfig(configPath);
+        const nonDefault = getNonDefaultConfig(pluginConfig);
+        const keys = Object.keys(nonDefault);
+        if (keys.length === 0) {
+            console.log("当前无自定义配置，全部使用默认值。");
+            console.log("运行 openclaw libp2p-mesh setup 进行配置。");
+            return;
+        }
+        console.log("─────────────────────────────────");
+        console.log("  当前 libp2p-mesh 配置：\n");
+        for (const key of keys) {
+            const value = nonDefault[key];
+            if (Array.isArray(value)) {
+                console.log(`  ${key}:`);
+                if (value.length === 0) {
+                    console.log("    （空列表）");
+                }
+                else {
+                    for (const item of value) {
+                        if (typeof item === "object" && item !== null) {
+                            const obj = item;
+                            const label = obj.id ? `${obj.id} — ` : "";
+                            console.log(`    - ${label}${obj.channel ?? ""} / ${obj.target ?? ""}`);
+                        }
+                        else {
+                            console.log(`    - ${item}`);
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(`  ${key}:  ${value}`);
+            }
+        }
+        console.log(`\n  ...共 ${keys.length} 项非默认配置`);
+    });
+    // ---- config get ----
+    configCmd
+        .command("get <key>")
+        .description("读取单个配置值")
+        .action((key) => {
+        const configPath = resolveConfigPath();
+        const { pluginConfig } = readFullConfig(configPath);
+        const defaults = getDefaultConfig();
+        const value = key in pluginConfig ? pluginConfig[key] : defaults[key];
+        if (value === undefined) {
+            console.log(`  （未配置）`);
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 0) {
+                console.log("  （空列表）");
+            }
+            else {
+                for (const item of value) {
+                    if (typeof item === "object" && item !== null) {
+                        console.log(JSON.stringify(item, null, 2));
+                    }
+                    else {
+                        console.log(`  ${item}`);
+                    }
+                }
+            }
+        }
+        else {
+            console.log(`  ${value}`);
+        }
+    });
+    // ---- config set ----
+    configCmd
+        .command("set <key> [value]")
+        .description("设置配置值。数组类型使用 --add / --remove")
+        .option("--add <item>", "追加到数组")
+        .option("--remove <item>", "从数组中移除")
+        .action(async (key, value, opts) => {
+        const configPath = resolveConfigPath();
+        const { pluginConfig } = readFullConfig(configPath);
+        const defaults = getDefaultConfig();
+        const current = key in pluginConfig ? pluginConfig[key] : defaults[key];
+        const oldValue = current;
+        let newValue;
+        // Array operations
+        if (opts.add || opts.remove) {
+            const arr = Array.isArray(current) ? [...current] : [];
+            if (opts.add) {
+                if (arr.includes(opts.add)) {
+                    console.log(`  ⚠ 该值已存在`);
+                    return;
+                }
+                arr.push(opts.add);
+                console.log(`  ✓ 已追加`);
+            }
+            if (opts.remove) {
+                const idx = arr.indexOf(opts.remove);
+                if (idx === -1) {
+                    console.log(`  ⚠ 未找到该值`);
+                    return;
+                }
+                arr.splice(idx, 1);
+                console.log(`  ✓ 已移除`);
+            }
+            newValue = arr;
+        }
+        else {
+            // Scalar
+            if (value === undefined) {
+                console.error("  请提供值。用法: openclaw libp2p-mesh config set <key> <value>");
+                process.exit(1);
+            }
+            // Auto-detect boolean and number
+            if (value === "true")
+                newValue = true;
+            else if (value === "false")
+                newValue = false;
+            else if (/^-?\d+(\.\d+)?$/.test(value))
+                newValue = Number(value);
+            else
+                newValue = value;
+        }
+        // Write
+        const updates = { ...pluginConfig, [key]: newValue };
+        writeFullConfig(configPath, updates);
+        // Feedback
+        if (!opts.add && !opts.remove) {
+            console.log(`  ✓ ${key}: ${JSON.stringify(oldValue)} → ${JSON.stringify(newValue)}`);
+        }
+    });
+    // ---- config unset ----
+    configCmd
+        .command("unset <key>")
+        .description("删除 key，恢复默认值")
+        .action((key) => {
+        const configPath = resolveConfigPath();
+        const { pluginConfig } = readFullConfig(configPath);
+        const newConfig = { ...pluginConfig };
+        delete newConfig[key];
+        writeFullConfig(configPath, newConfig);
+        console.log(`  ✓ ${key} 已恢复为默认值`);
+    });
+}

package/dist/src/config-io.d.ts

@@ -0,0 +1,9 @@
+export declare const MULTIADDR_PATTERN: RegExp;
+export declare function getDefaultConfig(): Record<string, unknown>;
+export declare function resolveConfigPath(): string;
+export declare function readFullConfig(configPath: string): {
+    config: Record<string, unknown>;
+    pluginConfig: Record<string, unknown>;
+};
+export declare function writeFullConfig(configPath: string, pluginConfigUpdates: Record<string, unknown>): void;
+export declare function getNonDefaultConfig(pluginConfig: Record<string, unknown>): Record<string, unknown>;

package/dist/src/config-io.js

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+export const MULTIADDR_PATTERN = /^(\/ip[46]\/(?:[\d.]+|[0-9a-fA-F:]+)|\/dns(?:[46])?\/[a-zA-Z0-9][a-zA-Z0-9.-]*)\/(?:tcp|udp|ws|wss)\/\d+(?:\/p2p\/[12][a-zA-Z2-7]{48,})?$/;
+export function getDefaultConfig() {
+    return {
+        listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
+        enableWebSocket: false,
+        discovery: "mdns",
+        meshTopic: "openclaw-mesh",
+        enablePubsub: true,
+        enableAgentSync: true,
+        enableDHT: true,
+        enableNATTraversal: true,
+        enableIdentify: true,
+        enableAutoNAT: true,
+        enableUPnP: true,
+        enableCircuitRelay: true,
+        enableCircuitRelayServer: false,
+        enableDCUtR: true,
+        discoverRelays: 0,
+        deliveryAckTimeoutMs: 15000,
+    };
+}
+export function resolveConfigPath() {
+    if (process.env.OPENCLAW_CONFIG_PATH) {
+        const resolved = process.env.OPENCLAW_CONFIG_PATH.replace(/^~(?=$|\/|\\)/, os.homedir());
+        return path.resolve(resolved);
+    }
+    const stateDir = process.env.OPENCLAW_STATE_DIR
+        ? process.env.OPENCLAW_STATE_DIR.replace(/^~(?=$|\/|\\)/, os.homedir())
+        : path.join(os.homedir(), ".openclaw");
+    return path.join(stateDir, "openclaw.json");
+}
+export function readFullConfig(configPath) {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { config: {}, pluginConfig: {} };
+        }
+        throw new Error(`无法解析 ${configPath}: ${err.message}\n请手动修复 JSON 格式后重试。`);
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`${configPath} 内容不是合法的 JSON 对象。`);
+    }
+    const plugins = raw.plugins;
+    const entries = plugins && typeof plugins === "object" && !Array.isArray(plugins)
+        ? plugins.entries
+        : undefined;
+    const entry = entries && typeof entries === "object" && !Array.isArray(entries)
+        ? entries["libp2p-mesh"]
+        : undefined;
+    const pluginConfig = entry && typeof entry === "object" && !Array.isArray(entry)
+        ? entry.config ?? {}
+        : {};
+    return { config: raw, pluginConfig };
+}
+export function writeFullConfig(configPath, pluginConfigUpdates) {
+    // Ensure directory exists
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    // Read existing or start fresh
+    let base = {};
+    try {
+        base = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw new Error(`无法读取 ${configPath}: ${err.message}`);
+        }
+    }
+    // Create backup
+    try {
+        if (fs.existsSync(configPath)) {
+            fs.copyFileSync(configPath, configPath + ".bak");
+        }
+    }
+    catch {
+        console.warn("备份 openclaw.json 失败，继续写入。");
+    }
+    // Build output object with deep merge
+    const output = structuredClone(typeof base === "object" && !Array.isArray(base) ? base : {});
+    // Ensure plugins.entries["libp2p-mesh"] exists
+    if (!output.plugins || typeof output.plugins !== "object" || Array.isArray(output.plugins)) {
+        output.plugins = {};
+    }
+    const plugins = output.plugins;
+    if (!plugins.entries || typeof plugins.entries !== "object" || Array.isArray(plugins.entries)) {
+        plugins.entries = {};
+    }
+    const entries = plugins.entries;
+    if (!entries["libp2p-mesh"] ||
+        typeof entries["libp2p-mesh"] !== "object" ||
+        Array.isArray(entries["libp2p-mesh"])) {
+        entries["libp2p-mesh"] = {};
+    }
+    const meshEntry = entries["libp2p-mesh"];
+    meshEntry.enabled = true;
+    // Merge plugin config shallowly (key-level)
+    if (!meshEntry.config || typeof meshEntry.config !== "object" || Array.isArray(meshEntry.config)) {
+        meshEntry.config = {};
+    }
+    const existing = meshEntry.config;
+    meshEntry.config = { ...existing, ...pluginConfigUpdates };
+    // Ensure channels["libp2p-mesh"].enabled exists
+    if (!output.channels ||
+        typeof output.channels !== "object" ||
+        Array.isArray(output.channels)) {
+        output.channels = {};
+    }
+    const channels = output.channels;
+    if (!channels["libp2p-mesh"] ||
+        typeof channels["libp2p-mesh"] !== "object" ||
+        Array.isArray(channels["libp2p-mesh"])) {
+        channels["libp2p-mesh"] = {};
+    }
+    const meshChannel = channels["libp2p-mesh"];
+    meshChannel.enabled = true;
+    // Write atomically (write to temp, then rename)
+    const tmpPath = configPath + ".tmp";
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(output, null, 2) + "\n", "utf-8");
+        fs.renameSync(tmpPath, configPath);
+    }
+    catch (err) {
+        // Rollback from backup
+        try {
+            if (fs.existsSync(configPath + ".bak")) {
+                fs.copyFileSync(configPath + ".bak", configPath);
+            }
+        }
+        catch {
+            // rollback failure — leave existing state
+        }
+        // Clean up temp
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            // ok
+        }
+        throw new Error(`写入 ${configPath} 失败：${err.message}。配置未更改。`);
+    }
+}
+export function getNonDefaultConfig(pluginConfig) {
+    const defaults = getDefaultConfig();
+    const result = {};
+    for (const key of Object.keys(pluginConfig)) {
+        const value = pluginConfig[key];
+        if (value === undefined)
+            continue;
+        if (!(key in defaults)) {
+            // Unknown key — include (could be a new key added in later version)
+            result[key] = value;
+            continue;
+        }
+        const def = defaults[key];
+        if (Array.isArray(value) && Array.isArray(def)) {
+            if (value.length === 0 && def.length > 0)
+                continue;
+            if (value.length !== def.length || value.some((v, i) => v !== def[i])) {
+                result[key] = value;
+            }
+        }
+        else if (value !== def) {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/src/inbound-delivery.d.ts

@@ -1,11 +1,13 @@
+import type { ChannelOutboundAdapter, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { InboundDeliveryAdapter } from "./types.js";
 export type DeliveryLogger = {
     info?: (message: string) => void;
     debug?: (message: string) => void;
     warn?: (message: string) => void;
 };
-export declare function createOpenClawCliInboundDelivery(options?: {
-    command?: string;
-    timeoutMs?: number;
+export type LoadChannelOutboundAdapter = (channel: string) => Promise<ChannelOutboundAdapter | undefined>;
+export declare function createOpenClawRuntimeInboundDelivery(options: {
+    config: OpenClawConfig;
+    loadAdapter: LoadChannelOutboundAdapter;
     logger?: DeliveryLogger;
 }): InboundDeliveryAdapter;