@cursor/july 0.1.97 → 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>;
@@ -41,7 +57,7 @@ type StreamArgs = {
 /**
  * How the default handlers deliver an in-progress reply. Methods write live
  * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
- * `streamingUnavailable`) on `channel.state` directly.
+ * `streamBlockText`, `streamingUnavailable`) on `channel.state` directly.
  */
 export interface LiveDeliveryStrategy {
   readonly inlineToolSteps: boolean;
@@ -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,7 +145,9 @@ export function createStreamDeliveryStrategy(
     }
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
-    channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
+    channel.state.streamFull = false;
+    channel.state.lastPostedText = openingText;
+    channel.state.streamBlockText = openingText;
     log.info("chat.startStream ok", {
       channel: started.channel,
       stream_ts: started.ts,
@@ -167,14 +188,14 @@ export function createStreamDeliveryStrategy(
     text: string;
   }): Promise<{ ok: boolean; error?: string }> => {
     const appendText = computeStreamAppend(
-      args.channel.state.lastPostedText,
+      args.channel.state.streamBlockText,
       args.text
     );
     const stopped = await stopChatStream({
       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) {
@@ -198,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,
@@ -213,7 +300,7 @@ export function createStreamDeliveryStrategy(
         return;
       }
       const appendText = computeStreamAppend(
-        channel.state.lastPostedText,
+        channel.state.streamBlockText,
         text
       );
       if (appendText === "") {
@@ -223,7 +310,7 @@ export function createStreamDeliveryStrategy(
         botToken,
         channel: channelId,
         ts,
-        markdown_text: appendText,
+        chunks: [markdownChunk(appendText)],
       });
       if (!result.ok) {
         getLog().warn("appendStream failed", {
@@ -232,15 +319,17 @@ export function createStreamDeliveryStrategy(
           stream_ts: ts,
           session: sessionId,
         });
-        if (result.unsupported === true) {
-          channel.state.streamingUnavailable = true;
-        }
+        noteAppendFailure(channel, result);
         return;
       }
       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,
@@ -260,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;
     },
 
@@ -274,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,
@@ -289,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/progress-delivery.ts

@@ -0,0 +1,133 @@
+/**
+ * Mid-turn thread progress when `chat.startStream` is unavailable.
+ * One editable message; `setThreadStatus` stays on the caller.
+ */
+
+import type { ChannelEventContext } from "../../types.js";
+import { deleteMessage, postMessage, updateMessage } from "./api.js";
+import type { SlackLog } from "./log.js";
+import type { SlackBotToken, SlackChannelState } from "./types.js";
+
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+
+export interface ProgressDeliveryDeps {
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+}
+
+function activeProgressTs(state: SlackChannelState): string | null {
+  const ts = state.progressTs;
+  return ts == null || ts === "" ? null : ts;
+}
+
+export interface ProgressDelivery {
+  upsert(args: { channel: SlackChannel; text: string }): Promise<void>;
+  replace(args: { channel: SlackChannel; text: string }): Promise<boolean>;
+  clear(args: { channel: SlackChannel }): Promise<void>;
+}
+
+export function createProgressDelivery(
+  deps: ProgressDeliveryDeps
+): ProgressDelivery {
+  const { botToken, getLog } = deps;
+
+  const clear: ProgressDelivery["clear"] = async (args) => {
+    const state = args.channel.state;
+    const ts = activeProgressTs(state);
+    state.progressTs = null;
+    if (ts === null || state.channelId === null) {
+      return;
+    }
+    const deleted = await deleteMessage({
+      botToken,
+      channel: state.channelId,
+      ts,
+    });
+    if (!deleted.ok) {
+      getLog().warn("progress delete failed", {
+        error: deleted.error,
+        channel: state.channelId,
+        progress_ts: ts,
+      });
+    }
+  };
+
+  return {
+    async upsert(args) {
+      const state = args.channel.state;
+      if (
+        state.channelId === null ||
+        state.threadTs === null ||
+        args.text === ""
+      ) {
+        return;
+      }
+      const existing = activeProgressTs(state);
+      if (existing !== null) {
+        const updated = await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: existing,
+          text: args.text,
+        });
+        if (updated.ok) {
+          return;
+        }
+        getLog().warn("progress update failed; posting a new message", {
+          error: updated.error,
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          progress_ts: existing,
+        });
+        await clear({ channel: args.channel });
+      }
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: args.text,
+        });
+        state.progressTs = posted.ts;
+      } catch (error) {
+        getLog().warn(
+          `progress post failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          {
+            channel: state.channelId,
+            thread_ts: state.threadTs,
+          }
+        );
+      }
+    },
+
+    async replace(args) {
+      const state = args.channel.state;
+      const ts = activeProgressTs(state);
+      if (ts === null || state.channelId === null || args.text === "") {
+        return false;
+      }
+      const updated = await updateMessage({
+        botToken,
+        channel: state.channelId,
+        ts,
+        text: args.text,
+      });
+      if (!updated.ok) {
+        getLog().warn("progress replace failed", {
+          error: updated.error,
+          channel: state.channelId,
+          progress_ts: ts,
+        });
+        return false;
+      }
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = ts;
+      state.progressTs = null;
+      return true;
+    },
+
+    clear,
+  };
+}

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]");
+}