> ## Documentation Index
> Fetch the complete documentation index at: https://openclaw.veiseule.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Streaming und Chunking

# Streaming + Chunking

OpenClaw hat zwei separate „Streaming“-Ebenen:

* **Block-Streaming (Kanäle):** gibt abgeschlossene **Blöcke** aus, während der Assistent schreibt. Dies sind normale Kanalnachrichten (keine Token-Deltas).
* **Token-ähnliches Streaming (nur Telegram):** aktualisiert während der Generierung eine **Entwurfsblase** mit partiellem Text; die finale Nachricht wird am Ende gesendet.

Es gibt derzeit **kein echtes Token-Streaming** zu externen Kanalnachrichten. Telegram-Entwurfs-Streaming ist die einzige Oberfläche für Teil-Streaming.

## Block-Streaming (Kanalnachrichten)

Block-Streaming sendet Assistenten-Ausgaben in groben Chunks, sobald sie verfügbar sind.

```
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)
```

Legende:

* `text_delta/events`: Modell-Stream-Ereignisse (können bei nicht-streamenden Modellen spärlich sein).
* `chunker`: `EmbeddedBlockChunker` unter Anwendung von Min-/Max-Grenzen + Trennpräferenz.
* `channel send`: tatsächliche ausgehende Nachrichten (Blockantworten).

**Steuerungen:**

* `agents.defaults.blockStreamingDefault`: `"on"`/`"off"` (standardmäßig aus).
* Kanalüberschreibungen: `*.blockStreaming` (und Varianten pro Konto), um `"on"`/`"off"` pro Kanal zu erzwingen.
* `agents.defaults.blockStreamingBreak`: `"text_end"` oder `"message_end"`.
* `agents.defaults.blockStreamingChunk`: `{ minChars, maxChars, breakPreference? }`.
* `agents.defaults.blockStreamingCoalesce`: `{ minChars?, maxChars?, idleMs? }` (gestreamte Blöcke vor dem Senden zusammenführen).
* Harte Kanalgrenze: `*.textChunkLimit` (z. B. `channels.whatsapp.textChunkLimit`).
* Kanal-Chunk-Modus: `*.chunkMode` (`length` Standard, `newline` trennt an Leerzeilen (Absatzgrenzen) vor dem Längen-Chunking).
* Discord-Soft-Cap: `channels.discord.maxLinesPerMessage` (Standard 17) teilt hohe Antworten, um UI-Clipping zu vermeiden.

**Grenzsemantik:**

* `text_end`: streamt Blöcke, sobald der Chunker ausgibt; Flush bei jedem `text_end`.
* `message_end`: wartet, bis die Assistenten-Nachricht abgeschlossen ist, und flusht dann den gepufferten Output.

`message_end` verwendet weiterhin den Chunker, wenn der gepufferte Text `maxChars` überschreitet, sodass am Ende mehrere Chunks ausgegeben werden können.

## Chunking-Algorithmus (untere/obere Grenzen)

Block-Chunking wird implementiert durch `EmbeddedBlockChunker`:

* **Untere Grenze:** nicht ausgeben, bis der Puffer >= `minChars` ist (außer erzwungen).
* **Obere Grenze:** bevorzugt Trennungen vor `maxChars`; wenn erzwungen, Trennung bei `maxChars`.
* **Trennpräferenz:** `paragraph` → `newline` → `sentence` → `whitespace` → harte Trennung.
* **Code-Fences:** niemals innerhalb von Fences trennen; wenn bei `maxChars` erzwungen, Fence schließen + erneut öffnen, um gültiges Markdown zu behalten.

`maxChars` wird auf die kanalweite `textChunkLimit` begrenzt, sodass kanalabhängige Limits nicht überschritten werden können.

## Zusammenführen (gestreamte Blöcke mergen)

Wenn Block-Streaming aktiviert ist, kann OpenClaw **aufeinanderfolgende Block-Chunks zusammenführen**, bevor sie gesendet werden. Das reduziert „Einzeilen-Spam“, während weiterhin progressiver Output bereitgestellt wird.

* Das Zusammenführen wartet auf **Leerlauf-Lücken** (`idleMs`), bevor geflusht wird.
* Puffer sind durch `maxChars` begrenzt und werden geflusht, wenn sie diese überschreiten.
* `minChars` verhindert das Senden winziger Fragmente, bis sich genügend Text angesammelt hat
  (der finale Flush sendet immer den verbleibenden Text).
* Der Joiner wird aus `blockStreamingChunk.breakPreference` abgeleitet
  (`paragraph` → `\n\n`, `newline` → `\n`, `sentence` → Leerzeichen).
* Kanalüberschreibungen sind über `*.blockStreamingCoalesce` verfügbar (einschließlich Konfigurationen pro Konto).
* Der Standardwert für das Zusammenführen `minChars` wird für Signal/Slack/Discord auf 1500 erhöht, sofern nicht überschrieben.

## Menschlich wirkendes Tempo zwischen Blöcken

Wenn Block-Streaming aktiviert ist, können Sie zwischen Blockantworten (nach dem ersten Block) eine **zufällige Pause** hinzufügen. Dadurch wirken Antworten mit mehreren Blasen natürlicher.

* Konfiguration: `agents.defaults.humanDelay` (Überschreibung pro Agent über `agents.list[].humanDelay`).
* Modi: `off` (Standard), `natural` (800–2500 ms), `custom` (`minMs`/`maxMs`).
* Gilt nur für **Blockantworten**, nicht für finale Antworten oder Werkzeug-Zusammenfassungen.

## „Chunks streamen oder alles auf einmal“

Diese Karten zu:

* **Chunks streamen:** `blockStreamingDefault: "on"` + `blockStreamingBreak: "text_end"` (Ausgabe während der Generierung). Nicht-Telegram-Kanäle benötigen zusätzlich `*.blockStreaming: true`.
* **Alles am Ende streamen:** `blockStreamingBreak: "message_end"` (einmal flushen, ggf.
* **Kein Block-Streaming:** `blockStreamingDefault: "off"` (nur finale Antwort).

**Kanalhinweis:** Für Nicht-Telegram-Kanäle ist Block-Streaming **aus, sofern**
`*.blockStreaming` nicht explizit auf `true` gesetzt ist. Telegram kann Entwürfe streamen
(`channels.telegram.streamMode`), ohne Blockantworten zu senden.

Hinweis zum Konfigurationsort: Die Standardwerte von `blockStreaming*` befinden sich unter
`agents.defaults`, nicht in der Root-Konfiguration.

## Telegram-Entwurfs-Streaming (token-ähnlich)

Telegram ist der einzige Kanal mit Entwurfs-Streaming:

* Verwendet die Bot API `sendMessage` (erstes Update) + `editMessageText` (nachfolgende Updates).
* `channels.telegram.streamMode: "partial" | "block" | "off"`.
  * `partial`: Entwurfs-Updates mit dem neuesten Stream-Text.
  * `block`: Entwurfs-Updates in gechunkten Blöcken (gleiche Chunker-Regeln).
  * `off`: kein Entwurfs-Streaming.
* Entwurfs-Chunk-Konfiguration (nur für `streamMode: "block"`): `channels.telegram.draftChunk` (Standardwerte: `minChars: 200`, `maxChars: 800`).
* Preview-Streaming ist vom Block-Streaming getrennt.
* Wenn Entwurfs-Streaming aktiv ist, deaktiviert OpenClaw das Block-Streaming für diese Antwort, um doppeltes Streaming zu vermeiden.
* Reine Text-Finalisierungen werden angewendet, indem die Preview-Nachricht direkt bearbeitet wird.
* Nicht-textuelle/komplexe Finalisierungen greifen auf die normale Zustellung der finalen Nachricht zurück.
* `/reasoning stream` schreibt die Begründung in die Entwurfsblase (nur Telegram).

```
Telegram (private + topics)
  └─ sendMessageDraft (draft bubble)
       ├─ streamMode=partial → update latest text
       └─ streamMode=block   → chunker updates draft
  └─ final reply → normal message
```

Legende:

* `preview message`: temporäre Telegram-Nachricht, die während der Generierung aktualisiert wird.
* `final edit`: direkte Bearbeitung derselben Preview-Nachricht (nur Text).