Slack

Inbound hooks decide whether to dispatch a turn and with what auth. Return { auth } to dispatch, null to drop, or { auth, context } to inject background into history.

• onAppMention(ctx, message) handles app_mention events. The default derives workspace-scoped auth and posts a Thinking… indicator.
• onDirectMessage(ctx, message) handles message.im events (needs im:history scope). Bot-authored messages and edits are filtered out first.
• onInteraction(action, ctx) handles block_actions callbacks not consumed by HITL.

eve attaches the triggering Slack user id to the same model message as the message text. This keeps speaker attribution intact when several people use one thread without making profile lookup requests.

You get the triggering mention by default, but not the earlier replies in the thread. Enable threadContext to fetch and inject them with every message attributed by stable Slack user id. Use since: "last-agent-reply" so repeated mentions inject only what is new:

import { slackChannel } from "eve/channels/slack";
import { connectSlackCredentials } from "@vercel/connect/eve";

export default slackChannel({
  credentials: connectSlackCredentials("slack/my-agent"),
  threadContext: { since: "last-agent-reply" },
});

since sets the boundary for what each mention injects and accepts three values:

• "thread-root" (the default): every prior message in the thread, on every mention. threadContext: {} behaves the same.
• "last-agent-reply": only messages after the agent's last reply, keeping repeated mentions incremental.
• A predicate (message: SlackThreadMessage) => boolean: only messages after the last one it matches, such as "since the last message that mentioned a particular user".

threadContext performs one conversations.replies request for each triggering thread reply and requires the matching Slack history scope. Omit it when the agent should see only direct mentions. loadThreadContextMessages remains available when you need custom filtering or non-model processing of the raw thread messages.

Inside webhook-side handlers (onAppMention, onInteraction, events), ctx.slack.request(operation, body) is the raw-API escape hatch. Outside those contexts there is no handle — a schedule resolving reactions on old messages, for example, has no inbound Slack request. For that, call the same primitive the handle uses directly:

import { callSlackApi, resolveSlackBotToken } from "eve/channels/slack";
import { connectSlackCredentials } from "@vercel/connect/eve";

const { botToken } = connectSlackCredentials("slack/my-agent");
const response = await callSlackApi({
  botToken,
  operation: "reactions.get",
  body: { channel: "C0123456789", timestamp: "1712345678.000100", full: true },
});
if (!response.ok) throw new Error(String(response.error));

callSlackApi resolves function-form tokens (secret managers, Connect rotation) at call time and form-encodes the body — the only safe default, since Slack's JSON support is partial (conversations.replies rejects JSON). resolveSlackBotToken materializes a SlackBotToken to a string when you need the bearer token itself.

The default handlers reply in-thread and show progress. Typing indicators post automatically: Thinking… on inbound, Working… on turn.started, a truncated reasoning snippet on reasoning.appended, and an action label on actions.requested — the tool name plus its most telling argument (grep useEveAgent, read_file agent/agent.ts), the subagent or remote-agent name for dispatched calls, and +N more when the model requests several actions at once. The model's own pre-tool narration, when present, takes precedence over the derived label. Reasoning snippets build progressively: extensions of at least four characters appear immediately, while smaller streamed deltas use the five-second refresh interval to avoid one Slack request per token. Override events["reasoning.appended"] if you prefer generic wording. Override onAppMention or the events handlers to customize.

Outbound text preserves bare @ tokens as literal text. To mention a user, embed Slack's <@USER_ID> syntax directly or use channel.thread.mentionUser(userId).

When a session starts without a threadTs (say, from a schedule or receive(slack, ...)), eve gives it a unique temporary continuation token. The first agent post anchors the session to the Slack message timestamp, and later posts and mentions resume that same session. Pass initialMessage with a Card to land a structured anchor first instead. threadTs and initialMessage are mutually exclusive.

The example below overrides onAppMention to gate on an authored message and posts the completed reply to the thread. Event handlers receive (eventData, channel, ctx), with Slack platform handles on channel.thread and channel.slack:

import { defaultSlackAuth, slackChannel } from "eve/channels/slack";
import { connectSlackCredentials } from "@vercel/connect/eve";

export default slackChannel({
  credentials: connectSlackCredentials("slack/my-agent"),
  onAppMention: (ctx, message) =>
    message.author ? { auth: defaultSlackAuth(message, ctx) } : null,
  events: {
    "message.completed"(eventData, channel, ctx) {
      if (eventData.finishReason === "tool-calls") return;
      if (eventData.message) channel.thread.post(eventData.message);
    },
  },
});

HITL renders as Slack buttons and selects. When the user responds, the parked session (paused awaiting input) resumes.

Authorization prompts split public status from private credentials. A sign-in challenge (OAuth URL, device code) is a credential. Anyone who completes it binds their identity to the session's connection. The default authorization.required handler posts a public, link-free status in the thread, delivers the actual challenge ephemerally to the triggering user, device code included, and then updates that public status when authorization.completed fires. The handler receives a private-delivery context with postEphemeral, postDirectMessage (needs the im:write scope), and state. There is, intentionally, no public post and no raw API access.

events: {
  "authorization.required"(eventData, channel) {
    const userId = channel.state.triggeringUserId;
    if (!userId || !eventData.authorization?.url) return;
    return channel.postDirectMessage(userId, `Sign in to continue: ${eventData.authorization.url}`);
  },
},

Start a session without an inbound message through receive(slack, { message, target, auth }) from a schedule run handler, or args.receive(slack, ...) from another channel. The proactive target shape is { channelId }.

Inbound files behind authenticated Slack URLs are staged with fetchFile. See File uploads for the fetchFile contract.