@cursor/bdk 0.2.2 → 0.2.4

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

@@ -1,489 +0,0 @@
-/**
- * Live-reply delivery for Slack `chat.startStream` / append / stop.
- *
- * Cursor-account channels do not use this path — they reply with a single
- * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
- * (no message edits).
- *
- * Assistant-pane threads only render stream APIs. Start lazily with the
- * first real markdown/chunks plus recipient ids — empty startStream is
- * rejected or never attaches.
- *
- * Every call speaks `chunks`. Slack pins a stream's mode at start: text
- * opened as bare `markdown_text` rejects later `task_update` appends with
- * `streaming_mode_mismatch`, so assistant text goes out as `markdown_text`
- * chunks and tool steps can land in the same message.
- */
-
-import { markHostedFirstVisibleReply } from "../../internal/hosted-execution-latency.js";
-import type { ChannelEventContext } from "../../types.js";
-import { appendChatStream, postMessage, startChatStream, stopChatStream } from "./api.js";
-import { highlightCodeFences } from "./code-fences.js";
-import { SLACK_MARKDOWN_TEXT_MAX_LEN } from "./constants.js";
-import type { SlackLog } from "./log.js";
-import {
-  computeStreamAppend,
-  markdownChunk,
-  type StreamChunk,
-  type StreamTaskChunk,
-} from "./stream.js";
-import type { SlackBotToken, SlackChannelState } from "./types.js";
-
-type SlackChannel = ChannelEventContext<SlackChannelState>;
-
-export interface LiveDeliveryDeps {
-  botToken: SlackBotToken | undefined;
-  getLog: () => SlackLog;
-}
-
-type OpenArgs = {
-  channel: SlackChannel;
-  channelId: string;
-  threadTs?: string;
-  sessionId: string;
-  markdown_text?: string;
-  chunks?: StreamTaskChunk[];
-};
-
-type StreamArgs = {
-  channel: SlackChannel;
-  channelId: string;
-  sessionId: string;
-};
-
-/**
- * How the default handlers deliver an in-progress reply. Methods write live
- * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
- * `streamBlockText`, `streamingUnavailable`) on `channel.state` directly.
- */
-export interface LiveDeliveryStrategy {
-  readonly inlineToolSteps: boolean;
-  /** Open the live message with the first real markdown or task chunks. */
-  open(args: OpenArgs): Promise<boolean>;
-  append(args: StreamArgs & { text: string }): Promise<void>;
-  appendChunks(args: StreamArgs & { chunks: StreamTaskChunk[] }): Promise<boolean>;
-  /**
-   * Flush the final reply text. `delivered` is false only when the caller must
-   * post the full reply as a fresh message (finalize failed on partial text).
-   */
-  finalize(args: StreamArgs & { text: string }): Promise<{ delivered: boolean }>;
-  finalizeEmpty(args: { channel: SlackChannel }): Promise<void>;
-  cleanupOrphan(args: { channel: SlackChannel }): Promise<void>;
-  fail(args: StreamArgs & { errorText: string }): Promise<{ delivered: boolean }>;
-}
-
-function streamRecipients(channel: SlackChannel): {
-  recipient_user_id: string | undefined;
-  recipient_team_id: string | undefined;
-} {
-  const user = channel.state.triggeringUserId;
-  const team = channel.state.teamId;
-  return {
-    recipient_user_id: user === null || user === "" ? undefined : user,
-    recipient_team_id: team === null || team === "" ? undefined : team,
-  };
-}
-
-function activeStreamTs(channel: SlackChannel): string | null {
-  const ts = channel.state.streamTs;
-  return ts === null || ts === "" ? null : ts;
-}
-
-export function createStreamDeliveryStrategy(deps: LiveDeliveryDeps): LiveDeliveryStrategy {
-  const { botToken, getLog } = deps;
-
-  const open: LiveDeliveryStrategy["open"] = async ({
-    channel,
-    channelId,
-    threadTs,
-    sessionId,
-    markdown_text,
-    chunks,
-  }) => {
-    if (activeStreamTs(channel) !== null) {
-      return true;
-    }
-    const openingText = markdown_text ?? "";
-    const opening: StreamChunk[] = [];
-    if (openingText !== "") {
-      opening.push(markdownChunk(highlightCodeFences(openingText)));
-    }
-    opening.push(...(chunks ?? []));
-    if (opening.length === 0) {
-      return false;
-    }
-    const log = getLog();
-    const started = await startChatStream({
-      botToken,
-      channel: channelId,
-      thread_ts: threadTs,
-      chunks: opening,
-      ...streamRecipients(channel),
-    });
-    if (!started.ok) {
-      log.warn("chat.startStream unavailable", {
-        error: started.error,
-        channel: channelId,
-        thread_ts: threadTs,
-        session: sessionId,
-      });
-      if (started.unsupported === true) {
-        channel.state.streamingUnavailable = true;
-      }
-      return false;
-    }
-    channel.state.streamTs = started.ts;
-    channel.state.streamChannelId = started.channel;
-    channel.state.streamFull = false;
-    channel.state.streamAppendedChunks = 0;
-    channel.state.lastPostedText = openingText;
-    channel.state.streamBlockText = openingText;
-    log.info("chat.startStream ok", {
-      channel: started.channel,
-      stream_ts: started.ts,
-      session: sessionId,
-    });
-    markHostedFirstVisibleReply({
-      outcome: "progress_update",
-      deliverySurface: "slack",
-    });
-    return true;
-  };
-
-  const ensureOpen = async (
-    args: StreamArgs & {
-      markdown_text?: string;
-      chunks?: StreamTaskChunk[];
-    },
-  ): Promise<string | null> => {
-    const existing = activeStreamTs(args.channel);
-    if (existing !== null) {
-      return existing;
-    }
-    if (args.channelId === "") {
-      return null;
-    }
-    if (args.channel.state.threadTs === null || args.channel.state.threadTs === "") {
-      return null;
-    }
-    const opened = await open({
-      channel: args.channel,
-      channelId: args.channelId,
-      threadTs: args.channel.state.threadTs,
-      sessionId: args.sessionId,
-      markdown_text: args.markdown_text,
-      chunks: args.chunks,
-    });
-    return opened ? activeStreamTs(args.channel) : null;
-  };
-
-  /**
-   * What to append for the new cumulative text, as Slack should see it: the
-   * block text on both sides goes through the same fence rewrite, so the
-   * delta lines up with what the stream already holds.
-   */
-  const streamDelta = (channel: SlackChannel, text: string): string =>
-    computeStreamAppend(
-      highlightCodeFences(channel.state.streamBlockText ?? ""),
-      highlightCodeFences(text),
-    );
-
-  /**
-   * The reply does not extend what the stream already holds, so there is no
-   * delta to append and the text on Slack is not the reply.
-   */
-  const rewound = (channel: SlackChannel, text: string): boolean =>
-    streamDelta(channel, text) === "" &&
-    !highlightCodeFences(text).startsWith(highlightCodeFences(channel.state.streamBlockText ?? ""));
-
-  const countAppended = (channel: SlackChannel, chunks: number): void => {
-    channel.state.streamAppendedChunks = (channel.state.streamAppendedChunks ?? 0) + chunks;
-  };
-
-  const stopWithSuffix = async (args: {
-    channel: SlackChannel;
-    channelId: string;
-    ts: string;
-    text: string;
-  }): Promise<{ ok: boolean; error?: string }> => {
-    const appendText = streamDelta(args.channel, args.text);
-    const stopped = await stopChatStream({
-      botToken,
-      channel: args.channelId,
-      ts: args.ts,
-      chunks: appendText === "" ? undefined : [markdownChunk(appendText)],
-    });
-    args.channel.state.streamTs = null;
-    if (stopped.ok) {
-      args.channel.state.lastPostedText = args.text;
-      args.channel.state.lastBotMessageTs = args.ts;
-      return { ok: true };
-    }
-    if (stopped.unsupported === true) {
-      args.channel.state.streamingUnavailable = true;
-    }
-    return { ok: false, error: stopped.error };
-  };
-
-  const closeOrphan = async (channel: SlackChannel): Promise<void> => {
-    const orphanTs = activeStreamTs(channel);
-    const channelId = channel.state.streamChannelId ?? channel.state.channelId;
-    if (orphanTs === null || channelId === null || channelId === "") {
-      return;
-    }
-    await stopChatStream({ botToken, channel: channelId, ts: orphanTs });
-    channel.state.streamTs = null;
-  };
-
-  /**
-   * `msg_too_long` means the message is full: every further append would
-   * fail the same way, so appends stop until `finalize` continues the reply
-   * in a new message.
-   */
-  const noteAppendFailure = (
-    channel: SlackChannel,
-    result: { error?: string; unsupported?: boolean },
-  ): void => {
-    if (result.unsupported === true) {
-      channel.state.streamingUnavailable = true;
-    }
-    if (result.error === "msg_too_long") {
-      channel.state.streamFull = true;
-    }
-  };
-
-  /**
-   * The open stream cannot carry the rest of the reply — it is full, or the
-   * reply no longer extends what it holds. Close it as it stands so it stops
-   * spinning and post the remainder as a new thread message.
-   */
-  const continueInNewMessage = async (args: {
-    channel: SlackChannel;
-    channelId: string;
-    ts: string;
-    remainder: string;
-    reason: string;
-    sessionId: string;
-  }): Promise<boolean> => {
-    const { channel, channelId, ts, remainder, reason, sessionId } = args;
-    const log = getLog();
-    await stopChatStream({ botToken, channel: channelId, ts });
-    channel.state.streamTs = null;
-    if (remainder === "") {
-      return true;
-    }
-    if (channel.state.threadTs === null || channel.state.threadTs === "") {
-      return true;
-    }
-    try {
-      const posted = await postMessage({
-        botToken,
-        channel: channelId,
-        text: remainder,
-        threadTs: channel.state.threadTs,
-        plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
-      });
-      channel.state.lastBotMessageTs = posted.ts;
-      log.info("reply continued in a new message", {
-        reason,
-        channel: channelId,
-        stream_ts: ts,
-        session: sessionId,
-        continued_chars: remainder.length,
-      });
-      markHostedFirstVisibleReply({
-        outcome: "final_post",
-        deliverySurface: "slack",
-      });
-      return true;
-    } catch (error) {
-      log.warn("stream continuation failed", {
-        reason,
-        error: error instanceof Error ? error.message : String(error),
-        channel: channelId,
-        stream_ts: ts,
-        session: sessionId,
-      });
-      return false;
-    }
-  };
-
-  return {
-    inlineToolSteps: true,
-    open,
-
-    async append({ channel, channelId, text, sessionId }) {
-      if (channel.state.streamFull === true) {
-        return;
-      }
-      const ts = await ensureOpen({
-        channel,
-        channelId,
-        sessionId,
-        markdown_text: text,
-      });
-      if (ts === null) {
-        return;
-      }
-      const appendText = streamDelta(channel, text);
-      if (appendText === "") {
-        return;
-      }
-      const result = await appendChatStream({
-        botToken,
-        channel: channelId,
-        ts,
-        chunks: [markdownChunk(appendText)],
-      });
-      if (!result.ok) {
-        getLog().warn("appendStream failed", {
-          error: result.error,
-          channel: channelId,
-          stream_ts: ts,
-          session: sessionId,
-        });
-        noteAppendFailure(channel, result);
-        return;
-      }
-      countAppended(channel, 1);
-      channel.state.lastPostedText = text;
-      channel.state.streamBlockText = text;
-    },
-
-    async appendChunks({ channel, channelId, chunks, sessionId }) {
-      if (channel.state.streamFull === true) {
-        return false;
-      }
-      const hadStream = activeStreamTs(channel) !== null;
-      const ts = await ensureOpen({
-        channel,
-        channelId,
-        sessionId,
-        chunks,
-      });
-      if (ts === null) {
-        return false;
-      }
-      if (!hadStream) {
-        return true;
-      }
-      const result = await appendChatStream({
-        botToken,
-        channel: channelId,
-        ts,
-        chunks,
-      });
-      if (!result.ok) {
-        getLog().warn("appendStream chunks failed", {
-          error: result.error,
-          channel: channelId,
-          stream_ts: ts,
-          session: sessionId,
-          chunks: chunks.length,
-        });
-        noteAppendFailure(channel, result);
-        return false;
-      }
-      countAppended(channel, chunks.length);
-      return true;
-    },
-
-    async finalize({ channel, channelId, text, sessionId }) {
-      const log = getLog();
-      const ts = await ensureOpen({
-        channel,
-        channelId,
-        sessionId,
-        markdown_text: text,
-      });
-      if (ts === null) {
-        return { delivered: false };
-      }
-      // Measured before the stop attempt mutates stream state.
-      const remainder = streamDelta(channel, text);
-      // Nothing to append and the stream does not hold the reply: closing it
-      // here would leave the answer nowhere and report it as delivered.
-      if (rewound(channel, text)) {
-        const posted = await continueInNewMessage({
-          channel,
-          channelId,
-          ts,
-          remainder: text,
-          reason: "rewound",
-          sessionId,
-        });
-        if (posted) {
-          channel.state.lastPostedText = text;
-        }
-        return { delivered: posted };
-      }
-      const stopped =
-        channel.state.streamFull === true
-          ? { ok: false, error: "msg_too_long" }
-          : await stopWithSuffix({ channel, channelId, ts, text });
-      if (stopped.ok) {
-        log.info("reply delivered via stream", {
-          channel: channelId,
-          stream_ts: ts,
-          session: sessionId,
-          chars: text.length,
-          appends: channel.state.streamAppendedChunks ?? 0,
-        });
-        return { delivered: true };
-      }
-      if (stopped.error === "msg_too_long") {
-        await continueInNewMessage({
-          channel,
-          channelId,
-          ts,
-          remainder,
-          reason: "msg_too_long",
-          sessionId,
-        });
-        channel.state.lastPostedText = text;
-        return { delivered: true };
-      }
-      log.warn("chat.stopStream failed; falling back to postMessage", {
-        error: stopped.error,
-        channel: channelId,
-        stream_ts: ts,
-        session: sessionId,
-      });
-      const alreadyStreamed =
-        typeof channel.state.lastPostedText === "string" && channel.state.lastPostedText.length > 0;
-      return { delivered: alreadyStreamed };
-    },
-
-    async finalizeEmpty({ channel }) {
-      await closeOrphan(channel);
-    },
-
-    async cleanupOrphan({ channel }) {
-      await closeOrphan(channel);
-    },
-
-    async fail({ channel, channelId, errorText, sessionId }) {
-      const ts = await ensureOpen({
-        channel,
-        channelId,
-        sessionId,
-        markdown_text: errorText,
-      });
-      if (ts === null) {
-        return { delivered: false };
-      }
-      const stopped = await stopWithSuffix({
-        channel,
-        channelId,
-        ts,
-        text: errorText,
-      });
-      if (stopped.ok) {
-        return { delivered: true };
-      }
-      const alreadyStreamed =
-        typeof channel.state.lastPostedText === "string" && channel.state.lastPostedText.length > 0;
-      return { delivered: alreadyStreamed };
-    },
-  };
-}

package/src/channels/slack/log.ts

@@ -1,70 +0,0 @@
-/**
- * Shared logging for the Slack channel pack.
- *
- * Uses the same `(line: string) => void` contract as ServeOptions.logger.
- * Lines always start with `[agent-sdk/slack]` so Socket Mode docs and greps
- * keep working. Optional key=value fields carry correlation ids.
- */
-
-import { SLACK_LOG_PREFIX } from "../../internal/distribution.js";
-
-export type SlackLogWrite = (line: string) => void;
-
-export type SlackLogLevel = "debug" | "info" | "warn" | "error";
-
-export type SlackLogFields = Record<string, string | number | boolean | null | undefined>;
-
-export interface SlackLog {
-  /** Raw sink used by Socket Mode (already-prefixed lines ok). */
-  write: SlackLogWrite;
-  debug: (message: string, fields?: SlackLogFields) => void;
-  info: (message: string, fields?: SlackLogFields) => void;
-  warn: (message: string, fields?: SlackLogFields) => void;
-  error: (message: string, fields?: SlackLogFields) => void;
-}
-
-/** Format `key=value` pairs; omit null/undefined. */
-export function formatSlackLogFields(fields?: SlackLogFields): string {
-  if (fields === undefined) {
-    return "";
-  }
-  const parts: string[] = [];
-  for (const [key, value] of Object.entries(fields)) {
-    if (value === undefined || value === null) {
-      continue;
-    }
-    const rendered =
-      typeof value === "string" && /[\s=]/.test(value) ? JSON.stringify(value) : String(value);
-    parts.push(`${key}=${rendered}`);
-  }
-  return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
-}
-
-export function formatSlackLogLine(
-  level: SlackLogLevel,
-  message: string,
-  fields?: SlackLogFields,
-): string {
-  const levelTag = level === "info" ? "" : `${level} `;
-  return `${SLACK_LOG_PREFIX} ${levelTag}${message}${formatSlackLogFields(fields)}`;
-}
-
-export function createSlackLogger(write: SlackLogWrite = line => console.log(line)): SlackLog {
-  const emit = (level: SlackLogLevel, message: string, fields?: SlackLogFields): void => {
-    write(formatSlackLogLine(level, message, fields));
-  };
-
-  return {
-    write(line: string): void {
-      // Preserve Socket Mode messages that already include the prefix.
-      write(line.startsWith(SLACK_LOG_PREFIX) ? line : `${SLACK_LOG_PREFIX} ${line}`);
-    },
-    debug: (message, fields) => emit("debug", message, fields),
-    info: (message, fields) => emit("info", message, fields),
-    warn: (message, fields) => emit("warn", message, fields),
-    error: (message, fields) => emit("error", message, fields),
-  };
-}
-
-/** Default logger when none is injected (console). */
-export const defaultSlackLog: SlackLog = createSlackLogger();