chat 4.23.0 → 4.25.0

package/dist/index.js

@@ -59,7 +59,7 @@ import {
   toModalElement,
   toPlainText,
   walkAst
-} from "./chunk-JW7GYSMH.js";
+} from "./chunk-OPV5U4WG.js";
 
 // src/ai.ts
 var TEXT_MIME_PREFIXES = [
@@ -380,6 +380,27 @@ var Message = class _Message {
   }
 };
 
+// src/postable-object.ts
+var POSTABLE_OBJECT = /* @__PURE__ */ Symbol.for("chat.postable");
+function isPostableObject(value) {
+  return typeof value === "object" && value !== null && value.$$typeof === POSTABLE_OBJECT;
+}
+async function postPostableObject(obj, adapter, threadId, postFn, logger) {
+  const context = (raw) => ({
+    adapter,
+    logger,
+    messageId: raw.id,
+    threadId: raw.threadId ?? threadId
+  });
+  if (obj.isSupported(adapter) && adapter.postObject) {
+    const raw = await adapter.postObject(threadId, obj.kind, obj.getPostData());
+    obj.onPosted(context(raw));
+  } else {
+    const raw = await postFn(threadId, obj.getFallbackText());
+    obj.onPosted(context(raw));
+  }
+}
+
 // src/errors.ts
 var ChatError = class extends Error {
   code;
@@ -605,6 +626,10 @@ var ChannelImpl = class _ChannelImpl {
     };
   }
   async post(message) {
+    if (isPostableObject(message)) {
+      await this.handlePostableObject(message);
+      return message;
+    }
     if (isAsyncIterable(message)) {
       let accumulated = "";
       for await (const chunk of fromFullStream(message)) {
@@ -624,6 +649,14 @@ var ChannelImpl = class _ChannelImpl {
     }
     return this.postSingleMessage(postable);
   }
+  async handlePostableObject(obj) {
+    await postPostableObject(
+      obj,
+      this.adapter,
+      this.id,
+      (threadId, message) => this.adapter.postChannelMessage ? this.adapter.postChannelMessage(threadId, message) : this.adapter.postMessage(threadId, message)
+    );
+  }
   async postSingleMessage(postable) {
     const rawMessage = this.adapter.postChannelMessage ? await this.adapter.postChannelMessage(this.id, postable) : await this.adapter.postMessage(this.id, postable);
     const sent = this.createSentMessage(
@@ -877,6 +910,12 @@ var StreamingMarkdownRenderer = class {
   fenceToggles = 0;
   /** Incomplete trailing line buffer for incremental fence tracking. */
   incompleteLine = "";
+  options;
+  constructor(options = {}) {
+    this.options = {
+      wrapTablesForAppend: options.wrapTablesForAppend ?? true
+    };
+  }
   /** Append a chunk from the LLM stream. */
   push(chunk) {
     this.accumulated += chunk;
@@ -928,30 +967,31 @@ var StreamingMarkdownRenderer = class {
    * Get text safe for append-only streaming (e.g. Slack native streaming).
    *
    * - Holds back unconfirmed table headers until separator arrives.
-   * - Wraps confirmed tables in code fences so pipes render as literal
-   *   text (not broken mrkdwn). The code fence is left OPEN while
-   *   the table is still streaming, keeping output monotonic for deltas.
+   * - Optionally wraps confirmed tables in code fences so pipes render as
+   *   literal text on append-only surfaces that lack native table support.
+   *   The code fence is left OPEN while the table is still streaming,
+   *   keeping output monotonic for deltas.
    * - Holds back unclosed inline markers (**, *, ~~, `, [).
    * - The final editMessage replaces everything with properly formatted text.
    */
   getCommittableText() {
     if (this.finished) {
-      return wrapTablesForAppend(this.accumulated, true);
+      return this.formatAppendOnlyText(this.accumulated, true);
     }
     let text2 = this.accumulated;
     if (text2.length > 0 && !text2.endsWith("\n")) {
       const lastNewline = text2.lastIndexOf("\n");
       const withoutIncompleteLine = lastNewline >= 0 ? text2.slice(0, lastNewline + 1) : "";
       if (isInsideCodeFence(withoutIncompleteLine)) {
-        return wrapTablesForAppend(text2);
+        return this.formatAppendOnlyText(text2);
       }
       text2 = withoutIncompleteLine;
     }
     if (isInsideCodeFence(text2)) {
-      return wrapTablesForAppend(text2);
+      return this.formatAppendOnlyText(text2);
     }
     const committed = getCommittablePrefix(text2);
-    const wrapped = wrapTablesForAppend(committed);
+    const wrapped = this.formatAppendOnlyText(committed);
     if (isInsideCodeFence(wrapped)) {
       return wrapped;
     }
@@ -967,6 +1007,12 @@ var StreamingMarkdownRenderer = class {
     this.dirty = true;
     return this.render();
   }
+  formatAppendOnlyText(text2, closeFences = false) {
+    if (!this.options.wrapTablesForAppend) {
+      return text2;
+    }
+    return wrapTablesForAppend(text2, closeFences);
+  }
 };
 var INLINE_MARKER_CHARS = /* @__PURE__ */ new Set(["*", "~", "`", "["]);
 function isClean(text2) {
@@ -1308,6 +1354,10 @@ var ThreadImpl = class _ThreadImpl {
     await this._stateAdapter.unsubscribe(this.id);
   }
   async post(message) {
+    if (isPostableObject(message)) {
+      await this.handlePostableObject(message);
+      return message;
+    }
     if (isAsyncIterable2(message)) {
       return this.handleStream(message);
     }
@@ -1330,6 +1380,15 @@ var ThreadImpl = class _ThreadImpl {
     }
     return result;
   }
+  async handlePostableObject(obj) {
+    await postPostableObject(
+      obj,
+      this.adapter,
+      this.id,
+      (threadId, message) => this.adapter.postMessage(threadId, message),
+      this._logger
+    );
+  }
   async postEphemeral(user, message, options) {
     const { fallbackToDM } = options;
     const userId = typeof user === "string" ? user : user.userId;
@@ -2243,7 +2302,7 @@ var Chat = class {
    * Handles waitUntil registration and error catching internally.
    */
   processAction(event, options) {
-    const task = this.handleActionEvent(event).catch((err) => {
+    const task = this.handleActionEvent(event, options).catch((err) => {
       this.logger.error("Action processing error", {
         error: err,
         actionId: event.actionId,
@@ -2253,6 +2312,7 @@ var Chat = class {
     if (options?.waitUntil) {
       options.waitUntil(task);
     }
+    return task;
   }
   async processModalSubmit(event, contextId, _options) {
     const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
@@ -2307,7 +2367,7 @@ var Chat = class {
    * Handles waitUntil registration and error catching internally.
    */
   processSlashCommand(event, options) {
-    const task = this.handleSlashCommandEvent(event).catch((err) => {
+    const task = this.handleSlashCommandEvent(event, options).catch((err) => {
       this.logger.error("Slash command processing error", {
         error: err,
         command: event.command,
@@ -2382,7 +2442,7 @@ var Chat = class {
   /**
    * Handle a slash command event internally.
    */
-  async handleSlashCommandEvent(event) {
+  async handleSlashCommandEvent(event, options) {
     this.logger.debug("Incoming slash command", {
       adapter: event.adapter.name,
       command: event.command,
@@ -2404,11 +2464,11 @@ var Chat = class {
       ...event,
       channel,
       openModal: async (modal) => {
-        if (!event.triggerId) {
+        if (!(event.triggerId || options?.onOpenModal)) {
           this.logger.warn("Cannot open modal: no triggerId available");
           return void 0;
         }
-        if (!event.adapter.openModal) {
+        if (!(options?.onOpenModal || event.adapter.openModal)) {
           this.logger.warn(
             `Cannot open modal: ${event.adapter.name} does not support modals`
           );
@@ -2423,18 +2483,24 @@ var Chat = class {
           modalElement = converted;
         }
         const contextId = crypto.randomUUID();
-        this.storeModalContext(
+        await this.storeModalContext(
           event.adapter.name,
           contextId,
           void 0,
           void 0,
           channel
         );
-        return event.adapter.openModal(
-          event.triggerId,
-          modalElement,
-          contextId
-        );
+        if (options?.onOpenModal) {
+          return options.onOpenModal(modalElement, contextId);
+        }
+        if (event.triggerId && event.adapter.openModal) {
+          return event.adapter.openModal(
+            event.triggerId,
+            modalElement,
+            contextId
+          );
+        }
+        return void 0;
       }
     };
     this.logger.debug("Checking slash command handlers", {
@@ -2459,19 +2525,21 @@ var Chat = class {
    * Store modal context server-side with a context ID.
    * Called when opening a modal to preserve thread/message/channel for the submit handler.
    */
-  storeModalContext(adapterName, contextId, thread, message, channel) {
+  async storeModalContext(adapterName, contextId, thread, message, channel) {
     const key = `modal-context:${adapterName}:${contextId}`;
     const context = {
       thread: thread?.toJSON(),
       message: message?.toJSON(),
       channel: channel?.toJSON()
     };
-    this._stateAdapter.set(key, context, MODAL_CONTEXT_TTL_MS).catch((err) => {
+    try {
+      await this._stateAdapter.set(key, context, MODAL_CONTEXT_TTL_MS);
+    } catch (err) {
       this.logger.error("Failed to store modal context", {
         contextId,
         error: err
       });
-    });
+    }
   }
   /**
    * Retrieve and delete modal context from server-side storage.
@@ -2494,6 +2562,7 @@ var Chat = class {
         relatedChannel: void 0
       };
     }
+    await this._stateAdapter.delete(key);
     const adapter = this.adapters.get(adapterName);
     let relatedThread;
     if (stored.thread) {
@@ -2513,7 +2582,7 @@ var Chat = class {
   /**
    * Handle an action event internally.
    */
-  async handleActionEvent(event) {
+  async handleActionEvent(event, options) {
     this.logger.debug("Incoming action", {
       adapter: event.adapter.name,
       actionId: event.actionId,
@@ -2549,11 +2618,11 @@ var Chat = class {
       ...event,
       thread,
       openModal: async (modal) => {
-        if (!event.triggerId) {
+        if (!(event.triggerId || options?.onOpenModal)) {
           this.logger.warn("Cannot open modal: no triggerId available");
           return void 0;
         }
-        if (!event.adapter.openModal) {
+        if (!(options?.onOpenModal || event.adapter.openModal)) {
           this.logger.warn(
             `Cannot open modal: ${event.adapter.name} does not support modals`
           );
@@ -2589,18 +2658,24 @@ var Chat = class {
         }
         const contextId = crypto.randomUUID();
         const channel = thread ? thread.channel : void 0;
-        this.storeModalContext(
+        await this.storeModalContext(
           event.adapter.name,
           contextId,
           thread ? thread : void 0,
           message,
           channel
         );
-        return event.adapter.openModal(
-          event.triggerId,
-          modalElement,
-          contextId
-        );
+        if (options?.onOpenModal) {
+          return options.onOpenModal(modalElement, contextId);
+        }
+        if (event.triggerId && event.adapter.openModal) {
+          return event.adapter.openModal(
+            event.triggerId,
+            modalElement,
+            contextId
+          );
+        }
+        return void 0;
       }
     };
     this.logger.debug("Checking action handlers", {
@@ -3198,8 +3273,7 @@ var Chat = class {
     }
   }
   createThread(adapter, threadId, initialMessage, isSubscribedContext = false) {
-    const parts = threadId.split(":");
-    const channelId = parts[1] || "";
+    const channelId = adapter.channelIdFromThreadId(threadId);
     const isDM = adapter.isDM?.(threadId) ?? false;
     const channelVisibility = adapter.getChannelVisibility?.(threadId) ?? "unknown";
     return new ThreadImpl({
@@ -3296,6 +3370,220 @@ var Chat = class {
   }
 };
 
+// src/plan.ts
+function contentToPlainText(content) {
+  if (!content) {
+    return "";
+  }
+  if (Array.isArray(content)) {
+    return content.join(" ").trim();
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  if ("markdown" in content) {
+    return toPlainText(parseMarkdown(content.markdown));
+  }
+  if ("ast" in content) {
+    return toPlainText(content.ast);
+  }
+  return "";
+}
+var Plan = class {
+  $$typeof = POSTABLE_OBJECT;
+  kind = "plan";
+  _model;
+  _bound = null;
+  constructor(options) {
+    const title = contentToPlainText(options.initialMessage) || "Plan";
+    const firstTask = {
+      id: crypto.randomUUID(),
+      title,
+      status: "in_progress"
+    };
+    this._model = { title, tasks: [firstTask] };
+  }
+  isSupported(adapter) {
+    return !!adapter.postObject && !!adapter.editObject;
+  }
+  getPostData() {
+    return this._model;
+  }
+  getFallbackText() {
+    const lines = [];
+    lines.push(`\u{1F4CB} ${this._model.title || "Plan"}`);
+    for (const task of this._model.tasks) {
+      const statusIcons = {
+        complete: "\u2705",
+        in_progress: "\u{1F504}",
+        error: "\u274C"
+      };
+      const statusIcon = statusIcons[task.status] ?? "\u2B1C";
+      lines.push(`${statusIcon} ${task.title}`);
+    }
+    return lines.join("\n");
+  }
+  onPosted(context) {
+    this._bound = {
+      adapter: context.adapter,
+      fallback: !this.isSupported(context.adapter),
+      logger: context.logger,
+      messageId: context.messageId,
+      threadId: context.threadId,
+      updateChain: Promise.resolve()
+    };
+  }
+  get id() {
+    return this._bound?.messageId ?? "";
+  }
+  get threadId() {
+    return this._bound?.threadId ?? "";
+  }
+  get title() {
+    return this._model.title;
+  }
+  get tasks() {
+    return this._model.tasks.map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status
+    }));
+  }
+  get currentTask() {
+    let current;
+    for (let i = this._model.tasks.length - 1; i >= 0; i--) {
+      if (this._model.tasks[i].status === "in_progress") {
+        current = this._model.tasks[i];
+        break;
+      }
+    }
+    current ??= this._model.tasks.at(-1);
+    if (!current) {
+      return null;
+    }
+    return { id: current.id, title: current.title, status: current.status };
+  }
+  async addTask(options) {
+    if (!this.canMutate()) {
+      return null;
+    }
+    const title = contentToPlainText(options.title) || "Task";
+    for (const task of this._model.tasks) {
+      if (task.status === "in_progress") {
+        task.status = "complete";
+      }
+    }
+    const nextTask = {
+      id: crypto.randomUUID(),
+      title,
+      status: "in_progress",
+      details: options.children
+    };
+    this._model.tasks.push(nextTask);
+    this._model.title = title;
+    await this.enqueueEdit();
+    return { id: nextTask.id, title: nextTask.title, status: nextTask.status };
+  }
+  async updateTask(update) {
+    if (!this.canMutate()) {
+      return null;
+    }
+    let current;
+    for (let i = this._model.tasks.length - 1; i >= 0; i--) {
+      if (this._model.tasks[i].status === "in_progress") {
+        current = this._model.tasks[i];
+        break;
+      }
+    }
+    current ??= this._model.tasks.at(-1);
+    if (!current) {
+      return null;
+    }
+    if (update !== void 0) {
+      if (typeof update === "object" && update !== null && "output" in update) {
+        if (update.output !== void 0) {
+          current.output = update.output;
+        }
+        if (update.status) {
+          current.status = update.status;
+        }
+      } else {
+        current.output = update;
+      }
+    }
+    await this.enqueueEdit();
+    return { id: current.id, title: current.title, status: current.status };
+  }
+  async reset(options) {
+    if (!this.canMutate()) {
+      return null;
+    }
+    const title = contentToPlainText(options.initialMessage) || "Plan";
+    const firstTask = {
+      id: crypto.randomUUID(),
+      title,
+      status: "in_progress"
+    };
+    this._model = { title, tasks: [firstTask] };
+    await this.enqueueEdit();
+    return {
+      id: firstTask.id,
+      title: firstTask.title,
+      status: firstTask.status
+    };
+  }
+  async complete(options) {
+    if (!this.canMutate()) {
+      return;
+    }
+    for (const task of this._model.tasks) {
+      if (task.status === "in_progress") {
+        task.status = "complete";
+      }
+    }
+    this._model.title = contentToPlainText(options.completeMessage) || this._model.title;
+    await this.enqueueEdit();
+  }
+  canMutate() {
+    return !!this._bound;
+  }
+  enqueueEdit() {
+    if (!this._bound) {
+      return Promise.resolve();
+    }
+    const bound = this._bound;
+    const doEdit = async () => {
+      if (bound.fallback) {
+        await bound.adapter.editMessage(
+          bound.threadId,
+          bound.messageId,
+          this.getFallbackText()
+        );
+      } else {
+        const editObject = bound.adapter.editObject;
+        if (!editObject) {
+          return;
+        }
+        await editObject.call(
+          bound.adapter,
+          bound.threadId,
+          bound.messageId,
+          this.kind,
+          this._model
+        );
+      }
+    };
+    const chained = bound.updateChain.then(doEdit, doEdit);
+    bound.updateChain = chained.then(
+      () => void 0,
+      (err) => {
+        bound.logger?.warn("Failed to edit plan", err);
+      }
+    );
+    return chained;
+  }
+};
+
 // src/emoji.ts
 var emojiRegistry = /* @__PURE__ */ new Map();
 function getEmoji(name) {
@@ -3734,6 +4022,7 @@ export {
   MessageHistoryCache,
   Modal2 as Modal,
   NotImplementedError,
+  Plan,
   RadioSelect2 as RadioSelect,
   RateLimitError,
   Section2 as Section,
@@ -3772,6 +4061,7 @@ export {
   isListNode,
   isModalElement2 as isModalElement,
   isParagraphNode,
+  isPostableObject,
   isStrongNode,
   isTableCellNode,
   isTableNode,
@@ -3794,4 +4084,3 @@ export {
   toPlainText,
   walkAst
 };
-//# sourceMappingURL=index.js.map

package/dist/{jsx-runtime-DraWieqP.d.ts → jsx-runtime-DxATbnrP.d.ts}

@@ -50,6 +50,8 @@ type ButtonStyle = "primary" | "danger" | "default";
 type TextStyle = "plain" | "bold" | "muted";
 /** Button element for interactive actions */
 interface ButtonElement {
+    /** Whether this button triggers a regular action or opens a modal dialog. Default: "action" */
+    actionType?: "action" | "modal";
     /** If true, the button is displayed in an inactive state and doesn't respond to user actions */
     disabled?: boolean;
     /** Unique action ID for callback routing */
@@ -237,6 +239,8 @@ declare function Section(children: CardChild[]): SectionElement;
 declare function Actions(children: (ButtonElement | LinkButtonElement | SelectElement | RadioSelectElement)[]): ActionsElement;
 /** Options for Button */
 interface ButtonOptions {
+    /** Whether this button triggers a regular action or opens a modal dialog. Default: "action" */
+    actionType?: "action" | "modal";
     /** If true, the button is displayed in an inactive state and doesn't respond to user actions */
     disabled?: boolean;
     /** Unique action ID for callback routing */
@@ -504,7 +508,9 @@ interface TextProps {
 }
 /** Props for Button component in JSX */
 interface ButtonProps {
+    actionType?: "action" | "modal";
     children?: string | number | (string | number | undefined)[];
+    disabled?: boolean;
     id: string;
     label?: string;
     style?: ButtonStyle;

package/dist/jsx-runtime.d.ts

@@ -1 +1 @@
-export { A as ActionsComponent, B as ButtonComponent, V as ButtonProps, c as CardComponent, W as CardJSXElement, X as CardJSXProps, e as CardLinkComponent, Y as CardLinkProps, Z as CardProps, C as ChatElement, _ as ContainerProps, D as DividerComponent, $ as DividerProps, F as FieldComponent, a0 as FieldProps, f as FieldsComponent, an as Fragment, I as ImageComponent, a1 as ImageProps, ao as JSX, L as LinkButtonComponent, a2 as LinkButtonProps, n as ModalComponent, a3 as ModalProps, R as RadioSelectComponent, S as SectionComponent, o as SelectComponent, p as SelectOptionComponent, a4 as SelectOptionProps, a5 as SelectProps, ai as TableComponent, ah as TableProps, T as TextComponent, q as TextInputComponent, a6 as TextInputProps, a7 as TextProps, aj as isCardLinkProps, h as isJSX, ak as jsx, am as jsxDEV, al as jsxs, t as toCardElement, k as toModalElement } from './jsx-runtime-DraWieqP.js';
+export { A as ActionsComponent, B as ButtonComponent, V as ButtonProps, c as CardComponent, W as CardJSXElement, X as CardJSXProps, e as CardLinkComponent, Y as CardLinkProps, Z as CardProps, C as ChatElement, _ as ContainerProps, D as DividerComponent, $ as DividerProps, F as FieldComponent, a0 as FieldProps, f as FieldsComponent, an as Fragment, I as ImageComponent, a1 as ImageProps, ao as JSX, L as LinkButtonComponent, a2 as LinkButtonProps, n as ModalComponent, a3 as ModalProps, R as RadioSelectComponent, S as SectionComponent, o as SelectComponent, p as SelectOptionComponent, a4 as SelectOptionProps, a5 as SelectProps, ai as TableComponent, ah as TableProps, T as TextComponent, q as TextInputComponent, a6 as TextInputProps, a7 as TextProps, aj as isCardLinkProps, h as isJSX, ak as jsx, am as jsxDEV, al as jsxs, t as toCardElement, k as toModalElement } from './jsx-runtime-DxATbnrP.js';

package/dist/jsx-runtime.js

@@ -7,7 +7,7 @@ import {
   jsxs,
   toCardElement,
   toModalElement
-} from "./chunk-JW7GYSMH.js";
+} from "./chunk-OPV5U4WG.js";
 export {
   Fragment,
   isCardLinkProps,
@@ -18,4 +18,3 @@ export {
   toCardElement,
   toModalElement
 };
-//# sourceMappingURL=jsx-runtime.js.map

package/docs/adapters.mdx

@@ -64,7 +64,7 @@ Ready to build your own? Follow the [building](/docs/contributing/building) guid
 ⚠️ indicates partial support — the feature works with limitations. See individual adapter pages for details.
 </Callout>
 
-## How adapters work
+## How [adapters](/adapters) work
 
 Each adapter implements a standard interface that the `Chat` class uses to route events and send messages. When a webhook arrives:
 
@@ -73,9 +73,9 @@ Each adapter implements a standard interface that the `Chat` class uses to route
 3. Routes to your handlers via the `Chat` class
 4. Converts outgoing messages from markdown/AST/cards to the platform's native format
 
-## Using multiple adapters
+## Using multiple [adapters](/adapters)
 
-Register multiple adapters and your event handlers work across all of them:
+Register multiple [adapters](/adapters) and your event handlers work across all of them:
 
 ```typescript title="lib/bot.ts" lineNumbers
 import { Chat } from "chat";

package/docs/getting-started.mdx

@@ -14,7 +14,7 @@ Learn the core patterns for handling incoming events and posting messages back t
   <Card title="Posting Messages" description="Different ways to render and send messages with thread.post()." href="/docs/posting-messages" />
 </Cards>
 
-## Adapters
+## [Adapters](/adapters)
 
 Connect your bot to chat platforms and persist state across restarts.
 
@@ -23,6 +23,8 @@ Connect your bot to chat platforms and persist state across restarts.
   <Card title="State Adapters" description="Pluggable state adapters for thread subscriptions, distributed locking, and caching." href="/docs/state" />
 </Cards>
 
+Browse all official and community adapters on the [Adapters](/adapters) page.
+
 ## Guides
 
 Step-by-step tutorials to get up and running on your platform of choice.

package/docs/guides/slack-nextjs.mdx

@@ -87,6 +87,8 @@ After creating the app:
 1. Go to **OAuth & Permissions**, click **Install to Workspace**, and copy the **Bot User OAuth Token** (`xoxb-...`) — you'll need this as `SLACK_BOT_TOKEN`
 2. Go to **Basic Information** → **App Credentials** and copy the **Signing Secret** — you'll need this as `SLACK_SIGNING_SECRET`
 
+If you're distributing the app across multiple workspaces via OAuth instead of installing it to one workspace, configure `clientId` and `clientSecret` on the Slack adapter and pass the same redirect URI used during the authorize step into `handleOAuthCallback(request, { redirectUri })` in your callback route.
+
 ## Configure environment variables
 
 Create a `.env.local` file in your project root:

package/docs/index.mdx

@@ -11,7 +11,7 @@ Chat SDK is a TypeScript library for building chat bots that work across multipl
 Building a chat bot that works across multiple platforms typically means maintaining separate codebases, learning different APIs, and handling platform-specific quirks individually. Chat SDK abstracts these differences behind a unified interface.
 
 - **Single codebase** for all platforms
-- **Type-safe** adapters and event handlers with full TypeScript support
+- **Type-safe** [adapters](/adapters) and event handlers with full TypeScript support
 - **Event-driven** architecture with handlers for mentions, messages, reactions, button clicks, slash commands, and modals
 - **Thread subscriptions** for multi-turn conversations
 - **Rich UI** with JSX cards, buttons, and modals that render natively on each platform
@@ -22,8 +22,8 @@ Building a chat bot that works across multiple platforms typically means maintai
 
 Chat SDK has three core concepts:
 
-1. **Chat** — the main entry point that coordinates adapters and routes events to your handlers
-2. **Adapters** — platform-specific implementations that handle webhook parsing, message formatting, and API calls
+1. **Chat** — the main entry point that coordinates [adapters](/adapters) and routes events to your handlers
+2. **[Adapters](/adapters)** — platform-specific implementations that handle webhook parsing, message formatting, and API calls
 3. **State** — a pluggable persistence layer for thread subscriptions and distributed locking
 
 ```typescript title="lib/bot.ts" lineNumbers