@cursor/bdk 0.2.2 → 0.2.4

package/src/channels/slack/agentic-delivery.ts

@@ -1,634 +0,0 @@
-/**
- * Agentic Slack watches communication tools on the turn stream and
- * renders them through the channel Slack client. The tools do not call
- * Slack. Writes happen on a successful, non-stubbed `action.result`.
- *
- * Ack and the thinking chip are channel-owned: they fire on `turn.started`
- * / `reasoning.appended` / `actions.requested`, not from model `react` /
- * `set-status`. Prefer the last assistant line before a `tool_call`.
- */
-
-import {
-  markHostedFirstVisibleReply,
-  noteHostedVisibleReplyError,
-} from "../../internal/hosted-execution-latency.js";
-import type { ChannelEventContext, ChannelEventHandlers, HostContext } from "../../types.js";
-import {
-  begin,
-  bind,
-  end,
-  has,
-  latest,
-  latestPosted,
-  remove,
-  resolve,
-  setPostedText,
-} from "./agentic-posted.js";
-import {
-  DELETE_MESSAGE,
-  EDIT_MESSAGE,
-  isOwnedSignal,
-  isSignal,
-  POST_CARD,
-  POST_FILE,
-  POST_UPDATE,
-  parseCard,
-  parseDelete,
-  parseEdit,
-  parseReaction,
-  parseStagedFile,
-  parseUpdate,
-  REACT,
-} from "./agentic-signals.js";
-import { addReaction, deleteMessage, postMessage, setThreadStatus, updateMessage } from "./api.js";
-import { paintSlackFooter, type SlackReplyFooter, turnDurationMs } from "./footer.js";
-import { createStreamDeliveryStrategy } from "./live-delivery.js";
-import { defaultSlackLog, type SlackLog } from "./log.js";
-import { paintTurnStart } from "./paint-start.js";
-import { finishPlaceholder, overlayPlaceholder, startPlaceholder } from "./placeholder.js";
-import { commitReasoningChip, nextReasoningChip } from "./reasoning-chip.js";
-import { DEFAULT_ACK, type ResolvedSlackStatus } from "./reply-options.js";
-import { rememberPendingToolCall, takeToolChipLine } from "./tool-chip.js";
-import type {
-  SlackBotToken,
-  SlackChannelState,
-  SlackCredentials,
-  SoftSlackResult,
-} from "./types.js";
-import { type ThreadFile, uploadThreadFiles } from "./upload.js";
-
-type SlackChannel = ChannelEventContext<SlackChannelState>;
-
-type AgenticWrite = {
-  channel: SlackChannel;
-  output: unknown;
-  sessionId: string;
-  botToken: SlackBotToken | undefined;
-  getLog: () => SlackLog;
-};
-
-function nested(event: { data: { parentCallId?: string } }): boolean {
-  return event.data.parentCallId !== undefined;
-}
-
-function skip(event: { data: { parentCallId?: string } }, dryRun: boolean | undefined): boolean {
-  return nested(event) || dryRun === true;
-}
-
-function thread(state: SlackChannelState): { channelId: string; threadTs: string } | undefined {
-  if (state.channelId === null || state.channelId === "") {
-    return undefined;
-  }
-  if (state.threadTs === null || state.threadTs === "") {
-    return undefined;
-  }
-  return { channelId: state.channelId, threadTs: state.threadTs };
-}
-
-async function postStaticPlaceholder(args: {
-  channel: SlackChannel;
-  placeholder: string | undefined;
-  botToken: SlackBotToken | undefined;
-  log: SlackLog;
-}): Promise<void> {
-  if (args.channel.state.placeholderPosted === true) {
-    return;
-  }
-  if (args.placeholder === undefined) {
-    return;
-  }
-  const target = thread(args.channel.state);
-  if (target === undefined) {
-    return;
-  }
-  const started = startPlaceholder({
-    line: args.placeholder,
-    botToken: args.botToken,
-    channelId: target.channelId,
-    threadTs: target.threadTs,
-    log: args.log,
-    recipientUserId: args.channel.state.triggeringUserId,
-    recipientTeamId: args.channel.state.teamId,
-  });
-  await started?.done;
-}
-
-async function setChip(
-  channel: SlackChannel,
-  status: string,
-  botToken: SlackBotToken | undefined,
-  getLog: () => SlackLog,
-  loadingMessages?: readonly string[],
-): Promise<boolean> {
-  const target = thread(channel.state);
-  if (target === undefined) {
-    return false;
-  }
-  const result = await setThreadStatus({
-    botToken,
-    channelId: target.channelId,
-    threadTs: target.threadTs,
-    status,
-    loadingMessages: loadingMessages === undefined ? undefined : [...loadingMessages],
-  });
-  if (!result.ok) {
-    getLog().warn(`agentic status failed: ${result.error}`, {
-      channel: target.channelId,
-      thread_ts: target.threadTs,
-    });
-    return false;
-  }
-  return true;
-}
-
-async function postNew(args: {
-  channel: SlackChannel;
-  text: string;
-  ts?: string;
-  sessionId: string;
-  botToken: SlackBotToken | undefined;
-  getLog: () => SlackLog;
-}): Promise<void> {
-  const state = args.channel.state;
-  const target = thread(state);
-  if (target === undefined) {
-    return;
-  }
-  const log = args.getLog();
-  const overlaid = await overlayPlaceholder({
-    channelId: target.channelId,
-    threadTs: target.threadTs,
-    botToken: args.botToken,
-    text: args.text,
-  });
-  if (overlaid !== undefined) {
-    state.lastPostedText = args.text;
-    state.lastBotMessageTs = overlaid;
-    bind(args.sessionId, args.ts ?? overlaid, overlaid, args.text);
-    log.info("placeholder replaced", {
-      channel: target.channelId,
-      thread_ts: target.threadTs,
-      message_ts: overlaid,
-      session: args.sessionId,
-      chars: args.text.length,
-    });
-    markHostedFirstVisibleReply({
-      outcome: "progress_update",
-      deliverySurface: "slack",
-    });
-    await setChip(args.channel, "", args.botToken, args.getLog);
-    return;
-  }
-  try {
-    const posted = await postMessage({
-      botToken: args.botToken,
-      channel: target.channelId,
-      text: args.text,
-      threadTs: target.threadTs,
-    });
-    state.lastPostedText = args.text;
-    state.lastBotMessageTs = posted.ts;
-    bind(args.sessionId, args.ts ?? posted.ts, posted.ts, args.text);
-    log.info("agentic reply posted", {
-      channel: target.channelId,
-      thread_ts: target.threadTs,
-      message_ts: posted.ts,
-      session: args.sessionId,
-      chars: args.text.length,
-    });
-    markHostedFirstVisibleReply({
-      outcome: "final_post",
-      deliverySurface: "slack",
-    });
-    await setChip(args.channel, "", args.botToken, args.getLog);
-  } catch (error) {
-    log.warn(`agentic reply failed: ${error instanceof Error ? error.message : String(error)}`, {
-      channel: target.channelId,
-      thread_ts: target.threadTs,
-    });
-    noteHostedVisibleReplyError({ deliverySurface: "slack" });
-  }
-}
-
-export function buildAgenticEvents(options: {
-  credentials?: SlackCredentials;
-  getLog?: () => SlackLog;
-  ack?: string;
-  placeholder?: string;
-  status: ResolvedSlackStatus;
-  footer?: SlackReplyFooter;
-}): ChannelEventHandlers<SlackChannelState> {
-  const botToken = options.credentials?.botToken;
-  const getLog = options.getLog ?? (() => defaultSlackLog);
-  const ack = options.ack ?? DEFAULT_ACK;
-  const placeholder = options.placeholder;
-  const status = options.status;
-  const stream = createStreamDeliveryStrategy({ botToken, getLog });
-
-  return {
-    async "turn.started"(event, channel, ctx) {
-      await stream.cleanupOrphan({ channel });
-      channel.state.agenticFiles = [];
-      channel.state.streamTs = null;
-      channel.state.streamChannelId = null;
-      channel.state.streamFull = false;
-      channel.state.streamingUnavailable = false;
-      channel.state.streamAppendedChunks = 0;
-      channel.state.lastReasoningTypingAtMs = null;
-      channel.state.lastReasoningTypingStatus = null;
-      channel.state.pendingToolCallMessage = null;
-      channel.state.turnStartedAtMs = Date.now();
-      begin(event.sessionId);
-      if (ctx.session.dryRun === true) {
-        return;
-      }
-      const target = thread(channel.state);
-      if (target === undefined) {
-        return;
-      }
-      if (channel.state.startPainted !== true) {
-        await paintTurnStart({
-          botToken,
-          channelId: target.channelId,
-          threadTs: target.threadTs,
-          ack,
-          log: getLog(),
-        });
-      }
-      await postStaticPlaceholder({
-        channel,
-        placeholder,
-        botToken,
-        log: getLog(),
-      });
-    },
-
-    async "message.received"(_event, channel, ctx) {
-      if (ctx.session.dryRun === true) {
-        return;
-      }
-      await postStaticPlaceholder({
-        channel,
-        placeholder,
-        botToken,
-        log: getLog(),
-      });
-    },
-
-    async "reasoning.appended"(event, channel, ctx) {
-      if (nested(event) || ctx.session.dryRun === true) {
-        return;
-      }
-      if (status.reasoning === false) {
-        return;
-      }
-      const now = Date.now();
-      const line = nextReasoningChip(channel.state, event.data.text, now);
-      if (line === undefined) {
-        return;
-      }
-      if (await setChip(channel, line, botToken, getLog, [line])) {
-        commitReasoningChip(channel.state, line, now);
-      }
-    },
-
-    async "message.completed"(event, channel, ctx) {
-      if (nested(event) || ctx.session.dryRun === true) {
-        return;
-      }
-      rememberPendingToolCall(channel.state, event.data.finishReason, event.data.text);
-    },
-
-    async "actions.requested"(event, channel, ctx) {
-      if (skip(event, ctx.session.dryRun)) {
-        return;
-      }
-      const calls = event.data.calls.filter(call => !isOwnedSignal(call.toolName));
-      const line = takeToolChipLine(channel.state, status.tools, calls);
-      if (line === undefined) {
-        return;
-      }
-      await setChip(channel, line, botToken, getLog, [line]);
-    },
-
-    async "action.result"(event, channel, ctx) {
-      if (skip(event, ctx.session.dryRun)) {
-        return;
-      }
-      if (event.data.isError || event.data.stubbed === true) {
-        return;
-      }
-      if (isSignal(event.data.toolName, POST_UPDATE)) {
-        const update = parseUpdate(event.data.output);
-        if (update === undefined) {
-          return;
-        }
-        await postNew({
-          channel,
-          text: update.message,
-          ts: update.ts,
-          sessionId: ctx.session.id,
-          botToken,
-          getLog,
-        });
-        return;
-      }
-      if (isSignal(event.data.toolName, EDIT_MESSAGE)) {
-        await applyEdit({
-          channel,
-          output: event.data.output,
-          sessionId: ctx.session.id,
-          botToken,
-          getLog,
-        });
-        return;
-      }
-      if (isSignal(event.data.toolName, DELETE_MESSAGE)) {
-        await applyDelete({
-          channel,
-          output: event.data.output,
-          sessionId: ctx.session.id,
-          botToken,
-          getLog,
-        });
-        return;
-      }
-      if (isSignal(event.data.toolName, POST_CARD)) {
-        const card = parseCard(event.data.output);
-        const channelId = channel.state.channelId;
-        if (card === undefined || channelId === null || channelId === "") {
-          return;
-        }
-        await stream.appendChunks({
-          channel,
-          channelId,
-          sessionId: ctx.session.id,
-          chunks: [
-            {
-              type: "task_update",
-              id: card.id,
-              title: card.title,
-              status: card.status,
-              details: card.details,
-            },
-          ],
-        });
-        return;
-      }
-      if (isSignal(event.data.toolName, REACT)) {
-        await applyReaction({
-          channel,
-          output: event.data.output,
-          sessionId: ctx.session.id,
-          botToken,
-          getLog,
-        });
-        return;
-      }
-      if (!isSignal(event.data.toolName, POST_FILE)) {
-        return;
-      }
-      const file = parseStagedFile(event.data.output);
-      if (file === undefined) {
-        return;
-      }
-      const staged = channel.state.agenticFiles ?? [];
-      staged.push(file);
-      channel.state.agenticFiles = staged;
-    },
-
-    async "turn.completed"(_event, channel, ctx) {
-      await stream.cleanupOrphan({ channel });
-      if (ctx.session.dryRun !== true) {
-        await setChip(channel, "", botToken, getLog);
-        await paintFooter({
-          channel,
-          sessionId: ctx.session.id,
-          status: "completed",
-          footer: options.footer,
-          botToken,
-          getLog,
-          host: ctx.host,
-        });
-      }
-      await retractUnclaimed(channel, botToken, getLog);
-      end(ctx.session.id);
-      const files = channel.state.agenticFiles ?? [];
-      channel.state.agenticFiles = [];
-      await uploadStaged(files, channel, botToken, getLog);
-    },
-
-    async "turn.failed"(_event, channel, ctx) {
-      await stream.cleanupOrphan({ channel });
-      channel.state.agenticFiles = [];
-      if (ctx.session.dryRun !== true) {
-        await setChip(channel, "", botToken, getLog);
-        await paintFooter({
-          channel,
-          sessionId: ctx.session.id,
-          status: "failed",
-          footer: options.footer,
-          botToken,
-          getLog,
-          host: ctx.host,
-        });
-      }
-      await retractUnclaimed(channel, botToken, getLog);
-      end(ctx.session.id);
-    },
-  };
-}
-
-async function paintFooter(args: {
-  channel: SlackChannel;
-  sessionId: string;
-  status: "completed" | "failed";
-  footer: SlackReplyFooter | undefined;
-  botToken: SlackBotToken | undefined;
-  getLog: () => SlackLog;
-  host?: HostContext;
-}): Promise<void> {
-  const posted = latestPosted(args.sessionId);
-  const target = thread(args.channel.state);
-  if (posted === undefined || target === undefined) {
-    return;
-  }
-  const result = await paintSlackFooter({
-    footer: args.footer,
-    ctx: {
-      sessionId: args.sessionId,
-      channelId: target.channelId,
-      threadTs: target.threadTs,
-      text: posted.text,
-      status: args.status,
-      durationMs: turnDurationMs(args.channel.state.turnStartedAtMs),
-      host: args.host,
-    },
-    ts: posted.ts,
-    botToken: args.botToken,
-  });
-  if (result !== undefined && !result.ok) {
-    args.getLog().warn(`agentic footer failed: ${result.error}`, {
-      channel: target.channelId,
-      ts: posted.ts,
-    });
-  }
-}
-
-async function retractUnclaimed(
-  channel: SlackChannel,
-  botToken: SlackBotToken | undefined,
-  getLog: () => SlackLog,
-): Promise<void> {
-  const target = thread(channel.state);
-  if (target === undefined) {
-    return;
-  }
-  await finishPlaceholder({
-    channelId: target.channelId,
-    threadTs: target.threadTs,
-    botToken,
-    log: getLog(),
-  });
-}
-
-async function applyOwned(args: {
-  channel: SlackChannel;
-  sessionId: string;
-  ts: string;
-  botToken: SlackBotToken | undefined;
-  getLog: () => SlackLog;
-  verb: "edit" | "delete";
-  write: (channelId: string, ts: string) => Promise<SoftSlackResult>;
-  ok?: (ts: string) => void;
-}): Promise<void> {
-  const target = thread(args.channel.state);
-  if (target === undefined) {
-    return;
-  }
-  const log = args.getLog();
-  if (!has(args.sessionId, args.ts)) {
-    log.warn(`agentic ${args.verb} rejected: ts is not a message this turn posted`, {
-      channel: target.channelId,
-      ts: args.ts,
-    });
-    return;
-  }
-  const slackTs = resolve(args.sessionId, args.ts);
-  if (slackTs === undefined) {
-    return;
-  }
-  const result = await args.write(target.channelId, slackTs);
-  if (!result.ok) {
-    log.warn(`agentic ${args.verb} failed: ${result.error}`, {
-      channel: target.channelId,
-      ts: args.ts,
-    });
-    return;
-  }
-  if (args.ok !== undefined) {
-    args.ok(slackTs);
-  }
-}
-
-async function applyEdit(args: AgenticWrite): Promise<void> {
-  const edit = parseEdit(args.output);
-  if (edit === undefined) {
-    return;
-  }
-  await applyOwned({
-    channel: args.channel,
-    sessionId: args.sessionId,
-    ts: edit.ts,
-    botToken: args.botToken,
-    getLog: args.getLog,
-    verb: "edit",
-    write: (channelId, ts) =>
-      updateMessage({
-        botToken: args.botToken,
-        channel: channelId,
-        ts,
-        text: edit.message,
-      }),
-    ok: slackTs => {
-      setPostedText(args.sessionId, slackTs, edit.message);
-    },
-  });
-}
-
-async function applyDelete(args: AgenticWrite): Promise<void> {
-  const removed = parseDelete(args.output);
-  if (removed === undefined) {
-    return;
-  }
-  await applyOwned({
-    channel: args.channel,
-    sessionId: args.sessionId,
-    ts: removed.ts,
-    botToken: args.botToken,
-    getLog: args.getLog,
-    verb: "delete",
-    write: (channelId, ts) =>
-      deleteMessage({
-        botToken: args.botToken,
-        channel: channelId,
-        ts,
-      }),
-    ok: slackTs => {
-      remove(args.sessionId, removed.ts);
-      if (args.channel.state.lastBotMessageTs === slackTs) {
-        args.channel.state.lastBotMessageTs = latest(args.sessionId) ?? null;
-      }
-    },
-  });
-}
-
-async function applyReaction(args: AgenticWrite): Promise<void> {
-  const reaction = parseReaction(args.output);
-  const target = thread(args.channel.state);
-  if (reaction === undefined || target === undefined) {
-    return;
-  }
-  const ts = reaction.ts ?? target.threadTs;
-  const result = await addReaction({
-    botToken: args.botToken,
-    channel: target.channelId,
-    ts,
-    name: reaction.emoji,
-  });
-  if (!result.ok) {
-    args.getLog().warn(`agentic react failed: ${result.error}`, {
-      channel: target.channelId,
-      ts,
-    });
-  }
-}
-
-async function uploadStaged(
-  files: readonly ThreadFile[],
-  channel: SlackChannel,
-  botToken: SlackBotToken | undefined,
-  getLog: () => SlackLog,
-): Promise<void> {
-  if (files.length === 0) {
-    return;
-  }
-  const target = thread(channel.state);
-  if (target === undefined) {
-    return;
-  }
-  const failures = await uploadThreadFiles({
-    botToken,
-    channelId: target.channelId,
-    threadTs: target.threadTs,
-    files,
-  });
-  if (failures.length === 0) {
-    return;
-  }
-  getLog().warn("agentic file upload failed", {
-    channel: target.channelId,
-    thread_ts: target.threadTs,
-    failures: failures.join("; "),
-  });
-}