[slack] [bug] resolve structured streaming team context from interactive payloads

Author: mdnanocom

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

@@ -2296,6 +2296,7 @@ interface MockableClient {
     update: ReturnType<typeof vi.fn>;
     delete: ReturnType<typeof vi.fn>;
   };
+  chatStream: ReturnType<typeof vi.fn>;
   conversations: {
     open: ReturnType<typeof vi.fn>;
     replies: ReturnType<typeof vi.fn>;

packages/chat/src/thread.test.ts

@@ -595,15 +595,33 @@ describe("ThreadImpl", () => {
       }
     });
 
-    it("should pass stream options from current message context", async () => {
+    it.each([
+      {
+        expectedTeamId: "T123",
+        label: "team_id",
+        raw: { team_id: "T123", type: "app_mention" },
+      },
+      {
+        expectedTeamId: "T234",
+        label: "team string",
+        raw: { team: "T234", type: "message" },
+      },
+      {
+        expectedTeamId: "T345",
+        label: "team.id",
+        raw: { team: { id: "T345" }, type: "block_actions" },
+      },
+    ])("should pass stream options from Slack current message context via $label", async ({
+      raw,
+      expectedTeamId,
+    }) => {
       const mockStream = vi.fn().mockResolvedValue({
         id: "msg-stream",
         threadId: "t1",
         raw: "Hello",
       });
       mockAdapter.stream = mockStream;
 
-      // Create thread with current message context
       const threadWithContext = new ThreadImpl({
         id: "slack:C123:1234.5678",
         adapter: mockAdapter,
@@ -614,7 +632,7 @@ describe("ThreadImpl", () => {
           threadId: "slack:C123:1234.5678",
           text: "test",
           formatted: { type: "root", children: [] },
-          raw: { team_id: "T123" },
+          raw,
           author: {
             userId: "U456",
             userName: "user",
@@ -630,6 +648,65 @@ describe("ThreadImpl", () => {
       const textStream = createTextStream(["Hello"]);
       await threadWithContext.post(textStream);
 
+      expect(mockStream).toHaveBeenCalledWith(
+        "slack:C123:1234.5678",
+        expect.any(Object),
+        expect.objectContaining({
+          recipientUserId: "U456",
+          recipientTeamId: expectedTeamId,
+        })
+      );
+    });
+
+    it("should derive recipientTeamId from Slack block_actions payloads for structured streams", async () => {
+      const mockStream = vi.fn().mockResolvedValue({
+        id: "msg-stream",
+        threadId: "t1",
+        raw: "Hello",
+      });
+      mockAdapter.stream = mockStream;
+
+      const threadWithActionContext = new ThreadImpl({
+        id: "slack:C123:1234.5678",
+        adapter: mockAdapter,
+        channelId: "C123",
+        stateAdapter: mockState,
+        currentMessage: {
+          id: "action-msg",
+          threadId: "slack:C123:1234.5678",
+          text: "",
+          formatted: { type: "root", children: [] },
+          raw: {
+            actions: [
+              { action_id: "select-option", selected_option: { value: "option-a" } },
+            ],
+            team: { domain: "workspace", id: "T123" },
+            type: "block_actions",
+          },
+          author: {
+            userId: "U456",
+            userName: "user",
+            fullName: "Test User",
+            isBot: false,
+            isMe: false,
+          },
+          metadata: { dateSent: new Date(), edited: false },
+          attachments: [],
+        },
+      });
+
+      async function* structuredStream(): AsyncIterable<string | StreamChunk> {
+        yield "Picking option...";
+        yield {
+          id: "task-1",
+          status: "pending",
+          title: "Thinking",
+          type: "task_update",
+        };
+      }
+
+      await threadWithActionContext.post(structuredStream());
+
       expect(mockStream).toHaveBeenCalledWith(
         "slack:C123:1234.5678",
         expect.any(Object),

packages/chat/src/thread.ts

@@ -110,6 +110,62 @@ function isAsyncIterable(
   );
 }
 
+/**
+ * Slack payloads carry the workspace ID in a few different shapes depending on
+ * the webhook type. Message events usually expose `team_id`, while interactive
+ * payloads commonly expose `team.id`.
+ */
+function extractSlackRecipientTeamId(raw: unknown): string | undefined {
+  if (!raw || typeof raw !== "object") {
+    return undefined;
+  }
+
+  const payload = raw as {
+    authorizations?: Array<{ team_id?: unknown }>;
+    team?: { id?: unknown; team_id?: unknown } | string;
+    team_id?: unknown;
+    user?: { team_id?: unknown };
+  };
+
+  if (typeof payload.team_id === "string" && payload.team_id.length > 0) {
+    return payload.team_id;
+  }
+
+  if (typeof payload.team === "string" && payload.team.length > 0) {
+    return payload.team;
+  }
+
+  if (payload.team && typeof payload.team === "object") {
+    if (typeof payload.team.id === "string" && payload.team.id.length > 0) {
+      return payload.team.id;
+    }
+
+    if (
+      typeof payload.team.team_id === "string" &&
+      payload.team.team_id.length > 0
+    ) {
+      return payload.team.team_id;
+    }
+  }
+
+  if (
+    typeof payload.user?.team_id === "string" &&
+    payload.user.team_id.length > 0
+  ) {
+    return payload.user.team_id;
+  }
+
+  const authorizationTeamId = payload.authorizations?.find(
+    (authorization) =>
+      typeof authorization.team_id === "string" &&
+      authorization.team_id.length > 0
+  )?.team_id;
+
+  return typeof authorizationTeamId === "string"
+    ? authorizationTeamId
+    : undefined;
+}
+
 export class ThreadImpl<TState = Record<string, unknown>>
   implements Thread<TState>
 {
@@ -574,12 +630,9 @@ export class ThreadImpl<TState = Record<string, unknown>>
     const options: StreamOptions = { ...callerOptions };
     if (this._currentMessage) {
       options.recipientUserId = this._currentMessage.author.userId;
-      // Extract teamId from raw Slack payload
-      const raw = this._currentMessage.raw as {
-        team_id?: string;
-        team?: string;
-      };
-      options.recipientTeamId = raw?.team_id ?? raw?.team;
+      options.recipientTeamId = extractSlackRecipientTeamId(
+        this._currentMessage.raw
+      );
     }
 
     // Use native streaming if adapter supports it