docs(ai-chat): surface chat.toStreamTextOptions() in entry-point pages

The spread-into-streamText pattern was only mentioned on the
compaction / pending-messages / background-injection feature pages —
buried far enough that customers writing a fresh chat.agent miss it
and silently lose prepareStep wiring (compaction, steering,
background context injection). The deeper pages are the ones that
already include it; the entry points (quick-start, backend, overview)
were the gap.

quick-start: spread the call in the very first `streamText` example
plus a Warning explaining what it wires up.

backend: top-of-page Warning before the first example block, with the
canonical "spread first, override after" snippet. Existing examples
in this file keep the spread implicit for brevity now that the
warning establishes the pattern.

overview: short Warning in "What the backend accumulates" that points
back to backend.mdx.

Author: ericallam

docs/ai-chat/backend.mdx

@@ -16,6 +16,23 @@ The highest-level approach. Handles message accumulation, stop signals, turn lif
   Every `chat.agent` conversation is backed by a durable Session — `externalId` is your `chatId`, `type` is `"chat.agent"`, `taskIdentifier` is the agent's task ID. The session is the run manager: it owns the chat's runs, persists across run lifecycles, and orchestrates handoffs (idle continuation, `chat.requestUpgrade`). You rarely need to touch the session directly (`chat.stream`, `chat.messages`, `chat.stopSignal` wrap everything), but `payload.sessionId` is available if you want to reach in — e.g. `sessions.open(payload.sessionId)` to write from a sub-agent or from outside the turn loop.
 </Info>
 
+<Warning>
+  **Always spread `chat.toStreamTextOptions()` into every `streamText` call.** It wires up the `prepareStep` callback that drives [compaction](/ai-chat/compaction), [steering](/ai-chat/pending-messages), and [background injection](/ai-chat/background-injection) — features that silently no-op if the spread is missing. It also injects the system prompt set via `chat.prompt()`, the resolved model (when a registry is provided), and telemetry metadata.
+
+  Spread it **first** in the options object so any explicit overrides win:
+
+  ```ts
+  streamText({
+    ...chat.toStreamTextOptions({ registry, tools }),
+    messages,
+    abortSignal: signal,
+    // any explicit overrides go here
+  });
+  ```
+
+  Examples in this doc keep the spread implicit for brevity, but you should include it in real code.
+</Warning>
+
 ### Simple: return a StreamTextResult
 
 Return the `streamText` result from `run` and it's automatically piped to the frontend:
@@ -29,6 +46,7 @@ export const simpleChat = chat.agent({
   id: "simple-chat",
   run: async ({ messages, signal }) => {
     return streamText({
+      ...chat.toStreamTextOptions(), // prepareStep, system, telemetry — see callout above
       model: openai("gpt-4o"),
       system: "You are a helpful assistant.",
       messages,

docs/ai-chat/overview.mdx

@@ -160,6 +160,10 @@ The accumulated messages are available in:
 - `onTurnStart()` as `uiMessages` (`UIMessage[]`) — for persisting before streaming
 - `onTurnComplete()` as `uiMessages` (`UIMessage[]`) — for persisting after the response
 
+<Warning>
+  **Always spread `chat.toStreamTextOptions()` into every `streamText` call.** It wires up the `prepareStep` callback that drives compaction, steering, and background injection. Skipping the spread silently disables those features. See [Backend → chat.agent()](/ai-chat/backend#chatagent).
+</Warning>
+
 Agents appear in the **Agents** section of the dashboard (not Tasks) and can be tested via the **Playground**.
 
 ## Three approaches

docs/ai-chat/quick-start.mdx

@@ -18,9 +18,13 @@ description: "Get a working AI agent in 3 steps — define an agent, generate a
     export const myChat = chat.agent({
       id: "my-chat",
       run: async ({ messages, signal }) => {
-        // messages is ModelMessage[] — pass directly to streamText
-        // signal fires on stop or run cancel
         return streamText({
+          // Spread chat.toStreamTextOptions() FIRST — it wires up
+          // prepareStep (compaction, steering, background injection),
+          // the system prompt set via chat.prompt(), and telemetry.
+          // Skipping this is the single most common cause of subtle
+          // bugs (silent broken compaction, missing steering, etc.).
+          ...chat.toStreamTextOptions(),
           model: openai("gpt-4o"),
           messages,
           abortSignal: signal,
@@ -29,6 +33,10 @@ description: "Get a working AI agent in 3 steps — define an agent, generate a
     });
     ```
 
+    <Warning>
+      **Always spread `chat.toStreamTextOptions()` into your `streamText` call.** It wires up the `prepareStep` callback that drives compaction, mid-turn steering, and background injection — features that silently no-op if the spread is missing. Spread it **first** so any explicit overrides (e.g. a custom `prepareStep`) win.
+    </Warning>
+
     <Tip>
       For a **custom** [`UIMessage`](https://sdk.vercel.ai/docs/reference/ai-sdk-core/ui-message) subtype (typed `data-*` parts, tool map, etc.), define the agent with [`chat.withUIMessage<...>().agent({...})`](/ai-chat/types) instead of `chat.agent`.
     </Tip>