feat(chat): add stop handling, abort cleanup, continuation support, and reference project enhancements

- Fix onFinish race condition: await onFinishPromise so capturedResponseMessage is set before accumulation
- Add chat.isStopped() helper accessible from anywhere during a turn
- Add chat.cleanupAbortedParts() to remove incomplete tool/reasoning/text parts on stop
- Auto-cleanup aborted parts before passing to onTurnComplete
- Clean incoming messages from frontend to prevent tool_use without tool_result API errors
- Add stopped and rawResponseMessage fields to TurnCompleteEvent
- Add continuation and previousRunId fields to all lifecycle hooks and run payload
- Add span attributes (chat.id, chat.turn, chat.stopped, chat.continuation, chat.previous_run_id, etc.)
- Add webFetch tool and reasoning model support to ai-chat reference project
- Render reasoning parts in frontend chat component
- Document all new fields in ai-chat guide

Author: ericallam

docs/guides/ai-chat.mdx

@@ -240,10 +240,17 @@ export const manualChat = task({
 
 Fires once on the first turn (turn 0) before `run()` executes. Use it to create a chat record in your database.
 
+The `continuation` field tells you whether this is a brand new chat or a continuation of an existing one (where the previous run timed out or was cancelled):
+
 ```ts
 export const myChat = chat.task({
   id: "my-chat",
-  onChatStart: async ({ chatId, clientData }) => {
+  onChatStart: async ({ chatId, clientData, continuation }) => {
+    if (continuation) {
+      // Previous run ended — chat record already exists, just update session
+      return;
+    }
+    // Brand new chat — create the record
     const { userId } = clientData as { userId: string };
     await db.chat.create({
       data: { id: chatId, userId, title: "New chat" },
@@ -271,6 +278,7 @@ Fires at the start of every turn, after message accumulation and `onChatStart` (
 | `turn` | `number` | Turn number (0-indexed) |
 | `runId` | `string` | The Trigger.dev run ID |
 | `chatAccessToken` | `string` | Scoped access token for this run |
+| `continuation` | `boolean` | Whether this run is continuing an existing chat |
 
 ```ts
 export const myChat = chat.task({
@@ -312,6 +320,9 @@ Fires after each turn completes — after the response is captured, before waiti
 | `runId` | `string` | The Trigger.dev run ID |
 | `chatAccessToken` | `string` | Scoped access token for this run |
 | `lastEventId` | `string \| undefined` | Stream position for resumption. Persist this with the session. |
+| `stopped` | `boolean` | Whether the user stopped generation during this turn |
+| `continuation` | `boolean` | Whether this run is continuing an existing chat |
+| `rawResponseMessage` | `UIMessage \| undefined` | The raw assistant response before abort cleanup (same as `responseMessage` when not stopped) |
 
 ```ts
 export const myChat = chat.task({
@@ -679,6 +690,66 @@ export const myChat = chat.task({
   Use `signal` (the combined signal) in most cases. The separate `stopSignal` and `cancelSignal` are only needed if you want different behavior for stop vs cancel.
 </Tip>
 
+### Detecting stop in callbacks
+
+The `onTurnComplete` event includes a `stopped` boolean that indicates whether the user stopped generation during that turn:
+
+```ts
+export const myChat = chat.task({
+  id: "my-chat",
+  onTurnComplete: async ({ chatId, uiMessages, stopped }) => {
+    await db.chat.update({
+      where: { id: chatId },
+      data: { messages: uiMessages, lastStoppedAt: stopped ? new Date() : undefined },
+    });
+  },
+  run: async ({ messages, signal }) => {
+    return streamText({ model: openai("gpt-4o"), messages, abortSignal: signal });
+  },
+});
+```
+
+You can also check stop status from **anywhere** during a turn using `chat.isStopped()`. This is useful inside `streamText`'s `onFinish` callback where the AI SDK's `isAborted` flag can be unreliable (e.g. when using `createUIMessageStream` + `writer.merge()`):
+
+```ts
+import { chat } from "@trigger.dev/sdk/ai";
+import { streamText } from "ai";
+
+export const myChat = chat.task({
+  id: "my-chat",
+  run: async ({ messages, signal }) => {
+    return streamText({
+      model: openai("gpt-4o"),
+      messages,
+      abortSignal: signal,
+      onFinish: ({ isAborted }) => {
+        // isAborted may be false even after stop when using createUIMessageStream
+        const wasStopped = isAborted || chat.isStopped();
+        if (wasStopped) {
+          // handle stop — e.g. log analytics
+        }
+      },
+    });
+  },
+});
+```
+
+### Cleaning up aborted messages
+
+When stop happens mid-stream, the captured response message can contain parts in an incomplete state — tool calls stuck in `partial-call`, reasoning blocks still marked as `streaming`, etc. These can cause UI issues like permanent spinners.
+
+`chat.task` automatically cleans up the `responseMessage` when stop is detected before passing it to `onTurnComplete`. If you use `chat.pipe()` manually and capture response messages yourself, use `chat.cleanupAbortedParts()`:
+
+```ts
+const cleaned = chat.cleanupAbortedParts(rawResponseMessage);
+```
+
+This removes tool invocation parts stuck in `partial-call` state and marks any `streaming` text or reasoning parts as `done`.
+
+<Note>
+  Stop signal delivery is best-effort. There is a small race window where the model may finish before the stop signal arrives, in which case the turn completes normally with `stopped: false`. This is expected and does not require special handling.
+</Note>
+
 ## Client data and metadata
 
 ### Transport-level client data
@@ -982,6 +1053,7 @@ Plus all standard [TaskOptions](/tasks/overview) — `retry`, `queue`, `machine`
 | `trigger` | `"submit-message" \| "regenerate-message"` | What triggered the request |
 | `messageId` | `string \| undefined` | Message ID (for regenerate) |
 | `clientData` | Typed by `clientDataSchema` | Custom data from the frontend (typed when schema is provided) |
+| `continuation` | `boolean` | Whether this run is continuing an existing chat (previous run ended) |
 | `signal` | `AbortSignal` | Combined stop + cancel signal |
 | `cancelSignal` | `AbortSignal` | Cancel-only signal |
 | `stopSignal` | `AbortSignal` | Stop-only signal (per-turn) |
@@ -1001,6 +1073,8 @@ See [onTurnComplete](#onturncomplete) for the full field reference.
 | `chat.setTurnTimeout(duration)` | Override turn timeout at runtime (e.g. `"2h"`) |
 | `chat.setTurnTimeoutInSeconds(seconds)` | Override turn timeout at runtime (in seconds) |
 | `chat.setWarmTimeoutInSeconds(seconds)` | Override warm timeout at runtime |
+| `chat.isStopped()` | Check if the current turn was stopped by the user (works anywhere during a turn) |
+| `chat.cleanupAbortedParts(message)` | Remove incomplete parts from a stopped response message |
 
 ## Self-hosting