Streaming and chunking

• Block streaming (channels): emit completed blocks as the assistant writes. These are normal channel messages, not token deltas.
• Preview streaming (Telegram/Discord/Slack/Matrix/Mattermost/MS Teams): update a temporary preview message while generating (send + edits/appends).

​

Block streaming (channel messages)

Model output
  └─ text_delta/events
       ├─ (blockStreamingBreak=text_end)
       │    └─ chunker emits blocks as buffer grows
       └─ (blockStreamingBreak=message_end)
            └─ chunker flushes at message_end
                   └─ channel send (block replies)

• text_delta/events: model stream events (may be sparse for non-streaming models).
• chunker: EmbeddedBlockChunker applying min/max bounds + break preference.
• channel send: actual outbound messages (block replies).

• text_end: stream blocks as soon as the chunker emits; flush on each text_end.
• message_end: wait until the assistant message finishes, then flush buffered output. Still uses the chunker if the buffered text exceeds maxChars, so it can emit multiple chunks at the end.

​

Media delivery with block streaming

​

Chunking algorithm (low/high bounds)

• Low bound: don’t emit until buffer >= minChars (unless forced).
• High bound: prefer splits before maxChars; if forced, split at maxChars.
• Break preference chain: paragraph -> newline -> sentence -> whitespace -> hard break.
• Code fences: never split inside fences; when forced at maxChars, close and reopen the fence to keep Markdown valid.

​

Coalescing (merge streamed blocks)

• Coalescing waits for idle gaps (idleMs) before flushing.
• Buffers are capped by maxChars and flush if they exceed it.
• minChars prevents tiny fragments from sending until enough text accumulates (final flush always sends remaining text).
• Joiner is derived from blockStreamingChunk.breakPreference: paragraph -> \n\n, newline -> \n, sentence -> space.
• Channel overrides are available via *.blockStreamingCoalesce (including per-account configs).
• Discord, Signal, and Slack default coalesce to { minChars: 1500, idleMs: 1000 } unless overridden.

​

Human-like pacing between blocks

​

”Stream chunks or everything”

• Stream chunks: blockStreamingDefault: "on" + blockStreamingBreak: "text_end" (emit as you go). Non-Telegram channels also need *.blockStreaming: true.
• Stream everything at end: blockStreamingBreak: "message_end" (flush once, possibly multiple chunks if very long).
• No block streaming: blockStreamingDefault: "off" (only final reply).

​

Preview streaming modes

​

Channel mapping

• channels.slack.streaming.nativeTransport toggles Slack native streaming API calls (chat.startStream/chat.appendStream/chat.stopStream) when channels.slack.streaming.mode="partial" (default: true).
• Slack native streaming and Slack assistant thread status require a reply thread target. Top-level DMs do not show that thread-style preview, but can still use Slack draft preview posts and edits.

​

Legacy key migration

​

Runtime behavior

​

Telegram

• Uses sendMessage + editMessageText preview updates across DMs and group/topics; final text edits the active preview in place. Telegram ephemeral 30-second “typing” drafts (sendMessageDraft) are not used for answer streaming.
• Short initial previews are still debounced for push-notification UX, but materialize after a bounded delay so active runs do not stay visually silent.
• Long finals reuse the preview message for the first chunk and send only the remaining chunks.
• block mode rotates the preview into a new message at streaming.preview.chunk.maxChars (default 800, capped at Telegram’s 4096 edit limit); other modes grow one preview up to 4096 characters.
• progress mode keeps tool progress in an editable status draft, materializes the status label when answer streaming is active but no tool line is available yet, clears the draft at completion, and sends the final answer through normal delivery.
• If the final edit fails before the completed text is confirmed, OpenClaw uses normal final delivery and cleans up the stale preview.
• Preview streaming is skipped when Telegram block streaming is explicitly enabled, to avoid double-streaming.
• /reasoning stream can write reasoning to a transient preview that is deleted after final delivery.
• Telegram selected quote replies are an exception: when replyToMode is not "off" and selected quote text is present, OpenClaw skips the answer preview stream for that turn (the final answer must go through the native quote-reply path) so tool-progress preview lines cannot render. Current-message replies without selected quote text still keep preview streaming. See Telegram channel docs for details.

​

Discord

• Uses send + edit preview messages.
• block mode uses draft chunking (draftChunk).
• Preview streaming is skipped when Discord block streaming is explicitly enabled.
• Final media, error, and explicit-reply payloads cancel pending previews without flushing a new draft, then use normal delivery.

​

Slack

• partial can use Slack native streaming (chat.startStream/append/stop) when available.
• block uses append-style draft previews.
• progress uses status preview text, then the final answer.
• Top-level DMs without a reply thread use draft preview posts and edits instead of Slack native streaming.
• Native and draft preview streaming suppress block replies for that turn, so a Slack reply is streamed by one delivery path only.
• Final media/error payloads and progress finals do not create throwaway draft messages; only text/block finals that can edit the preview flush pending draft text.

​

Mattermost

• Streams thinking, tool activity, and partial reply text into a single draft preview post that finalizes in place when the final answer is safe to send.
• Falls back to sending a fresh final post if the preview post was deleted or is otherwise unavailable at finalize time.
• Final media/error payloads cancel pending preview updates before normal delivery instead of flushing a temporary preview post.

​

Matrix

• Draft previews finalize in place when the final text can reuse the preview event.
• Media-only, error, and reply-target-mismatch finals cancel pending preview updates before normal delivery; an already-visible stale preview is redacted.

​

Tool-progress preview updates

• Discord, Slack, Telegram, and Matrix stream tool-progress and Codex preamble updates into the live preview edit by default when preview streaming is active. Microsoft Teams uses its native progress stream in personal chats.
• Telegram has shipped with tool-progress preview updates enabled since v2026.4.22; keeping them enabled preserves that released behavior.
• Mattermost already folds tool activity into its single draft preview post (see above).
• Tool-progress edits follow the active preview streaming mode; they are skipped when preview streaming is off or when block streaming has taken over the message. On Telegram, streaming.mode: "off" is final-only: generic progress chatter is also suppressed instead of delivered as standalone status messages, while approval prompts, media payloads, and errors still route normally.
• To keep preview streaming but hide tool-progress lines, set streaming.preview.toolProgress to false for that channel (default true). To keep tool-progress lines visible while hiding command/exec text, set streaming.preview.commandText to "status" or streaming.progress.commandText to "status"; the default is "raw" to preserve released behavior. This policy is shared by draft/progress channels that use OpenClaw’s compact progress renderer, including Discord, Matrix, Microsoft Teams, Mattermost, Slack draft previews, and Telegram. To disable preview edits entirely, set streaming.mode to off.

​

Progress draft rendering

​

Commentary progress lane

• streaming.progress.commentary - render the model’s pre-tool commentary (a short “I’ll check… then…” narration) interleaved with tool lines in the progress draft.

{
  "channels": {
    "discord": {
      "streaming": { "mode": "progress", "progress": { "commentary": true } }
    }
  }
}

{
  "channels": {
    "telegram": {
      "streaming": {
        "mode": "partial",
        "preview": {
          "toolProgress": true,
          "commandText": "status"
        }
      }
    }
  }
}

{
  "channels": {
    "telegram": {
      "streaming": {
        "mode": "progress",
        "progress": {
          "toolProgress": true,
          "commandText": "status"
        }
      }
    }
  }
}

​

Related

• Message lifecycle refactor - target shared preview, edit, stream, and finalization design
• Progress drafts - visible work-in-progress messages that update during long turns
• Messages - message lifecycle and delivery
• Retry - retry behavior on delivery failure
• Channels - per-channel streaming support