fix(dingtalk): parse forwarded chat records

packages/channels/dingtalk/src/DingtalkAdapter.test.ts

@@ -2373,6 +2373,106 @@ describe('DingtalkChannel parsed-message logging', () => {
   });
 });
 
+describe('DingtalkChannel chat records', () => {
+  it('includes a replied chat-record title and summary as referenced context', () => {
+    const channel = createChannel();
+    const downstream = {
+      data: JSON.stringify({
+        msgId: 'chat-record-reply-m1',
+        conversationType: '2',
+        conversationId: 'cid-chat-record',
+        conversationTitle: 'Channel test group',
+        sessionWebhook:
+          'https://oapi.dingtalk.com/robot/send?access_token=token',
+        senderNick: 'Alice',
+        senderStaffId: 'staff-1',
+        senderId: 'sender-1',
+        chatbotUserId: 'bot-1',
+        isInAtList: true,
+        text: {
+          content: '@DingTalkTest can you see this?',
+          isReplyMsg: true,
+          repliedMsg: {
+            msgId: 'forwarded-record-m1',
+            msgType: 'chatRecord',
+            senderId: 'sender-1',
+            content: {
+              title: 'Group chat history',
+              summary: 'Alice: first message\nBob: [message]',
+            },
+          },
+        },
+      }),
+      headers: { messageId: 'chat-record-reply-m1' },
+    } as unknown as DWClientDownStream;
+
+    (
+      channel as unknown as { onMessage(d: DWClientDownStream): void }
+    ).onMessage(downstream);
+
+    expect(channel.handleInbound).toHaveBeenCalledWith(
+      expect.objectContaining({
+        text: 'can you see this?',
+        referencedText:
+          '[Group chat history] Alice: first message\nBob: [message]',
+      }),
+    );
+    expect(
+      vi.mocked(channel.handleInbound).mock.calls[0]![0].referencedText,
+    ).not.toContain('[Chat record messages]');
+  });
+
+  it.each([
+    ['chatRecord', false],
+    ['records', true],
+    ['messages', false],
+  ])(
+    'expands top-level %s entries in their original order',
+    (entryField, stringifyEntries) => {
+      const channel = createChannel();
+      const entries = [
+        { senderName: 'Alice', content: 'first message' },
+        { senderNick: 'Bob', msgType: 'picture' },
+        {
+          sender: 'Carol',
+          msgType: 'file',
+          content: { fileName: 'report.pdf' },
+        },
+        { senderId: 'dan-id', content: { text: 'last message' } },
+      ];
+      const downstream = {
+        data: JSON.stringify({
+          msgId: `chat-record-${entryField}`,
+          conversationType: '1',
+          conversationId: 'cid-chat-record-dm',
+          sessionWebhook:
+            'https://oapi.dingtalk.com/robot/send?access_token=token',
+          senderNick: 'Alice',
+          senderStaffId: 'staff-1',
+          senderId: 'sender-1',
+          msgtype: 'chatRecord',
+          content: {
+            title: 'Group chat history',
+            summary: 'Alice: first message\nBob: [image]',
+            [entryField]: stringifyEntries ? JSON.stringify(entries) : entries,
+          },
+        }),
+        headers: { messageId: `chat-record-${entryField}` },
+      } as unknown as DWClientDownStream;
+
+      (
+        channel as unknown as { onMessage(d: DWClientDownStream): void }
+      ).onMessage(downstream);
+
+      expect(channel.handleInbound).toHaveBeenCalledWith(
+        expect.objectContaining({
+          text: '[Group chat history] Alice: first message\nBob: [image]\n\n[Chat record messages]\nAlice: first message\nBob: [image]\nCarol: [file: report.pdf]\ndan-id: last message',
+        }),
+      );
+    },
+  );
+});
+
 describe('DingtalkChannel downstream logging', () => {
   it('replaces raw SDK Buffer logging with a structured downstream summary', () => {
     createChannel();

packages/channels/dingtalk/src/DingtalkAdapter.ts

@@ -66,16 +66,24 @@ interface DingTalkRichTextPart {
   atName?: string;
 }
 
+interface DingTalkMessageContent {
+  text?: string;
+  richText?: DingTalkRichTextPart[];
+  downloadCode?: string;
+  fileName?: string;
+  recognition?: string;
+  title?: string;
+  summary?: string;
+  chatRecord?: unknown;
+  records?: unknown;
+  messages?: unknown;
+}
+
 interface DingTalkRepliedMsg {
   msgId?: string;
   msgType?: string;
   senderId?: string;
-  content?: {
-    text?: string;
-    richText?: DingTalkRichTextPart[];
-    downloadCode?: string;
-    fileName?: string;
-  };
+  content?: DingTalkMessageContent;
 }
 
 interface DingTalkAtUser {
@@ -107,12 +115,86 @@ interface DingTalkMessageData {
     text?: { content?: string };
     msgtype?: string;
   };
-  content?: {
-    richText?: DingTalkRichTextPart[];
-    downloadCode?: string;
-    fileName?: string;
-    recognition?: string;
-  };
+  content?: DingTalkMessageContent;
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function formatChatRecordEntryBody(record: Record<string, unknown>): string {
+  const rawContent = record['content'];
+  const content =
+    rawContent && typeof rawContent === 'object'
+      ? (rawContent as Record<string, unknown>)
+      : undefined;
+  const body =
+    nonEmptyString(record['text']) ||
+    nonEmptyString(rawContent) ||
+    nonEmptyString(content?.['text']) ||
+    nonEmptyString(record['message']) ||
+    nonEmptyString(record['body']);
+  if (body) return body;
+
+  const msgType =
+    nonEmptyString(record['msgType']) || nonEmptyString(record['msgtype']);
+  switch (msgType) {
+    case 'picture':
+      return '[image]';
+    case 'file':
+      return `[file: ${nonEmptyString(content?.['fileName']) || 'file'}]`;
+    case 'audio':
+      return '[audio]';
+    case 'video':
+      return '[video]';
+    default:
+      return msgType ? `[${msgType}]` : '[message]';
+  }
+}
+
+function formatChatRecord(content?: DingTalkMessageContent): string {
+  const title = nonEmptyString(content?.title);
+  const summary = nonEmptyString(content?.summary);
+  let entries = content?.chatRecord ?? content?.records ?? content?.messages;
+
+  if (typeof entries === 'string') {
+    try {
+      entries = JSON.parse(entries);
+    } catch {
+      entries = undefined;
+    }
+  }
+
+  const recordLines = Array.isArray(entries)
+    ? entries.flatMap((entry) => {
+        if (typeof entry === 'string') {
+          const body = nonEmptyString(entry);
+          return body ? [`Unknown: ${body}`] : [];
+        }
+        if (!entry || typeof entry !== 'object') return [];
+        const record = entry as Record<string, unknown>;
+        const sender =
+          nonEmptyString(record['senderName']) ||
+          nonEmptyString(record['senderNick']) ||
+          nonEmptyString(record['sender']) ||
+          nonEmptyString(record['senderId']) ||
+          'Unknown';
+        return [`${sender}: ${formatChatRecordEntryBody(record)}`];
+      })
+    : [];
+
+  const parts: string[] = [];
+  if (summary && summary !== '[]') {
+    parts.push(`[${title || 'Chat record'}] ${summary}`);
+  } else if (title) {
+    parts.push(`[${title}]`);
+  }
+  if (recordLines.length > 0) {
+    parts.push(`[Chat record messages]\n${recordLines.join('\n')}`);
+  }
+  return parts.join('\n\n');
 }
 
 /** Track seen msgIds to deduplicate retried callbacks. */
@@ -1431,6 +1513,10 @@ export class DingtalkChannel extends ChannelBase {
       if (summary) return summary;
     }
 
+    if (msgType === 'chatRecord') {
+      return formatChatRecord(content);
+    }
+
     // Media type placeholders
     switch (msgType) {
       case 'picture':
@@ -1521,6 +1607,13 @@ export class DingtalkChannel extends ChannelBase {
       };
     }
 
+    if (msgtype === 'chatRecord') {
+      return {
+        text: formatChatRecord(data.content) || '(chat record)',
+        downloadCodes: [],
+      };
+    }
+
     // Default: text message
     return { text: data.text?.content?.trim() || '', downloadCodes: [] };
   }