chat 4.27.0 → 4.29.0

package/docs/conversation-history.mdx

@@ -0,0 +1,137 @@
+---
+title: Conversation History
+description: Persist messages per user across every platform — for LLM context, audit, or compliance.
+type: guide
+prerequisites:
+  - /docs/state
+related:
+  - /docs/handling-events
+  - /docs/api/transcripts
+---
+
+Bots that hold context across a user's conversations need somewhere to store it. The platform's own message history won't do — a user might talk to your bot in Slack today and Discord tomorrow, and you want the same memory to follow them.
+
+`bot.transcripts` keeps a per-user transcript in your state adapter, keyed by a stable identifier you choose (an email, an internal user ID, anything that's the same person no matter where they are).
+
+## Setup
+
+You opt in by setting two fields on `ChatConfig`:
+
+```typescript title="lib/bot.ts" lineNumbers
+import { Chat } from "chat";
+import { createSlackAdapter } from "@chat-adapter/slack";
+import { createDiscordAdapter } from "@chat-adapter/discord";
+import { createRedisState } from "@chat-adapter/state-redis";
+
+const bot = new Chat({
+  userName: "mybot",
+  adapters: {
+    slack: createSlackAdapter(),
+    discord: createDiscordAdapter(),
+  },
+  state: createRedisState({ url: process.env.REDIS_URL! }),
+
+  // Resolve the cross-platform identifier for an inbound message.
+  // Return null for messages you don't want to remember.
+  identity: ({ author }) => author.email ?? null,
+
+  // Storage tuning. retention is the list TTL, refreshed on every append.
+  transcripts: {
+    retention: "30d",
+    maxPerUser: 200,
+  },
+});
+```
+
+`transcripts` and `identity` are paired — set one without the other and the constructor throws. This keeps the API loud rather than silently no-op'ing on every call.
+
+## Building LLM context
+
+The most common pattern: append the user's message, build a prompt from recent transcript entries, post the reply, append the reply too.
+
+```typescript title="lib/bot.ts" lineNumbers
+bot.onSubscribedMessage(async (thread, msg) => {
+  await bot.transcripts.append(thread, msg);
+
+  const recent = await bot.transcripts.list({
+    userKey: msg.userKey!,
+    limit: 20,
+  });
+
+  const reply = await generateReply(recent, msg);
+  await thread.post(reply);
+
+  await bot.transcripts.append(
+    thread,
+    { role: "assistant", text: reply },
+    { userKey: msg.userKey! }
+  );
+});
+```
+
+A few things worth knowing:
+
+- **`msg.userKey`** is set automatically from your `identity` resolver before your handler runs. If the resolver returned `null`, it stays `undefined` and the `append` call no-ops.
+- **Bot replies are explicit.** The SDK doesn't auto-capture `thread.post()` output — you decide what gets remembered. That's important for retries, intermediate streaming chunks, and anything you don't want feeding back into the model later.
+- **Order is chronological.** `list` returns oldest-first, ready to feed into a model. Set `limit` to keep prompts bounded.
+
+## Identity resolution
+
+`identity` runs once per inbound message during dispatch. The `author`, `message`, and `adapter` name are all available:
+
+```typescript
+identity: async ({ adapter, author, message }) => {
+  // Look up by email when the platform exposes it
+  if (author.email) {
+    return author.email;
+  }
+  // Or map a platform user to an internal ID
+  return await lookupUser(adapter, author.userId);
+}
+```
+
+Return `null` when you can't resolve a key. The SDK won't fall back to a platform-specific ID — that would silently fragment a user's transcript across platforms, which is exactly what this feature is here to prevent.
+
+If your resolver throws, the SDK logs a warning and dispatches the message without a `userKey`. Handlers still run; only the persistence is skipped.
+
+## Filtering entries
+
+`list` accepts a few filters. They compose, and they're applied after `getList` — useful for narrowing prompts without restructuring storage.
+
+```typescript
+// Recent N across all platforms
+await bot.transcripts.list({ userKey: "mike@acme.com", limit: 50 });
+
+// Single platform
+await bot.transcripts.list({ userKey: "mike@acme.com", platforms: ["slack"] });
+
+// Single thread
+await bot.transcripts.list({
+  userKey: "mike@acme.com",
+  threadId: "slack:C123:1234.5678",
+});
+
+// Only the user's own messages
+await bot.transcripts.list({ userKey: "mike@acme.com", roles: ["user"] });
+```
+
+## Deleting a user's transcript
+
+For data-subject requests or simple "forget me" flows:
+
+```typescript
+await bot.transcripts.delete({ userKey: "mike@acme.com" });
+// → { deleted: 47 }
+```
+
+This wipes every entry stored under the key. Single-entry and time-range deletes aren't part of the API — `appendToList` doesn't support them safely under concurrent writes.
+
+## Where it's stored
+
+`bot.transcripts` is backed by `StateAdapter.appendToList` / `getList` / `delete`. Every built-in state adapter (`memory`, `redis`, `ioredis`, `pg`) supports these primitives, so this works on whichever one you've already configured.
+
+Entries are written under the key `transcripts:user:{userKey}` as a capped list. `appendToList` is atomic, so concurrent inbound messages on the same user don't race.
+
+## Reference
+
+See [Transcripts](/docs/api/transcripts) for full type signatures, configuration options, and the entry shape.

package/docs/direct-messages.mdx

@@ -1,20 +1,29 @@
 ---
-title: Direct messages
+title: Direct Messages
 description: Initiate DM conversations with users programmatically.
 type: guide
 prerequisites:
   - /docs/usage
 ---
 
-Open direct message conversations with users using `bot.openDM()`. The adapter is automatically inferred from the user ID format.
+Open direct message conversations with users using `bot.openDM()`. For globally recognizable user IDs, the adapter is automatically inferred from the ID format.
 
 ## DM behavior
 
 DMs behave slightly differently from channel messages:
 
-- **Implicit mentions** — DM messages automatically set `isMention=true`, so your `onNewMention` handler fires without the user needing to @-mention the bot. This feels natural for 1:1 conversations.
+- **Direct message handlers** — if you register `onDirectMessage`, every incoming DM routes there before `onSubscribedMessage`, `onNewMention`, and pattern handlers. This keeps DM-centric flows like WhatsApp conversations, Telegram DMs, and web chat on one consistent handler.
+- **Mention fallback** — if no `onDirectMessage` handlers are registered, DMs continue through normal routing. Unsubscribed DMs are treated as mentions, so existing `onNewMention` bots keep working without requiring the user to @-mention the bot.
 - **Per-conversation threading** — Each top-level DM starts a new conversation. Thread replies within a DM continue the same conversation, giving you the same per-thread isolation as channels.
 
+## Handle incoming DMs
+
+```typescript title="lib/bot.ts" lineNumbers
+bot.onDirectMessage(async (thread, message) => {
+  await thread.post(`You said: ${message.text}`);
+});
+```
+
 ## Open a DM
 
 ### From an Author object
@@ -40,10 +49,19 @@ const dmThread = await bot.openDM("U1234567890"); // Slack
 
 | Format | Platform |
 |--------|----------|
-| `U...` | Slack |
+| `U...` / `W...` | Slack |
 | `29:...` | Teams |
 | `users/...` | Google Chat |
-| Snowflake (numeric) | Discord |
+| Numeric ID | Discord or Telegram |
+
+<Callout type="info">
+  Numeric IDs can be ambiguous when multiple numeric-ID adapters are registered. For platforms whose user IDs are not globally distinguishable, call the adapter directly and wrap the returned thread ID with `bot.thread()`.
+</Callout>
+
+```typescript title="lib/bot.ts"
+const threadId = await bot.getAdapter("whatsapp").openDM("15551234567");
+const dmThread = bot.thread(threadId);
+```
 
 ## Check if a thread is a DM
 

package/docs/ephemeral-messages.mdx

@@ -1,5 +1,5 @@
 ---
-title: Ephemeral messages
+title: Ephemeral Messages
 description: Send messages visible only to a specific user.
 type: guide
 prerequisites:

package/docs/error-handling.mdx

@@ -1,5 +1,5 @@
 ---
-title: Error handling
+title: Error Handling
 description: Handle rate limits, unsupported features, and other errors from adapters.
 type: guide
 prerequisites:
@@ -16,7 +16,19 @@ import { ChatError, RateLimitError, NotImplementedError, LockError } from "chat"
 
 ### ChatError
 
-Base error class for all SDK errors. Every error below extends `ChatError`.
+Base error class for all SDK errors. Every error below extends `ChatError`. The `code` property carries a machine-readable identifier you can branch on:
+
+| Code | Thrown by | Meaning |
+|------|-----------|---------|
+| `NOT_SUPPORTED` | `bot.openDM`, `bot.getUser` | The resolved adapter doesn't implement this method |
+| `INVALID_THREAD_ID` | `bot.thread`, internal routing | Thread ID does not match the `adapter:channel:thread` shape |
+| `INVALID_CHANNEL_ID` | `bot.channel` | Channel ID does not match the `adapter:channel` shape |
+| `ADAPTER_NOT_FOUND` | `bot.thread`, `bot.channel` | Thread/channel ID references an adapter that wasn't registered on this `Chat` instance |
+| `AMBIGUOUS_USER_ID` | `bot.getUser`, `bot.openDM` | Numeric user ID could match more than one registered adapter (Discord/Telegram/GitHub) |
+| `UNKNOWN_USER_ID_FORMAT` | `bot.getUser`, `bot.openDM` | The `userId` doesn't match any platform's known ID format |
+| `RATE_LIMITED` | Any platform call | Platform returned 429; see `RateLimitError` below |
+| `NOT_IMPLEMENTED` | Any platform call | The adapter doesn't implement this feature; see `NotImplementedError` below |
+| `LOCK_FAILED` | Inbound message routing | Distributed lock was busy; see `LockError` below |
 
 <TypeTable
   type={{
@@ -25,7 +37,7 @@ Base error class for all SDK errors. Every error below extends `ChatError`.
       type: 'string',
     },
     code: {
-      description: 'Machine-readable error code.',
+      description: 'Machine-readable error code (see table above).',
       type: 'string',
     },
     cause: {

package/docs/files.mdx

@@ -1,5 +1,5 @@
 ---
-title: File uploads
+title: File Uploads
 description: Send and receive files across chat platforms.
 type: guide
 prerequisites:
@@ -25,6 +25,26 @@ await thread.post({
 });
 ```
 
+### Typed attachments
+
+Use `attachments` when you already have normalized `Attachment` objects and the adapter supports typed outgoing media. Telegram supports one outgoing attachment per message and uses the native media method for the attachment type:
+
+```typescript title="lib/bot.ts" lineNumbers
+await thread.post({
+  markdown: "Here's the image:",
+  attachments: [
+    {
+      data: imageBuffer,
+      name: "diagram.png",
+      mimeType: "image/png",
+      type: "image",
+    },
+  ],
+});
+```
+
+Outgoing `attachments` are available on `{ raw }`, `{ markdown }`, and `{ ast }` messages. Card messages use `files` for uploads. Use `files` for generic uploads. On Telegram, `files` always upload as documents, while `attachments` preserve image, audio, video, or file media type. Use `data` or `fetchData` for private/authenticated files; URL-only attachments must be public URLs Telegram can fetch directly.
+
 ### Multiple files
 
 ```typescript title="lib/bot.ts" lineNumbers

package/docs/handling-events.mdx

@@ -16,9 +16,10 @@ Chat SDK uses an event-driven architecture. You register handlers for different
 
 When a message arrives, the SDK evaluates handlers in this order:
 
-1. **Subscribed threads** — if the thread is subscribed, `onSubscribedMessage` fires and no other message handler runs.
-2. **Mentions** — if the bot is @-mentioned in an unsubscribed thread, `onNewMention` fires.
-3. **Pattern matches** — if the message text matches any `onNewMessage` regex patterns, those handlers fire.
+1. **Direct messages** — if the thread is a DM and any `onDirectMessage` handlers are registered, they fire before `onSubscribedMessage`, `onNewMention`, and pattern handlers.
+2. **Subscribed threads** — if the thread is subscribed, `onSubscribedMessage` fires and no other message handler runs. DMs only reach this step when no `onDirectMessage` handlers are registered.
+3. **Mentions** — if the bot is @-mentioned in an unsubscribed thread, `onNewMention` fires. Unsubscribed DMs without direct handlers are treated as mentions for backward compatibility.
+4. **Pattern matches** — if the message text matches any `onNewMessage` regex patterns, those handlers fire.
 
 Reactions, slash commands, actions, and modals have their own dedicated routing and are not affected by subscription state.
 
@@ -68,7 +69,9 @@ bot.onNewMention(async (thread, message) => {
 
 ## Handling subscribed messages
 
-`onSubscribedMessage` fires for every new message in a thread your bot has subscribed to. Once subscribed, all messages (including @-mentions) route here instead of `onNewMention`.
+`onSubscribedMessage` fires for every new message in a non-DM thread your bot has subscribed to. Once subscribed, messages (including @-mentions) route here instead of `onNewMention`.
+
+If an `onDirectMessage` handler is registered, DM messages route there before subscription routing. Without a direct handler, subscribed DMs route to `onSubscribedMessage`.
 
 ```typescript title="lib/bot.ts" lineNumbers
 bot.onSubscribedMessage(async (thread, message) => {
@@ -94,7 +97,7 @@ Messages sent by the bot itself do not trigger this handler. You don't need to f
 ### Example: Conversational AI with history
 
 ```typescript title="lib/bot.ts" lineNumbers
-import { toAiMessages } from "chat";
+import { toAiMessages } from "chat/ai";
 
 bot.onSubscribedMessage(async (thread, message) => {
   await thread.startTyping();
@@ -111,7 +114,7 @@ bot.onSubscribedMessage(async (thread, message) => {
 });
 ```
 
-See [`toAiMessages`](/docs/api/to-ai-messages) for all options including multi-user name prefixing, message transforms, and attachment handling.
+See [`toAiMessages`](/docs/ai/to-ai-messages) for all options including multi-user name prefixing, message transforms, and attachment handling.
 
 ### Example: Unsubscribe on keyword
 
@@ -299,7 +302,7 @@ These handlers are specific to the Slack platform and require the Slack adapter.
 
 ### Handling assistant threads
 
-`onAssistantThreadStarted` fires when a user opens a new assistant thread in Slack. Use it with the [Slack Assistants API](/adapters/slack#slack-assistants-api) to set suggested prompts and status indicators.
+`onAssistantThreadStarted` fires when a user opens a new assistant thread in Slack. Use it with the [Slack Assistants API](/adapters/official/slack#slack-assistants-api) to set suggested prompts and status indicators.
 
 ```typescript title="lib/bot.ts" lineNumbers
 bot.onAssistantThreadStarted(async (event) => {

package/docs/index.mdx

@@ -4,7 +4,7 @@ description: A unified SDK for building chat bots across Slack, Microsoft Teams,
 type: overview
 ---
 
-Chat SDK is a TypeScript library for building chat bots that work across multiple platforms with a single codebase. Write your bot logic once and deploy it to Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, and WhatsApp.
+Chat SDK is a TypeScript library for building chat bots that work across multiple platforms with a single codebase. Write your bot logic once and deploy it to Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, WhatsApp, and Messenger.
 
 ## Why Chat SDK?
 
@@ -52,13 +52,14 @@ Each adapter factory auto-detects credentials from environment variables (`SLACK
 | Platform | Package | Mentions | Reactions | Cards | Modals | Streaming | DMs |
 |----------|---------|----------|-----------|-------|--------|-----------|-----|
 | Slack | `@chat-adapter/slack` | Yes | Yes | Yes | Yes | Native | Yes |
-| Microsoft Teams | `@chat-adapter/teams` | Yes | Read-only | Yes | No | Post+Edit | Yes |
+| Microsoft Teams | `@chat-adapter/teams` | Yes | Read-only | Yes | Yes | Native (DMs) / Buffered | Yes |
 | Google Chat | `@chat-adapter/gchat` | Yes | Yes | Yes | No | Post+Edit | Yes |
 | Discord | `@chat-adapter/discord` | Yes | Yes | Yes | No | Post+Edit | Yes |
 | Telegram | `@chat-adapter/telegram` | Yes | Yes | Partial | No | Post+Edit | Yes |
-| GitHub | `@chat-adapter/github` | Yes | Yes | No | No | No | No |
-| Linear | `@chat-adapter/linear` | Yes | Yes | No | No | No | No |
-| WhatsApp | `@chat-adapter/whatsapp` | N/A | Yes | Partial | No | No | Yes |
+| GitHub | `@chat-adapter/github` | Yes | Yes | No | No | Buffered | No |
+| Linear | `@chat-adapter/linear` | Yes | Yes | No | No | Agent sessions / Post+Edit | No |
+| WhatsApp | `@chat-adapter/whatsapp` | N/A | Yes | Partial | No | Buffered | Yes |
+| Messenger | `@chat-adapter/messenger` | Yes | Receive-only | Partial | No | Buffered | Yes |
 
 ## AI coding agent support
 
@@ -77,6 +78,7 @@ The SDK is distributed as a set of packages you install based on your needs:
 | Package | Description |
 |---------|-------------|
 | `chat` | Core SDK with `Chat` class, types, JSX runtime, and utilities |
+| `chat/ai` | [AI utilities](/docs/ai) — [`createChatTools`](/docs/ai/ai-sdk-tools) for agent operations and [`toAiMessages`](/docs/ai/to-ai-messages) for converting chat history into AI SDK prompts |
 | `@chat-adapter/slack` | Slack adapter |
 | `@chat-adapter/teams` | Microsoft Teams adapter |
 | `@chat-adapter/gchat` | Google Chat adapter |
@@ -85,6 +87,7 @@ The SDK is distributed as a set of packages you install based on your needs:
 | `@chat-adapter/github` | GitHub Issues adapter |
 | `@chat-adapter/linear` | Linear Issues adapter |
 | `@chat-adapter/whatsapp` | WhatsApp Business adapter |
+| `@chat-adapter/messenger` | Facebook Messenger adapter |
 | `@chat-adapter/state-redis` | Redis state adapter (production) |
 | `@chat-adapter/state-ioredis` | ioredis state adapter (alternative) |
 | `@chat-adapter/state-pg` | PostgreSQL state adapter (production) |

package/docs/meta.json

@@ -8,13 +8,27 @@
     "threads-messages-channels",
     "handling-events",
     "posting-messages",
+    "error-handling",
+    "testing",
+    "---AI---",
+    "...ai",
     "---Adapters---",
     "adapters",
     "state",
-    "---Features---",
+    "---Messaging---",
+    "streaming",
+    "direct-messages",
+    "ephemeral-messages",
+    "files",
+    "conversation-history",
+    "subject",
     "concurrency",
-    "...",
-    "error-handling",
+    "---Interactivity---",
+    "cards",
+    "modals",
+    "actions",
+    "slash-commands",
+    "emoji",
     "---API Reference---",
     "...api",
     "---Contributing---",

package/docs/modals.mdx

@@ -59,6 +59,7 @@ The top-level container for the form.
 | `submitLabel` | `string` (optional) | Submit button text (defaults to "Submit") |
 | `closeLabel` | `string` (optional) | Cancel button text (defaults to "Cancel") |
 | `notifyOnClose` | `boolean` (optional) | Fire `onModalClose` when user cancels |
+| `callbackUrl` | `string` (optional) | URL to POST form values to on submit |
 | `privateMetadata` | `string` (optional) | Custom context passed through to handlers |
 
 ### TextInput
@@ -248,6 +249,29 @@ bot.onModalClose("feedback_form", async (event) => {
 });
 ```
 
+## Callback URLs
+
+Like buttons, modals accept a `callbackUrl`. When the modal is submitted, the form values are POSTed to the URL:
+
+```tsx title="lib/bot.tsx" lineNumbers
+await event.openModal(
+  <Modal callbackUrl={webhook.url} callbackId="intake" title="Request Access" submitLabel="Submit">
+    <TextInput id="reason" label="Reason" multiline />
+  </Modal>
+);
+```
+
+The POST body for modal submissions:
+
+```json
+{
+  "type": "modal_submit",
+  "callbackId": "intake",
+  "values": { "reason": "Need access to production logs" },
+  "user": { "id": "U123", "name": "alice" }
+}
+```
+
 ## Pass context with privateMetadata
 
 Use `privateMetadata` to carry context from the button click through to the submit handler:

package/docs/posting-messages.mdx

@@ -24,7 +24,7 @@ This sends the string directly without any formatting conversion.
 
 ## Markdown
 
-Pass a `{ markdown }` object to have the SDK convert standard markdown to each platform's native format — mrkdwn for Slack, HTML for Teams, and so on.
+Pass a `{ markdown }` object to have the SDK render standard markdown on each platform — passed through to Slack's native `markdown_text` field, converted to HTML for Teams, and so on.
 
 ```typescript title="lib/bot.ts" lineNumbers
 await thread.post({
@@ -32,7 +32,7 @@ await thread.post({
 });
 ```
 
-Under the hood, the SDK parses the markdown into an mdast AST, then each adapter converts it to the platform's format.
+Under the hood, the SDK parses the markdown into an mdast AST, then each adapter handles it natively or converts it to the platform's format.
 
 ## AST builders
 
@@ -139,7 +139,7 @@ See the [Cards](/docs/cards) page for the full list of card components.
 
 ## Streaming
 
-Pass an AI SDK stream to `thread.post()` to stream a message in real time. The SDK uses platform-native streaming where available and falls back to post-then-edit on other platforms.
+Pass an AI SDK stream to `thread.post()` to stream a message in real time. The SDK uses platform-native streaming where available and falls back to post-then-edit or buffered delivery depending on the platform.
 
 ```typescript title="lib/bot.ts" lineNumbers
 import { ToolLoopAgent } from "ai";
@@ -151,7 +151,9 @@ await thread.post(result.fullStream);
 
 Both `fullStream` and `textStream` are supported. Use `fullStream` with multi-step agents — it preserves paragraph breaks between steps. Any `AsyncIterable<string>` also works for custom streams.
 
-For multi-turn conversations, use [`toAiMessages()`](/docs/api/to-ai-messages) to convert thread history into the `{ role, content }[]` format expected by AI SDKs.
+For multi-turn conversations, use [`toAiMessages()`](/docs/ai/to-ai-messages) to convert thread history into the `{ role, content }[]` format expected by AI SDKs.
+
+To pass platform-specific streaming options (e.g. Slack task grouping or stop blocks), wrap the stream in a [`StreamingPlan`](/docs/streaming#streaming-with-options) and post that.
 
 See the [Streaming](/docs/streaming) page for details on platform behavior and configuration.
 
@@ -166,6 +168,8 @@ await thread.post({
 });
 ```
 
+Use `attachments` on `{ raw }`, `{ markdown }`, or `{ ast }` when an adapter supports typed media uploads, such as Telegram's single image/audio/video/file upload support.
+
 See the [Files](/docs/files) page for more on attachments.
 
 ## Choosing a format
@@ -178,5 +182,7 @@ See the [Files](/docs/files) page for more on attachments.
 | Card (function) | You need buttons, fields, or structured layouts | Approval flows, dashboards |
 | Card (JSX) | Same as above, with JSX syntax preference | Same use cases as function cards |
 | `AsyncIterable` | Streaming AI responses | Chat with LLMs |
+| [`Plan`](/docs/streaming#plan-api) | Step-by-step tasks that mutate after posting | Multi-step agents, deploy progress |
+| [`StreamingPlan`](/docs/streaming#streaming-with-options) | Streaming with platform-specific options | Slack streaming with grouped tasks or stop blocks |
 
 For most cases, **AST builders** give the best balance of control and simplicity. Reach for **cards** when you need interactive elements like buttons or dropdowns.

package/docs/slash-commands.mdx

@@ -6,13 +6,13 @@ prerequisites:
   - /docs/getting-started
 related:
   - /docs/modals
-  - /adapters/slack
-  - /adapters/discord
+  - /adapters/official/slack
+  - /adapters/official/discord
 ---
 
 Slash commands let users invoke your bot with `/command` syntax. Register handlers with `onSlashCommand` to respond.
 
-Slash commands are supported on [Slack](/adapters/slack) and [Discord](/adapters/discord).
+Slash commands are supported on [Slack](/adapters/official/slack) and [Discord](/adapters/official/discord).
 
 ## Handle a specific command
 
@@ -114,7 +114,7 @@ bot.onModalSubmit("feedback_form", async (event) => {
 
 ## Discord
 
-Discord slash commands are received via [HTTP Interactions](/adapters/discord#architecture-http-interactions-vs-gateway) — no Gateway connection is needed. The adapter automatically sends a deferred response to Discord, then resolves it when your handler calls `event.channel.post()`.
+Discord slash commands are received via [HTTP Interactions](/adapters/official/discord#http-interactions-vs-gateway) — no Gateway connection is needed. The adapter automatically sends a deferred response to Discord, then resolves it when your handler calls `event.channel.post()`.
 
 ### Subcommands