---
title: smoothStream
description: Stream transformer for smoothing text and reasoning output
url: "https://ai-sdk.dev/docs/reference/ai-sdk-core/smooth-stream"
docs_index: /llms.txt
---

> For an index of all documentation, see [/llms.txt](/llms.txt).

`smoothStream` is a utility function that creates a TransformStream
for the `streamText` `experimental_transform` option
to smooth out text and reasoning streaming by buffering and releasing complete chunks with configurable delays.
This creates a more natural reading experience when streaming text and reasoning responses.

```ts {6-9}
import { smoothStream, streamText } from 'ai';

const result = streamText({
  model,
  prompt,
  experimental_transform: smoothStream({
    delayInMs: 20, // optional: defaults to 10ms
    chunking: 'line', // optional: defaults to 'word'
  }),
});
```

## Import

```
import { smoothStream } from "ai"
```

## API Signature

### Parameters

- `delayInMs?` (`number | null`): The delay in milliseconds between outputting each chunk. Defaults to 10ms. Set to \`null\` to disable delays. The delay is skipped while the document is hidden (e.g. browser background tabs), where timer throttling would otherwise stall the stream.
- `chunking?` (`"word" | "line" | RegExp | Intl.Segmenter | (buffer: string) => string | undefined | null`): Controls how text and reasoning content is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom callback or RegExp pattern that does not match the empty string for custom chunking.

#### Word chunking caveats with non-latin languages

The word based chunking **does not work well** with the following languages that do not delimit words with spaces:

- Chinese
- Japanese
- Korean
- Vietnamese
- Thai

#### Using Intl.Segmenter (recommended)

For these languages, we recommend using `Intl.Segmenter` for proper locale-aware word segmentation.
This is the preferred approach as it provides accurate word boundaries for CJK and other languages.

`Intl.Segmenter` is available in Node.js 16+ and all modern browsers (Chrome
87+, Firefox 125+, Safari 14.1+).

```tsx title="Japanese example with Intl.Segmenter"
import { smoothStream, streamText } from 'ai';

const segmenter = new Intl.Segmenter('ja', { granularity: 'word' });

const result = streamText({
  model: "anthropic/claude-sonnet-5.5",
  prompt: 'Your prompt here',
  experimental_transform: smoothStream({
    chunking: segmenter,
  }),
});
```

```tsx title="Chinese example with Intl.Segmenter"
import { smoothStream, streamText } from 'ai';

const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });

const result = streamText({
  model: "anthropic/claude-sonnet-5.5",
  prompt: 'Your prompt here',
  experimental_transform: smoothStream({
    chunking: segmenter,
  }),
});
```

#### Regex based chunking

To use regex based chunking, pass a `RegExp` to the `chunking` option. Global
and sticky expressions are supported. The expression must not match the empty
string.

```ts
// To split on underscores:
smoothStream({
  chunking: /_+/,
});

// Also can do it like this, same behavior
smoothStream({
  chunking: /[^_]*_/,
});
```

#### Custom callback chunking

To use a custom callback for chunking, pass a function to the `chunking` option.

```ts
smoothStream({
  chunking: text => {
    const findString = 'some string';
    const index = text.indexOf(findString);

    if (index === -1) {
      return null;
    }

    return text.slice(0, index) + findString;
  },
});
```

### Returns

Returns a `TransformStream` that:

- Buffers incoming text and reasoning chunks
- Releases content when the chunking pattern is encountered
- Adds configurable delays between chunks for smooth output
- Passes through non-text/reasoning chunks (like tool calls, step-finish events) immediately

---

For a semantic overview of all documentation, see [/sitemap.md](/sitemap.md)

For an index of all available documentation, see [/llms.txt](/llms.txt)

For agent-facing discovery, including API and MCP surfaces, see [/agents.md](/agents.md)