Agent Slack Bot 만들기 (feat. Chat SDK)

import { Chat } from 'chat';
import { createSlackAdapter } from '@chat-adapter/slack';
import { createRedisState } from '@chat-adapter/state-redis';
 
const bot = new Chat({
  userName: 'mybot',
  adapters: { slack: createSlackAdapter() },
  state: createRedisState(),
});
 
bot.onNewMention(async (thread) => {
  await thread.post('안녕하세요!');
});

# 기본
npm create chat-sdk@latest my-bot
 
# slack, redis 설정 포함
npm create chat-sdk@latest -- my-bot --adapter slack redis -y

const bot = new Chat({
  userName: 'mybot',
  adapters: { slack: createSlackAdapter() },
  state: createRedisState(),
});

bot.onNewMention(async (thread, message) => {
  await thread.subscribe();
  await thread.post('스레드를 구독하고 있습니다.');
});
 
bot.onSubscribedMessage(async (thread, message) => {
  await thread.post(`구독 답변: ${message.text}`);
});

for await (const message of thread.allMessages) {
  console.log(message.author.fullName, message.text);
}

const result = await agent.stream({ prompt: message.text });
await thread.post(result.fullStream);

import { bot } from '@/lib/bot';
 
export const POST = bot.webhooks.slack;

@봇 이 스레드 요약해줘
@봇 이 이슈 전에도 있었어?
@봇 이 스레드 지식 저장해줘
@봇 이거 기술검토해줘

interface Context {
  params: Promise<{ platform: string }>;
}
 
async function handleRequest(request: Request, context: Context) {
  const { platform } = await context.params;
 
  const bot = getBot();
  const handler = bot.webhooks[platform as keyof typeof bot.webhooks];
 
  if (!handler) {
    return new Response(`Unknown platform: ${platform}`, { status: 404 });
  }
 
  return handler(request, {
    waitUntil: (task) => after(() => task),
  });
}
 
export const GET = handleRequest;
export const POST = handleRequest;

let instance: Chat | undefined;
 
export function getBot(): Chat {
  if (!instance) {
    instance = new Chat({
      userName: process.env.BOT_USERNAME ?? 'slack-bot',
      adapters: {
        slack: createSlackAdapter(),
      },
      state: createPostgresState(),
    });
 
    registerHandlers(instance);
  }
 
  return instance;
}

function registerHandlers(chat: Chat) {
  // 채널에서는 멘션을 부를때만 응답을 전달합니다.
  chat.onNewMention(respond);
 
  // DM에서 활성화를 원한다면, 추가로 연결해줍니다.
  chat.onDirectMessage(respond);
}

/**
 * 스레드 내용과 메세지를 사용해 agent를 실행하고, 슬랙에 응답을 전달합니다.
 */
async function respond(thread: Thread, message: Message) {
  const requestedBy = message.author.fullName || message.author.userName;
 
  try {
    // 응답 중에 로딩 상태를 표시합니다.
    await thread.startTyping('스레드를 읽는 중...');
 
    // 아래 4번에서 다룰 bot의 핵심 Agent 도구 함수입니다.
    const agent = createKnowledgeAgent({ thread, requestedBy });
    // 멘션 내용을 제외하고 prompt로 전달합니다.
    const result = await agent.stream({ prompt: stripMentionIds(message.text) });
 
    await thread.post(result.fullStream);
  } catch (error) {
    console.error('[respond] 처리 실패', { threadId: thread.id, error });
    await thread.post('잠시 후 다시 시도해 주세요.');
  }
}

export async function toSourceThread(thread: Thread, options: ToSourceThreadOptions = {}): Promise<SourceThread> {
  const messages: SourceMessage[] = [];
 
  // 스레드의 메세지 내용을 추출합니다.
  for await (const message of thread.allMessages) {
    // 봇 메세지와 시스템 메세지는 건너뜁니다.
    if (message.author.isMe || message.author.isSystem) continue;
 
    // 멘션 내용은 제거합니다.
    const text = stripMentionIds(message.text);
    if (!text) continue;
 
    messages.push({
      authorName: message.author.fullName || message.author.userName,
      text,
      postedAt: message.metadata.dateSent,
    });
  }
 
  let channelName: string | undefined;
  let permalink: string | undefined;
 
  // 저장 요청의 경우 슬랙에서 채널 이름과 원본 링크를 가져옵니다.
  if (options.forStorage) {
    try {
      await thread.channel.fetchMetadata();
      channelName = thread.channel.name ?? undefined;
    } catch {}
    // slack api를 사용해 원문 링크를 전달합니다.
    permalink = await resolvePermalink(thread.id);
  }
 
  return {
    key: thread.id,
    channelId: thread.channelId,
    channelName,
    permalink,
    messages,
  };
}

export function createKnowledgeAgent({ thread, requestedBy }: AgentContext) {
  return new ToolLoopAgent({
    model: reasoningModel,
    instructions: INSTRUCTIONS,
    providerOptions: { anthropic: { effort: 'high' } },
    tools: {
      // 도구 1 : 스레드를 읽을 때
      read_thread: tool({
        description:
          '지금 스레드의 대화 원문을 읽는다. 요약이나 기술검토처럼 스레드 내용 자체가 ' +
          '필요한 요청에서 먼저 부른다.',
        inputSchema: z.object({}),
        execute: async () => {
          const source = await toSourceThread(thread);
          return {
            messageCount: source.messages.length,
            transcript: renderTranscript(source),
          };
        },
      }),
      // 도구 2 : 유사 스레드 찾을 때
      find_related_knowledge: tool({
        description:
          '지금 스레드의 논의와 같은 상황을 다룬 과거 기록이 지식베이스에 있는지 찾는다. ' +
          "'이거 전에 있었던 이슈야?', '전에 이런 적 있었나?' 같은 질문에 쓴다.",
        inputSchema: z.object({}),
        execute: async () => {
          const source = await toSourceThread(thread);
          const result = await findRelatedKnowledge(source);
 
          return {
            searchedFor: result.situation,
            verdict: result.related.length > 0 ? 'related_found' : 'no_related_record',
            related: result.related.map((match) => ({
              ...describeEntry(match.entry),
              why: match.why,
            })),
            adjacent: result.adjacent.map(describeEntry),
          };
        },
      }),
      // 도구 3 : 스레드를 저장할 때
      save_knowledge: tool({
        description:
          '지금 스레드를 지식베이스에 저장한다. 이미 저장된 스레드면 새로 만들지 않고 ' +
          "스레드를 다시 읽어 기존 기록을 갱신한다. '이 스레드 저장해줘', '지식으로 남겨줘'에 쓴다.",
        inputSchema: z.object({}),
        execute: async () => {
          // DM에 저장하면 출처 채널이 그 DM이라 아무도 찾을 수 없다. 저장했다고
          // 답해놓고 아무도 못 찾는 상태가 제일 나쁘므로 여기서 막는다.
          if (thread.isDM) {
            return {
              saved: false,
              reason: 'DM에서는 저장하지 않습니다. 채널에서 저장해야 다른 사람이 찾을 수 있습니다.',
            };
          }
 
          const source = await toSourceThread(thread, { forStorage: true });
          const { entry, created } = await saveThreadAsKnowledge(source, requestedBy);
 
          return {
            saved: true,
            created,
            visibility: '워크스페이스 전원이 검색할 수 있습니다.',
            entry: describeEntry(entry),
          };
        },
      }),
      // 도구 4 : 스레드를 삭제할 때
      delete_knowledge: tool({
        description: '지금 스레드의 기록을 지식베이스에서 지운다. 공개돼선 안 될 내용이 저장됐을 때 쓴다.',
        inputSchema: z.object({}),
        execute: async () => {
          const deleted = await forgetThread(thread.id);
          return deleted
            ? { deleted: true, entry: describeEntry(deleted) }
            : { deleted: false, reason: '이 스레드는 지식베이스에 저장된 적이 없습니다.' };
        },
      }),
    },
  });
}

let pool: Pool | undefined;
 
export function db(): Pool {
  // pool이 없을 때만, 생성합니다.
  if (!pool) {
    const connectionString = process.env.POSTGRES_URL ?? process.env.DATABASE_URL;
    if (!connectionString) {
      throw new Error('POSTGRES_URL (또는 DATABASE_URL) 환경변수가 없습니다.');
    }
    // 서버리스 환경이므로, 최대 3개의 연결을 설정합니다.
    pool = new Pool({ connectionString, max: 3 });
  }
  return pool;
}

export interface ExtractOptions {
  model?: LanguageModel;
}
 
export async function extractDraft(thread: SourceThread, options: ExtractOptions = {}): Promise<EntryDraft> {
  if (thread.messages.length === 0) {
    throw new Error(`빈 스레드에서는 지식을 뽑을 수 없습니다: ${thread.key}`);
  }
 
  const { object, usage } = await generateObject({
    model: options.model ?? reasoningModel,
    schema: draftSchema,
    schemaName: 'knowledge_entry',
    system: SYSTEM_PROMPT,
    prompt: renderTranscript(thread),
    maxOutputTokens: 4000,
    providerOptions: {
      anthropic: { effort: 'high' },
    },
  });
 
  return object;
}