Platform Adapters

Platform adapters handle webhook verification, message parsing, and API calls for each messaging platform. Install only the adapters you need. Browse every available adapter, including community-built ones, on the Adapters page.

Need a browser chat UI? See the Web adapter. It speaks the AI SDK UI stream protocol and works with React (@ai-sdk/react), Vue (@ai-sdk/vue), and Svelte (@ai-sdk/svelte), so one bot can serve Slack, Teams, and a browser chat UI.

Feature matrix

This matrix covers Vercel-maintained official adapters only. For vendor-official and community adapters, see each adapter's page.

How adapters work

Each adapter implements the Adapter interface, which the Chat class uses to route events and send messages. When a webhook arrives, the adapter:

1. Verifies the request signature.
2. Parses the platform-specific payload into a normalized Message.
3. Passes the message to the Chat class, which routes it to your handlers.

When your handler posts a reply, the adapter converts it from markdown, an AST, or a card into the platform's native format.

Using multiple adapters

Register multiple adapters and your event handlers work across all of them:

import { Chat } from "chat";
import { createSlackAdapter } from "@chat-adapter/slack";
import { createTeamsAdapter } from "@chat-adapter/teams";
import { createGoogleChatAdapter } from "@chat-adapter/gchat";
import { createRedisState } from "@chat-adapter/state-redis";

const bot = new Chat({
  userName: "mybot",
  adapters: {
    slack: createSlackAdapter(),
    teams: createTeamsAdapter(),
    gchat: createGoogleChatAdapter(),
  },
  state: createRedisState(),
});

// This handler fires for mentions on any platform
bot.onNewMention(async (thread) => {
  await thread.subscribe();
  await thread.post("Hello!");
});

Each adapter reads its credentials from environment variables, so you only pass config to override them.

Each adapter gets a webhook handler at bot.webhooks.<name>, keyed by the name you registered it under.

Customizing an adapter via subclassing

Official adapters expose their extension points as protected members, so you can subclass an adapter to override or extend its behavior without forking the package. Use this to handle a payload type the built-in adapter doesn't cover, intercept verification, or wrap an existing handler.

import { TelegramAdapter, type TelegramUpdate } from "@chat-adapter/telegram";
import type { WebhookOptions } from "chat";

export class CustomTelegramAdapter extends TelegramAdapter {
  protected override processUpdate(
    update: TelegramUpdate,
    options?: WebhookOptions
  ): void {
    // Handle a payload type the base adapter doesn't, e.g. chat_join_request.
    if ("chat_join_request" in update) {
      this.logger.info("Received chat_join_request", { update });
      return;
    }
    super.processUpdate(update, options);
  }
}

Construct your subclass anywhere you'd construct the base adapter, for example adapters: { telegram: new CustomTelegramAdapter({ ... }) }. Members marked private stay inaccessible. If you need a hook that isn't protected, open an issue.