> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ag-ui.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Stream Compaction

> compactEvents utility for reducing verbose streaming sequences

# compactEvents

`compactEvents` reduces verbose streaming sequences in an event array while
preserving semantics. Use it to shrink logs before persistence or to simplify
post‑processing of Server‑Sent Events (SSE) streams.

```ts theme={null}
import { compactEvents, EventType, type BaseEvent } from "@ag-ui/client"

const compacted: BaseEvent[] = compactEvents(events)
```

## API

```ts theme={null}
function compactEvents(events: BaseEvent[]): BaseEvent[]
```

## What it does

* Text messages: Groups `TEXT_MESSAGE_START` → `TEXT_MESSAGE_CONTENT*` →
  `TEXT_MESSAGE_END` for the same `messageId`, concatenating all `delta`
  chunks into a single `TEXT_MESSAGE_CONTENT` event.
* Tool calls: Groups `TOOL_CALL_START` → `TOOL_CALL_ARGS*` → `TOOL_CALL_END`
  for the same `toolCallId`, concatenating all `delta` chunks into a single
  `TOOL_CALL_ARGS` event.
* Interleaved events: Any events that occur between a start/end pair are moved
  after that sequence so the streaming block remains contiguous.
* Pass‑through: All other events (state, custom, etc.) are preserved unchanged.

## Example

Before:

```ts theme={null}
[
  { type: EventType.TEXT_MESSAGE_START, messageId: "m1", role: "assistant" },
  { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "m1", delta: "Hello" },
  { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "m1", delta: " " },
  { type: EventType.CUSTOM, name: "thinking" },
  { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "m1", delta: "world" },
  { type: EventType.TEXT_MESSAGE_END, messageId: "m1" },
]
```

After:

```ts theme={null}
[
  { type: EventType.TEXT_MESSAGE_START, messageId: "m1", role: "assistant" },
  { type: EventType.TEXT_MESSAGE_CONTENT, messageId: "m1", delta: "Hello world" },
  { type: EventType.TEXT_MESSAGE_END, messageId: "m1" },
  { type: EventType.CUSTOM, name: "thinking" },
]
```

Tool call compaction works analogously for `TOOL_CALL_ARGS` chunks.

## When to use

* Persisting event history (store fewer frames with the same meaning)
* Preparing snapshots for analytics or export
* Reducing noise in tests or debugging output

## Metadata

Collapsing a run of delta events also folds their
[metadata](/concepts/metadata), key by key with the last write winning, so a
compacted stream produces the same metadata as the original. Metadata that
arrives after the first delta — from later deltas and from a replayed start
alike — rides the collapsed event in arrival order, because compaction emits
the start ahead of it.

Compaction reorders events so each stream's events stay together, and that
reordering is not semantics-preserving in general. Two parallel tool calls
whose ends arrive in the opposite order to their starts end up swapped in the
assistant message's `toolCalls` array, each still carrying its own metadata.
More significantly, an event that interrupts a stream is emitted after it, so a
`MESSAGES_SNAPSHOT` arriving mid-message is replayed after that message's own
events and overwrites what they produced — the appended content as much as the
merged metadata. Avoid interleaving snapshots with an open stream if you rely
on exact replay equivalence.

## Notes & limitations

* This utility focuses on message and tool‑call streams. It does not modify
  state events (`STATE_SNAPSHOT`/`STATE_DELTA`) or generate message snapshots.
* For background and broader patterns (branching, normalization), see
  [Serialization](/concepts/serialization).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.