fix(slack): guard API calls with threadTs || undefined to fix invalid_thread_ts

Preserve empty threadTs for top-level DMs (matches openDM subscriptions)
while guarding postMessage, chatStream, and setStatus calls to prevent
Slack API "invalid_thread_ts" errors from empty strings.

This addresses review feedback: the two-part fix keeps openDM()
subscription matching working while preventing API errors.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: chechunhsu

.changeset/fix-dm-thread-ts.md

@@ -2,4 +2,4 @@
 "@chat-adapter/slack": patch
 ---
 
-Fix DM messages failing with `invalid_thread_ts` by using `event.ts` as fallback for threadTs in DMs
+Fix DM messages failing with `invalid_thread_ts` by guarding Slack API calls with `threadTs || undefined`

packages/adapter-slack/src/index.test.ts

@@ -1636,7 +1636,7 @@ describe("DM message handling", () => {
 
     expect(chatInstance.processMessage).toHaveBeenCalledWith(
       adapter,
-      "slack:D_DM_CHAN:1234567890.111111",
+      "slack:D_DM_CHAN:",
       expect.any(Function),
       undefined
     );
@@ -2253,7 +2253,7 @@ describe("postMessage", () => {
     expect(client.chat.postMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         channel: "C123",
-        thread_ts: "",
+        thread_ts: undefined,
       })
     );
   });
@@ -3303,7 +3303,7 @@ describe("postChannelMessage", () => {
     expect(client.chat.postMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         channel: "C123",
-        thread_ts: "",
+        thread_ts: undefined,
       })
     );
   });

packages/adapter-slack/src/index.ts

@@ -1322,7 +1322,11 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
       return;
     }
 
-    const threadTs = event.thread_ts || event.ts;
+    // For DMs: top-level messages use empty threadTs (matches openDM subscriptions),
+    // thread replies use thread_ts for per-conversation isolation.
+    // For channels: always use thread_ts or ts for per-thread IDs.
+    const isDM = event.channel_type === "im";
+    const threadTs = isDM ? event.thread_ts || "" : event.thread_ts || event.ts;
     const threadId = this.encodeThreadId({
       channel: event.channel,
       threadTs,
@@ -2203,7 +2207,7 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
         const result = await this.client.chat.postMessage(
           this.withToken({
             channel,
-            thread_ts: threadTs,
+            thread_ts: threadTs || undefined,
             text: fallbackText, // Fallback for notifications
             blocks,
             unfurl_links: false,
@@ -2235,7 +2239,7 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
         const result = await this.client.chat.postMessage(
           this.withToken({
             channel,
-            thread_ts: threadTs,
+            thread_ts: threadTs || undefined,
             text: tableResult.text,
             blocks: tableResult.blocks,
             unfurl_links: false,
@@ -2270,7 +2274,7 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
       const result = await this.client.chat.postMessage(
         this.withToken({
           channel,
-          thread_ts: threadTs,
+          thread_ts: threadTs || undefined,
           text,
           unfurl_links: false,
           unfurl_media: false,
@@ -2887,7 +2891,7 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
       await this.client.assistant.threads.setStatus(
         this.withToken({
           channel_id: channel,
-          thread_ts: threadTs,
+          thread_ts: (threadTs || undefined) as string,
           status: status ?? "Typing...",
           loading_messages: [status ?? "Typing..."],
         })
@@ -2929,9 +2933,11 @@ export class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     this.logger.debug("Slack: starting stream", { channel, threadTs });
 
     const token = this.getToken();
+    // Guard against empty threadTs from DM subscriptions (openDM returns empty threadTs)
+    // to avoid Slack API "invalid_thread_ts" errors
     const streamer = this.client.chatStream({
       channel,
-      thread_ts: threadTs,
+      thread_ts: (threadTs || undefined) as string,
       recipient_user_id: options.recipientUserId,
       recipient_team_id: options.recipientTeamId,
       ...(options.taskDisplayMode && {

packages/integration-tests/src/replay-dm.test.ts

@@ -206,7 +206,7 @@ describe("DM Replay Tests", () => {
       expect(state.mentionMessage).not.toBeNull();
     });
 
-    it("should receive user DM as new mention (threadTs differs from openDM subscription)", async () => {
+    it("should receive user reply in DM when subscribed", async () => {
       // Step 1: Initial mention to subscribe
       await sendWebhook(slackFixtures.mention);
       expect(state.mentionMessage).not.toBeNull();
@@ -216,22 +216,23 @@ describe("DM Replay Tests", () => {
       expect(state.openDMCalled).toBe(true);
       expect(state.dmThreadId).not.toBeNull();
 
-      // Reset mention state to track the DM message
-      state.mentionMessage = null;
-
       // Step 3: User sends message in DM
-      // With the threadTs fix, top-level DM messages use event.ts as threadTs,
-      // which differs from the openDM subscription's empty threadTs.
-      // So this arrives as a new mention rather than a subscribed message.
       await sendWebhook(slackFixtures.dmMessage);
 
-      // DM arrives as new mention (isMention=true for DMs)
-      const dmMentionMsg = state.mentionMessage as Message | null;
-      expect(dmMentionMsg).not.toBeNull();
-      expect(dmMentionMsg?.text).toBe("Hey!");
+      // Verify the DM reply was captured
+      expect(state.dmMessage).not.toBeNull();
+      expect(state.dmMessage?.text).toBe("Hey!");
 
       // Verify the DM message is identified as im channel type
       expect(slackFixtures.dmMessage.event.channel_type).toBe("im");
+
+      // Verify bot responded to the DM
+      expect(mockSlackClient.chat.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: slackFixtures.dmChannelId,
+          text: expect.stringContaining("Got your DM: Hey!"),
+        })
+      );
     });
   });
 
@@ -299,13 +300,13 @@ describe("DM Replay Tests", () => {
       expect(state.mentionMessage?.text).toBe("hello hello");
     });
 
-    it("should use event.ts as threadTs for top-level DM messages", async () => {
+    it("should use empty threadTs for top-level DM messages", async () => {
       await sendWebhook(slackDirectFixtures.directDM);
 
       expect(state.mentionMessage).not.toBeNull();
-      // Top-level DM → threadId uses event.ts as threadTs
+      // Top-level DM → threadId is "slack:<channel>:" with empty threadTs
       expect(state.mentionMessage?.threadId).toBe(
-        `slack:${slackDirectFixtures.dmChannelId}:${slackDirectFixtures.directDM.event.ts}`
+        `slack:${slackDirectFixtures.dmChannelId}:`
       );
     });
 
@@ -320,24 +321,23 @@ describe("DM Replay Tests", () => {
       );
     });
 
-    it("should receive follow-up DM as new mention (different threadTs)", async () => {
+    it("should receive follow-up DM as subscribed message", async () => {
       // First DM triggers onNewMention and subscribes
       await sendWebhook(slackDirectFixtures.directDM);
       expect(state.mentionMessage).not.toBeNull();
 
-      // Reset to track the second mention
-      const firstMention = state.mentionMessage;
-      state.mentionMessage = null;
-
-      // Second DM has different ts, so gets a different threadId
-      // and is treated as a new mention rather than a subscribed message
+      // Second DM (real recorded follow-up) triggers onSubscribedMessage
       await sendWebhook(slackDirectFixtures.followUp);
 
-      const followUpMention = state.mentionMessage as Message | null;
-      expect(followUpMention).not.toBeNull();
-      expect(followUpMention?.text).toBe("cool!!");
-      // Verify it's a different thread than the first DM
-      expect(followUpMention?.threadId).not.toBe(firstMention?.threadId);
+      expect(state.dmMessage).not.toBeNull();
+      expect(state.dmMessage?.text).toBe("cool!!");
+
+      expect(mockSlackClient.chat.postMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel: slackDirectFixtures.dmChannelId,
+          text: expect.stringContaining("Follow-up: cool!!"),
+        })
+      );
     });
 
     it("should use thread_ts for DM thread replies", async () => {