chat 4.27.0 → 4.29.0

package/docs/streaming.mdx

@@ -6,7 +6,7 @@ prerequisites:
   - /docs/usage
 ---
 
-Chat SDK accepts any `AsyncIterable<string>` as a message, enabling real-time streaming of AI responses and other incremental content to chat platforms. For platforms with native streaming support (Slack), you can also stream structured `StreamChunk` objects for rich content like task progress cards and plan updates.
+Chat SDK accepts any `AsyncIterable<string>` as a message, enabling real-time streaming of AI responses and other incremental content to chat platforms. For platforms with native or structured streaming support, you can also stream `StreamChunk` objects for rich content like task progress cards and plan updates.
 
 ## AI SDK integration
 
@@ -59,9 +59,14 @@ await thread.post(stream);
 | Platform | Method | Description |
 |----------|--------|-------------|
 | Slack | Native streaming API | Uses Slack's `chatStream` for smooth, real-time updates |
-| Teams | Post + Edit | Posts a message then edits it as chunks arrive |
+| Teams | Native (DMs) / Buffered (group chats) | Uses the Teams SDK's native `stream.emit()` for direct messages; accumulates chunks and posts one final message when no native streamer is active |
 | Google Chat | Post + Edit | Posts a message then edits it as chunks arrive |
 | Discord | Post + Edit | Posts a message then edits it as chunks arrive |
+| Telegram | Post + Edit | Posts a message then edits it as chunks arrive |
+| GitHub | Buffered | Accumulates chunks and posts one final comment |
+| Linear | Agent sessions / Post + Edit | Uses agent session activities in agent-session threads; falls back to post+edit comments in issue threads |
+| WhatsApp | Buffered | Accumulates chunks and sends one final message |
+| Messenger | Buffered | Accumulates chunks and sends one final message |
 
 The post+edit fallback throttles edits to avoid rate limits. Configure the update interval when creating your `Chat` instance:
 
@@ -104,9 +109,9 @@ When streaming content that contains GFM tables (e.g. from an LLM), the SDK auto
 
 This happens transparently — no configuration needed.
 
-## Structured streaming chunks (Slack only)
+## Structured streaming chunks
 
-For Slack's native streaming API, you can yield `StreamChunk` objects alongside plain text for rich content:
+For Slack native streams and Linear agent-session streams, you can yield `StreamChunk` objects alongside plain text for rich progress updates:
 
 ```typescript title="lib/bot.ts" lineNumbers
 import type { StreamChunk } from "chat";
@@ -144,39 +149,42 @@ await thread.post(stream);
 | Type | Fields | Description |
 |------|--------|-------------|
 | `markdown_text` | `text` | Streamed text content |
-| `task_update` | `id`, `title`, `status`, `details?`, `output?` | Tool/step progress cards (`pending`, `in_progress`, `complete`, `error`) with optional extra task context |
-| `plan_update` | `title` | Plan title updates |
+| `task_update` | `id`, `title`, `status`, `details?`, `output?` | Tool/step progress updates (`pending`, `in_progress`, `complete`, `error`) with optional extra task context |
+| `plan_update` | `title` | Plan title updates on supported platforms |
 
-### Task display mode
+### Streaming with options
 
-Control how `task_update` chunks render in Slack by passing `taskDisplayMode` via the adapter's streaming API. These options are currently only available through `adapter.stream()` directly:
+Wrap a stream in a `StreamingPlan` to pass platform-specific options through `thread.post()` without dropping down to `adapter.stream()` directly:
 
 ```typescript
-const raw = message.raw as { team_id?: string; team?: string };
-await thread.adapter.stream(thread.id, stream, {
-  recipientUserId: message.author.userId,
-  recipientTeamId: raw.team_id ?? raw.team,
-  taskDisplayMode: "plan",
+import { StreamingPlan } from "chat";
+
+const planned = new StreamingPlan(stream, {
+  groupTasks: "plan",         // Slack: render task cards as a single grouped block
+  endWith: [feedbackBlock],   // Slack: Block Kit elements appended after stream stops
+  updateIntervalMs: 750,      // Post+edit cadence on supported adapters
 });
+
+await thread.post(planned);
 ```
 
-| Mode | Description |
-|------|-------------|
-| `"timeline"` | Individual task cards shown inline with text (default) |
-| `"plan"` | All tasks grouped into a single plan block |
+| Option | Platform | Description |
+|--------|----------|-------------|
+| `groupTasks` | Slack | `"timeline"` (default) renders task cards inline; `"plan"` groups them into one plan block |
+| `endWith` | Slack | Block Kit elements attached when the stream stops (e.g. retry / feedback buttons) |
+| `updateIntervalMs` | Post+edit adapters | Minimum interval between post+edit cycles in ms (default `500`) |
 
-Adapters without structured chunk support extract text from `markdown_text` chunks and ignore other types.
+Adapters without structured chunk support extract text from `markdown_text` chunks and ignore other types. Slack-only options are silently ignored on other platforms.
 
 ## Stop blocks (Slack only)
 
-When streaming in Slack, you can attach Block Kit elements to the final message using `stopBlocks`. This is useful for adding action buttons after a streamed response completes:
+Use `endWith` on `StreamingPlan` to attach Block Kit elements to the final message. This is useful for adding action buttons after a streamed response completes:
 
 ```typescript title="lib/bot.ts" lineNumbers
-const raw = message.raw as { team_id?: string; team?: string };
-await thread.adapter.stream(thread.id, textStream, {
-  recipientUserId: message.author.userId,
-  recipientTeamId: raw.team_id ?? raw.team,
-  stopBlocks: [
+import { StreamingPlan } from "chat";
+
+const planned = new StreamingPlan(textStream, {
+  endWith: [
     {
       type: "actions",
       elements: [{
@@ -187,15 +195,55 @@ await thread.adapter.stream(thread.id, textStream, {
     },
   ],
 });
+
+await thread.post(planned);
 ```
 
+## Plan API
+
+For step-by-step task progress that lives outside an LLM stream, post a `Plan` directly. `Plan` is a `PostableObject` you can mutate after posting — every mutation re-renders the block in place.
+
+```typescript title="lib/bot.ts" lineNumbers
+import { Plan } from "chat";
+
+const plan = new Plan({ initialMessage: "Researching options..." });
+await thread.post(plan);
+
+const lookup = await plan.addTask({ title: "Look up customer record" });
+// ...do work...
+await plan.updateTask("Found 3 matches");
+
+await plan.addTask({ title: "Summarize findings" });
+await plan.complete({ completeMessage: "Done!" });
+```
+
+By default `updateTask()` mutates the most recent `in_progress` task. Pass `{ id }` to target a specific task — useful when work runs in parallel or out of order:
+
+```typescript
+const fetchTask = await plan.addTask({ title: "Fetch data" });
+const transformTask = await plan.addTask({ title: "Transform" });
+
+// Update a specific task by id, even if it isn't the most recent in_progress one.
+await plan.updateTask({ id: fetchTask.id, output: "Got 42 rows" });
+await plan.updateTask({ id: transformTask.id, status: "complete" });
+```
+
+Adapters that don't support PostableObject editing (e.g. WhatsApp) render the plan as a fallback emoji-list message; the plan still posts, but mutations are no-ops.
+
+| Method | Description |
+|--------|-------------|
+| `addTask({ title, children? })` | Append a new task. The previous in-progress task is auto-completed |
+| `updateTask(input)` | Mutate the current (or `{ id }`-targeted) task's `output`, `status`, or `title` |
+| `complete({ completeMessage })` | Mark all in-progress tasks complete and update the plan title |
+| `reset({ initialMessage })` | Discard all tasks and start fresh with a new initial message — useful when re-using a plan handle for a new run |
+
 ## Streaming with conversation history
 
 Combine message history with streaming for multi-turn AI conversations.
-Use [`toAiMessages()`](/docs/api/to-ai-messages) to convert chat messages into the `{ role, content }` format expected by AI SDKs:
+Use [`toAiMessages()`](/docs/ai/to-ai-messages) to convert chat messages into the `{ role, content }` format expected by AI SDKs:
 
 ```typescript title="lib/bot.ts" lineNumbers
-import { toAiMessages } from "chat";
+import { toAiMessages } from "chat/ai";
 
 bot.onSubscribedMessage(async (thread, message) => {
   // Fetch recent messages for context
@@ -208,4 +256,4 @@ bot.onSubscribedMessage(async (thread, message) => {
 });
 ```
 
-See the [`toAiMessages` API reference](/docs/api/to-ai-messages) for all options including `includeNames`, `transformMessage`, and attachment handling.
+See the [`toAiMessages` reference](/docs/ai/to-ai-messages) for all options including `includeNames`, `transformMessage`, and attachment handling.

package/docs/subject.mdx

@@ -0,0 +1,53 @@
+---
+title: Message Subject
+description: Fetch the parent resource that a message is about.
+type: guide
+prerequisites:
+  - /docs/handling-events
+related:
+  - /docs/conversation-history
+---
+
+When your bot receives a comment on a Linear issue or GitHub PR, `message.subject` resolves the parent resource so your handler knows what the conversation is about.
+
+## Usage
+
+```typescript title="lib/bot.ts" lineNumbers
+bot.onNewMention(async (thread, message) => {
+  const subject = await message.subject;
+
+  if (subject) {
+    await thread.post(
+      `This is about: ${subject.title} (${subject.status})\n${subject.url}`
+    );
+  }
+});
+```
+
+On Linear and GitHub, comment webhooks deliver the comment text but not the parent issue or pull request — `message.subject` fetches it from the platform API on first access. The result is cached on the message instance. On chat platforms (which have no parent-resource concept), or if the API call fails, it returns `null`.
+
+See [`MessageSubject`](/docs/api/message#messagesubject) for the full type shape.
+
+### Platform support
+
+| Platform | `message.subject` returns |
+|----------|--------------------------|
+| Linear | Parent issue (from comment webhooks) |
+| GitHub | Parent issue or PR (from comment webhooks) |
+
+All other platforms return `null`.
+
+## User info
+
+For user profile details, use [`bot.getUser`](/docs/api/chat#getuser):
+
+```typescript title="lib/bot.ts" lineNumbers
+bot.onNewMention(async (thread, message) => {
+  const user = await bot.getUser(message.author);
+  if (user) {
+    await thread.post(`Hi ${user.fullName} (${user.email})`);
+  }
+});
+```
+
+For anything beyond `message.subject`, access the platform's typed API client via [`bot.getAdapter("github").octokit`](/docs/api/chat#getadapter) or [`bot.getAdapter("linear").linearClient`](/docs/api/chat#getadapter).

package/docs/testing.mdx

@@ -0,0 +1,142 @@
+---
+title: Testing
+description: Test your bot handlers and custom adapters with @chat-adapter/tests — Vitest factories, custom matchers, and a setup file.
+type: guide
+prerequisites:
+  - /docs/getting-started
+related:
+  - /docs/state
+  - /docs/handling-events
+  - /docs/contributing/testing
+---
+
+The [`@chat-adapter/tests`](https://www.npmjs.com/package/@chat-adapter/tests) package gives you Vitest factories, custom matchers, and a setup file for testing bots and custom adapters built on Chat SDK.
+
+## Install
+
+```bash
+pnpm add -D @chat-adapter/tests
+```
+
+`chat` and `vitest` are peer dependencies — they should already be in your project.
+
+## Setup file (recommended)
+
+Auto-register all matchers by adding the package's setup file to your Vitest config:
+
+```typescript title="vitest.config.ts" lineNumbers
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["@chat-adapter/tests/setup"],
+  },
+});
+```
+
+Without the setup file, register matchers manually:
+
+```typescript
+import { matchers } from "@chat-adapter/tests/matchers";
+expect.extend(matchers);
+```
+
+## Mock factories
+
+```typescript
+import {
+  createMockAdapter,
+  createMockChatInstance,
+  createMockState,
+  createTestMessage,
+  mockLogger,
+} from "@chat-adapter/tests";
+```
+
+| Factory | Returns | Notes |
+|---|---|---|
+| `createMockAdapter(name?, overrides?)` | `Adapter` | Every method is `vi.fn()` with sensible defaults |
+| `createMockChatInstance(options?)` | `ChatInstance` | Every `process*` handler is `vi.fn()`; `getState`/`getUserName`/`getLogger` wired up |
+| `createMockState()` | `MockStateAdapter` | In-memory `Map`s for subscriptions, locks, KV, lists, queues; `cache` exposes the underlying map |
+| `createTestMessage(id, text, overrides?)` | `Message` | Markdown text is parsed into the formatted AST |
+| `mockLogger` / `createMockLogger()` | `Logger` | Shared default vs fresh-per-call |
+
+## Matchers
+
+| Matcher | Asserts |
+|---|---|
+| `expect(adapter).toHavePosted(threadId, textPattern?)` | `adapter.postMessage` was called for this thread |
+| `expect(adapter).toHaveEdited(threadId, messageId, textPattern?)` | `adapter.editMessage` was called for this message |
+| `expect(adapter).toHaveDeleted(threadId, messageId)` | `adapter.deleteMessage` was called for this message |
+| `expect(adapter).toHaveReactedWith(threadId, messageId, emoji)` | `adapter.addReaction` was called with the emoji (string or `EmojiValue.name`) |
+| `expect(adapter).toHaveStartedTyping(threadId)` | `adapter.startTyping` was called for this thread |
+| `expect(adapter).toHavePostedToChannel(channelId, textPattern?)` | `adapter.postChannelMessage` was called for this channel |
+| `expect(chat).toHaveDispatched(handler)` | The named `process*` handler on the mock `ChatInstance` was called |
+| `expect(state).toBeSubscribedTo(threadId)` | `state.isSubscribed(threadId)` resolves to `true` (async — `await expect(...)`) |
+
+Text-pattern matchers extract a comparable string from `AdapterPostableMessage` — strings directly, `PostableMarkdown.markdown`, `PostableRaw.raw`, and `PostableCard.fallbackText`. AST-shaped messages and cards without `fallbackText` aren't text-matchable; assert without `textPattern` and inspect `mock.calls` directly.
+
+## Bot authors: test your handlers
+
+When you're building a bot on top of Chat SDK, the kit lets you exercise your handlers without a real Slack/Teams/etc. webhook on the wire:
+
+```typescript title="bot.test.ts"
+import { describe, expect, it } from "vitest";
+import { Chat } from "chat";
+import { createMockAdapter, createMockState } from "@chat-adapter/tests";
+
+describe("bot handlers", () => {
+  it("replies with a greeting on mention", async () => {
+    const slack = createMockAdapter("slack");
+    const state = createMockState();
+    const bot = new Chat({
+      userName: "mybot",
+      adapters: { slack },
+      state,
+    });
+
+    bot.onNewMention(async (thread) => {
+      await thread.post("hello there");
+    });
+
+    // Drive a synthesized mention through the bot…
+    // (use your adapter's webhook path or a thread-level call)
+
+    expect(slack).toHavePosted("slack:C1:t1", /hello there/);
+  });
+});
+```
+
+## Adapter authors: test webhook → dispatch
+
+When you're building a custom `Adapter`, the kit gives you a `ChatInstance` mock you can hand to your adapter and assert that webhooks route through the right `process*` hook with the right normalized payload:
+
+```typescript title="adapter.test.ts"
+import { describe, expect, it } from "vitest";
+import { createMockChatInstance } from "@chat-adapter/tests";
+import { MyAdapter } from "./adapter";
+
+describe("MyAdapter.handleWebhook", () => {
+  it("dispatches incoming messages through processMessage", async () => {
+    const chat = createMockChatInstance();
+    const adapter = new MyAdapter({ /* config */ });
+    await adapter.initialize(chat);
+
+    const request = new Request("https://example.com/webhook", {
+      method: "POST",
+      body: JSON.stringify({ /* platform-specific payload */ }),
+      headers: { "content-type": "application/json" },
+    });
+    const response = await adapter.handleWebhook(request);
+
+    expect(response.status).toBe(200);
+    expect(chat).toHaveDispatched("processMessage");
+  });
+});
+```
+
+## Adapter-specific helpers
+
+Helpers that depend on a specific platform's wire format (signed Slack webhooks, Teams claim builders, etc.) live in each adapter's own `/testing` subpath rather than in this kit, so adopting `@chat-adapter/tests` doesn't pull in adapter dependencies you don't use.
+
+If you're contributing adapters or core to this repo, see the [Testing adapters contributing guide](/docs/contributing/testing) for hand-rolled patterns used inside `packages/`.

package/docs/threads-messages-channels.mdx

@@ -13,6 +13,15 @@ related:
 
 A `Thread` represents a conversation thread on any platform. It provides methods for posting messages, managing subscriptions, and accessing message history.
 
+Thread instances are most often supplied by the SDK to your event handlers. You can also construct one explicitly from a thread ID — useful for cron jobs, workflow steps, or any other context outside an inbound webhook:
+
+```typescript title="lib/bot.ts" lineNumbers
+const thread = bot.thread("slack:C123ABC:1234567890.123456");
+await thread.post("Reminder from a cron job");
+```
+
+For DM-style conversations, use [`bot.openDM(userIdOrAuthor)`](/docs/direct-messages) instead. It resolves the right channel and thread for user ID formats the SDK can infer.
+
 ### Post a message
 
 ```typescript title="lib/bot.ts" lineNumbers
@@ -31,7 +40,7 @@ await thread.post({
 
 ### Subscribe and unsubscribe
 
-Subscriptions persist across restarts (stored in your state adapter). When a thread is subscribed, all messages route to `onSubscribedMessage`.
+Subscriptions persist across restarts (stored in your state adapter). When a non-DM thread is subscribed, all messages route to `onSubscribedMessage`. DM threads route to `onDirectMessage` first when a direct message handler is registered.
 
 ```typescript title="lib/bot.ts" lineNumbers
 await thread.subscribe();

package/docs/usage.mdx

@@ -34,7 +34,7 @@ bot.onNewMention(async (thread) => {
 ```
 
 <Callout type="info">
-  This example uses Redis. Chat SDK also supports [PostgreSQL](/docs/state/postgres) and [ioredis](/docs/state/ioredis) as production state adapters. See [State Adapters](/docs/state) for all options.
+  This example uses Redis. Chat SDK also supports [PostgreSQL](/adapters/official/postgres) and [ioredis](/adapters/official/ioredis) as production state adapters. See [State Adapters](/docs/state) for all options.
 </Callout>
 
 Each adapter factory auto-detects credentials from environment variables (`SLACK_BOT_TOKEN`, `SLACK_SIGNING_SECRET`, `REDIS_URL`, etc.), so you can get started with zero config. Pass explicit values to override.
@@ -72,6 +72,7 @@ Your event handlers work identically across all registered adapters — the SDK
 | `state` | `StateAdapter` | *required* | State adapter for subscriptions and locking |
 | `logger` | `Logger \| LogLevel` | `"info"` | Logger instance or log level (`"debug"`, `"info"`, `"warn"`, `"error"`, `"silent"`) |
 | `dedupeTtlMs` | `number` | `300000` | TTL in ms for message deduplication (5 minutes) |
+| `concurrency` | `"drop" \| "queue" \| "debounce" \| "burst" \| "concurrent" \| ConcurrencyConfig` | `"drop"` | Strategy for overlapping messages on the same thread |
 | `streamingUpdateIntervalMs` | `number` | `500` | Update interval in ms for post+edit streaming |
 | `fallbackStreamingPlaceholderText` | `string \| null` | `"..."` | Placeholder text while streaming starts. Set to `null` to skip |
 | `onLockConflict` | `'drop' \| 'force' \| (threadId, message) => 'drop' \| 'force'` | `"drop"` | Behavior when a thread lock is already held. `'force'` releases the existing lock and re-acquires it, enabling interrupt/steerability for long-running handlers |
@@ -89,6 +90,18 @@ await slack.setSuggestedPrompts(channelId, threadTs, [
 ]);
 ```
 
+For typed access to the platform's native API client, use the SDK-named getter on each adapter:
+
+```typescript title="lib/bot.ts" lineNumbers
+const slack = bot.getAdapter("slack").webClient; // WebClient
+const linear = bot.getAdapter("linear").linearClient; // LinearClient
+const github = bot.getAdapter("github").octokit; // Octokit
+```
+
+The previous `.client` getter still works as a deprecated alias on all three adapters.
+
+See [`getAdapter`](/docs/api/chat#getadapter) for multi-tenant constraints.
+
 ## Webhook routing
 
 The `webhooks` property provides type-safe handlers for each registered adapter. Wire these up to your HTTP framework's routes:
@@ -139,7 +152,7 @@ const bot = Chat.getSingleton();
 Open a DM thread with a user by passing their platform user ID or an `Author` object:
 
 ```typescript title="lib/bot.ts" lineNumbers
-const dm = await bot.openDM("slack:U123ABC");
+const dm = await bot.openDM("U123ABC");
 await dm.post("Hey! Just wanted to follow up on your request.");
 ```
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "chat",
-  "version": "4.27.0",
+  "version": "4.29.0",
   "description": "Unified chat abstraction for Slack, Teams, Google Chat, and Discord",
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,6 +14,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js"
+    },
     "./jsx-runtime": {
       "types": "./dist/jsx-runtime.d.ts",
       "import": "./dist/jsx-runtime.js"
@@ -37,9 +44,23 @@
   "devDependencies": {
     "@types/mdast": "^4.0.4",
     "@types/node": "^25.3.2",
+    "ai": "^6.0.182",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.182",
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
   },
   "repository": {
     "type": "git",

package/resources/guides/how-to-build-an-ai-agent-for-slack-with-chat-sdk-and-ai-sdk.md

@@ -86,7 +86,7 @@ Each tool has a `description` (which tells the model when to use it), an `inputS
 
 Create `lib/bot.ts` with a `ToolLoopAgent` and a `Chat` instance:
 
-`import { Chat } from "chat"; import { toAiMessages } from "chat"; import { createSlackAdapter } from "@chat-adapter/slack"; import { createRedisState } from "@chat-adapter/state-redis"; import { ToolLoopAgent } from "ai"; import { tools } from "./tools"; const agent = new ToolLoopAgent({ model: "anthropic/claude-sonnet-4.6", instructions: "You are a helpful AI assistant in a Slack workspace. " + "Answer questions clearly and use your tools when you need " + "real-time data. Keep responses concise and well-formatted for chat.", tools, }); export const bot = new Chat({ userName: "ai-agent", adapters: { slack: createSlackAdapter(), }, state: createRedisState(), }); // Handle first-time mentions bot.onNewMention(async (thread, message) => { await thread.subscribe(); const result = await agent.stream({ prompt: message.text }); await thread.post(result.fullStream); }); // Handle follow-up messages in subscribed threads bot.onSubscribedMessage(async (thread, message) => { const allMessages = []; for await (const msg of thread.allMessages) { allMessages.push(msg); } const history = await toAiMessages(allMessages); const result = await agent.stream({ messages: history }); await thread.post(result.fullStream); });`
+`import { Chat } from "chat"; import { toAiMessages } from "chat/ai"; import { createSlackAdapter } from "@chat-adapter/slack"; import { createRedisState } from "@chat-adapter/state-redis"; import { ToolLoopAgent } from "ai"; import { tools } from "./tools"; const agent = new ToolLoopAgent({ model: "anthropic/claude-sonnet-4.6", instructions: "You are a helpful AI assistant in a Slack workspace. " + "Answer questions clearly and use your tools when you need " + "real-time data. Keep responses concise and well-formatted for chat.", tools, }); export const bot = new Chat({ userName: "ai-agent", adapters: { slack: createSlackAdapter(), }, state: createRedisState(), }); // Handle first-time mentions bot.onNewMention(async (thread, message) => { await thread.subscribe(); const result = await agent.stream({ prompt: message.text }); await thread.post(result.fullStream); }); // Handle follow-up messages in subscribed threads bot.onSubscribedMessage(async (thread, message) => { const allMessages = []; for await (const msg of thread.allMessages) { allMessages.push(msg); } const history = await toAiMessages(allMessages); const result = await agent.stream({ messages: history }); await thread.post(result.fullStream); });`
 
 When someone @mentions the bot, `onNewMention` fires. The handler subscribes to the thread (to track future messages in that thread) and streams the agent's response. For follow-up messages, `onSubscribedMessage` retrieves the full thread history using `thread.allMessages`, converts it to the AI SDK message format with `toAiMessages`and passes it to the agent so it has a complete conversation context.