@cursor/july 0.1.99 → 0.1.100

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

@@ -8,12 +8,28 @@
  * 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 type { ChannelEventContext } from "../../types.js";
-import { appendChatStream, startChatStream, stopChatStream } from "./api.js";
+import {
+  appendChatStream,
+  postMessage,
+  startChatStream,
+  stopChatStream,
+} from "./api.js";
+import { SLACK_MARKDOWN_TEXT_MAX_LEN } from "./constants.js";
 import type { SlackLog } from "./log.js";
-import { computeStreamAppend, type StreamTaskChunk } from "./stream.js";
+import {
+  computeStreamAppend,
+  markdownChunk,
+  type StreamChunk,
+  type StreamTaskChunk,
+} from "./stream.js";
 import type { SlackBotToken, SlackChannelState } from "./types.js";
 
 type SlackChannel = ChannelEventContext<SlackChannelState>;
@@ -98,9 +114,13 @@ export function createStreamDeliveryStrategy(
     if (activeStreamTs(channel) !== null) {
       return true;
     }
-    const hasMarkdown = markdown_text !== undefined && markdown_text !== "";
-    const hasChunks = chunks !== undefined && chunks.length > 0;
-    if (!hasMarkdown && !hasChunks) {
+    const openingText = markdown_text ?? "";
+    const opening: StreamChunk[] = [];
+    if (openingText !== "") {
+      opening.push(markdownChunk(openingText));
+    }
+    opening.push(...(chunks ?? []));
+    if (opening.length === 0) {
       return false;
     }
     const log = getLog();
@@ -108,8 +128,7 @@ export function createStreamDeliveryStrategy(
       botToken,
       channel: channelId,
       thread_ts: threadTs,
-      markdown_text: hasMarkdown ? markdown_text : undefined,
-      chunks: hasChunks ? chunks : undefined,
+      chunks: opening,
       ...streamRecipients(channel),
     });
     if (!started.ok) {
@@ -126,8 +145,9 @@ export function createStreamDeliveryStrategy(
     }
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
-    channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
-    channel.state.streamBlockText = channel.state.lastPostedText;
+    channel.state.streamFull = false;
+    channel.state.lastPostedText = openingText;
+    channel.state.streamBlockText = openingText;
     log.info("chat.startStream ok", {
       channel: started.channel,
       stream_ts: started.ts,
@@ -175,7 +195,7 @@ export function createStreamDeliveryStrategy(
       botToken,
       channel: args.channelId,
       ts: args.ts,
-      markdown_text: appendText === "" ? undefined : appendText,
+      chunks: appendText === "" ? undefined : [markdownChunk(appendText)],
     });
     args.channel.state.streamTs = null;
     if (stopped.ok) {
@@ -199,11 +219,77 @@ export function createStreamDeliveryStrategy(
     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 streamed message is full. Close it as it stands so it stops spinning
+   * and post the rest as a new thread message. Most of the answer is on Slack
+   * either way, so the reply counts as delivered even if that post fails: a
+   * duplicate would be worse than a lost tail.
+   */
+  const continueOverflow = async (args: {
+    channel: SlackChannel;
+    channelId: string;
+    ts: string;
+    remainder: string;
+    sessionId: string;
+  }): Promise<void> => {
+    const { channel, channelId, ts, remainder, sessionId } = args;
+    const log = getLog();
+    await stopChatStream({ botToken, channel: channelId, ts });
+    channel.state.streamTs = null;
+    const threadTs = channel.state.threadTs;
+    if (remainder === "" || threadTs === null || threadTs === "") {
+      return;
+    }
+    try {
+      const posted = await postMessage({
+        botToken,
+        channel: channelId,
+        text: remainder,
+        threadTs,
+        plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
+      });
+      channel.state.lastBotMessageTs = posted.ts;
+      log.info("reply overflowed the stream; continued in a new message", {
+        channel: channelId,
+        stream_ts: ts,
+        session: sessionId,
+        continued_chars: remainder.length,
+      });
+    } catch (error) {
+      log.warn("stream overflow continuation failed", {
+        error: error instanceof Error ? error.message : String(error),
+        channel: channelId,
+        stream_ts: ts,
+        session: sessionId,
+      });
+    }
+  };
+
   return {
     inlineToolSteps: true,
     open,
 
     async append({ channel, channelId, text, sessionId }) {
+      if (channel.state.streamFull === true) {
+        return;
+      }
       const ts = await ensureOpen({
         channel,
         channelId,
@@ -224,7 +310,7 @@ export function createStreamDeliveryStrategy(
         botToken,
         channel: channelId,
         ts,
-        markdown_text: appendText,
+        chunks: [markdownChunk(appendText)],
       });
       if (!result.ok) {
         getLog().warn("appendStream failed", {
@@ -233,9 +319,7 @@ export function createStreamDeliveryStrategy(
           stream_ts: ts,
           session: sessionId,
         });
-        if (result.unsupported === true) {
-          channel.state.streamingUnavailable = true;
-        }
+        noteAppendFailure(channel, result);
         return;
       }
       channel.state.lastPostedText = text;
@@ -243,6 +327,9 @@ export function createStreamDeliveryStrategy(
     },
 
     async appendChunks({ channel, channelId, chunks, sessionId }) {
+      if (channel.state.streamFull === true) {
+        return false;
+      }
       const hadStream = activeStreamTs(channel) !== null;
       const ts = await ensureOpen({
         channel,
@@ -262,6 +349,16 @@ export function createStreamDeliveryStrategy(
         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 result.ok;
     },
 
@@ -276,12 +373,15 @@ export function createStreamDeliveryStrategy(
       if (ts === null) {
         return { delivered: false };
       }
-      const stopped = await stopWithSuffix({
-        channel,
-        channelId,
-        ts,
-        text,
-      });
+      // Measured before the stop attempt mutates stream state.
+      const remainder = computeStreamAppend(
+        channel.state.streamBlockText,
+        text
+      );
+      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,
@@ -291,6 +391,17 @@ export function createStreamDeliveryStrategy(
         });
         return { delivered: true };
       }
+      if (stopped.error === "msg_too_long") {
+        await continueOverflow({
+          channel,
+          channelId,
+          ts,
+          remainder,
+          sessionId,
+        });
+        channel.state.lastPostedText = text;
+        return { delivered: true };
+      }
       log.warn("chat.stopStream failed; falling back to postMessage", {
         error: stopped.error,
         channel: channelId,

package/src/channels/slack/reasoning-card.ts

@@ -0,0 +1,140 @@
+/**
+ * The "Thinking" task card that receives the model's reasoning as it streams.
+ * Slack appends a card's `details` across updates, so the card is fed
+ * deltas: the part of the current reasoning block already on Slack, plus a
+ * buffer of what has not gone out yet.
+ */
+
+import type { ChannelEventContext } from "../../types.js";
+import type { ResolvedSlackReasoningCard } from "./reply-options.js";
+import { type StreamTaskChunk, truncateCardText } from "./stream.js";
+import type { ReasoningCardState, SlackChannelState } from "./types.js";
+
+const FLUSH_MS = 1_000;
+const FLUSH_CHARS = 160;
+const CARD_ID = "reasoning";
+const BLOCK_SEPARATOR = "\n\n";
+
+type Channel = ChannelEventContext<SlackChannelState>;
+type CardStatus = "in_progress" | "complete";
+
+export interface ReasoningCard {
+  /** Buffer the current reasoning block's cumulative text; flushes when due. */
+  append(args: {
+    channel: Channel;
+    sessionId: string;
+    text: string;
+  }): Promise<void>;
+  /** Send buffered text and set the card status. */
+  flush(args: {
+    channel: Channel;
+    sessionId: string;
+    status: CardStatus;
+  }): Promise<void>;
+  /** The next reasoning block appends after a blank line. */
+  endBlock(channel: Channel): void;
+  inProgress(channel: Channel): boolean;
+}
+
+/** Delivers one chunk into the reply stream; `false` when nothing went out. */
+export type SendCardChunk = (args: {
+  channel: Channel;
+  sessionId: string;
+  chunk: StreamTaskChunk;
+}) => Promise<boolean>;
+
+function cardState(state: SlackChannelState): ReasoningCardState {
+  if (state.reasoningCard === undefined) {
+    state.reasoningCard = {
+      status: null,
+      blockSent: null,
+      pending: "",
+      lastFlushMs: null,
+      chars: 0,
+    };
+  }
+  return state.reasoningCard;
+}
+
+export function createReasoningCard(
+  card: ResolvedSlackReasoningCard,
+  send: SendCardChunk
+): ReasoningCard {
+  const flush: ReasoningCard["flush"] = async ({
+    channel,
+    sessionId,
+    status,
+  }) => {
+    const state = cardState(channel.state);
+    if (
+      state.pending === "" &&
+      (state.status === status || state.status === null)
+    ) {
+      return;
+    }
+    const chunk: StreamTaskChunk = {
+      type: "task_update",
+      id: CARD_ID,
+      title: card.title,
+      status,
+    };
+    if (state.pending !== "") {
+      chunk.details = state.pending;
+    }
+    // Stamped on the attempt, so a failing stream is retried at most once
+    // per flush window instead of once per token.
+    state.lastFlushMs = Date.now();
+    if (!(await send({ channel, sessionId, chunk }))) {
+      return;
+    }
+    state.chars += state.pending.length;
+    state.pending = "";
+    state.status = status;
+  };
+
+  return {
+    flush,
+
+    async append({ channel, sessionId, text }) {
+      const state = cardState(channel.state);
+      if (state.chars >= card.maxChars) {
+        return;
+      }
+      const sent = state.blockSent ?? 0;
+      let delta: string;
+      if (sent > 0 && text.length >= sent) {
+        delta = text.slice(sent);
+      } else {
+        const hasText = state.chars + state.pending.length > 0;
+        delta = `${hasText ? BLOCK_SEPARATOR : ""}${text}`;
+      }
+      state.blockSent = text.length;
+      if (delta === "") {
+        return;
+      }
+      let pending = `${state.pending}${delta}`;
+      const room = card.maxChars - state.chars;
+      if (pending.length > room) {
+        pending = truncateCardText(pending, room);
+        state.chars = card.maxChars - pending.length;
+      }
+      state.pending = pending;
+
+      const due =
+        state.lastFlushMs === null ||
+        Date.now() - state.lastFlushMs >= FLUSH_MS ||
+        pending.length >= FLUSH_CHARS;
+      if (due) {
+        await flush({ channel, sessionId, status: "in_progress" });
+      }
+    },
+
+    endBlock(channel) {
+      cardState(channel.state).blockSent = null;
+    },
+
+    inProgress(channel) {
+      return channel.state.reasoningCard?.status === "in_progress";
+    },
+  };
+}

package/src/channels/slack/redact.ts

@@ -0,0 +1,6 @@
+/** Credential shapes that must never reach a Slack thread verbatim. */
+const SECRET_TOKEN = /\b(crsr_|xox[baprs]-|sk-|Bearer\s+)\S+/gi;
+
+export function redactSecretTokens(text: string): string {
+  return text.replace(SECRET_TOKEN, "[redacted]");
+}

package/src/channels/slack/reply-options.ts

@@ -0,0 +1,229 @@
+/**
+ * Resolve `slackChannel({ reply, toolLabels })` — and the deprecated
+ * `streaming` / `thinkingSteps` / `loadingMessages` flags — into one config
+ * the default event handlers read.
+ */
+
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultToolCardDetails } from "./tool-cards.js";
+import type {
+  SlackChannelOptions,
+  SlackReasoningCardOptions,
+  SlackReplyOptions,
+  SlackToolCall,
+  SlackToolCardGroup,
+  SlackToolLabels,
+  SlackToolResult,
+} from "./types.js";
+
+export type SlackReplyMode = "post" | "stream";
+
+export interface ResolvedSlackStatus {
+  reasoning: boolean;
+  /** `false`, or the line to show when tool calls start. */
+  tools: false | ((calls: readonly SlackToolCall[]) => string);
+  idle: string[];
+}
+
+export interface ResolvedSlackToolCards {
+  group: SlackToolCardGroup;
+  details?: (call: SlackToolCall) => string | undefined;
+  output?: (result: SlackToolResult) => string | undefined;
+}
+
+export interface ResolvedSlackReasoningCard {
+  title: string;
+  maxChars: number;
+}
+
+export interface ResolvedSlackReply {
+  mode: SlackReplyMode;
+  status: ResolvedSlackStatus;
+  toolCards: false | ResolvedSlackToolCards;
+  reasoningCard: false | ResolvedSlackReasoningCard;
+  toolLabel: (toolName: string) => string;
+  /** Author-facing notices about deprecated options that were honored. */
+  deprecations: string[];
+}
+
+export const DEFAULT_REASONING_CARD_TITLE = "Thinking";
+/** A modest share of `SLACK_MARKDOWN_TEXT_MAX_LEN`, which the whole streamed message shares. */
+export const DEFAULT_REASONING_CARD_MAX_CHARS = 1500;
+
+type ReplyInputs = Pick<
+  SlackChannelOptions,
+  "reply" | "toolLabels" | "streaming" | "thinkingSteps"
+> & { loadingMessages?: readonly string[] };
+
+function resolveToolLabel(
+  labels: SlackToolLabels | undefined
+): (toolName: string) => string {
+  if (labels === undefined) {
+    return (toolName) => toolName;
+  }
+  const lookup =
+    typeof labels === "function" ? labels : (name: string) => labels[name];
+  return (toolName) => {
+    const label = lookup(toolName);
+    return label === undefined || label === "" ? toolName : label;
+  };
+}
+
+function defaultToolStatusLine(
+  toolLabel: (toolName: string) => string
+): (calls: readonly SlackToolCall[]) => string {
+  return (calls) => {
+    const names = [...new Set(calls.map((call) => toolLabel(call.toolName)))];
+    return `Running ${names.join(", ")}…`;
+  };
+}
+
+function resolveIdle(idle: readonly string[] | undefined): string[] {
+  const cleaned = (idle ?? []).filter((line) => line.trim() !== "");
+  return cleaned.length > 0 ? cleaned : [...SLACK_DEFAULT_LOADING_MESSAGES];
+}
+
+function resolveReasoningCard(
+  option: boolean | SlackReasoningCardOptions | undefined
+): false | ResolvedSlackReasoningCard {
+  if (option === undefined || option === false) {
+    return false;
+  }
+  const options = option === true ? {} : option;
+  const title = options.title?.trim();
+  return {
+    title:
+      title === undefined || title === ""
+        ? DEFAULT_REASONING_CARD_TITLE
+        : title,
+    maxChars:
+      options.maxChars !== undefined && options.maxChars > 0
+        ? options.maxChars
+        : DEFAULT_REASONING_CARD_MAX_CHARS,
+  };
+}
+
+function resolveToolCards(
+  option: SlackReplyOptions & { mode: "stream" }
+): false | ResolvedSlackToolCards {
+  const cards = option.toolCards;
+  if (cards === undefined || cards === false) {
+    return false;
+  }
+  if (cards === true) {
+    return { group: "per-tool", details: defaultToolCardDetails };
+  }
+  const group = cards.group ?? "per-tool";
+  if (cards.collapsible === false) {
+    return { group };
+  }
+  return {
+    group,
+    details: cards.details ?? defaultToolCardDetails,
+    output: cards.output,
+  };
+}
+
+/**
+ * Map the deprecated flags onto a `reply` shape with their old defaults
+ * (streaming on, per-call cards on), so a config that only sets these keeps
+ * behaving as it did. `null` when none of them is set.
+ */
+function legacyReplyOptions(
+  options: ReplyInputs
+): { reply: SlackReplyOptions; deprecations: string[] } | null {
+  const idle = options.loadingMessages;
+  if (
+    options.streaming === undefined &&
+    options.thinkingSteps === undefined &&
+    idle === undefined
+  ) {
+    return null;
+  }
+  const deprecations: string[] = [];
+  const mode: SlackReplyMode = options.streaming === false ? "post" : "stream";
+  // What legacy streaming showed: one title-only card per call.
+  const cards = options.thinkingSteps === false ? false : LEGACY_CARDS;
+  const replacement =
+    mode === "post"
+      ? 'reply: { mode: "post" }'
+      : cards === false
+        ? 'reply: { mode: "stream" }'
+        : 'reply: { mode: "stream", toolCards: { group: "per-call", collapsible: false } }';
+  if (idle !== undefined) {
+    deprecations.push(
+      `slackChannel({ loadingMessages }) is deprecated; use reply: { mode: "${mode}", status: { idle: [...] } }.`
+    );
+  }
+  if (options.streaming !== undefined) {
+    deprecations.push(
+      `slackChannel({ streaming: ${String(options.streaming)} }) is deprecated; use ${replacement}.`
+    );
+  }
+  if (options.thinkingSteps !== undefined) {
+    deprecations.push(
+      mode === "post"
+        ? "slackChannel({ thinkingSteps }) has no effect in post mode; remove it."
+        : `slackChannel({ thinkingSteps: ${String(options.thinkingSteps)} }) is deprecated; use ${replacement}.`
+    );
+  }
+  const status = { idle };
+  if (mode === "post") {
+    return { reply: { mode, status }, deprecations };
+  }
+  return { reply: { mode, status, toolCards: cards }, deprecations };
+}
+
+const LEGACY_CARDS = { group: "per-call", collapsible: false } as const;
+
+export function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply {
+  const deprecations: string[] = [];
+  let reply: SlackReplyOptions = { mode: "post" };
+  const legacy = legacyReplyOptions(options);
+  if (options.reply !== undefined) {
+    reply = options.reply;
+    if (legacy !== null) {
+      const ignored = (
+        ["streaming", "thinkingSteps", "loadingMessages"] as const
+      ).filter((key) => options[key] !== undefined);
+      deprecations.push(
+        `slackChannel({ ${ignored.join(", ")} }) is ignored because reply is set; remove the deprecated option${ignored.length === 1 ? "" : "s"}.`
+      );
+    }
+  } else if (legacy !== null) {
+    reply = legacy.reply;
+    deprecations.push(...legacy.deprecations);
+  }
+
+  const toolLabel = resolveToolLabel(options.toolLabels);
+  const statusInput = reply.status ?? {};
+  const status: ResolvedSlackStatus = {
+    reasoning: statusInput.reasoning !== false,
+    tools:
+      statusInput.tools === false
+        ? false
+        : typeof statusInput.tools === "function"
+          ? statusInput.tools
+          : defaultToolStatusLine(toolLabel),
+    idle: resolveIdle(statusInput.idle),
+  };
+
+  if (reply.mode === "post") {
+    return {
+      mode: "post",
+      status,
+      toolCards: false,
+      reasoningCard: false,
+      toolLabel,
+      deprecations,
+    };
+  }
+  return {
+    mode: "stream",
+    status,
+    toolCards: resolveToolCards(reply),
+    reasoningCard: resolveReasoningCard(reply.reasoningCard),
+    toolLabel,
+    deprecations,
+  };
+}

package/src/channels/slack/slack-channel.ts

@@ -57,6 +57,7 @@ import {
   dispatchInteractiveFromPayload,
 } from "./interactive.js";
 import { createSlackLogger, type SlackLog } from "./log.js";
+import { resolveSlackReply } from "./reply-options.js";
 import {
   type SlackSocketModeHandle,
   type SlackSocketModeOptions,
@@ -128,7 +129,8 @@ export function slackChannel(
   const credentials =
     options.credentials ?? credentialsFromEnv(options.envPrefix);
   const envKeys = slackEnvKeys(options.envPrefix);
-  const loadingMessages = options.loadingMessages;
+  const reply = resolveSlackReply(options);
+  const loadingMessages = reply.status.idle;
   const policy = options.policy;
   const blockExternals = resolveSlackBlockExternals(policy);
   const defaultInbound = createDefaultOnInbound(loadingMessages, policy);
@@ -174,11 +176,13 @@ export function slackChannel(
       events,
       buildDefaultEvents({
         credentials,
+        reply: options.reply,
+        toolLabels: options.toolLabels,
         streaming: options.streaming,
         thinkingSteps: options.thinkingSteps,
+        loadingMessages: options.loadingMessages,
         suggestedPrompts: options.suggestedPrompts,
         suggestedPromptsTitle: options.suggestedPromptsTitle,
-        loadingMessages,
         getLog,
       })
     );
@@ -252,6 +256,7 @@ export function slackChannel(
       ...(channelPosts === undefined
         ? {}
         : { slackChannelPosts: [...channelPosts.allow] }),
+      deprecations: reply.deprecations,
     },
     async receive(input: ReceiveInput, { send }) {
       const target = input.target ?? {};