`channels.slack.streaming.nativeTransport` controls Slack native text streaming when `channels.slack.streaming.mode` is `partial` (default: `true`).

Slack native progress task cards are opt-in for progress mode. Set `channels.slack.streaming.progress.nativeTaskCards` to `true` with `channels.slack.streaming.mode="progress"` to send a Slack-native plan/task card while work is running, then update the same task card at completion. Without this flag, progress mode keeps the portable draft-preview behavior.

- A reply thread must be available for native text streaming and Slack assistant thread status to appear. Thread selection still follows `replyToMode`.

- Channel, group-chat, and top-level DM roots can still use the normal draft preview when native streaming is unavailable or no reply thread exists.

- Top-level Slack DMs stay off-thread by default, so they do not show Slack's thread-style native stream/status preview; OpenClaw posts and edits a draft preview in the DM instead.

}

```

Opt in to Slack native progress task cards:

```json5

{

channels: {

slack: {

streaming: {

mode: "progress",

progress: {

nativeTaskCards: true,

render: "rich",

},

},

},

},

}

```

Legacy keys:

- `channels.slack.streamMode` (`replace | status_final | append`) is a legacy runtime alias for `channels.slack.streaming.mode`.

});

});

it("merges canonical account streaming over top-level defaults field-by-field", () => {

const resolved = resolveSlackAccount({

cfg: {

channels: {

slack: {

streaming: {

mode: "progress",

nativeTransport: true,

preview: { toolProgress: true, commandText: "raw" },

progress: { label: "Shelling", commandText: "status" },

block: { enabled: true, coalesce: { minChars: 40, maxChars: 80, idleMs: 250 } },

},

accounts: {

work: {

botToken: "xoxb-work",

appToken: "xapp-work",

streaming: {

progress: { nativeTaskCards: true },

block: { coalesce: { idleMs: 500 } },

},

},

},

},

},

},

accountId: "work",

});

expect(resolved.config.streaming).toEqual({

mode: "progress",

nativeTransport: true,

preview: { toolProgress: true, commandText: "raw" },

progress: { label: "Shelling", commandText: "status", nativeTaskCards: true },

block: { enabled: true, coalesce: { minChars: 40, maxChars: 80, idleMs: 500 } },

});

});

it("preserves account legacy scalar streaming overrides", () => {

const resolved = resolveSlackAccount({

cfg: {

channels: {

slack: {

streaming: { mode: "progress", progress: { label: "Shelling" } },

accounts: {

work: {

botToken: "xoxb-work",

appToken: "xapp-work",

streaming: "off",

},

},

},

},

} as unknown as OpenClawConfig,

accountId: "work",

});

expect(resolved.config.streaming).toBe("off");

});

it("does not inherit default account allowFrom for named account when top-level is absent", () => {

const resolved = resolveSlackAccount({

cfg: {

return resolveAccountEntry(cfg.channels?.slack?.accounts, accountId);

}

type SlackStreamingConfig = NonNullable<SlackAccountConfig["streaming"]>;

type SlackStreamingConfigValue = SlackStreamingConfig | boolean | string;

function asStreamingConfigObject(value: unknown): SlackStreamingConfig | undefined {

return value && typeof value === "object" && !Array.isArray(value)

? (value as SlackStreamingConfig)

: undefined;

}

function asLegacyStreamingScalar(value: unknown): boolean | string | undefined {

return typeof value === "boolean" || typeof value === "string" ? value : undefined;

}

function mergeSlackStreamingConfig(

base: unknown,

account: unknown,

): SlackStreamingConfigValue | undefined {

const accountObject = asStreamingConfigObject(account);

if (account !== undefined && !accountObject) {

return asLegacyStreamingScalar(account);

}

const baseObject = asStreamingConfigObject(base);

if (base !== undefined && !baseObject) {

return accountObject ?? asLegacyStreamingScalar(base);

}

const baseConfig = baseObject;

const accountConfig = accountObject;

if (!baseConfig || !accountConfig) {

return accountConfig ?? baseConfig;

}

return {

...baseConfig,

...accountConfig,

...(baseConfig.preview || accountConfig.preview

? { preview: { ...baseConfig.preview, ...accountConfig.preview } }

: {}),

...(baseConfig.progress || accountConfig.progress

? { progress: { ...baseConfig.progress, ...accountConfig.progress } }

: {}),

...(baseConfig.block || accountConfig.block

? {

block: {

...baseConfig.block,

...accountConfig.block,

...(baseConfig.block?.coalesce || accountConfig.block?.coalesce

? {

coalesce: {

...baseConfig.block?.coalesce,

...accountConfig.block?.coalesce,

},

}

: {}),

},

}

: {}),

};

}

export function mergeSlackAccountConfig(

cfg: OpenClawConfig,

accountId: string,

): SlackAccountConfig {

return resolveMergedAccountConfig<SlackAccountConfig>({

const accountConfig = resolveSlackAccountConfig(cfg, accountId);

const merged = resolveMergedAccountConfig<SlackAccountConfig>({

channelConfig: cfg.channels?.slack as SlackAccountConfig,

accounts: cfg.channels?.slack?.accounts as Record<string, Partial<SlackAccountConfig>>,

accountId,

nestedObjectKeys: ["botLoopProtection"],

});

const streaming = mergeSlackStreamingConfig(

(cfg.channels?.slack as Record<string, unknown> | undefined)?.streaming,

(accountConfig as Record<string, unknown> | undefined)?.streaming,

);

return streaming !== undefined ? ({ ...merged, streaming } as SlackAccountConfig) : merged;

}

export function resolveSlackAccountAllowFrom(params: {

label: "Slack Progress Renderer",

help: 'Progress draft renderer: "text" uses one portable text body; "rich" renders structured Slack Block Kit fields with the same text fallback.',

},

"streaming.progress.nativeTaskCards": {

label: "Slack Native Progress Task Cards",

help: 'Opt in to Slack native task-card progress updates when channels.slack.streaming.mode="progress" and streaming.nativeTransport is enabled. Default: false.',

},

"streaming.progress.toolProgress": {

label: "Slack Progress Tool Lines",

help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery.",