@clawling/clawchat-plugin-openclaw 2026.5.13-dev.1 → 2026.5.13-dev.3

package/dist/index.js

@@ -16,5 +16,12 @@ export default defineChannelPluginEntry({
         registerOpenclawClawlingCommands(api);
         registerClawChatPromptInjection(api);
         registerOpenclawClawlingTools(api);
+        // NOTE: the legacy-rename config migration is intentionally NOT registered
+        // here. The host's setup-migration runner only loads a plugin's SETUP source
+        // (`openclaw.setupEntry`/`runtimeSetupEntry` → setup-entry.ts) and calls its
+        // `register(api)` in "setup-only" mode; registrations made in `registerFull`
+        // (full/tool-discovery modes) are never collected for migrations, and this
+        // gated full-load path doesn't run for the rename scenario anyway. The
+        // migration is wired into setup-entry.ts instead.
     },
 });

package/dist/setup-entry.js

@@ -1,3 +1,33 @@
 import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { CHANNEL_ID } from "./src/config.js";
 import { openclawClawlingSetupPlugin } from "./src/channel.setup.js";
-export default defineSetupPluginEntry(openclawClawlingSetupPlugin);
+import { migrateLegacyClawChatChannelConfig } from "./src/config-compat.js";
+/**
+ * Host setup-source `register` hook.
+ *
+ * The OpenClaw setup-migration runner (`setup-registry`) loads this module as
+ * the plugin's setup source (resolved from `package.json` `openclaw.setupEntry`
+ * / `runtimeSetupEntry`), unwraps the default export, and — when that export is
+ * an object exposing a `register` function whose `id` matches the plugin id —
+ * calls `register(api)` in setup-only mode. This is the ONLY ungated path that
+ * collects config migrations for the plugin-rename scenario.
+ *
+ * Mirrors the host's own built-in pattern (e.g. amazon-bedrock setup-api.js:
+ * `api.registerConfigMigration((config) => migrateAmazonBedrockLegacyConfig(config))`).
+ */
+export function register(api) {
+    api.registerConfigMigration?.((config) => migrateLegacyClawChatChannelConfig(config));
+}
+/**
+ * Default export consumed by BOTH host loaders of this setup source:
+ *  - the channel-setup loader unwraps `default` and reads `.plugin`
+ *    (`defineSetupPluginEntry` yields `{ plugin }`);
+ *  - the setup-migration runner unwraps `default` and reads `.register`,
+ *    rejecting it unless `.id` matches the plugin id.
+ * So the default export must carry `plugin`, `id`, and `register` together.
+ */
+export default {
+    ...defineSetupPluginEntry(openclawClawlingSetupPlugin),
+    id: CHANNEL_ID,
+    register,
+};

package/dist/src/config-compat.js

@@ -0,0 +1,120 @@
+import { CHANNEL_ID } from "./config.js";
+/**
+ * Compatibility migration for the plugin rename (commit 260044f): the plugin
+ * `id` and channel key changed from the OLD `openclaw-clawchat` to the NEW
+ * `clawchat-plugin-openclaw` (= {@link CHANNEL_ID}).
+ *
+ * Users upgrading from the old version have all their state — channel block
+ * (token/userId/ownerUserId/refreshToken/…), `plugins.allow`,
+ * `plugins.entries`, and `tools.allow`/`tools.alsoAllow` — keyed under the old
+ * id. The new code only reads the new id, so the channel silently fails to
+ * load. This migration moves the old-keyed state onto the new id.
+ *
+ * The function is PURE: it clones the input via `structuredClone` and never
+ * mutates its argument. It is IDEMPOTENT: a config with no old id anywhere
+ * returns an equivalent config with `changes: []`.
+ */
+export const LEGACY_CHANNEL_ID = "openclaw-clawchat";
+export const TARGET_CHANNEL_ID = CHANNEL_ID;
+const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+function isBlockedObjectKey(key) {
+    return BLOCKED_OBJECT_KEYS.has(key);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyRecord(value) {
+    return isRecord(value) && Object.keys(value).length > 0;
+}
+/**
+ * Copy keys from `source` into `target` only when they are absent/undefined in
+ * `target` (target is more current — never overwrite an existing value).
+ * Recurses into nested records. Skips prototype-pollution keys.
+ */
+function mergeMissing(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        if (value === undefined || isBlockedObjectKey(key))
+            continue;
+        const existing = target[key];
+        if (existing === undefined) {
+            target[key] = value;
+            continue;
+        }
+        if (isRecord(existing) && isRecord(value))
+            mergeMissing(existing, value);
+    }
+}
+/** Replace `from` → `to` in a string array, preserving order and deduping. */
+function replaceAndDedup(list, from, to) {
+    const out = [];
+    for (const raw of list) {
+        const value = raw === from ? to : raw;
+        if (!out.includes(value))
+            out.push(value);
+    }
+    return out;
+}
+export function migrateLegacyClawChatChannelConfig(config) {
+    const changes = [];
+    if (!isRecord(config))
+        return { config, changes };
+    const next = structuredClone(config);
+    // 1. channels — move/merge the old channel block onto the new id.
+    const channels = next.channels;
+    if (isRecord(channels)) {
+        const oldChannel = channels[LEGACY_CHANNEL_ID];
+        if (isNonEmptyRecord(oldChannel)) {
+            const newChannel = channels[TARGET_CHANNEL_ID];
+            if (!isNonEmptyRecord(newChannel)) {
+                channels[TARGET_CHANNEL_ID] = oldChannel;
+                changes.push(`Moved channel "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`);
+            }
+            else {
+                mergeMissing(newChannel, oldChannel);
+                changes.push(`Merged channel "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}" (filled missing fields; kept existing values).`);
+            }
+            delete channels[LEGACY_CHANNEL_ID];
+        }
+    }
+    // plugins.* live under a single `plugins` record.
+    const plugins = next.plugins;
+    if (isRecord(plugins)) {
+        // 2. plugins.allow — replace old id with new id (append if missing), dedup.
+        const allow = plugins.allow;
+        if (Array.isArray(allow) && allow.includes(LEGACY_CHANNEL_ID)) {
+            const replaced = replaceAndDedup(allow.filter((v) => typeof v === "string"), LEGACY_CHANNEL_ID, TARGET_CHANNEL_ID);
+            plugins.allow = replaced;
+            changes.push(`Updated plugins.allow: "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`);
+        }
+        // 3. plugins.entries — merge-missing the old entry into the new one.
+        const entries = plugins.entries;
+        if (isRecord(entries)) {
+            const oldEntry = entries[LEGACY_CHANNEL_ID];
+            if (oldEntry !== undefined) {
+                if (isRecord(oldEntry)) {
+                    const newEntry = entries[TARGET_CHANNEL_ID];
+                    if (!isRecord(newEntry)) {
+                        entries[TARGET_CHANNEL_ID] = oldEntry;
+                    }
+                    else {
+                        mergeMissing(newEntry, oldEntry);
+                    }
+                }
+                delete entries[LEGACY_CHANNEL_ID];
+                changes.push(`Merged plugins.entries["${LEGACY_CHANNEL_ID}"] → plugins.entries["${TARGET_CHANNEL_ID}"].`);
+            }
+        }
+    }
+    // 4. tools.allow + tools.alsoAllow — replace old id with new id, dedup.
+    const tools = next.tools;
+    if (isRecord(tools)) {
+        for (const key of ["allow", "alsoAllow"]) {
+            const list = tools[key];
+            if (Array.isArray(list) && list.includes(LEGACY_CHANNEL_ID)) {
+                tools[key] = replaceAndDedup(list.filter((v) => typeof v === "string"), LEGACY_CHANNEL_ID, TARGET_CHANNEL_ID);
+                changes.push(`Updated tools.${key}: "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`);
+            }
+        }
+    }
+    return { config: next, changes };
+}

package/dist/src/runtime.js

@@ -1610,7 +1610,13 @@ export async function startOpenclawClawlingGateway(params) {
                     : {}),
             },
             ...(memoryRoot ? { extra: { memoryRoot } } : {}),
-            ...(turn.peer.kind === "group"
+            // Deliver the rendered ClawChat per-turn prompt (owner agent_behavior,
+            // metadata, peer/sender profile) to the host for ALL chat types. The host
+            // appends `GroupSystemPrompt` to the system prompt regardless of chat
+            // kind. Direct chats previously relied only on the `before_prompt_build`
+            // staging hook, which is not applied by the host for DM sessions, so the
+            // owner-configured behavior never reached the LLM in 1:1 chats.
+            ...(turnPrompt
                 ? { supplemental: { groupSystemPrompt: turnPrompt } }
                 : {}),
         });

package/index.ts

@@ -20,5 +20,12 @@ export default defineChannelPluginEntry({
     registerOpenclawClawlingCommands(api);
     registerClawChatPromptInjection(api as unknown as ClawChatPromptInjectionApi);
     registerOpenclawClawlingTools(api);
+    // NOTE: the legacy-rename config migration is intentionally NOT registered
+    // here. The host's setup-migration runner only loads a plugin's SETUP source
+    // (`openclaw.setupEntry`/`runtimeSetupEntry` → setup-entry.ts) and calls its
+    // `register(api)` in "setup-only" mode; registrations made in `registerFull`
+    // (full/tool-discovery modes) are never collected for migrations, and this
+    // gated full-load path doesn't run for the rename scenario anyway. The
+    // migration is wired into setup-entry.ts instead.
   },
 });

package/openclaw.plugin.json

@@ -1,6 +1,13 @@
 {
   "id": "clawchat-plugin-openclaw",
   "kind": "channel",
+  "legacyPluginIds": ["openclaw-clawchat"],
+  "configContracts": {
+    "compatibilityMigrationPaths": [
+      "channels.openclaw-clawchat",
+      "plugins.entries.openclaw-clawchat"
+    ]
+  },
   "channels": ["clawchat-plugin-openclaw"],
   "skills": ["./skills"],
   "activation": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.5.13-dev.1",
+  "version": "2026.5.13-dev.3",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "files": [

package/setup-entry.ts

@@ -1,4 +1,54 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { CHANNEL_ID } from "./src/config.ts";
 import { openclawClawlingSetupPlugin } from "./src/channel.setup.ts";
+import { migrateLegacyClawChatChannelConfig } from "./src/config-compat.ts";
 
-export default defineSetupPluginEntry(openclawClawlingSetupPlugin);
+/**
+ * Minimal shape of the host setup-registration api we touch. The host calls
+ * `register(api)` on the SETUP source (this module) in `registrationMode:
+ * "setup-only"`; `registerConfigMigration` is the hook that collects
+ * compatibility migrations (run by `openclaw doctor` / setup). It is optional
+ * here so a host that doesn't expose it can't throw.
+ */
+interface SetupRegisterApi {
+  registerConfigMigration?: (
+    migration: (config: OpenClawConfig) => {
+      config: OpenClawConfig;
+      changes: string[];
+    },
+  ) => void;
+}
+
+/**
+ * Host setup-source `register` hook.
+ *
+ * The OpenClaw setup-migration runner (`setup-registry`) loads this module as
+ * the plugin's setup source (resolved from `package.json` `openclaw.setupEntry`
+ * / `runtimeSetupEntry`), unwraps the default export, and — when that export is
+ * an object exposing a `register` function whose `id` matches the plugin id —
+ * calls `register(api)` in setup-only mode. This is the ONLY ungated path that
+ * collects config migrations for the plugin-rename scenario.
+ *
+ * Mirrors the host's own built-in pattern (e.g. amazon-bedrock setup-api.js:
+ * `api.registerConfigMigration((config) => migrateAmazonBedrockLegacyConfig(config))`).
+ */
+export function register(api: SetupRegisterApi): void {
+  api.registerConfigMigration?.((config) =>
+    migrateLegacyClawChatChannelConfig(config),
+  );
+}
+
+/**
+ * Default export consumed by BOTH host loaders of this setup source:
+ *  - the channel-setup loader unwraps `default` and reads `.plugin`
+ *    (`defineSetupPluginEntry` yields `{ plugin }`);
+ *  - the setup-migration runner unwraps `default` and reads `.register`,
+ *    rejecting it unless `.id` matches the plugin id.
+ * So the default export must carry `plugin`, `id`, and `register` together.
+ */
+export default {
+  ...defineSetupPluginEntry(openclawClawlingSetupPlugin),
+  id: CHANNEL_ID,
+  register,
+};

package/src/config-compat.ts

@@ -0,0 +1,154 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { CHANNEL_ID } from "./config.ts";
+
+/**
+ * Compatibility migration for the plugin rename (commit 260044f): the plugin
+ * `id` and channel key changed from the OLD `openclaw-clawchat` to the NEW
+ * `clawchat-plugin-openclaw` (= {@link CHANNEL_ID}).
+ *
+ * Users upgrading from the old version have all their state — channel block
+ * (token/userId/ownerUserId/refreshToken/…), `plugins.allow`,
+ * `plugins.entries`, and `tools.allow`/`tools.alsoAllow` — keyed under the old
+ * id. The new code only reads the new id, so the channel silently fails to
+ * load. This migration moves the old-keyed state onto the new id.
+ *
+ * The function is PURE: it clones the input via `structuredClone` and never
+ * mutates its argument. It is IDEMPOTENT: a config with no old id anywhere
+ * returns an equivalent config with `changes: []`.
+ */
+
+export const LEGACY_CHANNEL_ID = "openclaw-clawchat" as const;
+export const TARGET_CHANNEL_ID = CHANNEL_ID;
+
+const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+
+function isBlockedObjectKey(key: string): boolean {
+  return BLOCKED_OBJECT_KEYS.has(key);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNonEmptyRecord(value: unknown): value is Record<string, unknown> {
+  return isRecord(value) && Object.keys(value).length > 0;
+}
+
+/**
+ * Copy keys from `source` into `target` only when they are absent/undefined in
+ * `target` (target is more current — never overwrite an existing value).
+ * Recurses into nested records. Skips prototype-pollution keys.
+ */
+function mergeMissing(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+): void {
+  for (const [key, value] of Object.entries(source)) {
+    if (value === undefined || isBlockedObjectKey(key)) continue;
+    const existing = target[key];
+    if (existing === undefined) {
+      target[key] = value;
+      continue;
+    }
+    if (isRecord(existing) && isRecord(value)) mergeMissing(existing, value);
+  }
+}
+
+/** Replace `from` → `to` in a string array, preserving order and deduping. */
+function replaceAndDedup(list: string[], from: string, to: string): string[] {
+  const out: string[] = [];
+  for (const raw of list) {
+    const value = raw === from ? to : raw;
+    if (!out.includes(value)) out.push(value);
+  }
+  return out;
+}
+
+export function migrateLegacyClawChatChannelConfig(config: OpenClawConfig): {
+  config: OpenClawConfig;
+  changes: string[];
+} {
+  const changes: string[] = [];
+  if (!isRecord(config)) return { config, changes };
+
+  const next = structuredClone(config) as Record<string, unknown>;
+
+  // 1. channels — move/merge the old channel block onto the new id.
+  const channels = next.channels;
+  if (isRecord(channels)) {
+    const oldChannel = channels[LEGACY_CHANNEL_ID];
+    if (isNonEmptyRecord(oldChannel)) {
+      const newChannel = channels[TARGET_CHANNEL_ID];
+      if (!isNonEmptyRecord(newChannel)) {
+        channels[TARGET_CHANNEL_ID] = oldChannel;
+        changes.push(
+          `Moved channel "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`,
+        );
+      } else {
+        mergeMissing(newChannel, oldChannel);
+        changes.push(
+          `Merged channel "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}" (filled missing fields; kept existing values).`,
+        );
+      }
+      delete channels[LEGACY_CHANNEL_ID];
+    }
+  }
+
+  // plugins.* live under a single `plugins` record.
+  const plugins = next.plugins;
+  if (isRecord(plugins)) {
+    // 2. plugins.allow — replace old id with new id (append if missing), dedup.
+    const allow = plugins.allow;
+    if (Array.isArray(allow) && allow.includes(LEGACY_CHANNEL_ID)) {
+      const replaced = replaceAndDedup(
+        allow.filter((v): v is string => typeof v === "string"),
+        LEGACY_CHANNEL_ID,
+        TARGET_CHANNEL_ID,
+      );
+      plugins.allow = replaced;
+      changes.push(
+        `Updated plugins.allow: "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`,
+      );
+    }
+
+    // 3. plugins.entries — merge-missing the old entry into the new one.
+    const entries = plugins.entries;
+    if (isRecord(entries)) {
+      const oldEntry = entries[LEGACY_CHANNEL_ID];
+      if (oldEntry !== undefined) {
+        if (isRecord(oldEntry)) {
+          const newEntry = entries[TARGET_CHANNEL_ID];
+          if (!isRecord(newEntry)) {
+            entries[TARGET_CHANNEL_ID] = oldEntry;
+          } else {
+            mergeMissing(newEntry, oldEntry);
+          }
+        }
+        delete entries[LEGACY_CHANNEL_ID];
+        changes.push(
+          `Merged plugins.entries["${LEGACY_CHANNEL_ID}"] → plugins.entries["${TARGET_CHANNEL_ID}"].`,
+        );
+      }
+    }
+  }
+
+  // 4. tools.allow + tools.alsoAllow — replace old id with new id, dedup.
+  const tools = next.tools;
+  if (isRecord(tools)) {
+    for (const key of ["allow", "alsoAllow"] as const) {
+      const list = tools[key];
+      if (Array.isArray(list) && list.includes(LEGACY_CHANNEL_ID)) {
+        tools[key] = replaceAndDedup(
+          list.filter((v): v is string => typeof v === "string"),
+          LEGACY_CHANNEL_ID,
+          TARGET_CHANNEL_ID,
+        );
+        changes.push(
+          `Updated tools.${key}: "${LEGACY_CHANNEL_ID}" → "${TARGET_CHANNEL_ID}".`,
+        );
+      }
+    }
+  }
+
+  return { config: next as OpenClawConfig, changes };
+}

package/src/runtime.ts

@@ -1927,7 +1927,13 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
           : {}),
       },
       ...(memoryRoot ? { extra: { memoryRoot } } : {}),
-      ...(turn.peer.kind === "group"
+      // Deliver the rendered ClawChat per-turn prompt (owner agent_behavior,
+      // metadata, peer/sender profile) to the host for ALL chat types. The host
+      // appends `GroupSystemPrompt` to the system prompt regardless of chat
+      // kind. Direct chats previously relied only on the `before_prompt_build`
+      // staging hook, which is not applied by the host for DM sessions, so the
+      // owner-configured behavior never reached the LLM in 1:1 chats.
+      ...(turnPrompt
         ? { supplemental: { groupSystemPrompt: turnPrompt } }
         : {}),
     }) as MutableOpenClawReplyContext;