openclaw-channel-dmwork 0.5.16 → 0.5.17-dev.84f17dc

package/package.json

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

package/src/actions.test.ts

@@ -148,6 +148,189 @@ describe("handleDmworkMessageAction", () => {
     });
   });
 
+  // -----------------------------------------------------------------------
+  // send — v2 structured mentions (@[uid:name])
+  // -----------------------------------------------------------------------
+  describe("send — v2 structured mentions converted to @name + entities", () => {
+    it("should convert @[uid:name] to @name with correct entities", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const uidToNameMap = new Map([
+        ["uid_chen", "陈皮皮"],
+        ["uid_bob", "bob"],
+      ]);
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "Hello @[uid_chen:陈皮皮] and @[uid_bob:bob]!" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        uidToNameMap,
+      });
+
+      expect(result.ok).toBe(true);
+      // Content should have @name format (not @[uid:name])
+      expect(sentPayload.payload.content).toBe("Hello @陈皮皮 and @bob!");
+      // Entities should have correct offset/length/uid
+      const entities = sentPayload.payload.mention.entities;
+      expect(entities).toHaveLength(2);
+      expect(entities[0]).toMatchObject({ uid: "uid_chen", offset: 6, length: 4 });
+      expect(entities[1]).toMatchObject({ uid: "uid_bob", offset: 15, length: 4 });
+      // UIDs should be present
+      expect(sentPayload.payload.mention.uids).toEqual(["uid_chen", "uid_bob"]);
+    });
+  });
+
+  describe("send — @all detection", () => {
+    it("should set mentionAll when @all is present", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "Attention @all please read" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+      });
+
+      expect(result.ok).toBe(true);
+      expect(sentPayload.payload.mention.all).toBe(1);
+    });
+  });
+
+  describe("send — @所有人 detection", () => {
+    it("should set mentionAll when @所有人 is present", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "大家注意 @所有人 请查收" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+      });
+
+      expect(result.ok).toBe(true);
+      expect(sentPayload.payload.mention.all).toBe(1);
+    });
+  });
+
+  describe("send — mixed v1+v2 mentions", () => {
+    it("should resolve both @[uid:name] and @name in same message", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const memberMap = new Map([["alice", "uid_alice"]]);
+      const uidToNameMap = new Map([
+        ["uid_chen", "陈皮皮"],
+        ["uid_alice", "alice"],
+      ]);
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "Hey @[uid_chen:陈皮皮] and @alice!" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        memberMap,
+        uidToNameMap,
+      });
+
+      expect(result.ok).toBe(true);
+      // Content should have both converted
+      expect(sentPayload.payload.content).toBe("Hey @陈皮皮 and @alice!");
+      const entities = sentPayload.payload.mention.entities;
+      expect(entities).toHaveLength(2);
+      // First entity from v2 conversion
+      expect(entities[0]).toMatchObject({ uid: "uid_chen", offset: 4, length: 4 });
+      // Second entity from v1 fallback
+      expect(entities[1]).toMatchObject({ uid: "uid_alice", offset: 13, length: 6 });
+    });
+  });
+
+  describe("send — v2 without uidToNameMap graceful fallback", () => {
+    it("should leave @[uid:name] unchanged when uidToNameMap is not provided", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "Hello @[uid_chen:陈皮皮]!" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        // no uidToNameMap provided
+      });
+
+      expect(result.ok).toBe(true);
+      // Content should be unchanged — no conversion without uidToNameMap
+      expect(sentPayload.payload.content).toBe("Hello @[uid_chen:陈皮皮]!");
+    });
+  });
+
+  describe("send — invalid uid in v2 (uid not in uidToNameMap)", () => {
+    it("should convert format but not create entity for unknown uid", async () => {
+      let sentPayload: any = null;
+      globalThis.fetch = mockFetch({
+        "/v1/bot/sendMessage": async (_url, init) => {
+          sentPayload = JSON.parse(init?.body as string);
+          return jsonResponse({ message_id: 1, message_seq: 1 });
+        },
+      });
+
+      const uidToNameMap = new Map([
+        ["uid_bob", "bob"],
+      ]);
+      // uid_unknown is NOT in uidToNameMap
+
+      const { handleDmworkMessageAction } = await import("./actions.js");
+      const result = await handleDmworkMessageAction({
+        action: "send",
+        args: { target: "group:grp1", message: "Hello @[uid_unknown:Ghost] and @[uid_bob:bob]!" },
+        apiUrl: "http://localhost:8090",
+        botToken: "test-token",
+        uidToNameMap,
+      });
+
+      expect(result.ok).toBe(true);
+      // Format is still converted for both
+      expect(sentPayload.payload.content).toBe("Hello @Ghost and @bob!");
+      // Only valid uid gets an entity
+      const entities = sentPayload.payload.mention.entities;
+      expect(entities).toHaveLength(1);
+      expect(entities[0]).toMatchObject({ uid: "uid_bob" });
+    });
+  });
+
   describe("send — unresolvable @mentions still sends", () => {
     it("should send without mentionUids when names are unresolvable", async () => {
       let sentPayload: any = null;

package/src/actions.ts

@@ -16,7 +16,7 @@ import {
   updateGroupMd,
 } from "./api-fetch.js";
 import { uploadAndSendMedia } from "./inbound.js";
-import { buildEntitiesFromFallback } from "./mention-utils.js";
+import { buildEntitiesFromFallback, parseStructuredMentions, convertStructuredMentions } from "./mention-utils.js";
 import type { MentionEntity } from "./types.js";
 import { getKnownGroupIds } from "./group-md.js";
 
@@ -110,7 +110,7 @@ export async function handleDmworkMessageAction(params: {
 
   switch (action) {
     case "send":
-      return handleSend({ args, apiUrl, botToken, memberMap, currentChannelId, log });
+      return handleSend({ args, apiUrl, botToken, memberMap, uidToNameMap, currentChannelId, log });
     case "read":
       return handleRead({ args, apiUrl, botToken, uidToNameMap, currentChannelId, log });
     case "member-info":
@@ -137,10 +137,11 @@ async function handleSend(params: {
   apiUrl: string;
   botToken: string;
   memberMap?: Map<string, string>;
+  uidToNameMap?: Map<string, string>;
   currentChannelId?: string;
   log?: LogSink;
 }): Promise<MessageActionResult> {
-  const { args, apiUrl, botToken, memberMap, currentChannelId, log } = params;
+  const { args, apiUrl, botToken, memberMap, uidToNameMap, currentChannelId, log } = params;
 
   const target = args.target as string | undefined;
   if (!target) {
@@ -166,21 +167,56 @@ async function handleSend(params: {
   if (message) {
     let mentionUids: string[] = [];
     let mentionEntities: MentionEntity[] = [];
+    let finalMessage = message;
+
+    if (channelType === ChannelType.Group) {
+      // v2 path: convert @[uid:name] → @name + entities
+      if (uidToNameMap) {
+        const structuredMentions = parseStructuredMentions(finalMessage);
+        if (structuredMentions.length > 0) {
+          const validUids = new Set(uidToNameMap.keys());
+          const converted = convertStructuredMentions(finalMessage, structuredMentions, validUids);
+          finalMessage = converted.content;
+          mentionEntities = [...converted.entities];
+          mentionUids = [...converted.uids];
+        }
+      }
+
+      // v1 fallback: resolve remaining @name via memberMap
+      if (memberMap) {
+        const { entities, uids } = buildEntitiesFromFallback(finalMessage, memberMap);
+        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);
+          }
+        }
+      }
 
-    if (channelType === ChannelType.Group && memberMap) {
-      const { entities, uids } = buildEntitiesFromFallback(message, memberMap);
-      mentionUids = uids;
-      mentionEntities = entities;
+      // Sort entities by offset and rebuild uids from sorted entities
+      if (mentionEntities.length > 0) {
+        mentionEntities.sort((a, b) => a.offset - b.offset);
+        mentionUids = mentionEntities.map(e => e.uid);
+      }
     }
 
+    // Detect @all/@所有人 in final content
+    const hasAtAll = /(?:^|(?<=\s))@(?:all|所有人)(?=\s|[^\w]|$)/i.test(finalMessage);
+
     await sendMessage({
       apiUrl,
       botToken,
       channelId,
       channelType,
-      content: message,
+      content: finalMessage,
       ...(mentionUids.length > 0 ? { mentionUids } : {}),
       ...(mentionEntities.length > 0 ? { mentionEntities } : {}),
+      mentionAll: hasAtAll || undefined,
     });
   }
 

package/src/inbound.test.ts

@@ -5,6 +5,7 @@ import {
   resolveInnerMessageText,
   resolveApiMessagePlaceholder,
   resolveMultipleForwardText,
+  buildMediaUrl,
   calcDownloadTimeout,
   formatSize,
   resolveFileContentWithRetry,
@@ -865,3 +866,204 @@ describe("buildMemberListPrefix", () => {
     expect(result).toContain("50 members");
   });
 });
+
+/**
+ * Tests for buildMediaUrl — exported module-level URL builder.
+ */
+describe("buildMediaUrl", () => {
+  it("should return undefined for empty url", () => {
+    expect(buildMediaUrl(undefined)).toBeUndefined();
+    expect(buildMediaUrl("")).toBeUndefined();
+  });
+
+  it("should return absolute URL as-is", () => {
+    expect(buildMediaUrl("https://cdn.example.com/img.jpg")).toBe("https://cdn.example.com/img.jpg");
+    expect(buildMediaUrl("http://example.com/file.pdf")).toBe("http://example.com/file.pdf");
+  });
+
+  it("should use cdnUrl when provided", () => {
+    expect(buildMediaUrl("upload/abc123.jpg", "https://api.example.com", "https://cdn.example.com"))
+      .toBe("https://cdn.example.com/upload/abc123.jpg");
+  });
+
+  it("should strip trailing slashes from cdnUrl", () => {
+    expect(buildMediaUrl("upload/abc.jpg", undefined, "https://cdn.example.com///"))
+      .toBe("https://cdn.example.com/upload/abc.jpg");
+  });
+
+  it("should strip file/preview/ prefix with cdnUrl", () => {
+    expect(buildMediaUrl("file/preview/bucket/img.jpg", undefined, "https://cdn.example.com"))
+      .toBe("https://cdn.example.com/bucket/img.jpg");
+  });
+
+  it("should strip file/ prefix with cdnUrl", () => {
+    expect(buildMediaUrl("file/bucket/img.jpg", undefined, "https://cdn.example.com"))
+      .toBe("https://cdn.example.com/bucket/img.jpg");
+  });
+
+  it("should fall back to apiUrl when cdnUrl is not provided", () => {
+    expect(buildMediaUrl("upload/abc123.jpg", "https://api.example.com"))
+      .toBe("https://api.example.com/file/upload/abc123.jpg");
+  });
+
+  it("should strip trailing slashes from apiUrl", () => {
+    expect(buildMediaUrl("upload/abc.jpg", "https://api.example.com/"))
+      .toBe("https://api.example.com/file/upload/abc.jpg");
+  });
+
+  it("should strip file/ prefix with apiUrl fallback", () => {
+    expect(buildMediaUrl("file/bucket/img.jpg", "https://api.example.com"))
+      .toBe("https://api.example.com/file/bucket/img.jpg");
+  });
+
+  it("should return /file/path when neither cdnUrl nor apiUrl provided", () => {
+    expect(buildMediaUrl("upload/abc.jpg")).toBe("/file/upload/abc.jpg");
+  });
+});
+
+/**
+ * Tests for resolveInnerMessageText with buildUrl parameter.
+ */
+describe("resolveInnerMessageText with buildUrl", () => {
+  const mockBuildUrl = (url?: string) => url ? `https://cdn.example.com/${url}` : undefined;
+
+  it("should append URL for Image when buildUrl is provided", () => {
+    const result = resolveInnerMessageText(
+      { type: MessageType.Image, url: "img.jpg" },
+      mockBuildUrl,
+    );
+    expect(result).toBe("[图片]\nhttps://cdn.example.com/img.jpg");
+  });
+
+  it("should append URL for GIF when buildUrl is provided", () => {
+    const result = resolveInnerMessageText(
+      { type: MessageType.GIF, url: "anim.gif" },
+      mockBuildUrl,
+    );
+    expect(result).toBe("[GIF]\nhttps://cdn.example.com/anim.gif");
+  });
+
+  it("should append URL for Voice when buildUrl is provided", () => {
+    const result = resolveInnerMessageText(
+      { type: MessageType.Voice, url: "voice.mp3" },
+      mockBuildUrl,
+    );
+    expect(result).toBe("[语音]\nhttps://cdn.example.com/voice.mp3");
+  });
+
+  it("should append URL for Video when buildUrl is provided", () => {
+    const result = resolveInnerMessageText(
+      { type: MessageType.Video, url: "clip.mp4" },
+      mockBuildUrl,
+    );
+    expect(result).toBe("[视频]\nhttps://cdn.example.com/clip.mp4");
+  });
+
+  it("should append URL for File when buildUrl is provided", () => {
+    const result = resolveInnerMessageText(
+      { type: MessageType.File, name: "report.pdf", url: "report.pdf" },
+      mockBuildUrl,
+    );
+    expect(result).toBe("[文件: report.pdf]\nhttps://cdn.example.com/report.pdf");
+  });
+
+  it("should return placeholder without URL when buildUrl is not provided", () => {
+    expect(resolveInnerMessageText({ type: MessageType.Image, url: "img.jpg" })).toBe("[图片]");
+    expect(resolveInnerMessageText({ type: MessageType.GIF, url: "anim.gif" })).toBe("[GIF]");
+    expect(resolveInnerMessageText({ type: MessageType.Voice, url: "voice.mp3" })).toBe("[语音]");
+    expect(resolveInnerMessageText({ type: MessageType.Video, url: "clip.mp4" })).toBe("[视频]");
+    expect(resolveInnerMessageText({ type: MessageType.File, name: "doc.pdf", url: "doc.pdf" })).toBe("[文件: doc.pdf]");
+  });
+
+  it("should return placeholder when payload.url is missing even with buildUrl", () => {
+    expect(resolveInnerMessageText({ type: MessageType.Image }, mockBuildUrl)).toBe("[图片]");
+    expect(resolveInnerMessageText({ type: MessageType.Voice }, mockBuildUrl)).toBe("[语音]");
+    expect(resolveInnerMessageText({ type: MessageType.File, name: "doc.pdf" }, mockBuildUrl)).toBe("[文件: doc.pdf]");
+  });
+});
+
+/**
+ * Tests for resolveMultipleForwardText with apiUrl/cdnUrl — nested media URL resolution.
+ */
+describe("resolveMultipleForwardText with URL resolution", () => {
+  it("should include full URLs for media messages when apiUrl is provided", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "Alice" }],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Image, url: "upload/img.jpg" } },
+        { from_uid: "user1", payload: { type: MessageType.File, name: "doc.pdf", url: "upload/doc.pdf" } },
+      ],
+    };
+
+    const result = resolveMultipleForwardText(payload, "https://api.example.com");
+    expect(result).toContain("Alice: [图片]\nhttps://api.example.com/file/upload/img.jpg");
+    expect(result).toContain("Alice: [文件: doc.pdf]\nhttps://api.example.com/file/upload/doc.pdf");
+  });
+
+  it("should use cdnUrl when provided", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "Bob" }],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Video, url: "upload/clip.mp4" } },
+      ],
+    };
+
+    const result = resolveMultipleForwardText(payload, "https://api.example.com", "https://cdn.example.com");
+    expect(result).toContain("Bob: [视频]\nhttps://cdn.example.com/upload/clip.mp4");
+  });
+
+  it("should recursively resolve nested MultipleForward with URLs", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "张三" }],
+      msgs: [
+        {
+          from_uid: "user1",
+          payload: {
+            type: MessageType.MultipleForward,
+            users: [{ uid: "user2", name: "李四" }],
+            msgs: [
+              { from_uid: "user2", payload: { type: MessageType.File, name: "secret.docx", url: "upload/secret.docx" } },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = resolveMultipleForwardText(payload, "https://api.example.com");
+    expect(result).toContain("张三: [合并转发]");
+    expect(result).toContain("[合并转发: 聊天记录]");
+    expect(result).toContain("李四: [文件: secret.docx]\nhttps://api.example.com/file/upload/secret.docx");
+  });
+
+  it("should keep placeholders when no apiUrl or cdnUrl provided", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "Test" }],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Image, url: "upload/img.jpg" } },
+      ],
+    };
+
+    const result = resolveMultipleForwardText(payload);
+    expect(result).toBe("[合并转发: 聊天记录]\nTest: [图片]");
+  });
+
+  it("should handle payload.url being empty in nested messages", () => {
+    const payload = {
+      type: MessageType.MultipleForward,
+      users: [{ uid: "user1", name: "Test" }],
+      msgs: [
+        { from_uid: "user1", payload: { type: MessageType.Image } },
+        { from_uid: "user1", payload: { type: MessageType.File, name: "doc.pdf" } },
+      ],
+    };
+
+    const result = resolveMultipleForwardText(payload, "https://api.example.com");
+    expect(result).toContain("Test: [图片]");
+    expect(result).toContain("Test: [文件: doc.pdf]");
+    expect(result).not.toContain("https://");
+  });
+});

package/src/inbound.ts

@@ -243,26 +243,50 @@ export interface ForwardMessage {
   };
 }
 
+/** Build a full media URL from a relative storage path */
+export function buildMediaUrl(relUrl?: string, apiUrl?: string, cdnUrl?: string): string | undefined {
+  if (!relUrl) return undefined;
+  if (relUrl.startsWith("http")) return relUrl;
+  let storagePath = relUrl;
+  if (storagePath.startsWith("file/preview/")) {
+    storagePath = storagePath.substring("file/preview/".length);
+  } else if (storagePath.startsWith("file/")) {
+    storagePath = storagePath.substring("file/".length);
+  }
+  if (cdnUrl) {
+    const base = cdnUrl.replace(/\/+$/, "");
+    return `${base}/${storagePath}`;
+  }
+  const baseUrl = apiUrl?.replace(/\/+$/, "") ?? "";
+  return `${baseUrl}/file/${storagePath}`;
+}
+
 /** Resolve inner message type to display text for MultipleForward */
-export function resolveInnerMessageText(payload: ForwardMessage["payload"]): string {
+export function resolveInnerMessageText(
+  payload: ForwardMessage["payload"],
+  buildUrl?: (url?: string) => string | undefined,
+): string {
   if (!payload) return "";
+  const fullUrl = buildUrl?.(payload.url);
   switch (payload.type) {
     case MessageType.Text:
       return payload.content ?? "";
     case MessageType.Image:
-      return "[图片]";
+      return fullUrl ? `[图片]\n${fullUrl}` : "[图片]";
     case MessageType.GIF:
-      return "[GIF]";
+      return fullUrl ? `[GIF]\n${fullUrl}` : "[GIF]";
     case MessageType.Voice:
-      return "[语音]";
+      return fullUrl ? `[语音]\n${fullUrl}` : "[语音]";
     case MessageType.Video:
-      return "[视频]";
+      return fullUrl ? `[视频]\n${fullUrl}` : "[视频]";
     case MessageType.Location:
       return "[位置信息]";
     case MessageType.Card:
       return "[名片]";
-    case MessageType.File:
-      return payload.name ? `[文件: ${payload.name}]` : "[文件]";
+    case MessageType.File: {
+      const label = payload.name ? `[文件: ${payload.name}]` : "[文件]";
+      return fullUrl ? `${label}\n${fullUrl}` : label;
+    }
     case MessageType.MultipleForward:
       return "[合并转发]";
     default:
@@ -271,18 +295,27 @@ export function resolveInnerMessageText(payload: ForwardMessage["payload"]): str
 }
 
 /** Resolve MultipleForward payload into readable text */
-export function resolveMultipleForwardText(payload: any): string {
+export function resolveMultipleForwardText(payload: any, apiUrl?: string, cdnUrl?: string): string {
   const users: ForwardUser[] = payload?.users ?? [];
   const msgs: ForwardMessage[] = payload?.msgs ?? [];
   const userMap = new Map<string, string>();
   for (const u of users) {
     if (u.uid && u.name) userMap.set(u.uid, u.name);
   }
+  const buildUrl = (apiUrl || cdnUrl)
+    ? (url?: string) => buildMediaUrl(url, apiUrl, cdnUrl)
+    : undefined;
   const lines: string[] = ["[合并转发: 聊天记录]"];
   for (const m of msgs) {
     const senderName = userMap.get(m.from_uid) ?? m.from_uid;
-    const content = resolveInnerMessageText(m.payload);
-    lines.push(`${senderName}: ${content}`);
+    if (m.payload?.type === MessageType.MultipleForward) {
+      const nested = resolveMultipleForwardText(m.payload, apiUrl, cdnUrl);
+      lines.push(`${senderName}: [合并转发]`);
+      lines.push(nested);
+    } else {
+      const content = resolveInnerMessageText(m.payload, buildUrl);
+      lines.push(`${senderName}: ${content}`);
+    }
   }
   return lines.join("\n");
 }
@@ -290,26 +323,7 @@ export function resolveMultipleForwardText(payload: any): string {
 function resolveContent(payload: BotMessage["payload"], apiUrl?: string, log?: ChannelLogSink, cdnUrl?: string): ResolvedContent {
   if (!payload) return { text: "" };
 
-  const makeFullUrl = (relUrl?: string) => {
-    if (!relUrl) return undefined;
-    if (relUrl.startsWith("http")) return relUrl;
-    // Strip common path prefixes to get the raw storage path
-    let storagePath = relUrl;
-    // Remove "file/preview/" or "file/" prefix
-    if (storagePath.startsWith("file/preview/")) {
-      storagePath = storagePath.substring("file/preview/".length);
-    } else if (storagePath.startsWith("file/")) {
-      storagePath = storagePath.substring("file/".length);
-    }
-    if (cdnUrl) {
-      // CDN direct: public-read, no auth needed, LLM can access directly
-      const base = cdnUrl.replace(/\/+$/, "");
-      return `${base}/${storagePath}`;
-    }
-    // Fallback: Nginx public /file/ path (no auth)
-    const baseUrl = apiUrl?.replace(/\/+$/, "") ?? "";
-    return `${baseUrl}/file/${storagePath}`;
-  };
+  const makeFullUrl = (relUrl?: string) => buildMediaUrl(relUrl, apiUrl, cdnUrl);
 
   switch (payload.type) {
     case MessageType.Text:
@@ -353,7 +367,7 @@ function resolveContent(payload: BotMessage["payload"], apiUrl?: string, log?: C
       return { text: cardText };
     }
     case MessageType.MultipleForward: {
-      return { text: resolveMultipleForwardText(payload) };
+      return { text: resolveMultipleForwardText(payload, apiUrl, cdnUrl) };
     }
     default:
       return { text: payload.content ?? payload.url ?? "" };
@@ -1188,7 +1202,7 @@ export async function handleInboundMessage(params: {
           let body = m.content || resolveApiMessagePlaceholder(m.type, m.name);
           // For MultipleForward, expand the nested messages from full payload
           if (m.type === MessageType.MultipleForward && m.payload) {
-            body = resolveMultipleForwardText(m.payload);
+            body = resolveMultipleForwardText(m.payload, account.config.apiUrl, account.config.cdnUrl);
           }
           const entry: any = {
             sender: m.from_uid,
@@ -1416,8 +1430,17 @@ export async function handleInboundMessage(params: {
     replyOptions: {
       onPartialReply: async (partial: { text?: string; mediaUrls?: string[] }) => {
         if (streamFailed) return;
-        const text = partial.text?.trim();
+        let text = partial.text?.trim();
         if (!text) return;
+        // Convert @[uid:name] → @name for display (no entities — streaming should not trigger notifications)
+        if (isGroup) {
+          const structuredMentions = parseStructuredMentions(text);
+          if (structuredMentions.length > 0) {
+            const validUids = new Set(uidToNameMap.keys());
+            const converted = convertStructuredMentions(text, structuredMentions, validUids);
+            text = converted.content;
+          }
+        }
         try {
           if (!streamNo) {
             // Start stream