--- read_when: - Uitleg over hoe streaming of chunking werkt in kanalen - Wijzigen van het gedrag voor blokstreaming of kanaalchunking - Dubbele/vroege blokantwoorden of streaming van kanaalvoorbeelden debuggen summary: Streamen + segmenteringsgedrag (blokantwoorden, streamen van kanaalvoorbeelden, modustoewijzing) title: Streaming en opdelen in segmenten x-i18n: generated_at: "2026-05-06T17:55:07Z" model: gpt-5.5 provider: openai source_hash: e43dc87211e764f9721c4e6c0aa69088441344e1f7c34084fd711a780a852a17 source_path: concepts/streaming.md workflow: 16 --- OpenClaw heeft twee afzonderlijke streaminglagen: - **Blokstreaming (kanalen):** emit voltooide **blokken** terwijl de assistent schrijft. Dit zijn normale kanaalberichten (geen token-delta's). - **Previewstreaming (Telegram/Discord/Slack):** werk een tijdelijk **previewbericht** bij tijdens het genereren. Er is vandaag **geen echte token-delta-streaming** naar kanaalberichten. Previewstreaming is berichtgebaseerd (verzenden + bewerkingen/toevoegingen). ## Blokstreaming (kanaalberichten) Blokstreaming verzendt assistentuitvoer in grove chunks zodra die beschikbaar komt. ``` 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) ``` Legenda: - `text_delta/events`: modelstreamgebeurtenissen (kunnen schaars zijn voor niet-streamende modellen). - `chunker`: `EmbeddedBlockChunker` die min/max-grenzen + breukvoorkeur toepast. - `channel send`: daadwerkelijke uitgaande berichten (blokantwoorden). **Bedieningselementen:** - `agents.defaults.blockStreamingDefault`: `"on"`/`"off"` (standaard uit). - Kanaaloverschrijvingen: `*.blockStreaming` (en varianten per account) om `"on"`/`"off"` per kanaal te forceren. - `agents.defaults.blockStreamingBreak`: `"text_end"` of `"message_end"`. - `agents.defaults.blockStreamingChunk`: `{ minChars, maxChars, breakPreference? }`. - `agents.defaults.blockStreamingCoalesce`: `{ minChars?, maxChars?, idleMs? }` (voeg gestreamde blokken samen vóór verzending). - Harde kanaallimiet: `*.textChunkLimit` (bijv. `channels.whatsapp.textChunkLimit`). - Kanaalchunkmodus: `*.chunkMode` (`length` standaard, `newline` splitst op lege regels (alineagrenzen) vóór chunking op lengte). - Zachte Discord-limiet: `channels.discord.maxLinesPerMessage` (standaard 17) splitst hoge antwoorden om UI-afkapping te voorkomen. **Grenssemantiek:** - `text_end`: stream blokken zodra de chunker emit; flush bij elke `text_end`. - `message_end`: wacht tot het assistentbericht klaar is en flush daarna de gebufferde uitvoer. `message_end` gebruikt nog steeds de chunker als de gebufferde tekst `maxChars` overschrijdt, dus kan het aan het einde meerdere chunks emitten. ### Medialevering met blokstreaming `MEDIA:`-directieven zijn normale leveringsmetadata. Wanneer blokstreaming vroeg een mediablok verzendt, onthoudt OpenClaw die levering voor de beurt. Als de definitieve assistentpayload dezelfde media-URL herhaalt, verwijdert de definitieve levering de dubbele media in plaats van de bijlage opnieuw te verzenden. Exact dubbele definitieve payloads worden onderdrukt. Als de definitieve payload onderscheidende tekst toevoegt rond media die al was gestreamd, verzendt OpenClaw nog steeds de nieuwe tekst terwijl de media slechts één keer wordt geleverd. Dit voorkomt dubbele spraaknotities of bestanden op kanalen zoals Telegram wanneer een agent `MEDIA:` emit tijdens streaming en de provider deze ook opneemt in het voltooide antwoord. ## Chunkingalgoritme (lage/hoge grenzen) Blokchunking wordt geïmplementeerd door `EmbeddedBlockChunker`: - **Lage grens:** emit niet totdat buffer >= `minChars` (tenzij geforceerd). - **Hoge grens:** geef de voorkeur aan splitsingen vóór `maxChars`; als geforceerd, splits op `maxChars`. - **Breukvoorkeur:** `paragraph` → `newline` → `sentence` → `whitespace` → harde breuk. - **Code fences:** splits nooit binnen fences; wanneer geforceerd op `maxChars`, sluit + heropen de fence om Markdown geldig te houden. `maxChars` wordt begrensd tot de kanaal-`textChunkLimit`, dus je kunt limieten per kanaal niet overschrijden. ## Coalescing (gestreamde blokken samenvoegen) Wanneer blokstreaming is ingeschakeld, kan OpenClaw **opeenvolgende blokchunks samenvoegen** voordat ze worden verzonden. Dit vermindert "single-line spam" terwijl nog steeds progressieve uitvoer wordt geleverd. - Coalescing wacht op **inactieve intervallen** (`idleMs`) voordat er wordt geflusht. - Buffers worden begrensd door `maxChars` en worden geflusht als ze die overschrijden. - `minChars` voorkomt dat kleine fragmenten worden verzonden totdat genoeg tekst is verzameld (definitieve flush verzendt altijd resterende tekst). - Joiner wordt afgeleid van `blockStreamingChunk.breakPreference` (`paragraph` → `\n\n`, `newline` → `\n`, `sentence` → spatie). - Kanaaloverschrijvingen zijn beschikbaar via `*.blockStreamingCoalesce` (inclusief configuraties per account). - Standaard coalesce-`minChars` wordt verhoogd naar 1500 voor Signal/Slack/Discord tenzij overschreven. ## Mensachtig tempo tussen blokken Wanneer blokstreaming is ingeschakeld, kun je een **gerandomiseerde pauze** toevoegen tussen blokantwoorden (na het eerste blok). Daardoor voelen antwoorden met meerdere bubbels natuurlijker aan. - Configuratie: `agents.defaults.humanDelay` (per agent overschrijven via `agents.list[].humanDelay`). - Modi: `off` (standaard), `natural` (800-2500ms), `custom` (`minMs`/`maxMs`). - Geldt alleen voor **blokantwoorden**, niet voor definitieve antwoorden of toolsamenvattingen. ## "Chunks streamen of alles" Dit komt overeen met: - **Chunks streamen:** `blockStreamingDefault: "on"` + `blockStreamingBreak: "text_end"` (emit terwijl je bezig bent). Niet-Telegram-kanalen hebben ook `*.blockStreaming: true` nodig. - **Alles aan het einde streamen:** `blockStreamingBreak: "message_end"` (één keer flushen, mogelijk meerdere chunks als het erg lang is). - **Geen blokstreaming:** `blockStreamingDefault: "off"` (alleen definitief antwoord). **Kanaalnotitie:** Blokstreaming is **uit tenzij** `*.blockStreaming` expliciet is ingesteld op `true`. Kanalen kunnen een live preview streamen (`channels..streaming`) zonder blokantwoorden. Herinnering aan configuratielocatie: de `blockStreaming*`-standaarden staan onder `agents.defaults`, niet in de rootconfiguratie. ## Previewstreamingmodi Canonieke sleutel: `channels..streaming` Modi: - `off`: schakel previewstreaming uit. - `partial`: één preview die wordt vervangen door de nieuwste tekst. - `block`: preview wordt bijgewerkt in gechunkte/toegevoegde stappen. - `progress`: voortgangs-/statuspreview tijdens generatie, definitief antwoord bij voltooiing. `streaming.mode: "block"` is een previewstreamingmodus voor kanalen die bewerkingen ondersteunen, zoals Discord en Telegram. Het schakelt daar geen kanaalbloklevering in. Gebruik `streaming.block.enabled` of de legacy kanaalsleutel `blockStreaming` wanneer je normale blokantwoorden wilt. Microsoft Teams is de uitzondering: het heeft geen draft-preview-bloktransport, dus `streaming.mode: "block"` wordt gekoppeld aan Teams-bloklevering in plaats van native gedeeltelijke/voortgangsstreaming. ### Kanaalkoppeling | Kanaal | `off` | `partial` | `block` | `progress` | | ---------- | ----- | --------- | ------- | ------------------------ | | Telegram | ✅ | ✅ | ✅ | bewerkbare voortgangsdraft | | Discord | ✅ | ✅ | ✅ | bewerkbare voortgangsdraft | | Slack | ✅ | ✅ | ✅ | ✅ | | Mattermost | ✅ | ✅ | ✅ | ✅ | | MS Teams | ✅ | ✅ | ✅ | native voortgangsstream | Alleen Slack: - `channels.slack.streaming.nativeTransport` schakelt Slack native streaming-API-aanroepen in of uit wanneer `channels.slack.streaming.mode="partial"` (standaard: `true`). - Slack native streaming en Slack-assistentthreadstatus vereisen een doel voor antwoordthread. Top-level DM's tonen die threadachtige preview niet, maar kunnen nog steeds Slack-draftpreviewposts en bewerkingen gebruiken. Migratie van legacy sleutel: - Telegram: legacy `streamMode` en scalaire/booleaanse `streaming`-waarden worden gedetecteerd en gemigreerd door doctor-/configcompatibiliteitspaden naar `streaming.mode`. - Discord: `streamMode` + booleaanse `streaming` blijven runtime-aliassen voor de `streaming`-enum; voer `openclaw doctor --fix` uit om persistente configuratie te herschrijven. - Slack: `streamMode` blijft een runtime-alias voor `streaming.mode`; booleaanse `streaming` blijft een runtime-alias voor `streaming.mode` plus `streaming.nativeTransport`; legacy `nativeStreaming` blijft een runtime-alias voor `streaming.nativeTransport`. Voer `openclaw doctor --fix` uit om persistente configuratie te herschrijven. ### Runtimegedrag Telegram: - Gebruikt `sendMessage` + `editMessageText`-previewupdates in DM's en groepen/topics. - Definitieve tekst bewerkt de actieve preview ter plekke; lange definitieve antwoorden hergebruiken dat bericht voor de eerste chunk en verzenden alleen de resterende chunks. - `progress`-modus houdt toolvoortgang bij in een bewerkbare statusdraft, wist die draft bij voltooiing en verzendt het definitieve antwoord via normale levering. - Als de definitieve bewerking mislukt voordat de voltooide tekst is bevestigd, gebruikt OpenClaw normale definitieve levering en ruimt het de verouderde preview op. - Previewstreaming wordt overgeslagen wanneer Telegram-blokstreaming expliciet is ingeschakeld (om dubbel streamen te voorkomen). - `/reasoning stream` kan redenering schrijven naar een tijdelijke preview die na definitieve levering wordt verwijderd. Discord: - Gebruikt verzenden + bewerken van previewberichten. - `block`-modus gebruikt draftchunking (`draftChunk`). - Previewstreaming wordt overgeslagen wanneer Discord-blokstreaming expliciet is ingeschakeld. - Definitieve media-, fout- en expliciete-antwoordpayloads annuleren wachtende previews zonder een nieuwe draft te flushen en gebruiken daarna normale levering. Slack: - `partial` kan Slack native streaming (`chat.startStream`/`append`/`stop`) gebruiken wanneer beschikbaar. - `block` gebruikt append-achtige draftpreviews. - `progress` gebruikt statuspreviewtekst, daarna het definitieve antwoord. - Top-level DM's zonder antwoordthread gebruiken draftpreviewposts en bewerkingen in plaats van Slack native streaming. - Native en draftpreviewstreaming onderdrukken blokantwoorden voor die beurt, zodat een Slack-antwoord slechts via één leveringspad wordt gestreamd. - Definitieve media-/foutpayloads en voortgangsdefinitieven maken geen wegwerp-draftberichten aan; alleen tekst-/blokdefinitieven die de preview kunnen bewerken, flushen wachtende drafttekst. Mattermost: - Streamt denken, toolactiviteit en gedeeltelijke antwoordtekst naar één draftpreviewpost die ter plekke definitief wordt gemaakt wanneer het definitieve antwoord veilig kan worden verzonden. - Valt terug op het verzenden van een nieuwe definitieve post als de previewpost is verwijderd of anderszins niet beschikbaar is op het moment van definitief maken. - Definitieve media-/foutpayloads annuleren wachtende previewupdates vóór normale levering in plaats van een tijdelijke previewpost te flushen. Matrix: - Draftpreviews worden ter plekke definitief gemaakt wanneer de definitieve tekst de previewgebeurtenis kan hergebruiken. - Alleen-media-, fout- en antwoorddoel-mismatchdefinitieven annuleren wachtende previewupdates vóór normale levering; een al zichtbare verouderde preview wordt geredacteerd. ### Previewupdates voor toolvoortgang Previewstreaming kan ook **toolvoortgangs**-updates bevatten - korte statusregels zoals "zoeken op het web", "bestand lezen" of "tool aanroepen" - die in hetzelfde previewbericht verschijnen terwijl tools worden uitgevoerd, vóór het definitieve antwoord. Dit houdt toolbeurten met meerdere stappen visueel levend in plaats van stil tussen de eerste denkpreview en het definitieve antwoord. Ondersteunde oppervlakken: - **Discord**, **Slack**, **Telegram** en **Matrix** streamen standaard toolvoortgang naar de live voorvertoningsbewerking wanneer previewstreaming actief is. Microsoft Teams gebruikt zijn native voortgangsstream in persoonlijke chats. - Telegram wordt sinds `v2026.4.22` geleverd met ingeschakelde updates voor toolvoortgang in de voorvertoning; door ze ingeschakeld te houden blijft dat uitgebrachte gedrag behouden. - **Mattermost** neemt toolactiviteit al op in zijn ene conceptvoorvertoningsbericht (zie hierboven). - Bewerkingen voor toolvoortgang volgen de actieve previewstreamingmodus; ze worden overgeslagen wanneer previewstreaming `off` is of wanneer blokstreaming het bericht heeft overgenomen. In Telegram betekent `streaming.mode: "off"` alleen definitief: algemene voortgangsberichten worden ook onderdrukt in plaats van als zelfstandige statusberichten te worden geleverd, terwijl goedkeuringsprompts, media-payloads en fouten nog steeds normaal worden gerouteerd. - Om previewstreaming te behouden maar regels voor toolvoortgang te verbergen, stel je `streaming.preview.toolProgress` voor dat kanaal in op `false`. Om regels voor toolvoortgang zichtbaar te houden terwijl opdracht-/exec-tekst wordt verborgen, stel je `streaming.preview.commandText` in op `"status"` of `streaming.progress.commandText` op `"status"`; de standaardwaarde is `"raw"` om uitgebracht gedrag te behouden. Dit beleid wordt gedeeld door concept-/voortgangskanalen die OpenClaws compacte voortgangsrenderer gebruiken, waaronder Discord, Matrix, Microsoft Teams, Mattermost, Slack-conceptvoorvertoningen en Telegram. Om voorvertoningsbewerkingen volledig uit te schakelen, stel je `streaming.mode` in op `off`. - Geselecteerde citaatantwoorden in Telegram vormen een uitzondering: wanneer `replyToMode` niet `"off"` is en geselecteerde citaattekst aanwezig is, slaat OpenClaw de antwoordvoorvertoningsstream voor die beurt over, zodat regels voor toolvoortgang in de voorvertoning niet kunnen renderen. Antwoorden op het huidige bericht zonder geselecteerde citaattekst behouden previewstreaming nog steeds. Zie de [Telegram-kanaaldocumentatie](/nl/channels/telegram) voor details. Houd voortgangsregels zichtbaar maar verberg ruwe opdracht-/exec-tekst: ```json { "channels": { "telegram": { "streaming": { "mode": "partial", "preview": { "toolProgress": true, "commandText": "status" } } } } } ``` Gebruik dezelfde vorm onder een andere compacte voortgangskanaalsleutel, bijvoorbeeld `channels.discord`, `channels.matrix`, `channels.msteams`, `channels.mattermost`, of Slack-conceptvoorvertoningen. Zet voor de voortgangsconceptmodus hetzelfde beleid onder `streaming.progress`: ```json { "channels": { "telegram": { "streaming": { "mode": "progress", "progress": { "toolProgress": true, "commandText": "status" } } } } } ``` ## Gerelateerd - [Refactor van berichtlevenscyclus](/nl/concepts/message-lifecycle-refactor) - doelontwerp voor gedeelde voorvertoning, bewerking, stream en finalisatie - [Voortgangsconcepten](/nl/concepts/progress-drafts) - zichtbare berichten over werk in uitvoering die tijdens lange beurten worden bijgewerkt - [Berichten](/nl/concepts/messages) - berichtlevenscyclus en levering - [Opnieuw proberen](/nl/concepts/retry) - gedrag voor opnieuw proberen bij leveringsfouten - [Kanalen](/nl/channels) - streamingondersteuning per kanaal