From 46da76e267dc46e483aa711faa6d0d38d023cfc7 Mon Sep 17 00:00:00 2001 From: dan bachelder <325706+dbachelder@users.noreply.github.com> Date: Sun, 1 Mar 2026 09:02:06 -0800 Subject: [PATCH] fix(slack): honor replyToModeByChatType when ThreadLabel exists (#26251) * fix(slack): honor direct replyToMode when thread label exists ThreadLabel is a session/conversation label, not a reliable indicator of an actual Slack thread reply. Using it to force replyToMode="all" overrides replyToModeByChatType.direct="off" in DMs. Switch to MessageThreadId which indicates a real thread target is available, preserving expected behavior: thread replies stay threaded, normal DMs respect the configured mode. Co-Authored-By: Claude Opus 4.6 * Slack: add changelog for threading tool context fix --------- Co-authored-by: Claude Opus 4.6 Co-authored-by: Tak Hoffman <781889+Takhoffman@users.noreply.github.com> --- CHANGELOG.md | 1 + src/slack/threading-tool-context.test.ts | 50 ++++++++++++++++++++++-- src/slack/threading-tool-context.ts | 3 +- 3 files changed, 50 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1c170c23f..31dd563f3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -243,6 +243,7 @@ Docs: https://docs.openclaw.ai - Slack/Identity: thread agent outbound identity (`chat:write.customize` overrides) through the channel reply delivery path so per-agent username, icon URL, and icon emoji are applied to all Slack replies including media messages. (#27134) Thanks @hou-rong. - Slack/Threading: resolve `replyToMode` per incoming message using chat-type-aware account config (`replyToModeByChatType` and legacy `dm.replyToMode`) so DM/channel reply threading honors overrides instead of always using monitor startup defaults. (#24717) Thanks @dbachelder. - Slack/Threading: track bot participation in message threads (per account/channel/thread) so follow-up messages in those threads can be handled without requiring repeated @mentions, while preserving mention-gating behavior for unrelated threads. (#29165) Thanks @luijoc. +- Slack/Threading: stop forcing tool-call reply mode to `all` based on `ThreadLabel` alone; now force thread reply mode only when an explicit thread target exists (`MessageThreadId`/`ReplyToId`), so DM `replyToModeByChatType.direct` overrides are honored outside real thread replies. (#26251) Thanks @dbachelder. - Agents/Subagents delivery: refactor subagent completion announce dispatch into an explicit queue/direct/fallback state machine, recover outbound channel-plugin resolution in cold/stale plugin-registry states across announce/message/gateway send paths, finalize cleanup bookkeeping when announce flow rejects, and treat Telegram sends without `message_id` as delivery failures (instead of false-success `"unknown"` IDs). (#26867, #25961, #26803, #25069, #26741) Thanks @SmithLabsLLC and @docaohieu2808. - Telegram/Webhook: pre-initialize webhook bots, switch webhook processing to callback-mode JSON handling, and preserve full near-limit payload reads under delayed handlers to prevent webhook request hangs and dropped updates. (#26156) - Slack/Session threads: prevent oversized parent-session inheritance from silently bricking new thread sessions, surface embedded context-overflow empty-result failures to users, and add configurable `session.parentForkMaxTokens` (default `100000`, `0` disables). (#26912) Thanks @markshields-tl. diff --git a/src/slack/threading-tool-context.test.ts b/src/slack/threading-tool-context.test.ts index 9975a818c..c2054f103 100644 --- a/src/slack/threading-tool-context.test.ts +++ b/src/slack/threading-tool-context.test.ts @@ -86,20 +86,64 @@ describe("buildSlackThreadingToolContext", () => { expect(result.replyToMode).toBe("all"); }); - it("uses all mode when ThreadLabel is present", () => { + it("uses all mode when MessageThreadId is present", () => { const cfg = { channels: { - slack: { replyToMode: "off" }, + slack: { + replyToMode: "all", + replyToModeByChatType: { direct: "off" }, + }, }, } as OpenClawConfig; const result = buildSlackThreadingToolContext({ cfg, accountId: null, - context: { ChatType: "channel", ThreadLabel: "some-thread" }, + context: { + ChatType: "direct", + ThreadLabel: "thread-label", + MessageThreadId: "1771999998.834199", + }, }); expect(result.replyToMode).toBe("all"); }); + it("does not force all mode from ThreadLabel alone", () => { + const cfg = { + channels: { + slack: { + replyToMode: "all", + replyToModeByChatType: { direct: "off" }, + }, + }, + } as OpenClawConfig; + const result = buildSlackThreadingToolContext({ + cfg, + accountId: null, + context: { + ChatType: "direct", + ThreadLabel: "label-without-real-thread", + }, + }); + expect(result.replyToMode).toBe("off"); + }); + + it("keeps configured channel behavior when not in a thread", () => { + const cfg = { + channels: { + slack: { + replyToMode: "off", + replyToModeByChatType: { channel: "first" }, + }, + }, + } as OpenClawConfig; + const result = buildSlackThreadingToolContext({ + cfg, + accountId: null, + context: { ChatType: "channel", ThreadLabel: "label-only" }, + }); + expect(result.replyToMode).toBe("first"); + }); + it("defaults to off when no replyToMode is configured", () => { const result = buildSlackThreadingToolContext({ cfg: emptyCfg, diff --git a/src/slack/threading-tool-context.ts b/src/slack/threading-tool-context.ts index 6a8e1b57d..6841972d3 100644 --- a/src/slack/threading-tool-context.ts +++ b/src/slack/threading-tool-context.ts @@ -16,7 +16,8 @@ export function buildSlackThreadingToolContext(params: { accountId: params.accountId, }); const configuredReplyToMode = resolveSlackReplyToMode(account, params.context.ChatType); - const effectiveReplyToMode = params.context.ThreadLabel ? "all" : configuredReplyToMode; + const hasExplicitThreadTarget = params.context.MessageThreadId != null; + const effectiveReplyToMode = hasExplicitThreadTarget ? "all" : configuredReplyToMode; const threadId = params.context.MessageThreadId ?? params.context.ReplyToId; return { currentChannelId: params.context.To?.startsWith("channel:")