openclaw-channel-dmwork 0.5.13 → 0.5.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.5.13",
+  "version": "0.5.15",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",

package/src/api-fetch.test.ts

@@ -874,3 +874,67 @@ describe("fetchUserInfo", () => {
     expect(result).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+// sendMessage — mentionAll serialization
+// ---------------------------------------------------------------------------
+describe("sendMessage — mentionAll serialization", () => {
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it("mention.all 应序列化为数字 1 而非布尔 true", async () => {
+    let sentBody: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, init?: RequestInit) => {
+      sentBody = JSON.parse(init?.body as string);
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    const { sendMessage } = await import("./api-fetch.js");
+    await sendMessage({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+      channelId: "group1",
+      channelType: ChannelType.Group,
+      content: "hello @all",
+      mentionAll: true,
+    });
+
+    expect(sentBody).not.toBeNull();
+    const mention = sentBody.payload.mention;
+    expect(mention.all).toBe(1);
+    expect(mention.all).not.toBe(true);
+    expect(typeof mention.all).toBe("number");
+  });
+
+  it("未设置 mentionAll 时不应包含 mention.all 字段", async () => {
+    let sentBody: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, init?: RequestInit) => {
+      sentBody = JSON.parse(init?.body as string);
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    const { sendMessage } = await import("./api-fetch.js");
+    await sendMessage({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+      channelId: "group1",
+      channelType: ChannelType.Group,
+      content: "hello",
+    });
+
+    expect(sentBody.payload.mention).toBeUndefined();
+  });
+});

package/src/api-fetch.ts

@@ -218,7 +218,7 @@ export async function sendMessage(params: {
       mention.entities = params.mentionEntities;
     }
     if (params.mentionAll) {
-      mention.all = true;
+      mention.all = 1;
     }
     payload.mention = mention;
   }

package/src/channel.test.ts

@@ -127,3 +127,260 @@ describe("dmworkPlugin structure", () => {
     expect(dmworkPlugin.capabilities?.chatTypes).toContain("group");
   });
 });
+
+// ─── Group → Account mapping tests ──────────────────────────────────────────
+
+describe("resolveAccountForGroup — prefetch registration", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("should register groups during startup prefetch", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+
+    // Simulate prefetch registration
+    registerGroupToAccount("group_abc", "acct_1");
+
+    // resolveAccountForGroup should now return the registered account
+    expect(resolveAccountForGroup("group_abc")).toBe("acct_1");
+  });
+});
+
+// ─── resolveOutboundAccountId tests ──────────────────────────────────────────
+
+describe("resolveOutboundAccountId", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("should strip @uid suffix from group target and resolve account", async () => {
+    const { registerGroupToAccount, resolveOutboundAccountId } = await import("./channel.js");
+
+    registerGroupToAccount("abc", "acct_A");
+
+    // "group:abc@uid1,uid2" → should strip @uid1,uid2, resolve group "abc"
+    const result = resolveOutboundAccountId("group:abc@uid1,uid2", "fallback");
+    expect(result).toBe("acct_A");
+  });
+
+  it("should resolve plain group target without @suffix", async () => {
+    const { registerGroupToAccount, resolveOutboundAccountId } = await import("./channel.js");
+
+    registerGroupToAccount("abc", "acct_B");
+
+    const result = resolveOutboundAccountId("group:abc", "fallback");
+    expect(result).toBe("acct_B");
+  });
+
+  it("should return fallback for DM targets (no correction)", async () => {
+    const { resolveOutboundAccountId } = await import("./channel.js");
+
+    // DM target — resolveOutboundAccountId should not correct, return fallback
+    const result = resolveOutboundAccountId("user:some_uid", "fallback_acct");
+    expect(result).toBe("fallback_acct");
+  });
+});
+
+describe("resolveOutboundAccountId — explicit accountId should not be overridden", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("should NOT override explicit non-default accountId even when group is registered to another account", async () => {
+    const { registerGroupToAccount, resolveOutboundAccountId } = await import("./channel.js");
+
+    // group registered to thomas_fu_bot
+    registerGroupToAccount("some_group", "thomas_fu_bot");
+
+    // User explicitly passes allen-imtest — resolveOutboundAccountId would return thomas_fu_bot,
+    // but the caller (sendText/sendMedia) should not call resolveOutboundAccountId when accountId != default.
+    // We test that resolveOutboundAccountId itself still resolves to the registered account...
+    const resolved = resolveOutboundAccountId("group:some_group", "allen-imtest");
+    expect(resolved).toBe("thomas_fu_bot"); // resolveOutboundAccountId always resolves
+
+    // ...but the sendText/sendMedia logic should gate on rawAccountId === DEFAULT_ACCOUNT_ID.
+    // Simulate the gating logic:
+    const rawAccountId: string = "allen-imtest"; // explicit, non-default
+    const DEFAULT_ACCOUNT_ID = "default";
+    const accountId = (rawAccountId === DEFAULT_ACCOUNT_ID)
+      ? resolveOutboundAccountId("group:some_group", rawAccountId)
+      : rawAccountId;
+    expect(accountId).toBe("allen-imtest"); // NOT corrected
+  });
+
+  it("should correct when accountId is default", async () => {
+    const { registerGroupToAccount, resolveOutboundAccountId } = await import("./channel.js");
+
+    registerGroupToAccount("some_group", "thomas_fu_bot");
+
+    const DEFAULT_ACCOUNT_ID = "default";
+    const rawAccountId = DEFAULT_ACCOUNT_ID;
+    const accountId = (rawAccountId === DEFAULT_ACCOUNT_ID)
+      ? resolveOutboundAccountId("group:some_group", rawAccountId)
+      : rawAccountId;
+    expect(accountId).toBe("thomas_fu_bot"); // corrected
+  });
+});
+
+describe("outbound accountId correction pattern", () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it("should use resolveAccountForGroup for group targets", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+    const { parseTarget } = await import("./actions.js");
+
+    registerGroupToAccount("group_xyz", "correct_acct");
+
+    const target = "group:group_xyz";
+    const { channelId, channelType } = parseTarget(target);
+
+    // Simulate the correction logic
+    let accountId = "wrong_acct";
+    if (channelType === 2) { // ChannelType.Group
+      const correct = resolveAccountForGroup(channelId);
+      if (correct) accountId = correct;
+    }
+
+    expect(accountId).toBe("correct_acct");
+  });
+});
+
+// ─── @all / @所有人 hasAtAll regex tests ──────────────────────────────────────
+
+describe("hasAtAll regex — @所有人 support", () => {
+  const hasAtAllRegex = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i;
+
+  it("should match @all", () => {
+    expect(hasAtAllRegex.test("hello @all please check")).toBe(true);
+  });
+
+  it("should match @All (case-insensitive)", () => {
+    expect(hasAtAllRegex.test("hello @All please")).toBe(true);
+  });
+
+  it("should match @所有人", () => {
+    expect(hasAtAllRegex.test("大家好 @所有人 请注意")).toBe(true);
+  });
+
+  it("should match @所有人 at start of string", () => {
+    expect(hasAtAllRegex.test("@所有人 请注意")).toBe(true);
+  });
+
+  it("should match @all at start of string", () => {
+    expect(hasAtAllRegex.test("@all check this")).toBe(true);
+  });
+
+  it("should match @所有人 at end of string", () => {
+    expect(hasAtAllRegex.test("通知 @所有人")).toBe(true);
+  });
+
+  it("should NOT match @Alice (not all)", () => {
+    expect(hasAtAllRegex.test("hello @Alice")).toBe(false);
+  });
+
+  it("should NOT match email with @all in domain", () => {
+    expect(hasAtAllRegex.test("email user@all.com")).toBe(false);
+  });
+});
+
+// ─── sendText v2 structured mention handling (unit logic) ─────────────────────
+
+describe("sendText v2 mention processing logic", () => {
+  it("should convert @[uid:name] to @name + entities", async () => {
+    const { parseStructuredMentions, convertStructuredMentions, buildEntitiesFromFallback } = await import("./mention-utils.js");
+
+    const content = "请 @[abc123:张三] 确认";
+    const uidToNameMap = new Map([["abc123", "张三"]]);
+    const memberMap = new Map([["张三", "abc123"]]);
+    const validUids = new Set(uidToNameMap.keys());
+
+    // v2 path
+    const structuredMentions = parseStructuredMentions(content);
+    expect(structuredMentions).toHaveLength(1);
+
+    const converted = convertStructuredMentions(content, structuredMentions, validUids);
+    expect(converted.content).toBe("请 @张三 确认");
+    expect(converted.entities).toHaveLength(1);
+    expect(converted.entities[0]).toEqual({ uid: "abc123", offset: 2, length: 3 });
+    expect(converted.uids).toEqual(["abc123"]);
+
+    // v1 fallback on converted content should find @张三 but not create duplicate
+    const fallback = buildEntitiesFromFallback(converted.content, memberMap);
+    expect(fallback.uids).toEqual(["abc123"]);
+  });
+
+  it("should handle mixed v2 + v1 mentions", async () => {
+    const { parseStructuredMentions, convertStructuredMentions, buildEntitiesFromFallback } = await import("./mention-utils.js");
+
+    const content = "@[abc:张三] 和 @李四";
+    const uidToNameMap = new Map([["abc", "张三"]]);
+    const memberMap = new Map([["张三", "abc"], ["李四", "def"]]);
+    const validUids = new Set(uidToNameMap.keys());
+
+    // v2 path
+    const structuredMentions = parseStructuredMentions(content);
+    expect(structuredMentions).toHaveLength(1);
+
+    const converted = convertStructuredMentions(content, structuredMentions, validUids);
+    expect(converted.content).toBe("@张三 和 @李四");
+
+    // v1 fallback resolves @李四
+    const fallback = buildEntitiesFromFallback(converted.content, memberMap);
+
+    // Merge with dedup
+    const mentionEntities = [...converted.entities];
+    const existingOffsets = new Set(mentionEntities.map(e => e.offset));
+    for (const entity of fallback.entities) {
+      if (!existingOffsets.has(entity.offset)) {
+        mentionEntities.push(entity);
+      }
+    }
+
+    expect(mentionEntities).toHaveLength(2);
+    expect(mentionEntities.map(e => e.uid).sort()).toEqual(["abc", "def"]);
+  });
+
+  it("pure v1 content should work unchanged", async () => {
+    const { parseStructuredMentions, buildEntitiesFromFallback } = await import("./mention-utils.js");
+
+    const content = "@张三 你好";
+    const structuredMentions = parseStructuredMentions(content);
+    expect(structuredMentions).toHaveLength(0);
+
+    const memberMap = new Map([["张三", "abc"]]);
+    const fallback = buildEntitiesFromFallback(content, memberMap);
+    expect(fallback.uids).toEqual(["abc"]);
+    expect(fallback.entities).toHaveLength(1);
+  });
+
+  it("@[uid:name] with @所有人 should only produce entity for name, not 所有人", async () => {
+    const { parseStructuredMentions, convertStructuredMentions, buildEntitiesFromFallback } = await import("./mention-utils.js");
+
+    const content = "@[abc:张三] @所有人";
+    const validUids = new Set(["abc"]);
+    const memberMap = new Map([["张三", "abc"]]);
+
+    const structured = parseStructuredMentions(content);
+    const converted = convertStructuredMentions(content, structured, validUids);
+    expect(converted.content).toBe("@张三 @所有人");
+
+    const fallback = buildEntitiesFromFallback(converted.content, memberMap);
+    // @所有人 should be skipped by buildEntitiesFromFallback
+    const allEntities = [...converted.entities];
+    const existingOffsets = new Set(allEntities.map(e => e.offset));
+    for (const entity of fallback.entities) {
+      if (!existingOffsets.has(entity.offset)) {
+        allEntities.push(entity);
+      }
+    }
+    // Only 张三 should have an entity
+    expect(allEntities).toHaveLength(1);
+    expect(allEntities[0].uid).toBe("abc");
+
+    // hasAtAll should be true
+    const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(converted.content);
+    expect(hasAtAll).toBe(true);
+  });
+});

package/src/channel.ts

@@ -15,7 +15,7 @@ import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContent
 import { WKSocket } from "./socket.js";
 import { handleInboundMessage, type DmworkStatusSink } from "./inbound.js";
 import { ChannelType, MessageType, type BotMessage, type MessagePayload } from "./types.js";
-import { buildEntitiesFromFallback } from "./mention-utils.js";
+import { buildEntitiesFromFallback, parseStructuredMentions, convertStructuredMentions } from "./mention-utils.js";
 import type { MentionEntity } from "./types.js";
 import { handleDmworkMessageAction, parseTarget } from "./actions.js";
 import { createDmworkManagementTools } from "./agent-tools.js";
@@ -125,16 +125,26 @@ function getOrCreateGroupCacheTimestamps(accountId: string): Map<string, number>
 }
 
 
-// --- Group → Account mapping: tracks which account each group was received from ---
+// --- Group → Account mapping: tracks which accounts are active in each group ---
 // Used by handleAction to resolve the correct account when framework passes wrong accountId
-const _groupToAccount = new Map<string, string>(); // groupNo → accountId
+// A group may have multiple bots (1:N), so we store a Set of accountIds per group.
+const _groupToAccount = new Map<string, Set<string>>(); // groupNo → Set<accountId>
 
 export function registerGroupToAccount(groupNo: string, accountId: string): void {
-  _groupToAccount.set(groupNo, accountId);
+  let accounts = _groupToAccount.get(groupNo);
+  if (!accounts) {
+    accounts = new Set<string>();
+    _groupToAccount.set(groupNo, accounts);
+  }
+  accounts.add(accountId);
 }
 
 export function resolveAccountForGroup(groupNo: string): string | undefined {
-  return _groupToAccount.get(groupNo);
+  const accounts = _groupToAccount.get(groupNo);
+  if (!accounts || accounts.size === 0) return undefined;
+  // Only resolve when exactly one bot owns the group; multi-bot → ambiguous
+  if (accounts.size === 1) return accounts.values().next().value;
+  return undefined;
 }
 
 // --- Cache cleanup: evict groups inactive for >4 hours ---
@@ -212,6 +222,22 @@ async function checkForUpdates(
   }
 }
 
+/** Resolve correct accountId for outbound context using group→account mapping */
+export function resolveOutboundAccountId(ctxTo: string, fallbackAccountId: string): string {
+  let targetForParse = ctxTo;
+  if (ctxTo.startsWith("group:")) {
+    const groupPart = ctxTo.slice(6);
+    const atIdx = groupPart.indexOf("@");
+    if (atIdx >= 0) targetForParse = "group:" + groupPart.slice(0, atIdx);
+  }
+  const { channelId, channelType } = parseTarget(targetForParse, undefined, getKnownGroupIds());
+  if (channelType === ChannelType.Group) {
+    const correctAccountId = resolveAccountForGroup(channelId);
+    if (correctAccountId) return correctAccountId;
+  }
+  return fallbackAccountId;
+}
+
 const meta = {
   id: "dmwork",
   label: "DMWork",
@@ -253,11 +279,14 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
     handleAction: async (ctx: any) => {
       // Resolve correct accountId: framework may pass wrong one when agent has multiple accounts.
       // Use currentChannelId to look up which account actually owns the group.
+      // When multiple bots share the same group, do NOT correct — the caller's accountId is authoritative.
       let accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
       const currentChannelId = ctx.toolContext?.currentChannelId;
       if (currentChannelId) {
         const rawGroupNo = currentChannelId.replace(/^dmwork:/, '');
         const correctAccountId = resolveAccountForGroup(rawGroupNo);
+        // Only correct when resolveAccountForGroup returns a definitive answer
+        // (exactly one bot owns the group); multi-bot → undefined → no correction
         if (correctAccountId && correctAccountId !== accountId) {
           ctx.log?.info?.(`dmwork: handleAction accountId corrected: ${accountId} → ${correctAccountId} (group=${rawGroupNo})`);
           accountId = correctAccountId;
@@ -323,9 +352,14 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
   outbound: {
     deliveryMode: "direct",
     sendText: async (ctx) => {
+      // Resolve correct accountId — framework may pass wrong one for multi-bot setups
+      const accountId = resolveOutboundAccountId(
+        ctx.to,
+        ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+      );
       const account = resolveDmworkAccount({
         cfg: ctx.cfg as OpenClawConfig,
-        accountId: ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+        accountId,
       });
       if (!account.config.botToken) {
         throw new Error("DMWork botToken is not configured");
@@ -352,37 +386,66 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
       const { channelId, channelType } = parseTarget(targetForParse, undefined, getKnownGroupIds());
 
       let mentionEntities: MentionEntity[] = [];
+      let finalContent = content;
 
       if (channelType === ChannelType.Group) {
-        // Resolve @name to uid via memberMap (fixes name-as-uid bug)
-        const accountMemberMap = getOrCreateMemberMap(
-          ctx.accountId ?? DEFAULT_ACCOUNT_ID,
-        );
-        const { entities, uids } = buildEntitiesFromFallback(content, accountMemberMap);
+        const accountMemberMap = getOrCreateMemberMap(accountId);
+        const uidToNameMap = getOrCreateUidToNameMap(accountId);
+
+        // v2 path: convert @[uid:name] → @name + entities
+        const structuredMentions = parseStructuredMentions(finalContent);
+        if (structuredMentions.length > 0) {
+          const validUids = new Set(uidToNameMap.keys());
+          const converted = convertStructuredMentions(finalContent, structuredMentions, validUids);
+          finalContent = converted.content;
+          mentionEntities = [...converted.entities];
+          for (const uid of converted.uids) {
+            if (!mentionUids.includes(uid)) {
+              mentionUids.push(uid);
+            }
+          }
+        }
+
+        // v1 fallback: resolve remaining @name via memberMap
+        const { entities, uids } = buildEntitiesFromFallback(finalContent, accountMemberMap);
+        const existingOffsets = new Set(mentionEntities.map(e => e.offset));
+        for (const entity of entities) {
+          if (!existingOffsets.has(entity.offset)) {
+            mentionEntities.push(entity);
+          }
+        }
         for (const uid of uids) {
           if (!mentionUids.includes(uid)) {
             mentionUids.push(uid);
           }
         }
-        mentionEntities = entities;
       }
 
+      // Detect @all/@所有人 in content
+      const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(finalContent);
+
       await sendMessage({
         apiUrl: account.config.apiUrl,
         botToken: account.config.botToken,
         channelId,
         channelType,
-        content,
+        content: finalContent,
         ...(mentionUids.length > 0 ? { mentionUids } : {}),
         ...(mentionEntities.length > 0 ? { mentionEntities } : {}),
+        mentionAll: hasAtAll || undefined,
       });
 
       return { channel: "dmwork", to: ctx.to, messageId: "" };
     },
     sendMedia: async (ctx) => {
+      // Resolve correct accountId — framework may pass wrong one for multi-bot setups
+      const accountId = resolveOutboundAccountId(
+        ctx.to,
+        ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+      );
       const account = resolveDmworkAccount({
         cfg: ctx.cfg as OpenClawConfig,
-        accountId: ctx.accountId ?? DEFAULT_ACCOUNT_ID,
+        accountId,
       });
       if (!account.config.botToken) {
         throw new Error("DMWork botToken is not configured");
@@ -603,6 +666,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           let mdCount = 0;
           let memberCount = 0;
           for (const g of groups) {
+            // Register group → account mapping for outbound accountId resolution
+            registerGroupToAccount(g.group_no, account.accountId);
+
             // Prefetch GROUP.md
             try {
               const md = await getGroupMd({ apiUrl: account.config.apiUrl, botToken: account.config.botToken!, groupNo: g.group_no, log });

package/src/inbound.ts

@@ -1580,6 +1580,9 @@ export async function handleInboundMessage(params: {
           }
         }
 
+        // Detect @all/@所有人 in final content
+        const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(finalContent);
+
         await sendMessage({
           apiUrl: account.config.apiUrl,
           botToken: account.config.botToken ?? "",
@@ -1588,6 +1591,7 @@ export async function handleInboundMessage(params: {
           content: finalContent,
           ...(replyMentionUids.length > 0 ? { mentionUids: replyMentionUids } : {}),
           ...(replyMentionEntities.length > 0 ? { mentionEntities: replyMentionEntities } : {}),
+          mentionAll: hasAtAll || undefined,
         });
 
         statusSink?.({ lastOutboundAt: Date.now(), lastError: null });

package/src/mention-utils.test.ts

@@ -10,6 +10,7 @@ import {
   extractMentionUids,
   convertContentForLLM,
   buildSenderPrefix,
+  tryLongestMemberMatch,
 } from "./mention-utils.js";
 import type { MentionPayload } from "./types.js";
 
@@ -558,3 +559,130 @@ describe("buildSenderPrefix with cross-space", () => {
     expect(buildSenderPrefix("s14_abc", map)).toBe("s14_abc");
   });
 });
+
+// ── Space-name @mention support ──────────────────────────────────────────────
+
+describe("buildEntitiesFromFallback — 空格昵称支持", () => {
+  it("应匹配含空格的昵称 @Anyang Su", () => {
+    const memberMap = new Map([
+      ["Anyang Su", "uid_anyang"],
+      ["Bob", "uid_bob"],
+    ]);
+    const { entities, uids } = buildEntitiesFromFallback(
+      "Hello @Anyang Su and @Bob",
+      memberMap,
+    );
+    expect(uids).toEqual(["uid_anyang", "uid_bob"]);
+    expect(entities).toHaveLength(2);
+    expect(entities[0]).toEqual({ uid: "uid_anyang", offset: 6, length: 10 });
+    expect(entities[1]).toEqual({ uid: "uid_bob", offset: 21, length: 4 });
+  });
+
+  it("应优先匹配最长名称", () => {
+    const memberMap = new Map([
+      ["Anyang", "uid_short"],
+      ["Anyang Su", "uid_full"],
+    ]);
+    const { entities, uids } = buildEntitiesFromFallback(
+      "@Anyang Su hello",
+      memberMap,
+    );
+    expect(uids).toEqual(["uid_full"]);
+    expect(entities[0]).toEqual({ uid: "uid_full", offset: 0, length: 10 });
+  });
+
+  it("不应跨词误匹配 @Anyang Superman", () => {
+    const memberMap = new Map([["Anyang Su", "uid_anyang"]]);
+    const { entities, uids } = buildEntitiesFromFallback(
+      "@Anyang Superman",
+      memberMap,
+    );
+    expect(uids).toEqual([]);
+    expect(entities).toEqual([]);
+  });
+
+  it("应处理多个空格昵称", () => {
+    const memberMap = new Map([
+      ["Anyang Su", "uid_anyang"],
+      ["Li Wei", "uid_li"],
+    ]);
+    const { entities, uids } = buildEntitiesFromFallback(
+      "@Anyang Su @Li Wei",
+      memberMap,
+    );
+    expect(uids).toEqual(["uid_anyang", "uid_li"]);
+    expect(entities).toHaveLength(2);
+    expect(entities[0]).toEqual({ uid: "uid_anyang", offset: 0, length: 10 });
+    expect(entities[1]).toEqual({ uid: "uid_li", offset: 11, length: 7 });
+  });
+
+  it("无空格名称时行为不变", () => {
+    const memberMap = new Map([["Bob", "uid_bob"]]);
+    const { entities, uids } = buildEntitiesFromFallback("@Bob hi", memberMap);
+    expect(uids).toEqual(["uid_bob"]);
+    expect(entities[0]).toEqual({ uid: "uid_bob", offset: 0, length: 4 });
+  });
+});
+
+describe("buildEntitiesFromFallback — @all 跳过", () => {
+  it("@all 不应生成 entity", () => {
+    const memberMap = new Map([["Bob", "uid_bob"]]);
+    const { entities, uids } = buildEntitiesFromFallback("@all @Bob", memberMap);
+    expect(uids).toEqual(["uid_bob"]);
+    expect(entities).toHaveLength(1);
+    expect(entities[0]).toEqual({ uid: "uid_bob", offset: 5, length: 4 });
+  });
+
+  it("@All (大小写) 也不应生成 entity", () => {
+    const memberMap = new Map([["Bob", "uid_bob"]]);
+    const { entities, uids } = buildEntitiesFromFallback("@All @Bob", memberMap);
+    expect(uids).toEqual(["uid_bob"]);
+    expect(entities).toHaveLength(1);
+  });
+
+  it("@ALL 全大写不应生成 entity", () => {
+    const memberMap = new Map<string, string>();
+    const { entities, uids } = buildEntitiesFromFallback("@ALL please check", memberMap);
+    expect(uids).toEqual([]);
+    expect(entities).toEqual([]);
+  });
+
+  it("@all 单独出现也不应生成 entity", () => {
+    const memberMap = new Map<string, string>();
+    const { entities, uids } = buildEntitiesFromFallback("@all", memberMap);
+    expect(uids).toEqual([]);
+    expect(entities).toEqual([]);
+  });
+
+  it("@所有人 不应生成 entity", () => {
+    const memberMap = new Map([["Bob", "uid_bob"]]);
+    const { entities, uids } = buildEntitiesFromFallback("@所有人 @Bob", memberMap);
+    expect(uids).toEqual(["uid_bob"]);
+    expect(entities).toHaveLength(1);
+    expect(entities[0]).toEqual({ uid: "uid_bob", offset: 5, length: 4 });
+  });
+
+  it("@所有人 单独出现也不应生成 entity", () => {
+    const memberMap = new Map<string, string>();
+    const { entities, uids } = buildEntitiesFromFallback("@所有人", memberMap);
+    expect(uids).toEqual([]);
+    expect(entities).toEqual([]);
+  });
+
+  it("混合 @all 和 @所有人 都不应生成 entity", () => {
+    const memberMap = new Map([["Bob", "uid_bob"]]);
+    const { entities, uids } = buildEntitiesFromFallback("@all @所有人 @Bob", memberMap);
+    expect(uids).toEqual(["uid_bob"]);
+    expect(entities).toHaveLength(1);
+  });
+});
+
+describe("convertContentForLLM — 空格昵称支持", () => {
+  it("v1 memberMap 路径应匹配空格昵称", () => {
+    const content = "@Anyang Su 你好";
+    const mention: MentionPayload = { uids: ["uid_anyang"] };
+    const memberMap = new Map([["Anyang Su", "uid_anyang"]]);
+    const result = convertContentForLLM(content, mention, memberMap);
+    expect(result).toBe("@[uid_anyang:Anyang Su] 你好");
+  });
+});

package/src/mention-utils.ts

@@ -146,6 +146,36 @@ export function convertStructuredMentions(
 
 // ── Build entities from plain @name (fallback path) ──────────────────────────
 
+/** Name character class — mirrors MENTION_PATTERN's inner char set (without space) */
+const NAME_CHAR_RE =
+  /[\w\u00C0-\u024F\u4e00-\u9fff\u3040-\u30FF\uAC00-\uD7AF.\-]/;
+
+/**
+ * 从 @atPos 位置尝试匹配 memberMap 中最长的名称（支持含空格昵称）。
+ * sortedNames 必须按长度降序排列。
+ *
+ * 边界检查：匹配到的名称末尾之后的字符必须是终止字符（非"名字字符"），
+ * 防止 @Anyang Su 从 "@Anyang Superman" 中误匹配。
+ */
+export function tryLongestMemberMatch(
+  text: string,
+  atPos: number,
+  memberMap: Map<string, string>,
+  sortedNames: string[],
+): { name: string; uid: string } | undefined {
+  const after = text.substring(atPos + 1);
+  for (const candidate of sortedNames) {
+    if (after.startsWith(candidate)) {
+      const ch = text[atPos + 1 + candidate.length];
+      if (ch === undefined || !NAME_CHAR_RE.test(ch)) {
+        const uid = memberMap.get(candidate);
+        if (uid) return { name: candidate, uid };
+      }
+    }
+  }
+  return undefined;
+}
+
 /**
  * 从纯 @name 格式的文本中构建 entities（fallback 路径）。
  * 通过 memberMap（displayName → uid）解析每个 @name 对应的 uid。
@@ -163,15 +193,38 @@ export function buildEntitiesFromFallback(
   const pattern = new RegExp(MENTION_PATTERN.source, "g");
   let match;
 
+  // 按长度降序排列，优先匹配最长名称
+  const sortedNames = [...memberMap.keys()].sort((a, b) => b.length - a.length);
+
   while ((match = pattern.exec(content)) !== null) {
     const name = match[1];
-    const uid = memberMap.get(name);
+
+    // Skip @all / @All etc. — handled separately as mentionAll, not as entity
+    if (name.toLowerCase() === "all" || name === "所有人") continue;
+
+    let uid: string | undefined;
+    let matchedName = name;
+
+    // 优先尝试最长前缀匹配（支持含空格昵称）
+    const longer = tryLongestMemberMatch(
+      content, match.index, memberMap, sortedNames,
+    );
+    if (longer) {
+      uid = longer.uid;
+      matchedName = longer.name;
+    } else {
+      // 回退到精确正则匹配
+      uid = memberMap.get(name);
+    }
 
     if (!uid) continue;
 
-    const atName = `@${name}`;
+    const atName = `@${matchedName}`;
     entities.push({ uid, offset: match.index, length: atName.length });
     uids.push(uid);
+
+    // 跳过完整匹配长度，防止空格名称被部分重复匹配
+    pattern.lastIndex = match.index + atName.length;
   }
 
   return { entities, uids };
@@ -282,12 +335,27 @@ export function convertContentForLLM(
       replacement: string;
     }[] = [];
 
+    // 按长度降序排列，优先匹配最长名称
+    const sortedNames = hasMemberMap
+      ? [...memberMap!.keys()].sort((a, b) => b.length - a.length)
+      : [];
+
     while ((match = pattern.exec(content)) !== null) {
       const name = match[1];
       let uid: string | undefined;
+      let matchedName = name;
 
       if (hasMemberMap) {
-        uid = memberMap!.get(name);
+        // 优先尝试最长前缀匹配（支持含空格昵称）
+        const longer = tryLongestMemberMatch(
+          content, match.index, memberMap!, sortedNames,
+        );
+        if (longer) {
+          uid = longer.uid;
+          matchedName = longer.name;
+        } else {
+          uid = memberMap!.get(name);
+        }
       } else if (hasUids && i < mention.uids!.length) {
         const candidate = mention.uids![i];
         uid = typeof candidate === "string" ? candidate : undefined;
@@ -297,10 +365,15 @@ export function convertContentForLLM(
       if (uid) {
         replacements.push({
           start: match.index,
-          end: match.index + 1 + name.length,
-          replacement: `@[${uid}:${name}]`,
+          end: match.index + 1 + matchedName.length,
+          replacement: `@[${uid}:${matchedName}]`,
         });
       }
+
+      // 跳过完整匹配长度
+      if (matchedName.length > name.length) {
+        pattern.lastIndex = match.index + 1 + matchedName.length;
+      }
     }
 
     for (let j = replacements.length - 1; j >= 0; j--) {

package/src/multi-bot-isolation.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Tests for multi-bot accountId isolation fix.
+ *
+ * Verifies that when multiple bots share the same OpenClaw Gateway process,
+ * messages are sent from the correct bot account — not from whichever bot
+ * last processed a message in the same group.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// We need to reset module state between tests since _groupToAccount is module-level
+beforeEach(() => {
+  vi.resetModules();
+});
+
+// ─── registerGroupToAccount / resolveAccountForGroup unit tests ─────────────
+
+describe("registerGroupToAccount + resolveAccountForGroup", () => {
+  it("single bot — resolveAccountForGroup returns the registered accountId", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+
+    registerGroupToAccount("group-001", "botA");
+
+    expect(resolveAccountForGroup("group-001")).toBe("botA");
+  });
+
+  it("multi-bot same group — resolveAccountForGroup returns undefined", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+
+    registerGroupToAccount("group-001", "botA");
+    registerGroupToAccount("group-001", "botB");
+
+    expect(resolveAccountForGroup("group-001")).toBeUndefined();
+  });
+
+  it("unregistered group — resolveAccountForGroup returns undefined", async () => {
+    const { resolveAccountForGroup } = await import("./channel.js");
+
+    expect(resolveAccountForGroup("group-unknown")).toBeUndefined();
+  });
+
+  it("duplicate registration of same bot is idempotent", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+
+    registerGroupToAccount("group-001", "botA");
+    registerGroupToAccount("group-001", "botA");
+
+    // Still size 1 → should return the accountId
+    expect(resolveAccountForGroup("group-001")).toBe("botA");
+  });
+
+  it("different groups with different bots resolve independently", async () => {
+    const { registerGroupToAccount, resolveAccountForGroup } = await import("./channel.js");
+
+    registerGroupToAccount("group-001", "botA");
+    registerGroupToAccount("group-002", "botB");
+
+    expect(resolveAccountForGroup("group-001")).toBe("botA");
+    expect(resolveAccountForGroup("group-002")).toBe("botB");
+  });
+});
+
+// ─── handleAction correction logic tests ─────────────────────────────────────
+
+// Mock dependencies that handleAction calls
+vi.mock("./actions.js", () => ({
+  handleDmworkMessageAction: vi.fn(async () => ({ ok: true })),
+  parseTarget: vi.fn(() => ({ channelId: "test", channelType: 2 })),
+}));
+
+vi.mock("./agent-tools.js", () => ({
+  createDmworkManagementTools: vi.fn(() => []),
+}));
+
+vi.mock("./group-md.js", () => ({
+  getOrCreateGroupMdCache: vi.fn(() => new Map()),
+  registerBotGroupIds: vi.fn(),
+  getKnownGroupIds: vi.fn(() => new Set()),
+}));
+
+vi.mock("./api-fetch.js", () => ({
+  registerBot: vi.fn(),
+  sendMessage: vi.fn(),
+  sendHeartbeat: vi.fn(),
+  sendMediaMessage: vi.fn(),
+  inferContentType: vi.fn(),
+  ensureTextCharset: vi.fn((s: string) => s),
+  fetchBotGroups: vi.fn(async () => []),
+  getGroupMd: vi.fn(),
+  getGroupMembers: vi.fn(),
+  parseImageDimensions: vi.fn(),
+  parseImageDimensionsFromFile: vi.fn(),
+  getUploadCredentials: vi.fn(),
+  uploadFileToCOS: vi.fn(),
+}));
+
+describe("handleAction multi-bot isolation", () => {
+  it("single bot — corrects wrong accountId to the sole owner", async () => {
+    const { dmworkPlugin, registerGroupToAccount } = await import("./channel.js");
+    const { handleDmworkMessageAction } = await import("./actions.js");
+
+    // Only botA is in group-001
+    registerGroupToAccount("group-001", "botA");
+
+    const ctx = {
+      accountId: "wrongBot",
+      action: "send" as const,
+      channel: "dmwork",
+      params: { target: "group:group-001", text: "hello" },
+      toolContext: { currentChannelId: "dmwork:group-001" },
+      cfg: {
+        channels: {
+          dmwork: {
+            accounts: {
+              botA: { botToken: "tokenA", apiUrl: "http://api" },
+              wrongBot: { botToken: "tokenWrong", apiUrl: "http://api" },
+            },
+          },
+        },
+      },
+      log: { info: vi.fn() },
+    };
+
+    await dmworkPlugin.actions!.handleAction!(ctx as any);
+
+    // handleDmworkMessageAction should have been called with botA's token
+    expect(handleDmworkMessageAction).toHaveBeenCalledWith(
+      expect.objectContaining({ botToken: "tokenA" }),
+    );
+    // Correction log should have fired
+    expect(ctx.log.info).toHaveBeenCalledWith(
+      expect.stringContaining("accountId corrected"),
+    );
+  });
+
+  it("multi-bot same group — does NOT override ctx.accountId", async () => {
+    const { dmworkPlugin, registerGroupToAccount } = await import("./channel.js");
+    const { handleDmworkMessageAction } = await import("./actions.js");
+
+    // Both botA and botB are in group-001
+    registerGroupToAccount("group-001", "botA");
+    registerGroupToAccount("group-001", "botB");
+
+    const ctx = {
+      accountId: "botA",
+      action: "send" as const,
+      channel: "dmwork",
+      params: { target: "group:group-001", text: "hello from A" },
+      toolContext: { currentChannelId: "dmwork:group-001" },
+      cfg: {
+        channels: {
+          dmwork: {
+            accounts: {
+              botA: { botToken: "tokenA", apiUrl: "http://api" },
+              botB: { botToken: "tokenB", apiUrl: "http://api" },
+            },
+          },
+        },
+      },
+      log: { info: vi.fn() },
+    };
+
+    await dmworkPlugin.actions!.handleAction!(ctx as any);
+
+    // Should use botA's token (the caller's original accountId), NOT botB's
+    expect(handleDmworkMessageAction).toHaveBeenCalledWith(
+      expect.objectContaining({ botToken: "tokenA" }),
+    );
+    // No correction log should have fired
+    expect(ctx.log.info).not.toHaveBeenCalledWith(
+      expect.stringContaining("accountId corrected"),
+    );
+  });
+
+  it("single bot — correct accountId is not re-corrected", async () => {
+    const { dmworkPlugin, registerGroupToAccount } = await import("./channel.js");
+    const { handleDmworkMessageAction } = await import("./actions.js");
+
+    registerGroupToAccount("group-001", "botA");
+
+    const ctx = {
+      accountId: "botA", // already correct
+      action: "send" as const,
+      channel: "dmwork",
+      params: { target: "group:group-001", text: "hello" },
+      toolContext: { currentChannelId: "dmwork:group-001" },
+      cfg: {
+        channels: {
+          dmwork: {
+            accounts: {
+              botA: { botToken: "tokenA", apiUrl: "http://api" },
+            },
+          },
+        },
+      },
+      log: { info: vi.fn() },
+    };
+
+    await dmworkPlugin.actions!.handleAction!(ctx as any);
+
+    expect(handleDmworkMessageAction).toHaveBeenCalledWith(
+      expect.objectContaining({ botToken: "tokenA" }),
+    );
+    // No correction needed
+    expect(ctx.log.info).not.toHaveBeenCalledWith(
+      expect.stringContaining("accountId corrected"),
+    );
+  });
+});