Build a daily digest bot with Chat SDK and Workflow SDK

I want to deploy and customize the daily digest bot template.

Clone the repo at https://github.com/vercel-labs/daily-digest-bot, then read AGENTS.md and ARCHITECTURE.md to understand how it's built and the conventions to follow.

Install dependencies with pnpm, then help me run it locally with `pnpm dev` and deploy with `vercel deploy`. When searching for information, check for applicable skill(s) first and then Vercel documentation.
I want to deploy and customize the durable web research agent template.

Clone the repo at https://github.com/vercel-labs/durable-web-research-agent, then read AGENTS.md and ARCHITECTURE.md to understand how it's built and the conventions to follow.

Install dependencies with pnpm, then help me run it locally with `pnpm dev` and deploy with `vercel deploy`. When searching for information, check for applicable skill(s) first and then Vercel documentation.

npx plugins add vercel/vercel-plugin

pnpm create next-app@latest scheduled-digest-bot --yes
cd scheduled-digest-bot

pnpm add chat @chat-adapter/slack @chat-adapter/state-redis ai workflow @vercel/connect zod

import { withWorkflow } from "workflow/next";
import type { NextConfig } from "next";

const nextConfig: NextConfig = {
  serverExternalPackages: [
    "@chat-adapter/slack",
    "@chat-adapter/state-redis",
    "@redis/client",
    "@slack/socket-mode",
    "@slack/web-api",
    "redis",
  ],
};

export default withWorkflow(nextConfig);

vercel link
vercel integration add upstash

vercel env pull

VERCEL_OIDC_TOKEN=...

CONNECTOR_SLACK=slack/digest-bot

CRON_SECRET="replace-with-a-long-random-string" # e.g. "openssl rand --base64 32"
DIGEST_CHANNEL_ID="slack:SLACK_CHANNEL_ID"

CONNECTOR_GITHUB=github/digest-github

import { getToken } from "@vercel/connect";

export async function getGitHubToken() {
  const connector = process.env.CONNECTOR_GITHUB;

  if (!connector) {
    throw new Error("CONNECTOR_GITHUB is required.");
  }

  return getToken(connector, { subject: { type: "app" } });
}

import { createSlackAdapter } from "@chat-adapter/slack";
import { createRedisState } from "@chat-adapter/state-redis";
import { getToken } from "@vercel/connect";
import { Chat } from "chat";

let bot: Chat | null = null;

function getSlackBotToken() {
  const connector = process.env.CONNECTOR_SLACK;

  if (!connector) {
    throw new Error(
      "CONNECTOR_SLACK is required. Use the Vercel Connect connector id, such as slack/acme-slack.",
    );
  }

  return getToken(connector, { subject: { type: "app" } });
}

function verifyConnectForwardedSlackRequest() {
  return true;
}

export function getBot() {
  if (!bot) {
    bot = new Chat({
      userName: process.env.BOT_USER_NAME ?? "digest-bot",
      adapters: {
        slack: createSlackAdapter({
          botToken: getSlackBotToken,
          webhookVerifier: verifyConnectForwardedSlackRequest,
        }),
      },
      state: createRedisState(),
      dedupeTtlMs: 600_000,
    }).registerSingleton();
  }

  return bot;
}

import { z } from "zod";

export const DigestConfigSchema = z.object({
  tone: z.enum(["terse", "detailed"]).default("terse"),
  maxSections: z.number().int().positive().max(8).default(4),
  include: z
    .array(z.string())
    .default(["github-repositories", "github-issues"]),
});

export const DigestInputSchema = z.object({
  channelId: z.string().min(1),
  lookbackHours: z.number().int().positive().max(168).default(24),
  detailsUrl: z.url().optional(),
  config: DigestConfigSchema.default({
    tone: "terse",
    maxSections: 4,
    include: ["github-repositories", "github-issues"],
  }),
});

export const DigestChannelIdSchema = z.string().min(1);

export type DigestConfig = z.infer<typeof DigestConfigSchema>;
export type DigestInput = z.infer<typeof DigestInputSchema>;

export type GatherActivity = (input: DigestInput) => Promise<unknown>;

export const DigestSchema = z.object({
  headline: z.string().min(1),
  sections: z
    .array(
      z.object({
        label: z.string().min(1),
        body: z.string().min(1),
      }),
    )
    .min(1),
});

export type Digest = z.infer<typeof DigestSchema>;

import {
  DigestChannelIdSchema,
  type DigestConfig,
  type DigestInput,
} from "./types";

const DIGEST_LOOKBACK_HOURS = 24;
const DIGEST_DETAILS_URL = "https://vercel.com";

const DIGEST_CONFIG: DigestConfig = {
  tone: "terse",
  maxSections: 4,
  include: ["github-repositories", "github-issues"],
};

export async function loadDigestChannel(): Promise<DigestInput | null> {
  const raw = process.env.DIGEST_CHANNEL_ID;

  if (!raw) {
    return null;
  }

  const channelId = DigestChannelIdSchema.parse(raw);

  return {
    channelId,
    lookbackHours: DIGEST_LOOKBACK_HOURS,
    detailsUrl: DIGEST_DETAILS_URL,
    config: DIGEST_CONFIG,
  };
}

import { start } from "workflow/api";
import { loadDigestChannel } from "@/lib/digest/enrollment";
import { runDailyDigest } from "@/lib/digest/workflow";

export async function GET(request: Request) {
  const auth = request.headers.get("authorization");

  if (!process.env.CRON_SECRET || auth !== `Bearer ${process.env.CRON_SECRET}`) {
    return new Response("Unauthorized", { status: 401 });
  }

  const channel = await loadDigestChannel();

  if (!channel) {
    return Response.json({ started: false, reason: "DIGEST_CHANNEL_ID is not set" });
  }

  const run = await start(runDailyDigest, [channel]);

  return Response.json({ started: true, runId: run.runId });
}

{
  "crons": [
    {
      "path": "/api/cron/digest",
      "schedule": "0 8 * * *"
    }
  ]
}

import { fetchGitHubActivity, generateDigest, postDigest } from "./step";
import type { DigestInput } from "./types";

export async function runDailyDigest(channel: DigestInput) {
  "use workflow";

  try {
    const activity = await fetchGitHubActivity(channel);
    const digest = await generateDigest(channel, activity);

    await postDigest(channel, digest);

    return { posted: 1, failed: 0, channelId: channel.channelId };
  } catch (error) {
    return {
      posted: 0,
      failed: 1,
      channelId: channel.channelId,
      error: error instanceof Error ? error.message : String(error),
    };
  }
}

import { generateText, Output } from "ai";
import { postDigestCard } from "./card";
import { buildPrompt } from "./prompt";
import { gatherProjectActivity } from "./sources";
import { DigestSchema, type Digest, type DigestInput } from "./types";

export async function fetchGitHubActivity(input: DigestInput) {
  "use step";

  return gatherProjectActivity(input);
}

export async function generateDigest(input: DigestInput, activity: unknown) {
  "use step";

  const { output } = await generateText({
    model: process.env.DIGEST_MODEL ?? "anthropic/claude-haiku-4.5",
    output: Output.object({
      schema: DigestSchema,
      name: "daily_digest",
      description: "A concise channel digest with headline and sections.",
    }),
    prompt: buildPrompt(activity, input.config),
  });

  return output;
}

export async function postDigest(input: DigestInput, digest: Digest) {
  "use step";

  return postDigestCard(input, digest);
}

type RepositorySummary = {
  name: string;
  visibility: "public" | "private";
};

type RecentIssue = {
  repository: string;
  title: string;
  url: string;
  createdAt: string;
};

type IssueReport = {
  repository: RepositorySummary;
  openIssueCount: number;
  recentlyOpenedIssues: RecentIssue[];
};

function buildDigestActivity(
  repositories: RepositorySummary[],
  issueReports: IssueReport[],
  maxProcessed: number,
) {
  const publicRepositories = repositories.filter(
    (repository) => repository.visibility === "public",
  );
  const privateRepositories = repositories.filter(
    (repository) => repository.visibility === "private",
  );
  const recentlyOpened = issueReports
    .flatMap((report) => report.recentlyOpenedIssues)
    .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
  const openInPublicRepositories = sumOpenIssues(issueReports, "public");
  const openInPrivateRepositories = sumOpenIssues(issueReports, "private");

  return {
    repositories: {
      total: repositories.length,
      public: publicRepositories.length,
      private: privateRepositories.length,
      processed: Math.min(repositories.length, maxProcessed),
      maxProcessed,
    },
    issues: {
      totalOpen: openInPublicRepositories + openInPrivateRepositories,
      openInPublicRepositories,
      openInPrivateRepositories,
      recentlyOpenedInLookback: recentlyOpened.length,
      recentlyOpened,
      byRepository: issueReports.map((report) => ({
        repository: report.repository.name,
        visibility: report.repository.visibility,
        openIssueCount: report.openIssueCount,
        recentlyOpenedInLookback: report.recentlyOpenedIssues.length,
      })),
    },
  };
}

function sumOpenIssues(
  issueReports: IssueReport[],
  visibility: RepositorySummary["visibility"],
) {
  return issueReports
    .filter((report) => report.repository.visibility === visibility)
    .reduce((sum, report) => sum + report.openIssueCount, 0);
}

import type { DigestConfig } from "./types";

export function buildPrompt(activity: unknown, config: DigestConfig) {
  return [
    `Write a ${config.tone} daily GitHub issues digest.`,
    `Return at most ${config.maxSections} sections.`,
    `Only include these source areas: ${config.include.join(", ")}.`,
    "Include the total number of public repositories and private repositories.",
    "Include the total number of open issues in public repositories and private repositories.",
    "If repository totals may be limited by the fetch cap, call that out briefly.",
    "Highlight newly opened issues, affected repositories, owners, labels, and notable themes.",
    "If there are no recently opened issues, still summarize the repository and open issue totals.",
    "Use clear labels and concise bodies.",
    "Return a headline and sections that match the requested schema.",
    JSON.stringify(activity, null, 2),
  ].join("\n\n");
}

import { Actions, Card, CardText, LinkButton, Section } from "chat";
import { getBot } from "@/lib/bot";
import type { Digest, DigestInput } from "./types";

export async function postDigestCard(input: DigestInput, digest: Digest) {
  const channel = getBot().channel(input.channelId);

  await channel.post(
    Card({
      title: digest.headline,
      children: [
        ...digest.sections.map((section) =>
          Section([CardText(`**${section.label}** ${section.body}`)]),
        ),
        Actions([
          LinkButton({
            url: input.detailsUrl ?? "https://vercel.com",
            label: "View details",
          }),
        ]),
      ],
    }),
  );

  return { posted: true as const, channelId: input.channelId };
}

pnpm dev

curl -H "Authorization: Bearer $CRON_SECRET" \
  http://localhost:3000/api/cron/digest

pnpm exec workflow web