AI SDK Tools

createChatTools exposes Chat SDK operations as ready-to-use AI SDK tools so an agent can act inside the same workspaces your bot is connected to: read messages, post replies, send DMs, react, edit, delete, and manage thread subscriptions across every adapter you've registered.

Write operations require user approval out of the box, toggle them globally or per-tool when you want unattended execution.

Installation

The tools live in the chat/ai subpath of the core chat package:

import { createChatTools } from "chat/ai";

ai and zod are optional peer dependencies — install them if you haven't already:

Quick start

Pass your Chat instance and the tools you want into any AI SDK call:

import { Chat } from "chat";
import { createChatTools } from "chat/ai";
import { createSlackAdapter } from "@chat-adapter/slack";
import { createMemoryState } from "@chat-adapter/state-memory";
import { generateText } from "ai";

const chat = new Chat({
  userName: "mybot",
  adapters: { slack: createSlackAdapter() },
  state: createMemoryState(),
});

const result = await generateText({
  model: "anthropic/claude-sonnet-4.6",
  tools: createChatTools({
    chat,
    preset: "messenger",
    requireApproval: false, // unattended script, no human-in-the-loop needed
  }),
  prompt:
    "Post a friendly hello in slack:C0123ABC and react to it with a thumbs up.",
});

Each tool resolves the right adapter from the id prefix you give it (slack:..., discord:..., gchat:...), so the same agent can drive any platform your Chat instance is wired up to.

Presets

Pass preset to scope the toolset down to what an agent actually needs.

// Read-only — fetch messages, threads, channel info, users
createChatTools({ chat, preset: "reader" });

// Basic posting — read + post + DM + react + typing indicator
createChatTools({ chat, preset: "messenger" });

// Full management — everything including edit, delete, subscriptions
createChatTools({ chat, preset: "moderator" });

Presets compose — pass an array to combine them:

createChatTools({ chat, preset: ["reader", "messenger"] });

Omit preset entirely to get every tool (same as 'moderator').

Approval control

Write operations (posting, editing, deleting, reacting, subscribing) default to needsApproval: true. The AI SDK pauses execution and surfaces an approval request that your application is expected to confirm before the tool runs. This keeps a human in the loop for anything visible to the workspace.

// All writes need approval (default)
createChatTools({ chat });

// No approval needed
createChatTools({ chat, requireApproval: false });

// Per-tool — only destructive actions need approval
createChatTools({
  chat,
  requireApproval: {
    deleteMessage: true,
    editMessage: true,
    sendDirectMessage: false,
    postMessage: false,
    addReaction: false,
  },
});

Read tools (fetchMessages, fetchThread, getChannelInfo, …) and the startTyping indicator never require approval.

Cherry-picking tools

Each tool is also exported as a standalone factory you can hand to tools directly:

import { fetchMessages, postMessage, addReaction } from "chat/ai";

const tools = {
  fetchMessages: fetchMessages(chat),
  postMessage: postMessage(chat, { needsApproval: false }),
  addReaction: addReaction(chat, { needsApproval: false }),
};

Useful when you want a small, targeted toolset without going through createChatTools.

Tool overrides

Customize any AI SDK tool() property per tool, keyed by tool name:

import type { ChatToolName, ToolOverrides } from "chat/ai";

createChatTools({
  chat,
  overrides: {
    postMessage: {
      description: "Reply in the active customer support thread.",
      needsApproval: false,
    },
    deleteMessage: { needsApproval: true },
  },
});

Core properties (execute, inputSchema, outputSchema, and tool-kind fields like type, id, args) cannot be overridden so tool semantics stay stable.

Available tools

All ids accept the full Chat SDK form: slack:C123ABC:1234567890.123456 for a thread, slack:C123ABC for a channel, and the platform-native user id (e.g. U123456 on Slack, users/123 on Google Chat). The tools auto-detect the adapter from the prefix.

Reading

Writing

API

createChatTools(options)

Returns an object of tools, ready to spread into tools of any AI SDK call.

type ChatToolsOptions = {
  chat: Chat;
  requireApproval?: boolean | Partial<Record<ChatWriteToolName, boolean>>;
  preset?: ChatToolPreset | ChatToolPreset[];
  overrides?: Partial<Record<ChatToolName, ToolOverrides>>;
};

type ChatToolPreset = "reader" | "messenger" | "moderator";