chat 4.25.0 → 4.27.0

package/resources/guides/triage-form-submissions-with-chat-sdk.md

@@ -0,0 +1,178 @@
+# Triage form submissions with Chat SDK
+
+**Author:** Ben Sabic
+
+---
+
+Build a Slack bot that triages form submissions where your team already works. When someone submits a form on your website, the bot posts an interactive card to a Slack channel. A reviewer clicks a button to forward the submission via email, edit it before forwarding, or mark it as spam. The whole workflow happens inside Slack, with no separate dashboard or inbox to monitor.
+
+The bot is built with [Chat SDK](https://chat-sdk.dev/), the unified TypeScript SDK for building chatbots that work across Slack, Microsoft Teams, Discord, and other platforms from a single codebase. You write your logic once, and Chat SDK handles the platform-specific details, such as Block Kit on Slack or Adaptive Cards on Teams.
+
+Deploy the template now, or read on for a deeper look at how it all works.
+
+## Quick start with an AI coding agent
+
+If you're working with an AI coding agent like Claude Code or Cursor, you can clone the template and hand off implementation with this prompt:
+
+`I want to build a form triage Slack bot using Chat SDK. Clone the template repo at https://github.com/vercel-labs/chat-sdk-form-bot, install dependencies with pnpm, and walk me through setting up the environment variables in .env.local. I need a Slack app, Redis (Upstash), and Resend configured. After setup, help me deploy it to Vercel and test it with a curl POST to the /api/form endpoint. When searching for information, check for applicable skill(s) first and review local documentation.`
+
+### Vercel Plugin
+
+Turn your agent into a Vercel expert with this [plugin](https://vercel.com/docs/agent-resources/vercel-plugin); the [Chat SDK skill](https://skills.sh/vercel/chat/chat-sdk) is included.
+
+`npx plugins add vercel/vercel-plugin`
+
+## Setup and deployment
+
+### What you need before deploying
+
+You'll need accounts with three services:
+
+*   **Slack** for the bot itself. Create a new app at [api.slack.com/apps](https://api.slack.com/apps).
+    
+*   **Redis** for temporary submission storage. Any Redis provider works. [Upstash](https://vercel.com/marketplace/upstash) supports serverless deployments and has a free tier.
+    
+*   **Resend** to send forwarded submissions via email. Sign up at [resend.com](https://resend.com/) and verify a sending domain.
+    
+
+### Configure your Slack app
+
+1.  Create a new Slack app from a manifest at [api.slack.com/apps](https://api.slack.com/apps). Use the [slack-manifest.json](https://github.com/vercel-labs/chat-sdk-form-bot/blob/main/slack-manifest.json) file included in the template repo. Replace the two `https://example.com` URLs with your production domain (e.g. `https://your-app.vercel.app/api/webhooks/slack`).
+    
+2.  Install the app in your workspace and copy the **Bot User OAuth Token**.
+    
+3.  Copy the **Signing Secret** from the **Basic Information** page.
+    
+
+### Environment variables
+
+The template needs these environment variables:
+
+`# Slack SLACK_BOT_TOKEN=xoxb-... SLACK_SIGNING_SECRET=... SLACK_CHANNEL_ID=C... # Redis REDIS_URL=redis://... # Resend RESEND_API_KEY=re_... RESEND_FROM_ADDRESS=bot@yourdomain.com RESEND_FROM_NAME=Formbot # Optional, defaults to "Formbot" # Forwarding FORWARD_EMAIL=team@yourdomain.com # Where approved submissions are sent FORWARD_ENDPOINT= # Optional: webhook URL for downstream systems`
+
+`SLACK_CHANNEL_ID` is the channel where submission cards will appear. You can find it by right-clicking a channel in Slack and selecting "View channel details" (the ID is at the bottom of the modal).
+
+`FORWARD_ENDPOINT` is optional. If set, the bot will also POST the form data as JSON to that URL when a submission is forwarded. This is useful for piping approved submissions into a CRM, database, or another service.
+
+### Deploy to Vercel
+
+[Deploy the bot with one click](https://vercel.com/new/clone?repository-url=https://github.com/vercel-labs/chat-sdk-form-bot&env=SLACK_BOT_TOKEN,SLACK_SIGNING_SECRET,SLACK_CHANNEL_ID,REDIS_URL,RESEND_API_KEY,RESEND_FROM_ADDRESS,FORWARD_EMAIL), or clone the repo and deploy manually:
+
+`git clone https://github.com/vercel-labs/chat-sdk-form-bot.git cd chat-sdk-form-bot pnpm install vercel`
+
+After deploying, update your Slack app's interactivity request URL to point to your production domain: `https://<your-vercel-domain>/api/webhooks/slack`.
+
+### Test the form endpoint
+
+Send a test submission:
+
+`curl -X POST https://<your-domain>/api/form \ -H "Content-Type: application/json" \ -d '{"Name": "Jane Doe", "Email": "jane@example.com", "Message": "Hello!"}'`
+
+A card should appear in your configured Slack channel within a few seconds, and you should see a JSON response in your terminal:
+
+`{"status":"received","submissionId":"a1b2c3d4-..."}`
+
+### Local development
+
+For local development, the template includes a Node.js server entrypoint:
+
+`pnpm dev`
+
+This starts a local server at `http://localhost:3000`. To receive Slack webhooks locally, use [ngrok](https://ngrok.com/) to create a public tunnel:
+
+`ngrok http 3000`
+
+Then update your Slack app's request URL to the ngrok URL (e.g. `https://abc123.ngrok-free.dev/api/webhooks/slack`).
+
+## How the form triage bot works
+
+The bot has three moving parts, including an HTTP endpoint that receives form data, a Redis store that temporarily holds submissions, and a Chat SDK bot that manages Slack interactions.
+
+1.  An external service (your website, a form provider, a webhook) sends a `POST` request to `/api/form` with JSON data
+    
+2.  The bot generates a unique ID, stores the submission in Redis with a 7-day TTL, and posts an interactive card to a Slack channel
+    
+3.  A reviewer sees the card and takes one of three actions:
+    
+    *   **Forward Submission** sends a styled HTML email via [Resend](https://vercel.com/marketplace/resend) to a configured recipient, then updates the card to show who forwarded it
+        
+    *   **Edit & Forward** opens a modal where the reviewer can modify fields before forwarding
+        
+    *   **Mark as Spam** updates the card and deletes the submission from Redis
+        
+
+Once an action is taken, the card updates in place. The reviewer sees the result immediately in the same channel, without a confirmation page or context switch.
+
+## Code walkthrough
+
+The entire bot is about 200 lines across six files.
+
+### Receiving submissions
+
+The HTTP layer uses [Hono](https://vercel.com/docs/frameworks/backend/hono), a lightweight web framework. The form endpoint accepts any JSON body, assigns it a UUID, and hands it off to the bot:
+
+``import { Hono } from "hono"; import { cors } from "hono/cors"; import { bot, postFormCard } from "./bot.js"; const app = new Hono(); app.use("/api/form", cors()); app.post("/api/form", (c) => c.req.json().then(async (formData: Record<string, unknown>) => { const submissionId = crypto.randomUUID(); await Promise.resolve(postFormCard(formData, submissionId)); return c.json({ status: "received", submissionId }); }) ); app.post("/api/webhooks/:platform", (c) => { const platform = c.req.param("platform"); if (platform !== "slack") { return c.json({ error: `Unknown platform: ${platform}` }, 404); } return bot.webhooks.slack(c.req.raw); }); export default app;``
+
+You can submit directly from a browser-based form on any origin. The webhook route at `/api/webhooks/:platform` handles Slack's interaction payloads (button clicks and modal submissions). The `:platform` parameter is already set up for adding other platforms later.
+
+### Building the bot
+
+The bot itself is a Chat SDK instance with a Slack adapter and Redis-backed state:
+
+`import { Chat } from "chat"; import { createSlackAdapter } from "@chat-adapter/slack"; import { createRedisState } from "@chat-adapter/state-redis"; export const bot = new Chat({ adapters: { slack: createSlackAdapter(), }, state: createRedisState(), userName: "form-bot", });`
+
+That's the entire bot setup. Chat SDK handles Slack's signature verification, payload parsing, and response formatting. The `state` object is a Redis adapter that Chat SDK uses for its internal state management, and the same Redis connection is reused to store form submissions.
+
+### Interactive cards
+
+Cards are built using Chat SDK's component functions. These are platform-agnostic: on Slack, they render as Block Kit, on Teams, they'd render as Adaptive Cards. Here's the card that appears when a new submission arrives:
+
+`import { Actions, Button, Card, Fields, Field, Divider } from "chat"; export const newSubmissionCard = ( formData: Record<string, unknown>, submissionId: string ) => Card({ children: [ Fields( Object.entries(formData).map(([key, value]) => Field({ label: key, value: String(value) }) ) ), Divider(), Actions([ Button({ id: "forward", label: "Forward Submission", style: "primary", value: submissionId, }), Button({ id: "edit", label: "Edit & Forward", style: "primary", value: submissionId, }), ]), Actions([ Button({ id: "spam", label: "Mark as Spam", style: "danger", value: submissionId, }), ]), ], title: "New Form Submission", });`
+
+The form data is dynamic. Whatever keys and values are in the JSON body become fields on the card. A submission with `{"Name": "Jane", "Email": "jane@example.com"}` produces a card with two fields. A submission with ten fields produces a card with ten fields. No schema changes needed.
+
+### Handling actions
+
+When a reviewer clicks a button, Chat SDK routes the event to the right handler based on the action ID:
+
+`bot.onAction(["forward", "spam", "edit"], async (event) => { const submissionId = event.value; if (!submissionId || !event.thread) return; const formData = await getSubmission(submissionId); if (!formData) return; if (event.actionId === "edit") { await event.openModal(editSubmissionModal(formData, submissionId)); } else { const handler = event.actionId === "forward" ? handleForward : handleSpam; await handler(event, formData, submissionId, event.thread.id); } });`
+
+The forward handler sends the email, optionally POSTs to a webhook endpoint, updates the Slack card, and cleans up Redis, all in parallel:
+
+`const handleForward = async (event, formData, submissionId, threadId) => { const slack = bot.getAdapter("slack"); await Promise.all([ forwardToEmail(formData), forwardToEndpoint(formData), slack.editMessage( threadId, event.messageId, forwardedCard(formData, event.user.fullName) ), deleteSubmission(submissionId), ]); };`
+
+After forwarding, the card is replaced with a read-only version showing who forwarded it and where. The submission is deleted from Redis since it's no longer needed.
+
+## How to add Teams, Discord, or other platforms
+
+Chat SDK supports multiple platforms from a single codebase. The cards, fields, and buttons you've already defined render natively on each platform, including Block Kit on Slack, Adaptive Cards on Teams, and Google Chat Cards.
+
+To add Microsoft Teams or another platform, register an additional adapter:
+
+`import { createSlackAdapter } from "@chat-adapter/slack"; import { createTeamsAdapter } from "@chat-adapter/teams"; export const bot = new Chat({ adapters: { slack: createSlackAdapter(), teams: createTeamsAdapter(), }, state, userName: "form-bot", });`
+
+The existing webhook route in `src/index.ts` already uses a `:platform` parameter, so Teams webhooks would be handled at `/api/webhooks/teams` with no additional routing code.
+
+You could also post to multiple platforms at once. For example, you might post form submissions to both a Slack channel and a Teams channel by calling `bot.channel()` with different platform prefixes:
+
+``const slackChannel = bot.channel(`slack:${process.env.SLACK_CHANNEL_ID}`); const teamsChannel = bot.channel(`teams:${process.env.TEAMS_CHANNEL_ID}`); await Promise.all([ slackChannel.post(newSubmissionCard(formData, submissionId)), teamsChannel.post(newSubmissionCard(formData, submissionId)), ]);``
+
+Modals are currently Slack-only, so the Edit & Forward button only works on Slack. On other platforms, you'd want to either hide that button or replace it with a different editing flow.
+
+See the [Chat SDK adapter directory](https://chat-sdk.dev/adapters) for the full list of supported platforms.
+
+## Related resources
+
+*   [Chat SDK Form Bot template](https://github.com/vercel-labs/chat-sdk-form-bot)
+    
+*   [Chat SDK documentation](https://chat-sdk.dev/docs)
+    
+*   [Chat SDK GitHub](https://github.com/vercel/chat)
+    
+*   [Resend documentation](https://resend.com/docs/api-reference/emails/send-email)
+    
+*   [Hono documentation](https://hono.dev/docs/getting-started/vercel)
+
+---
+
+[View full KB sitemap](/kb/sitemap.md)

package/resources/templates.json

@@ -0,0 +1,19 @@
+{
+  "templates": [
+    {
+      "title": "Chat SDK Liveblocks Bot",
+      "description": "Build a bot that you can engage with inside Liveblocks.",
+      "href": "https://vercel.com/templates/next.js/chat-sdk-liveblocks-bot"
+    },
+    {
+      "title": "Knowledge Agent",
+      "description": "Open source file-system and knowledge based agent template. Build AI agents that stay up to date with your knowledge base.",
+      "href": "https://vercel.com/templates/nuxt/chat-sdk-knowledge-agent"
+    },
+    {
+      "title": "Community Agent",
+      "description": "Open source AI-powered Slack community management bot with a built-in Next.js admin panel. Uses Chat SDK, AI SDK, and Vercel Workflow.",
+      "href": "https://vercel.com/templates/next.js/chat-sdk-community-agent"
+    }
+  ]
+}

package/docs/adapters/whatsapp.mdx

@@ -1,222 +0,0 @@
----
-title: WhatsApp
-description: Configure the WhatsApp adapter for the WhatsApp Business Cloud API.
-type: integration
-prerequisites:
-  - /docs/getting-started
----
-
-## Installation
-
-```sh title="Terminal"
-pnpm add @chat-adapter/whatsapp
-```
-
-## Usage
-
-The adapter auto-detects `WHATSAPP_ACCESS_TOKEN`, `WHATSAPP_APP_SECRET`, `WHATSAPP_PHONE_NUMBER_ID`, and `WHATSAPP_VERIFY_TOKEN` from environment variables:
-
-```typescript title="lib/bot.ts" lineNumbers
-import { Chat } from "chat";
-import { createWhatsAppAdapter } from "@chat-adapter/whatsapp";
-
-const bot = new Chat({
-  userName: "mybot",
-  adapters: {
-    whatsapp: createWhatsAppAdapter(),
-  },
-});
-
-bot.onNewMention(async (thread, message) => {
-  await thread.post(`You said: ${message.text}`);
-});
-```
-
-Since all WhatsApp conversations are 1:1 DMs, every incoming message is treated as a mention.
-
-## Webhook route
-
-WhatsApp uses two webhook mechanisms:
-
-1. **Verification handshake** (GET) — Meta sends a `hub.verify_token` challenge that must match your `WHATSAPP_VERIFY_TOKEN`.
-2. **Event delivery** (POST) — incoming messages, reactions, and interactive responses, verified via `X-Hub-Signature-256`.
-
-Both are handled by the same `handleWebhook` method:
-
-```typescript title="app/api/webhooks/whatsapp/route.ts" lineNumbers
-import { bot } from "@/lib/bot";
-
-export async function GET(request: Request): Promise<Response> {
-  return bot.webhooks.whatsapp(request);
-}
-
-export async function POST(request: Request): Promise<Response> {
-  return bot.webhooks.whatsapp(request);
-}
-```
-
-## Meta app setup
-
-### 1. Create a Meta app
-
-1. Go to [developers.facebook.com/apps](https://developers.facebook.com/apps)
-2. Click **Create App** and select **Business** type
-3. Give it a name and click **Create App**
-
-### 2. Add WhatsApp product
-
-1. In the app dashboard, find **WhatsApp** and click **Set Up**
-2. This creates a test phone number and sandbox environment
-
-### 3. Get credentials
-
-From the app dashboard:
-
-| Credential | Where to find it |
-|---|---|
-| **Access Token** | WhatsApp > API Setup > Temporary access token (or create a System User token for production) |
-| **Phone Number ID** | WhatsApp > API Setup > Phone number ID |
-| **App Secret** | Settings > Basic > App Secret |
-| **Verify Token** | You define this — any secret string you choose |
-
-### 4. Configure webhooks
-
-1. Go to **WhatsApp** > **Configuration** in your app dashboard
-2. Click **Edit** next to Webhook URL
-3. Set **Callback URL** to `https://your-domain.com/api/webhooks/whatsapp`
-4. Set **Verify token** to the same value as your `WHATSAPP_VERIFY_TOKEN`
-5. Click **Verify and Save**
-6. Subscribe to the **messages** webhook field
-
-### 5. Production access
-
-For production use:
-
-1. Add a real phone number under **WhatsApp** > **API Setup**
-2. Create a **System User** in Meta Business Suite for a permanent access token
-3. Complete Meta's **App Review** process for the `whatsapp_business_messaging` permission
-
-## Interactive messages
-
-Card elements are automatically converted to WhatsApp interactive messages:
-
-- **3 or fewer buttons** — rendered as WhatsApp reply buttons (title max 20 characters)
-- **More than 3 buttons** — falls back to formatted text
-
-```typescript title="lib/bot.ts" lineNumbers
-import { Card, Actions, Button, Body, BodyText } from "chat";
-
-bot.onNewMention(async (thread) => {
-  await thread.post(
-    <Card>
-      <Body>
-        <BodyText>How can I help?</BodyText>
-      </Body>
-      <Actions>
-        <Button id="help" value="help">Get Help</Button>
-        <Button id="status" value="status">Check Status</Button>
-      </Actions>
-    </Card>
-  );
-});
-```
-
-## Media attachments
-
-Incoming media messages (images, documents, audio, video, voice, stickers) are exposed as attachments with a lazy `fetchData()` function. Media is downloaded in two steps via the Graph API — first fetching the media URL, then downloading the binary data.
-
-```typescript title="lib/bot.ts" lineNumbers
-bot.onNewMention(async (thread, message) => {
-  for (const attachment of message.attachments) {
-    if (attachment.fetchData) {
-      const data = await attachment.fetchData();
-      // Process the media buffer...
-    }
-  }
-});
-```
-
-## 24-hour messaging window
-
-WhatsApp enforces a [24-hour customer service window](https://developers.facebook.com/docs/whatsapp/cloud-api/guides/send-messages#customer-service-windows). You can only send free-form messages to a user within 24 hours of their last message. After that, you must use approved **message templates**.
-
-## Configuration
-
-All options are auto-detected from environment variables when not provided.
-
-| Option | Required | Description |
-|--------|----------|-------------|
-| `accessToken` | No* | Meta access token. Auto-detected from `WHATSAPP_ACCESS_TOKEN` |
-| `appSecret` | No* | App secret for webhook signature verification. Auto-detected from `WHATSAPP_APP_SECRET` |
-| `phoneNumberId` | No* | Bot's phone number ID. Auto-detected from `WHATSAPP_PHONE_NUMBER_ID` |
-| `verifyToken` | No* | Secret for webhook verification handshake. Auto-detected from `WHATSAPP_VERIFY_TOKEN` |
-| `apiVersion` | No | Graph API version (defaults to `v21.0`) |
-| `userName` | No | Bot username. Auto-detected from `WHATSAPP_BOT_USERNAME` or defaults to `whatsapp-bot` |
-| `logger` | No | Logger instance (defaults to `ConsoleLogger("info")`) |
-
-*All four credentials are required — either via config or environment variables.
-
-## Environment variables
-
-```bash title=".env.local"
-WHATSAPP_ACCESS_TOKEN=EAAx...         # Meta access token
-WHATSAPP_APP_SECRET=abc123...         # App secret for signature verification
-WHATSAPP_PHONE_NUMBER_ID=1234567890   # Phone number ID from Meta dashboard
-WHATSAPP_VERIFY_TOKEN=my-secret       # Your chosen webhook verify token
-```
-
-## Features
-
-| Feature | Supported |
-|---------|-----------|
-| Mentions | N/A (all messages are DMs) |
-| Reactions (add/remove) | Yes |
-| Cards | Interactive messages (max 3 buttons) / text fallback |
-| Modals | No |
-| Streaming | No |
-| DMs | Yes (all conversations) |
-| Ephemeral messages | No |
-| File uploads | Receive only |
-| Typing indicator | Yes |
-| Message history | No |
-| Edit message | No (throws) |
-| Delete message | No (throws) |
-
-## Thread ID format
-
-```
-whatsapp:{phoneNumberId}:{userWaId}
-```
-
-Example: `whatsapp:1234567890:15551234567`
-
-## Notes
-
-- All WhatsApp conversations are 1:1 DMs between the business phone number and the user, so every message sets `isMention: true`.
-- `editMessage()` and `deleteMessage()` throw errors — WhatsApp does not support these operations.
-- `fetchMessages()` returns empty results — WhatsApp does not provide a message history API.
-- Messages exceeding 4096 characters are automatically split at paragraph or line boundaries.
-- Webhook signatures are verified using HMAC-SHA256 with `timingSafeEqual` for timing-attack resistance.
-
-## Troubleshooting
-
-### Webhook verification failing
-
-- Verify `WHATSAPP_VERIFY_TOKEN` matches what you set in the Meta dashboard
-- Ensure both GET and POST routes are configured for the webhook URL
-
-### "Invalid signature" error
-
-- Check that `WHATSAPP_APP_SECRET` is correct (find it under Settings > Basic in your Meta app)
-- Ensure the raw request body is not parsed before verification
-
-### Bot not responding
-
-- Confirm the **messages** webhook field is subscribed in Meta dashboard
-- Check that you're within the 24-hour messaging window (or using template messages)
-- Verify the phone number ID matches your configured `WHATSAPP_PHONE_NUMBER_ID`
-
-### Media downloads failing
-
-- Ensure your access token has the required permissions
-- Check that the media hasn't expired (WhatsApp media URLs are temporary)

package/docs/guides/code-review-hono.mdx

@@ -1,241 +0,0 @@
----
-title: Code review GitHub bot with Hono and Redis
-description: This guide walks through building a GitHub bot that reviews pull requests on demand. When a user @mentions the bot on a PR, Chat SDK picks up the mention, spins up a Vercel Sandbox with the repo cloned, and uses AI SDK to analyze the diff.
-type: guide
-prerequisites: []
-related:
-  - /adapters/github
-  - /docs/state/redis
----
-
-## Prerequisites
-
-- Node.js 18+
-- [pnpm](https://pnpm.io) (or npm/yarn)
-- A GitHub repository where you have admin access
-- A Redis instance for state management
-- A [Vercel](https://vercel.com) account
-
-## Create a Hono app
-
-Scaffold a new Hono project and install dependencies:
-
-```sh title="Terminal"
-pnpm create hono my-review-bot
-cd my-review-bot
-pnpm add @octokit/rest @vercel/functions @vercel/sandbox ai bash-tool chat @chat-adapter/github @chat-adapter/state-redis
-```
-
-<Callout type="info">
-  Select the `vercel` template when prompted by `create-hono`. This sets up the project for Vercel deployment with the correct entry point.
-</Callout>
-
-## Configure a GitHub webhook
-
-1. Go to your repository **Settings** then **Webhooks** then **Add webhook**
-2. Set **Payload URL** to `https://your-domain.com/api/webhooks/github`
-3. Set **Content type** to `application/json`
-4. Set a **Secret** and save it — you'll need this as `GITHUB_WEBHOOK_SECRET`
-5. Under **Which events would you like to trigger this webhook?**, select **Let me select individual events** and check:
-   - **Issue comments** (for @mention on the PR conversation tab)
-   - **Pull request review comments** (for @mention on inline review threads)
-
-### Get credentials
-
-1. Go to [Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens) and create a token with `repo` scope — you'll need this as `GITHUB_TOKEN`
-2. Copy the **Webhook secret** you set above — you'll need this as `GITHUB_WEBHOOK_SECRET`
-
-## Configure environment variables
-
-Create a `.env` file in your project root:
-
-```bash title=".env"
-GITHUB_TOKEN=ghp_your_personal_access_token
-GITHUB_WEBHOOK_SECRET=your_webhook_secret
-REDIS_URL=redis://localhost:6379
-BOT_USERNAME=my-review-bot
-```
-
-The model (`anthropic/claude-sonnet-4.6`) uses AI Gateway. Develop locally by linking to your Vercel project with `vc link` then pulling your OIDC token with `vc pull --environment development`.
-
-## Define the review function
-
-Create the core review logic. This clones the repo into a Vercel Sandbox, then uses AI SDK with a bash tool to let Claude analyze the diff and read files directly.
-
-```typescript title="src/review.ts" lineNumbers
-import { Sandbox } from "@vercel/sandbox";
-import { ToolLoopAgent, stepCountIs } from "ai";
-import { createBashTool } from "bash-tool";
-
-interface ReviewInput {
-  owner: string;
-  repo: string;
-  prBranch: string;
-  baseBranch: string;
-}
-
-export async function reviewPullRequest(input: ReviewInput): Promise<string> {
-  const { owner, repo, prBranch, baseBranch } = input;
-
-  const sandbox = await Sandbox.create({
-    source: {
-      type: "git",
-      url: `https://github.com/${owner}/${repo}`,
-      username: "x-access-token",
-      password: process.env.GITHUB_TOKEN,
-      depth: 50,
-    },
-    timeout: 5 * 60 * 1000,
-  });
-
-  try {
-    await sandbox.runCommand("git", ["fetch", "origin", prBranch, baseBranch]);
-    await sandbox.runCommand("git", ["checkout", prBranch]);
-
-    const diffResult = await sandbox.runCommand("git", [
-      "diff",
-      `origin/${baseBranch}...HEAD`,
-    ]);
-    const diff = await diffResult.output("stdout");
-
-    const { tools } = await createBashTool({ sandbox });
-
-    const agent = new ToolLoopAgent({
-      model: "anthropic/claude-sonnet-4.6",
-      tools,
-      stopWhen: stepCountIs(20),
-    });
-
-    const result = await agent.generate({
-      prompt: `You are reviewing a pull request for bugs and issues.
-
-Here is the diff for this PR:
-
-\`\`\`diff
-${diff}
-\`\`\`
-
-Use the bash and readFile tools to inspect any files you need more context on.
-
-Look for bugs, security issues, performance problems, and missing error handling.
-Organize findings by severity (critical, warning, suggestion).
-If the code looks good, say so.`,
-    });
-
-    return result.text;
-  } finally {
-    await sandbox.stop();
-  }
-}
-```
-
-The `createBashTool` gives the agent `bash`, `readFile`, and `writeFile` tools — all scoped to the sandbox. The agent can run `git diff`, read source files, and explore the repo freely without any code escaping the sandbox.
-
-The function returns the review text instead of posting it directly. This lets the Chat SDK handler post it as a threaded reply.
-
-## Create the bot
-
-Create a `Chat` instance with the GitHub adapter. When someone @mentions the bot on a PR, it fetches the PR metadata, runs the review, and posts the result back to the thread.
-
-```typescript title="src/bot.ts" lineNumbers
-import { Chat } from "chat";
-import { createGitHubAdapter } from "@chat-adapter/github";
-import { createRedisState } from "@chat-adapter/state-redis";
-import { Octokit } from "@octokit/rest";
-import { reviewPullRequest } from "./review";
-import type { GitHubRawMessage } from "@chat-adapter/github";
-
-const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
-
-export const bot = new Chat({
-  userName: process.env.BOT_USERNAME!,
-  adapters: {
-    github: createGitHubAdapter(),
-  },
-  state: createRedisState(),
-});
-
-bot.onNewMention(async (thread, message) => {
-  const raw = message.raw as GitHubRawMessage;
-  const { owner, repo, prNumber } = {
-    owner: raw.repository.owner.login,
-    repo: raw.repository.name,
-    prNumber: raw.prNumber,
-  };
-
-  // Fetch PR branch info
-  const { data: pr } = await octokit.pulls.get({
-    owner,
-    repo,
-    pull_number: prNumber,
-  });
-
-  await thread.post("Starting code review...");
-  await thread.subscribe();
-
-  const review = await reviewPullRequest({
-    owner,
-    repo,
-    prBranch: pr.head.ref,
-    baseBranch: pr.base.ref,
-  });
-
-  await thread.post(review);
-});
-
-bot.onSubscribedMessage(async (thread, message) => {
-  await thread.post(
-    "I've already reviewed this PR. @mention me on a new PR to start another review."
-  );
-});
-```
-
-`onNewMention` fires when a user @mentions the bot — for example, `@codereview can you review this?`. The handler extracts the PR details from the message's raw payload, runs the sandboxed review, and posts the result. Calling `thread.subscribe()` lets the bot respond to follow-up messages in the same thread.
-
-## Handle the webhook
-
-Create the Hono app with a single webhook route that delegates to Chat SDK:
-
-```typescript title="src/index.ts" lineNumbers
-import { Hono } from "hono";
-import { waitUntil } from "@vercel/functions";
-import { bot } from "./bot";
-
-const app = new Hono();
-
-app.post("/api/webhooks/github", async (c) => {
-  const handler = bot.webhooks.github;
-  if (!handler) {
-    return c.text("GitHub adapter not configured", 404);
-  }
-
-  return handler(c.req.raw, { waitUntil });
-});
-
-export default app;
-```
-
-Chat SDK's GitHub adapter handles signature verification, event parsing, and routing internally. The `waitUntil` option ensures the review completes after the HTTP response is sent — required on serverless platforms where the function would otherwise terminate before your handlers finish.
-
-## Test locally
-
-1. Start your development server (`pnpm dev`)
-2. Expose it with a tunnel (e.g. `ngrok http 3000`)
-3. Update the webhook URL in your GitHub repository settings to your tunnel URL
-4. Open a pull request
-5. Comment `@my-review-bot can you review this?` — the bot should respond with "Starting code review..." followed by the full review
-
-## Deploy to Vercel
-
-Deploy your bot to Vercel:
-
-```sh title="Terminal"
-vercel deploy
-```
-
-After deployment, set your environment variables in the Vercel dashboard (`GITHUB_TOKEN`, `GITHUB_WEBHOOK_SECRET`, `REDIS_URL`, `BOT_USERNAME`). Update the webhook URL in your GitHub repository settings to your production URL.
-
-## Next steps
-
-- [GitHub adapter](/adapters/github) — Authentication options, thread model, and full configuration reference
-- [State Adapters](/docs/state) — Production state adapters (Redis, PostgreSQL, ioredis) for subscriptions and distributed locking