Using Chat SDK and eve together

eve and Chat SDK both connect developers and their applications to chat platforms, so it's natural to ask where one ends and the other begins. The short answer is that they solve different layers of the same problem.

Chat SDK is a universal chat layer for receiving and posting platform messages, while eve is a framework for running durable agents. They meet in two places: eve composes rich messages using Chat SDK card components, and eve's Chat SDK channel lets any Chat SDK adapter serve as an agent surface.

In this guide, you'll learn what each tool is responsible for, the two points where they connect, and how to choose between eve's first-class channels and the Chat SDK channel. You'll also wire a Chat SDK adapter into an eve agent to see the integration end to end.

The Chat SDK is an open-source TypeScript SDK for building chatbots across Slack, Microsoft Teams, Google Chat, Discord, WhatsApp, and other platforms, all from a single codebase. It gives you a Chat instance, platform adapters, threads, event handlers such as onNewMention and onSubscribedMessage, and typed cards for rich messages. The Chat SDK doesn't run a model loop; what your bot says is up to your code.

eve is a filesystem-first framework for durable agents. You define instructions and tools under agent/, and eve runs the model loop, persists every session, and serves the agent over HTTP and platform channels. A channel in eve is the edge adapter between a platform and your agent: it normalizes input into a user message, owns the conversation's continuation token, and decides how replies are delivered.

Put together, the Chat SDK answers "how do I talk to this platform?" and eve answers "how do I run the conversation?"

eve uses the Chat SDK's card-builder components (cards, buttons, actions, and related primitives) for composing rich messages. When you build a card in eve's Slack channel, the underlying primitives come from the Chat SDK and convert to Slack Block Kit at post time. Human-in-the-loop prompts render the same way: eve emits a Chat SDK Card with buttons, and the platform adapter translates it into the surface's native format.

eve's Chat SDK channel connects your agent to any Chat SDK adapter, including official adapters like @chat-adapter/slack and community adapters like @resend/chat-sdk-adapter. You register Chat SDK handlers for the messages you care about and call send to hand each turn to eve. The adapter owns provider auth, webhook verification, and delivery, while eve owns session dispatch, streaming, typing indicators, and human-in-the-loop.

Outside the Chat SDK channel, eve does not use the Chat SDK's runtime. eve's first-class channels, such as Slack and Discord, implement their own webhook handling, signature verification, event parsing, and thread management, and manage credentials through Vercel Connect. Building rich messages there feels like Chat SDK cards, but the Chat, Adapter, and Thread primitives only run in your app when you use the Chat SDK channel.

First-class channels are the default choice for the platforms they cover: credentials flow through Vercel Connect, and the channel is purpose-built for the surface. Reach for the Chat SDK channel when the adapter ecosystem covers a surface eve doesn't, or when you already run Chat SDK bots and want to keep their credential and state model.

An adapter, a state store, and one channel file connect the two. This example uses the Slack adapter with a Redis state store:

pnpm i chat @chat-adapter/slack @chat-adapter/state-redis

Create the channel under agent/channels/.

chatSdkChannel returns { bot, channel, send }: register Chat SDK handlers on bot, call send inside them to start or resume an eve session, and export channel as the default:

import { createSlackAdapter } from "@chat-adapter/slack";
import { createRedisState } from "@chat-adapter/state-redis";
import type { Message, Thread } from "chat";
import { chatSdkChannel } from "eve/channels/chat-sdk";

export const { bot, channel, send } = chatSdkChannel({
  userName: "Support Agent",
  adapters: {
    slack: createSlackAdapter(),
  },
  state: createRedisState(),
});

bot.onNewMention(async (thread: Thread, message: Message) => {
  await thread.subscribe();
  await send(message.text, { thread });
});

bot.onSubscribedMessage(async (thread: Thread, message: Message) => {
  await send(message.text, { thread });
});

export default channel;

The handlers are standard Chat SDK code.

The one eve-specific move is calling send, which dispatches the message as a session turn; the thread you pass determines the continuation token, so the agent's reply lands back on the originating thread. Deploy with eve deploy, then point the provider's webhook at the mounted route. Each adapter gets one POST route at /eve/v1/{adapterName}, so the slack adapter above is served at /eve/v1/slack.

You don't override delivery for the common case.

The channel's default handlers post completed replies back to the thread as markdown, stream token-by-token where the adapter supports message edits, and show typing indicators where the adapter supports them. When an adapter doesn't implement an operation, the channel degrades gracefully: streaming falls back to a single final post, and typing indicators are skipped.

• Use a durable state store in production: thread subscriptions and inbound deduplication live in the Chat SDK state adapter. An in-memory store loses both on every restart, so use Redis or another durable adapter for real traffic.
• Prefer first-class channels for their platforms: they exist so you don't manage provider credentials, and their behavior is tuned to the surface. Choose the Chat SDK channel deliberately, not as the default for everything.
• Match streaming to the surface: the channel streams by editing a posted message. For one-message-per-turn surfaces such as email, set streaming: false so the reply posts once on completion.

• Chat SDK channel: the full configuration reference for the bridge
• Give your eve agent an email inbox with Resend: a complete working example on the Chat SDK channel with the Resend adapter
• Channels overview: the channel contract and every built-in eve channel
• Chat SDK documentation: adapters, cards, and state adapters in depth